{"meta":{"title":"Crie seu primeiro aplicativo com tecnologia do Copilot","intro":"Neste tutorial, você usará o SDK do Copilot para criar um assistente de linha de comando. Você começará com as noções básicas, adicionará respostas de streaming e adicionará ferramentas personalizadas, dando Copilot a capacidade de chamar seu código.","product":"GitHub Copilot","breadcrumbs":[{"href":"/pt/copilot","title":"GitHub Copilot"},{"href":"/pt/copilot/how-tos","title":"Instruções"},{"href":"/pt/copilot/how-tos/copilot-sdk","title":"SDK do Copilot"},{"href":"/pt/copilot/how-tos/copilot-sdk/getting-started","title":"Introdução"}],"documentType":"article"},"body":"# Crie seu primeiro aplicativo com tecnologia do Copilot\n\nNeste tutorial, você usará o SDK do Copilot para criar um assistente de linha de comando. Você começará com as noções básicas, adicionará respostas de streaming e adicionará ferramentas personalizadas, dando Copilot a capacidade de chamar seu código.\n\n\n\n\n\n**O que você criará:**\n\n```text\nYou: What's the weather like in Seattle?\nCopilot: Let me check the weather for Seattle...\n Currently 62°F and cloudy with a chance of rain.\n Typical Seattle weather!\n\nYou: How about Tokyo?\nCopilot: In Tokyo it's 75°F and sunny. Great day to be outside!\n```\n\n## Pré-requisitos\n\nAntes de começar, verifique se você tem:\n\n* **GitHub Copilot CLI** instalada e autenticada (os SDKs Node.js, Python e .NET fornecem a CLI automaticamente— consulte [Configuração padrão (CLI empacotada)](/pt/copilot/how-tos/copilot-sdk/setup/bundled-cli). Necessário para Go, Java e Rust, a menos que usem os recursos de agrupamento da CLI no nível do aplicativo.)\n* Seu runtime de idioma preferido:\n * Node.js 20+ ou Python 3,11+ ou Go 1,24+ ou < Rust 1,94+ ou Java 17+ ou .NET 8.0+\n\nVerifique se a CLI está funcionando:\n\n```bash\ncopilot --version\n```\n\n## Etapa 1: instalar o SDK\n\n
\n
TypeScript
\n\nPrimeiro, crie um novo diretório e inicialize seu projeto:\n\n```bash\nmkdir copilot-demo && cd copilot-demo\nnpm init -y --init-type module\n```\n\nEm seguida, instale o SDK e o executor typeScript:\n\n```bash\nnpm install @github/copilot-sdk tsx\n```\n\n
\n\n
Python
\n\n```bash\npip install github-copilot-sdk\n```\n\n
\n\n
Go
\n\nPrimeiro, crie um novo diretório e inicialize seu módulo:\n\n```bash\nmkdir copilot-demo && cd copilot-demo\ngo mod init copilot-demo\n```\n\nEm seguida, instale o SDK:\n\n```bash\ngo get github.com/github/copilot-sdk/go\n```\n\n
\n\n
Rust
\n\nPrimeiro, crie um novo crate binário:\n\n```bash\ncargo new copilot-demo && cd copilot-demo\n```\n\nEm seguida, instale o SDK e as dependências diretas usadas pelos exemplos:\n\n```bash\ncargo add github-copilot-sdk --features derive\n# Used by #[tokio::main] and tokio::spawn\ncargo add tokio --features rt-multi-thread,macros\n# Used by custom-tool parameter derives later in this guide\ncargo add serde --features derive\ncargo add schemars\n```\n\n
\n\n
.NET
\n\nPrimeiro, crie um novo projeto de console:\n\n```bash\ndotnet new console -n CopilotDemo && cd CopilotDemo\n```\n\nEm seguida, adicione o SDK:\n\n```bash\ndotnet add package GitHub.Copilot.SDK\n```\n\n
\n\n
Java
\n\nPrimeiro, crie um novo diretório e inicialize seu projeto.\n\n**Maven** – adicionar ao seu `pom.xml`:\n\n```xml\n\n com.github\n copilot-sdk-java\n ${copilot.sdk.version}\n\n```\n\n**Gradle** — adicione ao seu `build.gradle`:\n\n```groovy\nimplementation 'com.github:copilot-sdk-java:${copilotSdkVersion}'\n```\n\n
\n\n
\n\n## Etapa 2: enviar sua primeira mensagem\n\nCrie um novo arquivo e adicione o código a seguir. Essa é a maneira mais simples de usar o SDK – cerca de 5 linhas de código.\n\n
\n
TypeScript
\n\nCriar `index.ts`:\n\n```typescript\nimport { CopilotClient } from \"@github/copilot-sdk\";\n\nconst client = new CopilotClient();\nconst session = await client.createSession({ model: \"auto\" });\n\nconst response = await session.sendAndWait({ prompt: \"What is 2 + 2?\" });\nconsole.log(response?.data.content);\n\nawait client.stop();\nprocess.exit(0);\n```\n\nExecute-o:\n\n```bash\nnpx tsx index.ts\n```\n\n
\n\n
Python
\n\nCriar `main.py`:\n\n```python\nimport asyncio\nfrom copilot import CopilotClient\nfrom copilot.session import PermissionHandler\n\nasync def main():\n client = CopilotClient()\n await client.start()\n\n session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model=\"auto\")\n response = await session.send_and_wait(\"What is 2 + 2?\")\n print(response.data.content)\n\n await client.stop()\n\nasyncio.run(main())\n```\n\nExecute-o:\n\n```bash\npython main.py\n```\n\n
\n\n
Go
\n\nCriar `main.go`:\n\n```golang\npackage main\n\nimport (\n \"context\"\n \"fmt\"\n \"log\"\n \"os\"\n\n copilot \"github.com/github/copilot-sdk/go\"\n)\n\nfunc main() {\n ctx := context.Background()\n client := copilot.NewClient(nil)\n if err := client.Start(ctx); err != nil {\n log.Fatal(err)\n }\n defer client.Stop()\n\n session, err := client.CreateSession(ctx, &copilot.SessionConfig{Model: \"auto\"})\n if err != nil {\n log.Fatal(err)\n }\n\n response, err := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: \"What is 2 + 2?\"})\n if err != nil {\n log.Fatal(err)\n }\n\n if d, ok := response.Data.(*copilot.AssistantMessageData); ok {\n fmt.Println(d.Content)\n }\n os.Exit(0)\n}\n```\n\nExecute-o:\n\n```bash\ngo run main.go\n```\n\n
\n\n
Rust
\n\nCriar `src/main.rs`:\n\n```rust\nuse std::sync::Arc;\nuse std::time::Duration;\n\nuse github_copilot_sdk::handler::ApproveAllHandler;\nuse github_copilot_sdk::{Client, ClientOptions, MessageOptions, SessionConfig};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box> {\n let client = Client::start(ClientOptions::default()).await?;\n let session = client\n .create_session(SessionConfig::default().with_permission_handler(Arc::new(ApproveAllHandler)))\n .await?;\n\n let response = session\n .send_and_wait(\n MessageOptions::new(\"What is 2 + 2?\").with_wait_timeout(Duration::from_secs(120)),\n )\n .await?;\n\n if let Some(event) = response {\n if let Some(content) = event.data.get(\"content\").and_then(|value| value.as_str()) {\n println!(\"{content}\");\n }\n }\n\n session.disconnect().await?;\n client.stop().await?;\n Ok(())\n}\n```\n\nExecute-o:\n\n```bash\ncargo run\n```\n\n
\n\n
.NET
\n\nCrie um novo projeto de console e adicione-o a `Program.cs`:\n\n```csharp\nusing GitHub.Copilot;\n\nawait using var client = new CopilotClient();\nawait using var session = await client.CreateSessionAsync(new SessionConfig\n{\n Model = \"auto\",\n OnPermissionRequest = PermissionHandler.ApproveAll\n});\n\nvar response = await session.SendAndWaitAsync(new MessageOptions { Prompt = \"What is 2 + 2?\" });\nConsole.WriteLine(response?.Data.Content);\n```\n\nExecute-o:\n\n```bash\ndotnet run\n```\n\n
\n\n
Java
\n\nCriar `HelloCopilot.java`:\n\n\n\n```java\nimport com.github.copilot.CopilotClient;\nimport com.github.copilot.rpc.*;\n\npublic class HelloCopilot {\n public static void main(String[] args) throws Exception {\n try (var client = new CopilotClient()) {\n client.start().get();\n\n var session = client.createSession(\n new SessionConfig()\n .setModel(\"auto\")\n .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)\n ).get();\n\n var response = session.sendAndWait(\n new MessageOptions().setPrompt(\"What is 2 + 2?\")\n ).get();\n\n System.out.println(response.getData().content());\n\n client.stop().get();\n }\n }\n}\n```\n\nExecute-o:\n\n```bash\njavac -cp copilot-sdk.jar HelloCopilot.java && java -cp .:copilot-sdk.jar HelloCopilot\n```\n\n
\n\n
\n\n**Você deve ver:**\n\n```text\n4\n```\n\nParabéns! Você acabou de criar seu primeiro aplicativo com tecnologia Copilot.\n\n## Etapa 3: adicionar respostas de streaming\n\nNo momento, aguarde a resposta completa antes de ver qualquer coisa. Vamos torná-la interativa transmitindo a resposta conforme ela é gerada.\n\n
\n
TypeScript
\n\nAtualização `index.ts`:\n\n```typescript\nimport { CopilotClient } from \"@github/copilot-sdk\";\n\nconst client = new CopilotClient();\nconst session = await client.createSession({\n model: \"auto\",\n streaming: true,\n});\n\n// Listen for response chunks\nsession.on(\"assistant.message_delta\", (event) => {\n process.stdout.write(event.data.deltaContent);\n});\nsession.on(\"session.idle\", () => {\n console.log(); // New line when done\n});\n\nawait session.sendAndWait({ prompt: \"Tell me a short joke\" });\n\nawait client.stop();\nprocess.exit(0);\n```\n\n
\n\n
Python
\n\nAtualização `main.py`:\n\n```python\nimport asyncio\nimport sys\nfrom copilot import CopilotClient\nfrom copilot.session import PermissionHandler\nfrom copilot.session_events import SessionEventType\n\nasync def main():\n client = CopilotClient()\n await client.start()\n\n session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model=\"auto\", streaming=True)\n\n # Listen for response chunks\n def handle_event(event):\n if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:\n sys.stdout.write(event.data.delta_content)\n sys.stdout.flush()\n if event.type == SessionEventType.SESSION_IDLE:\n print() # New line when done\n\n session.on(handle_event)\n\n await session.send_and_wait(\"Tell me a short joke\")\n\n await client.stop()\n\nasyncio.run(main())\n```\n\n
\n\n
Go
\n\nAtualização `main.go`:\n\n```golang\npackage main\n\nimport (\n \"context\"\n \"fmt\"\n \"log\"\n \"os\"\n\n copilot \"github.com/github/copilot-sdk/go\"\n)\n\nfunc main() {\n ctx := context.Background()\n client := copilot.NewClient(nil)\n if err := client.Start(ctx); err != nil {\n log.Fatal(err)\n }\n defer client.Stop()\n\n session, err := client.CreateSession(ctx, &copilot.SessionConfig{\n Model: \"auto\",\n Streaming: copilot.Bool(true),\n })\n if err != nil {\n log.Fatal(err)\n }\n\n // Listen for response chunks\n session.On(func(event copilot.SessionEvent) {\n switch d := event.Data.(type) {\n case *copilot.AssistantMessageDeltaData:\n fmt.Print(d.DeltaContent)\n case *copilot.SessionIdleData:\n _ = d\n fmt.Println()\n }\n })\n\n _, err = session.SendAndWait(ctx, copilot.MessageOptions{Prompt: \"Tell me a short joke\"})\n if err != nil {\n log.Fatal(err)\n }\n os.Exit(0)\n}\n```\n\n
\n\n
Rust
\n\nAtualização `src/main.rs`:\n\n```rust\nuse std::io::{self, Write};\nuse std::sync::Arc;\nuse std::time::Duration;\n\nuse github_copilot_sdk::handler::ApproveAllHandler;\nuse github_copilot_sdk::{Client, ClientOptions, MessageOptions, SessionConfig};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box> {\n let client = Client::start(ClientOptions::default()).await?;\n\n let mut config = SessionConfig::default();\n config.streaming = Some(true);\n let session = client\n .create_session(config.with_permission_handler(Arc::new(ApproveAllHandler)))\n .await?;\n\n // Listen for response chunks\n let mut events = session.subscribe();\n tokio::spawn(async move {\n while let Ok(event) = events.recv().await {\n match event.event_type.as_str() {\n \"assistant.message_delta\" => {\n if let Some(text) =\n event.data.get(\"deltaContent\").and_then(|value| value.as_str())\n {\n print!(\"{text}\");\n io::stdout().flush().ok();\n }\n }\n \"assistant.message\" => println!(),\n _ => {}\n }\n }\n });\n\n session\n .send_and_wait(\n MessageOptions::new(\"Tell me a short joke\")\n .with_wait_timeout(Duration::from_secs(120)),\n )\n .await?;\n\n session.disconnect().await?;\n client.stop().await?;\n Ok(())\n}\n```\n\n
\n\n
.NET
\n\nAtualização `Program.cs`:\n\n```csharp\nusing GitHub.Copilot;\n\nawait using var client = new CopilotClient();\nawait using var session = await client.CreateSessionAsync(new SessionConfig\n{\n Model = \"auto\",\n OnPermissionRequest = PermissionHandler.ApproveAll,\n Streaming = true,\n});\n\n// Listen for response chunks\nsession.On(ev =>\n{\n if (ev is AssistantMessageDeltaEvent deltaEvent)\n {\n Console.Write(deltaEvent.Data.DeltaContent);\n }\n if (ev is SessionIdleEvent)\n {\n Console.WriteLine();\n }\n});\n\nawait session.SendAndWaitAsync(new MessageOptions { Prompt = \"Tell me a short joke\" });\n```\n\n
\n\n
Java
\n\nAtualização `HelloCopilot.java`:\n\n\n\n```java\nimport com.github.copilot.CopilotClient;\nimport com.github.copilot.rpc.*;\n\npublic class HelloCopilot {\n public static void main(String[] args) throws Exception {\n try (var client = new CopilotClient()) {\n client.start().get();\n\n var session = client.createSession(\n new SessionConfig()\n .setModel(\"auto\")\n .setStreaming(true)\n .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)\n ).get();\n\n // Listen for response chunks\n session.on(AssistantMessageDeltaEvent.class, delta -> {\n System.out.print(delta.getData().deltaContent());\n });\n session.on(SessionIdleEvent.class, idle -> {\n System.out.println(); // New line when done\n });\n\n session.sendAndWait(\n new MessageOptions().setPrompt(\"Tell me a short joke\")\n ).get();\n\n client.stop().get();\n }\n }\n}\n```\n\n
\n\n
\n\nExecute o código novamente. Você verá a resposta aparecer palavra por palavra.\n\n### Métodos de assinatura de evento\n\nO SDK fornece métodos para assinar eventos de sessão:\n\n| Método | Description |\n| ------------------------ | --------------------------------------------------------------------------------------------------------------------- |\n| `on(handler)` | Inscreva-se em todos os eventos; retorna a função de cancelamento de assinatura |\n| `on(eventType, handler)` | Inscrever-se em um tipo específico de evento (somente Node.js/TypeScript); retorna a função para cancelar a inscrição |\n| `subscribe()` | Assinar todos os eventos (Rust); filtrar por `event_type` |\n\n
\n
TypeScript
\n\n```typescript\n// Subscribe to all events\nconst unsubscribeAll = session.on((event) => {\n console.log(\"Event:\", event.type);\n});\n\n// Subscribe to specific event type\nconst unsubscribeIdle = session.on(\"session.idle\", (event) => {\n console.log(\"Session is idle\");\n});\n\n// Later, to unsubscribe:\nunsubscribeAll();\nunsubscribeIdle();\n```\n\n
\n\n
Python
\n\n```python\n# Subscribe to all events\nunsubscribe = session.on(lambda event: print(f\"Event: {event.type}\"))\n\n# Filter by event type in your handler\ndef handle_event(event):\n if event.type == SessionEventType.SESSION_IDLE:\n print(\"Session is idle\")\n elif event.type == SessionEventType.ASSISTANT_MESSAGE:\n print(f\"Message: {event.data.content}\")\n\nunsubscribe = session.on(handle_event)\n\n# Later, to unsubscribe:\nunsubscribe()\n```\n\n
\n\n
Go
\n\n```golang\n// Subscribe to all events\nunsubscribe := session.On(func(event copilot.SessionEvent) {\n fmt.Println(\"Event:\", event.Type)\n})\n\n// Filter by event type in your handler\nsession.On(func(event copilot.SessionEvent) {\n switch d := event.Data.(type) {\n case *copilot.SessionIdleData:\n _ = d\n fmt.Println(\"Session is idle\")\n case *copilot.AssistantMessageData:\n fmt.Println(\"Message:\", d.Content)\n }\n})\n\n// Later, to unsubscribe:\nunsubscribe()\n```\n\n
\n\n
Rust
\n\n```rust\nlet mut events = session.subscribe();\n\ntokio::spawn(async move {\n while let Ok(event) = events.recv().await {\n println!(\"Event: {}\", event.event_type);\n\n match event.event_type.as_str() {\n \"session.idle\" => println!(\"Session is idle\"),\n \"assistant.message\" => {\n if let Some(content) = event.data.get(\"content\").and_then(|value| value.as_str()) {\n println!(\"Message: {content}\");\n }\n }\n _ => {}\n }\n }\n});\n```\n\n
\n\n
.NET
\n\n```csharp\n// Subscribe to all events\nvar unsubscribe = session.On(ev => Console.WriteLine($\"Event: {ev.Type}\"));\n\n// Filter by event type using pattern matching\nsession.On(ev =>\n{\n switch (ev)\n {\n case SessionIdleEvent:\n Console.WriteLine(\"Session is idle\");\n break;\n case AssistantMessageEvent msg:\n Console.WriteLine($\"Message: {msg.Data.Content}\");\n break;\n }\n});\n\n// Later, to unsubscribe:\nunsubscribe.Dispose();\n```\n\n
\n\n
Java
\n\n\n\n```java\n// Subscribe to all events\nvar unsubscribe = session.on(event -> {\n System.out.println(\"Event: \" + event.getType());\n});\n\n// Subscribe to a specific event type\nsession.on(AssistantMessageEvent.class, msg -> {\n System.out.println(\"Message: \" + msg.getData().content());\n});\n\nsession.on(SessionIdleEvent.class, idle -> {\n System.out.println(\"Session is idle\");\n});\n\n// Later, to unsubscribe:\nunsubscribe.close();\n```\n\n
\n\n
\n\n## Etapa 4: adicionar uma ferramenta personalizada\n\nAgora, a parte mais poderosa. Vamos dar a Copilot a capacidade de chamar seu código definindo uma ferramenta personalizada. Criaremos uma ferramenta de pesquisa de clima simples.\n\n
\n
TypeScript
\n\nAtualização `index.ts`:\n\n```typescript\nimport { CopilotClient, defineTool } from \"@github/copilot-sdk\";\n\n// Define a tool that Copilot can call\nconst getWeather = defineTool(\"get_weather\", {\n description: \"Get the current weather for a city\",\n parameters: {\n type: \"object\",\n properties: {\n city: { type: \"string\", description: \"The city name\" },\n },\n required: [\"city\"],\n },\n handler: async (args: { city: string }) => {\n const { city } = args;\n // In a real app, you'd call a weather API here\n const conditions = [\"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\"];\n const temp = Math.floor(Math.random() * 30) + 50;\n const condition = conditions[Math.floor(Math.random() * conditions.length)];\n return { city, temperature: `${temp}°F`, condition };\n },\n});\n\nconst client = new CopilotClient();\nconst session = await client.createSession({\n model: \"auto\",\n streaming: true,\n tools: [getWeather],\n});\n\nsession.on(\"assistant.message_delta\", (event) => {\n process.stdout.write(event.data.deltaContent);\n});\n\nsession.on(\"session.idle\", () => {\n console.log(); // New line when done\n});\n\nawait session.sendAndWait({\n prompt: \"What's the weather like in Seattle and Tokyo?\",\n});\n\nawait client.stop();\nprocess.exit(0);\n```\n\n
\n\n
Python
\n\nAtualização `main.py`:\n\n```python\nimport asyncio\nimport random\nimport sys\nfrom copilot import CopilotClient\nfrom copilot.session import PermissionHandler\nfrom copilot.tools import define_tool\nfrom copilot.session_events import SessionEventType\nfrom pydantic import BaseModel, Field\n\n# Define the parameters for the tool using Pydantic\nclass GetWeatherParams(BaseModel):\n city: str = Field(description=\"The name of the city to get weather for\")\n\n# Define a tool that Copilot can call\n@define_tool(description=\"Get the current weather for a city\")\nasync def get_weather(params: GetWeatherParams) -> dict:\n city = params.city\n # In a real app, you'd call a weather API here\n conditions = [\"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\"]\n temp = random.randint(50, 80)\n condition = random.choice(conditions)\n return {\"city\": city, \"temperature\": f\"{temp}°F\", \"condition\": condition}\n\nasync def main():\n client = CopilotClient()\n await client.start()\n\n session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model=\"auto\", streaming=True, tools=[get_weather])\n\n def handle_event(event):\n if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:\n sys.stdout.write(event.data.delta_content)\n sys.stdout.flush()\n if event.type == SessionEventType.SESSION_IDLE:\n print()\n\n session.on(handle_event)\n\n await session.send_and_wait(\"What's the weather like in Seattle and Tokyo?\")\n\n await client.stop()\n\nasyncio.run(main())\n```\n\n
\n\n
Go
\n\nAtualização `main.go`:\n\n```golang\npackage main\n\nimport (\n \"context\"\n \"fmt\"\n \"log\"\n \"math/rand\"\n \"os\"\n\n copilot \"github.com/github/copilot-sdk/go\"\n)\n\n// Define the parameter type\ntype WeatherParams struct {\n City string `json:\"city\" jsonschema:\"The city name\"`\n}\n\n// Define the return type\ntype WeatherResult struct {\n City string `json:\"city\"`\n Temperature string `json:\"temperature\"`\n Condition string `json:\"condition\"`\n}\n\nfunc main() {\n ctx := context.Background()\n\n // Define a tool that Copilot can call\n getWeather := copilot.DefineTool(\n \"get_weather\",\n \"Get the current weather for a city\",\n func(params WeatherParams, inv copilot.ToolInvocation) (WeatherResult, error) {\n // In a real app, you'd call a weather API here\n conditions := []string{\"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\"}\n temp := rand.Intn(30) + 50\n condition := conditions[rand.Intn(len(conditions))]\n return WeatherResult{\n City: params.City,\n Temperature: fmt.Sprintf(\"%d°F\", temp),\n Condition: condition,\n }, nil\n },\n )\n\n client := copilot.NewClient(nil)\n if err := client.Start(ctx); err != nil {\n log.Fatal(err)\n }\n defer client.Stop()\n\n session, err := client.CreateSession(ctx, &copilot.SessionConfig{\n Model: \"auto\",\n Streaming: copilot.Bool(true),\n Tools: []copilot.Tool{getWeather},\n })\n if err != nil {\n log.Fatal(err)\n }\n\n session.On(func(event copilot.SessionEvent) {\n switch d := event.Data.(type) {\n case *copilot.AssistantMessageDeltaData:\n fmt.Print(d.DeltaContent)\n case *copilot.SessionIdleData:\n _ = d\n fmt.Println()\n }\n })\n\n _, err = session.SendAndWait(ctx, copilot.MessageOptions{\n Prompt: \"What's the weather like in Seattle and Tokyo?\",\n })\n if err != nil {\n log.Fatal(err)\n }\n os.Exit(0)\n}\n```\n\n
\n\n
Rust
\n\nAtualização `src/main.rs`:\n\n```rust\nuse std::io::{self, Write};\nuse std::sync::Arc;\nuse std::time::Duration;\n\nuse github_copilot_sdk::handler::ApproveAllHandler;\nuse github_copilot_sdk::tool::{define_tool, JsonSchema};\nuse github_copilot_sdk::{Client, ClientOptions, MessageOptions, SessionConfig, ToolResult};\nuse serde::Deserialize;\n\n#[derive(Deserialize, JsonSchema)]\nstruct GetWeatherParams {\n city: String,\n}\n\n#[tokio::main]\nasync fn main() -> Result<(), Box> {\n // Define a tool that Copilot can call\n let tools = vec![define_tool(\n \"get_weather\",\n \"Get the current weather for a city\",\n |_inv, params: GetWeatherParams| async move {\n Ok(ToolResult::Text(format!(\n \"{}: 62°F and sunny\",\n params.city\n )))\n },\n )];\n\n let client = Client::start(ClientOptions::default()).await?;\n\n let mut config = SessionConfig::default();\n config.streaming = Some(true);\n let session = client\n .create_session(\n config\n .with_tools(tools)\n .with_permission_handler(Arc::new(ApproveAllHandler)),\n )\n .await?;\n\n let mut events = session.subscribe();\n tokio::spawn(async move {\n while let Ok(event) = events.recv().await {\n match event.event_type.as_str() {\n \"assistant.message_delta\" => {\n if let Some(text) =\n event.data.get(\"deltaContent\").and_then(|value| value.as_str())\n {\n print!(\"{text}\");\n io::stdout().flush().ok();\n }\n }\n \"assistant.message\" => println!(),\n _ => {}\n }\n }\n });\n\n session\n .send_and_wait(\n MessageOptions::new(\"What's the weather like in Seattle and Tokyo?\")\n .with_wait_timeout(Duration::from_secs(120)),\n )\n .await?;\n\n session.disconnect().await?;\n client.stop().await?;\n Ok(())\n}\n```\n\n
\n\n
.NET
\n\nAtualização `Program.cs`:\n\n```csharp\nusing GitHub.Copilot;\nusing Microsoft.Extensions.AI;\nusing System.ComponentModel;\n\nawait using var client = new CopilotClient();\n\n// Define a tool that Copilot can call\nvar getWeather = CopilotTool.DefineTool(\n ([Description(\"The city name\")] string city) =>\n {\n // In a real app, you'd call a weather API here\n var conditions = new[] { \"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\" };\n var temp = Random.Shared.Next(50, 80);\n var condition = conditions[Random.Shared.Next(conditions.Length)];\n return new { city, temperature = $\"{temp}°F\", condition };\n },\n factoryOptions: new AIFunctionFactoryOptions\n {\n Name = \"get_weather\",\n Description = \"Get the current weather for a city\",\n }\n);\n\nawait using var session = await client.CreateSessionAsync(new SessionConfig\n{\n Model = \"auto\",\n OnPermissionRequest = PermissionHandler.ApproveAll,\n Streaming = true,\n Tools = [getWeather],\n});\n\nsession.On(ev =>\n{\n if (ev is AssistantMessageDeltaEvent deltaEvent)\n {\n Console.Write(deltaEvent.Data.DeltaContent);\n }\n if (ev is SessionIdleEvent)\n {\n Console.WriteLine();\n }\n});\n\nawait session.SendAndWaitAsync(new MessageOptions\n{\n Prompt = \"What's the weather like in Seattle and Tokyo?\",\n});\n```\n\n
\n\n
Java
\n\nAtualização `HelloCopilot.java`:\n\n\n\n```java\nimport com.github.copilot.CopilotClient;\nimport com.github.copilot.rpc.*;\n\nimport java.util.List;\nimport java.util.Map;\nimport java.util.Random;\nimport java.util.concurrent.CompletableFuture;\n\npublic class HelloCopilot {\n public static void main(String[] args) throws Exception {\n var random = new Random();\n var conditions = List.of(\"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\");\n\n // Define a tool that Copilot can call\n var getWeather = ToolDefinition.create(\n \"get_weather\",\n \"Get the current weather for a city\",\n Map.of(\n \"type\", \"object\",\n \"properties\", Map.of(\n \"city\", Map.of(\"type\", \"string\", \"description\", \"The city name\")\n ),\n \"required\", List.of(\"city\")\n ),\n invocation -> {\n var city = (String) invocation.getArguments().get(\"city\");\n var temp = random.nextInt(30) + 50;\n var condition = conditions.get(random.nextInt(conditions.size()));\n return CompletableFuture.completedFuture(Map.of(\n \"city\", city,\n \"temperature\", temp + \"°F\",\n \"condition\", condition\n ));\n }\n );\n\n try (var client = new CopilotClient()) {\n client.start().get();\n\n var session = client.createSession(\n new SessionConfig()\n .setModel(\"auto\")\n .setStreaming(true)\n .setTools(List.of(getWeather))\n .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)\n ).get();\n\n session.on(AssistantMessageDeltaEvent.class, delta -> {\n System.out.print(delta.getData().deltaContent());\n });\n session.on(SessionIdleEvent.class, idle -> {\n System.out.println();\n });\n\n session.sendAndWait(\n new MessageOptions().setPrompt(\"What's the weather like in Seattle and Tokyo?\")\n ).get();\n\n client.stop().get();\n }\n }\n}\n```\n\n
\n\n
\n\nExecute-o e você verá Copilot chamar sua ferramenta para obter dados meteorológicos e responder com os resultados!\n\n## Etapa 5: criar um assistente interativo\n\nVamos juntar tudo em um assistente interativo útil:\n\n
\n
TypeScript
\n\n```typescript\nimport { CopilotClient, defineTool } from \"@github/copilot-sdk\";\nimport * as readline from \"readline\";\n\nconst getWeather = defineTool(\"get_weather\", {\n description: \"Get the current weather for a city\",\n parameters: {\n type: \"object\",\n properties: {\n city: { type: \"string\", description: \"The city name\" },\n },\n required: [\"city\"],\n },\n handler: async ({ city }) => {\n const conditions = [\"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\"];\n const temp = Math.floor(Math.random() * 30) + 50;\n const condition = conditions[Math.floor(Math.random() * conditions.length)];\n return { city, temperature: `${temp}°F`, condition };\n },\n});\n\nconst client = new CopilotClient();\nconst session = await client.createSession({\n model: \"auto\",\n streaming: true,\n tools: [getWeather],\n});\n\nsession.on(\"assistant.message_delta\", (event) => {\n process.stdout.write(event.data.deltaContent);\n});\n\nconst rl = readline.createInterface({\n input: process.stdin,\n output: process.stdout,\n});\n\nconsole.log(\"🌤️ Weather Assistant (type 'exit' to quit)\");\nconsole.log(\" Try: 'What's the weather in Paris?'\\n\");\n\nconst prompt = () => {\n rl.question(\"You: \", async (input) => {\n if (input.toLowerCase() === \"exit\") {\n await client.stop();\n rl.close();\n return;\n }\n\n process.stdout.write(\"Assistant: \");\n await session.sendAndWait({ prompt: input });\n console.log(\"\\n\");\n prompt();\n });\n};\n\nprompt();\n```\n\nExecute com:\n\n```bash\nnpx tsx weather-assistant.ts\n```\n\n
\n\n
Python
\n\nCriar `weather_assistant.py`:\n\n```python\nimport asyncio\nimport random\nimport sys\nfrom copilot import CopilotClient\nfrom copilot.session import PermissionHandler\nfrom copilot.tools import define_tool\nfrom copilot.session_events import SessionEventType\nfrom pydantic import BaseModel, Field\n\nclass GetWeatherParams(BaseModel):\n city: str = Field(description=\"The name of the city to get weather for\")\n\n@define_tool(description=\"Get the current weather for a city\")\nasync def get_weather(params: GetWeatherParams) -> dict:\n city = params.city\n conditions = [\"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\"]\n temp = random.randint(50, 80)\n condition = random.choice(conditions)\n return {\"city\": city, \"temperature\": f\"{temp}°F\", \"condition\": condition}\n\nasync def main():\n client = CopilotClient()\n await client.start()\n\n session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model=\"auto\", streaming=True, tools=[get_weather])\n\n def handle_event(event):\n if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:\n sys.stdout.write(event.data.delta_content)\n sys.stdout.flush()\n\n session.on(handle_event)\n\n print(\"🌤️ Weather Assistant (type 'exit' to quit)\")\n print(\" Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\\n\")\n\n while True:\n try:\n user_input = input(\"You: \")\n except EOFError:\n break\n\n if user_input.lower() == \"exit\":\n break\n\n sys.stdout.write(\"Assistant: \")\n await session.send_and_wait(user_input)\n print(\"\\n\")\n\n await client.stop()\n\nasyncio.run(main())\n```\n\nExecute com:\n\n```bash\npython weather_assistant.py\n```\n\n
\n\n
Go
\n\nCriar `weather-assistant.go`:\n\n```golang\npackage main\n\nimport (\n \"bufio\"\n \"context\"\n \"fmt\"\n \"log\"\n \"math/rand\"\n \"os\"\n \"strings\"\n\n copilot \"github.com/github/copilot-sdk/go\"\n)\n\ntype WeatherParams struct {\n City string `json:\"city\" jsonschema:\"The city name\"`\n}\n\ntype WeatherResult struct {\n City string `json:\"city\"`\n Temperature string `json:\"temperature\"`\n Condition string `json:\"condition\"`\n}\n\nfunc main() {\n ctx := context.Background()\n\n getWeather := copilot.DefineTool(\n \"get_weather\",\n \"Get the current weather for a city\",\n func(params WeatherParams, inv copilot.ToolInvocation) (WeatherResult, error) {\n conditions := []string{\"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\"}\n temp := rand.Intn(30) + 50\n condition := conditions[rand.Intn(len(conditions))]\n return WeatherResult{\n City: params.City,\n Temperature: fmt.Sprintf(\"%d°F\", temp),\n Condition: condition,\n }, nil\n },\n )\n\n client := copilot.NewClient(nil)\n if err := client.Start(ctx); err != nil {\n log.Fatal(err)\n }\n defer client.Stop()\n\n session, err := client.CreateSession(ctx, &copilot.SessionConfig{\n Model: \"auto\",\n Streaming: copilot.Bool(true),\n Tools: []copilot.Tool{getWeather},\n })\n if err != nil {\n log.Fatal(err)\n }\n\n session.On(func(event copilot.SessionEvent) {\n switch d := event.Data.(type) {\n case *copilot.AssistantMessageDeltaData:\n fmt.Print(d.DeltaContent)\n case *copilot.SessionIdleData:\n _ = d\n fmt.Println()\n }\n })\n\n fmt.Println(\"🌤️ Weather Assistant (type 'exit' to quit)\")\n fmt.Println(\" Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\\n\")\n\n scanner := bufio.NewScanner(os.Stdin)\n for {\n fmt.Print(\"You: \")\n if !scanner.Scan() {\n break\n }\n input := scanner.Text()\n if strings.ToLower(input) == \"exit\" {\n break\n }\n\n fmt.Print(\"Assistant: \")\n _, err = session.SendAndWait(ctx, copilot.MessageOptions{Prompt: input})\n if err != nil {\n fmt.Fprintf(os.Stderr, \"Error: %v\\n\", err)\n break\n }\n fmt.Println()\n }\n if err := scanner.Err(); err != nil {\n fmt.Fprintf(os.Stderr, \"Input error: %v\\n\", err)\n }\n}\n```\n\nExecute com:\n\n```bash\ngo run weather-assistant.go\n```\n\n
\n\n
Rust
\n\nCriar `src/main.rs`:\n\n```rust\nuse std::io::{self, BufRead, Write};\nuse std::sync::Arc;\nuse std::time::Duration;\n\nuse github_copilot_sdk::handler::ApproveAllHandler;\nuse github_copilot_sdk::tool::{define_tool, JsonSchema};\nuse github_copilot_sdk::{Client, ClientOptions, MessageOptions, SessionConfig, ToolResult};\nuse serde::Deserialize;\n\n#[derive(Deserialize, JsonSchema)]\nstruct GetWeatherParams {\n city: String,\n}\n\nfn read_line() -> Option {\n let stdin = io::stdin();\n let mut line = String::new();\n stdin.lock().read_line(&mut line).ok()?;\n if line.is_empty() {\n return None;\n }\n Some(line.trim_end_matches(&['\\n', '\\r'][..]).to_string())\n}\n\n#[tokio::main]\nasync fn main() -> Result<(), Box> {\n let tools = vec![define_tool(\n \"get_weather\",\n \"Get the current weather for a city\",\n |_inv, params: GetWeatherParams| async move {\n Ok(ToolResult::Text(format!(\n \"{}: 62°F and sunny\",\n params.city\n )))\n },\n )];\n\n let client = Client::start(ClientOptions::default()).await?;\n\n let mut config = SessionConfig::default();\n config.streaming = Some(true);\n let session = client\n .create_session(\n config\n .with_tools(tools)\n .with_permission_handler(Arc::new(ApproveAllHandler)),\n )\n .await?;\n\n let mut events = session.subscribe();\n tokio::spawn(async move {\n while let Ok(event) = events.recv().await {\n match event.event_type.as_str() {\n \"assistant.message_delta\" => {\n if let Some(text) =\n event.data.get(\"deltaContent\").and_then(|value| value.as_str())\n {\n print!(\"{text}\");\n io::stdout().flush().ok();\n }\n }\n \"assistant.message\" => println!(),\n _ => {}\n }\n }\n });\n\n println!(\"Weather Assistant (type 'exit' to quit)\");\n println!(\"Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\\n\");\n\n loop {\n print!(\"You: \");\n io::stdout().flush().ok();\n\n let Some(input) = read_line() else { break };\n if input.eq_ignore_ascii_case(\"exit\") {\n break;\n }\n\n print!(\"Assistant: \");\n io::stdout().flush().ok();\n session\n .send_and_wait(MessageOptions::new(input).with_wait_timeout(Duration::from_secs(120)))\n .await?;\n println!();\n }\n\n session.disconnect().await?;\n client.stop().await?;\n Ok(())\n}\n```\n\nExecute com:\n\n```bash\ncargo run\n```\n\n
\n\n
.NET
\n\nCrie um novo projeto de console e atualize `Program.cs`:\n\n```csharp\nusing GitHub.Copilot;\nusing Microsoft.Extensions.AI;\nusing System.ComponentModel;\n\n// Define the weather tool\nvar getWeather = CopilotTool.DefineTool(\n ([Description(\"The city name\")] string city) =>\n {\n var conditions = new[] { \"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\" };\n var temp = Random.Shared.Next(50, 80);\n var condition = conditions[Random.Shared.Next(conditions.Length)];\n return new { city, temperature = $\"{temp}°F\", condition };\n },\n factoryOptions: new AIFunctionFactoryOptions\n {\n Name = \"get_weather\",\n Description = \"Get the current weather for a city\",\n });\n\nawait using var client = new CopilotClient();\nawait using var session = await client.CreateSessionAsync(new SessionConfig\n{\n Model = \"auto\",\n OnPermissionRequest = PermissionHandler.ApproveAll,\n Streaming = true,\n Tools = [getWeather]\n});\n\n// Listen for response chunks\nsession.On(ev =>\n{\n if (ev is AssistantMessageDeltaEvent deltaEvent)\n {\n Console.Write(deltaEvent.Data.DeltaContent);\n }\n if (ev is SessionIdleEvent)\n {\n Console.WriteLine();\n }\n});\n\nConsole.WriteLine(\"🌤️ Weather Assistant (type 'exit' to quit)\");\nConsole.WriteLine(\" Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\\n\");\n\nwhile (true)\n{\n Console.Write(\"You: \");\n var input = Console.ReadLine();\n\n if (string.IsNullOrEmpty(input) || input.Equals(\"exit\", StringComparison.OrdinalIgnoreCase))\n {\n break;\n }\n\n Console.Write(\"Assistant: \");\n await session.SendAndWaitAsync(new MessageOptions { Prompt = input });\n Console.WriteLine(\"\\n\");\n}\n```\n\nExecute com:\n\n```bash\ndotnet run\n```\n\n
\n\n
Java
\n\nCriar `WeatherAssistant.java`:\n\n\n\n```java\nimport com.github.copilot.CopilotClient;\nimport com.github.copilot.rpc.*;\n\nimport java.util.List;\nimport java.util.Map;\nimport java.util.Random;\nimport java.util.Scanner;\nimport java.util.concurrent.CompletableFuture;\n\npublic class WeatherAssistant {\n public static void main(String[] args) throws Exception {\n var random = new Random();\n var conditions = List.of(\"sunny\", \"cloudy\", \"rainy\", \"partly cloudy\");\n\n var getWeather = ToolDefinition.create(\n \"get_weather\",\n \"Get the current weather for a city\",\n Map.of(\n \"type\", \"object\",\n \"properties\", Map.of(\n \"city\", Map.of(\"type\", \"string\", \"description\", \"The city name\")\n ),\n \"required\", List.of(\"city\")\n ),\n invocation -> {\n var city = (String) invocation.getArguments().get(\"city\");\n var temp = random.nextInt(30) + 50;\n var condition = conditions.get(random.nextInt(conditions.size()));\n return CompletableFuture.completedFuture(Map.of(\n \"city\", city,\n \"temperature\", temp + \"°F\",\n \"condition\", condition\n ));\n }\n );\n\n try (var client = new CopilotClient()) {\n client.start().get();\n\n var session = client.createSession(\n new SessionConfig()\n .setModel(\"auto\")\n .setStreaming(true)\n .setOnPermissionRequest(request ->\n CompletableFuture.completedFuture(PermissionDecision.allow())\n )\n .setTools(List.of(getWeather))\n ).get();\n\n session.on(AssistantMessageDeltaEvent.class, delta -> {\n System.out.print(delta.getData().deltaContent());\n });\n session.on(SessionIdleEvent.class, idle -> {\n System.out.println();\n });\n\n System.out.println(\"🌤️ Weather Assistant (type 'exit' to quit)\");\n System.out.println(\" Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\\n\");\n\n var scanner = new Scanner(System.in);\n while (true) {\n System.out.print(\"You: \");\n if (!scanner.hasNextLine()) break;\n var input = scanner.nextLine();\n if (input.equalsIgnoreCase(\"exit\")) break;\n\n System.out.print(\"Assistant: \");\n session.sendAndWait(\n new MessageOptions().setPrompt(input)\n ).get();\n System.out.println(\"\\n\");\n }\n\n client.stop().get();\n }\n }\n}\n```\n\nExecute com:\n\n```bash\njavac -cp copilot-sdk.jar WeatherAssistant.java && java -cp .:copilot-sdk.jar WeatherAssistant\n```\n\n
\n\n
\n\n**Sessão de exemplo:**\n\n```text\n🌤️ Weather Assistant (type 'exit' to quit)\n Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\n\nYou: What's the weather in Seattle?\nAssistant: Let me check the weather for Seattle...\nIt's currently 62°F and cloudy in Seattle.\n\nYou: How about Tokyo and London?\nAssistant: I'll check both cities for you:\n- Tokyo: 75°F and sunny\n- London: 58°F and rainy\n\nYou: exit\n```\n\nVocê criou um assistente com uma ferramenta personalizada que Copilot pode chamar!\n\n## Como as ferramentas funcionam\n\nAo definir uma ferramenta, você informa Copilot:\n\n1. **O que a ferramenta faz** (descrição)\n2. **Quais parâmetros ele precisa** (esquema)\n3. **Que código executar** (manipulador)\n\nCopilot decide quando chamar sua ferramenta com base na pergunta do usuário. Quando isso acontecer:\n\n1. Copilot envia uma solicitação de chamada de ferramenta com os parâmetros\n2. O SDK executa sua função de manipulador\n3. O resultado é enviado de volta para Copilot\n4. Copilot incorpora o resultado em sua resposta\n\n## E agora?\n\nAgora que você tem as noções básicas, aqui estão os recursos mais poderosos a serem explorados:\n\n### Conectar-se a servidores MCP\n\nOs servidores MCP (Protocolo de Contexto de Modelo) oferecem ferramentas pré-construídas. Conecte-se ao servidor MCP do GitHub para dar acesso Copilot a repositórios, problemas e solicitações de pull:\n\n```typescript\nconst session = await client.createSession({\n mcpServers: {\n github: {\n type: \"http\",\n url: \"https://api.githubcopilot.com/mcp/\",\n },\n },\n});\n```\n\n📖\n\\*\\*\n[Usando servidores MCP com o SDK do GitHub Copilot](/pt/copilot/how-tos/copilot-sdk/features/mcp)\\*\\* - Saiba mais sobre servidores locais versus remotos, todas as opções de configuração e solução de problemas.\n\n### Criar agentes personalizados\n\nDefina personas de IA especializadas para tarefas específicas:\n\n```typescript\nconst session = await client.createSession({\n customAgents: [{\n name: \"pr-reviewer\",\n displayName: \"PR Reviewer\",\n description: \"Reviews pull requests for best practices\",\n prompt: \"You are an expert code reviewer. Focus on security, performance, and maintainability.\",\n }],\n});\n```\n\n> \\[!TIP]\n> Você também pode definir `agent: \"pr-reviewer\"` na configuração da sessão para pré-selecionar esse agente desde o início. Consulte o [Agentes personalizados e orquestração de subagentes](/pt/copilot/how-tos/copilot-sdk/features/custom-agents#selecting-an-agent-at-session-creation) para obter detalhes.\n\n### Personalizar a mensagem do sistema\n\nControle o comportamento e a personalidade da IA acrescentando instruções:\n\n```typescript\nconst session = await client.createSession({\n systemMessage: {\n content: \"You are a helpful assistant for our engineering team. Always be concise.\",\n },\n});\n```\n\nPara um controle mais refinado, use `mode: \"customize\"` para substituir seções individuais do prompt do sistema, preservando o restante:\n\n```typescript\nconst session = await client.createSession({\n systemMessage: {\n mode: \"customize\",\n sections: {\n tone: { action: \"replace\", content: \"Respond in a warm, professional tone. Be thorough in explanations.\" },\n code_change_rules: { action: \"remove\" },\n guidelines: { action: \"append\", content: \"\\n* Always cite data sources\" },\n },\n content: \"Focus on financial analysis and reporting.\",\n },\n});\n```\n\nIDs de seção disponíveis: `preamble`, , `identity`, `tone`, `tool_efficiency`, `environment_context`, `code_change_rules`, `guidelines`, , `safety`, `tool_instructions`, , `custom_instructions`, , , `runtime_instructions``last_instructions`.\n\n`identity` e `tool_instructions` são *grupos* de seções: eles têm como destino uma coleção de subseções relacionadas como uma unidade. Use `preamble` para direcionar apenas o preâmbulo de identidade sem afetar suas respectivas subseções irmãs.\n\nCada substituição oferece suporte a cinco ações: `replace`, `remove`, `append`, `prepend` e `preserve`. A ação `preserve` é uma operação sem efeito que exclui uma seção endereçável individualmente de uma ação `remove` no nível do grupo (por exemplo, manter `tone` ao remover o grupo `identity`). As IDs de seção desconhecidas são processadas corretamente: o conteúdo das substituições de `replace`/`append`/`prepend` é acrescentado às instruções adicionais, e as substituições de `remove`são ignoradas silenciosamente.\n\nConsulte os READMEs do SDK específicos do idioma para obter exemplos em [TypeScript](https://github.com/github/copilot-sdk/tree/main/nodejs/README.md), [Python](https://github.com/github/copilot-sdk/tree/main/python/README.md), [Go](https://github.com/github/copilot-sdk/tree/main/go/README.md), [Rust](https://github.com/github/copilot-sdk/tree/main/rust/README.md), [Java](https://github.com/github/copilot-sdk/tree/main/java/README.md) e [C#](https://github.com/github/copilot-sdk/tree/main/dotnet/README.md).\n\n## Conectando-se a um servidor da CLI externa\n\nPor padrão, o SDK gerencia automaticamente o ciclo de vida do processo da CLI Copilot, iniciando e interrompendo a CLI conforme necessário. No entanto, você também pode executar a CLI no modo de servidor separadamente e fazer com que o SDK se conecte a ela. Isso pode ser útil para:\n\n* **Depuração**: mantenha a CLI em execução entre as reinicializações do SDK para inspecionar os logs\n* **Compartilhamento de** recursos: vários clientes do SDK podem se conectar ao mesmo servidor da CLI\n* **Desenvolvimento**: executar a CLI com configurações personalizadas ou em um ambiente diferente\n\n### Executando a CLI no modo de servidor\n\nInicie a CLI no modo de servidor usando o `--headless` sinalizador e, opcionalmente, especifique uma porta:\n\n```bash\ncopilot --headless --port 4321\n```\n\nSe você não especificar uma porta, a CLI escolherá uma porta disponível aleatória.\n\nPor padrão, o servidor sem periféricos aceita apenas conexões de loopback (`127.0.0.1`), portanto o SDK deve ser executado na mesma máquina. Para aceitar conexões de outros hosts (por exemplo, ao executar a CLI em um contêiner ou em um servidor separado), associe a um endereço que não seja de loopback com `--host`:\n\n```bash\n# Listen on all interfaces\ncopilot --headless --host 0.0.0.0 --port 4321\n```\n\n> \\[!WARNING]\n> Expor o servidor sem periféricos em um endereço diferente de loopback faz com que ele fique acessível a qualquer pessoa que tenha uma rota até esse endereço. Emparelhe-o com controles de rede (firewall, rede privada, proxy reverso) e autenticação apropriada para seu ambiente.\n\n### Conectando o SDK ao servidor externo\n\nDepois que a CLI estiver em execução no modo de servidor, configure o cliente do SDK para se conectar a ele usando a opção \"URL da CLI\":\n\n
\n
TypeScript
\n\n```typescript\nimport { CopilotClient, approveAll } from \"@github/copilot-sdk\";\n\nconst client = new CopilotClient({\n cliUrl: \"localhost:4321\"\n});\n\n// Use the client normally\nconst session = await client.createSession({ onPermissionRequest: approveAll });\n// ...\n```\n\n
\n\n
Python
\n\n```python\nfrom copilot import CopilotClient, RuntimeConnection\nfrom copilot.session import PermissionHandler\n\nclient = CopilotClient(connection=RuntimeConnection.for_uri(\"localhost:4321\"))\nawait client.start()\n\n# Use the client normally\nsession = await client.create_session(on_permission_request=PermissionHandler.approve_all)\n# ...\n```\n\n
\n\n
Go
\n\n```golang\nimport copilot \"github.com/github/copilot-sdk/go\"\n\nclient := copilot.NewClient(&copilot.ClientOptions{\n Connection: copilot.URIConnection{URL: \"localhost:4321\"},\n})\n\nif err := client.Start(ctx); err != nil {\n log.Fatal(err)\n}\ndefer client.Stop()\n\n// Use the client normally\nsession, err := client.CreateSession(ctx, &copilot.SessionConfig{\n OnPermissionRequest: copilot.PermissionHandler.ApproveAll,\n})\n// ...\n```\n\n
\n\n
Rust
\n\n```rust\nuse std::sync::Arc;\n\nuse github_copilot_sdk::handler::ApproveAllHandler;\nuse github_copilot_sdk::{Client, ClientOptions, SessionConfig, Transport};\n\nlet mut options = ClientOptions::default();\noptions.transport = Transport::External {\n host: \"localhost\".to_string(),\n port: 4321,\n connection_token: None,\n};\nlet client = Client::start(options).await?;\n\n// Use the client normally\nlet session = client\n .create_session(SessionConfig::default().with_permission_handler(Arc::new(ApproveAllHandler)))\n .await?;\n// ...\n```\n\n
\n\n
.NET
\n\n```csharp\nusing GitHub.Copilot;\n\nusing var client = new CopilotClient(new CopilotClientOptions\n{\n Connection = RuntimeConnection.ForUri(\"localhost:4321\"),\n});\n\n// Use the client normally\nawait using var session = await client.CreateSessionAsync(new()\n{\n OnPermissionRequest = PermissionHandler.ApproveAll\n});\n// ...\n```\n\n
\n\n
Java
\n\n```java\nimport com.github.copilot.CopilotClient;\nimport com.github.copilot.rpc.*;\n\nvar client = new CopilotClient(\n new CopilotClientOptions().setCliUrl(\"localhost:4321\")\n);\nclient.start().get();\n\n// Use the client normally\nvar session = client.createSession(\n new SessionConfig().setOnPermissionRequest(PermissionHandler.APPROVE_ALL)\n).get();\n// ...\n```\n\n
\n\n
\n\n**Nota:** Quando `cli_url` / `cliUrl` /Go's `URIConnection` é fornecido ou o Rust usa `Transport::External`, o SDK não gerará ou gerenciará um processo da CLI - ele só se conectará ao servidor existente na URL especificada.\n\n## Telemetria e observabilidade\n\nO SDK do Copilot dá suporte a [OpenTelemetry](https://opentelemetry.io/) para rastreamento distribuído. Forneça ao cliente uma configuração `telemetry` para permitir a exportação de rastreamentos do processo da CLI e a propagação automática de [W3C Trace Context](https://www.w3.org/TR/trace-context/) entre o SDK e a CLI.\n\n### Habilitando a telemetria\n\nPasse uma configuração `telemetry` (ou `Telemetry`) ao criar o cliente. Essa é a aceitação— nenhum sinalizador \"habilitado\" separado é necessário.\n\n
\n
TypeScript
\n\n\n\n```typescript\nimport { CopilotClient } from \"@github/copilot-sdk\";\n\nconst client = new CopilotClient({\n telemetry: {\n otlpEndpoint: \"http://localhost:4318\",\n },\n});\n```\n\nDependência de par opcional: `@opentelemetry/api`\n\n
\n\n
Python
\n\n\n\n```python\nfrom copilot import CopilotClient, CopilotClientOptions\n\nclient = CopilotClient(CopilotClientOptions(\n telemetry={\n \"otlp_endpoint\": \"http://localhost:4318\",\n },\n))\n```\n\nInstalar com extras de telemetria: `pip install copilot-sdk[telemetry]` (fornece `opentelemetry-api`)\n\n
\n\n
Go
\n\n\n\n```golang\nclient := copilot.NewClient(&copilot.ClientOptions{\n Telemetry: &copilot.TelemetryConfig{\n OTLPEndpoint: \"http://localhost:4318\",\n },\n})\n```\n\nDependência: `go.opentelemetry.io/otel`\n\n
\n\n
Rust
\n\n\n\n```rust\nuse github_copilot_sdk::{Client, ClientOptions, OtelExporterType, TelemetryConfig};\n\nlet mut options = ClientOptions::default();\noptions.telemetry = Some(\n TelemetryConfig::new()\n .with_exporter_type(OtelExporterType::OtlpHttp)\n .with_otlp_endpoint(\"http://localhost:4318\"),\n);\nlet client = Client::start(options).await?;\n```\n\nNenhuma dependência extra — o SDK injeta variáveis de ambiente de telemetria para o processo de CLI gerado.\n\n
\n\n
.NET
\n\n\n\n```csharp\nvar client = new CopilotClient(new CopilotClientOptions\n{\n Telemetry = new TelemetryConfig\n {\n OtlpEndpoint = \"http://localhost:4318\",\n },\n});\n```\n\nNenhuma dependência extra — usa o recurso integrado `System.Diagnostics.Activity`.\n\n
\n\n
Java
\n\n\n\n```java\nimport com.github.copilot.CopilotClient;\nimport com.github.copilot.rpc.*;\n\nvar client = new CopilotClient(new CopilotClientOptions()\n .setTelemetry(new TelemetryConfig()\n .setOtlpEndpoint(\"http://localhost:4318\")));\n```\n\nDependência: `io.opentelemetry:opentelemetry-api`\n\n
\n\n
\n\n### Opções de TelemetryConfig\n\n| Opção | Node.js | Python | Go | Rust | Java | .NET | Description |\n| ------------------------- | ---------------- | ----------------- | ---------------- | ----------------- | ---------------- | ---------------- | ---------------------------------------------------------------------------- |\n| Ponto de extremidade OTLP | `otlpEndpoint` | `otlp_endpoint` | `OTLPEndpoint` | `otlp_endpoint` | `otlpEndpoint` | `OtlpEndpoint` | URL do ponto de extremidade OTLP HTTP |\n| Protocolo OTLP | `otlpProtocol` | `otlp_protocol` | `OTLPProtocol` | `otlp_protocol` | `otlpProtocol` | `OtlpProtocol` | Protocolo HTTP OTLP para todos os sinais: `\"http/json\"` ou `\"http/protobuf\"` |\n| Caminho do arquivo | `filePath` | `file_path` | `FilePath` | `file_path` | `filePath` | `FilePath` | Caminho do arquivo para saída de rastreamento de linhas JSON |\n| Tipo de exportador | `exporterType` | `exporter_type` | `ExporterType` | `exporter_type` | `exporterType` | `ExporterType` | |\n| `\"otlp-http\"` ou `\"file\"` | | | | | | | |\n| Nome de origem | `sourceName` | `source_name` | `SourceName` | `source_name` | `sourceName` | `SourceName` | Nome do escopo da instrumentação |\n| Capturar conteúdo | `captureContent` | `capture_content` | `CaptureContent` | `capture_content` | `captureContent` | `CaptureContent` | Se o conteúdo da mensagem deve ser capturado |\n\nO campo de protocolo OTLP configura o exportador `\"otlp-http\"` da CLI para todos os sinais. Deixe-o não definido para usar o padrão da CLI ou defina-o como `\"http/protobuf\"` para exportar protobuf por HTTP.\n\n### Exportação de arquivo\n\nPara gravar rastros em um arquivo local em vez de um endpoint OTLP:\n\n\n\n```typescript\nconst client = new CopilotClient({\n telemetry: {\n filePath: \"./traces.jsonl\",\n exporterType: \"file\",\n },\n});\n```\n\n### Propagação de contexto de traceamento\n\nO contexto de rastreamento é propagado automaticamente— nenhuma instrumentação manual é necessária:\n\n* **SDK → CLI**: os cabeçalhos `traceparent` e `tracestate` do span/atividade atuais são incluídos nas chamadas RPC `session.create`, `session.resume` e `session.send`.\n* **CLI → SDK**: quando a CLI invoca manipuladores de ferramentas, o contexto de rastreamento do span da CLI é propagado para que o código da ferramenta seja executado sob o span pai correto.\n\n📖\n\\*\\*\n[Instrumentação OpenTelemetry para o Copilot SDK](/pt/copilot/how-tos/copilot-sdk/observability/opentelemetry)\\*\\* — opções de TelemetryConfig, propagação de contexto de rastreamento e dependências por idioma.\n\n## Saiba mais\n\n* [Autenticação](/pt/copilot/how-tos/copilot-sdk/auth/authenticate) - GitHub OAuth, variáveis de ambiente e BYOK\n* [BYOK (Bring Your Own Key - traga sua própria chave)](/pt/copilot/how-tos/copilot-sdk/auth/byok) - Use suas próprias chaves de API de Microsoft Foundry, OpenAI etc.\n* [ Referência do SDK doNode.js](https://github.com/github/copilot-sdk/tree/main/nodejs/README.md)\n* referência do SDK [Python](https://github.com/github/copilot-sdk/tree/main/python/README.md)\n* [Referência do SDK do Go](https://github.com/github/copilot-sdk/tree/main/go/README.md)\n* [Referência do SDK do Rust](https://github.com/github/copilot-sdk/tree/main/rust/README.md)\n* [Referência do SDK .NET](https://github.com/github/copilot-sdk/tree/main/dotnet/README.md)\n* referência do SDK [Java](https://github.com/github/copilot-sdk/tree/main/java/README.md)\n* [Usando servidores MCP com o SDK do GitHub Copilot](/pt/copilot/how-tos/copilot-sdk/features/mcp) – Integrar ferramentas externas por meio do Protocolo de Contexto de Modelo\n* [Documentação do servidor MCP do GitHub](https://github.com/github/github-mcp-server)\n* [Diretório de servidores MCP](https://github.com/modelcontextprotocol/servers) – Explorar mais servidores MCP\n* [Instrumentação OpenTelemetry para o Copilot SDK](/pt/copilot/how-tos/copilot-sdk/observability/opentelemetry) - TelemetryConfig, propagação do contexto de rastreamento e dependências por idioma\n\n**Você fez isso!** Você aprendeu os principais conceitos do SDK do GitHub Copilot:\n\n* ✅ Criando um cliente e uma sessão\n* ✅ Enviar mensagens e receber respostas\n* ✅ Streaming para saída em tempo real\n* ✅ Definindo ferramentas personalizadas que o Copilot pode invocar\n\nAgora vá criar algo incrível!\n🚀"}