Guia de migração semântico do Kernel para o Agent Framework

As seções a seguir resumem as principais diferenças entre o Semântico Kernel Agent Framework e o Microsoft Agent Framework para ajudá-lo a migrar seu código.

1. Atualizações de namespace

Núcleo Semântico

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;

Estrutura do Agente

Os namespaces do Agent Framework estão em Microsoft.Agents.AI. O Agent Framework usa os principais tipos de conteúdo e mensagens de IA para Microsoft.Extensions.AI comunicação entre componentes.

using Microsoft.Extensions.AI;
using Microsoft.Agents.AI;

2. Simplificação de criação de agente

Núcleo Semântico

Cada agente no Kernel Semântico depende de uma Kernel instância e tem um vazio Kernel se não for fornecido.

 Kernel kernel = Kernel
    .AddOpenAIChatClient(modelId, apiKey)
    .Build();

 ChatCompletionAgent agent = new() { Instructions = ParrotInstructions, Kernel = kernel };

O Azure AI Foundry requer que um recurso de agente seja criado na nuvem antes de criar uma classe de agente local que o use.

PersistentAgentsClient azureAgentClient = AzureAIAgent.CreateAgentsClient(azureEndpoint, new AzureCliCredential());

PersistentAgent definition = await azureAgentClient.Administration.CreateAgentAsync(
    deploymentName,
    instructions: ParrotInstructions);

AzureAIAgent agent = new(definition, azureAgentClient);

Estrutura do Agente

A criação de agente no Agent Framework é mais simples com extensões fornecidas por todos os provedores principais.

AIAgent openAIAgent = chatClient.CreateAIAgent(instructions: ParrotInstructions);
AIAgent azureFoundryAgent = await persistentAgentsClient.CreateAIAgentAsync(instructions: ParrotInstructions);
AIAgent openAIAssistantAgent = await assistantClient.CreateAIAgentAsync(instructions: ParrotInstructions);

Além disso, para provedores de agente hospedados, você também pode usar o GetAIAgent método para recuperar um agente de um agente hospedado existente.

AIAgent azureFoundryAgent = await persistentAgentsClient.GetAIAgentAsync(agentId);

3. Criação de thread do agente

Núcleo Semântico

O chamador precisa saber o tipo de thread e criá-lo manualmente.

// Create a thread for the agent conversation.
AgentThread thread = new OpenAIAssistantAgentThread(this.AssistantClient);
AgentThread thread = new AzureAIAgentThread(this.Client);
AgentThread thread = new OpenAIResponseAgentThread(this.Client);

Estrutura do Agente

O agente é responsável por criar o thread.

// New.
AgentThread thread = agent.GetNewThread();

4. Limpeza de thread do agente hospedado

Esse caso se aplica exclusivamente a alguns provedores de IA que ainda fornecem threads hospedados.

Núcleo Semântico

Os threads têm um self método de exclusão.

Provedor de Assistentes do OpenAI:

await thread.DeleteAsync();

Estrutura do Agente

O Agent Framework não tem uma API de exclusão de thread no AgentThread tipo, pois nem todos os provedores dão suporte a threads hospedados ou à exclusão de threads. Esse design se tornará mais comum à medida que mais provedores mudarem para arquiteturas baseadas em respostas.

Se você precisar de exclusão de thread e o provedor permitir, o chamador deverá acompanhar os threads criados e excluí-los posteriormente, quando necessário, por meio do SDK do provedor.

Provedor de Assistentes do OpenAI:

await assistantClient.DeleteThreadAsync(thread.ConversationId);

5. Registro de ferramenta

Núcleo Semântico

Para expor uma função como uma ferramenta, você deve:

1. Decore a função com um [KernelFunction] atributo.
2. Tenha uma Plugin classe ou use a KernelPluginFactory para encapsular a função.
3. Tenha um Kernel para adicionar o plug-in.
4. Passe o Kernel agente.

KernelFunction function = KernelFunctionFactory.CreateFromMethod(GetWeather);
KernelPlugin plugin = KernelPluginFactory.CreateFromFunctions("KernelPluginName", [function]);
Kernel kernel = ... // Create kernel
kernel.Plugins.Add(plugin);

ChatCompletionAgent agent = new() { Kernel = kernel, ... };

Estrutura do Agente

No Agent Framework, em uma única chamada, você pode registrar ferramentas diretamente no processo de criação do agente.

AIAgent agent = chatClient.CreateAIAgent(tools: [AIFunctionFactory.Create(GetWeather)]);

6. Invocação de não streaming do agente

As principais diferenças podem ser vistas nos nomes de método de Invoke para Run, tipos de retorno e parâmetros AgentRunOptions.

Núcleo Semântico

O Não Streaming usa um padrão IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> de streaming para retornar várias mensagens de agente.

await foreach (AgentResponseItem<ChatMessageContent> result in agent.InvokeAsync(userInput, thread, agentOptions))
{
    Console.WriteLine(result.Message);
}

Estrutura do Agente

O Non-Streaming retorna um único AgentRunResponse com a resposta do agente que pode conter várias mensagens. O resultado do texto da execução está disponível em AgentRunResponse.Text ou AgentRunResponse.ToString(). Todas as mensagens criadas como parte da resposta são retornadas na AgentRunResponse.Messages lista. Isso pode incluir mensagens de chamada de ferramenta, resultados de função, atualizações de raciocínio e resultados finais.

AgentRunResponse agentResponse = await agent.RunAsync(userInput, thread);

7. Invocação de Streaming do Agente

As principais diferenças estão nos nomes de método de Invoke para Run, tipos de retorno e parâmetros AgentRunOptions.

Núcleo Semântico

await foreach (StreamingChatMessageContent update in agent.InvokeStreamingAsync(userInput, thread))
{
    Console.Write(update);
}

Estrutura do Agente

O Agent Framework tem um padrão de API de streaming semelhante, com a principal diferença é que ele retorna AgentRunResponseUpdate objetos que incluem mais informações relacionadas ao agente por atualização.

Todas as atualizações produzidas por qualquer serviço subjacente ao AIAgent são retornadas. O resultado textual do agente está disponível concatenando os AgentRunResponse.Text valores.

await foreach (AgentRunResponseUpdate update in agent.RunStreamingAsync(userInput, thread))
{
    Console.Write(update); // Update is ToString() friendly
}

8. Assinaturas de função de ferramenta

Problema: os métodos de plug-in kernel semântico precisam de [KernelFunction] atributos.

public class MenuPlugin
{
    [KernelFunction] // Required.
    public static MenuItem[] GetMenu() => ...;
}

Solução: o Agent Framework pode usar métodos diretamente sem atributos.

public class MenuTools
{
    [Description("Get menu items")] // Optional description.
    public static MenuItem[] GetMenu() => ...;
}

9. Configuração de opções

Problema: configuração de opções complexas no Kernel Semântico.

OpenAIPromptExecutionSettings settings = new() { MaxTokens = 1000 };
AgentInvokeOptions options = new() { KernelArguments = new(settings) };

Solução: opções simplificadas no Agent Framework.

ChatClientAgentRunOptions options = new(new() { MaxOutputTokens = 1000 });

10. Injeção de Dependência

Núcleo Semântico

Um Kernel registro é necessário no contêiner de serviço para poder criar um agente, pois cada abstração de agente precisa ser inicializada com uma Kernel propriedade.

O Kernel Semântico usa o Agent tipo como a classe de abstração base para agentes.

services.AddKernel().AddProvider(...);
serviceContainer.AddKeyedSingleton<SemanticKernel.Agents.Agent>(
    TutorName,
    (sp, key) =>
        new ChatCompletionAgent()
        {
            // Passing the kernel is required.
            Kernel = sp.GetRequiredService<Kernel>(),
        });

Estrutura do Agente

O Agent Framework fornece o AIAgent tipo como a classe de abstração base.

services.AddKeyedSingleton<AIAgent>(() => client.CreateAIAgent(...));

11. Consolidação de tipos de agente

Núcleo Semântico

O Kernel Semântico fornece classes de agente específicas para vários serviços, por exemplo:

• ChatCompletionAgent para uso com serviços de inferência baseados em conclusão de chat.
• OpenAIAssistantAgent para uso com o serviço Assistentes openai.
• AzureAIAgent para uso com o serviço Azure AI Foundry Agents.

Estrutura do Agente

O Agent Framework dá suporte a todos os serviços mencionados por meio de um único tipo de agente. ChatClientAgent

ChatClientAgent pode ser usado para criar agentes usando qualquer serviço subjacente que forneça um SDK que implemente a IChatClient interface.

Principais diferenças

Aqui está um resumo das principais diferenças entre o Semântico Kernel Agent Framework e o Microsoft Agent Framework para ajudá-lo a migrar seu código.

1. Empacotar e importar atualizações

Núcleo Semântico

Pacotes kernel semânticos são instalados e semantic-kernel importados como semantic_kernel. O pacote também tem um número que extras você pode instalar para instalar as diferentes dependências para diferentes provedores de IA e outros recursos.

from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent

Estrutura do Agente

O pacote do Agent Framework é instalado e agent-framework importado como agent_framework. O Agent Framework é criado de forma diferente, tem um pacote agent-framework-core principal que contém a funcionalidade principal e, em seguida, há vários pacotes que dependem desse pacote principal, como agent-framework-azure-ai, agent-framework-mem0etc agent-framework-copilotstudio. Quando você executá-lo pip install agent-framework --pre , instalará o pacote principal e todos os pacotes, para que você possa começar a usar todos os recursos rapidamente. Quando você estiver pronto para reduzir o número de pacotes porque sabe o que precisa, poderá instalar apenas os pacotes necessários, portanto, se você planeja usar apenas o Azure AI Foundry e o Mem0, poderá instalar apenas esses dois pacotes: pip install agent-framework-azure-ai agent-framework-mem0 --preé agent-framework-core uma dependência para esses dois, portanto, será instalado automaticamente.

Mesmo que os pacotes sejam divididos, as importações são todas de agent_framework, ou são módulos. Portanto, por exemplo, para importar o cliente para o Azure AI Foundry, você faria:

from agent_framework.azure import AzureAIAgentClient

Muitos dos tipos mais usados são importados diretamente de agent_framework:

from agent_framework import ChatMessage, ChatAgent

2. Consolidação de tipos de agente

Núcleo Semântico

O Kernel Semântico fornece classes de agente específicas para vários serviços, por exemplo, ChatCompletionAgent, AzureAIAgent, OpenAIAssistantAgent etc. Consulte os tipos de agente no Kernel Semântico.

Estrutura do Agente

No Agent Framework, a maioria dos agentes é criada usando o ChatAgent que pode ser usado com todos os ChatClient serviços baseados, como o Azure AI Foundry, o OpenAI ChatCompletion e o OpenAI Responses. Há dois agentes adicionais: CopilotStudioAgent para uso com o Copilot Studio e A2AAgent para uso com A2A.

Todos os agentes internos são baseados no BaseAgent (from agent_framework import BaseAgent). E todos os agentes são consistentes com a AgentProtocol interface (from agent_framework import AgentProtocol).

3. Simplificação de criação de agente

Núcleo Semântico

Cada agente no Kernel Semântico depende de uma Kernel instância e terá um vazio Kernel se não for fornecido.

from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

agent = ChatCompletionAgent(
    service=OpenAIChatCompletion(),
    name="Support",
    instructions="Answer in one sentence.",
)

Estrutura do Agente

A criação de agente no Agent Framework pode ser feita de duas maneiras, diretamente:

from agent_framework.azure import AzureAIAgentClient
from agent_framework import ChatMessage, ChatAgent

agent = ChatAgent(chat_client=AzureAIAgentClient(credential=AzureCliCredential()), instructions="You are a helpful assistant")

Ou, com os métodos de conveniência fornecidos pelos clientes de chat:

from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import AzureCliCredential
agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent(instructions="You are a helpful assistant")

O método direto expõe todos os parâmetros possíveis que você pode definir para seu agente. Embora o método de conveniência tenha um subconjunto, você ainda pode passar o mesmo conjunto de parâmetros, pois ele chama o método direto internamente.

4. Criação de thread do agente

Núcleo Semântico

O chamador precisa saber o tipo de thread e criá-lo manualmente.

from semantic_kernel.agents import ChatHistoryAgentThread

thread = ChatHistoryAgentThread()

Estrutura do Agente

O agente pode ser solicitado a criar um novo thread para você.

agent = ...
thread = agent.get_new_thread()

Em seguida, um thread é criado de uma das três maneiras:

1. Se o agente tiver um thread_id conjunto (ou conversation_id algo semelhante), ele criará um thread no serviço subjacente com essa ID. Depois que um thread tiver um service_thread_id, você não poderá mais usá-lo para armazenar mensagens na memória. Isso só se aplica a agentes que têm um conceito de thread do lado do serviço. como agentes de descoberta de IA do Azure e assistentes do OpenAI.
2. Se o agente tiver um chat_message_store_factory conjunto, ele usará essa fábrica para criar um repositório de mensagens e usá-lo para criar um thread na memória. Em seguida, ele não pode mais ser usado com um agente com o store parâmetro definido como True.
3. Se nenhuma das configurações anteriores for definida, ela será considerada uninitialized e, dependendo de como ela é usada, ela se tornará um thread na memória ou um thread de serviço.

Estrutura do Agente

O Agent Framework não tem uma API de exclusão de thread no AgentThread tipo, pois nem todos os provedores dão suporte a threads hospedados ou exclusão de thread e isso se tornará mais comum à medida que mais provedores mudarem para arquiteturas baseadas em respostas.

Se você precisar de exclusão de thread e o provedor permitir isso, o chamador deverá acompanhar os threads criados e excluí-los posteriormente, quando necessário, por meio do sdk do provedor.

Provedor de Assistentes do OpenAI:

# OpenAI Assistants threads have self-deletion method in Semantic Kernel
await thread.delete_async()

5. Registro de ferramenta

Núcleo Semântico

Para expor uma função como uma ferramenta, você deve:

1. Decore a função com um @kernel_function decorador.
2. Tenha uma Plugin classe ou use a fábrica de plug-in do kernel para encapsular a função.
3. Tenha um Kernel para adicionar o plug-in.
4. Passe o Kernel agente.

from semantic_kernel.functions import kernel_function

class SpecialsPlugin:
    @kernel_function(name="specials", description="List daily specials")
    def specials(self) -> str:
        return "Clam chowder, Cobb salad, Chai tea"

agent = ChatCompletionAgent(
    service=OpenAIChatCompletion(),
    name="Host",
    instructions="Answer menu questions accurately.",
    plugins=[SpecialsPlugin()],
)

Estrutura do Agente

Em uma única chamada, você pode registrar ferramentas diretamente no processo de criação do agente. O Agent Framework não tem o conceito de um plug-in para encapsular várias funções, mas você ainda pode fazer isso se desejar.

A maneira mais simples de criar uma ferramenta é apenas criar uma função python:

def get_weather(location: str) -> str:
    """Get the weather for a given location."""
    return f"The weather in {location} is sunny."

agent = chat_client.create_agent(tools=get_weather)

Em seguida, o nome da função se tornará o nome da ferramenta e o docstring se tornará a descrição da ferramenta, você também pode adicionar uma descrição aos parâmetros:

from typing import Annotated

def get_weather(location: Annotated[str, "The location to get the weather for."]) -> str:
    """Get the weather for a given location."""
    return f"The weather in {location} is sunny."

Por fim, você pode usar o decorador para personalizar ainda mais o nome e a descrição da ferramenta:

from typing import Annotated
from agent_framework import ai_function

@ai_function(name="weather_tool", description="Retrieves weather information for any location")
def get_weather(location: Annotated[str, "The location to get the weather for."])
    """Get the weather for a given location."""
    return f"The weather in {location} is sunny."

Isso também funciona quando você cria uma classe com várias ferramentas como métodos.

Ao criar o agente, agora você pode fornecer a ferramenta de função ao agente passando-a para o tools parâmetro.

class Plugin:

    def __init__(self, initial_state: str):
        self.state: list[str] = [initial_state]

    def get_weather(self, location: Annotated[str, "The location to get the weather for."]) -> str:
        """Get the weather for a given location."""
        self.state.append(f"Requested weather for {location}. ")
        return f"The weather in {location} is sunny."

    def get_weather_details(self, location: Annotated[str, "The location to get the weather details for."]) -> str:
        """Get detailed weather for a given location."""
        self.state.append(f"Requested detailed weather for {location}. ")
        return f"The weather in {location} is sunny with a high of 25°C and a low of 15°C."

plugin = Plugin("Initial state")
agent = chat_client.create_agent(tools=[plugin.get_weather, plugin.get_weather_details])

... # use the agent

print("Plugin state:", plugin.state)

Esse mecanismo também é útil para ferramentas que precisam de entrada adicional que não pode ser fornecida pela LLM, como conexões, segredos etc.

Compatibilidade: usando o KernelFunction como ferramentas do Agent Framework

Se você tiver um código kernel semântico existente com KernelFunction instâncias (de prompts ou de métodos), poderá convertê-los em ferramentas do Agent Framework usando o .as_agent_framework_tool método.

Usando KernelFunction de um modelo de prompt

from semantic_kernel import Kernel
from semantic_kernel.functions import KernelFunctionFromPrompt
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, OpenAIChatPromptExecutionSettings
from semantic_kernel.prompt_template import KernelPromptTemplate, PromptTemplateConfig
from agent_framework.openai import OpenAIResponsesClient

# Create a kernel with services and plugins
kernel = Kernel()
# will get the api_key and model_id from the environment
kernel.add_service(OpenAIChatCompletion(service_id="default"))

# Create a function from a prompt template that uses plugin functions
function_definition = """
Today is: {{time.date}}
Current time is: {{time.time}}

Answer to the following questions using JSON syntax, including the data used.
Is it morning, afternoon, evening, or night (morning/afternoon/evening/night)?
Is it weekend time (weekend/not weekend)?
"""

prompt_template_config = PromptTemplateConfig(template=function_definition)
prompt_template = KernelPromptTemplate(prompt_template_config=prompt_template_config)

# Create a KernelFunction from the prompt
kernel_function = KernelFunctionFromPrompt(
    description="Determine the kind of day based on the current time and date.",
    plugin_name="TimePlugin",
    prompt_execution_settings=OpenAIChatPromptExecutionSettings(service_id="default", max_tokens=100),
    function_name="kind_of_day",
    prompt_template=prompt_template,
)

# Convert the KernelFunction to an Agent Framework tool
agent_tool = kernel_function.as_agent_framework_tool(kernel=kernel)

# Use the tool with an Agent Framework agent
agent = OpenAIResponsesClient(model_id="gpt-4o").create_agent(tools=agent_tool)
response = await agent.run("What kind of day is it?")
print(response.text)

Usando KernelFunction de um método

from semantic_kernel.functions import kernel_function
from agent_framework.openai import OpenAIResponsesClient

# Create a plugin class with kernel functions
@kernel_function(name="get_weather", description="Get the weather for a location")
def get_weather(self, location: str) -> str:
    return f"The weather in {location} is sunny."

# Get the KernelFunction and convert it to an Agent Framework tool
agent_tool = get_weather.as_agent_framework_tool()

# Use the tool with an Agent Framework agent
agent = OpenAIResponsesClient(model_id="gpt-4o").create_agent(tools=agent_tool)
response = await agent.run("What's the weather in Seattle?")
print(response.text)

Usando o VectorStore com create_search_function

Você também pode usar as integrações vectorStore do Kernel Semântico com o Agent Framework. O create_search_function método de uma coleção de repositório de vetores retorna um KernelFunction que pode ser convertido em uma ferramenta do Agent Framework.

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAITextEmbedding
from semantic_kernel.connectors.azure_ai_search import AzureAISearchCollection
from semantic_kernel.functions import KernelParameterMetadata
from agent_framework.openai import OpenAIResponsesClient

# Define your data model
class HotelSampleClass:
    HotelId: str
    HotelName: str
    Description: str
    # ... other fields

# Create an Azure AI Search collection
collection = AzureAISearchCollection[str, HotelSampleClass](
    record_type=HotelSampleClass,
    embedding_generator=OpenAITextEmbedding()
)

async with collection:
    await collection.ensure_collection_exists()
    # Load your records into the collection
    # await collection.upsert(records)

    # Create a search function from the collection
    search_function = collection.create_search_function(
        description="A hotel search engine, allows searching for hotels in specific cities.",
        search_type="keyword_hybrid",
        filter=lambda x: x.Address.Country == "USA",
        parameters=[
            KernelParameterMetadata(
                name="query",
                description="What to search for.",
                type="str",
                is_required=True,
                type_object=str,
            ),
            KernelParameterMetadata(
                name="city",
                description="The city that you want to search for a hotel in.",
                type="str",
                type_object=str,
            ),
            KernelParameterMetadata(
                name="top",
                description="Number of results to return.",
                type="int",
                default_value=5,
                type_object=int,
            ),
        ],
        string_mapper=lambda x: f"(hotel_id: {x.record.HotelId}) {x.record.HotelName} - {x.record.Description}",
    )

    # Convert the search function to an Agent Framework tool
    search_tool = search_function.as_agent_framework_tool()

    # Use the tool with an Agent Framework agent
    agent = OpenAIResponsesClient(model_id="gpt-4o").create_agent(
        instructions="You are a travel agent that helps people find hotels.",
        tools=search_tool
    )
    response = await agent.run("Find me a hotel in Seattle")
    print(response.text)

Esse padrão funciona com qualquer conector Semântico do Kernel VectorStore (Azure AI Search, Qdrant, Pinecone etc.), permitindo que você aproveite sua infraestrutura de pesquisa de vetor existente com agentes do Agent Framework.

Essa camada de compatibilidade permite migrar gradualmente seu código do Kernel Semântico para o Agent Framework, reutilizando suas implementações existentes KernelFunction , aproveitando os padrões simplificados de criação e execução do agente do Agent Framework.

6. Invocação de não streaming do agente

As principais diferenças podem ser vistas nos nomes de método de para invoke, tipos de run retorno (por exemplo, AgentRunResponse) e parâmetros.

Núcleo Semântico

A invocação não Streaming usa um padrão de iterador assíncrono para retornar várias mensagens de agente.

async for response in agent.invoke(
    messages=user_input,
    thread=thread,
):
    print(f"# {response.role}: {response}")
    thread = response.thread

E havia um método de conveniência para obter a resposta final:

response = await agent.get_response(messages="How do I reset my bike tire?", thread=thread)
print(f"# {response.role}: {response}")

Estrutura do Agente

A execução não Streaming retorna um único AgentRunResponse com a resposta do agente que pode conter várias mensagens. O resultado do texto da execução está disponível em response.text ou str(response). Todas as mensagens criadas como parte da resposta são retornadas na response.messages lista. Isso pode incluir mensagens de chamada de ferramenta, resultados da função, atualizações de raciocínio e resultados finais.

agent = ...

response = await agent.run(user_input, thread)
print("Agent response:", response.text)

7. Invocação de Streaming do Agente

Principais diferenças nos nomes de método de para invoke, tipos de run_stream retorno (AgentRunResponseUpdate) e parâmetros.

Núcleo Semântico

async for update in agent.invoke_stream(
    messages="Draft a 2 sentence blurb.",
    thread=thread,
):
    if update.message:
        print(update.message.content, end="", flush=True)

Estrutura do Agente

Padrão de API de streaming semelhante com a principal diferença é que ele retorna AgentRunResponseUpdate objetos, incluindo mais informações relacionadas ao agente por atualização.

Todo o conteúdo produzido por qualquer serviço subjacente ao Agente é retornado. O resultado final do agente está disponível combinando os update valores em uma única resposta.

from agent_framework import AgentRunResponse
agent = ...
updates = []
async for update in agent.run_stream(user_input, thread):
    updates.append(update)
    print(update.text)

full_response = AgentRunResponse.from_agent_run_response_updates(updates)
print("Full agent response:", full_response.text)

Você pode até mesmo fazer isso diretamente:

from agent_framework import AgentRunResponse
agent = ...
full_response = AgentRunResponse.from_agent_response_generator(agent.run_stream(user_input, thread))
print("Full agent response:", full_response.text)

8. Configuração de opções

Problema: configuração de opções complexas no Kernel Semântico

from semantic_kernel.connectors.ai.open_ai import OpenAIPromptExecutionSettings

settings = OpenAIPromptExecutionSettings(max_tokens=1000)
arguments = KernelArguments(settings)

response = await agent.get_response(user_input, thread=thread, arguments=arguments)

Solução: opções simplificadas no Agent Framework

O Agent Framework permite a passagem de todos os parâmetros diretamente para os métodos relevantes, para que você não precise importar nada extra ou criar objetos de opções, a menos que você queira. Internamente, ele usa um ChatOptions objeto para ChatClients e ChatAgentspara o qual você também pode criar e passar se desejar. Isso também é criado para ChatAgent manter as opções e pode ser substituído por chamada.

agent = ...

response = await agent.run(user_input, thread, max_tokens=1000, frequency_penalty=0.5)