@perstack/runtime 0.0.60 → 0.0.62

package/dist/src/index.js

@@ -5,10 +5,10 @@ import { createDeepSeek } from '@ai-sdk/deepseek';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createVertex } from '@ai-sdk/google-vertex';
 import { createOpenAI } from '@ai-sdk/openai';
-import { knownModels, stopRunByDelegate, stopRunByInteractiveTool, resolveThought, attemptCompletion, resolvePdfFile, resolveImageFile, resolveToolResult, stopRunByExceededMaxSteps, continueToNextStep, retry, completeRun, callDelegate, callInteractiveTool, callTool, startRun, startGeneration, finishToolCall, runParamsSchema, createRuntimeEvent, checkpointSchema, runSettingSchema } from '@perstack/core';
+import { knownModels, stopRunByDelegate, stopRunByInteractiveTool, resolveToolResults, attemptCompletion, callDelegate, callInteractiveTool, stopRunByExceededMaxSteps, continueToNextStep, retry, completeRun, callTools, startRun, resumeToolCalls, finishAllToolCalls, startGeneration, finishToolCall, runParamsSchema, createRuntimeEvent, checkpointSchema, runSettingSchema } from '@perstack/core';
 import { createOllama } from 'ollama-ai-provider-v2';
 import { createId } from '@paralleldrive/cuid2';
-import { readFile, readdir, mkdir, writeFile } from 'fs/promises';
+import { readdir, readFile, mkdir, writeFile } from 'fs/promises';
 import path from 'path';
 import { setup, assign, createActor } from 'xstate';
 import { generateText, tool, jsonSchema } from 'ai';
@@ -21,7 +21,7 @@ import { ApiV1Client } from '@perstack/api-client/v1';
 
 // package.json
 var package_default = {
-  version: "0.0.60"};
+  version: "0.0.62"};
 function getModel(modelId, providerConfig) {
   switch (providerConfig.providerName) {
     case "anthropic": {
@@ -192,7 +192,9 @@ function buildDelegationReturnState(currentSetting, resultCheckpoint, parentChec
     checkpoint: {
       ...parentCheckpoint,
       stepNumber: resultCheckpoint.stepNumber,
-      usage: resultCheckpoint.usage
+      usage: resultCheckpoint.usage,
+      pendingToolCalls: parentCheckpoint.pendingToolCalls,
+      partialToolResults: parentCheckpoint.partialToolResults
     }
   };
 }
@@ -229,7 +231,9 @@ function buildDelegateToState(currentSetting, resultCheckpoint, currentExpert) {
         toolName,
         checkpointId: resultCheckpoint.id
       },
-      usage: resultCheckpoint.usage
+      usage: resultCheckpoint.usage,
+      pendingToolCalls: void 0,
+      partialToolResults: void 0
     }
   };
 }
@@ -479,25 +483,37 @@ var McpSkillManager = class extends BaseSkillManager {
       env[envName] = this._env[envName];
     }
     const startTime = Date.now();
-    console.log(`[MCP] Starting skill ${skill.name}...`);
     const { command, args } = this._getCommandArgs(skill);
+    if (this._eventListener) {
+      const event = createRuntimeEvent("skillStarting", this._runId, {
+        skillName: skill.name,
+        command,
+        args
+      });
+      this._eventListener(event);
+    }
     const transport = new StdioClientTransport({ command, args, env, stderr: "pipe" });
     if (transport.stderr) {
       transport.stderr.on("data", (chunk) => {
-        console.log(`[MCP:${skill.name}:stderr] ${chunk.toString().trim()}`);
+        if (this._eventListener) {
+          const event = createRuntimeEvent("skillStderr", this._runId, {
+            skillName: skill.name,
+            message: chunk.toString().trim()
+          });
+          this._eventListener(event);
+        }
       });
     }
     const connectStartTime = Date.now();
     await this._mcpClient.connect(transport);
     const connectTime = Date.now();
-    console.log(
-      `[MCP] Skill ${skill.name} connected in ${connectTime - connectStartTime}ms (total: ${connectTime - startTime}ms)`
-    );
     if (this._eventListener) {
       const serverInfo = this._mcpClient.getServerVersion();
       const event = createRuntimeEvent("skillConnected", this._runId, {
         skillName: skill.name,
-        serverInfo: serverInfo ? { name: serverInfo.name, version: serverInfo.version } : void 0
+        serverInfo: serverInfo ? { name: serverInfo.name, version: serverInfo.version } : void 0,
+        connectDurationMs: connectTime - connectStartTime,
+        totalDurationMs: connectTime - startTime
       });
       this._eventListener(event);
     }
@@ -729,10 +745,14 @@ async function callingDelegateLogic({
   step,
   skillManagers
 }) {
-  if (!step.toolCall) {
-    throw new Error("No tool call found");
+  if (!step.pendingToolCalls || step.pendingToolCalls.length === 0) {
+    throw new Error("No pending tool calls found");
   }
-  const { id, toolName, args } = step.toolCall;
+  const toolCall = step.pendingToolCalls[0];
+  if (!toolCall) {
+    throw new Error("No pending tool call found");
+  }
+  const { id, toolName, args } = toolCall;
   const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
   if (!skillManager.expert) {
     throw new Error(`Delegation error: skill manager "${toolName}" not found`);
@@ -740,6 +760,8 @@ async function callingDelegateLogic({
   if (!args || !args.query || typeof args.query !== "string") {
     throw new Error("Delegation error: query is undefined");
   }
+  const currentToolCall = step.pendingToolCalls[0];
+  const remainingToolCalls = step.pendingToolCalls.slice(1);
   return stopRunByDelegate(setting, checkpoint, {
     checkpoint: {
       ...checkpoint,
@@ -753,7 +775,9 @@ async function callingDelegateLogic({
         toolCallId: id,
         toolName,
         query: args.query
-      }
+      },
+      pendingToolCalls: [currentToolCall, ...remainingToolCalls],
+      partialToolResults: step.partialToolResults
     },
     step: {
       ...step,
@@ -766,10 +790,17 @@ async function callingInteractiveToolLogic({
   checkpoint,
   step
 }) {
+  if (!step.pendingToolCalls || step.pendingToolCalls.length === 0) {
+    throw new Error("No pending tool calls found");
+  }
+  const currentToolCall = step.pendingToolCalls[0];
+  const remainingToolCalls = step.pendingToolCalls.slice(1);
   return stopRunByInteractiveTool(setting, checkpoint, {
     checkpoint: {
       ...checkpoint,
-      status: "stoppedByInteractiveTool"
+      status: "stoppedByInteractiveTool",
+      pendingToolCalls: [currentToolCall, ...remainingToolCalls],
+      partialToolResults: step.partialToolResults
     },
     step: {
       ...step,
@@ -777,37 +808,155 @@ async function callingInteractiveToolLogic({
     }
   });
 }
+function hasRemainingTodos(toolResult) {
+  const firstPart = toolResult.result[0];
+  if (!firstPart || firstPart.type !== "textPart") {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(firstPart.text);
+    return Array.isArray(parsed.remainingTodos) && parsed.remainingTodos.length > 0;
+  } catch {
+    return false;
+  }
+}
+function isFileInfo(value) {
+  return typeof value === "object" && value !== null && "path" in value && "mimeType" in value && "size" in value && typeof value.path === "string" && typeof value.mimeType === "string" && typeof value.size === "number";
+}
+async function processFileToolResult(toolResult, toolName) {
+  const processedContents = [];
+  for (const part of toolResult.result) {
+    if (part.type !== "textPart") {
+      processedContents.push(part);
+      continue;
+    }
+    let fileInfo;
+    try {
+      const parsed = JSON.parse(part.text);
+      if (isFileInfo(parsed)) {
+        fileInfo = parsed;
+      }
+    } catch {
+      processedContents.push(part);
+      continue;
+    }
+    if (!fileInfo) {
+      processedContents.push(part);
+      continue;
+    }
+    const { path: path2, mimeType } = fileInfo;
+    try {
+      const buffer = await readFile(path2);
+      if (toolName === "readImageFile") {
+        processedContents.push({
+          type: "imageInlinePart",
+          id: part.id,
+          encodedData: buffer.toString("base64"),
+          mimeType
+        });
+      } else {
+        processedContents.push({
+          type: "fileInlinePart",
+          id: part.id,
+          encodedData: buffer.toString("base64"),
+          mimeType
+        });
+      }
+    } catch (error) {
+      processedContents.push({
+        type: "textPart",
+        id: part.id,
+        text: `Failed to read file "${path2}": ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  return { ...toolResult, result: processedContents };
+}
+async function executeMcpToolCall(toolCall, skillManagers) {
+  const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
+  if (skillManager.type !== "mcp") {
+    throw new Error(`Incorrect SkillType, required MCP, got ${skillManager.type}`);
+  }
+  const result = await skillManager.callTool(toolCall.toolName, toolCall.args);
+  const toolResult = {
+    id: toolCall.id,
+    skillName: toolCall.skillName,
+    toolName: toolCall.toolName,
+    result
+  };
+  if (toolCall.toolName === "readPdfFile" || toolCall.toolName === "readImageFile") {
+    return processFileToolResult(toolResult, toolCall.toolName);
+  }
+  return toolResult;
+}
+async function getToolType(toolCall, skillManagers) {
+  const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
+  return skillManager.type;
+}
 async function callingToolLogic({
   setting,
   checkpoint,
   step,
   skillManagers
 }) {
-  if (!step.toolCall) {
-    throw new Error("No tool call found");
+  const pendingToolCalls = step.pendingToolCalls ?? step.toolCalls ?? [];
+  if (pendingToolCalls.length === 0) {
+    throw new Error("No tool calls found");
   }
-  const { id, skillName, toolName, args } = step.toolCall;
-  const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
-  if (skillManager.type !== "mcp") {
-    throw new Error(`Incorrect SkillType, required MCP, got ${skillManager.type}`);
+  const toolResults = step.toolResults ? [...step.toolResults] : [];
+  const attemptCompletionTool = pendingToolCalls.find(
+    (tc) => tc.skillName === "@perstack/base" && tc.toolName === "attemptCompletion"
+  );
+  if (attemptCompletionTool) {
+    const toolResult = await executeMcpToolCall(attemptCompletionTool, skillManagers);
+    if (hasRemainingTodos(toolResult)) {
+      return resolveToolResults(setting, checkpoint, { toolResults: [toolResult] });
+    }
+    return attemptCompletion(setting, checkpoint, { toolResult });
+  }
+  const toolCallTypes = await Promise.all(
+    pendingToolCalls.map(async (tc) => ({
+      toolCall: tc,
+      type: await getToolType(tc, skillManagers)
+    }))
+  );
+  const mcpToolCalls = toolCallTypes.filter((t) => t.type === "mcp").map((t) => t.toolCall);
+  const delegateToolCalls = toolCallTypes.filter((t) => t.type === "delegate").map((t) => t.toolCall);
+  const interactiveToolCalls = toolCallTypes.filter((t) => t.type === "interactive").map((t) => t.toolCall);
+  if (mcpToolCalls.length > 0) {
+    const mcpResults = await Promise.all(
+      mcpToolCalls.map((tc) => executeMcpToolCall(tc, skillManagers))
+    );
+    toolResults.push(...mcpResults);
+  }
+  const remainingToolCalls = [...delegateToolCalls, ...interactiveToolCalls];
+  if (delegateToolCalls.length > 0) {
+    const delegateToolCall = delegateToolCalls[0];
+    if (!delegateToolCall) {
+      throw new Error("No delegate tool call found");
+    }
+    step.partialToolResults = toolResults;
+    step.pendingToolCalls = remainingToolCalls;
+    return callDelegate(setting, checkpoint, {
+      newMessage: checkpoint.messages[checkpoint.messages.length - 1],
+      toolCall: delegateToolCall,
+      usage: step.usage
+    });
   }
-  const result = await skillManager.callTool(toolName, args);
-  const toolResult = { id, skillName, toolName, result };
-  if (skillName === "@perstack/base") {
-    if (toolName === "think") {
-      return resolveThought(setting, checkpoint, { toolResult });
-    }
-    if (toolName === "attemptCompletion") {
-      return attemptCompletion(setting, checkpoint, { toolResult });
-    }
-    if (toolName === "readPdfFile") {
-      return resolvePdfFile(setting, checkpoint, { toolResult });
-    }
-    if (toolName === "readImageFile") {
-      return resolveImageFile(setting, checkpoint, { toolResult });
-    }
+  if (interactiveToolCalls.length > 0) {
+    const interactiveToolCall = interactiveToolCalls[0];
+    if (!interactiveToolCall) {
+      throw new Error("No interactive tool call found");
+    }
+    step.partialToolResults = toolResults;
+    step.pendingToolCalls = remainingToolCalls;
+    return callInteractiveTool(setting, checkpoint, {
+      newMessage: checkpoint.messages[checkpoint.messages.length - 1],
+      toolCall: interactiveToolCall,
+      usage: step.usage
+    });
   }
-  return resolveToolResult(setting, checkpoint, { toolResult });
+  return resolveToolResults(setting, checkpoint, { toolResults });
 }
 async function finishingStepLogic({
   setting,
@@ -1023,9 +1172,12 @@ function toolResultPartToCoreToolResultPart(part) {
       output: { type: "text", value: contents[0].text }
     };
   }
-  const contentValue = contents.map(
-    (content) => content.type === "textPart" ? { type: "text", text: content.text } : { type: "media", data: content.encodedData, mediaType: content.mimeType }
-  );
+  const contentValue = contents.map((content) => {
+    if (content.type === "textPart") {
+      return { type: "text", text: content.text };
+    }
+    return { type: "media", data: content.encodedData, mediaType: content.mimeType };
+  });
   return {
     type: "tool-result",
     toolCallId: part.toolCallId,
@@ -1040,21 +1192,21 @@ async function generatingRunResultLogic({
   checkpoint,
   step
 }) {
-  if (!step.toolCall || !step.toolResult) {
-    throw new Error("No tool call or tool result found");
+  if (!step.toolCalls || !step.toolResults || step.toolResults.length === 0) {
+    throw new Error("No tool calls or tool results found");
   }
-  const { id, toolName } = step.toolCall;
-  const { result } = step.toolResult;
-  const toolMessage = createToolMessage([
-    {
+  const toolResultParts = step.toolResults.map((toolResult) => {
+    const toolCall = step.toolCalls?.find((tc) => tc.id === toolResult.id);
+    return {
       type: "toolResultPart",
-      toolCallId: id,
-      toolName,
-      contents: result.filter(
-        (part) => part.type === "textPart" || part.type === "imageInlinePart"
+      toolCallId: toolResult.id,
+      toolName: toolCall?.toolName ?? toolResult.toolName,
+      contents: toolResult.result.filter(
+        (part) => part.type === "textPart" || part.type === "imageInlinePart" || part.type === "fileInlinePart"
       )
-    }
-  ]);
+    };
+  });
+  const toolMessage = createToolMessage(toolResultParts);
   const model = getModel(setting.model, setting.providerConfig);
   const { messages } = checkpoint;
   let generationResult;
@@ -1091,13 +1243,48 @@ async function generatingRunResultLogic({
     step: {
       ...step,
       newMessages: [...step.newMessages, ...newMessages],
-      finishedAt: (/* @__PURE__ */ new Date()).getTime(),
+      finishedAt: Date.now(),
       usage: sumUsage(step.usage, usage)
     },
     text,
     usage
   });
 }
+async function classifyToolCalls(toolCalls, skillManagers) {
+  return Promise.all(
+    toolCalls.map(async (tc) => {
+      const skillManager = await getSkillManagerByToolName(skillManagers, tc.toolName);
+      return {
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        input: tc.input,
+        skillManager
+      };
+    })
+  );
+}
+function sortToolCallsByPriority(toolCalls) {
+  const priority = { mcp: 0, delegate: 1, interactive: 2 };
+  return [...toolCalls].sort(
+    (a, b) => (priority[a.skillManager.type] ?? 99) - (priority[b.skillManager.type] ?? 99)
+  );
+}
+function buildToolCallParts(toolCalls) {
+  return toolCalls.map((tc) => ({
+    type: "toolCallPart",
+    toolCallId: tc.toolCallId,
+    toolName: tc.toolName,
+    args: tc.input
+  }));
+}
+function buildToolCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    id: tc.toolCallId,
+    skillName: tc.skillManager.name,
+    toolName: tc.toolName,
+    args: tc.input
+  }));
+}
 async function generatingToolCallLogic({
   setting,
   checkpoint,
@@ -1129,8 +1316,7 @@ async function generatingToolCallLogic({
   }
   const usage = usageFromGenerateTextResult(result);
   const { text, toolCalls, finishReason } = result;
-  const toolCall = toolCalls[0];
-  if (!toolCall) {
+  if (toolCalls.length === 0) {
     const reason = JSON.stringify({
       error: "Error: No tool call generated",
       message: "You must generate a tool call. Try again."
@@ -1141,42 +1327,26 @@ async function generatingToolCallLogic({
       usage
     });
   }
-  const contents = [
-    {
-      type: "toolCallPart",
-      toolCallId: toolCall.toolCallId,
-      toolName: toolCall.toolName,
-      args: toolCall.input
-    }
-  ];
-  if (text) {
-    contents.push({
-      type: "textPart",
-      text
-    });
-  }
-  const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
-  const eventPayload = {
-    newMessage: createExpertMessage(contents),
-    toolCall: {
-      id: toolCall.toolCallId,
-      skillName: skillManager.name,
-      toolName: toolCall.toolName,
-      args: toolCall.input
-    },
-    usage
-  };
+  const classified = await classifyToolCalls(toolCalls, skillManagers);
+  const sorted = sortToolCallsByPriority(classified);
   if (finishReason === "tool-calls" || finishReason === "stop") {
-    switch (skillManager.type) {
-      case "mcp":
-        return callTool(setting, checkpoint, eventPayload);
-      case "interactive":
-        return callInteractiveTool(setting, checkpoint, eventPayload);
-      case "delegate":
-        return callDelegate(setting, checkpoint, eventPayload);
-    }
+    const toolCallParts = buildToolCallParts(sorted);
+    const contents = [...toolCallParts];
+    if (text) {
+      contents.push({ type: "textPart", text });
+    }
+    const allToolCalls = buildToolCalls(sorted);
+    return callTools(setting, checkpoint, {
+      newMessage: createExpertMessage(contents),
+      toolCalls: allToolCalls,
+      usage
+    });
   }
   if (finishReason === "length") {
+    const firstToolCall = sorted[0];
+    if (!firstToolCall) {
+      throw new Error("No tool call found");
+    }
     const reason = JSON.stringify({
       error: "Error: Tool call generation failed",
       message: "Generation length exceeded. Try again."
@@ -1187,27 +1357,36 @@ async function generatingToolCallLogic({
         createExpertMessage([
           {
             type: "toolCallPart",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            args: toolCall.input
+            toolCallId: firstToolCall.toolCallId,
+            toolName: firstToolCall.toolName,
+            args: firstToolCall.input
           }
         ]),
         createToolMessage([
           {
             type: "toolResultPart",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
+            toolCallId: firstToolCall.toolCallId,
+            toolName: firstToolCall.toolName,
             contents: [{ type: "textPart", text: reason }]
           }
         ])
       ],
-      toolCall: eventPayload.toolCall,
-      toolResult: {
-        id: toolCall.toolCallId,
-        skillName: skillManager.name,
-        toolName: toolCall.toolName,
-        result: [{ type: "textPart", id: createId(), text: reason }]
-      },
+      toolCalls: [
+        {
+          id: firstToolCall.toolCallId,
+          skillName: firstToolCall.skillManager.name,
+          toolName: firstToolCall.toolName,
+          args: firstToolCall.input
+        }
+      ],
+      toolResults: [
+        {
+          id: firstToolCall.toolCallId,
+          skillName: firstToolCall.skillManager.name,
+          toolName: firstToolCall.toolName,
+          result: [{ type: "textPart", id: createId(), text: reason }]
+        }
+      ],
       usage
     });
   }
@@ -1336,18 +1515,26 @@ async function initLogic({
       if (!setting.input.interactiveToolCallResult) {
         throw new Error("Interactive tool call result is undefined");
       }
-      return startRun(setting, checkpoint, {
-        initialCheckpoint: checkpoint,
-        inputMessages: [
-          createToolMessage([
-            {
-              type: "toolResultPart",
-              toolCallId: setting.input.interactiveToolCallResult.toolCallId,
-              toolName: setting.input.interactiveToolCallResult.toolName,
-              contents: [{ type: "textPart", text: setting.input.interactiveToolCallResult.text }]
-            }
-          ])
-        ]
+      const { toolCallId, toolName, text } = setting.input.interactiveToolCallResult;
+      const pendingToolCalls = checkpoint.pendingToolCalls ?? [];
+      const completedToolCall = pendingToolCalls.find((tc) => tc.id === toolCallId);
+      const skillName = completedToolCall?.skillName ?? (checkpoint.status === "stoppedByDelegate" ? checkpoint.delegateTo?.expert.key : "") ?? "";
+      const newToolResult = {
+        id: toolCallId,
+        skillName,
+        toolName,
+        result: [{ type: "textPart", id: createId(), text }]
+      };
+      const updatedPartialResults = [...checkpoint.partialToolResults ?? [], newToolResult];
+      const updatedPendingToolCalls = pendingToolCalls.filter((tc) => tc.id !== toolCallId);
+      const updatedCheckpoint = {
+        ...checkpoint,
+        partialToolResults: updatedPartialResults,
+        pendingToolCalls: updatedPendingToolCalls.length > 0 ? updatedPendingToolCalls : void 0
+      };
+      return startRun(setting, updatedCheckpoint, {
+        initialCheckpoint: updatedCheckpoint,
+        inputMessages: []
       });
     }
     default:
@@ -1364,116 +1551,27 @@ async function preparingForStepLogic({
   setting,
   checkpoint
 }) {
-  return startGeneration(setting, checkpoint, {
-    messages: checkpoint.messages
-  });
-}
-async function resolvingImageFileLogic({
-  setting,
-  checkpoint,
-  step
-}) {
-  if (!step.toolCall || !step.toolResult) {
-    throw new Error("No tool call or tool result found");
-  }
-  const { id, toolName } = step.toolCall;
-  const { result } = step.toolResult;
-  const textParts = result.filter((part) => part.type === "textPart");
-  const files = [];
-  for (const textPart of textParts) {
-    let imageInfo;
-    try {
-      imageInfo = JSON.parse(textPart.text);
-    } catch {
-      files.push({
-        type: "textPart",
-        text: textPart.text
-      });
-      continue;
-    }
-    const { path: path2, mimeType, size } = imageInfo;
-    try {
-      const buffer = await readFile(path2);
-      files.push({
-        type: "imageInlinePart",
-        encodedData: buffer.toString("base64"),
-        mimeType
-      });
-    } catch (error) {
-      files.push({
-        type: "textPart",
-        text: `Failed to read image file "${path2}": ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
+  if (checkpoint.pendingToolCalls && checkpoint.pendingToolCalls.length > 0) {
+    return resumeToolCalls(setting, checkpoint, {
+      pendingToolCalls: checkpoint.pendingToolCalls,
+      partialToolResults: checkpoint.partialToolResults ?? []
+    });
   }
-  return finishToolCall(setting, checkpoint, {
-    newMessages: [
-      createToolMessage([
-        {
-          type: "toolResultPart",
-          toolCallId: id,
-          toolName,
-          contents: files
-        }
-      ])
-    ]
-  });
-}
-async function resolvingPdfFileLogic({
-  setting,
-  checkpoint,
-  step
-}) {
-  if (!step.toolCall || !step.toolResult) {
-    throw new Error("No tool call or tool result found");
-  }
-  const { id, toolName } = step.toolCall;
-  const { result } = step.toolResult;
-  const textParts = result.filter((part) => part.type === "textPart");
-  const files = [];
-  for (const textPart of textParts) {
-    let pdfInfo;
-    try {
-      pdfInfo = JSON.parse(textPart.text);
-    } catch {
-      files.push({
-        type: "textPart",
-        text: textPart.text
-      });
-      continue;
-    }
-    const { path: path2, mimeType, size } = pdfInfo;
-    try {
-      const buffer = await readFile(path2);
-      files.push({
-        type: "fileInlinePart",
-        encodedData: buffer.toString("base64"),
-        mimeType
-      });
-    } catch (error) {
-      files.push({
-        type: "textPart",
-        text: `Failed to read PDF file "${path2}": ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
+  if (checkpoint.partialToolResults && checkpoint.partialToolResults.length > 0) {
+    const toolResultParts = checkpoint.partialToolResults.map((tr) => ({
+      type: "toolResultPart",
+      toolCallId: tr.id,
+      toolName: tr.toolName,
+      contents: tr.result.filter(
+        (part) => part.type === "textPart" || part.type === "imageInlinePart" || part.type === "fileInlinePart"
+      )
+    }));
+    return finishAllToolCalls(setting, checkpoint, {
+      newMessages: [createToolMessage(toolResultParts)]
+    });
   }
-  return finishToolCall(setting, checkpoint, {
-    newMessages: [
-      createToolMessage([
-        {
-          type: "toolResultPart",
-          toolCallId: id,
-          toolName,
-          contents: [
-            {
-              type: "textPart",
-              text: "User uploads PDF file as follows."
-            }
-          ]
-        }
-      ]),
-      createUserMessage(files)
-    ]
+  return startGeneration(setting, checkpoint, {
+    messages: checkpoint.messages
   });
 }
 async function resolvingToolResultLogic({
@@ -1481,24 +1579,22 @@ async function resolvingToolResultLogic({
   checkpoint,
   step
 }) {
-  if (!step.toolCall || !step.toolResult) {
-    throw new Error("No tool call or tool result found");
+  if (!step.toolCalls || !step.toolResults || step.toolResults.length === 0) {
+    throw new Error("No tool calls or tool results found");
   }
-  const { id, toolName } = step.toolCall;
-  const { result } = step.toolResult;
+  const toolResultParts = step.toolResults.map((toolResult) => {
+    const toolCall = step.toolCalls?.find((tc) => tc.id === toolResult.id);
+    return {
+      type: "toolResultPart",
+      toolCallId: toolResult.id,
+      toolName: toolCall?.toolName ?? toolResult.toolName,
+      contents: toolResult.result.filter(
+        (part) => part.type === "textPart" || part.type === "imageInlinePart" || part.type === "fileInlinePart"
+      )
+    };
+  });
   return finishToolCall(setting, checkpoint, {
-    newMessages: [
-      createToolMessage([
-        {
-          type: "toolResultPart",
-          toolCallId: id,
-          toolName,
-          contents: result.filter(
-            (part) => part.type === "textPart" || part.type === "imageInlinePart"
-          )
-        }
-      ])
-    ]
+    newMessages: [createToolMessage(toolResultParts)]
   });
 }
 
@@ -1540,7 +1636,9 @@ var runtimeStateMachine = setup({
             checkpoint: ({ context, event }) => ({
               ...context.checkpoint,
               status: "proceeding",
-              messages: [...context.checkpoint.messages, ...event.inputMessages]
+              messages: [...context.checkpoint.messages, ...event.inputMessages],
+              pendingToolCalls: event.initialCheckpoint.pendingToolCalls,
+              partialToolResults: event.initialCheckpoint.partialToolResults
             }),
             step: ({ context, event }) => ({
               ...context.step,
@@ -1563,6 +1661,38 @@ var runtimeStateMachine = setup({
               startedAt: event.timestamp
             })
           })
+        },
+        resumeToolCalls: {
+          target: "CallingTool",
+          actions: assign({
+            step: ({ context, event }) => ({
+              stepNumber: context.checkpoint.stepNumber,
+              inputMessages: context.step.inputMessages ?? [],
+              newMessages: context.step.newMessages,
+              toolCalls: context.step.toolCalls,
+              toolResults: event.partialToolResults,
+              pendingToolCalls: event.pendingToolCalls,
+              usage: context.step.usage,
+              startedAt: context.step.startedAt
+            })
+          })
+        },
+        finishAllToolCalls: {
+          target: "FinishingStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, ...event.newMessages],
+              pendingToolCalls: void 0,
+              partialToolResults: void 0
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [...context.step.newMessages, ...event.newMessages],
+              toolResults: context.checkpoint.partialToolResults,
+              pendingToolCalls: void 0
+            })
+          })
         }
       }
     },
@@ -1579,13 +1709,13 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: event.newMessages,
-              toolCall: event.toolCall,
-              toolResult: event.toolResult,
+              toolCalls: event.toolCalls,
+              toolResults: event.toolResults,
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
         },
-        callTool: {
+        callTools: {
           target: "CallingTool",
           actions: assign({
             checkpoint: ({ context, event }) => ({
@@ -1597,7 +1727,7 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
-              toolCall: event.toolCall,
+              toolCalls: event.toolCalls,
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -1614,7 +1744,7 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
-              toolCall: event.toolCall,
+              toolCalls: [event.toolCall],
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -1631,7 +1761,7 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
-              toolCall: event.toolCall,
+              toolCalls: [event.toolCall],
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -1640,12 +1770,13 @@ var runtimeStateMachine = setup({
     },
     CallingTool: {
       on: {
-        resolveToolResult: {
+        resolveToolResults: {
           target: "ResolvingToolResult",
           actions: assign({
             step: ({ context, event }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolResults: event.toolResults,
+              pendingToolCalls: void 0
             })
           })
         },
@@ -1654,34 +1785,40 @@ var runtimeStateMachine = setup({
           actions: assign({
             step: ({ context, event }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolResults: [event.toolResult]
             })
           })
         },
-        resolvePdfFile: {
-          target: "ResolvingPdfFile",
+        attemptCompletion: {
+          target: "GeneratingRunResult",
           actions: assign({
             step: ({ context, event }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolResults: [event.toolResult]
             })
           })
         },
-        resolveImageFile: {
-          target: "ResolvingImageFile",
+        callDelegate: {
+          target: "CallingDelegate",
           actions: assign({
-            step: ({ context, event }) => ({
+            step: ({ context }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolCalls: context.step.toolCalls,
+              toolResults: context.step.toolResults,
+              pendingToolCalls: context.step.pendingToolCalls,
+              partialToolResults: context.step.partialToolResults
             })
           })
         },
-        attemptCompletion: {
-          target: "GeneratingRunResult",
+        callInteractiveTool: {
+          target: "CallingInteractiveTool",
           actions: assign({
-            step: ({ context, event }) => ({
+            step: ({ context }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolCalls: context.step.toolCalls,
+              toolResults: context.step.toolResults,
+              pendingToolCalls: context.step.pendingToolCalls,
+              partialToolResults: context.step.partialToolResults
             })
           })
         }
@@ -1721,40 +1858,6 @@ var runtimeStateMachine = setup({
         }
       }
     },
-    ResolvingPdfFile: {
-      on: {
-        finishToolCall: {
-          target: "FinishingStep",
-          actions: assign({
-            checkpoint: ({ context, event }) => ({
-              ...context.checkpoint,
-              messages: [...context.checkpoint.messages, ...event.newMessages]
-            }),
-            step: ({ context, event }) => ({
-              ...context.step,
-              newMessages: [...context.step.newMessages, ...event.newMessages]
-            })
-          })
-        }
-      }
-    },
-    ResolvingImageFile: {
-      on: {
-        finishToolCall: {
-          target: "FinishingStep",
-          actions: assign({
-            checkpoint: ({ context, event }) => ({
-              ...context.checkpoint,
-              messages: [...context.checkpoint.messages, ...event.newMessages]
-            }),
-            step: ({ context, event }) => ({
-              ...context.step,
-              newMessages: [...context.step.newMessages, ...event.newMessages]
-            })
-          })
-        }
-      }
-    },
     GeneratingRunResult: {
       on: {
         retry: {
@@ -1768,8 +1871,8 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: event.newMessages,
-              toolCall: event.toolCall,
-              toolResult: event.toolResult,
+              toolCalls: event.toolCalls,
+              toolResults: event.toolResults,
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -1851,8 +1954,6 @@ var StateMachineLogics = {
   CallingTool: callingToolLogic,
   ResolvingToolResult: resolvingToolResultLogic,
   ResolvingThought: resolvingThoughtLogic,
-  ResolvingPdfFile: resolvingPdfFileLogic,
-  ResolvingImageFile: resolvingImageFileLogic,
   GeneratingRunResult: generatingRunResultLogic,
   CallingInteractiveTool: callingInteractiveToolLogic,
   CallingDelegate: callingDelegateLogic,