Guia de Migração do Kernel Semântico para o Agent Framework

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

1. Atualizações de namespace

Kernel 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 a mensagem principal da IA e os tipos de conteúdo para Microsoft.Extensions.AI comunicação entre componentes.

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

2. Simplificação da criação de agentes

Kernel Semântico

Cada agente no Semantic Kernel 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 agentes no Agent Framework é simplificada com extensões fornecidas por todos os principais provedores.

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 threads de agente

Kernel Semântico

O chamador tem que 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 pela criação do thread.

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

4. Limpeza de threads do agente hospedado

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

Kernel Semântico

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

Provedor de assistentes OpenAI:

await thread.DeleteAsync();

Estrutura do agente

O Agent Framework não tem uma API de exclusão de thread no tipo, AgentThread pois nem todos os provedores oferecem suporte a threads hospedados ou exclusão de thread. 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 deve acompanhar os threads criados e excluí-los mais tarde, quando necessário, por meio do SDK do provedor.

Provedor de assistentes OpenAI:

await assistantClient.DeleteThreadAsync(thread.ConversationId);

5. Registo da ferramenta

Kernel Semântico

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

1. Decore a função com um [KernelFunction] atributo.
2. Tenha uma Plugin classe ou use o KernelPluginFactory para encapsular a função.
3. Tem um Kernel para adicionar o seu plugin para.
4. Passe o Kernel para o 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 sem streaming do agente

As principais diferenças podem ser vistas nos nomes dos métodos de paraInvoke, tipos de Run retorno e parâmetrosAgentRunOptions.

Kernel Semântico

O Non-Streaming usa um padrão IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> de streaming para retornar várias mensagens do 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ções, 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 dos métodos de paraInvoke, tipos de Run retorno e parâmetrosAgentRunOptions.

Kernel 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 sendo 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 devolvidas. O resultado textual do agente está disponível pela concatenação dos AgentRunResponse.Text valores.

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

8. Assinaturas de função da ferramenta

Problema: Os métodos de plug-in do 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

Kernel 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.

Semantic Kernel 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 do tipo de agente

Kernel 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 OpenAI Assistants.
• AzureAIAgent para uso com o serviço Azure AI Foundry Agents.

Estrutura do agente

O Agent Framework suporta todos os serviços mencionados através 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.

Diferenças principais

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

1. Atualizações de pacote e importação

Kernel Semântico

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

from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent

Estrutura do agente

O pacote do Agent Framework é instalado como agent-framework e importado como agent_framework. O Agent Framework é construído de forma diferente, ele 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-mem0, agent-framework-copilotstudio, etc. Quando você executar pip install agent-framework --pre , ele instalará o pacote principal e todos os pacotes, para que você possa começar com todos os recursos rapidamente. Quando estiver pronto para reduzir o número de pacotes porque sabe do que precisa, pode instalar apenas os pacotes de que necessita, por exemplo, se planeia utilizar apenas o Azure AI Foundry e o Mem0, pode instalar apenas esses dois pacotes: pip install agent-framework-azure-ai agent-framework-mem0 --pre, agent-framework-core é uma dependência desses dois, pelo que será instalado automaticamente.

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

from agent_framework.azure import AzureAIAgentClient

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

from agent_framework import ChatMessage, ChatAgent

2. Consolidação do tipo de agente

Kernel Semântico

O Kernel Semântico fornece classes de agente específicas para vários serviços, por exemplo, ChatCompletionAgent, AzureAIAgent, OpenAIAssistantAgent, etc. Consulte 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 Azure AI Foundry, OpenAI ChatCompletion e OpenAI Responses. Existem 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 da criação de agentes

Kernel Semântico

Cada agente no Semantic Kernel 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 agentes 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 direct 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, porque ele chama o método direto internamente.

4. Criação de threads de agente

Kernel Semântico

O chamador tem que 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()

Um thread é então 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. Quando um thread tem um service_thread_id, você não pode 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 os Agentes de Fundição de IA do Azure e os Assistentes OpenAI.
2. Se o agente tiver um chat_message_store_factory conjunto, ele usará essa fábrica para criar um armazenamento de mensagens e usá-lo para criar um thread na memória. 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 for 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 tipo, AgentThread pois nem todos os provedores suportam 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 deve acompanhar os threads criados e excluí-los mais tarde, quando necessário, através do sdk do provedor.

Provedor de assistentes OpenAI:

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

5. Registo da ferramenta

Kernel Semântico

Para expor uma função como 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-ins do kernel para envolver a função.
3. Tem um Kernel para adicionar o seu plugin para.
4. Passe o Kernel para o 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 plugin para envolver 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)

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."

Finalmente, 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 para o 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 informações adicionais que não podem ser fornecidas pelo LLM, como conexões, segredos, etc.

Compatibilidade: Usando KernelFunction como ferramentas do Agent Framework

Se você tiver código existente do Kernel Semântico 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 a partir 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 a partir 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 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 armazenamento 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 VectorStore do Kernel Semântico (Azure AI Search, Qdrant, Pinecone, etc.), permitindo que você aproveite sua infraestrutura de pesquisa vetorial existente com agentes do Agent Framework.

Essa camada de compatibilidade permite que você migre gradualmente seu código do Semantic Kernel para o Agent Framework, reutilizando suas implementações existentes KernelFunction enquanto aproveita os padrões simplificados de criação e execução de agentes do Agent Framework.

6. Invocação sem streaming do agente

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

Kernel Semântico

A invocação Non-Streaming usa um padrão de iterador assíncrono para retornar várias mensagens do 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 Non-Streaming retorna uma única 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 de funções, 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.

Kernel 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 sendo que ele retorna AgentRunResponseUpdate objetos, incluindo mais informações relacionadas ao agente por atualização.

Todos os conteúdos produzidos por qualquer serviço subjacente ao Agente são devolvidos. O resultado final do agente está disponível através da combinação dos update valores numa ú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 queira. Internamente, ele usa um ChatOptions objeto para ChatClients e ChatAgents, que você também pode criar e passar se quiser. Isso também é criado em um ChatAgent para 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)