@agent-native/core 0.202.0 → 0.202.1-nightly-20261007011022

package/dist/client/chat/agentkit-protocol.js

@@ -1,12 +1,10 @@
-import { AGENTKIT_PROTOCOL_VERSION, AgentProtocolValidationError, approvalResponseFromResume, createCapabilityUnavailableError, createCapabilityUnsupportedError, inferAgentActivityKind, negotiateAgentKitProtocolVersion, resumeEntryFromApproval, resumeOptionId, } from "@agent-native/agentkit/protocol";
+import { AGENT_TOOL_CALL_HISTORY_MEDIA_TYPE, AGENT_TOOL_RESULT_HISTORY_MEDIA_TYPE, AGENTKIT_PROTOCOL_VERSION, AgentProtocolValidationError, approvalResponseFromResume, createCapabilityUnavailableError, createCapabilityUnsupportedError, inferAgentActivityKind, negotiateAgentKitProtocolVersion, resumeEntryFromApproval, resumeOptionId, } from "@agent-native/agentkit/protocol";
 import { AUTO_CONTINUE_OF_RUN_METADATA_KEY, AUTO_CONTINUE_PROMPT, AUTO_CONTINUE_REFUSAL_CODES, } from "../../agent/auto-continue.js";
 import { emitChatFirstOpenApp, emitChatFirstOpenBrowser, } from "../chat-first-state.js";
 import { decideAfterStreamClosed, runOutcomeForCode, } from "./run-outcome.js";
 function isTerminalRunStatus(status) {
     return (status === "completed" || status === "failed" || status === "cancelled");
 }
-const TOOL_RESULT_MEDIA_TYPE = "application/x-agent-native-tool-result";
-const TOOL_CALL_MEDIA_TYPE = "application/x-agent-native-tool-call";
 const RUNTIME_PART_MEDIA_TYPE = "application/x-agent-native-runtime-part";
 const RUNTIME_EVENT_TYPE = "x-core.runtime-event";
 const RUNTIME_USAGE_EVENT_TYPE = "x-core.usage";
@@ -209,6 +207,16 @@ function runtimeEventMessageId(run, ...metadata) {
     }
     return run.activeMessageCompleted ? undefined : run.activeMessageId;
 }
+function runtimeToolMessageId(run, ...metadata) {
+    for (const value of metadata) {
+        const messageId = metadataString(value, "messageId");
+        if (messageId)
+            return messageId;
+    }
+    return run.activeMessageRole === "assistant"
+        ? runtimeEventMessageId(run)
+        : undefined;
+}
 function runtimeAnnotationToProtocol(annotation) {
     return {
         id: annotation.id,
@@ -423,7 +431,7 @@ function runtimePartToProtocolPart(part, fallbackTextFormat) {
         case "tool-call":
             return {
                 type: "data",
-                mediaType: TOOL_CALL_MEDIA_TYPE,
+                mediaType: AGENT_TOOL_CALL_HISTORY_MEDIA_TYPE,
                 data: {
                     id: part.toolCallId,
                     name: part.toolName,
@@ -434,7 +442,7 @@ function runtimePartToProtocolPart(part, fallbackTextFormat) {
         case "tool-result":
             return {
                 type: "data",
-                mediaType: TOOL_RESULT_MEDIA_TYPE,
+                mediaType: AGENT_TOOL_RESULT_HISTORY_MEDIA_TYPE,
                 data: {
                     id: part.toolCallId,
                     name: part.toolName,
@@ -485,6 +493,43 @@ function protocolPartToRuntimePart(part) {
                 mediaType: part.mediaType,
                 url: part.url,
             };
+        case "data": {
+            const data = asRecord(part.data);
+            if (part.mediaType === AGENT_TOOL_CALL_HISTORY_MEDIA_TYPE) {
+                if (typeof data?.id !== "string" || typeof data.name !== "string") {
+                    throw new AgentProtocolValidationError("message.parts.data", "tool call history requires a call id and name");
+                }
+                return {
+                    type: "tool-call",
+                    toolCallId: data.id,
+                    toolName: data.name,
+                    ...(data.input === undefined ? {} : { input: data.input }),
+                    ...(typeof data.inputText === "string"
+                        ? { inputText: data.inputText }
+                        : {}),
+                };
+            }
+            if (part.mediaType === AGENT_TOOL_RESULT_HISTORY_MEDIA_TYPE) {
+                if (typeof data?.id !== "string") {
+                    throw new AgentProtocolValidationError("message.parts.data", "tool result history requires a call id");
+                }
+                return {
+                    type: "tool-result",
+                    toolCallId: data.id,
+                    ...(typeof data.name === "string" ? { toolName: data.name } : {}),
+                    ...(data.result === undefined ? {} : { result: data.result }),
+                    ...(typeof data.resultText === "string"
+                        ? { resultText: data.resultText }
+                        : {}),
+                    ...(data.isError === true ? { isError: true } : {}),
+                };
+            }
+            return {
+                type: "data",
+                data: part,
+                mediaType: "application/x-agentkit-protocol-part",
+            };
+        }
         default:
             return {
                 type: "data",
@@ -604,7 +649,7 @@ function actionResultFromTool(input) {
         ...(input.metadata ? { metadata: input.metadata } : {}),
     };
 }
-function runtimeToolToProtocolTool(tool, status = "running", result, error) {
+function runtimeToolToProtocolTool(tool, status = "running", result, error, messageId) {
     return {
         id: tool.id,
         name: tool.name,
@@ -612,6 +657,7 @@ function runtimeToolToProtocolTool(tool, status = "running", result, error) {
         status,
         output: result,
         error,
+        ...(messageId ? { messageId } : {}),
         ...(tool.metadata ? { metadata: tool.metadata } : {}),
     };
 }
@@ -989,6 +1035,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             pendingWidgets: new Map(),
             actions: new Map(),
             activeTools: new Map(),
+            pendingToolMessageAssociations: new Map(),
             activeActivities: new Map(),
             terminalAppendDepth: 0,
             pumpPromise: null,
@@ -1283,6 +1330,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 });
             }
         }
+        run.pendingToolMessageAssociations.clear();
     }
     function runtimeEventToProtocolEvents(run, event) {
         dispatchChatFirstOpenFromRuntimeEvent(event);
@@ -1300,9 +1348,32 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 widget,
             }));
         };
+        const attachPendingToolMessageAssociations = (messageId) => {
+            const tools = [...run.pendingToolMessageAssociations.values()];
+            run.pendingToolMessageAssociations.clear();
+            return tools.map((toolCall) => ({
+                type: "tool.updated",
+                ...base,
+                toolCall: { ...toolCall, messageId },
+            }));
+        };
+        const retainPendingToolMessageAssociation = (toolCall) => {
+            run.pendingToolMessageAssociations.delete(toolCall.id);
+            run.pendingToolMessageAssociations.set(toolCall.id, toolCall);
+            // Pending links use the same bound as the replay log they can be attached to.
+            while (run.pendingToolMessageAssociations.size > maxRetainedEvents) {
+                const oldestToolCallId = run.pendingToolMessageAssociations
+                    .keys()
+                    .next().value;
+                if (oldestToolCallId === undefined)
+                    break;
+                run.pendingToolMessageAssociations.delete(oldestToolCallId);
+            }
+        };
         switch (event.type) {
             case "message-start":
                 run.activeMessageId = event.message.id;
+                run.activeMessageRole = event.message.role;
                 run.activeMessageCompleted = false;
                 return [
                     {
@@ -1311,8 +1382,14 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                         message: runtimeMessageToProtocolMessage(event.message, textFormat),
                     },
                     ...attachPendingWidgets(event.message.id),
+                    ...(event.message.role === "assistant"
+                        ? attachPendingToolMessageAssociations(event.message.id)
+                        : []),
                 ];
             case "message-delta":
+                if (run.activeMessageId !== event.messageId) {
+                    run.activeMessageRole = undefined;
+                }
                 run.activeMessageId = event.messageId;
                 run.activeMessageCompleted = false;
                 if (event.delta.type === "text") {
@@ -1353,6 +1430,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 ];
             case "message-done":
                 run.activeMessageId = event.message.id;
+                run.activeMessageRole = event.message.role;
                 run.activeMessageCompleted = true;
                 return [
                     {
@@ -1361,18 +1439,29 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                         message: runtimeMessageToProtocolMessage(event.message, textFormat),
                     },
                     ...attachPendingWidgets(event.message.id),
+                    ...(event.message.role === "assistant"
+                        ? attachPendingToolMessageAssociations(event.message.id)
+                        : []),
                 ];
             case "tool-start": {
                 const metadata = mergeProtocolMetadata(base.metadata, event.toolCall.metadata);
                 const invocation = actionInvocationFromTool(run, event.toolCall, metadata);
                 if (invocation)
                     run.actions.set(event.toolCall.id, invocation);
+                const messageId = runtimeToolMessageId(run, event.toolCall.metadata);
+                const toolCall = runtimeToolToProtocolTool(event.toolCall, "running", undefined, undefined, messageId);
+                if (messageId) {
+                    run.pendingToolMessageAssociations.delete(toolCall.id);
+                }
+                else {
+                    retainPendingToolMessageAssociation(toolCall);
+                }
                 return [
                     {
                         type: "tool.started",
                         ...base,
                         metadata,
-                        toolCall: runtimeToolToProtocolTool(event.toolCall),
+                        toolCall,
                     },
                     ...(invocation
                         ? [
@@ -1436,20 +1525,34 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 if (invocation)
                     run.actions.delete(event.toolCallId);
                 const activeTool = run.activeTools.get(event.toolCallId);
+                const explicitMessageId = metadataString(event.metadata, "messageId");
+                const messageId = activeTool?.messageId ??
+                    explicitMessageId ??
+                    (run.pendingToolMessageAssociations.has(event.toolCallId)
+                        ? undefined
+                        : runtimeToolMessageId(run, event.metadata));
+                const toolCall = {
+                    ...activeTool,
+                    id: event.toolCallId,
+                    name: event.toolName,
+                    status,
+                    output: event.result !== undefined ? event.result : event.resultText,
+                    error,
+                    ...(messageId ? { messageId } : {}),
+                    ...(metadata ? { metadata } : {}),
+                };
+                if (messageId) {
+                    run.pendingToolMessageAssociations.delete(event.toolCallId);
+                }
+                else if (run.pendingToolMessageAssociations.has(event.toolCallId)) {
+                    retainPendingToolMessageAssociation(toolCall);
+                }
                 return [
                     {
                         type: "tool.updated",
                         ...base,
                         metadata,
-                        toolCall: {
-                            ...activeTool,
-                            id: event.toolCallId,
-                            name: event.toolName,
-                            status,
-                            output: event.result !== undefined ? event.result : event.resultText,
-                            error,
-                            ...(metadata ? { metadata } : {}),
-                        },
+                        toolCall,
                     },
                     ...(actionResult
                         ? [
@@ -2456,6 +2559,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 pendingWidgets: new Map(),
                 actions: new Map(),
                 activeTools: new Map(),
+                pendingToolMessageAssociations: new Map(),
                 activeActivities: new Map(),
                 terminalAppendDepth: 0,
                 pumpPromise: null,
@@ -2772,10 +2876,12 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     activeReaders: 0,
                     metadata: replacementMetadata,
                     activeMessageId: run.activeMessageId,
+                    activeMessageRole: run.activeMessageRole,
                     activeMessageCompleted: run.activeMessageCompleted,
                     pendingWidgets: new Map(run.pendingWidgets),
                     actions: new Map(run.actions),
                     activeTools: new Map(run.activeTools),
+                    pendingToolMessageAssociations: new Map(run.pendingToolMessageAssociations),
                     activeActivities: new Map(run.activeActivities),
                     terminalAppendDepth: 0,
                     pumpPromise: null,