copilot-sdk

Name: copilot-sdk
Author: github

GitHub Copilot SDK

在任何應用程式中嵌入 Copilot 的代理工作流程，支援 Python、TypeScript、Go 或 .NET。

概覽

GitHub Copilot SDK 公開了 Copilot CLI 背後的相同引擎：一個經過生產測試的代理執行環境，您可以透過程式方式呼叫。無需自行建構編排邏輯——您定義代理行為，Copilot 負責規劃、工具呼叫、檔案編輯等。

先決條件

安裝並驗證 GitHub Copilot CLI（安裝指南）
語言執行環境：Node.js 18+、Python 3.8+、Go 1.21+ 或 .NET 8.0+

驗證 CLI：copilot --version

安裝

Node.js/TypeScript

mkdir copilot-demo && cd copilot-demo
npm init -y --init-type module
npm install @github/copilot-sdk tsx

Python

pip install github-copilot-sdk

Go

mkdir copilot-demo && cd copilot-demo
go mod init copilot-demo
go get github.com/github/copilot-sdk/go

.NET

dotnet new console -n CopilotDemo && cd CopilotDemo
dotnet add package GitHub.Copilot.SDK

快速開始

TypeScript

import { CopilotClient, approveAll } from "@github/copilot-sdk";

const client = new CopilotClient();
const session = await client.createSession({
    onPermissionRequest: approveAll,
    model: "gpt-4.1",
});

const response = await session.sendAndWait({ prompt: "What is 2 + 2?" });
console.log(response?.data.content);

await client.stop();
process.exit(0);

執行：npx tsx index.ts

Python

import asyncio
from copilot import CopilotClient, PermissionHandler

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({
        "on_permission_request": PermissionHandler.approve_all,
        "model": "gpt-4.1",
    })
    response = await session.send_and_wait({"prompt": "What is 2 + 2?"})

    print(response.data.content)
    await client.stop()

asyncio.run(main())

Go

package main

import (
    "fmt"
    "log"
    "os"
    copilot "github.com/github/copilot-sdk/go"
)

func main() {
    client := copilot.NewClient(nil)
    if err := client.Start(); err != nil {
        log.Fatal(err)
    }
    defer client.Stop()

    session, err := client.CreateSession(&copilot.SessionConfig{
        OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
        Model:               "gpt-4.1",
    })
    if err != nil {
        log.Fatal(err)
    }

    response, err := session.SendAndWait(copilot.MessageOptions{Prompt: "What is 2 + 2?"}, 0)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(*response.Data.Content)
    os.Exit(0)
}

.NET (C#)

using GitHub.Copilot.SDK;

await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig
{
    OnPermissionRequest = PermissionHandler.ApproveAll,
    Model = "gpt-4.1",
});

var response = await session.SendAndWaitAsync(new MessageOptions { Prompt = "What is 2 + 2?" });
Console.WriteLine(response?.Data.Content);

執行：dotnet run

串流回應

啟用即時輸出以獲得更好的使用者體驗：

TypeScript

import { CopilotClient, approveAll, SessionEvent } from "@github/copilot-sdk";

const client = new CopilotClient();
const session = await client.createSession({
    onPermissionRequest: approveAll,
    model: "gpt-4.1",
    streaming: true,
});

session.on((event: SessionEvent) => {
    if (event.type === "assistant.message_delta") {
        process.stdout.write(event.data.deltaContent);
    }
    if (event.type === "session.idle") {
        console.log(); // New line when done
    }
});

await session.sendAndWait({ prompt: "Tell me a short joke" });

await client.stop();
process.exit(0);

Python

import asyncio
import sys
from copilot import CopilotClient, PermissionHandler
from copilot.generated.session_events import SessionEventType

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({
        "on_permission_request": PermissionHandler.approve_all,
        "model": "gpt-4.1",
        "streaming": True,
    })

    def handle_event(event):
        if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
            sys.stdout.write(event.data.delta_content)
            sys.stdout.flush()
        if event.type == SessionEventType.SESSION_IDLE:
            print()

    session.on(handle_event)
    await session.send_and_wait({"prompt": "Tell me a short joke"})
    await client.stop()

asyncio.run(main())

Go

session, err := client.CreateSession(&copilot.SessionConfig{
	OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
    Model:     "gpt-4.1",
    Streaming: true,
})

session.On(func(event copilot.SessionEvent) {
    if event.Type == "assistant.message_delta" {
        fmt.Print(*event.Data.DeltaContent)
    }
    if event.Type == "session.idle" {
        fmt.Println()
    }
})

_, err = session.SendAndWait(copilot.MessageOptions{Prompt: "Tell me a short joke"}, 0)

.NET

await using var session = await client.CreateSessionAsync(new SessionConfig
{
    OnPermissionRequest = PermissionHandler.ApproveAll,
    Model = "gpt-4.1",
    Streaming = true,
});

session.On(ev =>
{
    if (ev is AssistantMessageDeltaEvent deltaEvent)
        Console.Write(deltaEvent.Data.DeltaContent);
    if (ev is SessionIdleEvent)
        Console.WriteLine();
});

await session.SendAndWaitAsync(new MessageOptions { Prompt = "Tell me a short joke" });

自訂工具

定義 Copilot 在推理過程中可以呼叫的工具。當您定義工具時，您告訴 Copilot：

工具的功能（描述）
需要的參數（結構）
要執行的程式碼（處理器）

TypeScript (JSON Schema)

import { CopilotClient, approveAll, defineTool, SessionEvent } from "@github/copilot-sdk";

const getWeather = defineTool("get_weather", {
    description: "Get the current weather for a city",
    parameters: {
        type: "object",
        properties: {
            city: { type: "string", description: "The city name" },
        },
        required: ["city"],
    },
    handler: async (args: { city: string }) => {
        const { city } = args;
        // In a real app, call a weather API here
        const conditions = ["sunny", "cloudy", "rainy", "partly cloudy"];
        const temp = Math.floor(Math.random() * 30) + 50;
        const condition = conditions[Math.floor(Math.random() * conditions.length)];
        return { city, temperature: `${temp}°F`, condition };
    },
});

const client = new CopilotClient();
const session = await client.createSession({
    onPermissionRequest: approveAll,
    model: "gpt-4.1",
    streaming: true,
    tools: [getWeather],
});

session.on((event: SessionEvent) => {
    if (event.type === "assistant.message_delta") {
        process.stdout.write(event.data.deltaContent);
    }
});

await session.sendAndWait({
    prompt: "What's the weather like in Seattle and Tokyo?",
});

await client.stop();
process.exit(0);

Python (Pydantic)

import asyncio
import random
import sys
from copilot import CopilotClient, PermissionHandler
from copilot.tools import define_tool
from copilot.generated.session_events import SessionEventType
from pydantic import BaseModel, Field

class GetWeatherParams(BaseModel):
    city: str = Field(description="The name of the city to get weather for")

@define_tool(description="Get the current weather for a city")
async def get_weather(params: GetWeatherParams) -> dict:
    city = params.city
    conditions = ["sunny", "cloudy", "rainy", "partly cloudy"]
    temp = random.randint(50, 80)
    condition = random.choice(conditions)
    return {"city": city, "temperature": f"{temp}°F", "condition": condition}

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({
        "on_permission_request": PermissionHandler.approve_all,
        "model": "gpt-4.1",
        "streaming": True,
        "tools": [get_weather],
    })

    def handle_event(event):
        if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
            sys.stdout.write(event.data.delta_content)
            sys.stdout.flush()

    session.on(handle_event)

    await session.send_and_wait({
        "prompt": "What's the weather like in Seattle and Tokyo?"
    })

    await client.stop()

asyncio.run(main())

Go

type WeatherParams struct {
    City string `json:"city" jsonschema:"The city name"`
}

type WeatherResult struct {
    City        string `json:"city"`
    Temperature string `json:"temperature"`
    Condition   string `json:"condition"`
}

getWeather := copilot.DefineTool(
    "get_weather",
    "Get the current weather for a city",
    func(params WeatherParams, inv copilot.ToolInvocation) (WeatherResult, error) {
        conditions := []string{"sunny", "cloudy", "rainy", "partly cloudy"}
        temp := rand.Intn(30) + 50
        condition := conditions[rand.Intn(len(conditions))]
        return WeatherResult{
            City:        params.City,
            Temperature: fmt.Sprintf("%d°F", temp),
            Condition:   condition,
        }, nil
    },
)

session, _ := client.CreateSession(&copilot.SessionConfig{
	OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
    Model:     "gpt-4.1",
    Streaming: true,
    Tools:     []copilot.Tool{getWeather},
})

.NET (Microsoft.Extensions.AI)

using GitHub.Copilot.SDK;
using Microsoft.Extensions.AI;
using System.ComponentModel;

var getWeather = AIFunctionFactory.Create(
    ([Description("The city name")] string city) =>
    {
        var conditions = new[] { "sunny", "cloudy", "rainy", "partly cloudy" };
        var temp = Random.Shared.Next(50, 80);
        var condition = conditions[Random.Shared.Next(conditions.Length)];
        return new { city, temperature = $"{temp}°F", condition };
    },
    "get_weather",
    "Get the current weather for a city"
);

await using var session = await client.CreateSessionAsync(new SessionConfig
{
    OnPermissionRequest = PermissionHandler.ApproveAll,
    Model = "gpt-4.1",
    Streaming = true,
    Tools = [getWeather],
});

工具運作方式

當 Copilot 決定呼叫您的工具時：

Copilot 發送工具呼叫請求，包含參數
SDK 執行您的處理器函式
結果回傳給 Copilot
Copilot 將結果納入回應中

Copilot 會根據使用者的問題和工具的描述，決定何時呼叫您的工具。

互動式 CLI 助手

建立完整的互動式助手：

TypeScript

import { CopilotClient, approveAll, defineTool, SessionEvent } from "@github/copilot-sdk";
import * as readline from "readline";

const getWeather = defineTool("get_weather", {
    description: "Get the current weather for a city",
    parameters: {
        type: "object",
        properties: {
            city: { type: "string", description: "The city name" },
        },
        required: ["city"],
    },
    handler: async ({ city }) => {
        const conditions = ["sunny", "cloudy", "rainy", "partly cloudy"];
        const temp = Math.floor(Math.random() * 30) + 50;
        const condition = conditions[Math.floor(Math.random() * conditions.length)];
        return { city, temperature: `${temp}°F`, condition };
    },
});

const client = new CopilotClient();
const session = await client.createSession({
    onPermissionRequest: approveAll,
    model: "gpt-4.1",
    streaming: true,
    tools: [getWeather],
});

session.on((event: SessionEvent) => {
    if (event.type === "assistant.message_delta") {
        process.stdout.write(event.data.deltaContent);
    }
});

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
});

console.log("Weather Assistant (type 'exit' to quit)");
console.log("Try: 'What's the weather in Paris?'\n");

const prompt = () => {
    rl.question("You: ", async (input) => {
        if (input.toLowerCase() === "exit") {
            await client.stop();
            rl.close();
            return;
        }

        process.stdout.write("Assistant: ");
        await session.sendAndWait({ prompt: input });
        console.log("\n");
        prompt();
    });
};

prompt();

Python

import asyncio
import random
import sys
from copilot import CopilotClient, PermissionHandler
from copilot.tools import define_tool
from copilot.generated.session_events import SessionEventType
from pydantic import BaseModel, Field

class GetWeatherParams(BaseModel):
    city: str = Field(description="The name of the city to get weather for")

@define_tool(description="Get the current weather for a city")
async def get_weather(params: GetWeatherParams) -> dict:
    conditions = ["sunny", "cloudy", "rainy", "partly cloudy"]
    temp = random.randint(50, 80)
    condition = random.choice(conditions)
    return {"city": params.city, "temperature": f"{temp}°F", "condition": condition}

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({
        "on_permission_request": PermissionHandler.approve_all,
        "model": "gpt-4.1",
        "streaming": True,
        "tools": [get_weather],
    })

    def handle_event(event):
        if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
            sys.stdout.write(event.data.delta_content)
            sys.stdout.flush()

    session.on(handle_event)

    print("Weather Assistant (type 'exit' to quit)")
    print("Try: 'What's the weather in Paris?'\n")

    while True:
        try:
            user_input = input("You: ")
        except EOFError:
            break

        if user_input.lower() == "exit":
            break

        sys.stdout.write("Assistant: ")
        await session.send_and_wait({"prompt": user_input})
        print("\n")

    await client.stop()

asyncio.run(main())

MCP 伺服器整合

連線至 MCP（模型上下文協定）伺服器以使用預建工具。連線至 GitHub 的 MCP 伺服器以存取儲存庫、議題和 PR：

TypeScript

const session = await client.createSession({
    onPermissionRequest: approveAll,
    model: "gpt-4.1",
    mcpServers: {
        github: {
            type: "http",
            url: "https://api.githubcopilot.com/mcp/",
        },
    },
});

Python

session = await client.create_session({
    "on_permission_request": PermissionHandler.approve_all,
    "model": "gpt-4.1",
    "mcp_servers": {
        "github": {
            "type": "http",
            "url": "https://api.githubcopilot.com/mcp/",
        },
    },
})

Go

session, _ := client.CreateSession(&copilot.SessionConfig{
	OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
    Model: "gpt-4.1",
    MCPServers: map[string]copilot.MCPServerConfig{
        "github": {
            "type": "http",
            "url": "https://api.githubcopilot.com/mcp/",
        },
    },
})

.NET

await using var session = await client.CreateSessionAsync(new SessionConfig
{
    OnPermissionRequest = PermissionHandler.ApproveAll,
    Model = "gpt-4.1",
    McpServers = new Dictionary<string, McpServerConfig>
    {
        ["github"] = new McpServerConfig
        {
            Type = "http",
            Url = "https://api.githubcopilot.com/mcp/",
        },
    },
});

自訂代理

為特定任務定義專門的 AI 角色：

TypeScript

const session = await client.createSession({
    onPermissionRequest: approveAll,
    model: "gpt-4.1",
    customAgents: [{
        name: "pr-reviewer",
        displayName: "PR Reviewer",
        description: "Reviews pull requests for best practices",
        prompt: "You are an expert code reviewer. Focus on security, performance, and maintainability.",
    }],
});

Python

session = await client.create_session({
    "on_permission_request": PermissionHandler.approve_all,
    "model": "gpt-4.1",
    "custom_agents": [{
        "name": "pr-reviewer",
        "display_name": "PR Reviewer",
        "description": "Reviews pull requests for best practices",
        "prompt": "You are an expert code reviewer. Focus on security, performance, and maintainability.",
    }],
})

系統訊息

自訂 AI 的行為和個性：

TypeScript

const session = await client.createSession({
    onPermissionRequest: approveAll,
    model: "gpt-4.1",
    systemMessage: {
        content: "You are a helpful assistant for our engineering team. Always be concise.",
    },
});

Python

session = await client.create_session({
    "on_permission_request": PermissionHandler.approve_all,
    "model": "gpt-4.1",
    "system_message": {
        "content": "You are a helpful assistant for our engineering team. Always be concise.",
    },
})

外部 CLI 伺服器

將 CLI 以伺服器模式單獨執行，並將 SDK 連線至該伺服器。適用於除錯、資源共享或自訂環境。

以伺服器模式啟動 CLI

copilot --server --port 4321

將 SDK 連線至外部伺服器

TypeScript

const client = new CopilotClient({
    cliUrl: "localhost:4321"
});

const session = await client.createSession({
    onPermissionRequest: approveAll,
    model: "gpt-4.1",
});

Python

client = CopilotClient({
    "cli_url": "localhost:4321"
})
await client.start()

session = await client.create_session({
    "on_permission_request": PermissionHandler.approve_all,
    "model": "gpt-4.1",
})

Go

client := copilot.NewClient(&copilot.ClientOptions{
    CLIUrl: "localhost:4321",
})

if err := client.Start(); err != nil {
    log.Fatal(err)
}

session, _ := client.CreateSession(&copilot.SessionConfig{
	OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
	Model:               "gpt-4.1",
})

.NET

using var client = new CopilotClient(new CopilotClientOptions
{
    CliUrl = "localhost:4321"
});

await using var session = await client.CreateSessionAsync(new SessionConfig
{
    OnPermissionRequest = PermissionHandler.ApproveAll,
    Model = "gpt-4.1",
});

注意： 當提供 cliUrl 時，SDK 不會啟動或管理 CLI 程序——它只會連線至現有的伺服器。

事件類型

事件	描述
`user.message`	使用者輸入已新增
`assistant.message`	完整的模型回應
`assistant.message_delta`	串流回應區塊
`assistant.reasoning`	模型推理（依模型而定）
`assistant.reasoning_delta`	串流推理區塊
`tool.execution_start`	工具呼叫已開始
`tool.execution_complete`	工具執行已完成
`session.idle`	無進行中的處理
`session.error`	發生錯誤

用戶端設定

選項	描述	預設值
`cliPath`	Copilot CLI 可執行檔的路徑	系統 PATH
`cliUrl`	連線至現有伺服器（例如 "localhost:4321"）	無
`port`	伺服器通訊埠	隨機
`useStdio`	使用 stdio 傳輸而非 TCP	true
`logLevel`	記錄詳細程度	"info"
`autoStart`	自動啟動伺服器	true
`autoRestart`	當機時自動重新啟動	true
`cwd`	CLI 程序的工作目錄	繼承

工作階段設定

選項	描述
`model`	使用的 LLM（"gpt-4.1"、"claude-sonnet-4.5" 等）
`sessionId`	自訂工作階段識別碼
`tools`	自訂工具定義
`mcpServers`	MCP 伺服器連線
`customAgents`	自訂代理角色
`systemMessage`	覆寫預設系統提示
`streaming`	啟用增量回應區塊
`availableTools`	允許的工具白名單
`excludedTools`	停用的工具黑名單

工作階段持久化

在重新啟動之間儲存和恢復對話：

使用自訂 ID 建立

const session = await client.createSession({
    onPermissionRequest: approveAll,
    sessionId: "user-123-conversation",
    model: "gpt-4.1"
});

恢復工作階段

const session = await client.resumeSession("user-123-conversation", { onPermissionRequest: approveAll });
await session.send({ prompt: "What did we discuss earlier?" });

列出和刪除工作階段

const sessions = await client.listSessions();
await client.deleteSession("old-session-id");

錯誤處理

try {
    const client = new CopilotClient();
    const session = await client.createSession({
        onPermissionRequest: approveAll,
        model: "gpt-4.1",
    });
    const response = await session.sendAndWait(
        { prompt: "Hello!" },
        30000 // timeout in ms
    );
} catch (error) {
    if (error.code === "ENOENT") {
        console.error("Copilot CLI not installed");
    } else if (error.code === "ECONNREFUSED") {
        console.error("Cannot connect to Copilot server");
    } else {
        console.error("Error:", error.message);
    }
} finally {
    await client.stop();
}

優雅關閉

process.on("SIGINT", async () => {
    console.log("Shutting down...");
    await client.stop();
    process.exit(0);
});

常見模式

多輪對話

const session = await client.createSession({
    onPermissionRequest: approveAll,
    model: "gpt-4.1",
});

await session.sendAndWait({ prompt: "My name is Alice" });
await session.sendAndWait({ prompt: "What's my name?" });
// Response: "Your name is Alice"

檔案附件

await session.send({
    prompt: "Analyze this file",
    attachments: [{
        type: "file",
        path: "./data.csv",
        displayName: "Sales Data"
    }]
});

中止長時間操作

const timeoutId = setTimeout(() => {
    session.abort();
}, 60000);

session.on((event) => {
    if (event.type === "session.idle") {
        clearTimeout(timeoutId);
    }
});

可用模型

在執行時查詢可用模型：

const models = await client.getModels();
// Returns: ["gpt-4.1", "gpt-4o", "claude-sonnet-4.5", ...]

最佳實踐

務必清理：使用 try-finally 或 defer 確保 client.stop() 被呼叫
設定逾時：對長時間操作使用 sendAndWait 搭配逾時
處理事件：訂閱錯誤事件以實現穩健的錯誤處理
使用串流：啟用串流以獲得長時間回應的更好使用者體驗
持久化工作階段：對多輪對話使用自訂工作階段 ID
定義清晰工具：撰寫描述性的工具名稱和描述

架構

您的應用程式
       |
  SDK 用戶端
       | JSON-RPC
  Copilot CLI（伺服器模式）
       |
  GitHub（模型、驗證）

SDK 會自動管理 CLI 程序的生命週期。所有通訊透過 JSON-RPC 經由 stdio 或 TCP 進行。

資源

GitHub 儲存庫：https://github.com/github/copilot-sdk
入門教學：https://github.com/github/copilot-sdk/blob/main/docs/tutorials/first-app.md
GitHub MCP 伺服器：https://github.com/github/github-mcp-server
MCP 伺服器目錄：https://github.com/modelcontextprotocol/servers
食譜：https://github.com/github/copilot-sdk/tree/main/cookbook
範例：https://github.com/github/copilot-sdk/tree/main/samples

狀態

此 SDK 處於技術預覽階段，可能會有重大變更。目前不建議用於生產環境。

您可能也喜歡

cloudflare-one

2.2Kmcp-integrations

Guides Cloudflare One Zero Trust and SASE work across Access, Gateway, WARP, Tunnel, Cloudflare WAN, DLP, CASB, device posture, and identity. Use when designing, configuring, troubleshooting, or reviewing Cloudflare One deployments. Retrieval-first: use current Cloudflare docs/API schemas instead of embedded product docs.

cloudflare

獲取

stripe-best-practices

1.6Kmcp-integrations

引導 Stripe 整合決策 — API 選擇（Checkout Sessions 與 PaymentIntents）、Connect 平台設定（Accounts v2、控制器屬性）、帳單/訂閱、Treasury 金融帳戶、整合介面（Checkout、Payment Element）、從已棄用 Stripe API 遷移，以及安全最佳實務（API 金鑰管理、受限金鑰、Webhook、OAuth）。在建立、修改或審查任何 Stripe 整合時使用 — 包括收款、建立市集、整合 Stripe、處理付款、設定訂閱、建立關聯帳戶，或實作安全金鑰處理。

stripe

獲取

azure-storage

1.2Kmcp-integrations

Azure 儲存體服務，包括 Blob 儲存體、檔案共用、佇列儲存體、資料表儲存體和 Data Lake。回答關於儲存存取層（熱、酷、冷、封存）、何時使用各層以及層級比較的問題。提供物件儲存、SMB 檔案共用、非同步訊息、NoSQL 鍵值和大數據分析。包含生命週期管理。適用於：blob 儲存體、檔案共用、佇列儲存體、資料表儲存體、data lake、上傳檔案、下載 blob、儲存體帳戶、存取層、儲存層、熱酷冷封存、儲存層比較、何時使用儲存層、生命週期管理、Azure 儲存體概念。不適用於：SQL 資料庫、Cosmos DB（請使用 azure-prepare）、Event Hubs 或 Service Bus 的訊息（請使用 azure-messaging）。

microsoft

獲取

繼續探索

瀏覽 mcp-integrations 熱門 Skills 最近更新

copilot-sdk

相關技能

GitHub Copilot SDK

概覽

先決條件

安裝

Node.js/TypeScript

Python

Go

.NET

快速開始

TypeScript

Python

Go

.NET (C#)

串流回應

TypeScript

Python

Go

.NET

自訂工具

TypeScript (JSON Schema)

Python (Pydantic)

Go

.NET (Microsoft.Extensions.AI)

工具運作方式

互動式 CLI 助手

TypeScript

Python

MCP 伺服器整合

TypeScript

Python

Go

.NET

自訂代理

TypeScript

Python

系統訊息

TypeScript

Python

外部 CLI 伺服器

以伺服器模式啟動 CLI

將 SDK 連線至外部伺服器

TypeScript

Python

Go

.NET

事件類型

用戶端設定

工作階段設定

工作階段持久化

使用自訂 ID 建立

恢復工作階段

列出和刪除工作階段

錯誤處理

優雅關閉

常見模式

多輪對話

檔案附件

中止長時間操作

可用模型

最佳實踐

架構

資源

狀態

您可能也喜歡

cloudflare-one

stripe-best-practices

azure-storage

繼續探索