@cuongtran001/kanna 1.2.0 → 1.3.1

package/src/server/claude-subagent-wiring.test.ts

@@ -0,0 +1,263 @@
+/**
+ * Colocated unit tests for claude-subagent-wiring.ts.
+ *
+ * Tests cover the two extracted functions without a real AgentCoordinator:
+ *   - buildClaudeSubagentStarter  — PTY vs SDK dispatch logic
+ *   - buildSubagentProviderRunForChat — ProviderRunStart construction
+ */
+
+import { describe, expect, test } from "bun:test"
+import {
+  buildClaudeSubagentStarter,
+  buildSubagentProviderRunForChat,
+  type SubagentWiringDeps,
+  type BuildSubagentProviderRunForChatArgs,
+} from "./claude-subagent-wiring"
+import type { ProviderRunStart } from "./subagent-orchestrator"
+
+// ---------------------------------------------------------------------------
+// Minimal stubs — only what the functions call
+// ---------------------------------------------------------------------------
+
+const NOOP_PROMISE = () => Promise.resolve(null as unknown as never)
+
+function makeDeps(overrides: Partial<SubagentWiringDeps> = {}): SubagentWiringDeps {
+  const pendingResolvers = new Map<
+    string,
+    { resolve: (v: unknown) => void; reject: (e: Error) => void }
+  >()
+
+  const fakeSession = { interrupt: () => {}, getAccountInfo: async () => null, close: () => {}, getSupportedCommands: async () => [], setModel: async () => {}, setPermissionMode: async () => {}, sendPrompt: NOOP_PROMISE, pushChannelPrompt: NOOP_PROMISE }
+
+  return {
+    store: {
+      requireChat: (chatId) => ({
+        id: chatId,
+        projectId: "proj-1",
+        provider: "claude",
+        model: "claude-opus-4-5",
+        effort: undefined,
+        serviceTier: undefined,
+        planMode: false,
+        title: "Test chat",
+        createdAt: 0,
+        updatedAt: 0,
+        tokenCount: 0,
+        compactFailureCount: 0,
+        policyOverride: undefined,
+        stackProjectIds: [],
+      } as never),
+      getProject: (_id) => ({
+        id: "proj-1",
+        localPath: "/tmp/test-project",
+        title: "Test Project",
+        createdAt: 0,
+        updatedAt: 0,
+      } as never),
+      appendSubagentEvent: async () => {},
+    },
+    startClaudeSessionFn: async (_a) => fakeSession as never,
+    startClaudeSessionPTYFn: async (_a) => fakeSession as never,
+    toolCallback: null,
+    tunnelGateway: null,
+    claudePtyRegistry: null,
+    ptyInstanceRegistry: null,
+    workflowRegistry: null,
+    subagentOrchestrator: {
+      notifySubagentToolPending: () => {},
+    } as never,
+    codexManager: {} as never,
+    oauthPool: null,
+    subagentPendingResolvers: pendingResolvers as never,
+    realpath: (p) => p,
+    resolveClaudeDriverPreference: () => "sdk",
+    getEnabledCustomMcpServers: () => [],
+    buildOAuthBearers: async () => new Map(),
+    resolveChatPolicy: () => ({ mode: "acceptEdits" } as never),
+    emitStateChange: () => {},
+    buildPoolUnavailableMessage: () => "no token available",
+    getAppSettingsSnapshot: () => ({}),
+    readLlmProvider: async () => ({ provider: "claude", apiKey: null } as never),
+    subagentPendingKey: (chatId, runId, toolUseId) => `${chatId}::${runId}::${toolUseId}`,
+    ...overrides,
+  }
+}
+
+const BASE_SUBAGENT = {
+  id: "subagent-1",
+  name: "Test Agent",
+  description: "A test agent",
+  provider: "claude" as const,
+  model: "claude-opus-4-5",
+  modelOptions: { reasoningEffort: "low" as const, contextWindow: "200k" as const },
+  systemPrompt: "You are a test agent",
+  contextScope: "full-transcript" as const,
+  triggerMode: "manual" as const,
+  workingDir: undefined,
+  allowedPaths: undefined,
+  maxTurns: undefined,
+  updatedAt: 0,
+  createdAt: 0,
+}
+
+const BASE_ARGS: BuildSubagentProviderRunForChatArgs = {
+  subagent: BASE_SUBAGENT,
+  chatId: "chat-1",
+  primer: null,
+  userInstruction: "do something",
+  runId: "run-1",
+  abortSignal: new AbortController().signal,
+  depth: 0,
+  ancestorSubagentIds: [],
+  parentUserMessageId: "msg-1",
+}
+
+// ---------------------------------------------------------------------------
+// buildClaudeSubagentStarter
+// ---------------------------------------------------------------------------
+
+describe("buildClaudeSubagentStarter", () => {
+  test("returns a function", () => {
+    const starter = buildClaudeSubagentStarter(makeDeps())
+    expect(typeof starter).toBe("function")
+  })
+
+  test("SDK preference — calls startClaudeSessionFn with merged mcpServers", async () => {
+    let capturedArgs: unknown = null
+    const deps = makeDeps({
+      resolveClaudeDriverPreference: () => "sdk",
+      startClaudeSessionFn: async (a) => {
+        capturedArgs = a
+        return {} as never
+      },
+      getEnabledCustomMcpServers: () => [{ id: "s1", name: "server1", transport: "stdio", command: "npx", args: [], env: {}, disabled: false }] as never,
+      buildOAuthBearers: async () => new Map([["s1", "bearer-token"]]),
+    })
+    const starter = buildClaudeSubagentStarter(deps)
+    await starter({
+      projectId: "proj",
+      localPath: "/tmp/x",
+      model: "claude-opus-4-5",
+      effort: undefined,
+      planMode: false,
+      sessionToken: null,
+      forkSession: false,
+      oauthToken: null,
+      onToolRequest: async () => null,
+    } as never)
+
+    expect(capturedArgs).not.toBeNull()
+    const args = capturedArgs as Record<string, unknown>
+    expect(Array.isArray(args.customMcpServers)).toBe(true)
+    expect((args.customMcpServers as unknown[]).length).toBe(1)
+    expect(args.oauthBearers).toBeInstanceOf(Map)
+  })
+
+  test("PTY preference — calls startClaudeSessionPTYFn with oneShot: true", async () => {
+    let ptyCalled = false
+    let capturedPtyArgs: unknown = null
+    const deps = makeDeps({
+      resolveClaudeDriverPreference: () => "pty",
+      startClaudeSessionPTYFn: async (a) => {
+        ptyCalled = true
+        capturedPtyArgs = a
+        return {} as never
+      },
+    })
+    const starter = buildClaudeSubagentStarter(deps)
+    await starter({
+      chatId: "chat-x",
+      projectId: "proj",
+      localPath: "/tmp/x",
+      model: "claude-opus-4-5",
+      effort: undefined,
+      planMode: false,
+      sessionToken: null,
+      forkSession: false,
+      oauthToken: null,
+      onToolRequest: async () => null,
+    } as never)
+
+    expect(ptyCalled).toBe(true)
+    const ptyArgs = capturedPtyArgs as Record<string, unknown>
+    expect(ptyArgs.oneShot).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildSubagentProviderRunForChat
+// ---------------------------------------------------------------------------
+
+describe("buildSubagentProviderRunForChat", () => {
+  test("returns a ProviderRunStart with a start function", () => {
+    const result: ProviderRunStart = buildSubagentProviderRunForChat(makeDeps(), BASE_ARGS)
+    expect(typeof result.start).toBe("function")
+  })
+
+  test("throws when project is not found", () => {
+    const deps = makeDeps({
+      store: {
+        requireChat: (_chatId) => ({ id: _chatId, projectId: "proj-missing" } as never),
+        getProject: (_id) => undefined,
+        appendSubagentEvent: async () => {},
+      },
+    })
+    expect(() => buildSubagentProviderRunForChat(deps, BASE_ARGS)).toThrow(
+      "Project proj-missing not found for chat chat-1",
+    )
+  })
+
+  test("cwdOverride suppresses restriction and additionalDirectories", () => {
+    const capturedStartArgs: unknown[] = []
+    const deps = makeDeps({
+      startClaudeSessionFn: async (a) => {
+        capturedStartArgs.push(a)
+        return {} as never
+      },
+    })
+    const args: BuildSubagentProviderRunForChatArgs = {
+      ...BASE_ARGS,
+      cwdOverride: "/tmp/worktree",
+    }
+    const result = buildSubagentProviderRunForChat(deps, args)
+    // The ProviderRunStart is constructed — just verify it's valid
+    expect(typeof result.start).toBe("function")
+  })
+
+  test("delegation context increments depth and chains ancestorSubagentIds", () => {
+    // We verify the ProviderRunStart is created correctly with depth 0+1=1
+    // by checking the function doesn't throw with proper args
+    const args: BuildSubagentProviderRunForChatArgs = {
+      ...BASE_ARGS,
+      depth: 0,
+      ancestorSubagentIds: [],
+    }
+    const result = buildSubagentProviderRunForChat(makeDeps(), args)
+    expect(typeof result.start).toBe("function")
+  })
+
+  test("subagentPendingKey is called when onToolRequest receives ask_user_question", async () => {
+    let keyBuilt: string | null = null
+    const deps = makeDeps({
+      subagentPendingKey: (chatId, runId, toolUseId) => {
+        keyBuilt = `${chatId}::${runId}::${toolUseId}`
+        return keyBuilt
+      },
+      store: {
+        requireChat: (_chatId) =>
+          ({ id: _chatId, projectId: "proj-1", stackProjectIds: [] } as never),
+        getProject: (_id) =>
+          ({ id: "proj-1", localPath: "/tmp/test-project", title: "Test" } as never),
+        appendSubagentEvent: async () => {},
+      },
+    })
+
+    // We can't easily invoke onToolRequest without running start(), but we can
+    // confirm the ProviderRunStart builds without error, which exercises the
+    // closure that captures subagentPendingKey.
+    const result = buildSubagentProviderRunForChat(deps, BASE_ARGS)
+    expect(typeof result.start).toBe("function")
+    // The key builder will be called lazily when onToolRequest fires during a run.
+    expect(keyBuilt).toBeNull() // not yet called
+  })
+})

package/src/server/claude-subagent-wiring.ts

@@ -0,0 +1,324 @@
+/**
+ * Subagent provider-run wiring — standalone extraction from AgentCoordinator.
+ *
+ * Responsibilities:
+ *   - buildClaudeSubagentStarter — builds the startClaudeSession callback for
+ *     subagent runs: PTY/SDK dispatch, OAuth, MCP config, pool wiring.
+ *   - buildSubagentProviderRunForChat — constructs the full ProviderRunStart
+ *     bundle for a subagent run bound to a specific chat.
+ *
+ * Side-effect seal: this module contains NO direct IO (no node:fs, no HTTP
+ * calls, no Bun primitives). Every effectful operation is injected through
+ * SubagentWiringDeps so the module remains testable without real drivers.
+ * The `realpath` function is injected as a dep (RealpathFn) rather than
+ * imported from `paths-fs.adapter` directly.
+ */
+
+import type { AnyValue } from "../shared/errors"
+import type {
+  ClaudeDriverPreference,
+  LlmProviderSnapshot,
+  McpServerConfig,
+  Subagent,
+} from "../shared/types"
+import type { HarnessToolRequest } from "./harness-types"
+import type { ClaudeSessionHandle } from "./harness-types"
+import type { KannaMcpDelegationContext } from "./kanna-mcp"
+import type { ChatRecord, ProjectRecord, SubagentRunEvent } from "./events"
+import type { ProviderRunStart, SubagentOrchestrator } from "./subagent-orchestrator"
+import type { BuildSubagentProviderRunArgs } from "./subagent-provider-run"
+import { buildSubagentProviderRun } from "./subagent-provider-run"
+import type { StartClaudeSessionPtyArgs } from "./claude-pty/driver"
+import type { ChatPermissionPolicy } from "../shared/permission-policy"
+import type { ToolCallbackService } from "./tool-callback"
+import type { TunnelGateway } from "./cloudflare-tunnel/gateway"
+import type { ClaudePtyRegistry } from "./claude-pty/pid-registry.adapter"
+import type { PtyInstanceRegistry } from "./claude-pty/pty-instance-registry"
+import type { WorkflowRegistry } from "./workflow-registry"
+import type { CodexAppServerManager } from "./codex-app-server"
+import type { RealpathFn } from "./paths"
+import { resolveSubagentRoots } from "./paths"
+import { resolveSpawnPaths, resolveStackProjects } from "./claude-session-config"
+import { openrouterAuthReady } from "./provider-catalog"
+import { OAuthPoolUnavailableError } from "./oauth-errors"
+// Type-only import — no IO is pulled in from the SDK session start module.
+import type { startClaudeSession as StartClaudeSessionFn } from "./claude-session-start"
+
+// ---------------------------------------------------------------------------
+// Structural sub-interfaces — only the operations this module calls.
+// ---------------------------------------------------------------------------
+
+/** Subset of EventStore used by subagent wiring. */
+interface SubagentWiringStore {
+  requireChat(chatId: string): ChatRecord
+  getProject(id: string): ProjectRecord | null | undefined
+  appendSubagentEvent(event: SubagentRunEvent): Promise<void>
+}
+
+/** Subset of OAuthTokenPool used by subagent wiring. */
+interface SubagentWiringOAuthPool {
+  hasUsable(reservedFor?: string): boolean
+  pickActive(chatId: string): { id: string; token: string; label: string } | null | undefined
+  markUsed(tokenId: string): void
+  hasAnyToken(): boolean
+}
+
+// ---------------------------------------------------------------------------
+// Dependency bundle
+// ---------------------------------------------------------------------------
+
+/**
+ * All AgentCoordinator fields and methods accessed by the subagent wiring
+ * functions. Passed as a single deps object so both functions stay testable
+ * without a real coordinator.
+ */
+export interface SubagentWiringDeps {
+  // Store (structural subset — no concrete EventStore import)
+  store: SubagentWiringStore
+
+  // Session-start function references (injected so tests can stub them)
+  startClaudeSessionFn: typeof StartClaudeSessionFn
+  startClaudeSessionPTYFn: (args: StartClaudeSessionPtyArgs) => Promise<ClaudeSessionHandle>
+
+  // Opaque state passed through to the start functions
+  toolCallback: ToolCallbackService | null
+  tunnelGateway: TunnelGateway | null
+  claudePtyRegistry: ClaudePtyRegistry | null
+  ptyInstanceRegistry: PtyInstanceRegistry | null
+  workflowRegistry: WorkflowRegistry | null
+  subagentOrchestrator: SubagentOrchestrator
+  codexManager: CodexAppServerManager
+  oauthPool: SubagentWiringOAuthPool | null
+
+  // Per-run pending resolver registry (shared with the coordinator's cancel paths)
+  subagentPendingResolvers: Map<string, { resolve: (v: AnyValue) => void; reject: (e: Error) => void }>
+
+  // IO injection — realpath wraps realpathSync but is IO; inject via deps
+  realpath: RealpathFn
+
+  // Method references for private AgentCoordinator helpers
+  resolveClaudeDriverPreference: () => ClaudeDriverPreference
+  getEnabledCustomMcpServers: () => readonly McpServerConfig[]
+  buildOAuthBearers: (servers: readonly McpServerConfig[]) => Promise<Map<string, string>>
+  resolveChatPolicy: (chatId: string) => ChatPermissionPolicy
+  emitStateChange: (chatId: string) => void
+  buildPoolUnavailableMessage: (reservedFor: string, scopeSuffix: string) => string
+  getAppSettingsSnapshot: () => {
+    globalPromptAppend?: string
+    claudeAuth?: { authenticated?: boolean } | null
+  }
+  readLlmProvider: () => Promise<LlmProviderSnapshot>
+  subagentPendingKey: (chatId: string, runId: string, toolUseId: string) => string
+}
+
+// ---------------------------------------------------------------------------
+// Exported args type for buildSubagentProviderRunForChat
+// ---------------------------------------------------------------------------
+
+export interface BuildSubagentProviderRunForChatArgs {
+  subagent: Subagent
+  chatId: string
+  primer: string | null
+  userInstruction: string | null
+  runId: string
+  abortSignal: AbortSignal
+  depth: number
+  ancestorSubagentIds: string[]
+  parentUserMessageId: string
+  /**
+   * Orchestration workers run in an isolated git worktree, not the chat cwd.
+   * When set, this overrides the resolved cwd, disables workingDir/allowedPaths
+   * restriction, and drops additional dirs / stack labelling (the worktree is
+   * a self-contained checkout).
+   */
+  cwdOverride?: string
+}
+
+// ---------------------------------------------------------------------------
+// Core functions
+// ---------------------------------------------------------------------------
+
+/**
+ * D6 — subagent Claude starter. When `KANNA_CLAUDE_DRIVER=pty` the subagent
+ * turn runs through the PTY driver (subscription billing) instead of always
+ * falling back to the SDK (API billing). Adapts the SDK-shaped
+ * `startClaudeSession` arg to `StartClaudeSessionPtyArgs`, injecting the
+ * coordinator-owned preflight / toolCallback / tunnel / policy context and
+ * `oneShot: true` so the REPL closes after the single subagent turn.
+ *
+ * Extracted from AgentCoordinator.buildClaudeSubagentStarter.
+ */
+export function buildClaudeSubagentStarter(
+  deps: SubagentWiringDeps,
+): NonNullable<BuildSubagentProviderRunArgs["startClaudeSession"]> {
+  return async (a) => {
+    const enabledMcpServers = deps.getEnabledCustomMcpServers()
+    const oauthBearers = await deps.buildOAuthBearers(enabledMcpServers)
+    if (deps.resolveClaudeDriverPreference() === "pty") {
+      return deps.startClaudeSessionPTYFn({
+        chatId: a.chatId ?? "",
+        projectId: a.projectId,
+        localPath: a.localPath,
+        model: a.model,
+        effort: a.effort,
+        planMode: a.planMode,
+        sessionToken: a.sessionToken,
+        forkSession: a.forkSession,
+        oauthToken: a.oauthToken,
+        additionalDirectories: a.additionalDirectories,
+        onToolRequest: a.onToolRequest,
+        systemPromptOverride: a.systemPromptOverride,
+        initialPrompt: a.initialPrompt,
+        subagentOrchestrator: a.subagentOrchestrator,
+        delegationContext: a.delegationContext,
+        toolCallback: deps.toolCallback ?? undefined,
+        tunnelGateway: deps.tunnelGateway,
+        chatPolicy: a.chatId ? deps.resolveChatPolicy(a.chatId) : undefined,
+        oneShot: true,
+        ptyRegistry: deps.claudePtyRegistry ?? undefined,
+        ptyInstanceRegistry: deps.ptyInstanceRegistry ?? undefined,
+        workflowRegistry: deps.workflowRegistry ?? undefined,
+        customMcpServers: enabledMcpServers,
+        oauthBearers,
+        restrictedAllowedPaths: a.restrictedAllowedPaths,
+        keepAlive: a.keepAlive,
+      })
+    }
+    return deps.startClaudeSessionFn({ ...a, customMcpServers: enabledMcpServers, oauthBearers })
+  }
+}
+
+/**
+ * Constructs the full ProviderRunStart bundle for a subagent run bound to a
+ * specific chat. Resolves the cwd, builds the delegation context, wires up the
+ * interactive tool-request forwarder, and delegates to `buildSubagentProviderRun`.
+ *
+ * Extracted from AgentCoordinator.buildSubagentProviderRunForChat.
+ */
+export function buildSubagentProviderRunForChat(
+  deps: SubagentWiringDeps,
+  args: BuildSubagentProviderRunForChatArgs,
+): ProviderRunStart {
+  const chat = deps.store.requireChat(args.chatId)
+  const project = deps.store.getProject(chat.projectId)
+  if (!project) throw new Error(`Project ${chat.projectId} not found for chat ${args.chatId}`)
+  const spawn = resolveSpawnPaths(chat, project.localPath)
+  const restriction =
+    args.cwdOverride === undefined &&
+    (args.subagent.workingDir !== undefined || args.subagent.allowedPaths !== undefined)
+      ? resolveSubagentRoots(
+          spawn.cwd,
+          args.subagent.workingDir,
+          args.subagent.allowedPaths,
+          deps.realpath,
+        )
+      : null
+
+  const onToolRequest = async (request: HarnessToolRequest): Promise<AnyValue> => {
+    if (
+      request.tool.toolKind !== "ask_user_question" &&
+      request.tool.toolKind !== "exit_plan_mode"
+    ) {
+      // Non-interactive tools (bash, read, write, ...) — SDK handles
+      // them via canUseTool wrapper. No forwarding needed.
+      return null
+    }
+    const toolUseId = request.tool.toolId
+    const key = deps.subagentPendingKey(args.chatId, args.runId, toolUseId)
+    await deps.store.appendSubagentEvent({
+      v: 3,
+      type: "subagent_tool_pending",
+      timestamp: Date.now(),
+      chatId: args.chatId,
+      runId: args.runId,
+      toolUseId,
+      toolKind: request.tool.toolKind,
+      input: request.tool.input,
+    })
+    deps.emitStateChange(args.chatId)
+    deps.subagentOrchestrator.notifySubagentToolPending(args.runId)
+    return await new Promise<AnyValue>((resolve, reject) => {
+      // Defensive: if `canUseTool` somehow fires twice for the same
+      // (chatId, runId, toolUseId) — e.g. SDK retry — reject the previous
+      // resolver before overwriting so its Promise doesn't leak.
+      const existing = deps.subagentPendingResolvers.get(key)
+      if (existing) {
+        existing.reject(new Error("superseded by retry"))
+      }
+      deps.subagentPendingResolvers.set(key, { resolve, reject })
+    })
+  }
+
+  const delegationContext: KannaMcpDelegationContext = {
+    parentSubagentId: args.subagent.id,
+    parentRunId: args.runId,
+    ancestorSubagentIds: [...args.ancestorSubagentIds, args.subagent.id],
+    depth: args.depth + 1,
+    // For sub-spawn-sub, the parent_user_message_id stays anchored to the
+    // chat turn that started the whole chain — that's the attribution the
+    // run_started events use, and the orchestrator's depth/cycle checks
+    // protect against runaway chains.
+    getParentUserMessageId: () => args.parentUserMessageId,
+    // Subagents cannot inherit the user's @-mention authority: manual-trigger
+    // gates are enforced only at the top-level turn where the user typed the mention.
+    getMentionedSubagentIds: () => [],
+  }
+
+  return buildSubagentProviderRun({
+    subagent: args.subagent,
+    chatId: args.chatId,
+    primer: args.primer,
+    userInstruction: args.userInstruction,
+    runId: args.runId,
+    abortSignal: args.abortSignal,
+    cwd: args.cwdOverride ?? restriction?.cwd ?? spawn.cwd,
+    additionalDirectories: args.cwdOverride ? [] : spawn.additionalDirectories,
+    // Only label stack projects for unrestricted runs — a path-restricted
+    // subagent cannot reach every root, so listing them all would mislead.
+    stackProjects:
+      args.cwdOverride || restriction
+        ? []
+        : resolveStackProjects(chat, (id) => deps.store.getProject(id)?.title),
+    allowedPaths: restriction?.allowedPaths,
+    projectId: project.id,
+    startClaudeSession: buildClaudeSubagentStarter(deps),
+    // PTY claude has no native maxTurns (interactive CLI) — the orchestrator
+    // applies a host-side tool-call-count backstop for PTY + Codex runs.
+    claudeDriverIsPty: deps.resolveClaudeDriverPreference() === "pty",
+    subagentOrchestrator: deps.subagentOrchestrator,
+    delegationContext,
+    codexManager: deps.codexManager,
+    onToolRequest,
+    globalPromptAppend: deps.getAppSettingsSnapshot().globalPromptAppend,
+    authReady: async (provider) => {
+      if (provider === "openrouter") {
+        return openrouterAuthReady(await deps.readLlmProvider())
+      }
+      if (provider === "claude") {
+        const settings = deps.getAppSettingsSnapshot()
+        // Pass parent chat id so a token already reserved by the parent
+        // counts as usable. Subagent runs are sequential under the parent
+        // (parent's turn is paused), so sharing the parent's reservation
+        // is correct — see oauth-token-pool isEligible.
+        return Boolean(
+          settings.claudeAuth?.authenticated || deps.oauthPool?.hasUsable(args.chatId),
+        )
+      }
+      return true
+    },
+    pickOauthToken: () => {
+      // Subagent inherits the parent chat's reservation by re-picking under
+      // the same chatId. pickActive treats the parent's reservation as
+      // owned-by-self (drops + re-binds to chatId), so the lifecycle stays
+      // bound to the parent's close path — no separate subagent release.
+      const picked = deps.oauthPool?.pickActive(args.chatId) ?? null
+      if (deps.oauthPool && deps.oauthPool.hasAnyToken() && !picked) {
+        throw new OAuthPoolUnavailableError(
+          deps.buildPoolUnavailableMessage(args.chatId, " for subagent run"),
+        )
+      }
+      if (picked) deps.oauthPool!.markUsed(picked.id)
+      return picked?.token ?? null
+    },
+  })
+}