fix(session): preserve tool metadata across pending→running transition

The AI SDK fires tool execute() as a detached promise before the
processor handles the tool-call stream event. When execute() calls
ctx.metadata({sessionId}), the processor's tool-call handler
overwrites the DB with a fresh running state that has no metadata,
making subagent sessions unclickable in the TUI.

- Add synchronous toolMetadata side-channel on processor context
- setToolMetadata() on Handle writes to the map immediately
- tool-call handler reads and merges metadata from the side-channel
- prompt.ts metadata callback calls setToolMetadata() before the
  async DB update, ensuring metadata is captured regardless of
  event ordering
- Add E2E regression test using fake Anthropic HTTP server through
  the real AI SDK streamText pipeline with gate-based assertion of
  running-state metadata

Closes #20184

Author: rmk40

packages/opencode/src/session/processor.ts

@@ -30,6 +30,7 @@ export namespace SessionProcessor {
   export interface Handle {
     readonly message: MessageV2.Assistant
     readonly partFromToolCall: (toolCallID: string) => MessageV2.ToolPart | undefined
+    readonly setToolMetadata: (toolCallID: string, val: { title?: string; metadata?: Record<string, any> }) => void
     readonly abort: () => Effect.Effect<void>
     readonly process: (streamInput: LLM.StreamInput) => Effect.Effect<Result>
   }
@@ -46,6 +47,7 @@ export namespace SessionProcessor {
 
   interface ProcessorContext extends Input {
     toolcalls: Record<string, MessageV2.ToolPart>
+    toolMetadata: Record<string, { title?: string; metadata?: Record<string, any> }>
     shouldBreak: boolean
     snapshot: string | undefined
     blocked: boolean
@@ -89,6 +91,7 @@ export namespace SessionProcessor {
           sessionID: input.sessionID,
           model: input.model,
           toolcalls: {},
+          toolMetadata: {},
           shouldBreak: false,
           snapshot: undefined,
           blocked: false,
@@ -173,10 +176,18 @@ export namespace SessionProcessor {
               }
               const match = ctx.toolcalls[value.toolCallId]
               if (!match) return
+              const pending = ctx.toolMetadata[value.toolCallId]
+              delete ctx.toolMetadata[value.toolCallId]
               ctx.toolcalls[value.toolCallId] = yield* session.updatePart({
                 ...match,
                 tool: value.toolName,
-                state: { status: "running", input: value.input, time: { start: Date.now() } },
+                state: {
+                  status: "running",
+                  input: value.input,
+                  time: { start: Date.now() },
+                  title: pending?.title,
+                  metadata: pending?.metadata,
+                },
                 metadata: value.providerMetadata,
               } satisfies MessageV2.ToolPart)
 
@@ -224,6 +235,7 @@ export namespace SessionProcessor {
                 },
               })
               delete ctx.toolcalls[value.toolCallId]
+              delete ctx.toolMetadata[value.toolCallId]
               return
             }
 
@@ -243,6 +255,7 @@ export namespace SessionProcessor {
                 ctx.blocked = ctx.shouldBreak
               }
               delete ctx.toolcalls[value.toolCallId]
+              delete ctx.toolMetadata[value.toolCallId]
               return
             }
 
@@ -494,6 +507,9 @@ export namespace SessionProcessor {
           partFromToolCall(toolCallID: string) {
             return ctx.toolcalls[toolCallID]
           },
+          setToolMetadata(toolCallID: string, val: { title?: string; metadata?: Record<string, any> }) {
+            ctx.toolMetadata[toolCallID] = val
+          },
           abort,
           process,
         } satisfies Handle

packages/opencode/src/session/prompt.ts

@@ -384,7 +384,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
         model: Provider.Model
         session: Session.Info
         tools?: Record<string, boolean>
-        processor: Pick<SessionProcessor.Handle, "message" | "partFromToolCall">
+        processor: Pick<SessionProcessor.Handle, "message" | "partFromToolCall" | "setToolMetadata">
         bypassAgentCheck: boolean
         messages: MessageV2.WithParts[]
       }) {
@@ -399,23 +399,23 @@ NOTE: At any point in time through this workflow you should feel free to ask the
           extra: { model: input.model, bypassAgentCheck: input.bypassAgentCheck },
           agent: input.agent.name,
           messages: input.messages,
-          metadata: (val) =>
-            Effect.runPromise(
+          metadata: (val) => {
+            input.processor.setToolMetadata(options.toolCallId, val)
+            return Effect.runPromise(
               Effect.gen(function* () {
                 const match = input.processor.partFromToolCall(options.toolCallId)
                 if (!match || match.state.status !== "running") return
                 yield* sessions.updatePart({
                   ...match,
                   state: {
+                    ...match.state,
                     title: val.title,
                     metadata: val.metadata,
-                    status: "running",
-                    input: args,
-                    time: { start: Date.now() },
                   },
                 })
               }),
-            ),
+            )
+          },
           ask: (req) =>
             Effect.runPromise(
               permission.ask({

packages/opencode/test/session/compaction.test.ts

@@ -149,6 +149,7 @@ function fake(
         state: { status: "pending", input: {}, raw: "" },
       }
     },
+    setToolMetadata() {},
     process: Effect.fn("TestSessionProcessor.process")(() => Effect.succeed(result)),
   } satisfies SessionProcessorModule.SessionProcessor.Handle
 }