Add Rust SDK

Adds a complete Rust implementation of the Copilot SDK alongside the
existing TypeScript, Go, Python, and .NET SDKs, integrated into the
mono-repo so it builds and is checked the same way as the others.

Crate layout (rust/):
- copilot-sdk crate (lib name copilot) targeting tokio/serde/async-trait
- Public client (Client, ClientOptions, Transport: Stdio/Tcp/External)
  with stdio, TCP, and external transports; child process management
  with stderr draining; protocol version negotiation; and graceful
  Drop-time cleanup.
- Session API (Session, SessionConfig, ResumeSessionConfig) covering
  create/resume, send_message, get_messages, set_model /
  set_model_with_options, list-sessions, attachments, hooks, and
  reload helpers.
- Handler traits: SessionHandler, SessionHooks, SystemMessageTransform,
  SessionFsHandler, ListModelsHandler with idiomatic async-trait
  bounds and blanket impls for closures where appropriate.
- Typed session events generated from the shared schema, with full
  enum coverage and pattern-matching ergonomics.
- Custom session filesystem provider: connection-level SessionFsConfig
  + validation, sessionFs.setProvider registration after protocol
  verification, and per-session dispatch of all 10 sessionFs.* RPCs.
- Custom onListModels handler with thread-safe, double-checked cache
  matching the other SDKs' semantics.
- Model capability overrides via SetModelOptions / ModelCapabilitiesOverride
  and extended SessionConfig/ResumeSessionConfig fields (session_id,
  agent, model_capabilities, config_dir, working_directory,
  available_tools, provider, custom_agents, infinite_sessions,
  commands, disabled_skills, disable_resume).
- Permission, elicitation, exit-plan-mode, and user-input request
  routing with strongly typed results.
- Duration serde helper and codegen support for format: "duration",
  "deprecated": true, and $ref resolution.

Code generation (scripts/codegen/rust.ts):
- New TypeScript generator producing rust/src/generated/{rpc,session_events}.rs
- Mirrors the existing Go/Python/.NET generators: shared type
  registration, snake_case <-> camelCase serde renames, optional
  field handling, anonymous struct flattening, enum variant
  generation, and special-case handling (duration, deprecated, $ref).
- Run via: cd scripts/codegen && npm run generate:rust

CI / repo integration:
- GitHub Actions workflow for the Rust SDK (build, fmt, clippy, test)
- justfile tasks updated so just install / format / lint / test cover Rust
- Consistency-agent coverage so the Rust surface is checked against the
  other SDKs

Scenarios / E2E:
- Rust implementations of the shared E2E scenarios under
  test/scenarios/** so the replaying CAPI proxy harness exercises the
  Rust SDK alongside the others.

Docs:
- rust/README.md with quick start, API reference, and parity notes for
  the new handlers and extended config fields.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: stephentoub

.gitattributes

@@ -5,4 +5,5 @@ nodejs/src/generated/* eol=lf linguist-generated=true
 dotnet/src/Generated/* eol=lf linguist-generated=true
 python/copilot/generated/* eol=lf linguist-generated=true
 go/generated_session_events.go eol=lf linguist-generated=true
-go/rpc/generated_rpc.go eol=lf linguist-generated=true
+go/rpc/generated_rpc.go eol=lf linguist-generated=true
+rust/src/generated/* eol=lf linguist-generated=true

.github/copilot-instructions.md

@@ -4,13 +4,13 @@
 
 ## Big picture 🔧
 
-- The repo implements language SDKs (Node/TS, Python, Go, .NET) that speak to the **Copilot CLI** via **JSON‑RPC** (see `README.md` and `nodejs/src/client.ts`).
-- Typical flow: your App → SDK client → JSON-RPC → Copilot CLI (server mode). The CLI must be installed or you can connect to an external CLI server via the `CLI URL option (language-specific casing)` (Node: `cliUrl`, Go: `CLIUrl`, .NET: `CliUrl`, Python: `cli_url`).
+- The repo implements language SDKs (Node/TS, Python, Go, .NET, Rust) that speak to the **Copilot CLI** via **JSON‑RPC** (see `README.md` and `nodejs/src/client.ts`).
+- Typical flow: your App → SDK client → JSON-RPC → Copilot CLI (server mode). The CLI must be installed or you can connect to an external CLI server via the `CLI URL option (language-specific casing)` (Node: `cliUrl`, Go: `CLIUrl`, .NET: `CliUrl`, Python: `cli_url`, Rust: `cli_url`).
 
 ## Most important files to read first 📚
 
 - Top-level: `README.md` (architecture + quick start)
-- Language entry points: `nodejs/src/client.ts`, `python/README.md`, `go/README.md`, `dotnet/README.md`
+- Language entry points: `nodejs/src/client.ts`, `python/README.md`, `go/README.md`, `dotnet/README.md`, `rust/README.md`
 - Test harness & E2E: `test/harness/*`, Python harness wrapper `python/e2e/testharness/proxy.py`
 - Schemas & type generation: `nodejs/scripts/generate-session-types.ts`
 - Session snapshots used by E2E: `test/snapshots/` (used by the replay proxy)
@@ -25,6 +25,7 @@
   - Python: `cd python && uv pip install -e ".[dev]"` → `uv run pytest` (E2E tests use the test harness)
   - Go: `cd go && go test ./...`
   - .NET: `cd dotnet && dotnet test test/GitHub.Copilot.SDK.Test.csproj`
+  - Rust: `cd rust && cargo test`
   - **.NET testing note:** Never add `InternalsVisibleTo` to any project file when writing tests. Tests must only access public APIs.
 
 ## Testing & E2E tips ⚙️
@@ -35,20 +36,20 @@
 
 ## Project-specific conventions & patterns ✅
 
-- Tools: each SDK has helper APIs to expose functions as tools; prefer the language's `DefineTool`/`@define_tool`/`AIFunctionFactory.Create` patterns (see language READMEs).
+- Tools: each SDK has helper APIs to expose functions as tools; prefer the language's `DefineTool`/`@define_tool`/`AIFunctionFactory.Create`/`ToolHandler` trait patterns (see language READMEs).
 - Infinite sessions are enabled by default and persist workspace state to `~/.copilot/session-state/{sessionId}`; compaction events are emitted (`session.compaction_start`, `session.compaction_complete`). See language READMEs for usage.
 - Streaming: when `streaming`/`Streaming=true` you receive delta events (`assistant.message_delta`, `assistant.reasoning_delta`) and final events (`assistant.message`, `assistant.reasoning`) — tests expect this behavior.
 - Type generation is centralized in `nodejs/scripts/generate-session-types.ts` and requires the `@github/copilot` schema to be present (often via `npm link` or installed package).
 
 ## Integration & environment notes ⚠️
 
-- The SDK requires a Copilot CLI installation or an external server reachable via the `CLI URL option (language-specific casing)` (Node: `cliUrl`, Go: `CLIUrl`, .NET: `CliUrl`, Python: `cli_url`) or `COPILOT_CLI_PATH`.
+- The SDK requires a Copilot CLI installation or an external server reachable via the `CLI URL option (language-specific casing)` (Node: `cliUrl`, Go: `CLIUrl`, .NET: `CliUrl`, Python: `cli_url`, Rust: `cli_url`) or `COPILOT_CLI_PATH`.
 - Some scripts (typegen, formatting) call external tools: `gofmt`, `dotnet format`, `tsx` (available via npm), `quicktype`/`quicktype-core` (used by the Node typegen script), and `prettier` (provided as an npm devDependency). Most of these are available through the repo's package scripts or devDependencies—run `just install` (and `cd nodejs && npm ci`) to install them. Ensure the required tools are available in CI / developer machines.
 - Tests may assume `node >= 18`, `python >= 3.9`, platform differences handled (Windows uses `shell=True` for npx in harness).
 
 ## Where to add new code or tests 🧭
 
-- SDK code: `nodejs/src`, `python/copilot`, `go`, `dotnet/src`
-- Unit tests: `nodejs/test`, `python/*`, `go/*`, `dotnet/test`
+- SDK code: `nodejs/src`, `python/copilot`, `go`, `dotnet/src`, `rust/src`
+- Unit tests: `nodejs/test`, `python/*`, `go/*`, `dotnet/test`, `rust/tests`
 - E2E tests: `*/e2e/` folders that use the shared replay proxy and `test/snapshots/`
 - Generated types: update schema in `@github/copilot` then run `cd nodejs && npm run generate:session-types` and commit generated files in `src/generated` or language generated location.

.github/workflows/codegen-check.yml

@@ -13,6 +13,7 @@ on:
       - 'python/copilot/generated/**'
       - 'go/generated_*.go'
       - 'go/rpc/**'
+      - 'rust/src/generated/**'
       - '.github/workflows/codegen-check.yml'
   workflow_dispatch:
 

.github/workflows/docs-validation.yml

@@ -9,6 +9,7 @@ on:
       - 'python/copilot/**'
       - 'go/**/*.go'
       - 'dotnet/src/**'
+      - 'rust/src/**'
       - 'scripts/docs-validation/**'
       - '.github/workflows/docs-validation.yml'
   workflow_dispatch:

.github/workflows/rust-sdk-tests.yml

@@ -0,0 +1,80 @@
+name: "Rust SDK Tests"
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+    paths:
+      - 'rust/**'
+      - 'test/**'
+      - 'nodejs/package.json'
+      - '.github/workflows/rust-sdk-tests.yml'
+      - '.github/actions/setup-copilot/**'
+      - '!**/*.md'
+      - '!**/LICENSE*'
+      - '!**/.gitignore'
+      - '!**/.editorconfig'
+      - '!**/*.png'
+      - '!**/*.jpg'
+      - '!**/*.jpeg'
+      - '!**/*.gif'
+      - '!**/*.svg'
+  workflow_dispatch:
+  merge_group:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: "Rust SDK Tests"
+    env:
+      POWERSHELL_UPDATECHECK: Off
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+        working-directory: ./rust
+    steps:
+      - uses: actions/checkout@v6.0.2
+      - uses: ./.github/actions/setup-copilot
+        id: setup-copilot
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: "rust -> target"
+
+      - name: Run cargo fmt check
+        if: runner.os == 'Linux'
+        working-directory: ./rust
+        run: |
+          cargo fmt -- --check
+          echo "✅ cargo fmt produced no changes"
+
+      - name: Run cargo clippy
+        if: runner.os == 'Linux'
+        working-directory: ./rust
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+      - name: Install test harness dependencies
+        working-directory: ./test/harness
+        run: npm ci --ignore-scripts
+
+      - name: Warm up PowerShell
+        if: runner.os == 'Windows'
+        run: pwsh.exe -Command "Write-Host 'PowerShell ready'"
+
+      - name: Run Rust SDK tests
+        env:
+          COPILOT_HMAC_KEY: ${{ secrets.COPILOT_DEVELOPER_CLI_INTEGRATION_HMAC_KEY }}
+          COPILOT_CLI_PATH: ${{ steps.setup-copilot.outputs.cli-path }}
+        run: cargo test

.github/workflows/scenario-builds.yml

@@ -9,6 +9,8 @@ on:
       - "python/copilot/**"
       - "go/**/*.go"
       - "dotnet/src/**"
+      - "rust/src/**"
+      - "rust/Cargo.toml"
       - ".github/workflows/scenario-builds.yml"
   push:
     branches:
@@ -185,3 +187,41 @@ jobs:
             echo -e "Failures:$FAILURES"
             exit 1
           fi
+
+  # ── Rust ────────────────────────────────────────────────────────────
+  build-rust:
+    name: "Rust scenarios"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: "rust -> target"
+          cache-targets: false
+
+      - name: Check all Rust scenarios
+        run: |
+          PASS=0; FAIL=0; FAILURES=""
+          for manifest in $(find test/scenarios -path '*/rust/Cargo.toml' | sort); do
+            dir=$(dirname "$manifest")
+            scenario="${dir#test/scenarios/}"
+            echo "::group::$scenario"
+            if (cd "$dir" && cargo check 2>&1); then
+              echo "✅ $scenario"
+              PASS=$((PASS + 1))
+            else
+              echo "❌ $scenario"
+              FAIL=$((FAIL + 1))
+              FAILURES="$FAILURES\n  $scenario"
+            fi
+            echo "::endgroup::"
+          done
+          echo ""
+          echo "Rust checks: $PASS passed, $FAIL failed"
+          if [ "$FAIL" -gt 0 ]; then
+            echo -e "Failures:$FAILURES"
+            exit 1
+          fi

.github/workflows/sdk-consistency-review.md

@@ -10,6 +10,7 @@ on:
       - 'python/**'
       - 'go/**'
       - 'dotnet/**'
+      - 'rust/**'
   workflow_dispatch:
     inputs:
       pr_number:
@@ -35,7 +36,7 @@ timeout-minutes: 15
 
 # SDK Consistency Review Agent
 
-You are an AI code reviewer specialized in ensuring consistency across multi-language SDK implementations. This repository contains four SDK implementations (Node.js/TypeScript, Python, Go, and .NET) that should maintain feature parity and consistent API design.
+You are an AI code reviewer specialized in ensuring consistency across multi-language SDK implementations. This repository contains five SDK implementations (Node.js/TypeScript, Python, Go, .NET, and Rust) that should maintain feature parity and consistent API design.
 
 ## Your Task
 
@@ -69,6 +70,7 @@ When a pull request modifies any SDK client code, review it to ensure:
 - **Python**: `python/copilot/`
 - **Go**: `go/`
 - **.NET**: `dotnet/src/`
+- **Rust**: `rust/src/`
 
 ## Review Process
 
@@ -90,6 +92,7 @@ When a pull request modifies any SDK client code, review it to ensure:
    - Python uses snake_case (e.g., `create_session`)
    - Go uses PascalCase for exported/public functions (e.g., `CreateSession`) and camelCase for unexported/private functions
    - .NET uses PascalCase (e.g., `CreateSession`)
+   - Rust uses snake_case for functions (e.g., `create_session`) and PascalCase for types (e.g., `SessionConfig`)
    - Focus on public API methods when comparing across languages
 3. **Focus on API surface**: Prioritize public APIs over internal implementation details
 4. **Distinguish between bugs and features**:

README.md

@@ -8,7 +8,7 @@
 
 Agents for every app.
 
-Embed Copilot's agentic workflows in your application—now available in public preview as a programmable SDK for Python, TypeScript, Go, .NET, and Java.
+Embed Copilot's agentic workflows in your application—now available in public preview as a programmable SDK for Python, TypeScript, Go, .NET, Rust, and Java.
 
 The GitHub Copilot SDK exposes the same engine behind Copilot CLI: a production-tested agent runtime you can invoke programmatically. No need to build your own orchestration—you define agent behavior, Copilot handles planning, tool invocation, file edits, and more.
 
@@ -20,6 +20,7 @@ The GitHub Copilot SDK exposes the same engine behind Copilot CLI: a production-
 | **Python**               | [`python/`](./python/)                                                  | [Cookbook](https://github.com/github/awesome-copilot/blob/main/cookbook/copilot-sdk/python/README.md) | `pip install github-copilot-sdk`                                                                                                                                                                                                           |
 | **Go**                   | [`go/`](./go/)                                                          | [Cookbook](https://github.com/github/awesome-copilot/blob/main/cookbook/copilot-sdk/go/README.md)     | `go get github.com/github/copilot-sdk/go`                                                                                                                                                                                                  |
 | **.NET**                 | [`dotnet/`](./dotnet/)                                                  | [Cookbook](https://github.com/github/awesome-copilot/blob/main/cookbook/copilot-sdk/dotnet/README.md) | `dotnet add package GitHub.Copilot.SDK`                                                                                                                                                                                                    |
+| **Rust**                 | [`rust/`](./rust/)                                                      |                                                                                                       | `copilot-sdk = { git = "https://github.com/github/copilot-sdk" }`                                                                                                                                                                         |
 | **Java**                 | [`github/copilot-sdk-java`](https://github.com/github/copilot-sdk-java) | [Cookbook](https://github.com/github/awesome-copilot/blob/main/cookbook/copilot-sdk/java/README.md)                                                                                                   | Maven coordinates<br>`com.github:copilot-sdk-java`<br>See instructions for [Maven](https://github.com/github/copilot-sdk-java?tab=readme-ov-file#maven) and [Gradle](https://github.com/github/copilot-sdk-java?tab=readme-ov-file#gradle) |
 
 See the individual SDK READMEs for installation, usage examples, and API reference.
@@ -32,7 +33,7 @@ Quick steps:
 
 1. **(Optional) Install the Copilot CLI**
 
-For Node.js, Python, and .NET SDKs, the Copilot CLI is bundled automatically and no separate installation is required.
+For Node.js, Python, .NET, and Rust SDKs, the Copilot CLI is bundled automatically and no separate installation is required.
 For the Go SDK, [install the CLI manually](https://github.com/features/copilot/cli) or ensure `copilot` is available in your PATH.
 
 2. **Install your preferred SDK** using the commands above.

justfile

@@ -3,13 +3,13 @@ default:
     @just --list
 
 # Format all code across all languages
-format: format-go format-python format-nodejs format-dotnet
+format: format-go format-python format-nodejs format-dotnet format-rust
 
 # Lint all code across all languages
-lint: lint-go lint-python lint-nodejs lint-dotnet
+lint: lint-go lint-python lint-nodejs lint-dotnet lint-rust
 
 # Run tests for all languages
-test: test-go test-python test-nodejs test-dotnet test-corrections
+test: test-go test-python test-nodejs test-dotnet test-corrections test-rust
 
 # Format Go code
 format-go:
@@ -31,6 +31,11 @@ format-dotnet:
     @echo "=== Formatting .NET code ==="
     @cd dotnet && dotnet format src/GitHub.Copilot.SDK.csproj
 
+# Format Rust code
+format-rust:
+    @echo "=== Formatting Rust code ==="
+    @cd rust && cargo fmt
+
 # Lint Go code
 lint-go:
     @echo "=== Linting Go code ==="
@@ -51,6 +56,11 @@ lint-dotnet:
     @echo "=== Linting .NET code ==="
     @cd dotnet && dotnet format src/GitHub.Copilot.SDK.csproj --verify-no-changes
 
+# Lint Rust code
+lint-rust:
+    @echo "=== Linting Rust code ==="
+    @cd rust && cargo clippy --all-targets --all-features -- -D warnings
+
 # Test Go code
 test-go:
     @echo "=== Testing Go code ==="
@@ -71,13 +81,18 @@ test-dotnet:
     @echo "=== Testing .NET code ==="
     @cd dotnet && dotnet test test/GitHub.Copilot.SDK.Test.csproj
 
+# Test Rust code
+test-rust:
+    @echo "=== Testing Rust code ==="
+    @cd rust && cargo test
+
 # Test correction collection scripts
 test-corrections:
     @echo "=== Testing correction scripts ==="
     @cd scripts/corrections && npm test
 
 # Install all dependencies across all languages
-install: install-go install-python install-nodejs install-dotnet install-corrections
+install: install-go install-python install-nodejs install-dotnet install-corrections install-rust
     @echo "✅ All dependencies installed"
 
 # Install Go dependencies and prerequisites for tests
@@ -95,6 +110,11 @@ install-dotnet: install-nodejs install-test-harness
     @echo "=== Installing .NET dependencies ==="
     @cd dotnet && dotnet restore
 
+# Install Rust dependencies
+install-rust:
+    @echo "=== Installing Rust dependencies ==="
+    @cd rust && cargo fetch
+
 # Install Node.js dependencies
 install-nodejs:
     @echo "=== Installing Node.js dependencies ==="
@@ -187,6 +207,9 @@ scenario-build:
     # C#: dotnet build
     build_lang "C#" "-name '*.csproj' -path '*/csharp/*'" "dotnet build --nologo -v quiet"
 
+    # Rust: cargo check
+    build_lang "Rust" "-path '*/rust/Cargo.toml'" "cargo check --quiet"
+
     echo ""
     echo "══════════════════════════════════════"
     echo " Scenario build summary: $PASS passed, $FAIL failed (of $TOTAL)"
@@ -247,8 +270,18 @@ scenario-build-lang LANG:
           fi
         done
         ;;
+      rust)
+        for target in $(find test/scenarios -path '*/rust/Cargo.toml' | sort); do
+          dir=$(dirname "$target"); scenario="${dir#test/scenarios/}"
+          if (cd "$dir" && cargo check --quiet >/dev/null 2>&1); then
+            printf "  ✅ %s\n" "$scenario"; PASS=$((PASS + 1))
+          else
+            printf "  ❌ %s\n" "$scenario"; FAIL=$((FAIL + 1))
+          fi
+        done
+        ;;
       *)
-        echo "Unknown language: {{LANG}}. Use: typescript, python, go, csharp"
+        echo "Unknown language: {{LANG}}. Use: typescript, python, go, csharp, rust"
         exit 1
         ;;
     esac

nodejs/scripts/update-protocol-version.ts

@@ -117,4 +117,19 @@ internal static class SdkProtocolVersion
 fs.writeFileSync(path.join(rootDir, "dotnet", "src", "SdkProtocolVersion.cs"), csharpCode);
 console.log("  ✓ dotnet/src/SdkProtocolVersion.cs");
 
+// Generate Rust
+const rustCode = `// Code generated by update-protocol-version.ts. DO NOT EDIT.
+
+/// The SDK protocol version.
+/// This must match the version expected by the copilot-agent-runtime server.
+pub const SDK_PROTOCOL_VERSION: u32 = ${version};
+
+/// Gets the SDK protocol version.
+pub fn get_sdk_protocol_version() -> u32 {
+    SDK_PROTOCOL_VERSION
+}
+`;
+fs.writeFileSync(path.join(rootDir, "rust", "src", "generated", "mod.rs"), rustCode);
+console.log("  ✓ rust/src/generated/mod.rs");
+
 console.log("Done!");