Copilot Sdk

GitHub Copilot SDK

Overview

The GitHub Copilot SDK exposes the same Copilot CLI agent runtime over JSON-RPC, so apps can drive Copilot programmatically instead of building their own orchestration layer.

Status: Public preview SDKs: Node.js/TypeScript, Python, Go, .NET, Java Architecture: Application -> SDK client -> JSON-RPC -> Copilot CLI

How to use this skill

When helping with the Copilot SDK:

1. Prefer the official docs index and the language-specific README over memory. 2. Treat the top-level SDK README plus docs/ as the source of truth for shared behavior. 3. Call out preview status when stability or breaking changes matter. 4. Avoid hardcoding model lists when runtime discovery via listModels() is available. 5. Watch for stale guidance around permissions, lifecycle methods, and event names.

Current source of truth

Core SDK docs

• GitHub Copilot SDK repository
• Documentation index
• Getting started guide
• Setup guides
• Local CLI setup
• Bundled CLI setup
• Backend services setup
• Scaling and multi-tenancy
• Azure Managed Identity with BYOK
• Authentication
• BYOK
• Features index
• Image input
• Steering and queueing
• OpenTelemetry instrumentation
• Troubleshooting
• SDK/CLI compatibility

Language-specific docs

• Node.js / TypeScript README
• Python README
• Go README
• .NET README
• Java SDK repository

Copilot CLI and GitHub Docs

• About GitHub Copilot CLI
• Using GitHub Copilot CLI
• Custom agents configuration reference
• Enhancing agent mode with MCP
• Supported models

Recipes and examples

• Copilot SDK cookbook
• Node.js samples
• Go samples
• .NET samples

---

High-value facts

Authentication and prerequisites

• A GitHub Copilot subscription is required for normal SDK use.
• BYOK is supported and does not require GitHub Copilot authentication.
• Node.js, Python, and .NET bundle the Copilot CLI automatically.
• Go can use an installed CLI or embed/bundle one with the go tool bundler workflow.
• Java currently lives in github/copilot-sdk-java and expects the CLI to be installed separately.
• Azure Managed Identity / Entra auth is supported as a documented BYOK pattern by passing short-lived bearer tokens from DefaultAzureCredential.

Permissions

• The SDK uses a deny-by-default permission model.
• In practice, create/resume flows should provide an explicit permission handler such as:
• TypeScript: approveAll
• Python: PermissionHandler.approve_all
• Go: copilot.PermissionHandler.ApproveAll
• .NET: PermissionHandler.ApproveAll
• Java: PermissionHandler.APPROVE_ALL

Session lifecycle

• Preferred cleanup method: disconnect()
• Deprecated cleanup method: destroy()
• To resume sessions reliably, provide your own sessionId when creating them.
• BYOK provider configuration must be provided again when resuming because keys are not persisted.

Transport and deployment

• Default transport is stdio with an SDK-managed CLI process.
• You can connect to an external headless CLI server via cliUrl.
• Current external server docs use:

copilot --headless --port 4321

Models

• Do not hardcode model support unless the user specifically needs a fixed list.
• Prefer client.listModels() and the official supported-models page.
• reasoningEffort exists for models that support it.

---

Installation

Setup and deployment choices

Pick the setup that matches the application shape:

• Local CLI - simplest path for personal tools and development.
• Bundled CLI - ship a CLI binary with your app for desktop/distributable tooling.
• Backend services - run the CLI in headless mode and connect with cliUrl.
• Scaling and multi-tenancy - shared CLI vs CLI-per-user, shared storage, and session locking.
• Azure Managed Identity - use BYOK with short-lived bearer tokens instead of static API keys when Azure auth is the real requirement.

Quick start pattern

Use the same mental model in every language:

1. Create/start the client. 2. Create a session with a permission handler. 3. Register event handlers before send() if you need streaming or progress. 4. Send with send() or sendAndWait(). 5. Wait for session.idle or the returned final message. 6. disconnect() the session and stop/dispose the client.

TypeScript example

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

const client = new CopilotClient();
await client.start();

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

session.on("assistant.message_delta", (event) => {
  process.stdout.write(event.data.deltaContent ?? "");
});

await session.sendAndWait({ prompt: "What is 2+2?" });

await session.disconnect();
await client.stop();

---

Core capabilities to remember

Client and session APIs

Common operations across SDKs:

• Client lifecycle: start(), stop(), forceStop()
• Session lifecycle: createSession(), resumeSession(), disconnect()
• Messaging: send(), sendAndWait(), abort(), getMessages()
• Discovery: listModels(), listSessions(), getStatus() / ping()

Events and streaming

• Final assistant output arrives in assistant.message.
• Streaming text arrives in assistant.message_delta.
• session.idle is the reliable "turn complete" signal.
• The event system now includes reasoning, tool progress, permission, elicitation, sub-agent, and skill events.

See references/event-system.md.

Custom tools

• Node uses defineTool(...) with Zod or raw JSON Schema.
• Python uses @define_tool with Pydantic models.
• Go prefers DefineTool(...).
• .NET uses AIFunctionFactory.Create(...).
• Overriding built-ins always requires explicit opt-in:
• TypeScript: overridesBuiltInTool: true
• Python: overrides_built_in_tool=True
• Go: OverridesBuiltInTool = true
• .NET: AdditionalProperties["is_override"] = true
• Custom tools can also opt into skipPermission.

Custom agents, MCP, hooks, and skills

• customAgents lets you define sub-agents per session.
• mcpServers attaches local or remote MCP servers.
• Hooks provide control points such as onPreToolUse, onPostToolUse, onUserPromptSubmitted, and lifecycle/error hooks.
• Skills are loaded with skillDirectories; disable selectively with disabledSkills.

See references/cli-agents-mcp.md.

Attachments, commands, and interaction

• Sessions can send file, directory, and image attachments.
• Image input supports both file and blob attachments, and vision should be checked through model capabilities.
• In-flight messaging supports mode: "immediate" for steering and mode: "enqueue" for queueing.
• The SDK can register custom slash commands.
• Apps can answer user questions with onUserInputRequest.
• Rich UI prompts are available through elicitation handlers and session.ui when the connected client supports them.

Telemetry and observability

• The SDK supports OpenTelemetry configuration through TelemetryConfig.
• Trace context propagation is built in, with Node using an explicit onGetTraceContext callback for outbound propagation.

Persistence and long-running work

• Use a stable sessionId for resumable sessions.
• Use infiniteSessions for long-running workflows that may need compaction.
• Session state is stored under ~/.copilot/session-state/ unless configuration overrides it.

SDK vs. CLI-only features

• The SDK exposes programmatic surfaces for sessions, models, plans, mode switching, workspace files, custom agents, hooks, MCP, skills, and telemetry.
• Many terminal UX features remain CLI-only, such as most slash-command workflows, interactive pickers, and export/share commands.
• When translating a CLI workflow into app code, check the compatibility guide before assuming a slash command has an SDK equivalent.

---

Language conventions

---

Common gotchas

• The SDK is public preview, so older examples drift quickly.
• Hardcoded model tables get stale; prefer runtime discovery.
• destroy() still appears in older examples but disconnect() is the current method.
• A missing permission handler causes confusion fast; treat it as required for real sessions.
• assistant.message and assistant.message_delta use event.data.*, not top-level event.content.
• Streaming/event subscriptions should be attached before send().
• Session resumption without a caller-provided sessionId is awkward to operationalize.

---

Local reference files in this skill

• references/working-examples.md - current starter examples, including tools and resume patterns
• references/event-system.md - event names, lifecycle, and language access patterns
• references/cli-agents-mcp.md - custom agents, skills, MCP, headless CLI, and config locations
• references/troubleshooting.md - common failures, debug logging, auth, permissions, and transport issues

CLI, Custom Agents, Skills, and MCP

This file covers the overlap between the Copilot SDK and Copilot CLI configuration.

First distinction: SDK config vs CLI config

There are two related but different ways to shape Copilot behavior:

1. SDK session configuration - pass options like customAgents, mcpServers, skillDirectories, disabledSkills, and hooks directly when creating a session. 2. Copilot CLI configuration - use local config files, custom agent profiles, and the CLI UI/commands.

If you are building an application on the SDK, prefer SDK session configuration first and use CLI-level config when you want reusable local behavior outside your app.

Copilot CLI config locations

By default the CLI stores config under ~/.copilot/. This location can be overridden with COPILOT_HOME.

Common files and directories:

• config.json - general CLI config
• mcp-config.json - MCP server definitions
• agents/ - user-level custom agent profiles
• session-state/ - resumable sessions, plans, and session artifacts

Headless CLI server

The SDK can manage the CLI for you, or you can connect to a separately running server.

Start a headless CLI

copilot --headless --port 4321

Connect from the SDK

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

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

const session = await client.createSession({
  onPermissionRequest: approveAll,
});

Use this when you want persistent logs, resource sharing, or a separately managed runtime.

SDK custom agents

Use customAgents in session config to define sub-agents inside your app.

TypeScript example

const session = await client.createSession({
  model: "gpt-4.1",
  onPermissionRequest: approveAll,
  customAgents: [
    {
      name: "researcher",
      displayName: "Research Agent",
      description: "Explores codebases and answers questions with read-only tools",
      tools: ["grep", "glob", "view"],
      prompt: "Analyze code and answer questions. Do not modify files.",
    },
    {
      name: "editor",
      displayName: "Editor Agent",
      description: "Makes targeted code changes",
      tools: ["view", "edit", "bash"],
      prompt: "Make minimal, surgical changes only.",
    },
  ],
});

Useful fields include:

CLI custom agent profiles

Copilot CLI also supports standalone agent profile files with YAML frontmatter and Markdown instructions.

Useful docs:

• Custom agents configuration reference
• Using GitHub Copilot CLI

Common profile fields:

Useful tool aliases in CLI docs include:

• execute
• read
• edit
• search
• agent
• web
• todo

Skills in the SDK

Skills are loaded from directories containing child folders with SKILL.md.

TypeScript example

const session = await client.createSession({
  model: "gpt-4.1",
  onPermissionRequest: approveAll,
  skillDirectories: ["./skills"],
  disabledSkills: ["deprecated-tooling"],
});

Key points:

• skillDirectories points to the parent directory.
• The runtime discovers immediate subdirectories containing SKILL.md.
• disabledSkills disables by skill name or directory name.

MCP servers

Attach MCP servers with mcpServers in session config or define them in CLI config.

Supported server shapes:

Local MCP example

const session = await client.createSession({
  model: "gpt-5",
  onPermissionRequest: approveAll,
  mcpServers: {
    filesystem: {
      type: "local",
      command: "npx",
      args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      tools: ["*"],
    },
  },
});

Remote MCP example

mcpServers: {
  github: {
    type: "http",
    url: "https://api.githubcopilot.com/mcp/",
    headers: {
      Authorization: "Bearer ${TOKEN}",
    },
    tools: ["*"],
  },
}

Tool filtering rules

• tools: ["*"] enables all tools from that server.
• tools: [] disables all tools from that server.
• tools: ["tool-a", "tool-b"] exposes only those tools.

CLI-managed MCP

The CLI includes built-in support for configuring MCP servers interactively:

/mcp add

That writes to mcp-config.json under ~/.copilot/ unless COPILOT_HOME overrides it.

The CLI also ships with the GitHub MCP server already configured, which is why GitHub repository and workflow operations are often available out of the box in Copilot CLI sessions.

When to use what

Gotchas

• SDK and CLI examples often look similar but are not the same API surface.
• MCP tools still go through permission and tool filtering.
• When a server starts but no tools appear, check tools first.
• If sub-agent behavior is inconsistent, improve agent description text and tool scoping.

Event System

The Copilot SDK emits a rich stream of session events. Event names and payloads have expanded since early preview builds, so older examples are often incomplete.

Event envelope

Every event includes the same top-level structure:

Subscription patterns

TypeScript

session.on((event) => {
  console.log(event.type, event.data);
});

session.on("assistant.message_delta", (event) => {
  process.stdout.write(event.data.deltaContent ?? "");
});

Python

from copilot.generated.session_events import SessionEventType

def handle(event):
    if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
        print(event.data.delta_content, end="", flush=True)

session.on(handle)

Go

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

.NET

session.On(evt =>
{
    if (evt is AssistantMessageDeltaEvent delta)
    {
        Console.Write(delta.Data.DeltaContent);
    }
});

Java

session.on(AssistantMessageDeltaEvent.class, event -> {
    System.out.print(event.getData().deltaContent());
});

Typical turn flow

Exact order varies, but a normal streamed turn often looks like this:

1. user.message 2. assistant.turn_start 3. assistant.intent 4. assistant.reasoning_delta / assistant.reasoning 5. assistant.message_delta 6. tool.execution_start 7. tool.execution_partial_result / tool.execution_progress 8. tool.execution_complete 9. assistant.message 10. assistant.turn_end 11. session.idle 12. session.usage_info

For a completed task you may also see session.task_complete.

High-signal event types

Assistant events

Tool events

Session lifecycle events

Permission, user input, and elicitation

Sub-agent and skill events

Other useful events

Streaming behavior

• streaming: true adds delta events such as assistant.message_delta.
• Final events like assistant.message still fire even when streaming is enabled.
• Tool partial/progress events are often ephemeral and should be treated as live UI updates, not durable history.

Data access conventions by language

Practical guidance

1. Use assistant.message_delta for live rendering. 2. Use assistant.message for the final canonical text. 3. Use session.idle to know when a turn is done. 4. Use assistant.usage for per-call accounting and session.usage_info for session totals. 5. If you need every detail for audits or replay, store the full event stream from getMessages().

Troubleshooting

Fast checklist

1. Confirm which SDK and version you are using. 2. Confirm whether the session is using normal Copilot auth or BYOK. 3. Confirm whether the client is spawning the CLI or connecting via cliUrl. 4. Turn on debug logging. 5. Check permission handling before debugging anything else.

Common failures

Permission handling

This is one of the most common sources of confusion.

• Treat permission handling as required for real application sessions.
• The SDK is deny-by-default for tool execution.
• A session can appear healthy while silently refusing the work you expected it to do.

Examples

TypeScript

const session = await client.createSession({
  onPermissionRequest: approveAll,
});

Python

session = await client.create_session(
    on_permission_request=PermissionHandler.approve_all,
)

Authentication issues

Standard Copilot auth

Supported paths include:

• Stored Copilot CLI login
• Explicit githubToken
• Environment variables such as COPILOT_GITHUB_TOKEN, GH_TOKEN, GITHUB_TOKEN

BYOK

Use a custom provider when supplying your own model credentials.

Important BYOK rules:

• model is required.
• API keys are not persisted.
• Resume requires the provider config again.
• type: "azure" and type: "openai" are not interchangeable.
• Azure Managed Identity / Entra is a documented pattern via short-lived bearerToken / bearer_token values generated outside the SDK (for example with DefaultAzureCredential).

Debug logging

Enable SDK debug logging

TypeScript

const client = new CopilotClient({
  logLevel: "debug",
});

Python

client = CopilotClient({"log_level": "debug"})

Go

client := copilot.NewClient(&copilot.ClientOptions{
    LogLevel: "debug",
})

.NET

var client = new CopilotClient(new CopilotClientOptions
{
    LogLevel = "debug"
});

CLI log directory

• Node.js and .NET can pass CLI args such as --log-dir.
• Python can pass CLI flags via SubprocessConfig(..., cli_args=[...]).
• Go and Java are more limited here; use a separately managed headless CLI if you need custom CLI logging.

Transport issues

The default transport is stdio. If you are debugging startup or sharing a server, switch mentally to the headless/TCP model.

Start a headless CLI

copilot --headless --port 4321

Connect to it

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

If cliUrl is wrong, you will get connection failures that look unrelated to your app logic.

Event handling mistakes

• assistant.message is the final assistant output.
• assistant.message_delta is only a chunk.
• session.idle is the cleanest completion signal.
• Usage lives in assistant.usage and session.usage_info, not just the final message.

Resume and persistence mistakes

• If you do not supply a meaningful sessionId, operational resume is clumsy.
• disconnect() preserves session state on disk.
• deleteSession() removes it permanently.
• Resumable state lives under ~/.copilot/session-state/ unless config overrides it.

MCP debugging hints

1. Run the MCP server command independently first. 2. Check whether the server supports the expected transport. 3. Verify auth headers or environment variables. 4. Set tools: ["*"] while debugging. 5. Watch for permission denials after the tool appears.

Platform-specific notes

macOS

• GUI applications may not inherit your shell PATH; set cliPath explicitly if needed.

Windows

• Use explicit executable paths if PATH resolution is inconsistent.

Linux

• Verify execute permissions and shared-library dependencies if the CLI fails to launch.

Packaging note for Go

The Go SDK also supports bundling the CLI with go get -tool github.com/github/copilot-sdk/go/cmd/bundler followed by go tool bundler. If your Go app is distributed rather than run only on developer machines, do not assume a global copilot install is the only option.

Good default debugging sequence

1. Enable debug logging. 2. Swap to a trivial prompt like What is 2+2?. 3. Use approveAll temporarily. 4. Remove MCP and custom tools until the base session works. 5. Add features back one by one.

Working Examples

Before you start

• Use an explicit permission handler for real sessions.
• Register streaming/event handlers before send().
• Prefer disconnect() over destroy().
• If you want resumable sessions, provide your own sessionId.

Minimal chat examples

TypeScript / Node.js

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

const client = new CopilotClient();
await client.start();

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

session.on("assistant.message_delta", (event) => {
  process.stdout.write(event.data.deltaContent ?? "");
});

await session.sendAndWait({ prompt: "What is 2+2?" });

await session.disconnect();
await client.stop();

Python

import asyncio
from copilot import CopilotClient
from copilot.session import PermissionHandler

async def main():
    async with CopilotClient() as client:
        session = await client.create_session(
            model="gpt-5",
            streaming=True,
            on_permission_request=PermissionHandler.approve_all,
        )

        def on_event(event):
            if event.type.value == "assistant.message_delta":
                print(event.data.delta_content or "", end="", flush=True)

        session.on(on_event)
        await session.send_and_wait("What is 2+2?")
        await session.disconnect()

asyncio.run(main())

Go

package main

import (
    "context"
    "fmt"
    "log"

    copilot "github.com/github/copilot-sdk/go"
)

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

    session, err := client.CreateSession(ctx, &copilot.SessionConfig{
        Model:               "gpt-5",
        Streaming:           true,
        OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
    })
    if err != nil {
        log.Fatal(err)
    }
    defer session.Disconnect()

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

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

.NET

using GitHub.Copilot.SDK;

await using var client = new CopilotClient();
await client.StartAsync();

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

session.On(evt =>
{
    if (evt is AssistantMessageDeltaEvent delta)
    {
        Console.Write(delta.Data.DeltaContent);
    }
});

await session.SendAndWaitAsync(new MessageOptions
{
    Prompt = "What is 2+2?"
});

Java

import com.github.copilot.sdk.CopilotClient;
import com.github.copilot.sdk.events.AssistantMessageDeltaEvent;
import com.github.copilot.sdk.json.MessageOptions;
import com.github.copilot.sdk.json.PermissionHandler;
import com.github.copilot.sdk.json.SessionConfig;

try (var client = new CopilotClient()) {
    client.start().get();

    var session = client.createSession(
        new SessionConfig()
            .setModel("claude-sonnet-4.5")
            .setStreaming(true)
            .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
    ).get();

    session.on(AssistantMessageDeltaEvent.class, event ->
        System.out.print(event.getData().deltaContent())
    );

    session.sendAndWait(new MessageOptions().setPrompt("What is 2+2?")).get();
}

Custom tool examples

TypeScript

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

const client = new CopilotClient();
await client.start();

const session = await client.createSession({
  model: "gpt-5",
  onPermissionRequest: approveAll,
  tools: [
    defineTool("lookup_issue", {
      description: "Fetch issue details from our tracker",
      parameters: z.object({
        id: z.string().describe("Issue identifier"),
      }),
      handler: async ({ id }) => ({ id, status: "open" }),
    }),
  ],
});

Python

from pydantic import BaseModel, Field
from copilot import define_tool

class IssueParams(BaseModel):
    id: str = Field(description="Issue identifier")

@define_tool(description="Fetch issue details from our tracker")
async def lookup_issue(params: IssueParams) -> dict:
    return {"id": params.id, "status": "open"}

Go

type IssueParams struct {
    ID string `json:"id" jsonschema:"Issue identifier"`
}

lookupIssue := copilot.DefineTool(
    "lookup_issue",
    "Fetch issue details from our tracker",
    func(params IssueParams, inv copilot.ToolInvocation) (any, error) {
        return map[string]string{"id": params.ID, "status": "open"}, nil
    },
)

.NET

using Microsoft.Extensions.AI;

var lookupIssue = AIFunctionFactory.Create(
    (string id) => new { Id = id, Status = "open" },
    "lookup_issue",
    "Fetch issue details from our tracker"
);

Java

// Java SDK support lives in github/copilot-sdk-java.
// Follow its current documentation for tool wiring and event classes:
// https://github.com/github/copilot-sdk-java

Resume example

TypeScript

const session = await client.createSession({
  sessionId: "user-123-review-42",
  model: "gpt-5.2-codex",
  onPermissionRequest: approveAll,
});

await session.sendAndWait({ prompt: "Review the repository" });
await session.disconnect();

const resumed = await client.resumeSession("user-123-review-42", {
  onPermissionRequest: approveAll,
});

await resumed.sendAndWait({ prompt: "Continue from where you left off" });

Important resume note for BYOK

If the session uses a custom provider, pass that provider again when resuming. API keys and bearer tokens are not persisted to disk.

Small but important current rules

Overriding a built-in tool requires explicit opt-in

TypeScript

import { z } from "zod";
import { defineTool } from "@github/copilot-sdk";

defineTool("edit_file", {
  description: "Custom editor",
  parameters: z.object({ path: z.string(), content: z.string() }),
  overridesBuiltInTool: true,
  handler: async () => "ok",
});

Python

from pydantic import BaseModel, Field
from copilot import define_tool

class EditFileParams(BaseModel):
    path: str = Field(description="File path")
    content: str = Field(description="New file content")

@define_tool(
    name="edit_file",
    description="Custom editor",
    overrides_built_in_tool=True,
)
async def edit_file(params: EditFileParams) -> str:
    return "ok"

Go

type EditFileParams struct {
    Path string `json:"path" jsonschema:"File path"`
    Content string `json:"content" jsonschema:"New file content"`
}

editFile := copilot.DefineTool("edit_file", "Custom editor",
    func(params EditFileParams, inv copilot.ToolInvocation) (any, error) {
        return "ok", nil
    })
editFile.OverridesBuiltInTool = true

.NET

using Microsoft.Extensions.AI;
using System.Collections.Generic;

var editFile = AIFunctionFactory.Create(
    (string path, string content) => "ok",
    "edit_file",
    "Custom editor",
    new AIFunctionFactoryOptions
    {
        AdditionalProperties = new Dictionary<string, object?> { ["is_override"] = true }
    }
);

Other advanced patterns worth remembering

• Image input supports file and blob attachments; vision-capable models are required.
• Mid-turn steering uses mode: "immediate" and queueing uses mode: "enqueue".
• Telemetry uses TelemetryConfig and can export to OTLP or file.