Compartilhar via

Biblioteca de clientes do Azure AI Agents para JavaScript – versão 1.1.0

Use a biblioteca de cliente do AI Agents para:

  • Desenvolver Agentes usando o Serviço do Agente de IA do Azure, aproveitando um amplo ecossistema de modelos, ferramentas e funcionalidades do OpenAI, microsoft e outros provedores llm. O Serviço do Agente de IA do Azure permite a criação de Agentes para uma ampla gama de casos de uso de IA generativos.
  • Nota: Embora esse pacote possa ser usado de forma independente, recomendamos usar a biblioteca de clientes do Azure AI Projects para uma experiência aprimorada. A biblioteca de projetos fornece acesso simplificado a funcionalidades avançadas, como criar e gerenciar agentes, enumerar modelos de IA, trabalhar com conjuntos de dados e gerenciar índices de pesquisa, avaliar o desempenho de IA generativa e habilitar o rastreamento do OpenTelemetry.

Documentação do | produtoAmostras | Pacote (npm) | Documentação de referência da API

Sumário

Como começar

Pré-requisito

Autorização

  • O ID do Entra é necessário para autenticar o cliente. Seu aplicativo precisa de um objeto que implemente a interface TokenCredential. Exemplos de código aqui usam DefaultAzureCredential. Para que isso funcione, você precisará de:
    • A função Contributor. A função atribuída pode ser feita por meio da guia "Controle de Acesso (IAM)" do recurso do Projeto de IA do Azure no portal do Azure. Saiba mais sobre atribuições de função aqui.
    • CLI do Azure instalada.
    • Você está conectado à sua conta do Azure executando az login.
    • Observe que, se você tiver várias assinaturas do Azure, a assinatura que contém o recurso do Projeto de IA do Azure deverá ser sua assinatura padrão. Execute az account list --output table para listar toda a sua assinatura e ver qual é o padrão. Execute az account set --subscription "Your Subscription ID or Name" para alterar sua assinatura padrão.

Instalar o pacote

npm install @azure/ai-agents @azure/identity

Conceitos principais

Criar e autenticar o cliente

O AgentsClient é usado para construir o cliente. Atualmente, recomendamos que você use o AgentsClient por meio da Biblioteca de Clientes de Projetos de IA do Azure usando client.agents.

Para obter o ponto de extremidade do projeto, você pode consultar a documentação. Abaixo, assumiremos que a variável PROJECT_ENDPOINT de ambiente contém esse valor.

import { AgentsClient } from "@azure/ai-agents";
import { DefaultAzureCredential } from "@azure/identity";

const projectEndpoint = process.env["PROJECT_ENDPOINT"] || "<project endpoint>";
const modelDeploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || "gpt-4o";
const client = new AgentsClient(projectEndpoint, new DefaultAzureCredential());

Exemplos

Agentes

Os agentes na biblioteca de clientes de Projetos de IA do Azure foram projetados para facilitar várias interações e operações em seus projetos de IA. Eles servem como componentes principais que gerenciam e executam tarefas, aproveitando diferentes ferramentas e recursos para atingir metas específicas. As etapas a seguir descrevem a sequência típica para interagir com agentes. Consulte as amostras de pacote para obter amostras adicionais do Agente.

Criar Agente

Aqui está um exemplo de como criar um Agente:

const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful assistant",
});

Para permitir que os Agentes acessem seus recursos ou funções personalizadas, você precisa de ferramentas. Você pode passar ferramentas para createAgent pelos argumentos tools e toolResources.

Você pode usar ToolSet para fazer isso:

import { ToolSet } from "@azure/ai-agents";

// Upload file for code interpreter tool
const filePath1 = "./data/syntheticCompanyQuarterlyResults.csv";
const fileStream1 = fs.createReadStream(filePath1);
const codeInterpreterFile = await client.files.upload(fileStream1, "assistants", {
  fileName: "myLocalFile",
});
console.log(`Uploaded local file, file ID : ${codeInterpreterFile.id}`);
// Upload file for file search tool
const filePath2 = "./data/sampleFileForUpload.txt";
const fileStream2 = fs.createReadStream(filePath2);
const fileSearchFile = await client.files.upload(fileStream2, "assistants", {
  fileName: "sampleFileForUpload.txt",
});
console.log(`Uploaded file, file ID: ${fileSearchFile.id}`);
// Create vector store for file search tool
const vectorStore = await client.vectorStores
  .createAndPoll({
    fileIds: [fileSearchFile.id],
  })
  .pollUntilDone();
// Create tool set
const toolSet = new ToolSet();
toolSet.addFileSearchTool([vectorStore.id]);
toolSet.addCodeInterpreterTool([codeInterpreterFile.id]);

// Create agent with tool set
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful agent",
  tools: toolSet.toolDefinitions,
  toolResources: toolSet.toolResources,
});
console.log(`Created agent, agent ID: ${agent.id}`);

Vários agentes

Você pode criar vários agentes com ferramentas diferentes e conectá-los.

import { ToolUtility } from "@azure/ai-agents";

const connectedAgentName = "stock_price_bot";
const modelDeploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || "gpt-4o";
const stockAgent = await client.createAgent(modelDeploymentName, {
  name: "stock-price-agent",
  instructions:
    "Your job is to get the stock price of a company. If you don't know the realtime stock price, return the last known stock price.",
});
// Initialize Connected Agent tool with the agent id, name, and description
const connectedAgentTool = ToolUtility.createConnectedAgentTool(
  stockAgent.id,
  connectedAgentName,
  "Gets the stock price of a company",
);
// Create agent with the Connected Agent tool and process assistant run
const agent = await client.createAgent(modelDeploymentName, {
  name: "my-agent",
  instructions: "You are a helpful assistant, and use the connected agent to get stock prices.",
  tools: [connectedAgentTool.definition],
});
console.log(`Created agent, agent ID: ${agent.id}`);

Para executar a pesquisa de arquivos por um Agente, primeiro precisamos carregar um arquivo, criar um repositório de vetores e associar o arquivo ao repositório de vetores. Este é um exemplo:

import { ToolUtility } from "@azure/ai-agents";

const filePath = "./data/sampleFileForUpload.txt";
const localFileStream = fs.createReadStream(filePath);
const file = await client.files.upload(localFileStream, "assistants", {
  fileName: "sampleFileForUpload.txt",
});
console.log(`Uploaded file, file ID: ${file.id}`);

const vectorStore = await client.vectorStores.create({
  fileIds: [file.id],
  name: "myVectorStore",
});
console.log(`Created vector store, vector store ID: ${vectorStore.id}`);

const fileSearchTool = ToolUtility.createFileSearchTool([vectorStore.id]);

const agent = await client.createAgent("gpt-4o", {
  name: "File Search Agent",
  instructions: "You are helpful agent that can help fetch data from files you know about.",
  tools: [fileSearchTool.definition],
  toolResources: fileSearchTool.resources,
});
console.log(`Created agent, agent ID : ${agent.id}`);

Criar agente com interpretador de código

Aqui está um exemplo para carregar um arquivo e usá-lo para interpretador de código por um Agente:

import { ToolUtility } from "@azure/ai-agents";

const filePath = "./data/syntheticCompanyQuarterlyResults.csv";
const localFileStream = fs.createReadStream(filePath);
const localFile = await client.files.upload(localFileStream, "assistants", {
  fileName: "localFile",
});

console.log(`Uploaded local file, file ID : ${localFile.id}`);

const codeInterpreterTool = ToolUtility.createCodeInterpreterTool([localFile.id]);

// Notice that CodeInterpreter must be enabled in the agent creation, otherwise the agent will not be able to see the file attachment
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful agent",
  tools: [codeInterpreterTool.definition],
  toolResources: codeInterpreterTool.resources,
});
console.log(`Created agent, agent ID: ${agent.id}`);

Criar agente com aterramento do Bing

Para permitir que o Agente execute a pesquisa por meio da API de pesquisa do Bing, você usa ToolUtility.createBingGroundingTool() junto com uma conexão. Veja aqui para saber mais sobre o aterramento com a Pesquisa do Bing.

Este é um exemplo:

import { ToolUtility } from "@azure/ai-agents";

const connectionId = process.env["AZURE_BING_CONNECTION_ID"] || "<connection-name>";

// Initialize agent bing tool with the connection id
const bingTool = ToolUtility.createBingGroundingTool([{ connectionId: connectionId }]);

// Create agent with the bing tool and process assistant run
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful agent",
  tools: [bingTool.definition],
});
console.log(`Created agent, agent ID : ${agent.id}`);

O Azure AI Search é um sistema de pesquisa empresarial para aplicativos de alto desempenho. Ele se integra ao Serviço OpenAI do Azure e ao Azure Machine Learning, oferecendo tecnologias avançadas de pesquisa, como pesquisa de vetor e pesquisa de texto completo. Ideal para insights da base de dados de conhecimento, descoberta de informações e automação

Aqui está um exemplo para integrar o Azure AI Search:

import { ToolUtility } from "@azure/ai-agents";

const connectionName = process.env["AZURE_AI_SEARCH_CONNECTION_NAME"] || "<connection-name>";

// Initialize Azure AI Search tool
const azureAISearchTool = ToolUtility.createAzureAISearchTool(connectionName, "search-index", {
  queryType: "simple",
  topK: 3,
  filter: "", // Add string here to filter results
  indexConnectionId: connectionName,
  indexName: "search-index",
});

// Create agent with the Azure AI search tool
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful agent",
  tools: [azureAISearchTool.definition],
  toolResources: azureAISearchTool.resources,
});
console.log(`Created agent, agent ID : ${agent.id}`);

Criar agente com chamada de função

Você pode aprimorar seus Agentes definindo funções de retorno de chamada como ferramentas de função. Eles podem ser fornecidos para createAgent por meio da combinação de tools e toolResources. Somente as definições e descrições de função são fornecidas para createAgent, sem as implementações. O Run ou event handler of stream gerará um status de requires_action com base nas definições de função. Seu código deve lidar com esse status e chamar as funções apropriadas.

Este é um exemplo:

import {
  FunctionToolDefinition,
  ToolUtility,
  RequiredToolCall,
  ToolOutput,
} from "@azure/ai-agents";

class FunctionToolExecutor {
  private functionTools: {
    func: Function;
    definition: FunctionToolDefinition;
  }[];

  constructor() {
    this.functionTools = [
      {
        func: this.getUserFavoriteCity,
        ...ToolUtility.createFunctionTool({
          name: "getUserFavoriteCity",
          description: "Gets the user's favorite city.",
          parameters: {},
        }),
      },
      {
        func: this.getCityNickname,
        ...ToolUtility.createFunctionTool({
          name: "getCityNickname",
          description: "Gets the nickname of a city, e.g. 'LA' for 'Los Angeles, CA'.",
          parameters: {
            type: "object",
            properties: {
              location: { type: "string", description: "The city and state, e.g. Seattle, Wa" },
            },
          },
        }),
      },
      {
        func: this.getWeather,
        ...ToolUtility.createFunctionTool({
          name: "getWeather",
          description: "Gets the weather for a location.",
          parameters: {
            type: "object",
            properties: {
              location: { type: "string", description: "The city and state, e.g. Seattle, Wa" },
              unit: { type: "string", enum: ["c", "f"] },
            },
          },
        }),
      },
    ];
  }

  private getUserFavoriteCity(): {} {
    return { location: "Seattle, WA" };
  }

  private getCityNickname(_location: string): {} {
    return { nickname: "The Emerald City" };
  }

  private getWeather(_location: string, unit: string): {} {
    return { weather: unit === "f" ? "72f" : "22c" };
  }

  public invokeTool(toolCall: RequiredToolCall & FunctionToolDefinition): ToolOutput | undefined {
    console.log(`Function tool call - ${toolCall.function.name}`);
    const args: any[] = [];
    if (toolCall.function.parameters) {
      try {
        const params = JSON.parse(toolCall.function.parameters);
        for (const key in params) {
          if (Object.prototype.hasOwnProperty.call(params, key)) {
            args.push(params[key]);
          }
        }
      } catch (error) {
        console.error(`Failed to parse parameters: ${toolCall.function.parameters}`, error);
        return undefined;
      }
    }
    // Create a mapping of function names to their implementations
    const functionMap = new Map(
      this.functionTools.map((tool) => [tool.definition.function.name, tool.func]),
    );
    const result = functionMap.get(toolCall.function.name)?.(...args);
    return result
      ? {
          toolCallId: toolCall.id,
          output: JSON.stringify(result),
        }
      : {
          toolCallId: toolCall.id,
          output: JSON.stringify({
            error: `No matching tool found for function: ${toolCall.function.name}`,
          }),
        };
  }

  public getFunctionDefinitions(): FunctionToolDefinition[] {
    return this.functionTools.map((tool) => {
      return tool.definition;
    });
  }
}
const functionToolExecutor = new FunctionToolExecutor();
const functionTools = functionToolExecutor.getFunctionDefinitions();
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions:
    "You are a weather bot. Use the provided functions to help answer questions. Customize your responses to the user's preferences as much as possible and use friendly nicknames for cities whenever possible.",
  tools: functionTools,
});
console.log(`Created agent, agent ID: ${agent.id}`);

Criar agente com OpenAPI

As especificações do OpenAPI descrevem as operações REST em relação a um ponto de extremidade específico. O SDK de agentes pode ler uma especificação OpenAPI, criar uma função a partir dela e chamar essa função no ponto de extremidade REST sem execução adicional do lado do cliente. Aqui está um exemplo de criação de uma ferramenta OpenAPI (usando autenticação anônima):

import { ToolUtility } from "@azure/ai-agents";

// Read in OpenApi spec
const filePath = "./data/weatherOpenApi.json";
const openApiSpec = JSON.parse(fs.readFileSync(filePath, "utf-8"));

// Define OpenApi function
const openApiFunction = {
  name: "getWeather",
  spec: openApiSpec,
  description: "Retrieve weather information for a location",
  auth: {
    type: "anonymous",
  },
  default_params: ["format"], // optional
};

// Create OpenApi tool
const openApiTool = ToolUtility.createOpenApiTool(openApiFunction);

// Create agent with OpenApi tool
const agent = await client.createAgent("gpt-4o", {
  name: "myAgent",
  instructions: "You are a helpful agent",
  tools: [openApiTool.definition],
});
console.log(`Created agent, agent ID: ${agent.id}`);

Criar Thread

Para cada sessão ou conversa, um thread é necessário. Este é um exemplo:

const thread = await client.threads.create();
console.log(`Created thread, thread ID: ${thread.id}`);

Criar thread com recurso de ferramenta

Em alguns cenários, talvez seja necessário atribuir recursos específicos a threads individuais. Para conseguir isso, forneça o argumento toolResources para threads.create. No exemplo a seguir, você cria um repositório de vetores e carrega um arquivo, habilita um Agente para pesquisa de arquivos usando o argumento tools e associa o arquivo ao thread usando o argumento toolResources.

import { ToolUtility } from "@azure/ai-agents";

const filePath = "./data/syntheticCompanyQuarterlyResults.csv";
const localFileStream = fs.createReadStream(filePath);
const file = await client.files.upload(localFileStream, "assistants", {
  fileName: "sample_file_for_upload.csv",
});
console.log(`Uploaded file, ID: ${file.id}`);

const vectorStore = await client.agents.vectorStores.create()({
  fileIds: [file.id],
});
console.log(`Created vector store, ID: ${vectorStore.id}`);

const fileSearchTool = ToolUtility.createFileSearchTool([vectorStore.id]);

const agent = await client.agents.createAgent("gpt-4o", {
  name: "myAgent",
  instructions: "You are helpful agent that can help fetch data from files you know about.",
  tools: [fileSearchTool.definition],
});
console.log(`Created agent, agent ID : ${agent.id}`);

// Create thread with file resources.
// If the agent has multiple threads, only this thread can search this file.
const thread = await client.threads.create({ toolResources: fileSearchTool.resources });

Listar Threads

Para listar todos os threads anexados a um determinado agente, use threads.list:

const threads = client.threads.list();
console.log(`Threads for agent ${agent.id}:`);
for await (const t of threads) {
  console.log(`Thread ID: ${t.id}`);
  console.log(`Created at: ${t.createdAt}`);
  console.log(`Metadata: ${t.metadata}`);
  console.log(`---- `);
}

Criar mensagem

Para criar uma mensagem para o assistente processar, você passa user como role e uma pergunta como content:

const message = await client.messages.create(thread.id, "user", "hello, world!");
console.log(`Created message, message ID: ${message.id}`);

Criar mensagem com anexo de pesquisa de arquivo

Para anexar um arquivo a uma mensagem de pesquisa de conteúdo, use ToolUtility.createFileSearchTool() e o argumento attachments:

import { ToolUtility } from "@azure/ai-agents";

const fileSearchTool = ToolUtility.createFileSearchTool();
const message = await client.messages.create(
  thread.id,
  "user",
  "What feature does Smart Eyewear offer?",
  {
    attachments: [
      {
        fileId: file.id,
        tools: [fileSearchTool.definition],
      },
    ],
  },
);

Criar mensagem com anexo do interpretador de código

Para anexar um arquivo a uma mensagem para análise de dados, use ToolUtility.createCodeInterpreterTool() e o argumento attachment.

Este é um exemplo:

import { ToolUtility } from "@azure/ai-agents";

// notice that CodeInterpreter must be enabled in the agent creation,
// otherwise the agent will not be able to see the file attachment for code interpretation
const codeInterpreterTool = ToolUtility.createCodeInterpreterTool();
const agent = await client.agents.createAgent("gpt-4o", {
  name: "my-assistant",
  instructions: "You are helpful assistant",
  tools: [codeInterpreterTool.definition],
});
console.log(`Created agent, agent ID: ${agent.id}`);

const thread = await client.threads.create();
console.log(`Created thread, thread ID: ${thread.id}`);

const message = await client.messages.create(
  thread.id,
  "user",
  "Could you please create a bar chart in the TRANSPORTATION sector for the operating profit from the uploaded CSV file and provide the file to me?",
  {
    attachments: [
      {
        fileId: file.id,
        tools: [codeInterpreterTool.definition],
      },
    ],
  },
);
console.log(`Created message, message ID: ${message.id}`);

Criar mensagem com entradas de imagem

Você pode enviar mensagens para agentes do Azure com entradas de imagem das seguintes maneiras:

  • Usando uma imagem armazenada como um arquivo carregado
  • Usando uma imagem pública acessível via URL
  • Usando uma cadeia de caracteres de imagem codificada em base64

O exemplo a seguir demonstra o método base64:

Criar mensagem com entrada de imagem codificada em base64
function imageToBase64DataUrl(imagePath: string, mimeType: string): string {
  try {
    // Read the image file as binary
    const imageBuffer = fs.readFileSync(imagePath);
    // Convert to base64
    const base64Data = imageBuffer.toString("base64");
    // Format as a data URL
    return `data:${mimeType};base64,${base64Data}`;
  } catch (error) {
    console.error(`Error reading image file at ${imagePath}:`, error);
    throw error;
  }
}

// Convert your image file to base64 format
const filePath = "./data/image_file.png";
const imageDataUrl = imageToBase64DataUrl(filePath, "image/png");

// Create a message with both text and image content
console.log("Creating message with image content...");
const inputMessage = "Hello, what is in the image?";
const content = [
  {
    type: "text",
    text: inputMessage,
  },
  {
    type: "image_url",
    imageUrl: {
      url: imageDataUrl,
      detail: "high",
    },
  },
];

const message = await client.messages.create(thread.id, "user", content);
console.log(`Created message, message ID: ${message.id}`);

Criar Execução, Run_and_Process ou Stream

Aqui está um exemplo de runs.create e sondagem até que a execução seja concluída:

// Create and poll a run
console.log("Creating run...");
const run = await client.runs.createAndPoll(thread.id, agent.id, {
  pollingOptions: {
    intervalInMs: 2000,
  },
  onResponse: (response): void => {
    console.log(`Received response with status: ${response.parsedBody.status}`);
  },
});
console.log(`Run finished with status: ${run.status}`);

Para ter a pesquisa do SDK em seu nome, use o método createThreadAndRun.

Este é um exemplo:

const run = await client.runs.createThreadAndRun(agent.id, {
  thread: {
    messages: [
      {
        role: "user",
        content: "hello, world!",
      },
    ],
  },
});

Com o streaming, a sondagem também não precisa ser considerada.

Este é um exemplo:

const streamEventMessages = await client.runs.create(thread.id, agent.id).stream();

O tratamento de eventos pode ser feito da seguinte maneira:

import { RunStreamEvent, MessageStreamEvent, ErrorEvent, DoneEvent } from "@azure/ai-agents";

const streamEventMessages = await client.runs.create(thread.id, agent.id).stream();

for await (const eventMessage of streamEventMessages) {
  switch (eventMessage.event) {
    case RunStreamEvent.ThreadRunCreated:
      console.log(`ThreadRun status: ${eventMessage.data.status}`);
      break;
    case MessageStreamEvent.ThreadMessageDelta:
      {
        const messageDelta = eventMessage.data;
        messageDelta.delta.content.forEach((contentPart) => {
          if (contentPart.type === "text") {
            const textContent = contentPart;
            const textValue = textContent.text?.value || "No text";
            console.log(`Text delta received:: ${textValue}`);
          }
        });
      }
      break;
    case RunStreamEvent.ThreadRunCompleted:
      console.log("Thread Run Completed");
      break;
    case ErrorEvent.Error:
      console.log(`An error occurred. Data ${eventMessage.data}`);
      break;
    case DoneEvent.Done:
      console.log("Stream completed.");
      break;
  }
}

Recuperar Mensagem

Para recuperar mensagens de agentes, use o seguinte exemplo:

const messagesIterator = client.messages.list(thread.id);
const allMessages = [];
for await (const m of messagesIterator) {
  allMessages.push(m);
}
console.log("Messages:", allMessages);

// The messages are following in the reverse order,
// we will iterate them and output only text contents.
const messages = await client.messages.list(thread.id, {
  order: "asc",
});

for await (const dataPoint of messages) {
  const textContent = dataPoint.content.find((item) => item.type === "text");
  if (textContent && "text" in textContent) {
    console.log(`${dataPoint.role}: ${textContent.text.value}`);
  }
}

Recuperar Arquivo

Os arquivos carregados pelos Agentes não podem ser recuperados novamente. Se o caso de uso precisar acessar o conteúdo do arquivo carregado pelos Agentes, você será aconselhado a manter uma cópia adicional acessível pelo aplicativo. No entanto, os arquivos gerados pelos Agentes são recuperáveis por files.getContent.

Aqui está um exemplo de recuperação de IDs de arquivo de mensagens:

import { isOutputOfType, MessageTextContent, MessageImageFileContent } from "@azure/ai-agents";

const messagesIterator = client.messages.list(thread.id);
const allMessages = [];
for await (const m of messagesIterator) {
  allMessages.push(m);
}
console.log("Messages:", allMessages);

// Get most recent message from the assistant
const assistantMessage = allMessages.find((msg) => msg.role === "assistant");
if (assistantMessage) {
  const textContent = assistantMessage.content.find((content) =>
    isOutputOfType<MessageTextContent>(content, "text"),
  ) as MessageTextContent;
  if (textContent) {
    console.log(`Last message: ${textContent.text.value}`);
  }
}

const imageFile = (allMessages[0].content[0] as MessageImageFileContent).imageFile;
const imageFileName = (await client.agents.files.get(imageFile.fileId)).filename;

const fileContent = await (await client.files.getContent(imageFile.fileId).asNodeStream()).body;
if (fileContent) {
  const chunks: Buffer[] = [];
  for await (const chunk of fileContent) {
    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
  }
  const buffer = Buffer.concat(chunks);
  fs.writeFileSync(imageFileName, buffer);
} else {
  console.error("Failed to retrieve file content: fileContent is undefined");
}
console.log(`Saved image file to: ${imageFileName}`);

Subdivisão

Para remover recursos após a conclusão das tarefas, use as seguintes funções:

await client.vectorStores.delete(vectorStore.id);
console.log(`Deleted vector store, vector store ID: ${vectorStore.id}`);

await client.files.delete(file.id);
console.log(`Deleted file, file ID : ${file.id}`);

await client.deleteAgent(agent.id);
console.log(`Deleted agent, agent ID: ${agent.id}`);

Resolução de problemas

Exceções

Os métodos de cliente que fazem chamadas de serviço geram uma restError para uma resposta de código de status HTTP sem êxito do serviço. O code da exceção conterá o código de status de resposta HTTP. O error.message da exceção contém uma mensagem detalhada que pode ser útil para diagnosticar o problema:

import { RestError } from "@azure/core-rest-pipeline";

try {
  const thread = await client.threads.create();
} catch (e) {
  if (e instanceof RestError) {
    console.log(`Status code: ${e.code}`);
    console.log(e.message);
  } else {
    console.error(e);
  }
}

Por exemplo, quando você fornece credenciais erradas:

Status code: 401 (Unauthorized)
Operation returned an invalid status 'Unauthorized'

Problemas de relatórios

Para relatar problemas com a biblioteca de clientes ou solicitar recursos adicionais, abra um problema do GitHub aqui

Próximas etapas

Examine os exemplos de pacote pasta, contendo código totalmente executável.

Contribuindo

Este projeto recebe contribuições e sugestões. A maioria das contribuições exige que você concorde com um CLA (Contrato de Licença de Colaborador) declarando que você tem o direito de, e realmente fazer, conceder-nos os direitos de usar sua contribuição. Para obter detalhes, visite https://cla.microsoft.com.

Ao enviar uma solicitação de pull, um CLA-bot determinará automaticamente se você precisa fornecer um CLA e decorar a PR adequadamente (por exemplo, rótulo, comentário). Basta seguir as instruções fornecidas pelo bot. Você só precisará fazer isso uma vez em todos os repositórios usando nosso CLA.

Este projeto adotou o Código de Conduta de Software Livre da Microsoft. Para obter mais informações, consulte as perguntas frequentes sobre o Código de Conduta ou entre em contato com opencode@microsoft.com com perguntas ou comentários adicionais.

  • Last updated on