github-copilot-sdk

Other changes

• improvement: [C#] add a custom session event JSON converter and updated generated session event types for Copilot CLI 1.0.92-2 (5b2d7cd)
• improvement: update the bundled Copilot CLI version to 1.0.92-2

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Notes Generator · copilot · auto · 17.5 AIC · ⌖ 6.05 AIC · ⊞ 10.4K

Full Changelog: v1.0.16...v1.0.17-preview.1

Internal dependency updates only: this release refreshes the SDK snapshot for Copilot CLI 1.0.90. It contains no other user-visible SDK changes since v1.0.15.

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Notes Generator · copilot · auto · 18.8 AIC · ⌖ 6.11 AIC · ⊞ 10.3K

Internal dependency updates only (SDK snapshot updated for Copilot CLI 1.0.90-6).

Full Changelog: runtime-1.0.89-1.unstable.r36638597907.ge270afd...v1.0.16-preview.0

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Notes Generator · copilot · auto · 23.7 AIC · ⌖ 5.81 AIC · ⊞ 10.3K

Feature: typed structured outputs for all six SDKs

Provide a JSON Schema, or use an idiomatic typed helper, to have the model return typed, validated output instead of free-form text. (#2590)

const answerSchema = z.object({ value: z.number().int() });
const answer = await session.sendAndWait("What is 19 + 23?", answerSchema);

answer = await session.send_and_wait_typed("What is 19 + 23?", Answer)

Go, Java, C#, and Rust get the same capability via copilot.SendAndWait[Answer], session.sendAndWait(prompt, Answer.class), SendAndWaitAsync<Answer>, and session.send_and_wait_typed(prompt).

Feature: structured JSON-RPC error data in all SDKs

The raw JSON data payload of a JSON-RPC error response can now be inspected in every SDK, so apps can branch on machine-readable error details. (#2664, #2732)

if let Some(data) = error.rpc_data() { println!("{data}"); }

catch (JsonRpcException e) { JsonNode data = e.getData(); }

Feature: experimental connection-global installation confirmation

All six SDKs expose a connection-global handler for the runtime's installations.confirm callback, letting apps present a human review before an MCP or Skill installation proceeds. The handler must return an explicit confirm/decline/cancel decision.

const client = new CopilotClient({
  installationConfirmationHandler: async (request, context) => promptUser(request),
});

Java, Python, Rust, C#, and Go get equivalent options (setInstallationConfirmationHandler, installation_confirmation_handler, with_installation_confirmation_handler, InstallationConfirmationHandler). Java also now exposes typed unions for MCP installation review payloads.

Other changes

• feature: [Java] add native runtime support for darwin-x64 (#2701)
• feature: [Java] add native runtime support for linuxmusl-x64 (Alpine) (#2715)
• feature: [Java] experimental FusionCritic generated diagnostics type
• improvement: [Node/Python/Go/.NET/Java] coalesce intercepted HTTP response chunks for better tool-call streaming throughput (#2734)
• improvement: [Rust] coalesce intercepted HTTP response chunks (#2717)
• improvement: [Rust] avoid rebuilding and copying JSON payloads (#2711)
• improvement: [Rust] cut retained runtime-install memory by ~99% (#2676)
• improvement: [.NET] avoid redundant JSON event materialization and reduce allocations (#2733)
• improvement: [Node] pin production dependencies to exact versions with a publish-age policy (#2700)
• bugfix: preserve image replay compatibility across CLI image limits (#2670)

New contributors

• @mohamedmansour made their first contribution in #2676
• @roblourens made their first contribution in #2700

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Notes Generator · copilot · auto · 17.1 AIC · ⌖ 6.46 AIC · ⊞ 9K

Feature: experimental connection-global installation confirmation

All six SDKs now expose a connection-global handler for the runtime's installations.confirm callback, letting apps present a human review before an MCP or Skill installation proceeds. The handler receives the generated request plus a cancellation signal that fires when the review is retired or the connection closes, and must return an explicit confirm/decline/cancel decision — the SDK never infers approval.

const client = new CopilotClient({
  installationConfirmationHandler: async (request, context) => {
    return await promptUser(request); // "confirm" | "decline" | "cancel"
  },
});

var options = new CopilotClientOptions
{
    InstallationConfirmationHandler = async (request, context) =>
        await PromptUserAsync(request, context.CancellationToken),
};

opts := copilot.ClientOptions{
    InstallationConfirmationHandler: func(ctx context.Context, req *copilot.InstallationConfirmationRequest) (copilot.InstallationConfirmationDecision, error) {
        return promptUser(ctx, req)
    },
}

Java, Python, and Rust get the equivalent setInstallationConfirmationHandler(...), installation_confirmation_handler, and with_installation_confirmation_handler options. Java additionally converts the previously untyped MCP installation/removal review payloads (InstallationConfirmationRequest.review(), McpInstallPlan.transportChoices(), McpInstallationManagementResultOutcome.getOutcome()) into sealed/typed unions, bringing it into line with the other SDKs.

Other changes

• feature: [Java] experimental FusionCritic generated diagnostics type for execution-phase model/reasoning-effort tracking

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Notes Generator · copilot · auto · 169.2 AIC · ⌖ 5.87 AIC · ⊞ 9K

Feature: structured JSON-RPC error data in Go, .NET, and Java

Go, .NET, and Java can now inspect the raw JSON data payload of a JSON-RPC error response instead of only its code and message. This mirrors capabilities already available in TypeScript, Python, and Rust, letting apps branch on machine-readable error details. (#2732)

var rpcErr *copilot.RPCError
if errors.As(err, &rpcErr) {
    fmt.Printf("RPC error %d: %s\n", rpcErr.Code, rpcErr.Message)
}

catch (IOException ex) when (ex.InnerException is RemoteRpcException remote)
{
    Console.Error.WriteLine($"RPC error {remote.ErrorCode}: {remote.Message}");
}

catch (JsonRpcException e) {
    JsonNode data = e.getData();
}

Omitted data and explicit JSON null remain distinguishable in all three APIs, and existing error identity, wrapping, and formatting behavior are unchanged.

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Notes Generator · copilot · auto · 163.2 AIC · ⌖ 6.41 AIC · ⊞ 9K

Internal dependency updates only — this prerelease contains no user-visible SDK changes since v1.0.15-preview.1. The only changes are automated Copilot CLI snapshot updates for internal testing.

Full Changelog: v1.0.15-preview.1...v1.0.15-preview.2

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Notes Generator · copilot · auto · 59.3 AIC · ⌖ 8.22 AIC · ⊞ 9K

Internal dependency updates only — this prerelease contains no user-visible SDK changes since v1.0.15-preview.0. The only changes are automated Copilot CLI snapshot updates for internal testing.

Full Changelog: v1.0.15-preview.0...v1.0.15-preview.1

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Notes Generator · copilot · auto · 42.6 AIC · ⌖ 5.58 AIC · ⊞ 9K

Feature: typed structured outputs for all six SDKs

Provide a JSON Schema, or use an idiomatic typed helper, to have the model return typed, validated output instead of free-form text. (#2590)

const answerSchema = z.object({ value: z.number().int() });
const answer = await session.sendAndWait("What is 19 + 23?", answerSchema);

class Answer(BaseModel):
    value: int

answer = await session.send_and_wait_typed("What is 19 + 23?", Answer)

var answer = await session.SendAndWaitAsync("What is 19 + 23?");
public sealed record Answer(int Value);

Go, Java, and Rust get the same capability via copilot.SendAndWait[Answer], session.sendAndWait(prompt, Answer.class), and session.send_and_wait_typed(prompt) respectively.

Feature: structured JSON-RPC error data in Rust

copilot::Error now preserves the optional data payload from JSON-RPC errors so callers can inspect machine-readable error details instead of just the message. (#2664)

if let Some(data) = error.rpc_data() {
    println!("{data}");
}

Other changes

• feature: [Java] add native runtime support for darwin-x64 (#2701)
• feature: [Java] add native runtime support for linuxmusl-x64 (Alpine) (#2715)
• improvement: [Node/Python/Go/.NET/Java] coalesce intercepted HTTP response chunks with bounded read-ahead for better tool-call streaming throughput (#2734)
• improvement: [.NET] reduce allocations when processing inbound session events (#2733)
• improvement: [Node] pin production dependencies to exact versions and require a 7-day publish-age check across the resolved dependency graph (#2700)

New contributors

• @roblourens made their first contribution in #2700

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Changelog Generator · copilot · auto · 86.4 AIC · ⌖ 5.24 AIC · ⊞ 9.9K

Feature: typed message provenance for user, system, and agent sources

Messages sent through the SDK can now carry typed source provenance, distinguishing human user input, internal system injections, and identified agent- senders, so recipients can reliably tell agent input from human authorization. (#2573)

await session.send("Looks good to me.", { source: "agent-reviewer" });

await session.send("Looks good to me.", source=AgentMessageSource("reviewer"))

Feature: Auto model routing Fast tier

Sessions using auto model routing can now select the fast tier alongside the existing efficiency, balance, and intelligence tiers, giving integrators a latency-focused routing preset across all six SDKs. (#2669)

await session.setAutoTier("fast");

Feature: force-refresh managed settings cache

The new managedSettings.clearCache RPC method wipes the persistent server-policy cache and drops the runtime's in-memory retained policy, giving hosts a primitive for a "force refresh account policy" action. (#2438)

await client.rpc.managedSettings.clearCache();

await client.Rpc.ManagedSettings.ClearCacheAsync();

Feature: Rust SDK model allowlists

SessionConfig and ResumeSessionConfig in the Rust SDK now accept an optional allowed_models list, letting hosts restrict which model IDs a session may use without duplicating runtime validation. (#2512)

let config = SessionConfig::default().with_allowed_models(["gpt-4o", "claude-3.7-sonnet"]);

Other changes

• feature: [Core] add factory pause checkpoints for the Node.js Agent Factories API, letting a paused run resume without losing invocation limits or execution identity (#2537)
• feature: forward the optional host OAuth client metadata URL across all six SDKs on session create and resume (#2258)
• feature: [TypeScript] add max_output_tokens to the model capabilities override, previously unreachable without an unsafe cast (#2569)
• bugfix: [.NET] include Copilot CLI runtime assets in PackAsTool packages so dotnet pack --no-build produces a working tool (#2557)
• bugfix: apply the runtime's connection_close callback-quiescence contract consistently across all six in-process C ABI adapters, preventing races with freed callback state during disposal (#2610, #2622)
• bugfix: [Rust] fix codegen for CLI 1.0.84 schemas, correctly mapping the CatalogTrustEligibility unknown value and re-exporting shared session-event types (#2631)
• bugfix: [C#] fix codegen for runtime schema unions, unblocking single-variant anyOf/oneOf handling (#2656)
• bugfix: [Rust] isolate the hostless in-process runtime cache from the bundled CLI cache to prevent cross-deletion of a shared executable (#2659)
• improvement: [Rust] harden Copilot CLI download retries with more attempts and a longer backoff window (#2663)

New contributors

• @aurokin made their first contribution in #2573
• @kondv made their first contribution in #2557
• @1fanwang made their first contribution in #2569
• @SamMorrowDrums made their first contribution in #2258
• @SandraAhlgrimm made their first contribution in #2603
• @jpbufe3 made their first contribution in #2512

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Changelog Generator · copilot · auto · 73.3 AIC · ⌖ 9 AIC · ⊞ 10.3K

Feature: pause and resume durable factory runs at checkpoints

Agent Factories can now pause deliberately instead of only stopping at hard limits. Call ctx.pause(key) inside a factory body to register a durable, one-shot checkpoint that ends the current attempt; resuming replays the journal and returns from that checkpoint instead of redoing prior work. Callers can also pause a running attempt from outside the factory body. (#2537)

await ctx.step("prepare", prepareInput);
await ctx.pause("review-ready");
await ctx.agent("Review the prepared input");

const paused = await session.factory.pause(runId);

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Changelog Generator · copilot · auto · 52.5 AIC · ⌖ 5.57 AIC · ⊞ 10.3K

Feature: typed message provenance across all SDKs

Sending a message can now declare its source as user, system, or an identified agent (serialized as agent-<id>), so recipients can reliably distinguish human input from system injections and forwarded agent output. Ordinary sends remain unaffected: source stays omitted unless the caller opts in. (#2573)

await session.send({ prompt: "Reviewed and approved.", source: "agent-reviewer" });

await session.send(prompt="Reviewed and approved.", source=AgentMessageSource("reviewer"))

session.Send(ctx, copilot.SendOptions{Source: copilot.MessageSourceAgent("reviewer")})

• C#: Source = MessageSource.Agent("reviewer")
• Java: .setSource(MessageSource.agent("reviewer"))
• Rust: .with_source(MessageSource::Agent("reviewer".into()))

Feature: force-refresh enterprise managed settings

A new managedSettings.clearCache RPC wipes the persistent server-policy cache and drops the runtime's in-memory retained policy, so hosts can wire up a "sync account policy" action (for example VS Code's Developer: Sync Account Policy command). It's available in TypeScript, C#, Python, Go, and Rust; Java support follows once the underlying CLI release is pinned. (#2438)

await client.rpc.managedSettings.clearCache();

Other changes

• feature: [TypeScript] allow setting max_output_tokens on model capability overrides (#2569)
• feature: forward an optional host OAuth client metadata document URL across all six SDKs (#2258)
• bugfix: [.NET] include Copilot CLI runtime assets in PackAsTool publish output so packed tools install correctly (#2557)
• bugfix: [Rust] isolate GitHub token callbacks from the request-routing loop so a callback panic can no longer stall session requests (#2567)
• bugfix: [Python, Node.js] serialize concurrent client startup so racing callers reuse the same connection instead of launching duplicate runtimes (#2570)
• bugfix: [.NET] fix a vulnerable transitive SourceLink dependency (#2587)
• bugfix: fix in-process callback reclamation and FFI close responsiveness across all six SDKs to prevent use-after-free races and event-loop stalls during disposal (#2610, #2622)
• bugfix: [Rust] fix codegen for CLI 1.0.84 schemas (#2631)

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Changelog Generator · copilot · auto · 84.6 AIC · ⌖ 7 AIC · ⊞ 10.3K

Feature: cancellation for host-owned external tools

Host-owned external tool callbacks are now cancelled when their runtime request completes or their SDK session terminates. The cancellation primitive is idiomatic per SDK: .NET passes a request token to AIFunction, Node.js exposes ToolInvocation.signal, Go cancels ToolInvocation.TraceContext, Java cancels the returned CompletableFuture, Python cancels the handler task, and Rust drops the handler future. Go handlers that retain TraceContext for background work must derive a separate lifetime because the invocation context is cancelled when the request ends.

Feature: declare application identity with client info

Client options now accept optional client info (application name and version, integration name and version) across all six SDKs, exposed idiomatically per language (clientInfo in Node.js, client_info in Python and Rust, ClientInfo in Go and .NET, setClientInfo in Java). When set, the SDK forwards it on the server.connect handshake so the telemetry the runtime emits on the connection is attributed to the application and its Copilot integration instead of the runtime's own build. All fields are optional, and leaving client info unset keeps the runtime's default attribution. See Client info.

Feature: Node Agent Factories pagination and run notifications

The experimental Node.js Agent Factories convenience API now supports paginated run history. Existing session.factory.listRuns() calls still return the runs array, while calls with afterSeq, beforeSeq, or limit return the full page with cursor and truncation metadata.

Factory run and resume options now accept notifyOnComplete and logPhaseNames. The SDK forwards these options to the Copilot CLI for new and resumed runs.

Feature: selectable ask_user session behavior

Session create and cold resume now accept a language-specific askUserVariant option with legacy and elicitation values. SDK sessions retain the legacy question-and-answer tool by default. Select elicitation and provide an elicitation handler to expose the structured form-based ask_user tool.

Feature: rotating session-scoped GitHub credentials

All six SDKs can now acquire short-lived GitHub credentials through a session-scoped callback. The SDK registers the callback before session create or resume, maps initial and refresh requests to the owning session, and removes registrations on rollback, replacement, session close, and client close. Static per-session gitHubToken credentials remain supported and are mutually exclusive with the callback.

Token responses use the shared tagged token/cancelled shape and require expiresIn, expressed as the positive number of seconds remaining when the callback completes. See github/copilot-agent-runtime#16381 for the runtime credential-authority implementation.

Initial acquisition occurs during create or resume; cancellation, callback errors, and invalid credentials reject that operation instead of falling back to ambient authentication. Idle sessions refresh only before their next credential-consuming operation.

Feature: extensions can request sensitive environment variables

Copilot CLI extensions can now ask for named sensitive environment variables when they join a session. joinSession() accepts a requestedEnvironmentVariables option listing the variable names the extension needs. The CLI shows a permission prompt naming the extension and the exact variables requested. On approval, only those variables reach that extension and their values are written into the extension process's process.env before joinSession() resolves. On denial, joinSession() rejects, the extension does not load, and its tools never reach the model.

An approval is remembered against the exact set of names the user saw, so an extension that later asks for one more variable prompts again. Names that are unset, or that the CLI does not filter from extensions, are not prompted for. This is the client half of the feature; it requires a Copilot CLI that supports extension environment access, and older CLIs ignore the request and grant nothing.

import { joinSession } from "@github/copilot-sdk/extension";

const session = await joinSession({
    requestedEnvironmentVariables: ["GITHUB_TOKEN"],
});
const token = process.env.GITHUB_TOKEN;

Feature: early session-event subscription (Rust)

The Rust SDK can now observe every event routed to a session, starting with that session's very first routed event. Client::prepare_session and Client::prepare_resume_session return an inert PreparedSession that owns the session's event channel, so a subscription can be installed before any protocol activity begins:

let prepared = client.prepare_session(
    SessionConfig::default().with_event_buffer_capacity(2048),
)?;
let mut events = prepared.subscribe();
let session = prepared.start().await?;

Previously, Session::subscribe could only be called on the returned session, so events the runtime emitted while session.create / session.resume was still in flight were broadcast with no receiver installed and dropped. Ephemeral events such as session.idle are not persisted, so they could not be recovered with getMessages either.

The guarantee is scoped to routed events. For cloud sessions where the server assigns the session ID, the SDK cannot route notifications until the session.create response arrives and the ID is known, so events emitted before that point are not routable to any session. Pin session_id on the config to get router registration before the RPC, and with it complete pre-response coverage.

prepare_* is synchronous and inert: it validates the buffer capacity and allocates a local channel, and performs no router registration, task spawn, or wire activity until start() is first polled. start(self) consumes the handle and PreparedSession is not Clone, so a prepared session can never produce two event loops. Dropping an unstarted handle leaves no state behind; dropping a polled start() future cancels the startup and unregisters the session, so a retry with the same session ID succeeds. Session registrations now carry an ownership identity, so cleanup removes only the exact registration it owns and an abandoned startup can never evict a same-ID retry (or a session that replaced it).

Both SessionConfig and ResumeSessionConfig gained a runtime-only event_buffer_capacity option (default 512, Some(0) rejected as an invalid config). The buffer is finite, so slow subscribers observe Lagged rather than applying backpressure; consumers that need a lossless view of a large startup burst must size the buffer accordingly or drain concurrently with start().

create_session and resume_session are unchanged wrappers over prepare_*(...)?.start() with identical RPC sequences and error kinds.

Feature: host-injected managed settings permissions

Session create and resume accept a new optional managedSettings option that injects an enterprise permissions policy at session startup, alongside the existing enableManagedSettings self-fetch flag. The current contract is permissions-only: disableBypassPermissionsMode (the literal "disable"), plus deny, ask, and allow rule lists. The layer composes restrictively with any server- or device-level managed settings (deny/ask are unioned, every present allow list must admit a tool, and disableBypassPermissionsMode is deny-wins).

This layer is startup-only and is not persisted with the session, so it must be re-supplied on resume to remain in effect; omitting it on resume clears the previously injected layer. It can be combined with enableManagedSettings. Host injection requires Copilot CLI 1.0.79-5 or later and does not require an SDK protocol version bump.

The generated session-event types also expose truthful injected-policy provenance: session.managed_settings_resolved can report source as client or mixed, with optional clientManaged metadata.

const session = await client.createSession({
    managedSettings: {
        permissions: {
            disableBypassPermissionsMode: "disable",
            deny: ["shell(rm*)"],
            ask: ["write"],
        },
    },
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    ManagedSettings = new ManagedSettings
    {
        Permissions = new ManagedSettingsPermissions
        {
            DisableBypassPermissionsMode = DisableBypassPermissionsMode.Disable,
            Deny = ["shell(rm*)"],
            Ask = ["write"],
        },
    },
});

Feature: Auto model routing tier controls

Sessions can now steer auto model routing toward efficiency, balance, or intelligence. An Auto tier can be set at session creation, and a new setAutoTier (and equivalent setModel option) lets sessions stage or reset a tier preference afterward, since the runtime only commits a staged preference on the next successful auto model turn. (#2437, #2514)

await session.set_auto_tier("efficiency")

Feature: sandbox bypass and non-object external tool arguments

Sandbox configuration now exposes allowBypass across all six SDKs. External tool overrides such as apply_patch can also receive non-object JSON argument values, which previously failed before reaching the host handler in .NET. (#2372, #2496)

Feature: host-resolved feature flag overrides

Session create and resume now accept a featureFlags map across all six SDKs, forwarding host-resolved overrides while preserving the distinction between an unset map and an explicitly empty one. (#2451)

Other changes

• feature: use session.detach instead of session.destroy for SDK session cleanup so disconnecting one client no longer tears down a shared session for other owners (#2307)
• bugfix: [Rust] answer the request ID when a tool handler panics (#2311)
• bugfix: [Go] close failed session event loops (#2360)
• bugfix: support bracketed IPv6 runtime URLs (#2200)
• bugfix: [Python] serialize native values in tool results (#2374)
• bugfix: [Rust] prevent orphaned CLI processes (#2292)
• improvement: [Rust] default ClientMode::Empty to no built-in skills (#2410)
• improvement: [Go] auto-detect bundler package name and avoid duplicate license downloads (#2452, #2453)

New contributors

• @lukehoban made their first contribution in #2292
• @scordio made their first contribution in #2382
• @OllieinCanada made their first contribution in #2374
• @gimenete made their first contribution in #2458
• @gwwar made their first contribution in #2464
• @Pybsama made their first contribution in #2163
• @green3sf made their first contribution in #2360
• @gokhanarkan made their first contribution in #2532

network:
  allowed:
    - defaults
    - "github.com"

Generated by Release Changelog Generator · copilot · auto · 125.2 AIC · ⌖ 8.09 AIC · ⊞ 11.7K

Feature: rewind support across all SDKs

Sessions can now opt into file-change tracking and rewind conversation history and tracked file changes to any prior checkpoint. Enable file tracking when creating a session, then use rewind to roll back. (#2321)

const session = await client.createSession({ enableFileChangeTracking: true });
// ...later
const points = await session.rpc.rewind.list();
await session.rpc.rewind.rewind({ rewindTarget: points[0].id });

var session = await client.CreateSessionAsync(new SessionOptions { EnableFileChangeTracking = true });
var points = await session.Rpc.Rewind.ListAsync();
await session.Rpc.Rewind.RewindAsync(new RewindRequest { RewindTarget = points[0].Id });

session = await client.create_session(enable_file_change_tracking=True)
points = await session.rpc.rewind.list()
await session.rpc.rewind.rewind(rewind_target=points[0].id)

Feature: session-scoped GitHub token providers

Sessions now support expiry-aware GitHub token callbacks in addition to static tokens. The SDK handles refresh requests from the runtime, so extensions always receive fresh credentials. (#2412)

const session = await client.createSession({
  gitHubTokenProvider: async ({ host, reason }) => ({ token: await fetchToken(host) })
});

var session = await client.CreateSessionAsync(new SessionOptions {
    GitHubTokenProvider = async (req, ct) =>
        new GitHubTokenResult { Token = await FetchTokenAsync(req.Host) }
});

session, _ := client.CreateSession(ctx, copilot.SessionOptions{
    GitHubTokenProvider: func(ctx context.Context, req copilot.TokenProviderRequest) (copilot.TokenProviderResult, error) {
        return copilot.TokenProviderResult{Token: fetchToken(req.Host)}, nil
    },
})

Feature: Java in-process native runtime on all platforms

The Java SDK now ships a bundled in-process Copilot CLI runtime for Linux x64/arm64, Windows x64/arm64, and Apple Silicon macOS. No separate CLI installation is needed on these platforms. (#2301, #2393, #2402, #2421, #2427)

The correct native classifier is resolved and loaded automatically at runtime — no configuration needed.

Feature: managed SDK servers now use the Rust runtime wrapper

All six SDKs now spawn the dedicated copilot-runtime executable when managing their own subprocess connection, pairing the wrapper with the correct runtime.node addon for a leaner and more reliable process lifecycle. (#2395)

Feature: built-in plugin directory support

Host applications can now register trusted built-in plugin directories loaded before any session begins. Unlike ordinary --plugin-dir loading, these are registered via plugins.builtin.set and trusted by the host. (#2330)

const client = new CopilotClient({ builtinPluginDirectories: ['/path/to/plugins'] });

let client = CopilotClient::new(CopilotClientOptions {
    builtin_plugin_directories: vec![PathBuf::from("/path/to/plugins")],
    ..Default::default()
});

Feature: permission decisions can carry decision context

Permission handlers can now attach optional decisionContext when replying to a permission request, letting the runtime attribute decisions to a person, host policy, or automated recommendation. Additive for all SDKs except Rust. (#2294)

session.onPermissionRequest(async (req) =>
  createAttributedPermissionResult('approve_once', { source: 'policy' })
);

async def handler(req):
    return copilot.create_attributed_permission_result('approve_once', {'source': 'policy'})

Rust breaking change: PermissionResult::Decision changed from a tuple variant to a struct variant ({ decision, context }). Code using result helpers (approve_once() etc.) is unaffected; direct construction or pattern-matching on Decision requires migration.

Feature: extensions can request sensitive environment variables

joinSession() now accepts an env option listing the sensitive environment variable names the extension needs. The CLI prompts the user; on approval the values are written into process.env before joinSession resolves. (#2348)

const session = await host.joinSession(extensionId, { env: ['MY_API_KEY'] });

Feature: ClientMode::Empty now excludes built-in skills by default

When a session is created in empty mode, includedBuiltinSkills defaults to [] across all SDKs. Pass an explicit allowlist to opt individual built-in skills back in. (#2410)

Feature: agent factories — argsSchema, pagination, and completion options

Three improvements to the Agent Factories API in the Node SDK:

• Declare an argsSchema on a factory so the CLI validates arguments before a run starts (#2315)
• session.factory.runs.list() supports cursor-based pagination for browsing full run history (#2431)
• Run and resume options now forward completion notifications and phase-name logging (#2431)

Feature: ask-user variant session option

All SDKs expose an askUserVariant option on session create and resume for structured ask-user tool behavior. Omitting it preserves legacy behavior. (#2432)

Other changes

• bugfix: [Rust] prevent orphaned CLI processes when the client is dropped (#2292)
• bugfix: [Python] serialize native values in tool results correctly (#2374)
• bugfix: [Node] fix agent factory types and behavior to match the wire contract (#2309)
• improvement: [C#] skip untyped internal properties in C# codegen (#2298)

New contributors

• @lutzroeder made their first contribution in #2330
• @aymenfurter made their first contribution in #2294
• @lukehoban made their first contribution in #2292
• @scordio made their first contribution in #2382
• @OllieinCanada made their first contribution in #2374

Generated by Release Changelog Generator · sonnet46 44.1 AIC · ⌖ 6.59 AIC · ⊞ 8.1K

Feature: rewind support across all SDKs

Sessions can now opt into file-change tracking and conversation rewind. When enableFileChangeTracking is enabled, the session records which files were changed during a conversation turn. You can then list pending rewind points, preview changes, and rewind the conversation history together with any tracked file modifications. (#2321)

const session = await client.createSession({ enableFileChangeTracking: true });
const points = await session.rpc.rewind.listPendingRewindPoints();
await session.rpc.rewind.rewind({ id: points[0].id });

var session = await client.CreateSessionAsync(new SessionOptions { EnableFileChangeTracking = true });
var points = await session.Rpc.Rewind.ListPendingRewindPointsAsync();
await session.Rpc.Rewind.RewindAsync(new RewindRequest { Id = points[0].Id });

session = await client.create_session(enable_file_change_tracking=True)
points = await session.rpc.rewind.list_pending_rewind_points()
await session.rpc.rewind.rewind(id=points[0].id)

Feature: session-scoped GitHub token providers

Sessions now support a dynamic, expiry-aware GitHub token callback as an alternative to a static gitHubToken. The SDK maps each host request (with host, session, and reason context) to your callback, handling concurrent-session isolation automatically. (#2412)

const session = await client.createSession({
  gitHubTokenProvider: async ({ host }) => ({ token: await getToken(host), expiresIn: 3600 }),
});

var session = await client.CreateSessionAsync(new SessionOptions
{
    GitHubTokenProvider = async (req, ct) =>
        new GitHubToken { Token = await GetTokenAsync(req.Host, ct), ExpiresIn = TimeSpan.FromHours(1) }
});

session, err := client.CreateSession(ctx, copilot.SessionOptions{
    GitHubTokenProvider: func(ctx context.Context, req copilot.GitHubTokenRequest) (copilot.GitHubToken, error) {
        return copilot.GitHubToken{Token: getToken(req.Host), ExpiresIn: 3600}, nil
    },
})

Feature: built-in plugin directory support

Applications that ship their own built-in plugins can now register a trusted plugin directory at client startup. These plugins are registered with the runtime before any sessions are created, distinct from ordinary --plugin-dir loading. (#2330)

const client = new CopilotClient({ builtInPluginDirectories: ['/path/to/plugins'] });

let client = CopilotClient::builder()
    .built_in_plugin_directories(vec![PathBuf::from("/path/to/plugins")])
    .build()?;

Feature: permission decision context forwarding

Permission handlers can now attach a decisionContext so the runtime can attribute whether a decision came from a person, a host policy, or an automated recommendation. This is additive for TypeScript, C#, Go, Python, and Java. Rust clients that construct PermissionResult::Decision directly must migrate from the tuple variant to the new struct variant. (#2294)

session.onPermissionRequest(async (req) => {
  return createAttributedPermissionResult('allow_once', { source: 'host-policy' });
});

session.on_permission_request(|req| async move {
    PermissionResult::approve_once().with_context(DecisionContext { source: "host-policy".into() })
});

Feature: ClientMode::Empty now defaults to no built-in skills

When creating a session with ClientMode::Empty, built-in skills are now disabled by default. To opt specific skills in, supply an explicit includedBuiltinSkills allowlist. Custom skills via enableSkills and skillDirectories are unaffected. (#2410)

const session = await client.createSession({
  clientMode: 'empty',
  includedBuiltinSkills: ['grep'],
});

Feature: Java in-process CLI runtime for Linux, Windows, and macOS

The Java SDK now ships a bundled native CLI runtime for Linux x64, Linux ARM64, Windows x64, Windows ARM64, and Apple Silicon macOS. Applications on these platforms no longer need a separately installed Copilot CLI binary. (#2301, #2393, #2402, #2421, #2427)

Other changes

• feature: [Node] agent factories surface matches the wire contract — result and arguments typed as JsonValue, ctx.agent() forwards agent/reasoningEffort/contextTier (#2309)
• feature: [Node] factories can declare an argsSchema so the CLI validates caller arguments before starting a run (#2315)
• feature: [Node] factory run listing with cursor-based pagination and truncation metadata; run and resume support completion notifications and phase-name logging (#2431)
• feature: [Node] extensions can request sensitive environment variables (#2348)
• feature: [All] typed askUserVariant session option for structured ask-user tool selection (#2432)
• bugfix: [Rust] prevent orphaned CLI child processes on session drop (#2292)
• bugfix: [Python] serialize native values in tool results (#2374)
• improvement: [C#] codegen skips untyped internal properties (#2298)

New contributors

• @lutzroeder made their first contribution in #2330
• @aymenfurter made their first contribution in #2294
• @lukehoban made their first contribution in #2292
• @scordio made their first contribution in #2382
• @OllieinCanada made their first contribution in #2374

Generated by Release Changelog Generator · sonnet46 42.5 AIC · ⌖ 6.48 AIC · ⊞ 8.1K

Feature: rewind support across all SDKs

Sessions can now opt in to file-change tracking so that rewinding restores both conversation history and the files that were modified. Enable it with the new enableFileChangeTracking session option. (#2321)

const session = await client.startSession({ enableFileChangeTracking: true });

var session = await client.StartSessionAsync(new SessionOptions { EnableFileChangeTracking = true });

session = await client.start_session(enable_file_change_tracking=True)

session, _ := client.StartSession(ctx, &copilot.SessionOptions{EnableFileChangeTracking: true})

Session session = client.startSession(new SessionOptions().setEnableFileChangeTracking(true)).get();

let session = client.start_session(SessionOptions { enable_file_change_tracking: Some(true), ..Default::default() }).await?;

Feature: session-scoped GitHub token providers

Applications can now supply a dynamic GitHub token callback instead of a static gitHubToken string. The runtime calls the callback before each token use, so short-lived tokens stay fresh across long-running sessions. (#2412)

const session = await client.startSession({
  gitHubTokenProvider: async ({ host, reason }) => ({ token: await fetchToken(host) })
});

var session = await client.StartSessionAsync(new SessionOptions
{
    GitHubTokenProvider = async (request, ct) => new GitHubTokenResult(await FetchTokenAsync(request.Host))
});

async def token_provider(request):
    return GitHubTokenResult(token=await fetch_token(request.host))

session = await client.start_session(github_token_provider=token_provider)

session, _ := client.StartSession(ctx, &copilot.SessionOptions{
    GitHubTokenProvider: func(ctx context.Context, req copilot.GitHubTokenRequest) (copilot.GitHubTokenResult, error) {
        return copilot.GitHubTokenResult{Token: fetchToken(req.Host)}, nil
    },
})

session = client.startSession(new SessionOptions()
    .setGitHubTokenProvider((req, ct) ->
        CompletableFuture.completedFuture(new GitHubTokenResult(fetchToken(req.getHost()))))).get();

let session = client.start_session(SessionOptions {
    github_token_provider: Some(Box::new(|req| Box::pin(async move { Ok(GitHubTokenResult { token: fetch_token(&req.host).await }) }))),
    ..Default::default()
}).await?;

Feature: Java in-process runtime (linux-x64, macOS arm64, Windows x64/arm64)

The Java SDK now supports an in-process connection mode that loads the Copilot runtime as a native library via JNA, eliminating the need for a separate CLI child process. Add the platform-specific classifier JAR to your project and use RuntimeConnection.forInProcess(). (#2301, #2393, #2402, #2421, #2427)

CopilotClientOptions options = new CopilotClientOptions()
    .setConnection(RuntimeConnection.forInProcess());

CopilotClient client = new CopilotClient(options);
client.start().get();

Feature: built-in plugin directory support

Host applications can now register a set of trusted, host-bundled plugin directories at startup. These directories are registered with plugins.builtin.set before any session is created. (#2330)

Feature: ClientMode.Empty defaults to no built-in skills

ClientMode.Empty now deny-by-defaults includedBuiltinSkills to [], matching its deny-by-default behavior for all other built-in capabilities. Callers can still pass an explicit allowlist to opt in to specific runtime-bundled skills. (#2410)

Feature: permission decision context forwarding

Permission handlers can now attach decisionContext to let the runtime attribute decisions (human, policy, or automated recommendation). This is additive for TypeScript, Python, Go, C#, and Java. Rust clients that construct or match PermissionResult::Decision directly must migrate from the tuple variant to the new struct variant. (#2294)

return createAttributedPermissionResult(PermissionDecision.ApproveOnce, context);

PermissionResult::Decision { decision: PermissionDecision::ApproveOnce, context: Some(ctx) }

Feature: Node extensions can request sensitive environment variables

Node SDK extensions can now declare which sensitive environment variables they need. The CLI prompts the user and, on approval, injects the granted values before the extension starts. (#2348)

await joinSession({ env: ["MY_API_KEY", "MY_SECRET"] });

Feature: factory argsSchema declaration

Node SDK factories can now declare an argsSchema so the CLI validates caller arguments before starting a run, saving credits and preventing confusing runtime errors. (#2315)

session.defineFactory("my-factory", { argsSchema: { type: "object", properties: { query: { type: "string" } } } }, async (ctx) => { ... });

Other changes

• bugfix: [Node] fix agent factory surface to match wire contract — ctx.agent() now forwards agent, reasoningEffort, and contextTier (#2309)
• bugfix: [Python] serialize native values (datetime, UUID, Decimal, set, Enum) in tool results (#2374)
• bugfix: [Rust] prevent orphaned CLI child processes when the last Client is dropped (#2292)
• improvement: [C#] skip untyped internal properties in C# codegen (#2298)

New contributors

• @lutzroeder made their first contribution in #2330
• @aymenfurter made their first contribution in #2294
• @lukehoban made their first contribution in #2292
• @scordio made their first contribution in #2382
• @OllieinCanada made their first contribution in #2374

Generated by Release Changelog Generator · sonnet46 33.8 AIC · ⌖ 7.74 AIC · ⊞ 8.1K

Feature: ClientMode::Empty now disables built-in skills by default

ClientMode::Empty now applies deny-by-default isolation to runtime-bundled skills in addition to other built-in capabilities. includedBuiltinSkills defaults to [] in Empty mode; pass an explicit allowlist to re-enable specific skills. This behavior is consistent across all six SDKs. (#2410)

// Node — empty mode: built-in skills excluded by default
const session = await client.createSession({ mode: ClientMode.Empty });
// opt back in:
const session = await client.createSession({ mode: ClientMode.Empty, includedBuiltinSkills: ["edit"] });

// C#
var session = await client.CreateSessionAsync(new SessionOptions { Mode = ClientMode.Empty });
// opt back in:
var session = await client.CreateSessionAsync(new SessionOptions { Mode = ClientMode.Empty, IncludedBuiltinSkills = ["edit"] });

# Python
session = await client.create_session(mode=ClientMode.EMPTY)
# opt back in:
session = await client.create_session(mode=ClientMode.EMPTY, included_builtin_skills=["edit"])

// Go
session, err := client.CreateSession(ctx, copilot.SessionOptions{Mode: copilot.ClientModeEmpty})
// opt back in:
session, err := client.CreateSession(ctx, copilot.SessionOptions{Mode: copilot.ClientModeEmpty, IncludedBuiltinSkills: []string{"edit"}})

Generated by Release Changelog Generator · sonnet46 28.6 AIC · ⌖ 4.12 AIC · ⊞ 8.1K

Feature: rewind support across all SDKs

Sessions can now opt into file-change tracking and rewind conversation history along with tracked file changes. Enable the new enableFileChangeTracking session option to allow calling rewind later. (#2321)

const session = await client.createSession({ enableFileChangeTracking: true });
// later:
await session.rpc.conversation.rewind({ ...rewindPoint });

var session = await client.CreateSessionAsync(new SessionOptions { EnableFileChangeTracking = true });

session = await client.create_session(enable_file_change_tracking=True)

session, err := client.CreateSession(ctx, copilot.SessionOptions{EnableFileChangeTracking: true})

Feature: Java in-process runtime (experimental)

The Java SDK now ships platform-native classifier JARs that load the Copilot runtime directly in-process via JNA — no separate CLI child process required. Currently available for linux-x64, Windows x64, and Apple Silicon macOS. (#2301, #2393, #2402)

CopilotClientOptions options = new CopilotClientOptions()
    .setConnection(RuntimeConnection.forInProcess());
CopilotClient client = new CopilotClient(options);
client.start().get();

Feature: permission decision context forwarding

Permission handlers can now attach decisionContext so the runtime can attribute whether a decision came from a person, host policy, or an automated recommendation. This is additive for Node, Python, Go, .NET, and Java. Rust clients that construct or match PermissionResult::Decision directly must migrate to the new struct variant. (#2294)

• TypeScript: createAttributedPermissionResult(result, context)
• Python: copilot.create_attributed_permission_result(result, context)
• Go: copilot.NewAttributedPermissionResult(result, context)
• C#: set DecisionContext on the permission decision
• Java: PermissionRequestResult.approveOnce().setDecisionContext(context)
• Rust: PermissionResult::approve_once().with_context(context)

Feature: built-in plugin directory support

Applications can now register a set of host-bundled plugin directories that are trusted unconditionally and loaded before any user session begins. (#2330)

Feature: extensions can request sensitive environment variables (Node)

joinSession() now accepts an env option listing the sensitive environment variable names an extension needs. The CLI prompts the user for approval; if granted, the values are written into the extension's process.env before the session resolves. (#2348)

await joinSession({ env: ['MY_API_KEY', 'MY_SECRET'] });

Other changes

• improvement: [SDK/Factories] align agent factory types and behavior with the wire contract — factory results type as JsonValue, ctx.agent() forwards reasoningEffort and contextTier, resume error union narrowed to codes the runtime raises (#2309)
• feature: [SDK/Factories] expose optional argsSchema on FactoryMeta so the CLI can validate factory arguments before a run starts (#2315)
• bugfix: [Python] serialize native values (datetime, UUID, Decimal, Enum, set) in tool results (#2374)
• bugfix: [Rust] prevent orphaned CLI processes on client drop (#2292)

New contributors

• @lutzroeder made their first contribution in #2330
• @aymenfurter made their first contribution in #2294
• @lukehoban made their first contribution in #2292
• @scordio made their first contribution in #2382
• @OllieinCanada made their first contribution in #2374

Generated by Release Changelog Generator · sonnet46 36.8 AIC · ⌖ 4.91 AIC · ⊞ 8.1K

Feature: rewind support across all SDKs

Sessions now support rewinding conversation history and tracked file changes. Enable file-change tracking when creating a session, then rewind to a previous checkpoint to discard later turns and restore file state. (#2321)

const session = await client.createSession({ enableFileChangeTracking: true });
const rewindPoints = await session.rpc.rewind.listRewindPoints();
await session.rpc.rewind.rewind({ rewindPointId: rewindPoints[0].rewindPointId });

session = await client.create_session(enable_file_change_tracking=True)
rewind_points = await session.rpc.rewind.list_rewind_points()
await session.rpc.rewind.rewind(rewind_point_id=rewind_points[0].rewind_point_id)

session, _ := client.CreateSession(ctx, &copilot.SessionOptions{EnableFileChangeTracking: true})
points, _ := session.RPC.Rewind.ListRewindPoints(ctx)
_ = session.RPC.Rewind.Rewind(ctx, &copilot.RewindRequest{RewindPointId: points[0].RewindPointId})

var session = await client.CreateSessionAsync(new SessionOptions { EnableFileChangeTracking = true });
var points = await session.Rpc.Rewind.ListRewindPointsAsync();
await session.Rpc.Rewind.RewindAsync(new RewindRequest { RewindPointId = points[0].RewindPointId });

SessionOptions options = new SessionOptions().setEnableFileChangeTracking(true);
var session = client.createSession(options).get();
var points = session.getRpc().getRewind().listRewindPoints().get();
session.getRpc().getRewind().rewind(new RewindRequest().setRewindPointId(points.get(0).getRewindPointId())).get();

let session = client.create_session(SessionOptions { enable_file_change_tracking: Some(true), ..Default::default() }).await?;
let points = session.rpc.rewind.list_rewind_points().await?;
session.rpc.rewind.rewind(RewindRequest { rewind_point_id: points[0].rewind_point_id.clone() }).await?;

Feature: Java in-process Copilot CLI (linux-x64)

The Java SDK now supports an in-process connection mode on linux-x64 that loads the Copilot runtime as a native library via JNA — no separate CLI child process required. Add the copilot-sdk-java-runtime classifier JAR for your platform alongside the core SDK JAR. (#2301)

CopilotClientOptions options = new CopilotClientOptions()
    .setConnection(RuntimeConnection.forInProcess());
CopilotClient client = new CopilotClient(options);
client.start().get();

Feature: permission decision context across all SDKs

Permission handlers can now attach decisionContext so the runtime can attribute whether a decision came from a person, host policy, or an automated recommendation. This is additive for all SDKs. Note for Rust: PermissionResult::Decision changed from a tuple variant to a struct variant — callers that construct or match it directly must migrate. (#2294)

return createAttributedPermissionResult("allow_once", { source: "user" });

return copilot.create_attributed_permission_result("allow_once", context)

return copilot.NewAttributedPermissionResult("allow_once", context)

return new PermissionDecision { Result = "allow_once", DecisionContext = context };

return PermissionRequestResult.approveOnce().setDecisionContext(context);

return PermissionResult::Decision { decision: PermissionDecision::ApproveOnce, context: Some(ctx) };

Feature: built-in plugin directory support

Hosts can now register a trusted set of host-bundled plugin directories that are loaded before any session is created, distinct from user-managed --plugin-dir directories. (#2330)

Feature: Node extensions can request sensitive environment variables

Node extensions can now pass an env option to joinSession() listing the sensitive environment variable names they need. The CLI prompts the user for approval; if granted, the variables are written into the extension process before joinSession() resolves. (#2348)

await joinSession({ env: ["MY_SECRET_TOKEN", "API_KEY"] });

Feature: agent factory argsSchema support

FactoryMeta now exposes an optional argsSchema field so factory authors can declare the argument shape their factory expects. The CLI validates call arguments against the schema before starting a run, surfacing malformed calls early without consuming credits. (#2315)

session.defineFactory("my-factory", { argsSchema: { type: "object", properties: { query: { type: "string" } } } }, async (ctx) => { /* ... */ });

Other changes

• bugfix: [Rust] prevent orphaned CLI child processes when the last Client is dropped (#2292)
• improvement: [Node/SDK/Factories] align agent factory types and behavior with the wire contract — FactoryResult/FactoryArguments now typed as JsonValue, ctx.agent() forwards reasoningEffort and contextTier, resume error union trimmed to real codes (#2309)

New contributors

• @lutzroeder made their first contribution in #2330
• @aymenfurter made their first contribution in #2294
• @lukehoban made their first contribution in #2292

Generated by Release Changelog Generator · sonnet46 37.7 AIC · ⌖ 5.53 AIC · ⊞ 8.1K

What's Changed

• docs: correct the Python Customize Mode section IDs and action list by @examon in #2264
• Add history.clearContext and Tool.isTerminal across all SDKs by @examon in #2129
• fix(java): preserve MCP permission extension data by @rinceyuan in #2276
• Update @github/copilot to 1.0.79-5 by @github-actions[bot] in #2282
• Update @github/copilot to 1.0.79-6 by @github-actions[bot] in #2287
• SDK, Runtime: Recover JSON-RPC frames containing unpaired UTF-16 surrogates by @Chuxel in #2283
• Add managed permission settings to session startup by @joshspicer in #2139
• Skip untyped internal properties in C# codegen by @stephentoub in #2298
• Update @github/copilot to 1.0.79-9 by @github-actions[bot] in #2299
• Update @github/copilot to 1.0.79 by @github-actions[bot] in #2306
• Consolidate SDK GitHub releases by @stephentoub in #2305
• [SDK/Factories] Make The Agent Factories Surface Match The Wire Contract by @MRayermannMSFT in #2309
• Add rewind support across all SDKs by @stephentoub in #2321
• [java] Add linux-x64 implementation of in process Copilot CLI by @edburns in #2301
• [Java] Fix java publish to maven by @edburns in #2324
• test(java): skip linux runtime tests on other platforms by @edburns in #2325
• Fix codegen for internal runtime schemas by @stephentoub in #2331
• [SDK/Factories] Add argsSchema To The Factory Authoring Surface by @MRayermannMSFT in #2315
• Add built-in plugin directory support by @lutzroeder in #2330
• sdk: Forward decisionContext on permission replies across languages by @aymenfurter in #2294

New Contributors

• @Chuxel made their first contribution in #2283
• @lutzroeder made their first contribution in #2330
• @aymenfurter made their first contribution in #2294

Full Changelog: v1.0.9...v1.0.11

Feature: rewind support across all SDKs

The Copilot runtime supports rewinding conversation history and tracked file changes. SDKs can now opt into file-change tracking via a new enableFileChangeTracking session option, and then use rewind to restore the session to an earlier checkpoint. (#2321)

// TypeScript
const session = await client.startSession({ enableFileChangeTracking: true });
const rewindPoints = await session.rpc.session.listRewindPoints();
await session.rpc.session.rewind({ rewindPointId: rewindPoints[0].id });

// C#
var session = await client.StartSessionAsync(new SessionOptions { EnableFileChangeTracking = true });
var points = await session.Rpc.Session.ListRewindPointsAsync();
await session.Rpc.Session.RewindAsync(new RewindParams { RewindPointId = points[0].Id });

# Python
session = await client.start_session(enable_file_change_tracking=True)
points = await session.rpc.session.list_rewind_points()
await session.rpc.session.rewind(rewind_point_id=points[0].id)

// Go
session, _ := client.StartSession(ctx, &sdk.SessionOptions{EnableFileChangeTracking: true})
points, _ := session.RPC.Session.ListRewindPoints(ctx)
session.RPC.Session.Rewind(ctx, &sdk.RewindParams{RewindPointId: points[0].Id})

// Java
SessionOptions options = new SessionOptions().setEnableFileChangeTracking(true);
CopilotSession session = client.startSession(options).get();
List<RewindPoint> points = session.getRpc().getSession().listRewindPoints().get();
session.getRpc().getSession().rewind(new RewindParams().setRewindPointId(points.get(0).getId())).get();

// Rust
let session = client.start_session(SessionOptions { enable_file_change_tracking: Some(true), ..Default::default() }).await?;
let points = session.rpc().session().list_rewind_points().await?;
session.rpc().session().rewind(&RewindParams { rewind_point_id: points[0].id.clone() }).await?;

Feature: Java in-process runtime for Linux x64

The Java SDK now supports loading the Copilot runtime as a native library (via JNA) directly in-process on Linux x64, eliminating the need for a separate CLI child process. This mirrors the in-process mode already available in .NET and Rust. The feature is marked @CopilotExperimental. (#2301)

To use it, add the native runtime classifier JAR to your Maven dependencies and configure the connection:

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java-runtime</artifactId>
    <version>${copilot.version}</version>
    <classifier>linux-x64</classifier>
</dependency>

CopilotClientOptions options = new CopilotClientOptions()
    .setConnection(RuntimeConnection.forInProcess());

CopilotClient client = new CopilotClient(options);
client.start().get();

Other changes

• improvement: [Node] agent factories surface now correctly typed — factory args/results use JsonValue, ctx.agent() forwards reasoningEffort and contextTier, and a factory body can no longer start a second top-level run (#2309)

Generated by Release Changelog Generator · sonnet46 28.7 AIC · ⌖ 7.73 AIC · ⊞ 8.1K

Feature: history.clearContext and Tool.isTerminal across all SDKs

Two new capabilities are available in every SDK language:

history.clearContext clears the conversation context (keeping system and developer messages) and seeds the fresh context window with a required first user message. It can only be called from inside a tool handler with a tool call in flight. Also picks up the new session.context_cleared event. (#2129)

Tool.isTerminal lets a tool declare that a successful call ends the agent turn instead of feeding the result back to the model for another round. A failed call leaves the loop running so the model can read the error and retry. (#2129)

const session = await joinSession({
    tools: [{
        name: "clear_context",
        isTerminal: true,
        defer: "never",
        parameters: {
            type: "object",
            properties: { prompt: { type: "string" } },
            required: ["prompt"],
        },
        handler: async ({ prompt }) => {
            const { messagesCleared } = await session.rpc.history.clearContext({ prompt });
            return { textResultForLlm: `Cleared ${messagesCleared} message(s).`, resultType: "success" };
        },
    }],
});

session.DefineTool("clear_context", new ToolOptions { IsTerminal = true, Defer = DeferMode.Never }, async (params) => {
    var result = await session.Rpc.History.ClearContext(new ClearContextParams { Prompt = params.Prompt });
    return ToolResult.Success($"Cleared {result.MessagesCleared} message(s).");
});

Feature: managed permission settings at session startup

Hosts can now inject enterprise permission policy at session startup across all six SDKs. This is independent of the runtime's server-managed settings fetch path. (#2139)

const session = await createSession({
    managedSettings: {
        permissions: {
            disableBypassPermissionsMode: "disable",
            deny: ["shell"],
            allow: ["read_file"],
        },
    },
});

var session = await CopilotClient.CreateSessionAsync(new SessionOptions {
    ManagedSettings = new ManagedSettings {
        Permissions = new ManagedPermissions {
            DisableBypassPermissionsMode = "disable",
            Deny = ["shell"],
            Allow = ["read_file"],
        }
    }
});

Other changes

• bugfix: [Java] preserve MCP permission extension data (serverName, toolName, args) in PermissionRequest.extensionData (#2276)
• bugfix: [Rust] recover JSON-RPC frames containing unpaired UTF-16 surrogates instead of closing the connection (#2283)

New contributors

• @Chuxel made their first contribution in #2283

Generated by Release Changelog Generator · sonnet46 19 AIC · ⌖ 5.28 AIC · ⊞ 8.6K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.73, model: claude-sonnet-4.6, id: 31186148234, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/31186148234 -->

What's Changed

• java: enforce non-blank @CopilotToolParam description at compile time by @rinceyuan in https://github.com/github/copilot-sdk/pull/1980
• java: add schema attribute to @CopilotToolParam and lambda for custom type schema override by @edburns in https://github.com/github/copilot-sdk/pull/2069
• docs: fix non-compiling Rust session-limits example by @examon in https://github.com/github/copilot-sdk/pull/2082
• Fix the plan-mode exit action type name in the fleet mode guide by @examon in https://github.com/github/copilot-sdk/pull/2090
• Fix the Node.js tool-definition example in the Microsoft Agent Framework guide by @examon in https://github.com/github/copilot-sdk/pull/2088
• Fix Go telemetry examples: NewClient takes *ClientOptions and returns one value by @examon in https://github.com/github/copilot-sdk/pull/2086
• Fix active .NET and Python CI failures by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/2093
• docs: correct the delta field the MAF streaming example reads by @examon in https://github.com/github/copilot-sdk/pull/2105
• Fix the Python list_sessions docstring example to use session_id by @examon in https://github.com/github/copilot-sdk/pull/2099
• docs: rename Azure AI Foundry to Microsoft Foundry in BYOK guide by @scottaddie in https://github.com/github/copilot-sdk/pull/2097
• Bump fast-uri from 3.1.2 to 3.1.4 in /test/harness by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2094
• Bump brace-expansion from 1.1.14 to 1.1.16 in /nodejs by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2095
• Bump hono from 4.12.23 to 4.12.32 in /test/harness by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2096
• docs: add missing assistant.usage event fields to streaming-events reference by @rinceyuan in https://github.com/github/copilot-sdk/pull/2074
• docs: document complete sub-agent event data fields by @rinceyuan in https://github.com/github/copilot-sdk/pull/2072
• Refresh agentic workflows to gh-aw v0.83.1; issue-intent on issue-triage by @alondahari in https://github.com/github/copilot-sdk/pull/2063
• Add StartupTimings per-phase breakdown to Client::start by @jmoseley in https://github.com/github/copilot-sdk/pull/2066
• docs: fix inaccurate SDK/runtime claims found in docs audit by @patniko in https://github.com/github/copilot-sdk/pull/2064
• Fix flaky .NET ask-user E2E tests by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/2107
• sdk: Expose AgentStop session hook across languages by @belaltaher8 in https://github.com/github/copilot-sdk/pull/2054
• ci: add stable required SDK checks by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/2108
• Fix flaky .NET session resume E2E test by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/2109
• dotnet: release oversized JSON-RPC receive buffers by @adirh3 in https://github.com/github/copilot-sdk/pull/2047
• Version-independent SDK test and codegen fixes split from the 1.0.76-0 bump by @stephentoub in https://github.com/github/copilot-sdk/pull/2110
• docs: add server-to-server token guide by @patniko in https://github.com/github/copilot-sdk/pull/2005
• Update @github/copilot to 1.0.76-5 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/2140
• docs: correct the Python and Go event data model tip by @examon in https://github.com/github/copilot-sdk/pull/2160
• fix(python): select the current platform's CLI package in the E2E harness by @nytron88 in https://github.com/github/copilot-sdk/pull/2117
• docs: fix non-compiling Rust external-transport example by @examon in https://github.com/github/copilot-sdk/pull/2142
• Rebrand Azure AI Foundry references to Microsoft Foundry by @scottaddie in https://github.com/github/copilot-sdk/pull/2126
• Fix .NET in-process E2E transport coverage by @roji in https://github.com/github/copilot-sdk/pull/1986
• Document MCP tool filter naming across SDKs by @syedkazmi14 in https://github.com/github/copilot-sdk/pull/2101
• docs: fix EnableConfigDiscovery summary to accurately describe agent discovery behavior by @smz202000 in https://github.com/github/copilot-sdk/pull/2019
• build(deps): bump the java-maven-deps group across 1 directory with 6 updates by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2119
• Bump com.fasterxml.jackson.core:jackson-databind from 2.22.0 to 2.22.1 in /java by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2017
• Add the Agent Factories authoring surface by @MRayermannMSFT in https://github.com/github/copilot-sdk/pull/2114
• Fix CAPI reasoning E2E fixtures by @ellismg in https://github.com/github/copilot-sdk/pull/2181
• docs: correct the remote sessions client option name by @examon in https://github.com/github/copilot-sdk/pull/2179
• docs: correct the ephemeral labels on four persisted session events by @examon in https://github.com/github/copilot-sdk/pull/2172
• docs: document EnableSessionStore and one-shot session guidance by @syf2211 in https://github.com/github/copilot-sdk/pull/1822
• python: decode boolean-discriminated unions by @examon in https://github.com/github/copilot-sdk/pull/2123
• test(java): re-enable ModeHandlers exit_plan_mode E2E assertions by @arimu1 in https://github.com/github/copilot-sdk/pull/2032
• Add usage and billing metrics docs page by @andyfeller in https://github.com/github/copilot-sdk/pull/1720
• forward CustomAgentsLocalOnly in session.create and session.resume by @syf2211 in https://github.com/github/copilot-sdk/pull/1899
• Fix Python codegen synthetic permission approval names by @abhinavgautam01 in https://github.com/github/copilot-sdk/pull/1652
• fix(python): forward binary tool results in HandlePendingToolCall RPC by @syf2211 in https://github.com/github/copilot-sdk/pull/1821
• [Codegen] Honor internal flag on session event types in Node codegen by @MRayermannMSFT in https://github.com/github/copilot-sdk/pull/2177
• Expose managed approval requirement on permission requests by @joshspicer in https://github.com/github/copilot-sdk/pull/2080
• sdk: Expose githubMcpToolConfig across languages by @connor4312 in https://github.com/github/copilot-sdk/pull/2112
• Deflake background task removal E2E tests by @stephentoub in https://github.com/github/copilot-sdk/pull/2190
• Update @github/copilot to 1.0.77 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/2183
• Update @github/copilot to 1.0.78-2 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/2193
• fix(python): serialize Pydantic models with mode='json' in tool results by @rinceyuan in https://github.com/github/copilot-sdk/pull/2225
• all SDKs: add EnableExperimentalMode to session create/resume wire with mode-aware defaults by @jmoseley in https://github.com/github/copilot-sdk/pull/1600
• build(deps): bump brace-expansion from 5.0.6 to 5.0.9 in /scripts/docs-validation in the npm_and_yarn group across 1 directory by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2191
• docs: remove the nonexistent toolName field from tool.execution_complete by @examon in https://github.com/github/copilot-sdk/pull/2212
• feat: add support for additional directories in session configuration by @DonJayamanne in https://github.com/github/copilot-sdk/pull/2180
• docs: fix the Node.js inbound trace-context example to use a real tool-registration API by @examon in https://github.com/github/copilot-sdk/pull/2223
• Update @github/copilot to 1.0.78 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/2239
• dotnet: update README attachment examples to current API (fixes #2196) by @HindzStark in https://github.com/github/copilot-sdk/pull/2208
• Support reasoningEffort: max by @Dharshika-11 in https://github.com/github/copilot-sdk/pull/2228
• Stop sendAndWait from emitting an unhandled rejection by @thejesh23 in https://github.com/github/copilot-sdk/pull/2206
• docs: clarify working directory defaults across SDKs by @xianjianlf2 in https://github.com/github/copilot-sdk/pull/2201
• Speed up Rust E2E tests with shared clients by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/2250
• build(deps-dev): bump ip-address from 10.2.0 to 10.4.0 in /test/harness by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2245
• build(deps-dev): bump the npm_and_yarn group across 1 directory with 2 updates by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2244
• build(deps-dev): bump postcss from 8.5.15 to 8.5.25 in /nodejs by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2243
• build(deps-dev): bump fast-uri from 3.1.4 to 3.1.5 in /test/harness by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2242
• docs: move SDK development guidance to local READMEs by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/2253
• build(deps-dev): bump postcss from 8.5.15 to 8.5.25 in /test/harness by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/2252
• docs: replace removed session.idle.backgroundTasks field with the current aborted field by @examon in https://github.com/github/copilot-sdk/pull/2232
• Parallelize Python and Windows .NET CI tests by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/2251
• Fix active Node and Rust replay E2E flakes by @roji in https://github.com/github/copilot-sdk/pull/2186
• Add userPromptTransformed hook to all SDKs by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/2254
• fix: Java README version stuck at 1.0.5-01; release sed regex can't match numeric qualifiers by @rinceyuan in https://github.com/github/copilot-sdk/pull/2226
• docs: update Go and Rust API reference links by @scottaddie in https://github.com/github/copilot-sdk/pull/2266
• docs: add citations guide by @patniko in https://github.com/github/copilot-sdk/pull/2267
• sdk: Expose disabled MCP servers across languages by @connor4312 in https://github.com/github/copilot-sdk/pull/2260

New Contributors

• @alondahari made their first contribution in https://github.com/github/copilot-sdk/pull/2063
• @adirh3 made their first contribution in https://github.com/github/copilot-sdk/pull/2047
• @nytron88 made their first contribution in https://github.com/github/copilot-sdk/pull/2117
• @syedkazmi14 made their first contribution in https://github.com/github/copilot-sdk/pull/2101
• @smz202000 made their first contribution in https://github.com/github/copilot-sdk/pull/2019
• @arimu1 made their first contribution in https://github.com/github/copilot-sdk/pull/2032
• @abhinavgautam01 made their first contribution in https://github.com/github/copilot-sdk/pull/1652
• @joshspicer made their first contribution in https://github.com/github/copilot-sdk/pull/2080
• @connor4312 made their first contribution in https://github.com/github/copilot-sdk/pull/2112
• @DonJayamanne made their first contribution in https://github.com/github/copilot-sdk/pull/2180
• @HindzStark made their first contribution in https://github.com/github/copilot-sdk/pull/2208
• @Dharshika-11 made their first contribution in https://github.com/github/copilot-sdk/pull/2228
• @thejesh23 made their first contribution in https://github.com/github/copilot-sdk/pull/2206
• @xianjianlf2 made their first contribution in https://github.com/github/copilot-sdk/pull/2201

Full Changelog: https://github.com/github/copilot-sdk/compare/v1.0.8...v1.0.9

Feature: configure the built-in GitHub MCP server per session

All SDKs now accept a githubMcpToolConfig option on session create/resume, exposing settings the runtime already supports. The most useful new control is disableFormDeferral, which makes MCP write tools (like creating issues or PRs) execute directly instead of opening an interactive form — essential for autonomous workflows. (#2112)

const session = await client.createSession({
  githubMcpToolConfig: { disableFormDeferral: true }
});

var session = await client.CreateSessionAsync(new SessionConfig {
    GitHubMcpToolConfig = new GitHubMcpToolConfig { DisableFormDeferral = true }
});

Feature: opt in or out of experimental mode per session

A new enableExperimentalMode option lets SDK consumers control whether a session activates experimental runtime features. In empty mode the SDK defaults to false; in copilot-cli mode the runtime decides unless you set it explicitly. (#1600)

const session = await client.createSession({ enableExperimentalMode: true });

var session = await client.CreateSessionAsync(new SessionConfig { EnableExperimentalMode = true });

Feature: additional directories in session configuration

Sessions can now be created with an additionalDirectories field that exposes extra working directories to the session alongside the primary workspace. (#2180)

const session = await client.createSession({
  additionalDirectories: ["/path/to/other/project"]
});

Feature: distinguish enterprise-managed permission approvals

permission.requested events and permission handler callbacks now carry an optional managedApprovalRequired flag. When set, the permission must be approved by a person — built-in approve-all handlers refuse it loudly rather than silently approving, and custom handlers can inspect the flag to surface a proper UI prompt. (#2080)

Other changes

• bugfix: [Python] serialize Pydantic models with mode='json' in tool results to avoid serialization errors (#2225)

New contributors

• @joshspicer made their first contribution in #2080
• @connor4312 made their first contribution in #2112
• @DonJayamanne made their first contribution in #2180

Generated by Release Changelog Generator · sonnet46 18.7 AIC · ⌖ 4.92 AIC · ⊞ 8.6K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.73, model: claude-sonnet-4.6, id: 30870194454, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/30870194454 -->

Bug fixes

• bugfix: [Python] sessions.list() raised ValueError for any non-empty session list due to boolean-discriminated union decoding bug (#2123)
• bugfix: [Python] binary tool results (e.g., base64 image data) were silently dropped when forwarding tool responses, causing the model to report it could not view images (#1821)
• bugfix: [Python] codegen emitted an unintended synthetic class name (PermissionDecisionApproveForIonApproval) for permission approval types; now emits the correct schema-named aliases (PermissionDecisionApproveForSessionApproval, PermissionDecisionApproveForLocationApproval) (#1652)
• bugfix: [C#] CustomAgentsLocalOnly was only sent via session.options.update after session creation, arriving too late to restrict agent discovery to the working directory; it is now included in the session.create and session.resume wire payloads (#1899)

New contributors

• @abhinavgautam01 made their first contribution in #1652
• @arimu1 made their first contribution in #2032

Generated by Release Changelog Generator · sonnet46 21.4 AIC · ⌖ 4.16 AIC · ⊞ 8.6K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.73, model: claude-sonnet-4.6, id: 30652792188, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/30652792188 -->

Feature: Agent Factories authoring surface [experimental]

Agent Factories let a trusted extension declare a JavaScript closure that orchestrates a fleet of subagents, then invoke it by name. The runtime invokes the factory closure over a reverse RPC call, passing primitives to spawn subagents, journal results (so a resumed run replays completed work for free), compose work in parallel or as a pipeline, and report progress. (#2114)

import { defineFactory, joinSession } from "`@github/copilot-sdk`/extension";

const myFactory = defineFactory({
  meta: { name: "my-factory", description: "Orchestrates subagents" },
  run: async ({ spawnAgent, journal }) => {
    const result = await spawnAgent({ prompt: "Summarize the repo" });
    return journal("done", result);
  },
});

const session = await joinSession({ factories: [myFactory] });
const run = await session.factory.run({ name: "my-factory", input: {} });

Everything is gated behind the runtime's agent_factories flag and billing gate, and all public types are marked @experimental.

New contributors

• @nytron88 made their first contribution in #2117
• @syedkazmi14 made their first contribution in #2101
• @smz202000 made their first contribution in #2019

Generated by Release Changelog Generator · sonnet46 25.9 AIC · ⌖ 5.11 AIC · ⊞ 8.6K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.73, model: claude-sonnet-4.6, id: 30575593646, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/30575593646 -->

Feature: agentStop lifecycle hook

Applications can now intercept the natural stopping point of the top-level agent across all SDKs. Return { decision: "block", reason } to enqueue a follow-up message and keep the agent running; omit or return no decision to let it stop normally. (#2054)

session.hooks.agentStop(async ({ stopHookActive }) => {
  if (stopHookActive) return; // don't block continuation turns
  return { decision: "block", reason: "Run final validation and fix any failures." };
});

session.Hooks.AgentStop(async (input, ct) => {
    if (input.StopHookActive) return null; // don't block continuation turns
    return new AgentStopOutput { Decision = "block", Reason = "Run final validation and fix any failures." };
});

Feature: startup timing breakdown for the Rust SDK

Client::start now exposes a StartupTimings struct that breaks down initialization latency into per-phase millisecond fields (process_spawn_ms, transport_setup_ms, handshake_ms, and more), making it easier to diagnose cold-start performance. (#2066)

Feature: [Java] custom JSON schema override for @CopilotToolParam

The @CopilotToolParam annotation now accepts an optional schema attribute for passing an explicit JSON Schema string, enabling support for third-party types that the built-in schema generator cannot automatically map. (#2069)

`@CopilotTool`("Schedule a deployment")
public String scheduleDeployment(
    `@CopilotToolParam`(value = "Deployment time in ISO-8601",
        schema = "{\"type\":\"string\",\"format\":\"date-time\"}")
    com.acme.internal.AcmeDateTime deployTime) { ... }

Other changes

• improvement: [Java] enforce non-blank @CopilotToolParam descriptions at compile time (#1980)
• bugfix: [C#] release oversized JSON-RPC receive buffers after large frames to reduce memory retention (#2047)
• improvement: [Rust] emit type aliases for scalar RPC result schemas in generated code (#2110)

New contributors

• @adirh3 made their first contribution in #2047

Generated by Release Changelog Generator · sonnet46 45.2 AIC · ⌖ 4.94 AIC · ⊞ 8.6K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.73, model: claude-sonnet-4.6, id: 30515313396, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/30515313396 -->

Feature: per-agent reasoning effort

Custom sub-agents can now have their own reasoning effort level, independent of the parent session. When reasoningEffort is omitted on a custom agent, the backend applies its own default — the session-level setting is not inherited. (#1981)

const session = await client.createSession({
    customAgents: [{
        name: "planner",
        prompt: "You plan tasks.",
        reasoningEffort: "high",
    }],
});

var session = await client.CreateSessionAsync(new SessionOptions {
    CustomAgents = [new CustomAgentConfig {
        Name = "planner",
        Prompt = "You plan tasks.",
        ReasoningEffort = ReasoningEffort.High,
    }],
});

Other changes

• improvement: strongly type expAssignments session config field across all SDKs (#2033)
• bugfix: [Rust] fix ask_user starving the per-session event loop (#2034)

New contributors

• @lukewar made their first contribution in #1880

[!WARNING] <details> <summary>Firewall blocked 1 domain</summary>

The following domain was blocked by the firewall during workflow execution:

• awmgmcpg

To allow these domains, add them to the network.allowed list in your workflow frontmatter:

network:
  allowed:
    - defaults
    - "awmgmcpg"

See Network Configuration for more information.

</details>

Generated by Release Changelog Generator · 39.1 AIC · ⌖ 5.54 AIC · ⊞ 7.2K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.70, model: claude-sonnet-4.6, id: 29965645125, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/29965645125 -->

Feature: custom agent reasoning effort

You can now set a per-agent reasoning effort level on custom agent configurations. When omitted, the backend chooses its default; an explicit value overrides the backend default for that specific agent without affecting the parent session. (#1981)

const config: CustomAgentConfig = {
  name: "my-agent",
  prompt: "...",
  reasoningEffort: "high",
};

var config = new CustomAgentConfig {
    Name = "my-agent",
    Prompt = "...",
    ReasoningEffort = "high",
};

[!WARNING] <details> <summary>Firewall blocked 1 domain</summary>

The following domain was blocked by the firewall during workflow execution:

• awmgmcpg

To allow these domains, add them to the network.allowed list in your workflow frontmatter:

network:
  allowed:
    - defaults
    - "awmgmcpg"

See Network Configuration for more information.

</details>

Generated by Release Changelog Generator · 53.4 AIC · ⌖ 4.74 AIC · ⊞ 7.3K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.70, model: claude-sonnet-4.6, id: 29849964843, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/29849964843 -->

Feature: in-process (FFI) transport

The SDK can now host the Copilot runtime in-process by loading the native runtime library via its C ABI (FFI), eliminating the overhead of spawning a child process. This experimental transport is available for Node.js, Rust, Python, and Go. (#1953, #1915, #1975, #1976)

const client = new CopilotClient({ connection: RuntimeConnection.forInProcess() });

var client = new CopilotClient(new CopilotClientOptions { Connection = RuntimeConnection.ForInProcess() });

Feature: tool search configuration

A new toolSearch session option controls how the SDK defers tools when the total tool count exceeds a threshold. When enabled (the default), excess MCP and external tools are surfaced on demand through the built-in tool_search_tool rather than pre-loaded into every prompt. Tool results can also include toolReferences to link cited sources back to the tool that produced them. (#1933)

const session = await client.createSession({
    toolSearch: { defer: "auto" },
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    ToolSearch = new ToolSearchConfig { Defer = "auto" },
});

Feature: opaque metadata passthrough on tool definitions

Tool definitions now accept an optional metadata bag that is forwarded verbatim in session.create and session.resume RPC calls. This lets hosts attach namespaced, implementation-specific metadata to tools without expanding the typed public contract; unknown keys are preserved and round-tripped untouched. (#1864)

session.defineTool("my-tool", { metadata: { "myapp:priority": 1 } }, handler);

session.DefineTool("my-tool", new ToolOptions { Metadata = new() { ["myapp:priority"] = 1 } }, handler);

Other changes

• feature: [All SDKs] add canvasProvider field to session create/resume config so hosts can supply a stable canvas-provider identity that survives cold resume (#1847)
• feature: [All SDKs] forward enableManagedSettings flag in session create/resume for enterprise managed-settings enforcement (#1925)
• feature: [All SDKs] propagate agentId, parentAgentId, and interactionType from LLM inference start frames into request-handler contexts (#1949)
• improvement: [Rust] make tool schema and MCP server serialization deterministic by replacing HashMap with IndexMap (#1931)
• improvement: [Rust] use native-tls for the build-time CLI download (#1964)
• bugfix: [.NET] avoid Windows in-process test teardown deadlock (#1997)

New contributors

• @agoncal made their first contribution in #1951
• @Shivam60 made their first contribution in #1964
• @rinceyuan made their first contribution in #1978
• @belaltaher8 made their first contribution in #1864

Full Changelog: https://github.com/github/copilot-sdk/compare/v1.0.6...v1.0.7

Generated by Release Changelog Generator · sonnet46 1.2M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 29510898443, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/29510898443 -->

Feature: tool search configuration

Tool search lets the model discover tools on demand instead of loading every tool definition up front. When the active tool count exceeds the deferral threshold, MCP and external tools are marked as deferred and surfaced through the built-in tool_search_tool. This release adds a toolSearch option to CreateSession/ResumeSession so applications can enable/disable the feature and tune the threshold. (#1933)

const session = await client.createSession({
  toolSearch: { enabled: true, deferThreshold: 20 },
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    ToolSearch = new ToolSearchConfig { Enabled = true, DeferThreshold = 20 },
});

Tool results can now return toolReferences — a list of tool names chosen by a tool-search override — to narrow the active tool set before the next model turn.

Feature: in-process (FFI) transport for Python and Go

The Python and Go SDKs now support loading the Copilot runtime as a native shared library in-process, matching the existing .NET, TypeScript, and Rust implementations. This avoids spawning a child process and communicates over the runtime's C ABI instead of stdio or TCP. (#1975, #1976)

Python — experimental, no new dependencies (uses stdlib ctypes):

from copilot import CopilotClient, RuntimeConnection
client = CopilotClient(connection=RuntimeConnection.for_inprocess())

Go — requires the copilot_inprocess build tag:

// build with: go build -tags copilot_inprocess
client, _ := sdk.NewClient(&sdk.ClientOptions{
    Connection: &sdk.InProcessConnection{},
})

The SDK selects and provisions the native runtime automatically. Per-client Env, WorkingDirectory, and Telemetry settings are not supported with in-process transport (they cannot be isolated in a shared host process). Set COPILOT_SDK_DEFAULT_CONNECTION=inprocess to use in-process transport by default across your application.

New contributors

• @rinceyuan made their first contribution in #1978

Generated by Release Changelog Generator · sonnet46 762.9K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 29385766972, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/29385766972 -->

Feature: in-process FFI transport for Rust SDK

The Rust SDK can now host the Copilot runtime as an in-process cdylib instead of spawning a CLI subprocess. Select it with Transport::InProcess or set COPILOT_SDK_DEFAULT_CONNECTION=inprocess. (#1915)

let client = ClientOptions::new()
    .transport(Transport::InProcess)
    .build()?;

The existing Transport::Stdio and Transport::Tcp variants are fully backward-compatible — no breaking changes for current consumers.

Other changes

• improvement: [Rust] switch build-time CLI download from rustls/ring to native-tls to resolve Microsoft Component Governance advisory (#1964)

New contributors

• @Shivam60 made their first contribution in #1964

Generated by Release Changelog Generator · sonnet46 447.1K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 29133943660, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/29133943660 -->

Feature: in-process (FFI) transport for the Node.js SDK

The Node.js SDK now supports an experimental in-process transport that hosts the Copilot runtime as a native library via FFI (using [koffi]((koffi.dev/redacted), instead of spawning a child process. This reduces process overhead and eliminates the need for a separate CLI installation when using a bundled native runtime. (#1953)

const connection = RuntimeConnection.forInProcess("/path/to/libcopilot-runtime.so");
const client = new CopilotClient({ runtimeConnection: connection });

Feature: canvasProvider field on session config

All SDKs (Node.js, .NET, Go, Python, Rust) now support an optional canvasProvider field on session create and resume config. This lets host connections supply a stable canvas-provider identity so host-provided canvases restore correctly across cold resume. (#1847)

• TypeScript: canvasProvider: { id: "app:builtin:my-host", name: "My Host" }
• C#: CanvasProvider = new CanvasProviderIdentity { Id = "app:builtin:my-host" }
• Python: canvas_provider=CanvasProviderIdentity(id="app:builtin:my-host")
• Go: CanvasProvider: &CanvasProviderIdentity{Id: "app:builtin:my-host"}

Feature: agent metadata in request handler contexts

Request handler callbacks across all SDKs (Node.js, Python, Go, .NET, Rust, Java) now expose agentId, parentAgentId, and interactionType from LLM inference request-start frames. This lets BYOK/CAPI request handlers identify which agent is making the inference request, and whether it is a subagent call. (#1949)

Other changes

• bugfix: [.NET] fix request-handler forwarding so GET/HEAD requests do not receive an empty content body (#1949)

Generated by Release Changelog Generator · sonnet46 498.2K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 29070724716, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/29070724716 -->

Feature: enableManagedSettings for enterprise policy enforcement (all SDKs)

Applications can now pass enableManagedSettings when creating or resuming a session to opt the runtime into enterprise managed-settings enforcement (bypass-permissions policy) using the session's gitHubToken. This is purely additive and opt-in — omitting it behaves exactly as before. (#1925)

const session = await client.createSession({
  gitHubToken: "...",
  enableManagedSettings: true,
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    GitHubToken = "...",
    EnableManagedSettings = true,
});

• Python: enable_managed_settings=True kwarg on create_session / resume_session
• Go: EnableManagedSettings: boolPtr(true) on SessionConfig / ResumeSessionConfig
• Rust: .with_enable_managed_settings(true) builder on SessionConfig
• Java: sessionConfig.setEnableManagedSettings(true) on SessionConfig

Fix: deterministic tool schema serialization in Rust SDK ⚠️ Breaking change

The Rust SDK previously used HashMap for Tool.parameters and mcp_servers fields, causing random key ordering in serialized JSON each process startup. This busted the model provider's prompt cache on the system+tools prefix, increasing cost and latency. HashMap is now replaced with IndexMap for these model-visible maps. (#1931)

IndexMap mirrors HashMap's API and is re-exported as github_copilot_sdk::IndexMap — migration is mechanical:

// Before: use std::collections::HashMap;
// After:
use github_copilot_sdk::IndexMap; // same API, deterministic iteration order

Affected public types: Tool.parameters, mcp_servers on SessionConfig / ResumeSessionConfig / CustomAgentConfig, and the tool_parameters / try_tool_parameters return types.

New contributors

• @agoncal made their first contribution in #1951

Generated by Release Changelog Generator · sonnet46 987.8K

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 29030149715, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/29030149715 -->

What's Changed

• Stream Anthropic /messages responses in E2E fake handlers by @stephentoub in https://github.com/github/copilot-sdk/pull/1868
• [changelog] Add changelog for java/v1.0.5-01 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1871
• [changelog] Add changelog for v1.0.5 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1869
• Add experimental GitHub telemetry redirection across all SDKs by @MackinnonBuck in https://github.com/github/copilot-sdk/pull/1835
• Update @github/copilot to 1.0.68 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1886
• Update Java JaCoCo coverage badge by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1833
• Remove Java JaCoCo badge auto-update pipeline by @brunoborges with @Copilot in https://github.com/github/copilot-sdk/pull/1826
• Update @github/copilot to 1.0.69-0 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1892
• Edburns/1810 java tool ergonomics tool as lambda seeking review by @edburns in https://github.com/github/copilot-sdk/pull/1895
• test(java): add arity 0 and arity 2 coverage to ErgonomicToolDefinitionIT by @edburns in https://github.com/github/copilot-sdk/pull/1897
• Update @github/copilot to 1.0.69-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1908
• Fix telemetry forwarding handshake CI failures by @stephentoub in https://github.com/github/copilot-sdk/pull/1909
• Improve E2E coverage across SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1906
• dotnet: in-process FFI runtime hosting (InProcess transport) by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1901
• Update @github/copilot to 1.0.69-2 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1914
• Remove P2 installation, use simple retry instead by @edburns in https://github.com/github/copilot-sdk/pull/1916
• Restrict block-remove-before-merge check to PRs targeting main by @edburns in https://github.com/github/copilot-sdk/pull/1898
• docs(java): add ADR-007 native runtime bundling strategy by @edburns in https://github.com/github/copilot-sdk/pull/1923
• Honor inprocess transport in C# E2E harness and fix in-process auth by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1920
• Simplify in-process env isolation to snapshot/restore by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1929
• fix(python): preserve original JSON keys in Data shim round-trips by @syf2211 in https://github.com/github/copilot-sdk/pull/1900
• C#: make per-client Environment coherent per transport by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1930
• Make .NET CopilotClient.DisposeAsync graceful by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1932
• Update @github/copilot to 1.0.69-3 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1940
• Surface Pydantic ValidationError to LLM in tool arg validation by @idryzhov in https://github.com/github/copilot-sdk/pull/1862
• Update @github/copilot to 1.0.69 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1941

New Contributors

• @syf2211 made their first contribution in https://github.com/github/copilot-sdk/pull/1900

Full Changelog: https://github.com/github/copilot-sdk/compare/v1.0.5...v1.0.6

Feature: experimental context attribution APIs

Two new experimental methods on session.metadata provide per-source token attribution for the session's context window. (#1886)

getContextAttribution() returns a flat list of attribution entries — skills, subagents, MCP servers, tools, plugins — each with a token count and hierarchical nesting via parentId. getContextHeaviestMessages() returns the largest individual messages currently in context, most-expensive first.

const attr = await session.metadata.getContextAttribution();
// attr.contextAttribution.entries → [{ kind: 'skill', id: 'skill:tmux', tokens: 1234, ... }, ...]
const heavy = await session.metadata.getContextHeaviestMessages({ limit: 10 });

var attr = await session.Metadata.GetContextAttributionAsync();
var heavy = await session.Metadata.GetContextHeaviestMessagesAsync(limit: 10);

Other changes

• feature: SlashCommandInput now supports an optional choices field, allowing slash commands to declare selectable literal options with human-facing descriptions (#1886)
• feature: ExternalToolTextResultForLlm now supports toolReferences for returning deferred tool names to the model from a tool-search override (#1886)

Generated by Release Changelog Generator · claude-sonnet-4.6

Generated by Release Changelog Generator · sonnet46 1.8M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 28602028763, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/28602028763 -->

Feature: experimental GitHub telemetry redirection

All SDKs now support an optional onGitHubTelemetry callback in ClientOptions that lets hosts receive per-session GitHub telemetry events forwarded by the runtime. When a handler is registered, the client automatically opts sessions in via enableGitHubTelemetryRedirection and dispatches each incoming gitHubTelemetry.event notification to the callback. This feature is experimental, intentionally hidden from public IDE completion in C# ([EditorBrowsable(Never)]) and Rust (#[doc(hidden)]). (#1835)

const client = new CopilotClient({
  onGitHubTelemetry: (notification) => { /* handle telemetry event */ },
});

var client = new CopilotClient(new CopilotClientOptions
{
    OnGitHubTelemetry = (notification) => { /* handle telemetry event */ return Task.CompletedTask; },
});

Generated by Release Changelog Generator · sonnet46 1.2M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 28552536351, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/28552536351 -->

Feature: MCP OAuth host token handlers

SDK applications can now handle OAuth challenges from MCP servers that require host-provided authentication. Register an onMcpAuthRequest callback on the session config and the SDK will invoke it whenever an MCP server responds with a 401 WWW-Authenticate challenge; return an access token (or cancel the request). Supports initial auth, refresh, reauth, and upscope flows across all SDKs. (#1669)

const session = await client.createSession({
    onMcpAuthRequest: async (request) => ({
        accessToken: await myIdentityProvider.getToken(request.serverUrl),
    }),
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    OnMcpAuthRequest = async ctx =>
        McpAuthResult.FromToken(new McpAuthToken
        {
            AccessToken = await myIdentityProvider.GetTokenAsync(ctx.ServerUrl)
        }),
});

Feature: session options for citations, excluded agents, and spending limits

Three additional session configuration options are now available across all SDKs. (#1865)

const session = await client.createSession({
    enableCitations: true,
    excludedBuiltinAgents: ["github-search"],
    sessionLimits: { maxAiCredits: 10 },
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    EnableCitations = true,
    ExcludedBuiltInAgents = ["github-search"],
    SessionLimits = new SessionLimitsConfig { MaxAiCredits = 10 },
});

Other changes

• improvement: [All SDKs] rename BYOK callback field getBearerToken → bearerTokenProvider; add sessionId to ProviderTokenArgs for per-session token scoping (#1796)
• bugfix: [Node] fix MCP OAuth registerInterest sent before session.resume, causing "Session not found" errors when resuming a session with onMcpAuthRequest (#1861)
• feature: [Java] @CopilotTool and @CopilotToolParam annotations with compile-time annotation processor for ergonomic tool registration via ToolDefinition.fromObject() (#1792, #1838)
• feature: [Java] ToolInvocation parameter injection in @CopilotTool methods for accessing session context without exposing it to the LLM schema (#1832)
• feature: [Rust] add 9 GitHub-anchored variants to Attachment enum (GitHubCommit, GitHubRelease, GitHubActionsJob, GitHubRepository, GitHubFileDiff, GitHubTreeComparison, GitHubUrl, GitHubFile, GitHubSnippet) (#1823)

New contributors

• @pallaviraiturkar0 made their first contribution in #1823
• @roji made their first contribution in #1827
• @coleflennikenmsft made their first contribution in #1854
• @szabta89 made their first contribution in #1856

Full Changelog: https://github.com/github/copilot-sdk/compare/v1.0.4...v1.0.5

Generated by Release Changelog Generator · sonnet46 2.6M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 28527869621, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/28527869621 -->

Feature: MCP OAuth host token callbacks

When a Copilot session connects to an OAuth-protected MCP server, the SDK now calls back to your application to supply OAuth tokens. Register an onMcpAuthRequest handler in the session config to provide tokens or cancel the request. (#1669)

const session = await client.startSession({
  onMcpAuthRequest: async (request) => {
    const token = await myOAuthFlow(request.serverUrl, request.reason);
    return token ? { kind: "token", accessToken: token } : { kind: "cancelled" };
  },
});

var session = await client.StartSessionAsync(new SessionConfig
{
    OnMcpAuthRequest = async (ctx) =>
    {
        var token = await MyOAuthFlow(ctx.ServerUrl, ctx.Reason);
        return token is not null
            ? McpAuthResult.FromToken(new McpAuthToken { AccessToken = token })
            : McpAuthResult.Cancel();
    },
});

Feature: sessionId in BYOK bearer-token callback; field renamed to bearerTokenProvider

The BYOK config field has been renamed from getBearerToken to bearerTokenProvider across all SDKs. The callback now also receives a sessionId, so a single callback shared across multiple sessions can scope token acquisition or caching per session. (#1796)

const client = new CopilotClient({
  provider: {
    bearerTokenProvider: async ({ providerName, sessionId }) => {
      return await getTokenForSession(sessionId);
    },
  },
});

var client = new CopilotClient(new CopilotClientConfig
{
    Provider = new ProviderConfig
    {
        BearerTokenProvider = async (args) => await GetTokenForSession(args.SessionId),
    },
});

Feature: Java @CopilotTool annotation-based tool definition

Java applications can now define Copilot tools by annotating methods with @CopilotTool and @CopilotToolParam instead of building ToolDefinition objects manually. A compile-time annotation processor generates the metadata, and ToolDefinition.fromObject() registers all annotated methods at once. (#1792)

`@CopilotTool`("Get the current weather for a given city")
public String getWeather(
        `@CopilotToolParam`(value = "The city", required = true) String city,
        `@CopilotToolParam`(value = "Unit: celsius or fahrenheit", defaultValue = "celsius") String unit) {
    return fetchWeather(city, unit);
}

List<ToolDefinition> tools = ToolDefinition.fromObject(new WeatherTools());

Other changes

• feature: [Java] @CopilotTool methods can declare ToolInvocation as a hidden injected parameter to access runtime context such as sessionId (#1832)
• feature: [Java] rename @Param annotation to @CopilotToolParam (#1838)
• feature: [Rust] add 9 GitHub-anchored variants to the Attachment enum (GitHubCommit, GitHubRelease, GitHubActionsJob, GitHubRepository, GitHubFileDiff, GitHubTreeComparison, GitHubUrl, GitHubFile, GitHubSnippet) (#1823)

New contributors

• @pallaviraiturkar0 made their first contribution in #1823
• @roji made their first contribution in #1827

Generated by Release Changelog Generator · sonnet46 1.5M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 28432082983, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/28432082983 -->

Feature: BYOK bearer-token provider gets sessionId and is renamed to bearerTokenProvider

The BYOK bearer-token provider callback now receives a sessionId parameter, enabling per-session token scoping or caching. The configuration field has been renamed from getBearerToken to bearerTokenProvider across all six SDKs (and the callback type to BearerTokenProvider), aligning with the existing *Provider naming convention. (#1796)

const client = new CopilotClient({
  bearerTokenProvider: async ({ sessionId }) => getTokenForSession(sessionId),
});

var client = new CopilotClient(new CopilotClientOptions {
    BearerTokenProvider = async (args) => await GetTokenForSessionAsync(args.SessionId),
});

Feature: @CopilotTool annotation for ergonomic Java tool registration

Java applications can now declare tools using the @CopilotTool and @Param annotations. The SDK's annotation processor generates the necessary metadata at compile time; use ToolDefinition.fromObject(...) to register an entire object's annotated methods without manual JSON schema construction. (#1792)

Note: This API is currently @CopilotExperimental.

`@CopilotTool`("Get the current weather for a city")
public String getWeather(
        `@Param`(value = "City name", required = true) String city,
        `@Param`(value = "Unit: celsius or fahrenheit", required = false, defaultValue = "celsius") String unit) {
    // implementation
}

// Registration:
List<ToolDefinition> tools = ToolDefinition.fromObject(new WeatherTools());

Feature: GitHub-anchored attachment variants added to Rust SDK

The Rust Attachment enum now includes all 9 GitHub-anchored reference types that the CLI can deliver — GitHubCommit, GitHubRelease, GitHubActionsJob, GitHubRepository, GitHubFileDiff, GitHubTreeComparison, GitHubUrl, GitHubFile, and GitHubSnippet. Previously these variants were silently dropped at the SDK boundary when received. (#1823)

New contributors

• @pallaviraiturkar0 made their first contribution in #1823

Generated by Release Changelog Generator · sonnet46 1.1M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 28381408107, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/28381408107 -->

What's Changed

• Add experimental multi-provider BYOK registry config across all six SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1718
• [changelog] Add changelog for v1.0.2 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1714
• edburns/java-add-spotless-to-java-coding-skill by @edburns in https://github.com/github/copilot-sdk/pull/1723
• Add Java low-level tool definition E2E test and skill [1/6] by @edburns in https://github.com/github/copilot-sdk/pull/1721
• Add Node.js low-level tool-definition E2E test [3/6] by @edburns in https://github.com/github/copilot-sdk/pull/1725
• Add Go low-level tool-definition E2E test [2/6] by @edburns in https://github.com/github/copilot-sdk/pull/1724
• Add Python low-level tool-definition E2E test [4/6] by @edburns in https://github.com/github/copilot-sdk/pull/1726
• Add .NET low-level tool-definition E2E test [6/6] by @edburns in https://github.com/github/copilot-sdk/pull/1728
• Add Rust low-level tool-definition E2E test [5/6] by @edburns in https://github.com/github/copilot-sdk/pull/1727
• Fix codegen schema resolution for new @github/copilot package layout by @stephentoub in https://github.com/github/copilot-sdk/pull/1738
• Update @github/copilot to 1.0.64-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1739
• Bump undici from 6.24.1 to 6.27.0 in /scripts/corrections in the npm_and_yarn group across 1 directory by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/1742
• Add capi.enableWebSocketResponses and provider.transport session options by @dereklegenzoff in https://github.com/github/copilot-sdk/pull/1711
• Python: switch from bundled CLI wheels to downloading explicitly or at runtime by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1744
• Update @github/copilot to 1.0.64-3 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1752
• HTTP request callback support by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1689
• fix(rust): backdate extracted CLI mtime to stop build.rs self-invalidation by @redsun82 in https://github.com/github/copilot-sdk/pull/1776
• Address stephentoub review feedback on HTTP request callback support (+ cross-SDK parity) by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1775
• Strong-name sign .NET SDK by @stephentoub in https://github.com/github/copilot-sdk/pull/1778
• Harden bundled Copilot CLI extraction against corrupt/partial installs by @jmoseley in https://github.com/github/copilot-sdk/pull/1635
• Clean up HTTP passthrough API by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1784
• Document Java memory section and add Copilot Memory links across SDK READMEs by @Morabbin in https://github.com/github/copilot-sdk/pull/1783
• Add preamble section and preserve action to SDKs by @MackinnonBuck in https://github.com/github/copilot-sdk/pull/1713
• fix(nodejs): handle stdio stdin errors by @sjh9714 in https://github.com/github/copilot-sdk/pull/1584
• docs: add system message customization section to Python README by @Halcyonhal9 in https://github.com/github/copilot-sdk/pull/1066
• Add embeddedcli.Path() accessor for the resolved CLI path by @tbrady77 in https://github.com/github/copilot-sdk/pull/1677
• normalize-sharing-prompts-during-iteration by @edburns in https://github.com/github/copilot-sdk/pull/1729
• Expose exp_assignments injection on session create/resume across all SDKs by @ellismg in https://github.com/github/copilot-sdk/pull/1750
• Update @github/copilot to 1.0.65 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1793
• Add getBearerToken callback for BYOK providers (Managed Identity) by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1748

New Contributors

• @dereklegenzoff made their first contribution in https://github.com/github/copilot-sdk/pull/1711
• @redsun82 made their first contribution in https://github.com/github/copilot-sdk/pull/1776
• @sjh9714 made their first contribution in https://github.com/github/copilot-sdk/pull/1584
• @Halcyonhal9 made their first contribution in https://github.com/github/copilot-sdk/pull/1066
• @tbrady77 made their first contribution in https://github.com/github/copilot-sdk/pull/1677
• @ellismg made their first contribution in https://github.com/github/copilot-sdk/pull/1750

Full Changelog: https://github.com/github/copilot-sdk/compare/v1.0.2...v1.0.4

Feature: opt-in memory for sessions

Sessions can now be configured with persistent memory, allowing the agent to recall information across turns. Set memory: { enabled: true } when creating or resuming a session; when omitted the runtime default applies. (#1617)

const session = await client.createSession({
    memory: { enabled: true },
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    Memory = new MemoryConfiguration { Enabled = true }
});

Feature: defer parameter for tool definitions

Tools now support a defer option controlling whether they are pre-loaded eagerly or surfaced lazily through tool search. Use "auto" (the default) to allow lazy loading, or "never" to force pre-loading. (#1632)

defineTool("lookup_issue", {
    description: "Fetch issue details",
    parameters: z.object({ id: z.string() }),
    defer: "auto",
    handler: async ({ id }) => { /* ... */ },
});

var tool = CopilotTool.DefineTool(
    async ([Description("Issue ID")] string id) => { /* ... */ },
    toolOptions: new CopilotToolOptions { Defer = CopilotToolDefer.Auto });

Other changes

• feature: [All SDKs] add otlpProtocol telemetry option ("http/json" or "http/protobuf") for configuring OTLP export transport (#1648)
• feature: [All SDKs] surface ModelBilling.tokenPrices on public SDK types, exposing per-tier input/output/cache pricing and context window limits (#1633)
• improvement: [All SDKs] call runtime.shutdown during normal client stop for deterministic OTEL telemetry flush before process cleanup (#1667)
• improvement: [Go] thread context.Context through the JSON-RPC request path for proper cancellation support (#1643)
• improvement: [Java] add getOpenCanvases() to CopilotSession to track currently open canvas instances, matching the other SDKs (#1606)
• improvement: [Java] rename SystemPromptSections to SystemMessageSections for cross-SDK consistency; old class deprecated with forRemoval=true (#1683)
• bugfix: [Python] round sub-millisecond durations in to_timedelta_int to avoid serialization errors (#1668)
• bugfix: [Rust] skip CLI binary download in build.rs when DOCS_RS env var is set (#1660)

New contributors

• @andyfeller made their first contribution in #1631
• @almaleksia made their first contribution in #1632
• @idryzhov made their first contribution in #1668
• @scottaddie made their first contribution in #1636

Generated by Release Changelog Generator · sonnet46 1.8M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 27729623733, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/27729623733 -->

Feature: @CopilotExperimental compile-time gate for Java SDK

The Java SDK now ships a @CopilotExperimental annotation and a JSR 269 annotation processor that causes compilation to fail when experimental SDK APIs are referenced without opting in. Annotate a class or method with @AllowCopilotExperimental, or pass -Acopilot.experimental.allowed=true to the compiler to acknowledge the experimental status. (#1601)

// Opt in at the declaration level
`@AllowCopilotExperimental`
public class MyApp {
    // experimental SDK types and methods may be used here
}

<!-- Or opt in for the entire compilation unit via Maven -->
<compilerArgs>
    <arg>-Acopilot.experimental.allowed=true</arg>
</compilerArgs>

Other changes

• bugfix: [Node, Python, Go, .NET, Rust] open_canvases snapshot now correctly shrinks when session.canvas.closed is emitted — previously closed canvases were never removed (#1604)
• bugfix: [Go] generator no longer produces discriminator accessor names that collide with struct field names (#1596)
• bugfix: [Rust] generator now scopes RPC methods that reference internal schemas as pub(crate) instead of pub (#1596)
• improvement: [Java] generated types now propagate schema stability and deprecation metadata — experimental items gain @apiNote Javadoc and deprecated items gain @Deprecated (#1591)

Generated by Release Changelog Generator · sonnet46 1.9M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.55, model: claude-sonnet-4.6, id: 27291901369, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/27291901369 -->

What's Changed

• fix(dotnet): Add AOT-safe SetForegroundSessionRequest for SetForegroundSessionIdAsync() by @Encryptoid in https://github.com/github/copilot-sdk/pull/1144
• Update @github/copilot to 1.0.39-0 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1157
• Update @github/copilot to 1.0.39 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1167
• Update @github/copilot to 1.0.40-0 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1171
• Document --host for non-loopback headless connections by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1174
• Replace StreamJsonRpc with a custom JSON-RPC implementation in the .NET SDK by @stephentoub in https://github.com/github/copilot-sdk/pull/1170
• Update @github/copilot to 1.0.40-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1177
• Update @github/copilot to 1.0.40-3 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1182
• Update @github/copilot to 1.0.40 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1183
• Derive session event envelopes from schema by @stephentoub in https://github.com/github/copilot-sdk/pull/1184
• Expand E2E test coverage across all 4 SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1186
• docs: replace non-existent Docker image with build instructions by @patniko in https://github.com/github/copilot-sdk/pull/1189
• docs(python): clarify available_tools/excluded_tools filter all tools, not just built-ins by @loganrosen in https://github.com/github/copilot-sdk/pull/1180
• Add instructionDirectories session config support by @stephentoub in https://github.com/github/copilot-sdk/pull/1190
• Support optional connection token for TCP servers by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1176
• feat: add copilotHome option for configurable data directory by @patniko in https://github.com/github/copilot-sdk/pull/1191
• Refine version update logic to allow arbitrary identifiers (e.g., "beta", not just "preview") by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1193
• Update @github/copilot to 1.0.41-0 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1195
• Stabilize unknown session delete E2E assertions by @stephentoub in https://github.com/github/copilot-sdk/pull/1198
• Expand SDK E2E runtime coverage by @stephentoub in https://github.com/github/copilot-sdk/pull/1197
• Ignore C# Dev Kit *.csproj.lscache files by @MackinnonBuck in https://github.com/github/copilot-sdk/pull/1196
• Update byok.md by @patniko in https://github.com/github/copilot-sdk/pull/1203
• Make agent reload test runtime-compatible by @stephentoub in https://github.com/github/copilot-sdk/pull/1201
• Add offline GitHub proxy for E2E tests by @stephentoub in https://github.com/github/copilot-sdk/pull/1199
• Update @github/copilot to 1.0.41-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1202
• Harden Extension E2E Tests With --yolo For Permission Gate Compatibility by @MRayermannMSFT in https://github.com/github/copilot-sdk/pull/1204
• Fix .NET client startup cleanup race by @stephentoub in https://github.com/github/copilot-sdk/pull/1206
• Avoid shell kill cwd cleanup flakes by @stephentoub in https://github.com/github/copilot-sdk/pull/1207
• Add provider model and token limit overrides to ProviderConfig by @MackinnonBuck in https://github.com/github/copilot-sdk/pull/966
• Add Rust SDK (technical preview) by @tclem in https://github.com/github/copilot-sdk/pull/1164
• Update @github/copilot to 1.0.42 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1211
• Align Rust SDK public surface by @stephentoub in https://github.com/github/copilot-sdk/pull/1212
• Internalize env_value_mode (cross-SDK parity) by @tclem in https://github.com/github/copilot-sdk/pull/1215
• feat: add remote session support across all SDKs by @patniko in https://github.com/github/copilot-sdk/pull/1192
• Fix .NET E2E event capture race by @stephentoub in https://github.com/github/copilot-sdk/pull/1221
• Update @github/copilot to 1.0.43 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1218
• Add SDK tracing diagnostics by @stephentoub in https://github.com/github/copilot-sdk/pull/1217
• Add enableSessionTelemetry session option across SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1224
• Update @github/copilot to 1.0.44-2 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1225
• Docs normalization for the SDK -> Docs pipeline by @sunbrye in https://github.com/github/copilot-sdk/pull/1208
• Use string enums for .NET session events by @stephentoub in https://github.com/github/copilot-sdk/pull/1226
• Restore mode handler APIs across SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1228
• feat(rust): support binary tool results by @cschleiden in https://github.com/github/copilot-sdk/pull/1222
• Disable CI workflows on forked repositories by @IeuanWalker in https://github.com/github/copilot-sdk/pull/1232
• Default release publishing to prerelease by @Copilot in https://github.com/github/copilot-sdk/pull/1233
• Fix SDK documentation typos by @stephentoub in https://github.com/github/copilot-sdk/pull/1235
• Unify Rust SDK release with publish.yml workflow by @tclem in https://github.com/github/copilot-sdk/pull/1237
• Update @github/copilot to 1.0.44-3 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1239
• Replace Go RPC quicktype generation by @qmuntal in https://github.com/github/copilot-sdk/pull/1234
• fix(go): capture CLI stderr and fix SetProcessDone race by @claudiogodoy99 in https://github.com/github/copilot-sdk/pull/863
• Handle empty session fork behavior in E2E tests by @stephentoub in https://github.com/github/copilot-sdk/pull/1247
• Add Go reference badge to README by @qmuntal in https://github.com/github/copilot-sdk/pull/1253
• Expand Rust E2E coverage by @stephentoub in https://github.com/github/copilot-sdk/pull/1250
• Add Maven Central badge to README by @brunoborges in https://github.com/github/copilot-sdk/pull/1254
• Update README and guide for Rust SDK by @stephentoub in https://github.com/github/copilot-sdk/pull/1259
• Fix C# listFiles E2E ordering assumption by @stephentoub in https://github.com/github/copilot-sdk/pull/1261
• Update @github/copilot to 1.0.45 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1263
• Generate typed Go union interfaces by @qmuntal in https://github.com/github/copilot-sdk/pull/1252
• Use z-prefixed Go generated files by @qmuntal in https://github.com/github/copilot-sdk/pull/1268
• Support experimental schema types in codegen by @stephentoub in https://github.com/github/copilot-sdk/pull/1267
• Normalize skill context replay snapshots by @stephentoub in https://github.com/github/copilot-sdk/pull/1269
• Update @github/copilot to 1.0.46 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1270
• Temporarily use beta versions for "latest" dist-tag by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1283
• Fix codegen identifier sanitization by @stephentoub in https://github.com/github/copilot-sdk/pull/1285
• Update @github/copilot to 1.0.47 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1286
• Derive Default on generated Rust types by @tclem in https://github.com/github/copilot-sdk/pull/1272
• Generate Go bool discriminated unions by @qmuntal in https://github.com/github/copilot-sdk/pull/1284
• Update @github/copilot to 1.0.48-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1288
• Share generated schema definitions across SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1289
• Hide deprecated APIs where supported by @stephentoub in https://github.com/github/copilot-sdk/pull/1293
• Use schema descriptions in generated SDK docs by @stephentoub in https://github.com/github/copilot-sdk/pull/1291
• Update @github/copilot to 1.0.48 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1292
• Add remote_session field to all SDK SessionConfig types by @devm33 in https://github.com/github/copilot-sdk/pull/1295
• Fix shared schema comparison for Go codegen by @stephentoub in https://github.com/github/copilot-sdk/pull/1304
• Update @github/copilot to 1.0.49-0 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1305
• Update @github/copilot to 1.0.49-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1307
• feat: add model field to CustomAgentConfig across all SDKs by @patniko in https://github.com/github/copilot-sdk/pull/1309
• Fix Python Quick Start example to compile with current SDK by @stephentoub in https://github.com/github/copilot-sdk/pull/1310
• Fix Python session.send docs examples by @stephentoub in https://github.com/github/copilot-sdk/pull/1312
• Consolidate ask_user E2E snapshots into single canonical folder by @stephentoub in https://github.com/github/copilot-sdk/pull/1311
• Stabilize compaction E2E tests by @stephentoub in https://github.com/github/copilot-sdk/pull/1314
• Harden permission-reject E2E tests across all SDKs (#1194) by @stephentoub in https://github.com/github/copilot-sdk/pull/1317
• Honor preinstalled CLI path in .NET MSBuild targets (#921) by @stephentoub in https://github.com/github/copilot-sdk/pull/1318
• Add netstandard and net10 targets to C# SDK by @stephentoub in https://github.com/github/copilot-sdk/pull/1320
• Fix some argument validation in C# by @stephentoub in https://github.com/github/copilot-sdk/pull/1322
• Add .NET CopilotTool helper by @stephentoub in https://github.com/github/copilot-sdk/pull/1321
• Add cloud session config support by @tiagonbotelho in https://github.com/github/copilot-sdk/pull/1306
• Fix sub-agent hook propagation: expose sessionId on hook inputs by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1290
• Make tool callbacks optional across SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1308
• Fix permission handler kinds in SDK docs and samples (#1133) by @stephentoub in https://github.com/github/copilot-sdk/pull/1315
• Use 32-bit types for bounded schema integers by @stephentoub in https://github.com/github/copilot-sdk/pull/1329
• Seal generated session event types by @stephentoub in https://github.com/github/copilot-sdk/pull/1330
• Propagate experimental RPC markers through generated types by @stephentoub in https://github.com/github/copilot-sdk/pull/1331
• Clean up more argument validation by @stephentoub in https://github.com/github/copilot-sdk/pull/1328
• Update @github/copilot to 1.0.49-6 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1327
• Update @github/copilot to 1.0.49 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1333
• Export generated session event types by @stephentoub in https://github.com/github/copilot-sdk/pull/1316
• Fix .NET E2E auth setup by @stephentoub in https://github.com/github/copilot-sdk/pull/1334
• Add enum value descriptions to generated docs by @stephentoub in https://github.com/github/copilot-sdk/pull/1336
• Add SessionFs sqlite support for runtime sqlite routing by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1299
• Fix Python from_dict() round-trip for optional fields with schema defaults by @stephentoub in https://github.com/github/copilot-sdk/pull/1313
• Fix hook snapshot for runtime replay by @stephentoub in https://github.com/github/copilot-sdk/pull/1337
• Emit regex attributes from C# codegen by @stephentoub in https://github.com/github/copilot-sdk/pull/1338
• Strip Ms suffix for duration properties by @stephentoub in https://github.com/github/copilot-sdk/pull/1339
• Update @github/copilot to 1.0.51-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1340
• Update @github/copilot to 1.0.51-2 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1342
• Fix flaky Should_Accept_Both_MCP_Servers_And_Custom_Agents test by @stephentoub in https://github.com/github/copilot-sdk/pull/1346
• Add Rust (and C#) to SDK language lists across docs by @stephentoub in https://github.com/github/copilot-sdk/pull/1349
• Make MCPStdioServerConfig.args optional across all SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1347
• Publish .snupkg symbols package to NuGet.org by @stephentoub in https://github.com/github/copilot-sdk/pull/1345
• Update @github/copilot to 1.0.51-3 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1351
• Update @github/copilot to 1.0.51 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1353
• C# API review fixes by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1343
• Enable .NET E2E tests to run on .NET Framework (net472) by @stephentoub in https://github.com/github/copilot-sdk/pull/1358
• TypeScript SDK API review fixes by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1357
• Fix flaky pending-messages-modified E2E test across SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1362
• Go SDK API review fixes by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1360
• Add java to monorepo: Phase 02: code and test CI. by @edburns in https://github.com/github/copilot-sdk/pull/1348
• Bump org.apache.maven.plugins:maven-enforcer-plugin from 3.6.2 to 3.6.3 in /java in the java-maven-deps group by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/1365
• Update @github/copilot to 1.0.52-0 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1370
• Update @github/copilot to 1.0.52-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1371
• Add preMcpToolCall hook support to all SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1366
• Rust SDK API review fixes by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1367
• Python SDK API review fixes by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1376
• Add runtime_instructions system message section to all SDKs by @stephentoub in https://github.com/github/copilot-sdk/pull/1377
• Cross-SDK cleanup follow-ups from PR #1376 by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1378
• Rust SDK: PR #1367 review follow-ups by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1382
• Fix flaky SDK E2E tests by @stephentoub in https://github.com/github/copilot-sdk/pull/1379
• C# SDK: re-land x-opaque-json → JsonElement mapping with object boundary at RPC params by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1359
• Implement phase 03 of merge to monorepo plan by @edburns in https://github.com/github/copilot-sdk/pull/1369
• Fix .NET package version props generation by @stephentoub in https://github.com/github/copilot-sdk/pull/1387
• Rust SDK: bundle Copilot CLI by default by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1385
• Add Java-specific content to monorepo copilot-instructions.md by @edburns in https://github.com/github/copilot-sdk/pull/1391
• Java SDK: sync reference implementation to ^1.0.52-1, add preMcpToolCall hook, fix PingResponse timestamp type by @edburns in https://github.com/github/copilot-sdk/pull/1389
• Update @github/copilot to 1.0.52-4 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1393
• Update @github/copilot to 1.0.52 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1405
• Update @github/copilot to 1.0.53-2 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1408
• Add SDK canvas runtime support by @jmoseley in https://github.com/github/copilot-sdk/pull/1401
• Update @github/copilot to 1.0.53 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1410
• Update @github/copilot to 1.0.54 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1411
• Update @github/copilot to 1.0.55-0 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1412
• Bump brace-expansion from 5.0.5 to 5.0.6 in /scripts/docs-validation in the npm_and_yarn group across 1 directory by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/1325
• C# codegen: add isOpaqueJson guard to resolveRpcType by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1414
• Update vulnerable npm lockfile dependencies by @stephentoub in https://github.com/github/copilot-sdk/pull/1415
• Fix flaky SDK E2E tests by @stephentoub in https://github.com/github/copilot-sdk/pull/1418
• Change title from 'GitHub Copilot SDK documentation' to 'Copilot SDK' by @sunbrye in https://github.com/github/copilot-sdk/pull/1386
• Add cross-SDK RPC E2E coverage by @stephentoub in https://github.com/github/copilot-sdk/pull/1424
• SDK: Align canvas with codegen pipeline, add e2e tests by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1413
• Preserve JSON-RPC error data in .NET by @stephentoub in https://github.com/github/copilot-sdk/pull/1425
• Add post-tool-use failure hooks by @stephentoub in https://github.com/github/copilot-sdk/pull/1421
• Fixes #1434 Repackaging. by @edburns in https://github.com/github/copilot-sdk/pull/1437
• Update @github/copilot to 1.0.55-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1432
• Add MessageOptions.agentMode and fix per-message mode misuse by @MRayermannMSFT in https://github.com/github/copilot-sdk/pull/1438
• Update @github/copilot to 1.0.55-4 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1453
• Remove test/scenarios and scenario-builds CI by @patniko in https://github.com/github/copilot-sdk/pull/1448
• Add extract-to-cache build mode for the Copilot CLI by @tclem in https://github.com/github/copilot-sdk/pull/1450
• Move java to monorepo. Phase 05: Cross-Cutting Updates by @edburns in https://github.com/github/copilot-sdk/pull/1441
• Update @github/copilot to 1.0.55-5 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1456
• Multitenancy hardening: Client Mode by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1428
• Refactor Rust SDK errors to use structs with a kind() method by @heaths in https://github.com/github/copilot-sdk/pull/1400
• Use jsoncreator for AgentMode ctor, per review comments. by @edburns in https://github.com/github/copilot-sdk/pull/1465
• Update @github/copilot to 1.0.55-6 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1471
• Port copilot-sdk-java PR #232: reference-impl-sync with EMPTY mode fixes by @edburns in https://github.com/github/copilot-sdk/pull/1473
• Move Java to monorepo: Phase 06: Cutover and Cleanup by @edburns in https://github.com/github/copilot-sdk/pull/1472
• Add from https://github.com/github/copilot-sdk-java/pull/233 by @edburns in https://github.com/github/copilot-sdk/pull/1475
• Add displayPrompt support to session.send across all SDKs by @devm33 in https://github.com/github/copilot-sdk/pull/1470
• Update @github/copilot to 1.0.55-7 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1476
• Defer sessionId to server for cloud sessions by @stephentoub in https://github.com/github/copilot-sdk/pull/1479
• Re-invalidate build.rs when extracted CLI cache is removed by @tclem in https://github.com/github/copilot-sdk/pull/1480
• Canvas SDK: post-merge review followups (PR #1401) by @jmoseley in https://github.com/github/copilot-sdk/pull/1420
• feat: add MCP Apps (SEP-1865) support by @mattdholloway in https://github.com/github/copilot-sdk/pull/1335
• Config parity across SDKs: add largeOutput, pluginDirectories, spell out Directory by @stephentoub in https://github.com/github/copilot-sdk/pull/1482
• feat: add mcpOAuthTokenStorage support across all SDKs by @MackinnonBuck in https://github.com/github/copilot-sdk/pull/1326
• Integrate Bruno's PR 1478 with Ed's desired CI/CD changes by @edburns in https://github.com/github/copilot-sdk/pull/1483
• Update @github/copilot to 1.0.55 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1484
• Track live open canvas snapshots by @jmoseley in https://github.com/github/copilot-sdk/pull/1447
• Update @github/copilot to 1.0.56-0 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1485
• feat: add granular per-session flags for multitenancy hardening by @MackinnonBuck in https://github.com/github/copilot-sdk/pull/1474
• Apply review comments from standalone backport. by @edburns in https://github.com/github/copilot-sdk/pull/1486
• Update @github/copilot to 1.0.56-1 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1488
• Coordinate Copilot CLI stderr pump cleanup by @xoofx in https://github.com/github/copilot-sdk/pull/1136
• Skip JaCoCo (always fails on main) by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1492
• Expose install_bundled_cli and HAS_BUNDLED_CLI in the Rust SDK by @tclem in https://github.com/github/copilot-sdk/pull/1489
• Expose enableOnDemandInstructionDiscovery across all SDK SessionConfig types by @examon in https://github.com/github/copilot-sdk/pull/1323
• Edburns/fix jacoco failure on main by @edburns in https://github.com/github/copilot-sdk/pull/1497
• Update to use correct package name for generated by @edburns in https://github.com/github/copilot-sdk/pull/1499
• Plumb Extension SDK Path Through Session Create And Resume by @MRayermannMSFT in https://github.com/github/copilot-sdk/pull/1494
• Update Java JaCoCo coverage badge by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1500
• Update @github/copilot to 1.0.56-2 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1495
• Add typed context tier support by @stephentoub in https://github.com/github/copilot-sdk/pull/1503
• Add path-filtered CodeQL workflow for content-specific analysis by @Copilot in https://github.com/github/copilot-sdk/pull/1444
• Fixes #1443: per-language CodeQL targeting by @edburns in https://github.com/github/copilot-sdk/pull/1510
• Add reflection-based Jackson round-trip test for all generated types by @edburns in https://github.com/github/copilot-sdk/pull/1509
• On branch edburns/ghcp-sp-122-java-release-improvements by @edburns in https://github.com/github/copilot-sdk/pull/1512
• Edburns/ghcp sp 122 java release improvements by @edburns in https://github.com/github/copilot-sdk/pull/1514
• Update @github/copilot to 1.0.56 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1504
• Fix Go session event attachment aliases by @dmytrostruk in https://github.com/github/copilot-sdk/pull/1515
• Bump tar from 0.4.45 to 0.4.46 in /rust in the cargo group across 1 directory by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/1505
• Update @github/copilot to 1.0.57-2 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1517
• Update @github/copilot to 1.0.57-3 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1519
• docs: refresh for GA; add cloud sessions, fleet mode, multi-tenancy guides by @patniko in https://github.com/github/copilot-sdk/pull/1481
• Java: Make it so slash command responses are accessible via RPC by @edburns in https://github.com/github/copilot-sdk/pull/1520
• fix(python): derive version from package metadata; align Node version sentinel by @stephentoub in https://github.com/github/copilot-sdk/pull/1521
• Update @github/copilot to 1.0.57-4 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1522
• Map session.mcp.apps.callTool result to JsonNode and harden mvn clean by @edburns in https://github.com/github/copilot-sdk/pull/1523
• Add documentation site generation for Java SDK by @edburns in https://github.com/github/copilot-sdk/pull/1524
• Use JAVA_RELEASE_GITHUB_TOKEN for site deploy trigger by @edburns in https://github.com/github/copilot-sdk/pull/1525
• Consolidate Go initialism casing by @qmuntal in https://github.com/github/copilot-sdk/pull/1527
• Preserve empty Go slices and maps in JSON by @qmuntal in https://github.com/github/copilot-sdk/pull/1528
• Fix GitHub brand casing in SDK public surface by @stephentoub in https://github.com/github/copilot-sdk/pull/1531
• Update @github/copilot to 1.0.57 by @github-actions[bot] in https://github.com/github/copilot-sdk/pull/1534
• fix(nodejs): Map suppressResumeEvent to disableResume on the wire by @willglas in https://github.com/github/copilot-sdk/pull/1529
• Remove 'generated' from public API in Python and Rust by @SteveSandersonMS in https://github.com/github/copilot-sdk/pull/1535
• Bump vitest from 3.2.4 to 4.1.0 in /scripts/corrections in the npm_and_yarn group across 1 directory by @dependabot[bot] in https://github.com/github/copilot-sdk/pull/1537
• go: preserve tri-state session flags by @qmuntal in https://github.com/github/copilot-sdk/pull/1536
• De-flake builtin_tools E2E tests with a longer send timeout by @stephentoub in https://github.com/github/copilot-sdk/pull/1538
• Update java README with accurate validation steps by @edburns in https://github.com/github/copilot-sdk/pull/1541
• Java SDK: Update @github/copilot dependency to ^1.0.57 by @edburns in https://github.com/github/copilot-sdk/pull/1546
• Edburns/remove pr 1524 test java publish update notes to point to docs by @edburns in https://github.com/github/copilot-sdk/pull/1543
• java: disable ModeHandlersTest pending snapshot re-recording (#1547) by @edburns in https://github.com/github/copilot-sdk/pull/1548
• Refine Go SDK pre-GA API surfaces by @qmuntal in https://github.com/github/copilot-sdk/pull/1549

New Contributors

• @Encryptoid made their first contribution in https://github.com/github/copilot-sdk/pull/1144
• @loganrosen made their first contribution in https://github.com/github/copilot-sdk/pull/1180
• @tclem made their first contribution in https://github.com/github/copilot-sdk/pull/1164
• @sunbrye made their first contribution in https://github.com/github/copilot-sdk/pull/1208
• @cschleiden made their first contribution in https://github.com/github/copilot-sdk/pull/1222
• @IeuanWalker made their first contribution in https://github.com/github/copilot-sdk/pull/1232
• @claudiogodoy99 made their first contribution in https://github.com/github/copilot-sdk/pull/863
• @tiagonbotelho made their first contribution in https://github.com/github/copilot-sdk/pull/1306
• @heaths made their first contribution in https://github.com/github/copilot-sdk/pull/1400
• @mattdholloway made their first contribution in https://github.com/github/copilot-sdk/pull/1335
• @examon made their first contribution in https://github.com/github/copilot-sdk/pull/1323
• @dmytrostruk made their first contribution in https://github.com/github/copilot-sdk/pull/1515
• @willglas made their first contribution in https://github.com/github/copilot-sdk/pull/1529

Full Changelog: https://github.com/github/copilot-sdk/compare/v0.3.0...v1.0.0

Feature: [Go] idiomatic initialism casing across the Go SDK

All Go identifiers now use idiomatic uppercase initialisms as required by Go conventions. (#1527)

⚠️ Breaking change for Go callers. Key renames include:

• Api → API, Rpc → RPC, Mcp → MCP, Sse → SSE
• Url/Uri → URL/URI, Id → ID, Tcp → TCP
• Ado → ADO, Sdk → SDK, Fs → FS
• UriConnection → URIConnection, TcpConnection → TCPConnection

Feature: [Go] tri-state session boolean flags

SessionConfig.EnableConfigDiscovery, ResumeSessionConfig.EnableConfigDiscovery, and ResumeSessionConfig.ContinuePendingWork are now *bool instead of bool, allowing callers to express explicit false (opt out) vs. unset (defer to runtime default). (#1536)

⚠️ Breaking change for Go callers. Use copilot.Bool(true) / copilot.Bool(false) to set a value, or leave the field nil to defer to the runtime default.

cfg := copilot.SessionConfig{
    EnableConfigDiscovery: copilot.Bool(false), // explicitly opt out
}

Feature: [Java] slash command responses accessible via RPC

Java callers can now retrieve responses from slash commands via the RPC layer. Previously it was possible to invoke slash commands but not to receive their responses programmatically. (#1520)

Improvement: [Python/Rust] stable public namespaces for generated types

Generated types are no longer exposed under the internal generated sub-module. (#1535)

• Python: use copilot.session_events.X and copilot.rpc.X instead of copilot.generated.*
• Rust: use github_copilot_sdk::session_events::X and github_copilot_sdk::rpc::X instead of github_copilot_sdk::generated::*

Other changes

• bugfix: [Go] fix session event attachment aliases (#1515)
• bugfix: [Go] preserve empty slices and maps in JSON serialization (#1528)
• bugfix: [Node] map suppressResumeEvent to disableResume on the wire (#1529)
• improvement: [Java] map session.mcp.apps.callTool result to JsonNode (#1523)
• improvement: [Python] derive __version__ from package metadata; align Node version sentinel (#1521)
• improvement: fix GitHub brand casing across SDK public surface (#1531)

New contributors

• @dmytrostruk made their first contribution in #1515
• @willglas made their first contribution in #1529

Generated by Release Changelog Generator · ● 1.4M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.48, model: claude-sonnet-4.6, id: 26783077412, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/26783077412 -->

Fix: [C#] Coordinate Copilot CLI stderr pump cleanup

Fixes a race condition in the .NET CopilotClient where the stderr reader could outlive the CLI process during shutdown, causing TaskScheduler.UnobservedTaskException errors. The stderr pump now has its own cancellation token and connection cleanup properly coordinates pump shutdown before disposing the process. (#1136)

Feature: [Rust] Expose install_bundled_cli and HAS_BUNDLED_CLI

Two new public APIs make it easier to access the bundled CLI path before a Client exists, eliminating the need for consumers to duplicate the cache-path resolution logic. (#1489)

// Check if a bundled CLI is available at compile time
if copilot_sdk::HAS_BUNDLED_CLI {
    // Extract and get the path to the bundled CLI
    if let Some(path) = copilot_sdk::install_bundled_cli() {
        println!("Bundled CLI at: {}", path.display());
    }
}

[!NOTE] <details> <summary>🔒 Integrity filter blocked 2 items</summary>

The following items were blocked because they don't meet the GitHub integrity level.

• #1136 search_pull_requests: has lower integrity than agent requires. The agent cannot read data with integrity below "approved".
• #868 search_pull_requests: has lower integrity than agent requires. The agent cannot read data with integrity below "approved".

To allow these resources, lower min-integrity in your GitHub frontmatter:

tools:
  github:
    min-integrity: approved  # merged | approved | unapproved | none

</details>

Generated by Release Changelog Generator · ● 2.4M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.48, model: claude-sonnet-4.6, id: 26641549279, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/26641549279 -->

Feature: CopilotClientMode.Empty for multi-tenant apps

Multi-tenant applications can now opt into a hardened "empty" client mode that starts from a clean slate: no built-in tools, host integration disabled, system prompt sanitized, and storage explicitly required. This prevents user-specific state (plugins, custom agents, co-author trailers, etc.) from leaking across tenants. (#1428)

const client = new CopilotClient({
    mode: "empty",
    baseDirectory: "/tmp/per-tenant-state",
});

const session = await client.createSession({
    onPermissionRequest: approveAll,
    availableTools: new ToolSet()
        .addBuiltIn(BuiltInTools.Isolated)
        .addMcp("*"),
    excludedTools: new ToolSet()
        .addMcp("github-delete_repository"),
});

using var client = new CopilotClient(new CopilotClientOptions
{
    Mode = CopilotClientMode.Empty,
    BaseDirectory = "/tmp/per-tenant-state",
});

await using var session = await client.CreateSessionAsync(new SessionConfig
{
    OnPermissionRequest = PermissionHandler.ApproveAll,
    AvailableTools = new ToolSet()
        .AddBuiltIn(BuiltInTools.Isolated)
        .AddMcp("*"),
    ExcludedTools = new ToolSet()
        .AddMcp("github-delete_repository"),
});

Feature: post-tool-use failure hooks

A new postToolUseFailure / OnPostToolUseFailure hook lets SDK users observe failed tool executions and inject follow-up guidance, separate from the existing success-only postToolUse hook. Available across Node, Python, Go, .NET, and Rust. (#1421)

session.hooks.postToolUseFailure = async (event) => {
    console.error(`Tool ${event.toolName} failed: ${event.error}`);
};

session.OnPostToolUseFailure = async (e, ct) =>
{
    Console.Error.WriteLine($"Tool {e.ToolName} failed: {e.Error}");
};

Feature: agentMode on MessageOptions

All six SDKs now expose an agentMode field on MessageOptions to set the per-message UI mode (interactive, plan, autopilot, shell). Previously there was no correct way to request plan/autopilot mode from the SDK. (#1438)

• TypeScript: session.send(message, { agentMode: "plan" })
• C#: session.SendAsync(message, new MessageOptions { AgentMode = "plan" })
• Python: session.send(message, agent_mode="plan")
• Go: session.Send(ctx, message, copilot.MessageOptions{AgentMode: "plan"})

Feature: [Rust] structured error types with kind() method

Rust SDK error types have been refactored from a flat #[non_exhaustive] enum to a struct-with-kind() pattern, aligning with the Azure SDK for Rust design. This is a breaking change for Rust callers matching on error variants — update match arms to call .kind() instead. (#1400)

Other changes

• bugfix: [C#] preserve JSON-RPC error.data in the .NET client transport (#1425)
• improvement: [Java] cross-cutting monorepo updates — phase 05 (#1441)
• bugfix: [Java] fix repackaging issue (#1437)

New contributors

• @heaths made their first contribution in #1400

Generated by Release Changelog Generator · ● 3.6M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.48, model: claude-sonnet-4.6, id: 26535875210, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/26535875210 -->

To make it easier to keep track of what's changed during the beta period, these release notes cover all the updates since beta 1.

This release consolidates a major round of API review, adds new capabilities (remote sessions, MCP hook, mode handlers), and introduces the Rust SDK. Every SDK went through a thorough final API review, resulting in cleaner, more consistent, and more idiomatic APIs that we can support post-GA.

🚀 GA timeline: The 1.0.0 GA release is planned for approximately one week from now.

⚠️ Breaking changes: This release includes breaking changes from the API review. See the breaking changes summary below and the detailed migration doc that you can give as context to Copilot to help it update your app code quickly.

Highlights

Rust SDK

A new Rust SDK joins the family, bringing the same Copilot capabilities to Rust applications. It supports the full feature set — sessions, tools, hooks, streaming, MCP, permissions, telemetry, canvases, and remote sessions — with idiomatic Rust patterns throughout.

use github_copilot_sdk::{Client, ClientOptions, SessionConfig, permission::ApproveAllHandler};

let client = Client::new(ClientOptions::default());
client.start().await?;

let session = client.create_session(
    SessionConfig::default()
        .with_permission_handler(Arc::new(ApproveAllHandler))
).await?;

let reply = session.send_and_wait("Hello!").await?;

The Rust SDK ships with the Copilot runtime bundled by default — just add the crate and go. The runtime is downloaded when your app builds and is embedded in your distributable binary. Opt out of bundling with default-features = false if you manage the CLI yourself.

Remote sessions and cloud sessions

Remote sessions connect a local Copilot session to GitHub's backend services, producing a shareable URL that lets users access the session from GitHub web or mobile — useful for monitoring a locally-running agent from your phone, or sharing a session with a teammate. Enable it globally or toggle it per-session with session.rpc.remote.enable().

const client = new CopilotClient({
  enableRemoteSessions: true,
});

// Each session emits a remote URL via session.info events
session.on("session.info", (event) => {
  if (event.data.infoType === "remote") {
    console.log("Remote URL:", event.data.url); // Share this or render as QR code
  }
});

var client = new CopilotClient(new CopilotClientOptions {
    EnableRemoteSessions = true,
});

Requirements: the user must be authenticated (gitHubToken or useLoggedInUser), and the session's working directory must be a GitHub repository. The enableRemoteSessions option only applies when the SDK spawns the CLI process (ignored when connecting to an external server).

Cloud sessions go a step further — the session runs entirely in the cloud rather than on the local machine. Pass a cloud option with repository metadata when creating a session:

const session = await client.createSession({
  onPermissionRequest: approveAll,
  cloud: {
    repository: { owner: "github", name: "my-repo", branch: "main" },
  },
});

Both features are available in all languages.

Pre-MCP tool call hook

A new preMcpToolCall hook fires before every MCP tool invocation, giving your application the chance to inspect, modify, or block MCP tool calls. This is useful for adding authorization, logging, or stripping sensitive metadata from tool call arguments.

const session = await client.createSession({
  onPermissionRequest: approveAll,
  preMcpToolCall: async (context) => {
    console.log(
      `MCP tool: ${context.toolName} on server: ${context.serverName}`,
    );
    // Return modified args, or throw to block the call
    return context.arguments;
  },
});

var session = await client.CreateSessionAsync(new SessionConfig {
    OnPermissionRequest = PermissionHandler.ApproveAll,
    PreMcpToolCall = async (context) => {
        Console.WriteLine($"MCP tool: {context.ToolName} on server: {context.ServerName}");
        return context.Arguments;
    },
});

Available in all languages.

Cleaner, more consistent APIs across all SDKs

Every SDK went through a comprehensive API review to make the developer experience cleaner and more idiomatic. The highlights:

Simplified client connection config — Instead of scattering transport options (cliPath, cliUrl, port, tcpConnectionToken, useStdio) across client options, there's now a single connection property with typed factory methods:

// Connect to an external server
const client = new CopilotClient({
  connection: RuntimeConnection.forUri("http://localhost:3000"),
});

// Or spawn a local CLI over stdio (the default if no connection is specified)
const client = new CopilotClient({
  connection: RuntimeConnection.forStdio(),
});

var client = new CopilotClient(new CopilotClientOptions {
    Connection = RuntimeConnection.ForStdio(),
});

• Python: CopilotClient(connection=RuntimeConnection.for_uri("http://localhost:3000"))
• Go: copilot.NewClient(&copilot.ClientOptions{Connection: copilot.UriConnection{Uri: "http://localhost:3000"}})
• Rust: Client::new(ClientOptions { connection: Some(RuntimeConnection::Uri { uri: "http://localhost:3000".into() }), ..Default::default() })

send() now accepts a plain string — The most common case just got simpler:

// Before
const reply = await session.send({ prompt: "Hello!" });

// After
const reply = await session.send("Hello!");
// Full options still available:
const reply = await session.send({ prompt: "Analyze this", attachments: [...] });

Permission decisions are now typed factories instead of stringly-typed objects:

// Before
return new PermissionRequestResult { Kind = "approve-once" };

// After
return PermissionDecision.ApproveOnce();
// Also: PermissionDecision.Reject(), .UserNotAvailable(), .NoResult()

getMessages() → getEvents() — The method name now accurately reflects what it returns (the full event stream, not just messages).

See the breaking changes guide for the complete list of API changes per language.

New features

• Mode handler APIs — onExitPlanModeRequest and onAutoModeSwitchRequest handlers let your app handle plan-approval flows and automatic mode switching (e.g., rate-limit recovery). Available in all languages.
• runtime_instructions system message section — A new section in the system message customization API for runtime-generated instructions, giving you another hook to inject or transform prompt content.
• enableSessionTelemetry — A per-session toggle to enable or disable telemetry collection, independent of the client-level telemetry config.
• SDK tracing diagnostics — Built-in diagnostic tracing for troubleshooting SDK ↔ CLI communication issues.
• Provider model and token limit overrides — ProviderConfig now supports modelId, wireModel, maxInputTokens, and maxOutputTokens, letting BYOK users decouple the model ID visible to agents from the wire model sent to the provider.
• Canvas extensions (experimental, GitHub Copilot App only) — Sessions can now declare canvases — interactive UI surfaces that the model can open, close, and invoke actions on. This is currently specific to the GitHub Copilot App and is not yet available in other environments.

Changes and improvements

• [.NET] Now compatible with .NET Framework (net472) in addition to .NET 8+, .NET 10, and .NET Standard 2.0 — broadening support for legacy applications.
• [.NET] Session event enums are now forward-compatible string-backed types, so unknown event values from newer CLI versions don't cause deserialization failures.
• [Go] Discriminated union types in generated RPC code are now proper typed interfaces instead of flattened structs.
• [Go] CLI stderr is now captured and surfaced in error messages, making it easier to diagnose startup failures.
• All SDKs — Generated RPC types have been streamlined with the latest schema. If you reference generated rpc.* types by name, expect renames.

⚠️ Breaking changes

This release includes breaking changes from a comprehensive API review. The changes are mechanical — mostly renames and reshaping — and make the APIs cleaner and more consistent as we finalize the 1.0.0 shape.

💡 Migrating your app? Pass the breaking changes document to GitHub Copilot and ask it to update your code. The document is structured as a machine-readable migration guide with before/after examples for every change.

Summary of breaking changes

Each language also has its own idiomatic changes beyond the shared ones above. See the detailed breaking changes document for the full per-language list.

Feature: canvas runtime support

Applications can now declare and handle canvases — interactive UI surfaces hosted by the Copilot runtime. Register a single CanvasHandler on a session and receive routed canvas.open, canvas.close, and canvas.action.invoke events; call session.canvas.* for native host actions. (#1401)

session.setCanvasHandler({
  onOpen: async (ctx) => { /* render canvas */ },
  onAction: async (ctx) => { /* handle action */ },
  onClose: async (ctx) => { /* cleanup */ },
});

session.SetCanvasHandler(new MyCanvasHandler());

Feature: remote session support

Applications can enable remote sessions either at the client level (all sessions in a GitHub repo get a remote URL) or on demand mid-session. (#1192)

// Always-on via client option:
const client = new CopilotClient({ remote: true });

// On-demand per session:
const result = await session.rpc.remote.enable();
console.log("Remote URL:", result.url);
await session.rpc.remote.disable();

// Always-on:
var client = new CopilotClient(new CopilotClientOptions { Remote = true });

// On-demand:
var result = await session.Rpc.Remote.EnableAsync();
await session.Rpc.Remote.DisableAsync();

Feature: preMcpToolCall hook

A new hook lets applications intercept MCP tool invocations before they execute — inspect, replace, or remove the _meta field sent to MCP servers. (#1366)

session.hooks.onPreMcpToolCall = async (input) => {
  return { metaToUse: { ...input.meta, traceId: myTraceId } };
};

session.Hooks.OnPreMcpToolCall = async (input) =>
    new PreMcpToolCallHookOutput { MetaToUse = new { traceId = myTraceId } };

Feature: cloud session config

Sessions can now be created with a cloud option to request cloud-backed remote sessions with repository metadata, without requiring a local CLI process. (#1306)

const session = await client.createSession({
  cloud: { repository: { owner: "my-org", name: "my-repo" } },
});

var session = await client.CreateSessionAsync(new SessionConfig {
    Cloud = new CloudSessionConfig { Repository = new RepositoryConfig { Owner = "my-org", Name = "my-repo" } }
});

Feature: [Rust] Copilot CLI bundled by default

The Rust SDK now bundles the Copilot CLI binary at publish time by default — no configuration needed to get a working binary. Opt out with default-features = false. (#1385)

# Default: CLI bundled automatically
copilot-sdk = "1.0.0-beta.7"

# Opt out of bundled CLI:
copilot-sdk = { version = "1.0.0-beta.7", default-features = false }

Feature: Java SDK

The Java SDK is now part of the monorepo, providing full parity with the other language SDKs including session management, tool registration, hooks, and E2E test coverage. (#1348, #1369, #1389)

var client = new CopilotClient();
var session = client.createSession(new SessionConfig()).join();
session.send("Hello from Java!").join();

Feature: SDK tracing diagnostics

The .NET, Python, and Rust SDKs now emit structured trace/log output covering CLI startup, JSON-RPC timing, session operations, and callback paths — making it easier to diagnose slow or failing connections. (#1217)

• C#: integrates with ILogger via structured fields and TimeSpan elapsed values
• Python: uses stdlib logging with elapsed_ms, session_id, and request identifiers
• Rust: uses the tracing crate with structured fields

Feature: [C#] CopilotTool helper

CopilotTool.DefineTool is a typed wrapper around AIFunctionFactory.Create that applies Copilot-specific metadata (override flag, skip-permission behavior) without magic strings. (#1321)

var tool = CopilotTool.DefineTool("edit",
    new CopilotToolOptions { IsOverride = true },
    async (params) => { /* custom edit */ });
session.AddTool(tool);

Feature: sessionId on hook inputs

All hook input types (PreToolUseHookInput, PostToolUseHookInput, SessionStartHookInput, etc.) now include a sessionId field, allowing applications to distinguish parent session hooks from sub-agent hooks. (#1290)

Other changes

• feature: add enableSessionTelemetry session option across all SDKs (#1224)
• feature: add model field to CustomAgentConfig across all SDKs (#1309)
• feature: add remote_session field to SessionConfig across all SDKs (#1295)
• feature: [Rust] support binary tool results (#1222)
• feature: restore mode handler APIs across SDKs (#1228)
• feature: add runtime_instructions system message section across all SDKs (#1377)
• feature: add SessionFs SQLite support for runtime routing (#1299)
• feature: make tool callbacks optional across SDKs (#1308)
• feature: make MCPStdioServerConfig.args optional across all SDKs (#1347)
• feature: [C#] add netstandard and net10 targets (#1320)
• feature: [C#] use string enums for session events (#1226)
• feature: [C#] seal generated session event types (#1330)
• feature: [C#] map x-opaque-json to JsonElement at RPC params boundary (#1359)
• feature: [Go] generate typed union interfaces (#1252)
• improvement: API review fixes for C# (#1343), TypeScript (#1357), Go (#1360), Rust (#1367), Python (#1376)
• improvement: share generated schema definitions across SDKs (#1289)
• improvement: hide deprecated APIs where supported (#1293)
• improvement: use 32-bit types for bounded schema integers (#1329)
• improvement: strip Ms suffix for duration properties in generated types (#1339)
• improvement: [C#] publish .snupkg symbols package to NuGet.org (#1345)
• improvement: [Go] replace RPC quicktype generation with native Go types (#1234)
• bugfix: [Go] capture CLI stderr and fix SetProcessDone race condition (#863)
• bugfix: [Python] fix from_dict() round-trip for optional fields with schema defaults (#1313)
• bugfix: [C#] honor preinstalled CLI path in MSBuild targets (#1318)

New contributors

• @cschleiden made their first contribution in #1222
• @claudiogodoy99 made their first contribution in #863
• @tiagonbotelho made their first contribution in #1306

Generated by Release Changelog Generator · ● 3.7M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.48, model: claude-sonnet-4.6, id: 26370426039, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/26370426039 -->

Feature: Java SDK joins the monorepo

The Java SDK is now a first-class part of the github/copilot-sdk monorepo, with full CI, Maven publishing workflows, and generated types that stay in sync with the rest of the SDK family. (#1348)

CopilotClient client = new CopilotClient();
CopilotSession session = client.createSession(new SessionConfig());
session.send("Hello from Java!");

Feature: preMcpToolCall hook across all SDKs

Applications can now intercept MCP tool invocations before they execute — useful for injecting, replacing, or removing the _meta field sent to MCP servers. The hook returns a tri-state result: return null to leave _meta unchanged, return a new object to replace it, or explicitly set metaToUse to null to strip it entirely. (#1366)

session.hooks.onPreMcpToolCall = async (input) => {
  return { metaToUse: { traceId: myTraceId() } };
};

session.Hooks.OnPreMcpToolCall = async (input) => {
    return new PreMcpToolCallHookOutput { MetaToUse = new { traceId = MyTraceId() } };
};

Feature: tool callbacks are now optional across all SDKs

Tools and permission handlers can be declared without providing a callback, leaving them pending for manual resolution. This makes it easier to pause execution and resolve requests from event streams rather than inline callbacks. (#1308)

// Declare without a callback — permission requests stay pending
session.setPermissionHandler({ kinds: ["edit"] });

// Later, resume manually from an event
session.resolvePermissionRequest(event.requestId, { outcome: "allow" });

// Declaration-only tool — no callback supplied
session.DefineTool(new ToolDefinition { Name = "myTool", Description = "..." });

Feature: sessionId on hook inputs — hooks now fire for sub-agents

All six hook input types (PreToolUseHookInput, PostToolUseHookInput, etc.) now carry a sessionId field. Hooks also fire for tool calls made by sub-agents spawned via the task tool, and input.sessionId lets you distinguish parent from sub-agent invocations. (#1290)

Feature: breaking API review changes for C#, TypeScript, and Go

These releases include coordinated, intentional breaking changes based on API review feedback. Key changes:

Connection configuration — CliPath/Port/CliUrl properties are replaced by a single RuntimeConnection discriminated union:

• TypeScript: new CopilotClient({ connection: RuntimeConnection.stdio(...) })
• C#: new CopilotClientOptions { Connection = RuntimeConnection.Stdio(...) }
• Go: CLIUrl equivalent updated

Convenience send overloads — send(string) / sendAndWait(string) string overloads added for all SDKs.

Lifecycle events — now a typed polymorphic hierarchy (SessionCreatedEvent, etc.) instead of stringly-typed discriminators.

C# specifics — CopilotHome → BaseDirectory, delegate types replaced with Func<...>, LogLevel retyped to CopilotLogLevel, SessionConfigBase extracted. (#1343, #1357, #1360)

Feature: model field on CustomAgentConfig

When defining custom sub-agents programmatically, you can now specify which model to use. The runtime falls back to the parent session model if the specified model is unavailable. (#1309)

• TypeScript: customAgents: [{ name: "my-agent", model: "gpt-4o", ... }]
• C#: new CustomAgentConfig { Name = "my-agent", Model = "gpt-4o" }
• Python: custom_agents=[{"name": "my-agent", "model": "gpt-4o"}]
• Go: CustomAgentConfig{Name: "my-agent", Model: "gpt-4o"}

Feature: cloud session config support

Session creation now accepts a cloud option to request cloud-backed remote sessions with repository metadata, matching the new runtime capability. (#1306)

Feature: CopilotTool.DefineTool helper for .NET

The .NET SDK now provides a typed CopilotTool.DefineTool wrapper that applies Copilot-specific metadata (override flags, skip-permission behavior) without magic strings, aligning C# with the typed helper APIs already available in other SDKs. (#1321)

var tool = CopilotTool.DefineTool("edit", new CopilotToolOptions { IsOverride = true },
    async (params, ctx) => { /* custom edit implementation */ });

Other changes

• feature: [C#] add netstandard2.0 and net10 target frameworks (#1320)
• feature: [C#] publish .snupkg symbols package to NuGet.org (#1345)
• bugfix: [C#] honor preinstalled CLI path in MSBuild targets (#1318)
• bugfix: [C#] fix argument validation edge cases (#1322, #1328)
• feature: [Node] export generated session event types (#1316)
• feature: make MCPStdioServerConfig.args optional across all SDKs (#1347)
• feature: add remote_session field to all SDK SessionConfig types (#1295)
• improvement: hide deprecated APIs where supported by the language (#1293)
• bugfix: [Python] fix from_dict() round-trip for optional fields with schema defaults (#1313)
• improvement: [Go] replace RPC quicktype generation with native Go codegen (#1234)
• improvement: [Go] generate typed union interfaces and bool-discriminated unions (#1252, #1284)
• improvement: [Rust] derive Default on generated types (#1272)

New contributors

• @tiagonbotelho made their first contribution in #1306

Generated by Release Changelog Generator · ● 6.2M

<!-- gh-aw-agentic-workflow: Release Changelog Generator, engine: copilot, version: 1.0.48, model: claude-sonnet-4.6, id: 26266286427, workflow_id: release-changelog, run: https://github.com/github/copilot-sdk/actions/runs/26266286427 -->