Skip to content

Releases: github/copilot-sdk

v1.0.0-beta.8

26 May 16:06
@github-actions github-actions
v1.0.0-beta.8
3dd7b01
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
v1.0.0-beta.8 Latest
Latest

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

Change All SDKs
Client transport config → RuntimeConnection ✅
copilotHome → baseDirectory ✅
getMessages() → getEvents() ✅
Permission results → PermissionDecision factories ✅ (C#, Python, Rust)
Handler renames (onExitPlanMode → onExitPlanModeRequest) ✅
Generated RPC type renames ✅

Each language also has its own idiomatic changes beyond the shared ones above. See the [det...

Read more
Assets 2
Loading

rust/v1.0.0-beta.8

26 May 16:06
@github-actions github-actions
rust/v1.0.0-beta.8
3dd7b01
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
rust/v1.0.0-beta.8

What's Changed

  • Update @github/copilot to 1.0.53 by @github-actions[bot] in #1410
  • Update @github/copilot to 1.0.54 by @github-actions[bot] in #1411
  • Update @github/copilot to 1.0.55-0 by @github-actions[bot] in #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 #1325
  • C# codegen: add isOpaqueJson guard to resolveRpcType by @SteveSandersonMS in #1414
  • Update vulnerable npm lockfile dependencies by @stephentoub in #1415
  • Fix flaky SDK E2E tests by @stephentoub in #1418
  • Change title from 'GitHub Copilot SDK documentation' to 'Copilot SDK' by @sunbrye in #1386
  • Add cross-SDK RPC E2E coverage by @stephentoub in #1424
  • SDK: Align canvas with codegen pipeline, add e2e tests by @SteveSandersonMS in #1413

Full Changelog: rust/v1.0.0-beta.7...rust/v1.0.0-beta.8

Contributors

SteveSandersonMS, stephentoub, and 2 other contributors
Loading

v1.0.0-beta.7

24 May 19:19
@github-actions github-actions
v1.0.0-beta.7
51043b1
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
v1.0.0-beta.7 Pre-release
Pre-release

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

Loading

rust/v1.0.0-beta.7

24 May 19:19
@github-actions github-actions
rust/v1.0.0-beta.7
51043b1
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
rust/v1.0.0-beta.7 Pre-release
Pre-release

What's Changed

Full Changelog: rust/v1.0.0-beta.6...rust/v1.0.0-beta.7

Contributors

edburns, SteveSandersonMS, and 2 other contributors
Loading

v1.0.0-beta.6

22 May 03:13
@github-actions github-actions
v1.0.0-beta.6
f4d22d7
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
v1.0.0-beta.6 Pre-release
Pre-release

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

Loading

rust/v1.0.0-beta.6

22 May 03:13
@github-actions github-actions
rust/v1.0.0-beta.6
f4d22d7
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
rust/v1.0.0-beta.6 Pre-release
Pre-release

What's Changed

New Contributors

Full Changelog: rust/v1.0.0-beta.4...rust/v1.0.0-beta.6

Contributors

edburns, tclem, and 7 other contributors
Loading

v1.0.0-beta.4

13 May 09:36
@github-actions github-actions
v1.0.0-beta.4
4e3dc73
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
v1.0.0-beta.4 Pre-release
Pre-release

Feature: typed Go union interfaces

Go SDK union types are now modelled as typed interfaces with concrete variants instead of flattened structs with many optional fields. Callers can switch on concrete variants and get compile-time safety — invalid union states that were previously representable are no longer possible. Unknown union members and session event payloads are preserved rather than dropped. (#1252)

switch v := event.Data.(type) {
case *SessionEventDataAssistantMessage:
    fmt.Println(v.Content)
case *RawSessionEventData:
    // forward-compatible: unknown future event type preserved
}

Feature: experimental schema type annotations

Generated types that carry stability: "experimental" in the protocol schema now surface language-appropriate markers so callers get compiler warnings when using unstable APIs. (#1267)

  • C#: [Experimental("GitHub.Copilot.SDK.Experimental")]
  • TypeScript: @experimental JSDoc tag
  • Go/Python: doc-comment warning
  • Rust: #[doc = "⚠️ Experimental"]

Other changes

  • improvement: [Go] replace quicktype-based RPC codegen with a custom schema-aware generator; preserves distinct named types that quicktype previously merged due to identical structure, and aligns generated casing with the repo's naming policy — note: this is a breaking change for Go callers using generated RPC types (#1234)
  • bugfix: [Go] CLI stderr is now captured and included in startup errors, making failure root causes (missing module, auth error, version mismatch) immediately visible instead of showing a generic opaque message (#863)

New contributors

  • @claudiogodoy99 made their first contribution in #863

Generated by Release Changelog Generator · ● 302.2K

Loading

rust/v1.0.0-beta.4

13 May 09:36
@github-actions github-actions
rust/v1.0.0-beta.4
4e3dc73
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
rust/v1.0.0-beta.4

What's Changed

New Contributors

Full Changelog: rust-v0.1.0...rust/v1.0.0-beta.4

Contributors

brunoborges, tclem, and 8 other contributors
Loading

v1.0.0-beta.3

08 May 16:10
@github-actions github-actions
v1.0.0-beta.3
ce56eb8
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
v1.0.0-beta.3

Feature: mode handler APIs for plan approval and rate-limit recovery

Applications can now register callbacks for exitPlanMode.request and autoModeSwitch.request from the Copilot runtime, giving full control over plan-mode transitions and automatic model switching after rate-limit events. (#1228)

const session = await client.createSession({
  onExitPlanMode: async (request) => ({ approved: true }),
  onAutoModeSwitch: (request) => "yes",
});
var session = await client.CreateSessionAsync(new SessionConfig
{
    OnExitPlanMode = (request, _) => Task.FromResult(new ExitPlanModeResult { Approved = true }),
    OnAutoModeSwitch = (request, _) => Task.FromResult(AutoModeSwitchResponse.Yes),
});
  • Python: on_exit_plan_mode / on_auto_mode_switch kwargs on create_session()
  • Go: ExitPlanModeHandler / AutoModeSwitchHandler fields on SessionConfig

Feature: SDK tracing diagnostics

The .NET, Python, and Rust SDKs now emit structured diagnostic logs covering CLI startup, TCP connection, JSON-RPC request timing, session lifecycle, and error paths. (#1217)

var client = new CopilotClient(new CopilotClientOptions
{
    Logger = loggerFactory.CreateLogger<CopilotClient>(),
});

Python emits logs via stdlib logging under copilot.* loggers at DEBUG level. Rust uses tracing structured fields; wire up a tracing_subscriber as usual.

Feature: enableSessionTelemetry session option

A new enableSessionTelemetry option on SessionConfig and ResumeSessionConfig lets applications explicitly enable or disable the runtime's internal session telemetry. (#1224)

const session = await client.createSession({ enableSessionTelemetry: true });
var session = await client.CreateSessionAsync(new SessionConfig { EnableSessionTelemetry = true });

Other changes

  • bugfix: [C#] session-event enums are now string-backed readonly structs, preventing deserialization failures when the runtime adds new enum values (#1226)
  • bugfix: [Rust] binary tool result resource blobs now default to application/octet-stream when mimeType is absent (#1222)

New contributors

  • @sunbrye made their first contribution in #1208
  • @cschleiden made their first contribution in #1222
  • @IeuanWalker made their first contribution in #1232

Generated by Release Changelog Generator · ● 225.2K

Generated by Release Changelog Generator · ● 1.3M

Loading

v1.0.0-beta.2

06 May 20:02
@github-actions github-actions
v1.0.0-beta.2
06bfc5d
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Choose a tag to compare

View all tags
v1.0.0-beta.2 Pre-release
Pre-release

Feature: remote session support

Applications can now enable remote session support across all SDKs, providing parity with the CLI's --remote flag. There are two complementary mechanisms: a client-level option that enables remote for all sessions, and per-session RPC methods to toggle remote on demand. (#1192)

Always-on via client option:

const client = new CopilotClient({ remote: true });
session.on("session.info", (event) => {
  if (event.data.infoType === "remote") {
    console.log("Remote URL:", event.data.url);
  }
});
var client = new CopilotClient(new CopilotClientOptions { Remote = true });
session.OnSessionInfo += (e) => {
    if (e.InfoType == "remote")
        Console.WriteLine($"Remote URL: {e.Url}");
};

On-demand via RPC:

const result = await session.rpc.remote.enable();
console.log("Remote URL:", result.url);
await session.rpc.remote.disable();
var result = await session.Rpc.Remote.EnableAsync();
Console.WriteLine($"Remote URL: {result.Url}");
await session.Rpc.Remote.DisableAsync();
  • Python: await session.rpc.remote.enable() / session.rpc.remote.disable()
  • Go: session.RPC.Remote.Enable(ctx) / session.RPC.Remote.Disable(ctx)

Other changes

  • improvement: [Rust] align Rust SDK public surface with C#, Go, Python, and TypeScript — removes autoModeSwitch, exitPlanMode, disabled_mcp_servers; adds available_tools/disabled_skills to ResumeSessionConfig; expands tool results with binary payloads and MCP CallToolResult conversion (#1212)
  • improvement: [Rust] internalize env_value_mode for cross-SDK parity — envValueMode is now always sent as "direct" on the wire, consistent with all other SDKs (#1215)

Generated by Release Changelog Generator · ● 225.2K

Loading