Skip to content

Bump GitHub.Copilot.SDK from 0.2.2 to 1.0.13 - #278

Open
dependabot[bot] wants to merge 1 commit into
mainfrom
dependabot/nuget/src/CopilotSdkPlayground.UnitTests/GitHub.Copilot.SDK-1.0.13
Open

Bump GitHub.Copilot.SDK from 0.2.2 to 1.0.13#278
dependabot[bot] wants to merge 1 commit into
mainfrom
dependabot/nuget/src/CopilotSdkPlayground.UnitTests/GitHub.Copilot.SDK-1.0.13

Conversation

@dependabot

@dependabot dependabot Bot commented on behalf of github Sep 4, 2026

Copy link
Copy Markdown
Contributor

Updated GitHub.Copilot.SDK from 0.2.2 to 1.0.13.

Release notes

Sourced from GitHub.Copilot.SDK's releases.

1.0.13

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();
 ... (truncated)

## 1.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](https://github.com/github/copilot-sdk/pull/2321))

```ts
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

... (truncated)

1.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

... (truncated)

1.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)
 ... (truncated)

## 1.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](https://github.com/github/copilot-sdk/pull/2410))

```ts
// 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

1.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)

... (truncated)

1.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();
 ... (truncated)

## 1.0.11

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

## New Contributors
* @​Chuxel made their first contribution in https://github.com/github/copilot-sdk/pull/2283
* @​lutzroeder made their first contribution in https://github.com/github/copilot-sdk/pull/2330
* @​aymenfurter made their first contribution in https://github.com/github/copilot-sdk/pull/2294

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

## 1.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](https://github.com/github/copilot-sdk/pull/2321))

```ts
// 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)
... (truncated)

1.0.10-preview.0

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.10-preview.0</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.10-preview.0")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.10-preview.0'

Feature: managed permission settings at session startup

Applications can now supply host-managed permission settings at session startup via SessionConfig.setManagedSettings(). The runtime validates and composes this policy with self-fetched and device policy. Re-supply on resume as it is not persisted. (#​2139)

SessionConfig config = new SessionConfig()
    .setManagedSettings(new ManagedSettings()
        .setPermissions(new ManagedSettingsPermissions()
            .setFilesystem(PermissionLevel.READ_WRITE)));

Feature: userPromptTransformed hook

A new onUserPromptTransformed hook on SessionHooks lets applications observe (and optionally modify) the prompt text after the runtime transforms it. (#​2254)

session.getHooks().setOnUserPromptTransformed((input, ctx) -> {
    System.out.println("Transformed prompt: " + input.getPrompt());
    return CompletableFuture.completedFuture(null);
});

... (truncated)

1.0.9

What's Changed

New Contributors

Full Changelog: github/copilot-sdk@rust/v1.0.9-preview.3...rust/v1.0.9

1.0.9-preview.3

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.9-preview.3</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.9-preview.3")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.9-preview.3'

Feature: managed approval requirement on permission requests

Permission handlers can now inspect request.getManagedApprovalRequired() to determine when a human decision is required. PermissionHandler.APPROVE_ALL now completes exceptionally when managed settings are enabled, preventing auto-approval of requests that require explicit human review. (#​2080)

PermissionHandler handler = (request, invocation) -> {
    if (Boolean.TRUE.equals(request.getManagedApprovalRequired())) {
        return requestHumanApproval(request);
    }
    return CompletableFuture.completedFuture(
        new PermissionRequestResult().setKind(PermissionRequestResultKind.APPROVED));
};

Feature: GitHub MCP tool configuration

SessionConfig and ResumeSessionConfig now expose a GitHubMcpToolConfig option to configure the built-in GitHub MCP server, including selectively enabling tools and disabling form deferral. (#​2112)

var config = new SessionConfig()
    .setGitHubMcpToolConfig(new GitHubMcpToolConfig()
        .setDisableFormDeferral(true));
 ... (truncated)

## 1.0.9-preview.2

# Installation

⚠️ **Artifact versioning plan:** Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form `vMaj.Min.Micro`. For example v0.1.32. The corresponding maven version for the release will be `Maj.Min.Micro-java.N`, where `Maj`, `Min` and `Micro` are the corresponding numbers for the reference implementation release, and `N` is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the `docs/adr` directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)


## Maven
```xml
<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.9-preview.2</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.9-preview.2")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.9-preview.2'

Changes

  • improvement: re-enable ModeHandlers exit_plan_mode E2E test assertions (#​2032)
  • improvement: update E2E test fixtures to use gpt-5.4 for reasoning effort tests (#​2181)

New contributors

  • @​arimu1 made their first contribution in #​2032

Generated by Release Changelog Generator · sonnet46 36.1 AIC · ⌖ 6.98 AIC · ⊞ 8.6K

1.0.9-preview.1

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.9-preview.1</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.9-preview.1")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.9-preview.1'

Other changes

  • improvement: document MCP tool filter naming convention (<server-key>-<tool-name>) for setAvailableTools, setExcludedTools, and agent config in README (#​2101)
  • improvement: fix EnableConfigDiscovery Javadoc to accurately describe agent discovery behavior — it gates .github/agents/ discovery, independent of SkipCustomInstructions (#​2019)

New contributors

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

Generated by Release Changelog Generator · sonnet46 47 AIC · ⌖ 5.17 AIC · ⊞ 8.6K

1.0.9-preview.0

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.9-preview.0</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.9-preview.0")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.9-preview.0'

Feature: AgentStop lifecycle hook

The agentStop hook lets your application intercept the natural end of an agent turn and optionally request the agent to continue. Return { decision: "block", reason: "..." } to queue a follow-up prompt; return nothing to let the agent stop normally. (#​2054)

SessionHooks hooks = new SessionHooks()
    .setOnAgentStop((input, invocation) -> {
        if (!input.isStopHookActive() && needsValidation()) {
            return CompletableFuture.completedFuture(
                new AgentStopHookOutput()
                    .setDecision("block")
                    .setReason("Run final validation and fix any failures.")
            );
        }
        return CompletableFuture.completedFuture(null);
    });

Feature: custom JSON schema for @​CopilotToolParam

... (truncated)

1.0.8

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.8</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.8")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.8'

Feature: per-agent reasoning effort

CustomAgentConfig now accepts an optional reasoningEffort field that controls the reasoning intensity for a specific sub-agent. Omitting it inherits the session-level effort; omitting it at both levels leaves the choice to the backend. (#​1981)

CustomAgentConfig agent = new CustomAgentConfig()
    .setName("coder")
    .setReasoningEffort("high");

Other changes

  • improvement: [Java] strongly type the internal expAssignments session-config field with CopilotExpAssignmentResponse to match the runtime wire contract (#​2033)

[!WARNING]

Firewall blocked 1 domain

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:
... (truncated)

1.0.8-preview.0

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.8-preview.0</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.8-preview.0")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.8-preview.0'

Feature: per-agent reasoning effort

You can now set a reasoningEffort override on individual custom agents within a session. When omitted, no per-agent override is sent and the backend chooses its default. (#​1981)

CustomAgentConfig agent = new CustomAgentConfig()
    .setName("my-agent")
    .setModel("claude-sonnet-4-5")
    .setReasoningEffort("high");

Other changes

  • improvement: strongly type internal expAssignments session config field with CopilotExpAssignmentResponse (#​2033)

[!WARNING]

Firewall blocked 1 domain

The following domain was blocked by the firewall during workflow execution:
... (truncated)

1.0.7

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.7</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.7")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.7'

Feature: opaque metadata passthrough for tool definitions

Hosts can now attach namespaced, opaque metadata to tool definitions and have it forwarded verbatim over the session.create/resumeSession wire call. Use ToolDefinition.createWithMetadata(...) or the fluent .metadata(Map) builder, or express shallow flag maps via @​CopilotTool.MetadataEntry annotations. (#​1864)

ToolDefinition tool = ToolDefinition.create("search", "Search files", schema, handler)
    .metadata(Map.of("com.example:featureFlags", Map.of("streamResults", true)));

Feature: tool search configuration support

SessionConfig and ResumeSessionConfig now accept a ToolSearchConfig that enables server-side tool search and controls the deferral threshold. Tool results can also carry back toolReferences indicating which tools were consulted during search. (#​1933)

SessionConfig config = new SessionConfig()
    .setToolSearch(new ToolSearchConfig().setEnabled(true).setDeferThreshold(5));

Other changes

  • feature: [Java] forward enableManagedSettings on SessionConfig/ResumeSessionConfig to opt into enterprise managed-settings enforcement at session bootstrap (#​1925)
  • feature: [Java] expose agentId(), parentAgentId(), and interactionType() on CopilotRequestContext in request-handler callbacks (#​1949)
    ... (truncated)

1.0.7-preview.3

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.7-preview.3</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.7-preview.3")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.7-preview.3'

Feature: tool search configuration

Sessions can now configure tool search behavior via ToolSearchConfig on SessionConfig. Tool search keeps the model's active tool set small by deferring MCP and external tools until needed. (#​1933)

var config = new SessionConfig()
    .setToolSearch(new ToolSearchConfig()
        .setEnabled(true)
        .setDeferThreshold(20));
var session = client.createSession(config).get();

Other changes

  • improvement: [Java] updated Javadoc examples to reference current model IDs (#​1978)

New contributors

  • @​rinceyuan made their first contribution in #​1978

... (truncated)

1.0.7-preview.2

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.7-preview.2</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.7-preview.2")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.7-preview.2'

Changes since java/v1.0.7-preview.1

  • improvement: [Java] document native runtime bundling strategy (ADR-007): chose per-platform classifier JARs (DJL-style) with JNA bindings over Panama FFM, including decision rationale and monolithic uber-jar support via maven-assembly-plugin (#​1966)

Generated by Release Changelog Generator · sonnet46 738.2K

1.0.7-preview.1

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.7-preview.1</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.7-preview.1")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.7-preview.1'

Feature: request handler context now exposes agent metadata

CopilotRequestContext now includes agentId, parentAgentId, and interactionType fields, giving request handlers visibility into which agent is making an LLM inference call and whether it is a subagent. (#​1949)

client.setRequestHandler((context, chain) -> {
    System.out.println("Agent: " + context.getAgentId());
    System.out.println("Parent: " + context.getParentAgentId());
    System.out.println("Interaction: " + context.getInteractionType());
    return chain.apply(context);
});

Generated by Release Changelog Generator · sonnet46 747.2K

1.0.7-preview.0

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.7-preview.0</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.7-preview.0")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.7-preview.0'

Feature: opt in to enterprise managed-settings enforcement

SessionConfig and ResumeSessionConfig now support an enableManagedSettings flag. When set to true, the runtime enforces organizational bypass-permissions policies at session creation using the session's GitHub token. (#​1925)

var session = client.createSession(
    new SessionConfig().setEnableManagedSettings(true)
).get();

Generated by Release Changelog Generator · sonnet46 2.3M

1.0.6

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.6</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.6")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.6'

Feature: inline lambda tool definitions

Developers can now define tools directly at the call site using ToolDefinition.from(...) with typed lambda handlers and Param.of(...) parameter metadata — no separate annotated class required. Async variants (fromAsync) and ToolInvocation context injection (fromWithToolInvocation) are also available. (#​1895)

ToolDefinition greet = ToolDefinition.from(
    "greet", "Greets a user by name",
    Param.of(String.class, "name", "The user's name"),
    name -> "Hello, " + name + "!");

Other changes

  • bugfix: [Java] preserve explicit null map values in JSON-RPC params so user setting clears reach the CLI (#​1906)
  • feature: [Java] add experimental onGitHubTelemetry callback on CopilotClientOptions for receiving forwarded GitHub telemetry events (#​1835)

Generated by Release Changelog Generator · sonnet46 2.5M

1.0.6-preview.1

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.6-preview.1</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.6-preview.1")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.6-preview.1'

Feature: experimental GitHub telemetry forwarding

The Java SDK now supports forwarding per-session GitHub telemetry events to your application. Set onGitHubTelemetry on CopilotClientOptions to receive gitHubTelemetry.event notifications from the runtime; the client automatically opts every session it creates or resumes into telemetry forwarding when the handler is present. (#​1835)

CopilotClientOptions options = new CopilotClientOptions()
    .setOnGitHubTelemetry(notification -> {
        // process per-session GitHub telemetry event
        return CompletableFuture.completedFuture(null);
    });

Note: This is an experimental feature (@​CopilotExperimental) and may change or be removed without notice.

Generated by Release Changelog Generator · sonnet46 977.2K

1.0.6-preview.0

What's Changed

New Contributors

Full Changelog: github/copilot-sdk@rust/v1.0.5-preview.1...rust/v1.0.6-preview.0

1.0.5

Installation

⚠️ Artifact versioning plan: Releases of this implementation track releases of the reference implementation. For each release of the reference implementation, there may follow a corresponding release of this implementation with the same number as the reference implementation. Release identifiers of the reference implementation are in the form vMaj.Min.Micro. For example v0.1.32. The corresponding maven version for the release will be Maj.Min.Micro-java.N, where Maj, Min and Micro are the corresponding numbers for the reference implementation release, and N is a monotonically increasing sequence number starting with 0 for each release. See the corresponding architectural decision record for more information in the docs/adr directory of the source code.

📦 [View on Maven Central]((central.sonatype.com/redacted)

📖 [Documentation]((github.github.io/redacted) · [Javadoc]((github.github.io/redacted)

Maven

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>1.0.5</version>
</dependency>

Gradle (Kotlin DSL)

implementation("com.github:copilot-sdk-java:1.0.5")

Gradle (Groovy DSL)

implementation 'com.github:copilot-sdk-java:1.0.5'

Feature: annotation-based tool API (@​CopilotTool)

The Java SDK now includes a high-level, annotation-driven tool API. Annotate methods with @​CopilotTool and parameters with @​CopilotToolParam to define tools — a JSR-269 annotation processor generates metadata at compile time with no runtime reflection. Use ToolDefinition.fromObject() to register tools with minimal boilerplate. (#​1792)

public class WeatherTools {
    `@​CopilotTool`("Get the current weather for a given city")
    public String getWeather(
            `@​CopilotToolParam`(value = "The city to get weather for", required = true) String city,
            `@​CopilotToolParam`(value = "Temperature unit: celsius or fahrenheit", defaultValue = "celsius") String unit) {
        // implementation
    }
}

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

Feature: ToolInvocation injection in @​CopilotTool methods

... (truncated)

1.0.5-preview.1

What's Changed

New Contributors

Full Changelog: github/copilot-sdk@rust/v1.0.5-preview.0...rust/v1.0.5-preview.1

1.0.5-preview.0

What's Changed

New Contributors

_Description has been tru...

Description has been truncated

@dependabot
Bump GitHub.Copilot.SDK from 0.2.2 to 1.0.13
fe95daf 
---
updated-dependencies:
- dependency-name: GitHub.Copilot.SDK
  dependency-version: 1.0.13
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
@dependabot dependabot Bot added .NET Pull requests that update .NET code dependencies Pull requests that update a dependency file labels Sep 4, 2026
@dependabot
dependabot Bot requested a review from SIkebe as a code owner September 4, 2026 22:15
@dependabot dependabot Bot added dependencies Pull requests that update a dependency file .NET Pull requests that update .NET code labels Sep 4, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@SIkebe SIkebe Awaiting requested review from SIkebe SIkebe is a code owner

Assignees

No one assigned

Labels

dependencies Pull requests that update a dependency file .NET Pull requests that update .NET code

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

0 participants