Fix sub-agent hook propagation: expose sessionId on hook inputs (#1290)

Author: SteveSandersonMS

dotnet/src/Types.cs

@@ -1100,6 +1100,12 @@ public class HookInvocation
 /// </summary>
 public class PreToolUseHookInput
 {
+    /// <summary>
+    /// The runtime session ID of the session that triggered the hook.
+    /// </summary>
+    [JsonPropertyName("sessionId")]
+    public string SessionId { get; set; } = string.Empty;
+
     /// <summary>
     /// Unix timestamp in milliseconds when the tool use was initiated.
     /// </summary>
@@ -1176,6 +1182,12 @@ public class PreToolUseHookOutput
 /// </summary>
 public class PostToolUseHookInput
 {
+    /// <summary>
+    /// The runtime session ID of the session that triggered the hook.
+    /// </summary>
+    [JsonPropertyName("sessionId")]
+    public string SessionId { get; set; } = string.Empty;
+
     /// <summary>
     /// Unix timestamp in milliseconds when the tool execution completed.
     /// </summary>
@@ -1241,6 +1253,12 @@ public class PostToolUseHookOutput
 /// </summary>
 public class UserPromptSubmittedHookInput
 {
+    /// <summary>
+    /// The runtime session ID of the session that triggered the hook.
+    /// </summary>
+    [JsonPropertyName("sessionId")]
+    public string SessionId { get; set; } = string.Empty;
+
     /// <summary>
     /// Unix timestamp in milliseconds when the prompt was submitted.
     /// </summary>
@@ -1294,6 +1312,12 @@ public class UserPromptSubmittedHookOutput
 /// </summary>
 public class SessionStartHookInput
 {
+    /// <summary>
+    /// The runtime session ID of the session that triggered the hook.
+    /// </summary>
+    [JsonPropertyName("sessionId")]
+    public string SessionId { get; set; } = string.Empty;
+
     /// <summary>
     /// Unix timestamp in milliseconds when the session started.
     /// </summary>
@@ -1352,6 +1376,12 @@ public class SessionStartHookOutput
 /// </summary>
 public class SessionEndHookInput
 {
+    /// <summary>
+    /// The runtime session ID of the session that triggered the hook.
+    /// </summary>
+    [JsonPropertyName("sessionId")]
+    public string SessionId { get; set; } = string.Empty;
+
     /// <summary>
     /// Unix timestamp in milliseconds when the session ended.
     /// </summary>
@@ -1424,6 +1454,12 @@ public class SessionEndHookOutput
 /// </summary>
 public class ErrorOccurredHookInput
 {
+    /// <summary>
+    /// The runtime session ID of the session that triggered the hook.
+    /// </summary>
+    [JsonPropertyName("sessionId")]
+    public string SessionId { get; set; } = string.Empty;
+
     /// <summary>
     /// Unix timestamp in milliseconds when the error occurred.
     /// </summary>

dotnet/test/E2E/SubagentHooksE2ETests.cs

@@ -0,0 +1,73 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+using System.Collections.Concurrent;
+using GitHub.Copilot.SDK.Test.Harness;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GitHub.Copilot.SDK.Test.E2E;
+
+public class SubagentHooksE2ETests(E2ETestFixture fixture, ITestOutputHelper output)
+    : E2ETestBase(fixture, "subagent_hooks", output)
+{
+    [Fact]
+    public async Task Should_Invoke_PreToolUse_And_PostToolUse_Hooks_For_Sub_Agent_Tool_Calls()
+    {
+        var hookLog = new ConcurrentBag<(string Kind, string ToolName, string SessionId)>();
+
+        // Create a client with the session-based subagents feature flag
+        var env = new Dictionary<string, string>(Ctx.GetEnvironment());
+        env["COPILOT_EXP_COPILOT_CLI_SESSION_BASED_SUBAGENTS"] = "true";
+        var client = Ctx.CreateClient(options: new CopilotClientOptions { Environment = env });
+
+        var session = await client.CreateSessionAsync(new SessionConfig
+        {
+            OnPermissionRequest = PermissionHandler.ApproveAll,
+            Hooks = new SessionHooks
+            {
+                OnPreToolUse = (input, invocation) =>
+                {
+                    hookLog.Add(("pre", input.ToolName, input.SessionId));
+                    return Task.FromResult<PreToolUseHookOutput?>(new PreToolUseHookOutput
+                    {
+                        PermissionDecision = "allow"
+                    });
+                },
+                OnPostToolUse = (input, invocation) =>
+                {
+                    hookLog.Add(("post", input.ToolName, input.SessionId));
+                    return Task.FromResult<PostToolUseHookOutput?>(null);
+                },
+            },
+        });
+
+        // Create a file for the sub-agent to read
+        await File.WriteAllTextAsync(Path.Combine(Ctx.WorkDir, "subagent-test.txt"), "Hello from subagent test!");
+
+        await session.SendAndWaitAsync(
+            new MessageOptions
+            {
+                Prompt = "Use the task tool to spawn an explore agent that reads the file "
+                    + "subagent-test.txt in the current directory and reports its contents. "
+                    + "You must use the task tool."
+            },
+            timeout: TimeSpan.FromSeconds(120));
+
+        var log = hookLog.ToArray();
+
+        // Parent tool hooks fire for "task"
+        var taskPre = log.Where(h => h.Kind == "pre" && h.ToolName == "task").ToArray();
+        Assert.True(taskPre.Length >= 1, "preToolUse should fire for the parent's 'task' tool call");
+
+        // Sub-agent tool hooks fire for "view"
+        var viewPre = log.Where(h => h.Kind == "pre" && h.ToolName == "view").ToArray();
+        var viewPost = log.Where(h => h.Kind == "post" && h.ToolName == "view").ToArray();
+        Assert.True(viewPre.Length > 0, "preToolUse should fire for the sub-agent's 'view' tool call");
+        Assert.True(viewPost.Length > 0, "postToolUse should fire for the sub-agent's 'view' tool call");
+
+        // input.SessionId distinguishes parent from sub-agent
+        Assert.NotEqual(viewPre[0].SessionId, taskPre[0].SessionId);
+    }
+}

go/internal/e2e/subagent_hooks_e2e_test.go

@@ -0,0 +1,103 @@
+package e2e
+
+import (
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+
+	copilot "github.com/github/copilot-sdk/go"
+	"github.com/github/copilot-sdk/go/internal/e2e/testharness"
+)
+
+func TestSubagentHooksE2E(t *testing.T) {
+	ctx := testharness.NewTestContext(t)
+	client := ctx.NewClient(func(o *copilot.ClientOptions) {
+		o.Env = append(o.Env, "COPILOT_EXP_COPILOT_CLI_SESSION_BASED_SUBAGENTS=true")
+	})
+	t.Cleanup(func() { client.ForceStop() })
+
+	t.Run("should invoke preToolUse and postToolUse hooks for sub-agent tool calls", func(t *testing.T) {
+		ctx.ConfigureForTest(t)
+
+		type hookEntry struct {
+			kind      string
+			toolName  string
+			sessionID string
+		}
+		var hookLog []hookEntry
+		var mu sync.Mutex
+
+		session, err := client.CreateSession(t.Context(), &copilot.SessionConfig{
+			OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
+			Hooks: &copilot.SessionHooks{
+				OnPreToolUse: func(input copilot.PreToolUseHookInput, invocation copilot.HookInvocation) (*copilot.PreToolUseHookOutput, error) {
+					mu.Lock()
+					hookLog = append(hookLog, hookEntry{kind: "pre", toolName: input.ToolName, sessionID: input.SessionID})
+					mu.Unlock()
+					return &copilot.PreToolUseHookOutput{PermissionDecision: "allow"}, nil
+				},
+				OnPostToolUse: func(input copilot.PostToolUseHookInput, invocation copilot.HookInvocation) (*copilot.PostToolUseHookOutput, error) {
+					mu.Lock()
+					hookLog = append(hookLog, hookEntry{kind: "post", toolName: input.ToolName, sessionID: input.SessionID})
+					mu.Unlock()
+					return nil, nil
+				},
+			},
+		})
+		if err != nil {
+			t.Fatalf("Failed to create session: %v", err)
+		}
+
+		// Create a file for the sub-agent to read
+		testFile := filepath.Join(ctx.WorkDir, "subagent-test.txt")
+		if err := os.WriteFile(testFile, []byte("Hello from subagent test!"), 0644); err != nil {
+			t.Fatalf("Failed to write test file: %v", err)
+		}
+
+		_, err = session.SendAndWait(t.Context(), copilot.MessageOptions{
+			Prompt: "Use the task tool to spawn an explore agent that reads the file subagent-test.txt in the current directory and reports its contents. You must use the task tool.",
+		})
+		if err != nil {
+			t.Fatalf("Failed to send message: %v", err)
+		}
+
+		mu.Lock()
+		defer mu.Unlock()
+
+		// Parent tool hooks fire for "task"
+		var taskPre *hookEntry
+		for i := range hookLog {
+			if hookLog[i].kind == "pre" && hookLog[i].toolName == "task" {
+				taskPre = &hookLog[i]
+				break
+			}
+		}
+		if taskPre == nil {
+			t.Fatal("preToolUse should fire for the parent's 'task' tool call")
+		}
+
+		// Sub-agent tool hooks fire for "view"
+		var viewPre, viewPost []hookEntry
+		for _, h := range hookLog {
+			if h.toolName == "view" {
+				if h.kind == "pre" {
+					viewPre = append(viewPre, h)
+				} else {
+					viewPost = append(viewPost, h)
+				}
+			}
+		}
+		if len(viewPre) == 0 {
+			t.Fatal("preToolUse should fire for the sub-agent's 'view' tool call")
+		}
+		if len(viewPost) == 0 {
+			t.Fatal("postToolUse should fire for the sub-agent's 'view' tool call")
+		}
+
+		// input.SessionID distinguishes parent from sub-agent
+		if viewPre[0].sessionID == taskPre.sessionID {
+			t.Error("Sub-agent tool hooks should have a different sessionId than parent tool hooks")
+		}
+	})
+}

go/types.go

@@ -349,6 +349,7 @@ type AutoModeSwitchHandler func(request AutoModeSwitchRequest, invocation AutoMo
 
 // PreToolUseHookInput is the input for a pre-tool-use hook
 type PreToolUseHookInput struct {
+	SessionID string `json:"sessionId"`
 	Timestamp int64  `json:"timestamp"`
 	Cwd       string `json:"cwd"`
 	ToolName  string `json:"toolName"`
@@ -369,6 +370,7 @@ type PreToolUseHandler func(input PreToolUseHookInput, invocation HookInvocation
 
 // PostToolUseHookInput is the input for a post-tool-use hook
 type PostToolUseHookInput struct {
+	SessionID  string `json:"sessionId"`
 	Timestamp  int64  `json:"timestamp"`
 	Cwd        string `json:"cwd"`
 	ToolName   string `json:"toolName"`
@@ -388,6 +390,7 @@ type PostToolUseHandler func(input PostToolUseHookInput, invocation HookInvocati
 
 // UserPromptSubmittedHookInput is the input for a user-prompt-submitted hook
 type UserPromptSubmittedHookInput struct {
+	SessionID string `json:"sessionId"`
 	Timestamp int64  `json:"timestamp"`
 	Cwd       string `json:"cwd"`
 	Prompt    string `json:"prompt"`
@@ -405,6 +408,7 @@ type UserPromptSubmittedHandler func(input UserPromptSubmittedHookInput, invocat
 
 // SessionStartHookInput is the input for a session-start hook
 type SessionStartHookInput struct {
+	SessionID     string `json:"sessionId"`
 	Timestamp     int64  `json:"timestamp"`
 	Cwd           string `json:"cwd"`
 	Source        string `json:"source"` // "startup", "resume", "new"
@@ -422,6 +426,7 @@ type SessionStartHandler func(input SessionStartHookInput, invocation HookInvoca
 
 // SessionEndHookInput is the input for a session-end hook
 type SessionEndHookInput struct {
+	SessionID    string `json:"sessionId"`
 	Timestamp    int64  `json:"timestamp"`
 	Cwd          string `json:"cwd"`
 	Reason       string `json:"reason"` // "complete", "error", "abort", "timeout", "user_exit"
@@ -441,6 +446,7 @@ type SessionEndHandler func(input SessionEndHookInput, invocation HookInvocation
 
 // ErrorOccurredHookInput is the input for an error-occurred hook
 type ErrorOccurredHookInput struct {
+	SessionID    string `json:"sessionId"`
 	Timestamp    int64  `json:"timestamp"`
 	Cwd          string `json:"cwd"`
 	Error        string `json:"error"`

nodejs/src/types.ts

@@ -933,6 +933,9 @@ export type AutoModeSwitchHandler = (
  * Base interface for all hook inputs
  */
 export interface BaseHookInput {
+    /** The runtime session ID of the session that triggered the hook.
+     * For sub-agent hooks this differs from `invocation.sessionId`. */
+    sessionId: string;
     timestamp: number;
     cwd: string;
 }