assistant-stream 0.2.39 → 0.2.41

package/dist/core/tool/toolResultStream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolResultStream.d.ts","sourceRoot":"","sources":["../../../src/core/tool/toolResultStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAuC,MAAM,cAAc,CAAC;AAGzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA2ElD,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,SAAS,EACvC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,6BAyClE;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EACD,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GACpB,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC,GACxC,SAAS,EACb,WAAW,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,CAAC,EAC9C,KAAK,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,uBAWlE"}
+{"version":3,"file":"toolResultStream.d.ts","sourceRoot":"","sources":["../../../src/core/tool/toolResultStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAuC,MAAM,cAAc,CAAC;AAGzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA2ElD,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,SAAS,EACvC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,6BAiElE;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EACD,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GACpB,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC,GACxC,SAAS,EACb,WAAW,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,CAAC,EAC9C,KAAK,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,uBAWlE"}

package/dist/core/tool/toolResultStream.js

@@ -37,41 +37,59 @@ function getToolStreamResponse(tools, abortSignal, reader, context, human) {
   });
 }
 async function unstable_runPendingTools(message, tools, abortSignal, human) {
-  for (const part of message.parts) {
-    if (part.type === "tool-call") {
-      const promiseOrUndefined = getToolResponse(
-        tools,
-        abortSignal,
-        part,
-        human ?? (async () => {
-          throw new Error(
-            "Tool human input is not supported in this context"
-          );
-        })
-      );
-      if (promiseOrUndefined) {
-        const result = await promiseOrUndefined;
-        const updatedParts = message.parts.map((p) => {
-          if (p.type === "tool-call" && p.toolCallId === part.toolCallId) {
-            return {
-              ...p,
-              state: "result",
-              ...result.artifact !== void 0 ? { artifact: result.artifact } : {},
-              result: result.result,
-              isError: result.isError
-            };
-          }
-          return p;
-        });
-        message = {
-          ...message,
-          parts: updatedParts,
-          content: updatedParts
+  const toolCallPromises = message.parts.filter((part) => part.type === "tool-call").map(async (part) => {
+    const promiseOrUndefined = getToolResponse(
+      tools,
+      abortSignal,
+      part,
+      human ?? (async () => {
+        throw new Error(
+          "Tool human input is not supported in this context"
+        );
+      })
+    );
+    if (promiseOrUndefined) {
+      const result = await promiseOrUndefined;
+      return {
+        toolCallId: part.toolCallId,
+        result
+      };
+    }
+    return null;
+  });
+  const toolCallResults = (await Promise.all(toolCallPromises)).filter(
+    (result) => result !== null
+  );
+  if (toolCallResults.length === 0) {
+    return message;
+  }
+  const toolCallResultsById = toolCallResults.reduce(
+    (acc, { toolCallId, result }) => {
+      acc[toolCallId] = result;
+      return acc;
+    },
+    {}
+  );
+  const updatedParts = message.parts.map((p) => {
+    if (p.type === "tool-call") {
+      const toolResponse = toolCallResultsById[p.toolCallId];
+      if (toolResponse) {
+        return {
+          ...p,
+          state: "result",
+          ...toolResponse.artifact !== void 0 ? { artifact: toolResponse.artifact } : {},
+          result: toolResponse.result,
+          isError: toolResponse.isError
         };
       }
     }
-  }
-  return message;
+    return p;
+  });
+  return {
+    ...message,
+    parts: updatedParts,
+    content: updatedParts
+  };
 }
 function toolResultStream(tools, abortSignal, human) {
   const toolsFn = typeof tools === "function" ? tools : () => tools;

package/dist/core/tool/toolResultStream.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/core/tool/toolResultStream.ts"],"sourcesContent":["import { Tool, ToolCallReader, ToolExecuteFunction } from \"./tool-types\";\nimport { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { ToolResponse } from \"./ToolResponse\";\nimport { ToolExecutionStream } from \"./ToolExecutionStream\";\nimport { AssistantMessage } from \"../utils/types\";\nimport { ReadonlyJSONObject, ReadonlyJSONValue } from \"../../utils\";\n\nconst isStandardSchemaV1 = (\n  schema: unknown,\n): schema is StandardSchemaV1<unknown> => {\n  return (\n    typeof schema === \"object\" &&\n    schema !== null &&\n    \"~standard\" in schema &&\n    (schema as StandardSchemaV1<unknown>)[\"~standard\"].version === 1\n  );\n};\n\nfunction getToolResponse(\n  tools: Record<string, Tool> | undefined,\n  abortSignal: AbortSignal,\n  toolCall: {\n    toolCallId: string;\n    toolName: string;\n    args: ReadonlyJSONObject;\n  },\n  human: (toolCallId: string, payload: unknown) => Promise<unknown>,\n) {\n  const tool = tools?.[toolCall.toolName];\n  if (!tool || !tool.execute) return undefined;\n\n  const getResult = async (\n    toolExecute: ToolExecuteFunction<ReadonlyJSONObject, unknown>,\n  ): Promise<ToolResponse<ReadonlyJSONValue>> => {\n    let executeFn = toolExecute;\n\n    if (isStandardSchemaV1(tool.parameters)) {\n      let result = tool.parameters[\"~standard\"].validate(toolCall.args);\n      if (result instanceof Promise) result = await result;\n\n      if (result.issues) {\n        executeFn =\n          tool.experimental_onSchemaValidationError ??\n          (() => {\n            throw new Error(\n              `Function parameter validation failed. ${JSON.stringify(result.issues)}`,\n            );\n          });\n      }\n    }\n\n    const result = (await executeFn(toolCall.args, {\n      toolCallId: toolCall.toolCallId,\n      abortSignal,\n      human: (payload: unknown) => human(toolCall.toolCallId, payload),\n    })) as unknown as ReadonlyJSONValue;\n    return ToolResponse.toResponse(result);\n  };\n\n  return getResult(tool.execute);\n}\n\nfunction getToolStreamResponse(\n  tools: Record<string, Tool> | undefined,\n  abortSignal: AbortSignal,\n  reader: ToolCallReader<any, ReadonlyJSONValue>,\n  context: {\n    toolCallId: string;\n    toolName: string;\n  },\n  human: (toolCallId: string, payload: unknown) => Promise<unknown>,\n) {\n  tools?.[context.toolName]?.streamCall?.(reader, {\n    toolCallId: context.toolCallId,\n    abortSignal,\n    human: (payload: unknown) => human(context.toolCallId, payload),\n  });\n}\n\nexport async function unstable_runPendingTools(\n  message: AssistantMessage,\n  tools: Record<string, Tool> | undefined,\n  abortSignal: AbortSignal,\n  human: (toolCallId: string, payload: unknown) => Promise<unknown>,\n) {\n  // TODO parallel tool calling\n  for (const part of message.parts) {\n    if (part.type === \"tool-call\") {\n      const promiseOrUndefined = getToolResponse(\n        tools,\n        abortSignal,\n        part,\n        human ??\n          (async () => {\n            throw new Error(\n              \"Tool human input is not supported in this context\",\n            );\n          }),\n      );\n      if (promiseOrUndefined) {\n        const result = await promiseOrUndefined;\n        const updatedParts = message.parts.map((p) => {\n          if (p.type === \"tool-call\" && p.toolCallId === part.toolCallId) {\n            return {\n              ...p,\n              state: \"result\" as const,\n              ...(result.artifact !== undefined\n                ? { artifact: result.artifact }\n                : {}),\n              result: result.result as ReadonlyJSONValue,\n              isError: result.isError,\n            };\n          }\n          return p;\n        });\n        message = {\n          ...message,\n          parts: updatedParts,\n          content: updatedParts,\n        };\n      }\n    }\n  }\n  return message;\n}\n\nexport function toolResultStream(\n  tools:\n    | Record<string, Tool>\n    | (() => Record<string, Tool> | undefined)\n    | undefined,\n  abortSignal: AbortSignal | (() => AbortSignal),\n  human: (toolCallId: string, payload: unknown) => Promise<unknown>,\n) {\n  const toolsFn = typeof tools === \"function\" ? tools : () => tools;\n  const abortSignalFn =\n    typeof abortSignal === \"function\" ? abortSignal : () => abortSignal;\n  return new ToolExecutionStream({\n    execute: (toolCall) =>\n      getToolResponse(toolsFn(), abortSignalFn(), toolCall, human),\n    streamCall: ({ reader, ...context }) =>\n      getToolStreamResponse(toolsFn(), abortSignalFn(), reader, context, human),\n  });\n}\n"],"mappings":";AAEA,SAAS,oBAAoB;AAC7B,SAAS,2BAA2B;AAIpC,IAAM,qBAAqB,CACzB,WACwC;AACxC,SACE,OAAO,WAAW,YAClB,WAAW,QACX,eAAe,UACd,OAAqC,WAAW,EAAE,YAAY;AAEnE;AAEA,SAAS,gBACP,OACA,aACA,UAKA,OACA;AACA,QAAM,OAAO,QAAQ,SAAS,QAAQ;AACtC,MAAI,CAAC,QAAQ,CAAC,KAAK,QAAS,QAAO;AAEnC,QAAM,YAAY,OAChB,gBAC6C;AAC7C,QAAI,YAAY;AAEhB,QAAI,mBAAmB,KAAK,UAAU,GAAG;AACvC,UAAIA,UAAS,KAAK,WAAW,WAAW,EAAE,SAAS,SAAS,IAAI;AAChE,UAAIA,mBAAkB,QAAS,CAAAA,UAAS,MAAMA;AAE9C,UAAIA,QAAO,QAAQ;AACjB,oBACE,KAAK,yCACJ,MAAM;AACL,gBAAM,IAAI;AAAA,YACR,yCAAyC,KAAK,UAAUA,QAAO,MAAM,CAAC;AAAA,UACxE;AAAA,QACF;AAAA,MACJ;AAAA,IACF;AAEA,UAAM,SAAU,MAAM,UAAU,SAAS,MAAM;AAAA,MAC7C,YAAY,SAAS;AAAA,MACrB;AAAA,MACA,OAAO,CAAC,YAAqB,MAAM,SAAS,YAAY,OAAO;AAAA,IACjE,CAAC;AACD,WAAO,aAAa,WAAW,MAAM;AAAA,EACvC;AAEA,SAAO,UAAU,KAAK,OAAO;AAC/B;AAEA,SAAS,sBACP,OACA,aACA,QACA,SAIA,OACA;AACA,UAAQ,QAAQ,QAAQ,GAAG,aAAa,QAAQ;AAAA,IAC9C,YAAY,QAAQ;AAAA,IACpB;AAAA,IACA,OAAO,CAAC,YAAqB,MAAM,QAAQ,YAAY,OAAO;AAAA,EAChE,CAAC;AACH;AAEA,eAAsB,yBACpB,SACA,OACA,aACA,OACA;AAEA,aAAW,QAAQ,QAAQ,OAAO;AAChC,QAAI,KAAK,SAAS,aAAa;AAC7B,YAAM,qBAAqB;AAAA,QACzB;AAAA,QACA;AAAA,QACA;AAAA,QACA,UACG,YAAY;AACX,gBAAM,IAAI;AAAA,YACR;AAAA,UACF;AAAA,QACF;AAAA,MACJ;AACA,UAAI,oBAAoB;AACtB,cAAM,SAAS,MAAM;AACrB,cAAM,eAAe,QAAQ,MAAM,IAAI,CAAC,MAAM;AAC5C,cAAI,EAAE,SAAS,eAAe,EAAE,eAAe,KAAK,YAAY;AAC9D,mBAAO;AAAA,cACL,GAAG;AAAA,cACH,OAAO;AAAA,cACP,GAAI,OAAO,aAAa,SACpB,EAAE,UAAU,OAAO,SAAS,IAC5B,CAAC;AAAA,cACL,QAAQ,OAAO;AAAA,cACf,SAAS,OAAO;AAAA,YAClB;AAAA,UACF;AACA,iBAAO;AAAA,QACT,CAAC;AACD,kBAAU;AAAA,UACR,GAAG;AAAA,UACH,OAAO;AAAA,UACP,SAAS;AAAA,QACX;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,iBACd,OAIA,aACA,OACA;AACA,QAAM,UAAU,OAAO,UAAU,aAAa,QAAQ,MAAM;AAC5D,QAAM,gBACJ,OAAO,gBAAgB,aAAa,cAAc,MAAM;AAC1D,SAAO,IAAI,oBAAoB;AAAA,IAC7B,SAAS,CAAC,aACR,gBAAgB,QAAQ,GAAG,cAAc,GAAG,UAAU,KAAK;AAAA,IAC7D,YAAY,CAAC,EAAE,QAAQ,GAAG,QAAQ,MAChC,sBAAsB,QAAQ,GAAG,cAAc,GAAG,QAAQ,SAAS,KAAK;AAAA,EAC5E,CAAC;AACH;","names":["result"]}
+{"version":3,"sources":["../../../src/core/tool/toolResultStream.ts"],"sourcesContent":["import { Tool, ToolCallReader, ToolExecuteFunction } from \"./tool-types\";\nimport { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { ToolResponse } from \"./ToolResponse\";\nimport { ToolExecutionStream } from \"./ToolExecutionStream\";\nimport { AssistantMessage } from \"../utils/types\";\nimport { ReadonlyJSONObject, ReadonlyJSONValue } from \"../../utils\";\n\nconst isStandardSchemaV1 = (\n  schema: unknown,\n): schema is StandardSchemaV1<unknown> => {\n  return (\n    typeof schema === \"object\" &&\n    schema !== null &&\n    \"~standard\" in schema &&\n    (schema as StandardSchemaV1<unknown>)[\"~standard\"].version === 1\n  );\n};\n\nfunction getToolResponse(\n  tools: Record<string, Tool> | undefined,\n  abortSignal: AbortSignal,\n  toolCall: {\n    toolCallId: string;\n    toolName: string;\n    args: ReadonlyJSONObject;\n  },\n  human: (toolCallId: string, payload: unknown) => Promise<unknown>,\n) {\n  const tool = tools?.[toolCall.toolName];\n  if (!tool || !tool.execute) return undefined;\n\n  const getResult = async (\n    toolExecute: ToolExecuteFunction<ReadonlyJSONObject, unknown>,\n  ): Promise<ToolResponse<ReadonlyJSONValue>> => {\n    let executeFn = toolExecute;\n\n    if (isStandardSchemaV1(tool.parameters)) {\n      let result = tool.parameters[\"~standard\"].validate(toolCall.args);\n      if (result instanceof Promise) result = await result;\n\n      if (result.issues) {\n        executeFn =\n          tool.experimental_onSchemaValidationError ??\n          (() => {\n            throw new Error(\n              `Function parameter validation failed. ${JSON.stringify(result.issues)}`,\n            );\n          });\n      }\n    }\n\n    const result = (await executeFn(toolCall.args, {\n      toolCallId: toolCall.toolCallId,\n      abortSignal,\n      human: (payload: unknown) => human(toolCall.toolCallId, payload),\n    })) as unknown as ReadonlyJSONValue;\n    return ToolResponse.toResponse(result);\n  };\n\n  return getResult(tool.execute);\n}\n\nfunction getToolStreamResponse(\n  tools: Record<string, Tool> | undefined,\n  abortSignal: AbortSignal,\n  reader: ToolCallReader<any, ReadonlyJSONValue>,\n  context: {\n    toolCallId: string;\n    toolName: string;\n  },\n  human: (toolCallId: string, payload: unknown) => Promise<unknown>,\n) {\n  tools?.[context.toolName]?.streamCall?.(reader, {\n    toolCallId: context.toolCallId,\n    abortSignal,\n    human: (payload: unknown) => human(context.toolCallId, payload),\n  });\n}\n\nexport async function unstable_runPendingTools(\n  message: AssistantMessage,\n  tools: Record<string, Tool> | undefined,\n  abortSignal: AbortSignal,\n  human: (toolCallId: string, payload: unknown) => Promise<unknown>,\n) {\n  const toolCallPromises = message.parts\n    .filter((part) => part.type === \"tool-call\")\n    .map(async (part) => {\n      const promiseOrUndefined = getToolResponse(\n        tools,\n        abortSignal,\n        part,\n        human ??\n          (async () => {\n            throw new Error(\n              \"Tool human input is not supported in this context\",\n            );\n          }),\n      );\n      if (promiseOrUndefined) {\n        const result = await promiseOrUndefined;\n        return {\n          toolCallId: part.toolCallId,\n          result,\n        };\n      }\n      return null;\n    });\n\n  const toolCallResults = (await Promise.all(toolCallPromises)).filter(\n    (result) => result !== null,\n  ) as { toolCallId: string; result: ToolResponse<ReadonlyJSONValue> }[];\n\n  if (toolCallResults.length === 0) {\n    return message;\n  }\n\n  const toolCallResultsById = toolCallResults.reduce(\n    (acc, { toolCallId, result }) => {\n      acc[toolCallId] = result;\n      return acc;\n    },\n    {} as Record<string, ToolResponse<ReadonlyJSONValue>>,\n  );\n\n  const updatedParts = message.parts.map((p) => {\n    if (p.type === \"tool-call\") {\n      const toolResponse = toolCallResultsById[p.toolCallId];\n      if (toolResponse) {\n        return {\n          ...p,\n          state: \"result\" as const,\n          ...(toolResponse.artifact !== undefined\n            ? { artifact: toolResponse.artifact }\n            : {}),\n          result: toolResponse.result as ReadonlyJSONValue,\n          isError: toolResponse.isError,\n        };\n      }\n    }\n    return p;\n  });\n\n  return {\n    ...message,\n    parts: updatedParts,\n    content: updatedParts,\n  };\n}\n\nexport function toolResultStream(\n  tools:\n    | Record<string, Tool>\n    | (() => Record<string, Tool> | undefined)\n    | undefined,\n  abortSignal: AbortSignal | (() => AbortSignal),\n  human: (toolCallId: string, payload: unknown) => Promise<unknown>,\n) {\n  const toolsFn = typeof tools === \"function\" ? tools : () => tools;\n  const abortSignalFn =\n    typeof abortSignal === \"function\" ? abortSignal : () => abortSignal;\n  return new ToolExecutionStream({\n    execute: (toolCall) =>\n      getToolResponse(toolsFn(), abortSignalFn(), toolCall, human),\n    streamCall: ({ reader, ...context }) =>\n      getToolStreamResponse(toolsFn(), abortSignalFn(), reader, context, human),\n  });\n}\n"],"mappings":"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","names":["result"]}

package/dist/core/tool/toolResultStream.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=toolResultStream.test.d.ts.map

package/dist/core/tool/toolResultStream.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolResultStream.test.d.ts","sourceRoot":"","sources":["../../../src/core/tool/toolResultStream.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistant-stream",
-  "version": "0.2.39",
+  "version": "0.2.41",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -25,9 +25,9 @@
   "sideEffects": false,
   "devDependencies": {
     "@standard-schema/spec": "^1.0.0",
-    "@types/node": "^24.10.0",
+    "@types/node": "^24.10.1",
     "tsx": "^4.20.6",
-    "vitest": "^4.0.6",
+    "vitest": "^4.0.10",
     "@assistant-ui/x-buildutils": "0.0.1"
   },
   "publishConfig": {

package/src/core/tool/toolResultStream.test.ts

@@ -0,0 +1,400 @@
+import { describe, expect, it } from "vitest";
+import { unstable_runPendingTools } from "./toolResultStream";
+import { AssistantMessage, ToolCallPart } from "../utils/types";
+import { Tool } from "./tool-types";
+
+const createDelayedTool = (delay: number, result?: string): Tool => ({
+  parameters: { type: "object", properties: {} },
+  execute: async () => {
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return result ?? `Tool with ${delay}ms delay executed`;
+  },
+});
+
+describe("unstable_runPendingTools", () => {
+  describe("parallel execution", () => {
+    it("should run tool calls in parallel", async () => {
+      const tool1 = createDelayedTool(100, "Tool 1");
+      const tool2 = createDelayedTool(100, "Tool 2");
+      const tool3 = createDelayedTool(100, "Tool 3");
+
+      const tools: Record<string, Tool> = {
+        tool1,
+        tool2,
+        tool3,
+      };
+
+      const message: AssistantMessage = {
+        role: "assistant",
+        status: {
+          type: "requires-action",
+          reason: "tool-calls",
+        },
+        parts: [
+          {
+            type: "tool-call",
+            toolCallId: "1",
+            toolName: "tool1",
+            args: {},
+          } as ToolCallPart,
+          {
+            type: "tool-call",
+            toolCallId: "2",
+            toolName: "tool2",
+            args: {},
+          } as ToolCallPart,
+          {
+            type: "tool-call",
+            toolCallId: "3",
+            toolName: "tool3",
+            args: {},
+          } as ToolCallPart,
+        ],
+        content: [],
+        metadata: {
+          unstable_state: {},
+          unstable_data: [],
+          unstable_annotations: [],
+          steps: [],
+          custom: {},
+        },
+      };
+
+      const startTime = Date.now();
+      const updatedMessage = await unstable_runPendingTools(
+        message,
+        tools,
+        new AbortController().signal,
+        async () => {},
+      );
+      const endTime = Date.now();
+
+      const executionTime = endTime - startTime;
+
+      expect(executionTime).toBeGreaterThanOrEqual(100);
+      // The execution time should be less than the sum of the delays of both tools.
+      expect(executionTime).toBeLessThan(300);
+
+      expect(updatedMessage.parts).toHaveLength(3);
+      expect(updatedMessage.parts[0]).toMatchObject({
+        type: "tool-call",
+        toolCallId: "1",
+        state: "result",
+        result: "Tool 1",
+        isError: false,
+      });
+      expect(updatedMessage.parts[1]).toMatchObject({
+        type: "tool-call",
+        toolCallId: "2",
+        state: "result",
+        result: "Tool 2",
+        isError: false,
+      });
+      expect(updatedMessage.parts[2]).toMatchObject({
+        type: "tool-call",
+        toolCallId: "3",
+        state: "result",
+        result: "Tool 3",
+        isError: false,
+      });
+    });
+
+    it("should verify parallel execution via execution order", async () => {
+      let tool1Started = false;
+      let tool2Started = false;
+      let tool1Finished = false;
+
+      const tool1: Tool = {
+        parameters: {
+          type: "object",
+          properties: {},
+        },
+        execute: async () => {
+          tool1Started = true;
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          tool1Finished = true;
+          return "Tool 1 executed";
+        },
+      };
+
+      const tool2: Tool = {
+        parameters: { type: "object", properties: {} },
+        execute: async () => {
+          tool2Started = true;
+          // In parallel execution, tool2 should start before tool1 finishes
+          expect(tool1Finished).toBe(false);
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          return "Tool 2 executed";
+        },
+      };
+
+      const tools = { tool1, tool2 };
+
+      const message: AssistantMessage = {
+        role: "assistant",
+        status: { type: "requires-action", reason: "tool-calls" },
+        parts: [
+          {
+            type: "tool-call",
+            toolCallId: "1",
+            toolName: "tool1",
+            args: {},
+          } as ToolCallPart,
+          {
+            type: "tool-call",
+            toolCallId: "2",
+            toolName: "tool2",
+            args: {},
+          } as ToolCallPart,
+        ],
+        content: [],
+        metadata: {
+          unstable_state: {},
+          unstable_data: [],
+          unstable_annotations: [],
+          steps: [],
+          custom: {},
+        },
+      };
+
+      await unstable_runPendingTools(
+        message,
+        tools,
+        new AbortController().signal,
+        async () => {},
+      );
+
+      // Verifying that both tools started (proving parallel execution)
+      expect(tool1Started).toBe(true);
+      expect(tool2Started).toBe(true);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should return original message when no tool calls exist", async () => {
+      const message: AssistantMessage = {
+        role: "assistant",
+        status: {
+          reason: "stop",
+          type: "complete",
+        },
+        parts: [
+          {
+            type: "text",
+            text: "Hello",
+            status: {
+              type: "complete",
+              reason: "stop",
+            },
+          },
+        ],
+        content: [],
+        metadata: {
+          unstable_state: {},
+          unstable_data: [],
+          unstable_annotations: [],
+          steps: [],
+          custom: {},
+        },
+      };
+
+      const result = await unstable_runPendingTools(
+        message,
+        {},
+        new AbortController().signal,
+        async () => {},
+      );
+
+      expect(result).toEqual(message);
+    });
+
+    it("should handle missing tool gracefully", async () => {
+      const message: AssistantMessage = {
+        role: "assistant",
+        status: {
+          type: "requires-action",
+          reason: "tool-calls",
+        },
+        parts: [
+          {
+            type: "tool-call",
+            toolCallId: "1",
+            toolName: "nonexistentTool",
+            args: {},
+            status: { type: "requires-action", reason: "tool-call-result" },
+          } as ToolCallPart,
+        ],
+        content: [],
+        metadata: {
+          unstable_state: {},
+          unstable_data: [],
+          unstable_annotations: [],
+          steps: [],
+          custom: {},
+        },
+      };
+
+      const result = await unstable_runPendingTools(
+        message,
+        {},
+        new AbortController().signal,
+        async () => {},
+      );
+
+      // Tool call should remain unchanged (no result added)
+      expect(result.parts[0]).toMatchObject({
+        type: "tool-call",
+        toolCallId: "1",
+        toolName: "nonexistentTool",
+      });
+      expect(result.parts[0]).not.toHaveProperty("state");
+      expect(result.parts[0]).not.toHaveProperty("result");
+    });
+
+    it("should handle mixed text and tool-call parts", async () => {
+      const tool: Tool = {
+        parameters: {
+          type: "object",
+          properties: {},
+        },
+        execute: async () => "executed",
+      };
+
+      const message: AssistantMessage = {
+        role: "assistant",
+        status: {
+          type: "requires-action",
+          reason: "tool-calls",
+        },
+        parts: [
+          {
+            type: "text",
+            text: "Let me call a tool",
+            status: {
+              type: "complete",
+              reason: "stop",
+            },
+          },
+          {
+            type: "tool-call",
+            toolCallId: "1",
+            toolName: "tool",
+            args: {},
+            status: {
+              type: "requires-action",
+              reason: "tool-call-result",
+            },
+          } as ToolCallPart,
+          {
+            type: "text",
+            text: "Done",
+            status: {
+              type: "complete",
+              reason: "stop",
+            },
+          },
+        ],
+        content: [],
+        metadata: {
+          unstable_state: {},
+          unstable_data: [],
+          unstable_annotations: [],
+          steps: [],
+          custom: {},
+        },
+      };
+
+      const result = await unstable_runPendingTools(
+        message,
+        { tool },
+        new AbortController().signal,
+        async () => {},
+      );
+
+      expect(result.parts).toHaveLength(3);
+      expect(result.parts[0]).toEqual({
+        type: "text",
+        text: "Let me call a tool",
+        status: { type: "complete", reason: "stop" },
+      });
+      expect(result.parts[1]).toMatchObject({
+        type: "tool-call",
+        state: "result",
+        result: "executed",
+      });
+      expect(result.parts[2]).toEqual({
+        type: "text",
+        text: "Done",
+        status: { type: "complete", reason: "stop" },
+      });
+    });
+
+    it("should handle tools with different execution times", async () => {
+      const fastTool = createDelayedTool(10, "fast");
+      const slowTool = createDelayedTool(100, "slow");
+
+      const tools = { fastTool, slowTool };
+
+      const message: AssistantMessage = {
+        role: "assistant",
+        status: {
+          type: "requires-action",
+          reason: "tool-calls",
+        },
+        parts: [
+          {
+            type: "tool-call",
+            toolCallId: "1",
+            toolName: "slowTool",
+            args: {},
+            status: {
+              type: "requires-action",
+              reason: "tool-call-result",
+            },
+          } as ToolCallPart,
+          {
+            type: "tool-call",
+            toolCallId: "2",
+            toolName: "fastTool",
+            args: {},
+            status: {
+              type: "requires-action",
+              reason: "tool-call-result",
+            },
+          } as ToolCallPart,
+        ],
+        content: [],
+        metadata: {
+          unstable_state: {},
+          unstable_data: [],
+          unstable_annotations: [],
+          steps: [],
+          custom: {},
+        },
+      };
+
+      const updatedMessage = await unstable_runPendingTools(
+        message,
+        tools,
+        new AbortController().signal,
+        async () => {},
+      );
+
+      // Both should complete successfully
+      expect(updatedMessage.parts[0]).toMatchObject({
+        type: "tool-call",
+        toolCallId: "1",
+        state: "result",
+        result: "slow",
+        isError: false,
+      });
+      expect(updatedMessage.parts[1]).toMatchObject({
+        type: "tool-call",
+        toolCallId: "2",
+        state: "result",
+        result: "fast",
+        isError: false,
+      });
+    });
+  });
+});

package/src/core/tool/toolResultStream.ts

@@ -83,9 +83,9 @@ export async function unstable_runPendingTools(
   abortSignal: AbortSignal,
   human: (toolCallId: string, payload: unknown) => Promise<unknown>,
 ) {
-  // TODO parallel tool calling
-  for (const part of message.parts) {
-    if (part.type === "tool-call") {
+  const toolCallPromises = message.parts
+    .filter((part) => part.type === "tool-call")
+    .map(async (part) => {
       const promiseOrUndefined = getToolResponse(
         tools,
         abortSignal,
@@ -99,29 +99,53 @@ export async function unstable_runPendingTools(
       );
       if (promiseOrUndefined) {
         const result = await promiseOrUndefined;
-        const updatedParts = message.parts.map((p) => {
-          if (p.type === "tool-call" && p.toolCallId === part.toolCallId) {
-            return {
-              ...p,
-              state: "result" as const,
-              ...(result.artifact !== undefined
-                ? { artifact: result.artifact }
-                : {}),
-              result: result.result as ReadonlyJSONValue,
-              isError: result.isError,
-            };
-          }
-          return p;
-        });
-        message = {
-          ...message,
-          parts: updatedParts,
-          content: updatedParts,
+        return {
+          toolCallId: part.toolCallId,
+          result,
         };
       }
-    }
+      return null;
+    });
+
+  const toolCallResults = (await Promise.all(toolCallPromises)).filter(
+    (result) => result !== null,
+  ) as { toolCallId: string; result: ToolResponse<ReadonlyJSONValue> }[];
+
+  if (toolCallResults.length === 0) {
+    return message;
   }
-  return message;
+
+  const toolCallResultsById = toolCallResults.reduce(
+    (acc, { toolCallId, result }) => {
+      acc[toolCallId] = result;
+      return acc;
+    },
+    {} as Record<string, ToolResponse<ReadonlyJSONValue>>,
+  );
+
+  const updatedParts = message.parts.map((p) => {
+    if (p.type === "tool-call") {
+      const toolResponse = toolCallResultsById[p.toolCallId];
+      if (toolResponse) {
+        return {
+          ...p,
+          state: "result" as const,
+          ...(toolResponse.artifact !== undefined
+            ? { artifact: toolResponse.artifact }
+            : {}),
+          result: toolResponse.result as ReadonlyJSONValue,
+          isError: toolResponse.isError,
+        };
+      }
+    }
+    return p;
+  });
+
+  return {
+    ...message,
+    parts: updatedParts,
+    content: updatedParts,
+  };
 }
 
 export function toolResultStream(