@assistant-ui/react-ag-ui 0.0.57 → 0.0.59

package/src/runtime/adapter/conversions.ts

@@ -5,6 +5,7 @@ import { generateId } from "@assistant-ui/core";
 import type {
   ThreadMessageLike as CoreThreadMessageLike,
   PartProviderMetadata,
+  ThreadMessage,
   ToolCallMessagePartMcpMetadata,
   ToolModelContentPart,
 } from "@assistant-ui/core";
@@ -106,8 +107,17 @@ type ToolCallPart = {
   modelContent?: readonly ToolModelContentPart[];
   unstable_toolMessageId?: string;
   mcp?: ToolCallMessagePartMcpMetadata;
+  messages?: readonly ThreadMessage[];
+  approval?: CoreToolCallPartApproval;
 };
 
+type CoreToolCallPartApproval = NonNullable<
+  Extract<
+    Exclude<CoreThreadMessageLike["content"], string>[number],
+    { type: "tool-call" }
+  >["approval"]
+>;
+
 const isObject = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null;
 
@@ -1051,36 +1061,96 @@ function convertAssistantMessage(
     return;
   }
 
+  // A subagent's tool calls live on nested assistant messages. Before
+  // subagent attribution they flattened to root and went out with this
+  // assistant record as their antecedent, so the resume payload restores
+  // exactly that shape: the calls join this record's toolCalls and their
+  // results follow as tool records — never a tool record without its call.
+  // The nested assistant content itself is backend-owned state and is not
+  // re-sent.
+  const nestedToolCalls: {
+    id: string;
+    call: AgUiToolCall;
+    part: ToolCallPart;
+  }[] = [];
+  for (const { part } of toolCalls) {
+    collectNestedToolCalls(part, nestedToolCalls);
+  }
+
   converted.push({
     id: message.id,
     role: "assistant",
     content,
     ...(message.name ? { name: message.name } : {}),
-    ...(toolCalls.length > 0
-      ? { toolCalls: toolCalls.map((entry) => entry.call) }
+    ...(toolCalls.length + nestedToolCalls.length > 0
+      ? {
+          toolCalls: [...toolCalls, ...nestedToolCalls].map(
+            (entry) => entry.call,
+          ),
+        }
       : {}),
   });
 
   for (const { id: toolCallId, part } of toolCalls) {
-    if (part.result === undefined) continue;
-
-    const resultContent =
-      part.modelContent !== undefined
-        ? extractText(part.modelContent)
-        : typeof part.result === "string"
-          ? part.result
-          : JSON.stringify(part.result);
+    emitToolResult(toolCallId, part, converted);
+  }
+  for (const { id: toolCallId, part } of nestedToolCalls) {
+    // A result recorded while the call's approval gate is still open must not
+    // reach the backend as if the gate had been decided.
+    const gateOpen =
+      part.approval != null &&
+      part.approval.approved === undefined &&
+      part.approval.resolution === undefined;
+    if (gateOpen) continue;
+    emitToolResult(toolCallId, part, converted);
+  }
+}
 
-    converted.push({
-      id: part.unstable_toolMessageId ?? `${toolCallId}:tool`,
-      role: "tool",
-      content: resultContent,
-      toolCallId,
-      ...(part.isError ? { error: resultContent } : {}),
-    });
+function collectNestedToolCalls(
+  part: ToolCallPart,
+  out: { id: string; call: AgUiToolCall; part: ToolCallPart }[],
+): void {
+  for (const nested of part.messages ?? []) {
+    if (!isObject(nested) || nested.role !== "assistant") continue;
+    const nestedContent = Array.isArray(nested.content) ? nested.content : [];
+    for (const nestedPart of nestedContent) {
+      if (!isObject(nestedPart) || nestedPart.type !== "tool-call") continue;
+      const nestedToolCall = nestedPart as ToolCallPart;
+      if (
+        typeof nestedToolCall.toolCallId !== "string" ||
+        nestedToolCall.toolCallId.startsWith("a2ui:")
+      ) {
+        continue;
+      }
+      out.push({ ...normalizeToolCall(nestedToolCall), part: nestedToolCall });
+      collectNestedToolCalls(nestedToolCall, out);
+    }
   }
 }
 
+function emitToolResult(
+  toolCallId: string,
+  part: ToolCallPart,
+  converted: AgUiMessage[],
+): void {
+  if (part.result === undefined) return;
+
+  const resultContent =
+    part.modelContent !== undefined
+      ? extractText(part.modelContent)
+      : typeof part.result === "string"
+        ? part.result
+        : JSON.stringify(part.result);
+
+  converted.push({
+    id: part.unstable_toolMessageId ?? `${toolCallId}:tool`,
+    role: "tool",
+    content: resultContent,
+    toolCallId,
+    ...(part.isError ? { error: resultContent } : {}),
+  });
+}
+
 function convertToolMessage(
   message: NormalizedThreadMessageLike,
   converted: AgUiMessage[],

package/src/runtime/adapter/run-aggregator.approval.test.ts

@@ -100,4 +100,132 @@ describe("RunAggregator tool approval projection", () => {
         ?.interrupts,
     ).toEqual([GATE]);
   });
+
+  /**
+   * `boundToolCallIds` names every call the run produced, root or nested, so a
+   * gate on a call inside a subagent message is bound and projects onto the
+   * nested part rather than collapsing the batch. The approval seams walk
+   * `ToolCallMessagePart.messages`, which is what makes a subagent-scoped gate
+   * answerable the same way a root one is.
+   */
+  it("projects a batch that names a subagent-scoped tool call onto both the root and nested parts", () => {
+    const emitted: ChatModelRunResult[] = [];
+    const aggregator = new RunAggregator({
+      showThinking: false,
+      logger: noopLogger,
+      emit: (result) => {
+        emitted.push(result);
+      },
+    });
+
+    const ROOT_GATE: AgUiInterrupt = {
+      id: "int-root",
+      reason: "tool_call",
+      toolCallId: "tc-root",
+      message: "Delete /tmp/root?",
+    };
+    const SUBAGENT_GATE: AgUiInterrupt = {
+      id: "int-sub",
+      reason: "tool_call",
+      toolCallId: "tc-sub",
+      message: "Delete /tmp/sub?",
+    };
+
+    aggregator.handle({ type: "RUN_STARTED", runId: "run-1" });
+    aggregator.handle({
+      type: "TOOL_CALL_START",
+      toolCallId: "tc-root",
+      toolCallName: "delete_file",
+    });
+    aggregator.handle({
+      type: "TOOL_CALL_ARGS",
+      toolCallId: "tc-root",
+      delta: '{"path":"/tmp/root"}',
+    });
+    aggregator.handle({ type: "TOOL_CALL_END", toolCallId: "tc-root" });
+    aggregator.handle({
+      type: "SUBAGENT_STARTED",
+      subagentRunId: "sub-1",
+      name: "cleanup",
+      parentToolCallId: "tc-root",
+    } as any);
+    aggregator.handle({
+      type: "TOOL_CALL_START",
+      toolCallId: "tc-sub",
+      toolCallName: "delete_file",
+      subagentRunId: "sub-1",
+    } as any);
+    aggregator.handle({
+      type: "TOOL_CALL_ARGS",
+      toolCallId: "tc-sub",
+      delta: '{"path":"/tmp/sub"}',
+      subagentRunId: "sub-1",
+    } as any);
+    aggregator.handle({
+      type: "TOOL_CALL_END",
+      toolCallId: "tc-sub",
+      subagentRunId: "sub-1",
+    } as any);
+    aggregator.handle({
+      type: "RUN_FINISHED",
+      runId: "run-1",
+      outcome: {
+        type: "interrupt",
+        interrupts: [ROOT_GATE, SUBAGENT_GATE],
+      },
+    } as any);
+
+    const result = emitted[emitted.length - 1]!;
+    expect(result.status).toMatchObject({
+      type: "requires-action",
+      reason: "interrupt",
+    });
+    const content = result.content ?? [];
+    const rootPart = content.find(
+      (p: any) => p.type === "tool-call" && p.toolCallId === "tc-root",
+    ) as any;
+    expect(rootPart?.approval).toEqual({
+      id: "int-root",
+      prompt: "Delete /tmp/root?",
+    });
+    const nestedPart = rootPart?.messages?.[0]?.content.find(
+      (p: any) => p.type === "tool-call" && p.toolCallId === "tc-sub",
+    );
+    expect(nestedPart?.approval).toEqual({
+      id: "int-sub",
+      prompt: "Delete /tmp/sub?",
+    });
+    // The interrupts survive on the message metadata so the app's bespoke
+    // interrupt hooks (useAgUiSubmitInterruptResponses / steerAway) can still
+    // resolve the batch.
+    expect(
+      (result.metadata?.custom as Record<string, any> | undefined)?.agui
+        ?.interrupts,
+    ).toEqual([ROOT_GATE, SUBAGENT_GATE]);
+  });
+
+  it("still projects a root gate whose batch is entirely root-scoped, even while an unrelated subagent tool call is in flight", () => {
+    const { aggregator, last } = gatedAggregator();
+
+    aggregator.handle({
+      type: "SUBAGENT_STARTED",
+      subagentRunId: "sub-1",
+      name: "cleanup",
+    } as any);
+    aggregator.handle({
+      type: "TOOL_CALL_START",
+      toolCallId: "tc-unrelated",
+      toolCallName: "noop",
+      subagentRunId: "sub-1",
+    } as any);
+
+    expect(last().status).toMatchObject({
+      type: "requires-action",
+      reason: "interrupt",
+    });
+    expect(approvalOf(last())).toEqual({
+      id: "int-1",
+      prompt: "Delete /tmp/a?",
+    });
+  });
 });