@assistant-ui/react-ag-ui 0.0.56 → 0.0.58

package/src/runtime/adapter/conversions.ts

@@ -1,16 +1,18 @@
 "use client";
 
 import type { InputContent, RunAgentParameters } from "@ag-ui/client";
+import { generateId } from "@assistant-ui/core";
 import type {
   ThreadMessageLike as CoreThreadMessageLike,
   PartProviderMetadata,
+  ThreadMessage,
   ToolCallMessagePartMcpMetadata,
   ToolModelContentPart,
 } from "@assistant-ui/core";
 import {
   getAutoStatus,
-  httpUrlPattern,
   parseDataUrl,
+  resolveFilePartSource,
 } from "@assistant-ui/core/internal";
 import { type Tool, toToolsJSONSchema } from "assistant-stream";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
@@ -105,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;
 
@@ -177,13 +188,6 @@ function parseJSONText(value: string): unknown {
   }
 }
 
-function generateId(): string {
-  return (
-    (globalThis.crypto as { randomUUID?: () => string })?.randomUUID?.() ??
-    Math.random().toString(36).slice(2)
-  );
-}
-
 function normalizeToolCall(part: ToolCallPart): {
   id: string;
   call: AgUiToolCall;
@@ -242,17 +246,20 @@ function buildInputSource(
   declaredMimeType: string | undefined,
   sourceType?: string,
 ): InputContentSource {
-  if (sourceType === "url" || httpUrlPattern.test(value)) {
+  const source = resolveFilePartSource({
+    data: value,
+    mimeType: declaredMimeType ?? "application/octet-stream",
+    sourceType,
+  });
+  if (source.kind === "url") {
     return declaredMimeType !== undefined
-      ? { type: "url", value, mimeType: declaredMimeType }
-      : { type: "url", value };
+      ? { type: "url", value: source.url, mimeType: declaredMimeType }
+      : { type: "url", value: source.url };
   }
-  const parsed = parseDataUrl(value);
   return {
     type: "data",
-    value: parsed?.data ?? value,
-    mimeType:
-      parsed?.mimeType ?? declaredMimeType ?? "application/octet-stream",
+    value: source.data,
+    mimeType: source.mimeType,
   };
 }
 
@@ -662,7 +669,7 @@ function toAssistantSnapshotMessage(
 }
 
 function toUserOrSystemSnapshotMessage(
-  role: "user" | "system",
+  role: "user" | "system" | "developer",
   rawMessage: Record<string, unknown>,
 ): CoreThreadMessageLike {
   const messageName = getString(rawMessage, "name");
@@ -670,10 +677,23 @@ function toUserOrSystemSnapshotMessage(
     role === "user" ? toSnapshotAttachments(rawMessage.content) : [];
   return {
     id: getString(rawMessage, "id") ?? generateId(),
-    role,
+    // The internal message model has no developer role; it rides as a system
+    // message with its wire role kept in metadata so the export restores it.
+    role: role === "developer" ? "system" : role,
     content: extractText(rawMessage.content),
     ...(messageName !== undefined ? { name: messageName } : {}),
     ...(attachments.length > 0 ? { attachments } : {}),
+    ...(role === "developer"
+      ? {
+          metadata: {
+            custom: {
+              [AG_UI_METADATA_NAMESPACE]: {
+                role: "developer",
+              } satisfies AgUiCustomMetadata,
+            },
+          },
+        }
+      : {}),
   };
 }
 
@@ -939,7 +959,7 @@ export function fromAgUiMessages(
       continue;
     }
 
-    if (role === "user" || role === "system") {
+    if (role === "user" || role === "system" || role === "developer") {
       converted.push(toUserOrSystemSnapshotMessage(role, rawMessage));
     }
   }
@@ -1041,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[],
@@ -1137,9 +1217,21 @@ export function toAgUiMessages(
     }
 
     if (message.role === "system" || message.role === "developer") {
+      const custom = isObject(message.metadata)
+        ? message.metadata.custom
+        : undefined;
+      const namespaced = isObject(custom)
+        ? custom[AG_UI_METADATA_NAMESPACE]
+        : undefined;
+      const wireRole =
+        message.role === "system" &&
+        isObject(namespaced) &&
+        namespaced.role === "developer"
+          ? ("developer" as const)
+          : message.role;
       converted.push({
         id: message.id,
-        role: message.role,
+        role: wireRole,
         content: extractText(message.content),
         ...(message.name ? { name: message.name } : {}),
       });

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?",
+    });
+  });
 });