@perstack/runtime 0.0.67 → 0.0.68

package/dist/{chunk-AQSRQW5R.js → chunk-7QLRRSNX.js}

@@ -22,7 +22,7 @@ import { ApiV1Client } from '@perstack/api-client/v1';
 // package.json
 var package_default = {
   name: "@perstack/runtime",
-  version: "0.0.67",
+  version: "0.0.68",
   description: "Perstack Runtime",
   author: "Wintermute Technologies, Inc.",
   license: "Apache-2.0",
@@ -353,12 +353,15 @@ var McpSkillManager = class extends BaseSkillManager {
       name: `${this.skill.name}-mcp-client`,
       version: "1.0.0"
     });
+    let timingInfo;
     if (this.skill.type === "mcpStdioSkill") {
-      await this._initStdio(this.skill);
+      timingInfo = await this._initStdio(this.skill);
     } else {
       await this._initSse(this.skill);
     }
+    const toolDiscoveryStartTime = Date.now();
     const { tools } = await this._mcpClient.listTools();
+    const toolDiscoveryDurationMs = Date.now() - toolDiscoveryStartTime;
     this._toolDefinitions = tools.map((tool2) => ({
       skillName: this.skill.name,
       name: tool2.name,
@@ -366,6 +369,19 @@ var McpSkillManager = class extends BaseSkillManager {
       inputSchema: tool2.inputSchema,
       interactive: false
     }));
+    if (this._eventListener && timingInfo) {
+      const totalDurationMs = Date.now() - timingInfo.startTime;
+      const event = createRuntimeEvent("skillConnected", this._jobId, this._runId, {
+        skillName: this.skill.name,
+        serverInfo: timingInfo.serverInfo,
+        spawnDurationMs: timingInfo.spawnDurationMs,
+        handshakeDurationMs: timingInfo.handshakeDurationMs,
+        toolDiscoveryDurationMs,
+        connectDurationMs: timingInfo.spawnDurationMs + timingInfo.handshakeDurationMs,
+        totalDurationMs
+      });
+      this._eventListener(event);
+    }
   }
   async _initStdio(skill) {
     if (!skill.command) {
@@ -390,6 +406,7 @@ var McpSkillManager = class extends BaseSkillManager {
       this._eventListener(event);
     }
     const transport = new StdioClientTransport({ command, args, env, stderr: "pipe" });
+    const spawnDurationMs = Date.now() - startTime;
     if (transport.stderr) {
       transport.stderr.on("data", (chunk) => {
         if (this._eventListener) {
@@ -403,17 +420,14 @@ var McpSkillManager = class extends BaseSkillManager {
     }
     const connectStartTime = Date.now();
     await this._mcpClient.connect(transport);
-    const connectTime = Date.now();
-    if (this._eventListener) {
-      const serverInfo = this._mcpClient.getServerVersion();
-      const event = createRuntimeEvent("skillConnected", this._jobId, this._runId, {
-        skillName: skill.name,
-        serverInfo: serverInfo ? { name: serverInfo.name, version: serverInfo.version } : void 0,
-        connectDurationMs: connectTime - connectStartTime,
-        totalDurationMs: connectTime - startTime
-      });
-      this._eventListener(event);
-    }
+    const handshakeDurationMs = Date.now() - connectStartTime;
+    const serverVersion = this._mcpClient.getServerVersion();
+    return {
+      startTime,
+      spawnDurationMs,
+      handshakeDurationMs,
+      serverInfo: serverVersion ? { name: serverVersion.name, version: serverVersion.version } : void 0
+    };
   }
   async _initSse(skill) {
     if (!skill.endpoint) {
@@ -671,12 +685,140 @@ async function getToolSet(skillManagers) {
   }
   return tools;
 }
+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, mimeType } = fileInfo;
+    try {
+      const buffer = await readFile(path);
+      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 "${path}": ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  return { ...toolResult, result: processedContents };
+}
+var McpToolExecutor = class {
+  type = "mcp";
+  async execute(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;
+  }
+};
 
-// src/state-machine/states/calling-delegate.ts
-async function getToolType(toolName, skillManagers) {
+// src/tool-execution/executor-factory.ts
+var ToolExecutorFactory = class {
+  executors;
+  constructor() {
+    this.executors = /* @__PURE__ */ new Map([
+      ["mcp", new McpToolExecutor()]
+      // delegate and interactive are handled specially (not executed here)
+    ]);
+  }
+  /**
+   * Get the executor for a given skill type
+   */
+  getExecutor(type) {
+    return this.executors.get(type);
+  }
+  /**
+   * Execute a tool call using the appropriate executor
+   */
+  async execute(toolCall, type, skillManagers) {
+    const executor = this.executors.get(type);
+    if (!executor) {
+      throw new Error(`No executor registered for skill type: ${type}`);
+    }
+    return executor.execute(toolCall, skillManagers);
+  }
+  /**
+   * Check if a skill type can be executed locally (vs requiring delegation)
+   */
+  canExecuteLocally(type) {
+    return type === "mcp";
+  }
+};
+var toolExecutorFactory = new ToolExecutorFactory();
+
+// src/tool-execution/tool-classifier.ts
+async function getToolTypeByName(toolName, skillManagers) {
   const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
   return skillManager.type;
 }
+async function classifyToolCalls(toolCalls, skillManagers) {
+  const classified = {
+    mcp: [],
+    delegate: [],
+    interactive: []
+  };
+  const results = await Promise.all(
+    toolCalls.map(async (toolCall) => {
+      const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
+      return { toolCall, type: skillManager.type, skillManager };
+    })
+  );
+  for (const result of results) {
+    classified[result.type].push(result);
+  }
+  return classified;
+}
+
+// src/state-machine/states/calling-delegate.ts
 async function callingDelegateLogic({
   setting,
   checkpoint,
@@ -689,7 +831,7 @@ async function callingDelegateLogic({
   const toolCallTypes = await Promise.all(
     step.pendingToolCalls.map(async (tc) => ({
       toolCall: tc,
-      type: await getToolType(tc.toolName, skillManagers)
+      type: await getToolTypeByName(tc.toolName, skillManagers)
     }))
   );
   const delegateToolCalls = toolCallTypes.filter((t) => t.type === "delegate").map((t) => t.toolCall);
@@ -767,79 +909,6 @@ function hasRemainingTodos(toolResult) {
     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, mimeType } = fileInfo;
-    try {
-      const buffer = await readFile(path);
-      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 "${path}": ${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 getToolType2(toolCall, skillManagers) {
-  const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
-  return skillManager.type;
-}
 async function callingToolLogic({
   setting,
   checkpoint,
@@ -855,28 +924,26 @@ async function callingToolLogic({
     (tc) => tc.skillName === "@perstack/base" && tc.toolName === "attemptCompletion"
   );
   if (attemptCompletionTool) {
-    const toolResult = await executeMcpToolCall(attemptCompletionTool, skillManagers);
+    const toolResult = await toolExecutorFactory.execute(
+      attemptCompletionTool,
+      "mcp",
+      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 getToolType2(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 classified = await classifyToolCalls(pendingToolCalls, skillManagers);
+  if (classified.mcp.length > 0) {
     const mcpResults = await Promise.all(
-      mcpToolCalls.map((tc) => executeMcpToolCall(tc, skillManagers))
+      classified.mcp.map((c) => toolExecutorFactory.execute(c.toolCall, "mcp", skillManagers))
     );
     toolResults.push(...mcpResults);
   }
-  if (delegateToolCalls.length > 0) {
+  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, {
@@ -885,11 +952,12 @@ async function callingToolLogic({
       usage: step.usage
     });
   }
-  if (interactiveToolCalls.length > 0) {
-    const interactiveToolCall = interactiveToolCalls[0];
+  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, {
@@ -1198,7 +1266,7 @@ async function generatingRunResultLogic({
     usage
   });
 }
-async function classifyToolCalls(toolCalls, skillManagers) {
+async function classifyToolCalls2(toolCalls, skillManagers) {
   return Promise.all(
     toolCalls.map(async (tc) => {
       const skillManager = await getSkillManagerByToolName(skillManagers, tc.toolName);
@@ -1275,7 +1343,7 @@ async function generatingToolCallLogic({
       usage
     });
   }
-  const classified = await classifyToolCalls(toolCalls, skillManagers);
+  const classified = await classifyToolCalls2(toolCalls, skillManagers);
   const sorted = sortToolCallsByPriority(classified);
   if (finishReason === "tool-calls" || finishReason === "stop") {
     const toolCallParts = buildToolCallParts(sorted);
@@ -1963,29 +2031,6 @@ async function executeStateMachine(params) {
     runActor.start();
   });
 }
-var RunEventEmitter = class {
-  listeners = [];
-  subscribe(listener) {
-    this.listeners.push(listener);
-  }
-  async emit(event) {
-    const errors = [];
-    for (const listener of this.listeners) {
-      try {
-        await listener({
-          ...event,
-          id: createId(),
-          timestamp: Date.now()
-        });
-      } catch (error) {
-        errors.push(error instanceof Error ? error : new Error(String(error)));
-      }
-    }
-    if (errors.length > 0) {
-      throw new AggregateError(errors, "One or more event listeners failed");
-    }
-  }
-};
 
 // src/helpers/checkpoint.ts
 function createInitialCheckpoint(checkpointId, params) {
@@ -2049,46 +2094,6 @@ function buildDelegationReturnState(currentSetting, resultCheckpoint, parentChec
     }
   };
 }
-function buildDelegateToState(currentSetting, resultCheckpoint, currentExpert) {
-  const { delegateTo } = resultCheckpoint;
-  if (!delegateTo || delegateTo.length === 0) {
-    throw new Error("delegateTo is required for buildDelegateToState");
-  }
-  const firstDelegation = delegateTo[0];
-  const { expert, toolCallId, toolName, query } = firstDelegation;
-  return {
-    setting: {
-      ...currentSetting,
-      expertKey: expert.key,
-      input: {
-        text: query
-      }
-    },
-    checkpoint: {
-      ...resultCheckpoint,
-      status: "init",
-      messages: [],
-      expert: {
-        key: expert.key,
-        name: expert.name,
-        version: expert.version
-      },
-      delegatedBy: {
-        expert: {
-          key: currentExpert.key,
-          name: currentExpert.name,
-          version: currentExpert.version
-        },
-        toolCallId,
-        toolName,
-        checkpointId: resultCheckpoint.id
-      },
-      usage: resultCheckpoint.usage,
-      pendingToolCalls: void 0,
-      partialToolResults: void 0
-    }
-  };
-}
 async function resolveExpertToRun(expertKey, experts, clientOptions) {
   if (experts[expertKey]) {
     return experts[expertKey];
@@ -2138,68 +2143,245 @@ async function setupExperts(setting, resolveExpertToRun2 = resolveExpertToRun) {
   }
   return { expertToRun, experts };
 }
-
-// src/run.ts
-var noopStoreCheckpoint = async () => {
-};
-var noopStoreEvent = async () => {
-};
-var noopStoreJob = () => {
+var SingleDelegationStrategy = class {
+  async execute(delegations, setting, context, parentExpert, _runFn, _parentOptions) {
+    if (delegations.length !== 1) {
+      throw new Error("SingleDelegationStrategy requires exactly one delegation");
+    }
+    const delegation = delegations[0];
+    const { expert, toolCallId, toolName, query } = delegation;
+    const nextSetting = {
+      ...setting,
+      expertKey: expert.key,
+      input: { text: query }
+    };
+    const nextCheckpoint = {
+      id: context.id,
+      jobId: setting.jobId,
+      runId: setting.runId,
+      status: "init",
+      stepNumber: context.stepNumber,
+      messages: [],
+      // Child starts fresh
+      expert: {
+        key: expert.key,
+        name: expert.name,
+        version: expert.version
+      },
+      delegatedBy: {
+        expert: {
+          key: parentExpert.key,
+          name: parentExpert.name,
+          version: parentExpert.version
+        },
+        toolCallId,
+        toolName,
+        checkpointId: context.id
+      },
+      usage: context.usage,
+      contextWindow: context.contextWindow,
+      pendingToolCalls: void 0,
+      partialToolResults: void 0
+    };
+    return { nextSetting, nextCheckpoint };
+  }
 };
-var noopRetrieveJob = () => void 0;
-var noopRetrieveCheckpoint = async (_jobId, _checkpointId) => {
-  throw new Error("retrieveCheckpoint not provided");
+var ParallelDelegationStrategy = class {
+  async execute(delegations, setting, context, parentExpert, runFn, parentOptions) {
+    if (delegations.length < 2) {
+      throw new Error("ParallelDelegationStrategy requires at least two delegations");
+    }
+    const [firstDelegation, ...remainingDelegations] = delegations;
+    if (!firstDelegation) {
+      throw new Error("No delegations found");
+    }
+    const allResults = await Promise.all(
+      delegations.map(
+        (delegation) => this.executeSingleDelegation(
+          delegation,
+          setting,
+          context,
+          parentExpert,
+          runFn,
+          parentOptions
+        )
+      )
+    );
+    const [firstResult, ...restResults] = allResults;
+    if (!firstResult) {
+      throw new Error("No delegation results");
+    }
+    const aggregatedUsage = allResults.reduce(
+      (acc, result) => sumUsage(acc, result.deltaUsage),
+      context.usage
+    );
+    const maxStepNumber = Math.max(...allResults.map((r) => r.stepNumber));
+    const restToolResults = restResults.map((result) => ({
+      id: result.toolCallId,
+      skillName: `delegate/${result.expertKey}`,
+      toolName: result.toolName,
+      result: [{ type: "textPart", id: createId(), text: result.text }]
+    }));
+    const processedToolCallIds = new Set(remainingDelegations.map((d) => d.toolCallId));
+    const remainingPendingToolCalls = context.pendingToolCalls?.filter(
+      (tc) => !processedToolCallIds.has(tc.id) && tc.id !== firstDelegation.toolCallId
+    );
+    const nextSetting = {
+      ...setting,
+      expertKey: parentExpert.key,
+      input: {
+        interactiveToolCallResult: {
+          toolCallId: firstResult.toolCallId,
+          toolName: firstResult.toolName,
+          skillName: `delegate/${firstResult.expertKey}`,
+          text: firstResult.text
+        }
+      }
+    };
+    const nextCheckpoint = {
+      id: context.id,
+      jobId: setting.jobId,
+      runId: setting.runId,
+      status: "stoppedByDelegate",
+      stepNumber: maxStepNumber,
+      messages: context.messages,
+      // Restore parent's conversation history
+      expert: {
+        key: parentExpert.key,
+        name: parentExpert.name,
+        version: parentExpert.version
+      },
+      usage: aggregatedUsage,
+      contextWindow: context.contextWindow,
+      delegatedBy: context.delegatedBy,
+      // Preserve parent reference for nested delegations
+      delegateTo: void 0,
+      pendingToolCalls: remainingPendingToolCalls?.length ? remainingPendingToolCalls : void 0,
+      partialToolResults: [...context.partialToolResults ?? [], ...restToolResults]
+    };
+    return { nextSetting, nextCheckpoint };
+  }
+  async executeSingleDelegation(delegation, parentSetting, parentContext, parentExpert, runFn, parentOptions) {
+    const { expert, toolCallId, toolName, query } = delegation;
+    const delegateRunId = createId();
+    const delegateSetting = {
+      ...parentSetting,
+      runId: delegateRunId,
+      expertKey: expert.key,
+      input: { text: query }
+    };
+    const delegateCheckpoint = {
+      id: createId(),
+      jobId: parentSetting.jobId,
+      runId: delegateRunId,
+      status: "init",
+      stepNumber: parentContext.stepNumber,
+      messages: [],
+      // Child starts fresh - no parent context inheritance
+      expert: {
+        key: expert.key,
+        name: expert.name,
+        version: expert.version
+      },
+      delegatedBy: {
+        expert: {
+          key: parentExpert.key,
+          name: parentExpert.name,
+          version: parentExpert.version
+        },
+        toolCallId,
+        toolName,
+        checkpointId: parentContext.id
+      },
+      usage: createEmptyUsage(),
+      contextWindow: parentContext.contextWindow
+    };
+    const resultCheckpoint = await runFn(
+      { setting: delegateSetting, checkpoint: delegateCheckpoint },
+      { ...parentOptions, returnOnDelegationComplete: true }
+    );
+    return this.extractDelegationResult(resultCheckpoint, toolCallId, toolName, expert.key);
+  }
+  extractDelegationResult(checkpoint, toolCallId, toolName, expertKey) {
+    const lastMessage = checkpoint.messages[checkpoint.messages.length - 1];
+    if (!lastMessage || lastMessage.type !== "expertMessage") {
+      throw new Error("Delegation error: delegation result message is incorrect");
+    }
+    const textPart = lastMessage.contents.find((c) => c.type === "textPart");
+    if (!textPart || textPart.type !== "textPart") {
+      throw new Error("Delegation error: delegation result message does not contain text");
+    }
+    return {
+      toolCallId,
+      toolName,
+      expertKey,
+      text: textPart.text,
+      stepNumber: checkpoint.stepNumber,
+      deltaUsage: checkpoint.usage
+    };
+  }
 };
-var defaultCreateJob = (jobId, expertKey, maxSteps) => ({
-  id: jobId,
-  coordinatorExpertKey: expertKey,
-  status: "running",
-  totalSteps: 0,
-  startedAt: Date.now(),
-  maxSteps,
-  usage: createEmptyUsage()
-});
-async function run(runInput, options) {
-  const runParams = runParamsSchema.parse(runInput);
-  const storeCheckpoint = options?.storeCheckpoint ?? noopStoreCheckpoint;
-  const storeEvent = options?.storeEvent ?? noopStoreEvent;
-  const storeJob = options?.storeJob ?? noopStoreJob;
-  const retrieveJob = options?.retrieveJob ?? noopRetrieveJob;
-  const retrieveCheckpoint = options?.retrieveCheckpoint ?? noopRetrieveCheckpoint;
-  const createJob = options?.createJob ?? defaultCreateJob;
-  const eventListener = createEventListener(options?.eventListener, storeEvent);
-  const eventEmitter = new RunEventEmitter();
-  eventEmitter.subscribe(eventListener);
-  let { setting, checkpoint } = runParams;
-  const contextWindow = getContextWindow(setting.providerConfig.providerName, setting.model);
-  let job = retrieveJob(setting.jobId) ?? createJob(setting.jobId, setting.expertKey, setting.maxSteps);
-  if (job.status !== "running") {
-    job = { ...job, status: "running", finishedAt: void 0 };
+function selectDelegationStrategy(delegationCount) {
+  if (delegationCount === 1) {
+    return new SingleDelegationStrategy();
   }
-  storeJob(job);
-  while (true) {
-    const { expertToRun, experts } = await setupExperts(setting, options?.resolveExpertToRun);
-    if (options?.eventListener) {
-      const initEvent = createRuntimeEvent("initializeRuntime", setting.jobId, setting.runId, {
-        runtimeVersion: package_default.version,
-        runtime: "local",
-        expertName: expertToRun.name,
-        experts: Object.keys(experts),
-        model: setting.model,
-        temperature: setting.temperature,
-        maxSteps: setting.maxSteps,
-        maxRetries: setting.maxRetries,
-        timeout: setting.timeout,
-        query: setting.input.text,
-        interactiveToolCall: setting.input.interactiveToolCallResult
-      });
-      options.eventListener(initEvent);
+  return new ParallelDelegationStrategy();
+}
+function buildReturnFromDelegation(currentSetting, resultCheckpoint, parentCheckpoint) {
+  return buildDelegationReturnState(currentSetting, resultCheckpoint, parentCheckpoint);
+}
+function extractDelegationContext(checkpoint) {
+  return {
+    id: checkpoint.id,
+    stepNumber: checkpoint.stepNumber,
+    contextWindow: checkpoint.contextWindow,
+    usage: checkpoint.usage,
+    pendingToolCalls: checkpoint.pendingToolCalls,
+    partialToolResults: checkpoint.partialToolResults,
+    delegatedBy: checkpoint.delegatedBy,
+    // Preserve for nested delegations
+    messages: checkpoint.messages
+    // Preserve for parent continuation after delegation
+  };
+}
+var RunEventEmitter = class {
+  listeners = [];
+  subscribe(listener) {
+    this.listeners.push(listener);
+  }
+  async emit(event) {
+    const errors = [];
+    for (const listener of this.listeners) {
+      try {
+        await listener({
+          ...event,
+          id: createId(),
+          timestamp: Date.now()
+        });
+      } catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "One or more event listeners failed");
     }
+  }
+};
+
+// src/orchestration/single-run-executor.ts
+var SingleRunExecutor = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async execute(setting, checkpoint) {
+    const contextWindow = getContextWindow(setting.providerConfig.providerName, setting.model);
+    const { expertToRun, experts } = await setupExperts(setting, this.options.resolveExpertToRun);
+    this.emitInitEvent(setting, expertToRun, experts);
     const skillManagers = await getSkillManagers(
       expertToRun,
       experts,
       setting,
-      options?.eventListener,
+      this.options.eventListener,
       { isDelegatedRun: !!checkpoint?.delegatedBy }
     );
     const initialCheckpoint = checkpoint ? createNextStepCheckpoint(createId(), checkpoint) : createInitialCheckpoint(createId(), {
@@ -2209,183 +2391,148 @@ async function run(runInput, options) {
       expert: expertToRun,
       contextWindow
     });
-    const runResultCheckpoint = await executeStateMachine({
+    const eventEmitter = new RunEventEmitter();
+    const eventListener = this.createEventListener();
+    eventEmitter.subscribe(eventListener);
+    const resultCheckpoint = await executeStateMachine({
       setting: { ...setting, experts },
       initialCheckpoint,
       eventListener,
       skillManagers,
       eventEmitter,
-      storeCheckpoint,
-      shouldContinueRun: options?.shouldContinueRun
+      storeCheckpoint: this.options.storeCheckpoint ?? (async () => {
+      }),
+      shouldContinueRun: this.options.shouldContinueRun
+    });
+    return { checkpoint: resultCheckpoint, expertToRun, experts };
+  }
+  createEventListener() {
+    const userListener = this.options.eventListener;
+    const storeEvent = this.options.storeEvent;
+    return async (event) => {
+      if ("stepNumber" in event && storeEvent) {
+        await storeEvent(event);
+      }
+      userListener?.(event);
+    };
+  }
+  emitInitEvent(setting, expertToRun, experts) {
+    if (!this.options.eventListener) return;
+    const initEvent = createRuntimeEvent("initializeRuntime", setting.jobId, setting.runId, {
+      runtimeVersion: package_default.version,
+      runtime: "local",
+      expertName: expertToRun.name,
+      experts: Object.keys(experts),
+      model: setting.model,
+      temperature: setting.temperature,
+      maxSteps: setting.maxSteps,
+      maxRetries: setting.maxRetries,
+      timeout: setting.timeout,
+      query: setting.input.text,
+      interactiveToolCall: setting.input.interactiveToolCallResult
     });
+    this.options.eventListener(initEvent);
+  }
+};
+
+// src/run.ts
+var defaultCreateJob = (jobId, expertKey, maxSteps) => ({
+  id: jobId,
+  coordinatorExpertKey: expertKey,
+  status: "running",
+  totalSteps: 0,
+  startedAt: Date.now(),
+  maxSteps,
+  usage: createEmptyUsage()
+});
+async function run(runInput, options) {
+  const runParams = runParamsSchema.parse(runInput);
+  let { setting, checkpoint } = runParams;
+  const storeJob = options?.storeJob ?? (() => {
+  });
+  const retrieveJob = options?.retrieveJob ?? (() => void 0);
+  const retrieveCheckpoint = options?.retrieveCheckpoint ?? (async () => {
+    throw new Error("retrieveCheckpoint not provided");
+  });
+  const createJob = options?.createJob ?? defaultCreateJob;
+  let job = retrieveJob(setting.jobId) ?? createJob(setting.jobId, setting.expertKey, setting.maxSteps);
+  if (job.status !== "running") {
+    job = { ...job, status: "running", finishedAt: void 0 };
+  }
+  storeJob(job);
+  const runExecutor = new SingleRunExecutor({
+    shouldContinueRun: options?.shouldContinueRun,
+    storeCheckpoint: options?.storeCheckpoint,
+    storeEvent: options?.storeEvent,
+    eventListener: options?.eventListener,
+    resolveExpertToRun: options?.resolveExpertToRun
+  });
+  while (true) {
+    const runResult = await runExecutor.execute(setting, checkpoint);
+    const resultCheckpoint = runResult.checkpoint;
     job = {
       ...job,
-      totalSteps: runResultCheckpoint.stepNumber,
-      usage: runResultCheckpoint.usage
+      totalSteps: resultCheckpoint.stepNumber,
+      usage: resultCheckpoint.usage
     };
-    switch (runResultCheckpoint.status) {
+    switch (resultCheckpoint.status) {
       case "completed": {
         if (options?.returnOnDelegationComplete) {
           storeJob(job);
-          return runResultCheckpoint;
+          return resultCheckpoint;
         }
-        if (runResultCheckpoint.delegatedBy) {
+        if (resultCheckpoint.delegatedBy) {
           storeJob(job);
           const parentCheckpoint = await retrieveCheckpoint(
             setting.jobId,
-            runResultCheckpoint.delegatedBy.checkpointId
+            resultCheckpoint.delegatedBy.checkpointId
           );
-          const result = buildDelegationReturnState(setting, runResultCheckpoint, parentCheckpoint);
+          const result = buildReturnFromDelegation(setting, resultCheckpoint, parentCheckpoint);
           setting = result.setting;
           checkpoint = result.checkpoint;
           break;
         }
         storeJob({ ...job, status: "completed", finishedAt: Date.now() });
-        return runResultCheckpoint;
+        return resultCheckpoint;
       }
       case "stoppedByInteractiveTool": {
         storeJob({ ...job, status: "stoppedByInteractiveTool" });
-        return runResultCheckpoint;
+        return resultCheckpoint;
       }
       case "stoppedByDelegate": {
         storeJob(job);
-        const { delegateTo } = runResultCheckpoint;
+        const { delegateTo } = resultCheckpoint;
         if (!delegateTo || delegateTo.length === 0) {
           throw new Error("No delegations found in checkpoint");
         }
-        if (delegateTo.length === 1) {
-          const result = buildDelegateToState(setting, runResultCheckpoint, expertToRun);
-          setting = result.setting;
-          checkpoint = result.checkpoint;
-          break;
-        }
-        const firstDelegation = delegateTo[0];
-        const remainingDelegations = delegateTo.slice(1);
-        const [firstResult, ...restResults] = await Promise.all(
-          delegateTo.map(
-            (delegation) => runDelegate(delegation, setting, runResultCheckpoint, expertToRun, options)
-          )
-        );
-        const allResults = [firstResult, ...restResults];
-        const aggregatedUsage = allResults.reduce(
-          (acc, result) => sumUsage(acc, result.deltaUsage),
-          runResultCheckpoint.usage
-        );
-        const maxStepNumber = Math.max(...allResults.map((r) => r.stepNumber));
-        const restToolResults = restResults.map((result) => ({
-          id: result.toolCallId,
-          skillName: `delegate/${result.expertKey}`,
-          toolName: result.toolName,
-          result: [{ type: "textPart", id: createId(), text: result.text }]
-        }));
-        const processedToolCallIds = new Set(remainingDelegations.map((d) => d.toolCallId));
-        const remainingToolCalls = runResultCheckpoint.pendingToolCalls?.filter(
-          (tc) => !processedToolCallIds.has(tc.id) && tc.id !== firstDelegation.toolCallId
+        const strategy = selectDelegationStrategy(delegateTo.length);
+        const context = extractDelegationContext(resultCheckpoint);
+        const delegationResult = await strategy.execute(
+          delegateTo,
+          setting,
+          context,
+          runResult.expertToRun,
+          run,
+          options
         );
-        setting = {
-          ...setting,
-          expertKey: expertToRun.key,
-          input: {
-            interactiveToolCallResult: {
-              toolCallId: firstResult.toolCallId,
-              toolName: firstResult.toolName,
-              skillName: `delegate/${firstResult.expertKey}`,
-              text: firstResult.text
-            }
-          }
-        };
-        checkpoint = {
-          ...runResultCheckpoint,
-          status: "stoppedByDelegate",
-          delegateTo: void 0,
-          stepNumber: maxStepNumber,
-          usage: aggregatedUsage,
-          pendingToolCalls: remainingToolCalls?.length ? remainingToolCalls : void 0,
-          partialToolResults: [
-            ...runResultCheckpoint.partialToolResults ?? [],
-            ...restToolResults
-          ]
-        };
+        setting = delegationResult.nextSetting;
+        checkpoint = delegationResult.nextCheckpoint;
         break;
       }
       case "stoppedByExceededMaxSteps": {
         storeJob({ ...job, status: "stoppedByMaxSteps", finishedAt: Date.now() });
-        return runResultCheckpoint;
+        return resultCheckpoint;
       }
       case "stoppedByError": {
         storeJob({ ...job, status: "stoppedByError", finishedAt: Date.now() });
-        return runResultCheckpoint;
+        return resultCheckpoint;
       }
       default:
         throw new Error("Run stopped by unknown reason");
     }
   }
 }
-function createEventListener(userListener, storeEvent) {
-  const listener = userListener ?? ((e) => console.log(JSON.stringify(e)));
-  return async (event) => {
-    if ("stepNumber" in event && storeEvent) {
-      await storeEvent(event);
-    }
-    listener(event);
-  };
-}
-async function runDelegate(delegation, parentSetting, parentCheckpoint, parentExpert, options) {
-  const { expert, toolCallId, toolName, query } = delegation;
-  const delegateRunId = createId();
-  const delegateSetting = {
-    ...parentSetting,
-    runId: delegateRunId,
-    expertKey: expert.key,
-    input: { text: query }
-  };
-  const delegateCheckpoint = {
-    id: createId(),
-    jobId: parentSetting.jobId,
-    runId: delegateRunId,
-    status: "init",
-    stepNumber: parentCheckpoint.stepNumber,
-    messages: [],
-    expert: {
-      key: expert.key,
-      name: expert.name,
-      version: expert.version
-    },
-    delegatedBy: {
-      expert: {
-        key: parentExpert.key,
-        name: parentExpert.name,
-        version: parentExpert.version
-      },
-      toolCallId,
-      toolName,
-      checkpointId: parentCheckpoint.id
-    },
-    usage: createEmptyUsage(),
-    contextWindow: parentCheckpoint.contextWindow
-  };
-  const resultCheckpoint = await run(
-    { setting: delegateSetting, checkpoint: delegateCheckpoint },
-    { ...options, returnOnDelegationComplete: true }
-  );
-  const lastMessage = resultCheckpoint.messages[resultCheckpoint.messages.length - 1];
-  if (!lastMessage || lastMessage.type !== "expertMessage") {
-    throw new Error("Delegation error: delegation result message is incorrect");
-  }
-  const textPart = lastMessage.contents.find((c) => c.type === "textPart");
-  if (!textPart || textPart.type !== "textPart") {
-    throw new Error("Delegation error: delegation result message does not contain text");
-  }
-  return {
-    toolCallId,
-    toolName,
-    expertKey: expert.key,
-    text: textPart.text,
-    stepNumber: resultCheckpoint.stepNumber,
-    deltaUsage: resultCheckpoint.usage
-  };
-}
 
 export { getModel, package_default, run, runtimeStateMachine };
-//# sourceMappingURL=chunk-AQSRQW5R.js.map
-//# sourceMappingURL=chunk-AQSRQW5R.js.map
+//# sourceMappingURL=chunk-7QLRRSNX.js.map
+//# sourceMappingURL=chunk-7QLRRSNX.js.map