v1.0.13-preview.4

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

v1.0.13-preview.3

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

v1.0.13-preview.2

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

v1.0.13-preview.1

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

v1.0.13-preview.0

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

v1.0.12-preview.0

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

v1.0.11

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

v1.0.11-preview.2

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

v1.0.10-preview.0

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

rust/v1.0.10-preview.0

What's Changed

• dotnet: update README attachment examples to current API (fixes #2196) by @HindzStark in #2208
• Support reasoningEffort: max by @Dharshika-11 in #2228
• Stop sendAndWait from emitting an unhandled rejection by @thejesh23 in #2206
• docs: clarify working directory defaults across SDKs by @xianjianlf2 in #2201
• Speed up Rust E2E tests with shared clients by @SteveSandersonMS in #2250
• build(deps-dev): bump ip-address from 10.2.0 to 10.4.0 in /test/harness by @dependabot[bot] in #2245
• build(deps-dev): bump the npm_and_yarn group across 1 directory with 2 updates by @dependabot[bot] in #2244
• build(deps-dev): bump postcss from 8.5.15 to 8.5.25 in /nodejs by @dependabot[bot] in #2243
• build(deps-dev): bump fast-uri from 3.1.4 to 3.1.5 in /test/harness by @dependabot[bot] in #2242
• docs: move SDK development guidance to local READMEs by @SteveSandersonMS in #2253
• build(deps-dev): bump postcss from 8.5.15 to 8.5.25 in /test/harness by @dependabot[bot] in #2252
• docs: replace removed session.idle.backgroundTasks field with the current aborted field by @examon in #2232
• Parallelize Python and Windows .NET CI tests by @SteveSandersonMS in #2251
• Fix active Node and Rust replay E2E flakes by @roji in #2186
• Add userPromptTransformed hook to all SDKs by @SteveSandersonMS in #2254
• fix: Java README version stuck at 1.0.5-01; release sed regex can't match numeric qualifiers by @rinceyuan in #2226
• docs: update Go and Rust API reference links by @scottaddie in #2266
• docs: add citations guide by @patniko in #2267
• sdk: Expose disabled MCP servers across languages by @connor4312 in #2260
• 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

New Contributors

• @HindzStark made their first contribution in #2208
• @Dharshika-11 made their first contribution in #2228
• @thejesh23 made their first contribution in #2206
• @xianjianlf2 made their first contribution in #2201
• @Chuxel made their first contribution in #2283

Full Changelog: rust/v1.0.9-preview.3...rust/v1.0.10-preview.0