@perstack/runtime 0.0.67 → 0.0.69

package/dist/{chunk-AQSRQW5R.js → chunk-H65LPOAK.js}

@@ -11,10 +11,10 @@ import { ProxyAgent, fetch } from 'undici';
 import { setup, assign, createActor } from 'xstate';
 import { generateText, tool, jsonSchema } from 'ai';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
 import { createId } from '@paralleldrive/cuid2';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { readFile } from 'fs/promises';
 import { dedent } from 'ts-dedent';
 import { ApiV1Client } from '@perstack/api-client/v1';
@@ -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.69",
   description: "Perstack Runtime",
   author: "Wintermute Technologies, Inc.",
   license: "Apache-2.0",
@@ -54,9 +54,6 @@ var package_default = {
     typecheck: "tsc --noEmit"
   },
   dependencies: {
-    commander: "^14.0.2",
-    dotenv: "^17.2.3",
-    "smol-toml": "^1.5.2",
     "@ai-sdk/amazon-bedrock": "^3.0.62",
     "@ai-sdk/anthropic": "^2.0.50",
     "@ai-sdk/azure": "^2.0.77",
@@ -69,14 +66,18 @@ var package_default = {
     "@perstack/api-client": "workspace:*",
     "@perstack/core": "workspace:*",
     ai: "^5.0.104",
+    commander: "^14.0.2",
+    dotenv: "^17.2.3",
     "ollama-ai-provider-v2": "^1.5.5",
+    "smol-toml": "^1.5.2",
     "ts-dedent": "^2.2.0",
-    xstate: "^5.24.0",
-    undici: "^7.9.0"
+    undici: "^7.9.0",
+    xstate: "^5.24.0"
   },
   devDependencies: {
     "@tsconfig/node22": "^22.0.5",
     "@types/node": "^24.10.1",
+    memfs: "^4.51.1",
     tsup: "^8.5.1",
     typescript: "^5.9.3",
     vitest: "^4.0.14"
@@ -260,11 +261,11 @@ var BaseSkillManager = class {
     this._initializing = void 0;
   }
   async getToolDefinitions() {
-    if (!this.isInitialized() && !this.lazyInit) {
-      throw new Error(`Skill ${this.name} is not initialized`);
+    if (!this.isInitialized() && this._initializing) {
+      await this._initializing;
     }
-    if (!this.isInitialized() && this.lazyInit) {
-      return [];
+    if (!this.isInitialized()) {
+      throw new Error(`Skill ${this.name} is not initialized`);
     }
     return this._filterTools(this._toolDefinitions);
   }
@@ -273,6 +274,22 @@ var BaseSkillManager = class {
   }
 };
 
+// src/skill-manager/command-args.ts
+function getCommandArgs(skill) {
+  const { name, command, packageName, args } = skill;
+  if (!packageName && (!args || args.length === 0)) {
+    throw new Error(`Skill ${name} has no packageName or args. Please provide one of them.`);
+  }
+  if (packageName && args && args.length > 0) {
+    throw new Error(`Skill ${name} has both packageName and args. Please provide only one of them.`);
+  }
+  let newArgs = args && args.length > 0 ? args : [packageName];
+  if (command === "npx" && !newArgs.includes("-y")) {
+    newArgs = ["-y", ...newArgs];
+  }
+  return { command, args: newArgs };
+}
+
 // src/skill-manager/delegate.ts
 var DelegateSkillManager = class extends BaseSkillManager {
   name;
@@ -334,6 +351,114 @@ var InteractiveSkillManager = class extends BaseSkillManager {
     return [];
   }
 };
+
+// src/skill-manager/ip-validator.ts
+function isPrivateOrLocalIP(hostname) {
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "0.0.0.0") {
+    return true;
+  }
+  const ipv4Match = hostname.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+  if (ipv4Match) {
+    const [, a, b] = ipv4Match.map(Number);
+    if (a === 10) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 169 && b === 254) return true;
+    if (a === 127) return true;
+  }
+  if (hostname.includes(":")) {
+    if (hostname.startsWith("fe80:")) return true;
+    if (hostname.startsWith("fc") || hostname.startsWith("fd")) return true;
+  }
+  if (hostname.startsWith("::ffff:")) {
+    const ipv4Part = hostname.slice(7);
+    if (isPrivateOrLocalIP(ipv4Part)) {
+      return true;
+    }
+  }
+  return false;
+}
+function handleToolError(error, toolName, McpErrorClass) {
+  if (error instanceof McpErrorClass) {
+    return [
+      {
+        type: "textPart",
+        text: `Error calling tool ${toolName}: ${error.message}`,
+        id: createId()
+      }
+    ];
+  }
+  throw error;
+}
+function convertToolResult(result, toolName, input) {
+  if (!result.content || result.content.length === 0) {
+    return [
+      {
+        type: "textPart",
+        text: `Tool ${toolName} returned nothing with arguments: ${JSON.stringify(input)}`,
+        id: createId()
+      }
+    ];
+  }
+  return result.content.filter((part) => part.type !== "audio" && part.type !== "resource_link").map((part) => convertPart(part));
+}
+function convertPart(part) {
+  switch (part.type) {
+    case "text":
+      if (!part.text || part.text === "") {
+        return { type: "textPart", text: "Error: No content", id: createId() };
+      }
+      return { type: "textPart", text: part.text, id: createId() };
+    case "image":
+      if (!part.data || !part.mimeType) {
+        throw new Error("Image part must have both data and mimeType");
+      }
+      return {
+        type: "imageInlinePart",
+        encodedData: part.data,
+        mimeType: part.mimeType,
+        id: createId()
+      };
+    case "resource":
+      if (!part.resource) {
+        throw new Error("Resource part must have resource content");
+      }
+      return convertResource(part.resource);
+  }
+}
+function convertResource(resource) {
+  if (!resource.mimeType) {
+    throw new Error(`Resource ${JSON.stringify(resource)} has no mimeType`);
+  }
+  if (resource.text && typeof resource.text === "string") {
+    return { type: "textPart", text: resource.text, id: createId() };
+  }
+  if (resource.blob && typeof resource.blob === "string") {
+    return {
+      type: "fileInlinePart",
+      encodedData: resource.blob,
+      mimeType: resource.mimeType,
+      id: createId()
+    };
+  }
+  throw new Error(`Unsupported resource type: ${JSON.stringify(resource)}`);
+}
+var DefaultTransportFactory = class {
+  createStdio(options) {
+    return new StdioClientTransport({
+      command: options.command,
+      args: options.args,
+      env: options.env,
+      stderr: options.stderr
+    });
+  }
+  createSse(options) {
+    return new SSEClientTransport(options.url);
+  }
+};
+var defaultTransportFactory = new DefaultTransportFactory();
+
+// src/skill-manager/mcp.ts
 var McpSkillManager = class extends BaseSkillManager {
   name;
   type = "mcp";
@@ -341,11 +466,13 @@ var McpSkillManager = class extends BaseSkillManager {
   skill;
   _mcpClient;
   _env;
-  constructor(skill, env, jobId, runId, eventListener) {
+  _transportFactory;
+  constructor(skill, env, jobId, runId, eventListener, options) {
     super(jobId, runId, eventListener);
     this.name = skill.name;
     this.skill = skill;
     this._env = env;
+    this._transportFactory = options?.transportFactory ?? defaultTransportFactory;
     this.lazyInit = skill.type === "mcpStdioSkill" && skill.lazyInit && skill.name !== "@perstack/base";
   }
   async _doInit() {
@@ -353,12 +480,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 +496,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) {
@@ -380,7 +523,7 @@ var McpSkillManager = class extends BaseSkillManager {
     }
     const env = getFilteredEnv(requiredEnv);
     const startTime = Date.now();
-    const { command, args } = this._getCommandArgs(skill);
+    const { command, args } = getCommandArgs(skill);
     if (this._eventListener) {
       const event = createRuntimeEvent("skillStarting", this._jobId, this._runId, {
         skillName: skill.name,
@@ -389,7 +532,8 @@ var McpSkillManager = class extends BaseSkillManager {
       });
       this._eventListener(event);
     }
-    const transport = new StdioClientTransport({ command, args, env, stderr: "pipe" });
+    const transport = this._transportFactory.createStdio({ command, args, env, stderr: "pipe" });
+    const spawnDurationMs = Date.now() - startTime;
     if (transport.stderr) {
       transport.stderr.on("data", (chunk) => {
         if (this._eventListener) {
@@ -403,17 +547,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) {
@@ -423,56 +564,14 @@ var McpSkillManager = class extends BaseSkillManager {
     if (url.protocol !== "https:") {
       throw new Error(`Skill ${skill.name} SSE endpoint must use HTTPS: ${skill.endpoint}`);
     }
-    if (this._isPrivateOrLocalIP(url.hostname)) {
+    if (isPrivateOrLocalIP(url.hostname)) {
       throw new Error(
         `Skill ${skill.name} SSE endpoint cannot use private/local IP: ${skill.endpoint}`
       );
     }
-    const transport = new SSEClientTransport(url);
+    const transport = this._transportFactory.createSse({ url });
     await this._mcpClient.connect(transport);
   }
-  _isPrivateOrLocalIP(hostname) {
-    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "0.0.0.0") {
-      return true;
-    }
-    const ipv4Match = hostname.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
-    if (ipv4Match) {
-      const [, a, b] = ipv4Match.map(Number);
-      if (a === 10) return true;
-      if (a === 172 && b >= 16 && b <= 31) return true;
-      if (a === 192 && b === 168) return true;
-      if (a === 169 && b === 254) return true;
-      if (a === 127) return true;
-    }
-    if (hostname.includes(":")) {
-      if (hostname.startsWith("fe80:") || hostname.startsWith("fc") || hostname.startsWith("fd")) {
-        return true;
-      }
-    }
-    if (hostname.startsWith("::ffff:")) {
-      const ipv4Part = hostname.slice(7);
-      if (this._isPrivateOrLocalIP(ipv4Part)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  _getCommandArgs(skill) {
-    const { name, command, packageName, args } = skill;
-    if (!packageName && (!args || args.length === 0)) {
-      throw new Error(`Skill ${name} has no packageName or args. Please provide one of them.`);
-    }
-    if (packageName && args && args.length > 0) {
-      throw new Error(
-        `Skill ${name} has both packageName and args. Please provide only one of them.`
-      );
-    }
-    let newArgs = args && args.length > 0 ? args : [packageName];
-    if (command === "npx" && !newArgs.includes("-y")) {
-      newArgs = ["-y", ...newArgs];
-    }
-    return { command, args: newArgs };
-  }
   async close() {
     if (this._mcpClient) {
       await this._mcpClient.close();
@@ -498,77 +597,33 @@ var McpSkillManager = class extends BaseSkillManager {
         name: toolName,
         arguments: input
       });
-      return this._convertToolResult(result, toolName, input);
+      return convertToolResult(result, toolName, input);
     } catch (error) {
-      return this._handleToolError(error, toolName);
+      return handleToolError(error, toolName, McpError);
     }
   }
-  _handleToolError(error, toolName) {
-    if (error instanceof McpError) {
-      return [
-        {
-          type: "textPart",
-          text: `Error calling tool ${toolName}: ${error.message}`,
-          id: createId()
-        }
-      ];
-    }
-    throw error;
+};
+
+// src/skill-manager/skill-manager-factory.ts
+var DefaultSkillManagerFactory = class {
+  createMcp(skill, context) {
+    return new McpSkillManager(
+      skill,
+      context.env,
+      context.jobId,
+      context.runId,
+      context.eventListener,
+      context.mcpOptions
+    );
   }
-  _convertToolResult(result, toolName, input) {
-    if (!result.content || result.content.length === 0) {
-      return [
-        {
-          type: "textPart",
-          text: `Tool ${toolName} returned nothing with arguments: ${JSON.stringify(input)}`,
-          id: createId()
-        }
-      ];
-    }
-    return result.content.filter((part) => part.type !== "audio" && part.type !== "resource_link").map((part) => this._convertPart(part));
+  createInteractive(skill, context) {
+    return new InteractiveSkillManager(skill, context.jobId, context.runId, context.eventListener);
   }
-  _convertPart(part) {
-    switch (part.type) {
-      case "text":
-        if (!part.text || part.text === "") {
-          return { type: "textPart", text: "Error: No content", id: createId() };
-        }
-        return { type: "textPart", text: part.text, id: createId() };
-      case "image":
-        if (!part.data || !part.mimeType) {
-          throw new Error("Image part must have both data and mimeType");
-        }
-        return {
-          type: "imageInlinePart",
-          encodedData: part.data,
-          mimeType: part.mimeType,
-          id: createId()
-        };
-      case "resource":
-        if (!part.resource) {
-          throw new Error("Resource part must have resource content");
-        }
-        return this._convertResource(part.resource);
-    }
-  }
-  _convertResource(resource) {
-    if (!resource.mimeType) {
-      throw new Error(`Resource ${JSON.stringify(resource)} has no mimeType`);
-    }
-    if (resource.text && typeof resource.text === "string") {
-      return { type: "textPart", text: resource.text, id: createId() };
-    }
-    if (resource.blob && typeof resource.blob === "string") {
-      return {
-        type: "fileInlinePart",
-        encodedData: resource.blob,
-        mimeType: resource.mimeType,
-        id: createId()
-      };
-    }
-    throw new Error(`Unsupported resource type: ${JSON.stringify(resource)}`);
+  createDelegate(expert, context) {
+    return new DelegateSkillManager(expert, context.jobId, context.runId, context.eventListener);
   }
 };
+var defaultSkillManagerFactory = new DefaultSkillManagerFactory();
 
 // src/skill-manager/helpers.ts
 async function initSkillManagersWithCleanup(managers, allManagers) {
@@ -583,11 +638,20 @@ async function initSkillManagersWithCleanup(managers, allManagers) {
 async function getSkillManagers(expert, experts, setting, eventListener, options) {
   const { perstackBaseSkillCommand, env, jobId, runId } = setting;
   const { skills } = expert;
+  const factory = options?.factory ?? defaultSkillManagerFactory;
   if (!skills["@perstack/base"]) {
     throw new Error("Base skill is not defined");
   }
+  const factoryContext = {
+    env,
+    jobId,
+    runId,
+    eventListener
+  };
   const allManagers = [];
-  const mcpSkills = Object.values(skills).filter((skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill").map((skill) => {
+  const mcpSkills = Object.values(skills).filter(
+    (skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill"
+  ).map((skill) => {
     if (perstackBaseSkillCommand && skill.type === "mcpStdioSkill") {
       const matchesBaseByPackage = skill.command === "npx" && skill.packageName === "@perstack/base";
       const matchesBaseByArgs = skill.command === "npx" && Array.isArray(skill.args) && skill.args.includes("@perstack/base");
@@ -608,7 +672,7 @@ async function getSkillManagers(expert, experts, setting, eventListener, options
     return skill;
   });
   const mcpSkillManagers = mcpSkills.map((skill) => {
-    const manager = new McpSkillManager(skill, env, jobId, runId, eventListener);
+    const manager = factory.createMcp(skill, factoryContext);
     allManagers.push(manager);
     return manager;
   });
@@ -618,7 +682,7 @@ async function getSkillManagers(expert, experts, setting, eventListener, options
       (skill) => skill.type === "interactiveSkill"
     );
     const interactiveSkillManagers = interactiveSkills.map((interactiveSkill) => {
-      const manager = new InteractiveSkillManager(interactiveSkill, jobId, runId, eventListener);
+      const manager = factory.createInteractive(interactiveSkill, factoryContext);
       allManagers.push(manager);
       return manager;
     });
@@ -632,7 +696,7 @@ async function getSkillManagers(expert, experts, setting, eventListener, options
       })));
       throw new Error(`Delegate expert "${delegateExpertName}" not found in experts`);
     }
-    const manager = new DelegateSkillManager(delegate, jobId, runId, eventListener);
+    const manager = factory.createDelegate(delegate, factoryContext);
     allManagers.push(manager);
     delegateSkillManagers.push(manager);
   }
@@ -671,12 +735,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 +881,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 +959,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 +974,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 +1002,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 +1316,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 +1393,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);
@@ -1905,88 +2023,115 @@ var StateMachineLogics = {
   CallingDelegate: callingDelegateLogic,
   FinishingStep: finishingStepLogic
 };
-async function executeStateMachine(params) {
-  const {
-    setting,
-    initialCheckpoint,
-    eventListener,
-    skillManagers,
-    eventEmitter,
-    storeCheckpoint,
-    shouldContinueRun
-  } = params;
-  const runActor = createActor(runtimeStateMachine, {
-    input: {
-      setting,
-      initialCheckpoint,
-      eventListener,
-      skillManagers
-    }
-  });
-  return new Promise((resolve, reject) => {
-    runActor.subscribe(async (runState) => {
-      try {
-        if (runState.value === "Stopped") {
-          const { checkpoint, skillManagers: skillManagers2 } = runState.context;
-          if (!checkpoint) {
-            throw new Error("Checkpoint is undefined");
-          }
-          await closeSkillManagers(skillManagers2);
-          resolve(checkpoint);
-        } else {
-          const event = await StateMachineLogics[runState.value](runState.context);
-          if ("checkpoint" in event) {
-            await storeCheckpoint(event.checkpoint);
-          }
-          await eventEmitter.emit(event);
-          if (shouldContinueRun) {
-            const shouldContinue = await shouldContinueRun(
-              runState.context.setting,
-              runState.context.checkpoint,
-              runState.context.step
-            );
-            if (!shouldContinue) {
-              runActor.stop();
-              await closeSkillManagers(runState.context.skillManagers);
-              resolve(runState.context.checkpoint);
-              return;
-            }
-          }
-          runActor.send(event);
-        }
-      } catch (error) {
-        await closeSkillManagers(skillManagers).catch(() => {
-        });
-        reject(error);
+var DefaultActorFactory = class {
+  create(input) {
+    return createActor(runtimeStateMachine, input);
+  }
+};
+var defaultActorFactory = new DefaultActorFactory();
+
+// src/state-machine/coordinator.ts
+var StateMachineCoordinator = class {
+  constructor(params, deps = {}) {
+    this.params = params;
+    this.actorFactory = deps.actorFactory ?? defaultActorFactory;
+    this.closeManagers = deps.closeSkillManagers ?? closeSkillManagers;
+    this.logics = deps.logics ?? StateMachineLogics;
+  }
+  actorFactory;
+  closeManagers;
+  logics;
+  actor = null;
+  resolvePromise = null;
+  rejectPromise = null;
+  /**
+   * Execute the state machine and return the final checkpoint.
+   */
+  async execute() {
+    const { setting, initialCheckpoint, eventListener, skillManagers } = this.params;
+    this.actor = this.actorFactory.create({
+      input: {
+        setting,
+        initialCheckpoint,
+        eventListener,
+        skillManagers
       }
     });
-    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()
+    return new Promise((resolve, reject) => {
+      this.resolvePromise = resolve;
+      this.rejectPromise = reject;
+      this.actor.subscribe((runState) => {
+        this.handleStateChange(runState).catch((error) => {
+          this.handleError(error);
         });
-      } catch (error) {
-        errors.push(error instanceof Error ? error : new Error(String(error)));
+      });
+      this.actor.start();
+    });
+  }
+  /**
+   * Handle state changes from the actor.
+   * Exported for testing purposes.
+   */
+  async handleStateChange(runState) {
+    if (runState.value === "Stopped") {
+      await this.handleStoppedState(runState);
+    } else {
+      await this.handleActiveState(runState);
+    }
+  }
+  /**
+   * Handle the stopped state - cleanup and resolve.
+   */
+  async handleStoppedState(runState) {
+    const { checkpoint, skillManagers } = runState.context;
+    if (!checkpoint) {
+      throw new Error("Checkpoint is undefined");
+    }
+    await this.closeManagers(skillManagers);
+    this.resolvePromise?.(checkpoint);
+  }
+  /**
+   * Handle active states - execute logic, store checkpoint, emit events.
+   */
+  async handleActiveState(runState) {
+    const { eventEmitter, storeCheckpoint, shouldContinueRun } = this.params;
+    const stateValue = runState.value;
+    const event = await this.logics[stateValue](runState.context);
+    if ("checkpoint" in event) {
+      await storeCheckpoint(event.checkpoint);
+    }
+    await eventEmitter.emit(event);
+    if (shouldContinueRun) {
+      const shouldContinue = await shouldContinueRun(
+        runState.context.setting,
+        runState.context.checkpoint,
+        runState.context.step
+      );
+      if (!shouldContinue) {
+        this.actor?.stop();
+        await this.closeManagers(runState.context.skillManagers);
+        this.resolvePromise?.(runState.context.checkpoint);
+        return;
       }
     }
-    if (errors.length > 0) {
-      throw new AggregateError(errors, "One or more event listeners failed");
-    }
+    this.actor?.send(event);
+  }
+  /**
+   * Handle errors - cleanup and reject.
+   */
+  async handleError(error) {
+    await this.closeManagers(this.params.skillManagers).catch(() => {
+    });
+    this.rejectPromise?.(error instanceof Error ? error : new Error(String(error)));
   }
 };
 
+// src/state-machine/executor.ts
+async function executeStateMachine(params) {
+  const coordinator = new StateMachineCoordinator(params);
+  return coordinator.execute();
+}
+
 // src/helpers/checkpoint.ts
 function createInitialCheckpoint(checkpointId, params) {
   return {
@@ -2049,46 +2194,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 +2243,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 +2491,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 strategy = selectDelegationStrategy(delegateTo.length);
+        const context = extractDelegationContext(resultCheckpoint);
+        const delegationResult = await strategy.execute(
+          delegateTo,
+          setting,
+          context,
+          runResult.expertToRun,
+          run,
+          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
-        );
-        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-H65LPOAK.js.map
+//# sourceMappingURL=chunk-H65LPOAK.js.map