Update SDK snapshot for Copilot CLI 1.0.90-5

Author: copilot-cli-release-app[bot]

.github/workflows/sdk-python.yml

@@ -33,6 +33,7 @@ jobs:
         os: ${{ fromJSON(inputs.platform == 'linux-x64' && '["ubuntu-latest"]' || inputs.platform == 'darwin-arm64' && '["macos-latest"]' || inputs.platform == 'win32-x64' && '["windows-latest"]' || '["ubuntu-latest","macos-latest","windows-latest"]') }}
         transport: [default, inprocess]
     runs-on: ${{ matrix.os }}
+    timeout-minutes: 20
     defaults:
       run:
         shell: bash

.github/workflows/sdk.yml

@@ -410,7 +410,7 @@ jobs:
       - sdk-win32-x64
       - sdk-docs
       - check-freshness
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
       - name: Check SDK results
         env:

dotnet/test/E2E/HookLifecycleAndOutputE2ETests.cs

@@ -2,6 +2,7 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *--------------------------------------------------------------------------------------------*/
 
+using GitHub.Copilot.Test.Harness;
 using Microsoft.Extensions.AI;
 using Xunit;
 using Xunit.Abstractions;
@@ -78,6 +79,87 @@ public async Task Should_Invoke_OnUserPromptSubmitted_Hook_When_Sending_A_Messag
         await session.DisposeAsync();
     }
 
+    [Fact]
+    [Trait(E2ETestTraits.Backend, E2ETestTraits.SelfConfiguredBackend)]
+    public async Task Should_Invoke_Session_Hooks_With_Named_Agent_After_Recreate()
+    {
+        var prompts = new List<string>();
+        var handler = new RecordingRequestHandler();
+        await using var client = Ctx.CreateClient(options: new CopilotClientOptions
+        {
+            Connection = RuntimeConnection.ForStdio(),
+            RequestHandler = handler,
+        });
+        await client.StartAsync();
+
+        var hooks = new SessionHooks
+        {
+            OnUserPromptSubmitted = (input, _) =>
+            {
+                lock (prompts)
+                {
+                    prompts.Add(input.Prompt);
+                }
+                return Task.FromResult<UserPromptSubmittedHookOutput?>(null);
+            },
+        };
+        var agent = new CustomAgentConfig
+        {
+            Name = "named-hook-agent",
+            Description = "Responds with a short answer",
+            Prompt = "Respond briefly to the user.",
+        };
+        var provider = new ProviderConfig
+        {
+            Type = "openai",
+            WireApi = "responses",
+            BaseUrl = "https://named-agent-hooks.invalid/v1",
+            ApiKey = "test-key",
+            ModelId = "claude-sonnet-5",
+            WireModel = "claude-sonnet-5",
+        };
+        await using var session = await Ctx.CreateSessionAsync(client, new SessionConfig
+        {
+            Model = "claude-sonnet-5",
+            Provider = provider,
+            Streaming = true,
+            CustomAgents = [agent],
+            Agent = agent.Name,
+            Hooks = hooks,
+            OnPermissionRequest = PermissionHandler.ApproveAll,
+        });
+
+        var first = await session.SendAndWaitAsync(new MessageOptions { Prompt = "First named-agent turn" });
+        Assert.Contains(RecordingRequestHandler.SyntheticText, first?.Data.Content ?? string.Empty);
+        lock (prompts)
+        {
+            Assert.Single(prompts);
+            Assert.Contains("First named-agent turn", prompts[0]);
+        }
+        await session.DisposeAsync();
+
+        await using var recreated = await Ctx.CreateSessionAsync(client, new SessionConfig
+        {
+            SessionId = session.SessionId,
+            Model = "claude-sonnet-5",
+            Provider = provider,
+            Streaming = true,
+            CustomAgents = [agent],
+            Agent = agent.Name,
+            Hooks = hooks,
+            OnPermissionRequest = PermissionHandler.ApproveAll,
+        });
+        Assert.Equal(session.SessionId, recreated.SessionId);
+        var second = await recreated.SendAndWaitAsync(new MessageOptions { Prompt = "Second named-agent turn" });
+        Assert.Contains(RecordingRequestHandler.SyntheticText, second?.Data.Content ?? string.Empty);
+        lock (prompts)
+        {
+            Assert.Equal(2, prompts.Count);
+            Assert.Contains("Second named-agent turn", prompts[1]);
+        }
+        Assert.Equal(2, handler.InferenceRequests.Count);
+    }
+
     [Fact]
     public async Task Should_Invoke_OnSessionEnd_Hook_When_Session_Is_Disconnected()
     {

nodejs/package.json

@@ -5,7 +5,7 @@
         "url": "https://github.com/github/copilot-sdk.git"
     },
     "version": "0.0.0-dev",
-    "copilotCliVersion": "1.0.90-4",
+    "copilotCliVersion": "1.0.90-5",
     "description": "TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC",
     "main": "./dist/cjs/index.js",
     "types": "./dist/index.d.ts",

nodejs/src/cliVersion.ts

@@ -1,3 +1,3 @@
-export const COPILOT_CLI_VERSION = "1.0.90-4";
+export const COPILOT_CLI_VERSION = "1.0.90-5";
 
 export const COPILOT_CLI_USE_NPM_PACKAGE = false;

nodejs/test/e2e/hooks.e2e.test.ts

@@ -5,17 +5,25 @@
 import { readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { describe, expect, it } from "vitest";
+import { z } from "zod";
 import type {
+    CopilotClient,
+    PermissionRequest,
     PreToolUseHookInput,
     PreToolUseHookOutput,
     PostToolUseHookInput,
     PostToolUseHookOutput,
 } from "../../src/index.js";
-import { approveAll } from "../../src/index.js";
-import { createSdkTestContext } from "./harness/sdkTestContext.js";
+import { approveAll, defineTool, RuntimeConnection } from "../../src/index.js";
+import {
+    createSdkTestContext,
+    getLegacyCliPathForTests,
+    isInProcessTransport,
+} from "./harness/sdkTestContext.js";
 
 describe("Session hooks", async () => {
-    const { copilotClient: client, workDir } = await createSdkTestContext();
+    const ctx = await createSdkTestContext();
+    const { copilotClient: client, workDir } = ctx;
 
     it("should invoke preToolUse hook when model runs a tool", async () => {
         const preToolUseInputs: PreToolUseHookInput[] = [];
@@ -161,4 +169,78 @@ describe("Session hooks", async () => {
 
         await session.disconnect();
     });
+
+    // Disconnecting the last owner tears the session down, so each resume must register
+    // the SDK's hooks with the freshly restored hook service.
+    async function expectPreToolUseAfterResume(target: CopilotClient): Promise<void> {
+        const preToolUseInputs: PreToolUseHookInput[] = [];
+        const permissionRequests: PermissionRequest[] = [];
+        const sessionOptions = () => ({
+            tools: [
+                defineTool("encrypt_string", {
+                    description: "Encrypts a string",
+                    parameters: z.object({
+                        input: z.string().describe("String to encrypt"),
+                    }),
+                    handler: ({ input }: { input: string }) => input.toUpperCase(),
+                }),
+            ],
+            // Records rather than denies so a regression surfaces as a clear assertion
+            // failure instead of a model-dependent denial transcript.
+            onPermissionRequest: (request: PermissionRequest) => {
+                permissionRequests.push(request);
+                return { kind: "approve-once" } as const;
+            },
+            hooks: {
+                onPreToolUse: async (input: PreToolUseHookInput) => {
+                    preToolUseInputs.push(input);
+                    return { permissionDecision: "allow" } as PreToolUseHookOutput;
+                },
+            },
+        });
+
+        let sessionId: string;
+        {
+            await using session1 = await target.createSession(sessionOptions());
+            sessionId = session1.sessionId;
+            await session1.sendAndWait({
+                prompt: "Use encrypt_string to encrypt this string: Hello",
+            });
+            expect(preToolUseInputs.map((input) => input.toolName)).toEqual(["encrypt_string"]);
+        }
+
+        await using session2 = await target.resumeSession(sessionId, sessionOptions());
+        const answer = await session2.sendAndWait({
+            prompt: "Use encrypt_string to encrypt this string: World",
+        });
+
+        expect(preToolUseInputs.map((input) => input.toolName)).toEqual([
+            "encrypt_string",
+            "encrypt_string",
+        ]);
+        expect(permissionRequests).toEqual([]);
+        // Validate the final assistant response arrived (guards against truncated captures)
+        expect(answer?.data.content).toContain("WORLD");
+    }
+
+    it("should invoke preToolUse hook for a custom tool after disconnect and resume", async () => {
+        await expectPreToolUseAfterResume(client);
+    });
+
+    // The legacy JavaScript CLI host tears sessions down through a separate path.
+    it.skipIf(isInProcessTransport)(
+        "should invoke preToolUse hook for a custom tool after disconnect and resume on the legacy CLI",
+        async () => {
+            const legacyClient = ctx.createClient({
+                connection: RuntimeConnection.forStdio({
+                    path: await getLegacyCliPathForTests(),
+                }),
+            });
+            try {
+                await expectPreToolUseAfterResume(legacyClient);
+            } finally {
+                await legacyClient.stop();
+            }
+        }
+    );
 });

test/snapshots/hooks/should_invoke_pretooluse_hook_for_a_custom_tool_after_disconnect_and_resume.yaml

@@ -0,0 +1,34 @@
+models:
+  - claude-sonnet-5
+conversations:
+  - messages:
+      - role: system
+        content: ${system}
+      - role: user
+        content: "Use encrypt_string to encrypt this string: Hello"
+      - role: assistant
+        tool_calls:
+          - id: toolcall_0
+            type: function
+            function:
+              name: encrypt_string
+              arguments: '{"input":"Hello"}'
+      - role: tool
+        tool_call_id: toolcall_0
+        content: HELLO
+      - role: assistant
+        content: "The encrypted string is: **HELLO**"
+      - role: user
+        content: "Use encrypt_string to encrypt this string: World"
+      - role: assistant
+        tool_calls:
+          - id: toolcall_1
+            type: function
+            function:
+              name: encrypt_string
+              arguments: '{"input":"World"}'
+      - role: tool
+        tool_call_id: toolcall_1
+        content: WORLD
+      - role: assistant
+        content: "The encrypted string is: **WORLD**"

test/snapshots/hooks/should_invoke_pretooluse_hook_for_a_custom_tool_after_disconnect_and_resume_on_the_legacy_cli.yaml

@@ -0,0 +1,34 @@
+models:
+  - claude-sonnet-5
+conversations:
+  - messages:
+      - role: system
+        content: ${system}
+      - role: user
+        content: "Use encrypt_string to encrypt this string: Hello"
+      - role: assistant
+        tool_calls:
+          - id: toolcall_0
+            type: function
+            function:
+              name: encrypt_string
+              arguments: '{"input":"Hello"}'
+      - role: tool
+        tool_call_id: toolcall_0
+        content: HELLO
+      - role: assistant
+        content: "The encrypted string is: **HELLO**"
+      - role: user
+        content: "Use encrypt_string to encrypt this string: World"
+      - role: assistant
+        tool_calls:
+          - id: toolcall_1
+            type: function
+            function:
+              name: encrypt_string
+              arguments: '{"input":"World"}'
+      - role: tool
+        tool_call_id: toolcall_1
+        content: WORLD
+      - role: assistant
+        content: "The encrypted string is: **WORLD**"