@perstack/runtime 0.0.76 → 0.0.77

package/dist/{chunk-CFZZFSPZ.js → chunk-J26GYDJQ.js}

@@ -1,7 +1,7 @@
 import { getSkillManagersFromLockfile, getSkillManagers, closeSkillManagers, getSkillManagerByToolName, getToolSet } from './chunk-RG4QHAGG.js';
 import { readFileSync } from 'fs';
 import path from 'path';
-import { parseWithFriendlyError, lockfileSchema, runParamsSchema, createRuntimeEvent, knownModels, stopRunByExceededMaxSteps, continueToNextStep, stopRunByDelegate, stopRunByInteractiveTool, stopRunByError, retry, completeRun, finishToolCall, resolveToolResults, attemptCompletion, callDelegate, callInteractiveTool, callTools, resumeToolCalls, finishAllToolCalls, startGeneration, startRun } from '@perstack/core';
+import { parseWithFriendlyError, lockfileSchema, runParamsSchema, createRuntimeEvent, knownModels, stopRunByExceededMaxSteps, continueToNextStep, stopRunByError, retry, createStreamingEvent, completeRun, finishToolCall, resolveToolResults, stopRunByInteractiveTool, skipDelegates, stopRunByDelegate, attemptCompletion, finishMcpTools, callTools, proceedToInteractiveTools, startGeneration, startRun, resumeFromStop } from '@perstack/core';
 import TOML from 'smol-toml';
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { createAnthropic } from '@ai-sdk/anthropic';
@@ -12,17 +12,17 @@ import { createVertex } from '@ai-sdk/google-vertex';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOllama } from 'ollama-ai-provider-v2';
 import { ProxyAgent, fetch } from 'undici';
+import { createId } from '@paralleldrive/cuid2';
 import { createApiClient } from '@perstack/api-client';
 import { setup, assign, createActor } from 'xstate';
 import { readFile } from 'fs/promises';
-import { createId } from '@paralleldrive/cuid2';
 import { dedent } from 'ts-dedent';
 import { APICallError, generateText, streamText } from 'ai';
 
 // package.json
 var package_default = {
   name: "@perstack/runtime",
-  version: "0.0.76",
+  version: "0.0.77",
   description: "Perstack Runtime",
   author: "Wintermute Technologies, Inc.",
   license: "Apache-2.0",
@@ -319,9 +319,11 @@ function buildDelegationReturnState(currentSetting, resultCheckpoint, parentChec
     );
   }
   const { expert, toolCallId, toolName } = delegatedBy;
+  const newRunId = createId();
   return {
     setting: {
       ...currentSetting,
+      runId: newRunId,
       expertKey: expert.key,
       input: {
         interactiveToolCallResult: {
@@ -334,6 +336,7 @@ function buildDelegationReturnState(currentSetting, resultCheckpoint, parentChec
     },
     checkpoint: {
       ...parentCheckpoint,
+      runId: newRunId,
       stepNumber: resultCheckpoint.stepNumber,
       usage: resultCheckpoint.usage,
       pendingToolCalls: parentCheckpoint.pendingToolCalls,
@@ -541,15 +544,18 @@ async function classifyToolCalls(toolCalls, skillManagers) {
   return classified;
 }
 
-// src/state-machine/states/calling-delegate.ts
-async function callingDelegateLogic({
+// src/state-machine/states/calling-delegates.ts
+async function callingDelegatesLogic({
   setting,
   checkpoint,
   step,
   skillManagers
 }) {
-  if (!step.pendingToolCalls || step.pendingToolCalls.length === 0) {
-    throw new Error("No pending tool calls found");
+  if (step.pendingToolCalls === void 0 || step.partialToolResults === void 0) {
+    throw new Error("CallingDelegates: tool handling state is undefined (invariant violation)");
+  }
+  if (step.pendingToolCalls.length === 0) {
+    return skipDelegates(setting, checkpoint, {});
   }
   const toolCallTypes = await Promise.all(
     step.pendingToolCalls.map(async (tc) => ({
@@ -560,7 +566,7 @@ async function callingDelegateLogic({
   const delegateToolCalls = toolCallTypes.filter((t) => t.type === "delegate").map((t) => t.toolCall);
   const nonDelegateToolCalls = toolCallTypes.filter((t) => t.type !== "delegate").map((t) => t.toolCall);
   if (delegateToolCalls.length === 0) {
-    throw new Error("No delegate tool calls found");
+    return skipDelegates(setting, checkpoint, {});
   }
   const delegations = await Promise.all(
     delegateToolCalls.map(async (tc) => {
@@ -588,7 +594,7 @@ async function callingDelegateLogic({
       ...checkpoint,
       status: "stoppedByDelegate",
       delegateTo: delegations,
-      pendingToolCalls: nonDelegateToolCalls.length > 0 ? nonDelegateToolCalls : void 0,
+      pendingToolCalls: nonDelegateToolCalls,
       partialToolResults: step.partialToolResults
     },
     step: {
@@ -597,21 +603,26 @@ async function callingDelegateLogic({
     }
   });
 }
-async function callingInteractiveToolLogic({
+async function callingInteractiveToolsLogic({
   setting,
   checkpoint,
   step
 }) {
-  if (!step.pendingToolCalls || step.pendingToolCalls.length === 0) {
-    throw new Error("No pending tool calls found");
+  if (step.pendingToolCalls === void 0 || step.partialToolResults === void 0) {
+    throw new Error(
+      "CallingInteractiveTools: tool handling state is undefined (invariant violation)"
+    );
+  }
+  if (step.pendingToolCalls.length === 0) {
+    return resolveToolResults(setting, checkpoint, {
+      toolResults: step.partialToolResults
+    });
   }
-  const currentToolCall = step.pendingToolCalls[0];
-  const remainingToolCalls = step.pendingToolCalls.slice(1);
   return stopRunByInteractiveTool(setting, checkpoint, {
     checkpoint: {
       ...checkpoint,
       status: "stoppedByInteractiveTool",
-      pendingToolCalls: [currentToolCall, ...remainingToolCalls],
+      pendingToolCalls: step.pendingToolCalls,
       partialToolResults: step.partialToolResults
     },
     step: {
@@ -620,109 +631,6 @@ 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;
-  }
-}
-async function callingToolLogic({
-  setting,
-  checkpoint,
-  step,
-  skillManagers
-}) {
-  const pendingToolCalls = step.pendingToolCalls ?? step.toolCalls ?? [];
-  if (pendingToolCalls.length === 0) {
-    throw new Error("No tool calls found");
-  }
-  const toolResults = step.toolResults ? [...step.toolResults] : [];
-  const attemptCompletionTool = pendingToolCalls.find(
-    (tc) => tc.skillName === "@perstack/base" && tc.toolName === "attemptCompletion"
-  );
-  if (attemptCompletionTool) {
-    const toolResult = await toolExecutorFactory.execute(
-      attemptCompletionTool,
-      "mcp",
-      skillManagers
-    );
-    if (hasRemainingTodos(toolResult)) {
-      return resolveToolResults(setting, checkpoint, { toolResults: [toolResult] });
-    }
-    return attemptCompletion(setting, checkpoint, { toolResult });
-  }
-  const classified = await classifyToolCalls(pendingToolCalls, skillManagers);
-  if (classified.mcp.length > 0) {
-    const mcpResults = await Promise.all(
-      classified.mcp.map((c) => toolExecutorFactory.execute(c.toolCall, "mcp", skillManagers))
-    );
-    toolResults.push(...mcpResults);
-  }
-  if (classified.delegate.length > 0) {
-    const delegateToolCalls = classified.delegate.map((c) => c.toolCall);
-    const interactiveToolCalls = classified.interactive.map((c) => c.toolCall);
-    step.partialToolResults = toolResults;
-    step.pendingToolCalls = [...delegateToolCalls, ...interactiveToolCalls];
-    return callDelegate(setting, checkpoint, {
-      newMessage: checkpoint.messages[checkpoint.messages.length - 1],
-      toolCalls: delegateToolCalls,
-      usage: step.usage
-    });
-  }
-  if (classified.interactive.length > 0) {
-    const interactiveToolCall = classified.interactive[0]?.toolCall;
-    if (!interactiveToolCall) {
-      throw new Error("No interactive tool call found");
-    }
-    const interactiveToolCalls = classified.interactive.map((c) => c.toolCall);
-    step.partialToolResults = toolResults;
-    step.pendingToolCalls = interactiveToolCalls;
-    return callInteractiveTool(setting, checkpoint, {
-      newMessage: checkpoint.messages[checkpoint.messages.length - 1],
-      toolCall: interactiveToolCall,
-      usage: step.usage
-    });
-  }
-  return resolveToolResults(setting, checkpoint, { toolResults });
-}
-async function finishingStepLogic({
-  setting,
-  checkpoint,
-  step
-}) {
-  if (setting.maxSteps !== void 0 && checkpoint.stepNumber >= setting.maxSteps) {
-    return stopRunByExceededMaxSteps(setting, checkpoint, {
-      checkpoint: {
-        ...checkpoint,
-        status: "stoppedByExceededMaxSteps"
-      },
-      step: {
-        ...step,
-        finishedAt: Date.now()
-      }
-    });
-  }
-  return continueToNextStep(setting, checkpoint, {
-    checkpoint: {
-      ...checkpoint
-    },
-    step: {
-      ...step,
-      finishedAt: Date.now()
-    },
-    nextCheckpoint: {
-      ...checkpoint,
-      id: createId(),
-      stepNumber: checkpoint.stepNumber + 1
-    }
-  });
-}
 function createUserMessage(contents) {
   return {
     type: "userMessage",
@@ -934,7 +842,146 @@ function toolResultPartToCoreToolResultPart(part) {
   };
 }
 
-// src/state-machine/states/generating-run-result.ts
+// src/state-machine/states/calling-mcp-tools.ts
+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 extractTextFromLastMessage(checkpoint) {
+  const lastMessage = checkpoint.messages[checkpoint.messages.length - 1];
+  if (!lastMessage || lastMessage.type !== "expertMessage") {
+    return void 0;
+  }
+  const textPart = lastMessage.contents.find((c) => c.type === "textPart");
+  if (!textPart || textPart.type !== "textPart") {
+    return void 0;
+  }
+  const text = textPart.text.trim();
+  return text.length > 0 ? text : void 0;
+}
+async function callingMcpToolsLogic({
+  setting,
+  checkpoint,
+  step,
+  skillManagers
+}) {
+  if (step.pendingToolCalls === void 0 || step.partialToolResults === void 0) {
+    throw new Error("CallingMcpTools: tool handling state is undefined (invariant violation)");
+  }
+  if (step.pendingToolCalls.length === 0) {
+    throw new Error("CallingMcpTools: pendingToolCalls is empty (invariant violation)");
+  }
+  const pendingToolCalls = step.pendingToolCalls;
+  const toolResults = [...step.partialToolResults];
+  const attemptCompletionTool = pendingToolCalls.find(
+    (tc) => tc.skillName === "@perstack/base" && tc.toolName === "attemptCompletion"
+  );
+  if (attemptCompletionTool) {
+    const toolResult = await toolExecutorFactory.execute(
+      attemptCompletionTool,
+      "mcp",
+      skillManagers
+    );
+    if (hasRemainingTodos(toolResult)) {
+      return resolveToolResults(setting, checkpoint, { toolResults: [toolResult] });
+    }
+    const existingText = extractTextFromLastMessage(checkpoint);
+    if (existingText) {
+      const toolResultPart = {
+        type: "toolResultPart",
+        toolCallId: toolResult.id,
+        toolName: attemptCompletionTool.toolName,
+        contents: toolResult.result.filter(
+          (part) => part.type === "textPart" || part.type === "imageInlinePart" || part.type === "fileInlinePart"
+        )
+      };
+      const toolMessage = createToolMessage([toolResultPart]);
+      const expertMessage = createExpertMessage([{ type: "textPart", text: existingText }]);
+      const newMessages = [toolMessage, expertMessage];
+      const newUsage = sumUsage(checkpoint.usage, createEmptyUsage());
+      return completeRun(setting, checkpoint, {
+        checkpoint: {
+          ...checkpoint,
+          messages: [...checkpoint.messages, ...newMessages],
+          usage: newUsage,
+          contextWindowUsage: checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, checkpoint.contextWindow) : void 0,
+          status: "completed",
+          // Clear tool handling state on completion
+          pendingToolCalls: void 0,
+          partialToolResults: void 0
+        },
+        step: {
+          ...step,
+          newMessages: [...step.newMessages, ...newMessages],
+          toolResults: [toolResult],
+          finishedAt: Date.now()
+        },
+        text: existingText,
+        usage: createEmptyUsage()
+      });
+    }
+    return attemptCompletion(setting, checkpoint, { toolResult });
+  }
+  const classified = await classifyToolCalls(pendingToolCalls, skillManagers);
+  if (classified.mcp.length > 0) {
+    const mcpResults = await Promise.all(
+      classified.mcp.map((c) => toolExecutorFactory.execute(c.toolCall, "mcp", skillManagers))
+    );
+    toolResults.push(...mcpResults);
+  }
+  const delegateToolCalls = classified.delegate.map((c) => c.toolCall);
+  const interactiveToolCalls = classified.interactive.map((c) => c.toolCall);
+  if (delegateToolCalls.length > 0 || interactiveToolCalls.length > 0) {
+    return finishMcpTools(setting, checkpoint, {
+      partialToolResults: toolResults,
+      pendingToolCalls: [...delegateToolCalls, ...interactiveToolCalls]
+    });
+  }
+  return resolveToolResults(setting, checkpoint, { toolResults });
+}
+async function finishingStepLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  if (setting.maxSteps !== void 0 && checkpoint.stepNumber >= setting.maxSteps) {
+    return stopRunByExceededMaxSteps(setting, checkpoint, {
+      checkpoint: {
+        ...checkpoint,
+        status: "stoppedByExceededMaxSteps"
+      },
+      step: {
+        ...step,
+        finishedAt: Date.now()
+      }
+    });
+  }
+  return continueToNextStep(setting, checkpoint, {
+    checkpoint: {
+      ...checkpoint
+    },
+    step: {
+      ...step,
+      finishedAt: Date.now()
+    },
+    nextCheckpoint: {
+      ...checkpoint,
+      id: createId(),
+      stepNumber: checkpoint.stepNumber + 1,
+      // Clear tool handling state for next step
+      pendingToolCalls: void 0,
+      partialToolResults: void 0
+    }
+  });
+}
 async function generatingRunResultLogic({
   setting,
   checkpoint,
@@ -962,20 +1009,27 @@ async function generatingRunResultLogic({
   let reasoningCompletedViaCallback = false;
   const callbacks = {
     onReasoningStart: () => {
-      eventListener(createRuntimeEvent("startReasoning", setting.jobId, setting.runId, {}));
+      eventListener(createStreamingEvent("startStreamingReasoning", setting, checkpoint, {}));
     },
     onReasoningDelta: (delta) => {
-      eventListener(createRuntimeEvent("streamReasoning", setting.jobId, setting.runId, { delta }));
+      eventListener(createStreamingEvent("streamReasoning", setting, checkpoint, { delta }));
     },
     onReasoningComplete: (text2) => {
-      eventListener(createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, { text: text2 }));
+      eventListener(
+        createStreamingEvent("completeStreamingReasoning", setting, checkpoint, { text: text2 })
+      );
       reasoningCompletedViaCallback = true;
     },
     onResultStart: () => {
-      eventListener(createRuntimeEvent("startRunResult", setting.jobId, setting.runId, {}));
+      eventListener(createStreamingEvent("startStreamingRunResult", setting, checkpoint, {}));
     },
     onResultDelta: (delta) => {
-      eventListener(createRuntimeEvent("streamRunResult", setting.jobId, setting.runId, { delta }));
+      eventListener(createStreamingEvent("streamRunResult", setting, checkpoint, { delta }));
+    },
+    onResultComplete: (text2) => {
+      eventListener(
+        createStreamingEvent("completeStreamingRunResult", setting, checkpoint, { text: text2 })
+      );
     }
   };
   const executionResult = await llmExecutor.streamText(
@@ -1029,7 +1083,7 @@ async function generatingRunResultLogic({
   const newMessages = [toolMessage, createExpertMessage(expertContents)];
   if (thinkingText && !reasoningCompletedViaCallback) {
     await eventListener(
-      createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, {
+      createStreamingEvent("completeStreamingReasoning", setting, checkpoint, {
         text: thinkingText
       })
     );
@@ -1041,7 +1095,10 @@ async function generatingRunResultLogic({
       messages: [...messages, ...newMessages],
       usage: newUsage,
       contextWindowUsage: checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, checkpoint.contextWindow) : void 0,
-      status: "completed"
+      status: "completed",
+      // Clear tool handling state on completion
+      pendingToolCalls: void 0,
+      partialToolResults: void 0
     },
     step: {
       ...step,
@@ -1100,13 +1157,15 @@ async function generatingToolCallLogic({
   let reasoningCompletedViaCallback = false;
   const callbacks = {
     onReasoningStart: () => {
-      eventListener(createRuntimeEvent("startReasoning", setting.jobId, setting.runId, {}));
+      eventListener(createStreamingEvent("startStreamingReasoning", setting, checkpoint, {}));
     },
     onReasoningDelta: (delta) => {
-      eventListener(createRuntimeEvent("streamReasoning", setting.jobId, setting.runId, { delta }));
+      eventListener(createStreamingEvent("streamReasoning", setting, checkpoint, { delta }));
     },
     onReasoningComplete: (text2) => {
-      eventListener(createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, { text: text2 }));
+      eventListener(
+        createStreamingEvent("completeStreamingReasoning", setting, checkpoint, { text: text2 })
+      );
       reasoningCompletedViaCallback = true;
     }
     // onResultStart and onResultDelta intentionally not set - result streaming only in GeneratingRunResult
@@ -1161,7 +1220,7 @@ async function generatingToolCallLogic({
     const newUsage = sumUsage(checkpoint.usage, usage);
     if (thinkingText && !reasoningCompletedViaCallback) {
       await eventListener(
-        createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, {
+        createStreamingEvent("completeStreamingReasoning", setting, checkpoint, {
           text: thinkingText
         })
       );
@@ -1172,7 +1231,10 @@ async function generatingToolCallLogic({
         messages: [...messages, newMessage],
         usage: newUsage,
         contextWindowUsage: checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, checkpoint.contextWindow) : void 0,
-        status: "completed"
+        status: "completed",
+        // Clear tool handling state on completion
+        pendingToolCalls: void 0,
+        partialToolResults: void 0
       },
       step: {
         ...step,
@@ -1221,7 +1283,7 @@ async function generatingToolCallLogic({
     const allToolCalls = buildToolCalls(sorted);
     if (thinkingText && !reasoningCompletedViaCallback) {
       await eventListener(
-        createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, {
+        createStreamingEvent("completeStreamingReasoning", setting, checkpoint, {
           text: thinkingText
         })
       );
@@ -1313,8 +1375,8 @@ function getMetaInstruction(startedAt) {
     2. Select Tools: Choose the next tool call based on current state, task planning, relevant knowledge, and available data APIs
     3. Wait for Execution: The selected tool action will be executed by the sandbox environment with new observations added to the event stream
     4. Iterate: Choose only one tool call per iteration, patiently repeat the above steps until task completion
-    5. Notify Task Completion: Call the attemptCompletion tool to inform the user when the task is complete
-    6. Generate Final Results: Produce a final result that clearly describes each task you performed, step by step
+    5. Notify Task Completion: Call attemptCompletion ONLY - do NOT include any text response with this tool call
+    6. Generate Final Results: AFTER attemptCompletion returns, you will be prompted to produce a final result in a SEPARATE response
 
     Conditions for ending the agent loop:
     If any of the following apply, **immediately call the attemptCompletion tool**.
@@ -1436,11 +1498,10 @@ async function initLogic({
       const updatedCheckpoint = {
         ...checkpoint,
         partialToolResults: updatedPartialResults,
-        pendingToolCalls: updatedPendingToolCalls.length > 0 ? updatedPendingToolCalls : void 0
+        pendingToolCalls: updatedPendingToolCalls
       };
-      return startRun(setting, updatedCheckpoint, {
-        initialCheckpoint: updatedCheckpoint,
-        inputMessages: []
+      return resumeFromStop(setting, checkpoint, {
+        checkpoint: updatedCheckpoint
       });
     }
     default:
@@ -1457,25 +1518,6 @@ async function preparingForStepLogic({
   setting,
   checkpoint
 }) {
-  if (checkpoint.pendingToolCalls && checkpoint.pendingToolCalls.length > 0) {
-    return resumeToolCalls(setting, checkpoint, {
-      pendingToolCalls: checkpoint.pendingToolCalls,
-      partialToolResults: checkpoint.partialToolResults ?? []
-    });
-  }
-  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 startGeneration(setting, checkpoint, {
     messages: checkpoint.messages
   });
@@ -1485,10 +1527,11 @@ async function resolvingToolResultLogic({
   checkpoint,
   step
 }) {
-  if (!step.toolCalls || !step.toolResults || step.toolResults.length === 0) {
-    throw new Error("No tool calls or tool results found");
+  if (step.toolResults === void 0 || step.toolResults.length === 0) {
+    throw new Error("ResolvingToolResult: toolResults is undefined or empty (invariant violation)");
   }
-  const toolResultParts = step.toolResults.map((toolResult) => {
+  const toolResults = step.toolResults;
+  const toolResultParts = toolResults.map((toolResult) => {
     const toolCall = step.toolCalls?.find((tc) => tc.id === toolResult.id);
     return {
       type: "toolResultPart",
@@ -1503,6 +1546,23 @@ async function resolvingToolResultLogic({
     newMessages: [createToolMessage(toolResultParts)]
   });
 }
+async function resumingFromStopLogic({
+  setting,
+  checkpoint
+}) {
+  if (checkpoint.pendingToolCalls === void 0 || checkpoint.partialToolResults === void 0) {
+    throw new Error("ResumingFromStop: tool handling state is undefined (invariant violation)");
+  }
+  if (checkpoint.pendingToolCalls.length > 0) {
+    return proceedToInteractiveTools(setting, checkpoint, {
+      pendingToolCalls: checkpoint.pendingToolCalls,
+      partialToolResults: checkpoint.partialToolResults
+    });
+  }
+  return resolveToolResults(setting, checkpoint, {
+    toolResults: checkpoint.partialToolResults
+  });
+}
 
 // src/state-machine/machine.ts
 var runtimeStateMachine = setup({
@@ -1512,7 +1572,7 @@ var runtimeStateMachine = setup({
     events: {}
   }
 }).createMachine({
-  /** @xstate-layout N4IgpgJg5mDOIC5QCUCuA7AdASXQSwBcBiWAgQwCcC10BtABgF1FQAHAe1kL3fRZAAeiAKz0AzJgDsAJgAsksZNlixs+gDZZAGhABPRIszCAjGIAcY4crPHhJyQF8HOmpgAKFMK0p50UAGLsFADKBF4k5FQA4mDoYBRkBDx0TPwcXEm8-EIIZmaymPRK8saSopL00tI6+gjq9JjSltLG9HnqZkqdTi4YmDFxCUl+ACrs7AA2AMJkExNEngQUugzMSCDp3FnrOcam0pgAnHbS9GeSZsIq6jWIh2KHUsYd9MbSwl2S6j0grgPxiV8UDGkxmcyIAGNZhMQRNVmlOFs+DtEPt1Jg3odpGVbFcrLcENIzOjbGYipIZMpnmYfn9YgDhsDxtNoZDobgwgkIUkAG5gWHw9abTLI0C7ImSTDqYTY2S45TCCwE54HUr1WRXSqHcRVWl9f5DIGwsHzKFzAAiYAmYCgiTAgrYiJF2VRYnoj1ehwskkOZTEz2EBMMJnMFnezxUF2+zl+fRNRuZCzgkz5sOQcFQEwIDo2TuSLoQpWJUvowl9Flk0sqBLlZik2Mkpjyan90d6WHjo0TnlgKf5AAt2KgoP3s6khXntmLUT6JL6PkoFJX1MZtHoRKIpdrK3sqorpG3Yx3oQnJknexM+W4IAAzfx4a054X5lGFn2PMTYlSyWQH32WAl1DKKV1Q6L1V1EWQ9WPOZT3mHs+2wABbMgYHvR9x0dDIX2nN8zEeOVjGORsmgsMQCTJYRMGJORwP9MwDxpGNXE7Jkz0SMIkNYAgpnYLjrRFJ9J1FQQZzJTBPxUfDDjlN1OgJIkSUVUtDlXCpsUPVx0wvHk4O0zNiBvXw8FgftjWhITsKnUTCU-SU92JMlfSaGtjDrGQKSbfJxGeaDMG0lMjUHYdRyIIz8FM8y5kspECyabFGneRz3RkN011qOwGnUbcVzeJKDz8gLLyBa87wfMAwuMyLmRNGLnVfeL7KSl5nPI9c6mA9RQPwmwNVLQrk2KvxkNQsB0Iq8KTLMmqLMw3MrJEnJGsSxUWtSgkfSU-JDmIqNKj8g1AT8Gh9KzSE+NYASwBoOqcJs+K61sDo5SKBifwU4tSRUtTKi+KDmLjE9hvQTkyG5PBU0TUh2FYGgACFdA5AFwchyZbus3YyklYRst-DUlDEaU2tqFUMS+NyPmlPZDiAvzWMta1bTCCIYfh3QGZtO10cWmcLiOQnG3qHHiSDbGvM-Ex1EjYk-PvCL+yBUJwghXhhlQfl2AAOTAAQCCV1hubiqxjCMRUZXMGSvVUZV6A1LcuorDp8I0WWqoVvx9ZZ2GMARgBRAQITASBIAAWTIAR9dgQ2Gs0Ki8nyK4bCuDVRZNzRwxse4GK6pwY3QdgIDgfgaARBaCxUBosU0cw5TLUiCQAWlkR4nPdbVCeyld-vbHB8AIUvYtfRQ6yr6xa6xcwCTLaiadj1dKxk1phD8jwvB8PxAhCMJWAH+rcKAyuyVaa5Wi+KeW9njV59xpeDvpQ0u1BaFd7u3Y2keDpO7LW2FDLc+Z6AnsPEO4ZYAxghMOCL8MaojsJKYi8cHZ5C9EGNoRg1CdH3GcZeYD-KDV0o-CYp1+4TjLg1cQkp-SfjDE9Ew1R2o-hNnsUs1MfR-UuANHSQUhwjmIVhQeuFTg-ilF8GUblTgKDoRlBQhQJEaiJMnfCHDAp+FKuNKBPNCSlgaOIeQttWxS0DO1bKdY9HvH9D+FotMcFFXwVAEaaFyrqLirbBo1M7KvFUDJCiRJGgalUM3LEMk5R30GEdKAJ0MxZicWQlQEklAyillWVoZgUF1isG0MoDEsF0yBnYkGyNeQa0mNE3CtgiIYnEEBToFwvS+mVPkU20l8JWG1OIHJsE-AcyZmAEpNlbBqEwLo7yVRbY3HatPfCXUOgfCsGSTQmk+hyymorbevSloykeFYCkrxfqrmJiIaRRQ7JbP8Q8PyoQYasEgGsxA2JWiNB-jjdQTRqb1IkP6OwRF8KMSAbnBwQA */
+  /** @xstate-layout N4IgpgJg5mDOIC5QCUCuA7AdASXQSwBcBiWAgQwCcC10BtABgF1FQAHAe1kL3fRZAAeiAKz0AzJgDsAJgAsksZNlixs+gDZZAGhABPRIszCAjGIAcY4crPHhJyQF8HOmpgAKFMK0p50UAGLsFADKBF4k5FQA4mDoYBRkBDx0TPwcXEm8-EIIZmaymPRK8saSopL00tI6+gjq9JjSltLG9HnqZkqdTi4YmDFxCUl+ACrs7AA2AMJkExNEngQUugzMSCDp3FnrOcam0pgAnHbS9GeSZsIq6jWIh2KHUsYd9MbSwl2S6j0grgPxiV8UDGkxmcyIAGNZhMQRNVmlOFs+DtEPt1Jg3odpGVbFcrLcENIzOjbGYipIZMpnmYfn9YgDhsDxtNoZDobgwgkIUkAG5gWHw9abTLI0C7ImSTDqYTY2S45TCCwE54HUr1WRXSqHcRVWl9f5DIGwsHzKFzAAiYAmYCgiTAgrYiJF2VRYnoj1ehwskkOZTEz2EBMMJnMFnezxUF2+zl+fRNRuZCzgkz5sOQcFQEwIDo2TuSLoQpWJUvowl9Flk0sqBLlZik2Mkpjyan90d6WHjo0TnlgKf5AAt2KgoP3s6khXntmLUT6JL6PkoFJX1MZtHoRKIpdrK3sqorpG3Yx3oQnJknexM+W4IAAzfx4a054X5lGFn2PMTYlSyWQH32WAl1DKKV1Q6L1V1EWQ9WPOZT3mHs+2wABbMgYHvR9x0dDIX2nN8zEeOVjGORsmgsMQCTJYRMGJORwP9MwDxpGNXE7Jkz0SMIkNYAgpnYLjrRFJ9J1FQQZzJTBPxUfDDjlN1OgJIkSUVUtDlXCpsUPVx0wvHk4O0zNiBvXw8FgftjWhITsKnUTCU-SU92JMlfSaGtjDrGQKSbfJxGeaDMG0lMjUHYdRyIIz8FM8y5kspECyabFGneRz3RkN011qOwGnUbcVzeJKDz8gLLyBa87wfMAwuMyLmRNGLnVfeL7KSl5nPI9c6mA9RQPwmwNVLQrk2KvxkNQsB0Iq8KTLMmqLMw3MrJEnJGsSxUWtSgkfSU-JDmIqNKj8g1AT8Gh9KzSE+NYASwBoOqcJs+K61sDo5SKBifwU4tSRUtTKi+KDmLjE9hvQTkyG5PBU0TUh2FYGgACFdA5AFwchyZbus3YyklYRst/DUlDEaU2tqFUMS+NyPmlPZDiAvzWMta1bTCCIYfh3QGZtO10cWmcLiOQnG3qHHiSDbGvM-Ex1EjYk/PvCL+yBUJwghXhhlQfl2AAOTAAQCCV1hubiqxjCMRUZXMGSvVUZV6A1LcuorDp8I0WWqoVvx9ZZ2GMARgBRAQITASBIAAWTIAR9dgQ2Gs0Ki8nyK4bCuDVRZNzRwxse4GK6pwY3QdgIDgfgaARBaCxUBosU0cw5TLUiCQAWlkR4nPdbVCeyld/vbHB8AIUvYtfRQ6yr6xa6xcwCTLaiadj1dKxk1phD8jwvB8PxAhCMJWAH+rcKAyuyVaa5Wi+KeW9njV59xpeDvpQ0u1BaFd7u3Y2keDpO7LW2FDLc+Z6AnsPEO4ZYAxghMOCL8MaojsJKYi8cHZ5C9EGNoRg1CdH3GcZeYD/KDV0o-CYp1+4TjLg1cQkp-SfjDE9Ew1R2o-hNnsUs1MfR-UuANHSQUhwjmIVhQeuFTg-ilF8GUblTgKDoRlBQhQJEaiJMnfCHDAp+FKuNKBPNCSlgaOIeQttWxS0DO1bKdY9HvH9D+FotMcFFXwVAEaaFyrqLirbBo1M7KvFUDJCiRJGgalUM3LEMk5R30GEdKAJ0MxZicWQlQEklAyillWVoZgUF1isG0MoDEsF0yBnYkGyNeQa0mNE3CtgiIYnEEBToFwvS+mVPkU20l8JWG1OIHJsE/AcyZmAEpNlbBqEwLo7yVRbY3HatPfCXUOgfCsGSTQmk+hyymorbevSloykeFYCkrxfqrmJiIaRRQ7JbP8Q8PyoQYasEgGsxA2JWiNB/jjdQTRqb1IkP6OwRF8KMSAbnBwQA */
   id: "Run",
   initial: "Init",
   context: ({ input }) => ({
@@ -1538,15 +1598,22 @@ var runtimeStateMachine = setup({
             checkpoint: ({ context, event }) => ({
               ...context.checkpoint,
               status: "proceeding",
-              messages: [...context.checkpoint.messages, ...event.inputMessages],
-              pendingToolCalls: event.initialCheckpoint.pendingToolCalls,
-              partialToolResults: event.initialCheckpoint.partialToolResults
+              messages: [...context.checkpoint.messages, ...event.inputMessages]
             }),
             step: ({ context, event }) => ({
               ...context.step,
               inputMessages: event.inputMessages
             })
           })
+        },
+        resumeFromStop: {
+          target: "ResumingFromStop",
+          actions: assign({
+            checkpoint: ({ event }) => ({
+              ...event.checkpoint,
+              status: "proceeding"
+            })
+          })
         }
       }
     },
@@ -1563,36 +1630,45 @@ var runtimeStateMachine = setup({
               startedAt: event.timestamp
             })
           })
-        },
-        resumeToolCalls: {
-          target: "CallingTool",
+        }
+      }
+    },
+    ResumingFromStop: {
+      on: {
+        proceedToInteractiveTools: {
+          target: "CallingInteractiveTools",
           actions: assign({
             step: ({ context, event }) => ({
               stepNumber: context.checkpoint.stepNumber,
-              inputMessages: context.step.inputMessages ?? [],
-              newMessages: context.step.newMessages,
-              toolCalls: context.step.toolCalls,
-              toolResults: event.partialToolResults,
+              inputMessages: [],
+              newMessages: [],
+              toolCalls: context.checkpoint.pendingToolCalls ?? [],
+              toolResults: [],
               pendingToolCalls: event.pendingToolCalls,
-              usage: context.step.usage,
-              startedAt: context.step.startedAt
+              partialToolResults: event.partialToolResults,
+              usage: createEmptyUsage(),
+              startedAt: Date.now()
             })
           })
         },
-        finishAllToolCalls: {
-          target: "FinishingStep",
+        resolveToolResults: {
+          target: "ResolvingToolResult",
           actions: assign({
-            checkpoint: ({ context, event }) => ({
+            checkpoint: ({ context }) => ({
               ...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
+              stepNumber: context.checkpoint.stepNumber,
+              inputMessages: [],
+              newMessages: [],
+              toolCalls: [],
+              toolResults: event.toolResults,
+              pendingToolCalls: void 0,
+              partialToolResults: void 0,
+              usage: createEmptyUsage(),
+              startedAt: Date.now()
             })
           })
         }
@@ -1642,50 +1718,7 @@ var runtimeStateMachine = setup({
           })
         },
         callTools: {
-          target: "CallingTool",
-          actions: assign({
-            checkpoint: ({ context, event }) => {
-              const newUsage = sumUsage(context.checkpoint.usage, event.usage);
-              return {
-                ...context.checkpoint,
-                messages: [...context.checkpoint.messages, event.newMessage],
-                usage: newUsage,
-                contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, context.checkpoint.contextWindow) : void 0,
-                retryCount: 0
-              };
-            },
-            step: ({ context, event }) => ({
-              ...context.step,
-              newMessages: [event.newMessage],
-              toolCalls: event.toolCalls,
-              usage: sumUsage(context.step.usage, event.usage)
-            })
-          })
-        },
-        callInteractiveTool: {
-          target: "CallingInteractiveTool",
-          actions: assign({
-            checkpoint: ({ context, event }) => {
-              const newUsage = sumUsage(context.checkpoint.usage, event.usage);
-              return {
-                ...context.checkpoint,
-                messages: [...context.checkpoint.messages, event.newMessage],
-                usage: newUsage,
-                contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, context.checkpoint.contextWindow) : void 0,
-                retryCount: 0
-                // Reset on successful generation
-              };
-            },
-            step: ({ context, event }) => ({
-              ...context.step,
-              newMessages: [event.newMessage],
-              toolCalls: [event.toolCall],
-              usage: sumUsage(context.step.usage, event.usage)
-            })
-          })
-        },
-        callDelegate: {
-          target: "CallingDelegate",
+          target: "CallingMcpTools",
           actions: assign({
             checkpoint: ({ context, event }) => {
               const newUsage = sumUsage(context.checkpoint.usage, event.usage);
@@ -1695,20 +1728,22 @@ var runtimeStateMachine = setup({
                 usage: newUsage,
                 contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, context.checkpoint.contextWindow) : void 0,
                 retryCount: 0
-                // Reset on successful generation
               };
             },
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
               toolCalls: event.toolCalls,
-              usage: sumUsage(context.step.usage, event.usage)
+              usage: sumUsage(context.step.usage, event.usage),
+              // Initialize tool handling state
+              pendingToolCalls: event.toolCalls,
+              partialToolResults: []
             })
           })
         }
       }
     },
-    CallingTool: {
+    CallingMcpTools: {
       on: {
         resolveToolResults: {
           target: "ResolvingToolResult",
@@ -1729,27 +1764,65 @@ var runtimeStateMachine = setup({
             })
           })
         },
-        callDelegate: {
-          target: "CallingDelegate",
+        finishMcpTools: {
+          target: "CallingDelegates",
           actions: assign({
-            step: ({ context }) => ({
+            step: ({ context, event }) => ({
               ...context.step,
-              toolCalls: context.step.toolCalls,
-              toolResults: context.step.toolResults,
-              pendingToolCalls: context.step.pendingToolCalls,
-              partialToolResults: context.step.partialToolResults
+              partialToolResults: event.partialToolResults,
+              pendingToolCalls: event.pendingToolCalls
+            })
+          })
+        },
+        completeRun: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => ({ ...event.checkpoint, retryCount: 0 }),
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          })
+        }
+      }
+    },
+    CallingDelegates: {
+      on: {
+        stopRunByDelegate: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          })
+        },
+        skipDelegates: {
+          target: "CallingInteractiveTools"
+        }
+      }
+    },
+    CallingInteractiveTools: {
+      on: {
+        stopRunByInteractiveTool: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
             })
           })
         },
-        callInteractiveTool: {
-          target: "CallingInteractiveTool",
+        resolveToolResults: {
+          target: "ResolvingToolResult",
           actions: assign({
-            step: ({ context }) => ({
+            step: ({ context, event }) => ({
               ...context.step,
-              toolCalls: context.step.toolCalls,
-              toolResults: context.step.toolResults,
-              pendingToolCalls: context.step.pendingToolCalls,
-              partialToolResults: context.step.partialToolResults
+              toolResults: event.toolResults,
+              pendingToolCalls: void 0,
+              partialToolResults: void 0
             })
           })
         }
@@ -1817,34 +1890,6 @@ var runtimeStateMachine = setup({
         }
       }
     },
-    CallingInteractiveTool: {
-      on: {
-        stopRunByInteractiveTool: {
-          target: "Stopped",
-          actions: assign({
-            checkpoint: ({ event }) => event.checkpoint,
-            step: ({ event }) => ({
-              ...event.step,
-              inputMessages: void 0
-            })
-          })
-        }
-      }
-    },
-    CallingDelegate: {
-      on: {
-        stopRunByDelegate: {
-          target: "Stopped",
-          actions: assign({
-            checkpoint: ({ event }) => event.checkpoint,
-            step: ({ event }) => ({
-              ...event.step,
-              inputMessages: void 0
-            })
-          })
-        }
-      }
-    },
     FinishingStep: {
       on: {
         continueToNextStep: {
@@ -1878,12 +1923,13 @@ var runtimeStateMachine = setup({
 var StateMachineLogics = {
   Init: initLogic,
   PreparingForStep: preparingForStepLogic,
+  ResumingFromStop: resumingFromStopLogic,
   GeneratingToolCall: generatingToolCallLogic,
-  CallingTool: callingToolLogic,
+  CallingMcpTools: callingMcpToolsLogic,
+  CallingDelegates: callingDelegatesLogic,
+  CallingInteractiveTools: callingInteractiveToolsLogic,
   ResolvingToolResult: resolvingToolResultLogic,
   GeneratingRunResult: generatingRunResultLogic,
-  CallingInteractiveTool: callingInteractiveToolLogic,
-  CallingDelegate: callingDelegateLogic,
   FinishingStep: finishingStepLogic
 };
 var DefaultActorFactory = class {
@@ -2002,15 +2048,17 @@ var SingleDelegationStrategy = class {
     }
     const delegation = delegations[0];
     const { expert, toolCallId, toolName, query } = delegation;
+    const childRunId = createId();
     const nextSetting = {
       ...setting,
+      runId: childRunId,
       expertKey: expert.key,
       input: { text: query }
     };
     const nextCheckpoint = {
       id: context.id,
       jobId: setting.jobId,
-      runId: setting.runId,
+      runId: childRunId,
       status: "init",
       stepNumber: context.stepNumber,
       messages: [],
@@ -2028,7 +2076,9 @@ var SingleDelegationStrategy = class {
         },
         toolCallId,
         toolName,
-        checkpointId: context.id
+        checkpointId: context.id,
+        runId: setting.runId
+        // Parent's runId for traceability
       },
       usage: context.usage,
       contextWindow: context.contextWindow,
@@ -2078,8 +2128,10 @@ var ParallelDelegationStrategy = class {
     const remainingPendingToolCalls = context.pendingToolCalls?.filter(
       (tc) => !processedToolCallIds.has(tc.id) && tc.id !== firstDelegation.toolCallId
     );
+    const returnRunId = createId();
     const nextSetting = {
       ...setting,
+      runId: returnRunId,
       expertKey: parentExpert.key,
       input: {
         interactiveToolCallResult: {
@@ -2093,7 +2145,7 @@ var ParallelDelegationStrategy = class {
     const nextCheckpoint = {
       id: context.id,
       jobId: setting.jobId,
-      runId: setting.runId,
+      runId: returnRunId,
       status: "stoppedByDelegate",
       stepNumber: maxStepNumber,
       messages: context.messages,
@@ -2143,7 +2195,8 @@ var ParallelDelegationStrategy = class {
         },
         toolCallId,
         toolName,
-        checkpointId: parentContext.id
+        checkpointId: parentContext.id,
+        runId: parentSetting.runId
       },
       usage: createEmptyUsage(),
       contextWindow: parentContext.contextWindow
@@ -2390,10 +2443,14 @@ function convertSkill(skill) {
     };
   }
   try {
+    const parsed = JSON.parse(skill.definition);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Definition must be a JSON object");
+    }
     return {
       type: "custom",
       name: skill.name,
-      mcp_config: JSON.parse(skill.definition)
+      mcp_config: parsed
     };
   } catch (error) {
     throw new Error(
@@ -2552,10 +2609,9 @@ function buildAzureOpenAITools(client, toolNames, options) {
       case "fileSearch": {
         const vectorStoreIds = options?.fileSearch?.vectorStoreIds;
         if (!vectorStoreIds || vectorStoreIds.length === 0) {
-          console.warn(
+          throw new Error(
             "Azure OpenAI fileSearch tool requires vectorStoreIds. Set providerToolOptions.fileSearch.vectorStoreIds to use this tool."
           );
-          break;
         }
         const fileSearchTool = client.tools.fileSearch({
           vectorStoreIds,
@@ -2867,10 +2923,9 @@ function buildGoogleTools(client, toolNames, options) {
       case "fileSearch": {
         const storeNames = options?.fileSearch?.vectorStoreIds;
         if (!storeNames || storeNames.length === 0) {
-          console.warn(
+          throw new Error(
             "Google fileSearch tool requires fileSearchStoreNames. Set providerToolOptions.fileSearch.vectorStoreIds to use this tool."
           );
-          break;
         }
         const fileSearchTool = client.tools.fileSearch({
           fileSearchStoreNames: storeNames,
@@ -3088,10 +3143,9 @@ function buildOpenAITools(client, toolNames, options) {
       case "fileSearch": {
         const vectorStoreIds = options?.fileSearch?.vectorStoreIds;
         if (!vectorStoreIds || vectorStoreIds.length === 0) {
-          console.warn(
+          throw new Error(
             "OpenAI fileSearch tool requires vectorStoreIds. Set providerToolOptions.fileSearch.vectorStoreIds to use this tool."
           );
-          break;
         }
         const fileSearchTool = client.tools.fileSearch({
           vectorStoreIds,
@@ -3462,6 +3516,9 @@ var LLMExecutor = class {
       const usage = await streamResult.usage;
       const reasoning = await streamResult.reasoning;
       const response = await streamResult.response;
+      if (resultStarted) {
+        callbacks.onResultComplete?.(text);
+      }
       const result = {
         text,
         toolCalls,
@@ -3665,5 +3722,5 @@ async function run(runInput, options) {
 }
 
 export { findLockfile, getLockfileExpertToolDefinitions, getModel, loadLockfile, package_default, run, runtimeStateMachine };
-//# sourceMappingURL=chunk-CFZZFSPZ.js.map
-//# sourceMappingURL=chunk-CFZZFSPZ.js.map
+//# sourceMappingURL=chunk-J26GYDJQ.js.map
+//# sourceMappingURL=chunk-J26GYDJQ.js.map