@perstack/runtime 0.0.61 → 0.0.63

package/dist/src/index.js

@@ -1,3 +1,7 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'fs';
+import { readFile, mkdir, writeFile } from 'fs/promises';
+import path2 from 'path';
+import { jobSchema, runSettingSchema, checkpointSchema, knownModels, stopRunByDelegate, stopRunByInteractiveTool, resolveToolResults, attemptCompletion, callDelegate, callInteractiveTool, stopRunByExceededMaxSteps, continueToNextStep, retry, completeRun, callTools, startRun, resumeToolCalls, finishAllToolCalls, startGeneration, finishToolCall, runParamsSchema, createRuntimeEvent } from '@perstack/core';
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createAzure } from '@ai-sdk/azure';
@@ -5,11 +9,8 @@ import { createDeepSeek } from '@ai-sdk/deepseek';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createVertex } from '@ai-sdk/google-vertex';
 import { createOpenAI } from '@ai-sdk/openai';
-import { knownModels, stopRunByDelegate, stopRunByInteractiveTool, resolveThought, attemptCompletion, resolvePdfFile, resolveImageFile, resolveToolResult, stopRunByExceededMaxSteps, continueToNextStep, retry, completeRun, callDelegate, callInteractiveTool, callTool, startRun, startGeneration, finishToolCall, runParamsSchema, createRuntimeEvent, checkpointSchema, runSettingSchema } from '@perstack/core';
 import { createOllama } from 'ollama-ai-provider-v2';
 import { createId } from '@paralleldrive/cuid2';
-import { readFile, readdir, mkdir, writeFile } from 'fs/promises';
-import path from 'path';
 import { setup, assign, createActor } from 'xstate';
 import { generateText, tool, jsonSchema } from 'ai';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -21,7 +22,208 @@ import { ApiV1Client } from '@perstack/api-client/v1';
 
 // package.json
 var package_default = {
-  version: "0.0.61"};
+  version: "0.0.63"};
+function getJobsDir() {
+  return `${process.cwd()}/perstack/jobs`;
+}
+function getJobDir(jobId) {
+  return `${getJobsDir()}/${jobId}`;
+}
+function storeJob(job) {
+  const jobDir = getJobDir(job.id);
+  if (!existsSync(jobDir)) {
+    mkdirSync(jobDir, { recursive: true });
+  }
+  const jobPath = path2.resolve(jobDir, "job.json");
+  writeFileSync(jobPath, JSON.stringify(job, null, 2));
+}
+function retrieveJob(jobId) {
+  const jobDir = getJobDir(jobId);
+  const jobPath = path2.resolve(jobDir, "job.json");
+  if (!existsSync(jobPath)) {
+    return void 0;
+  }
+  const content = readFileSync(jobPath, "utf-8");
+  return jobSchema.parse(JSON.parse(content));
+}
+function getAllJobs() {
+  const jobsDir = getJobsDir();
+  if (!existsSync(jobsDir)) {
+    return [];
+  }
+  const jobDirNames = readdirSync(jobsDir, { withFileTypes: true }).filter((dir) => dir.isDirectory()).map((dir) => dir.name);
+  if (jobDirNames.length === 0) {
+    return [];
+  }
+  const jobs = [];
+  for (const jobDirName of jobDirNames) {
+    const jobPath = path2.resolve(jobsDir, jobDirName, "job.json");
+    if (!existsSync(jobPath)) {
+      continue;
+    }
+    try {
+      const content = readFileSync(jobPath, "utf-8");
+      jobs.push(jobSchema.parse(JSON.parse(content)));
+    } catch {
+    }
+  }
+  return jobs.sort((a, b) => b.startedAt - a.startedAt);
+}
+function createInitialJob(jobId, expertKey, maxSteps) {
+  return {
+    id: jobId,
+    status: "running",
+    coordinatorExpertKey: expertKey,
+    totalSteps: 0,
+    maxSteps,
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0,
+      reasoningTokens: 0,
+      totalTokens: 0,
+      cachedInputTokens: 0
+    },
+    startedAt: Date.now()
+  };
+}
+async function createDefaultFileSystem() {
+  const fs = await import('fs');
+  const fsPromises = await import('fs/promises');
+  return {
+    existsSync: fs.existsSync,
+    mkdir: async (p, options) => {
+      await fsPromises.mkdir(p, options);
+    },
+    readFile: fsPromises.readFile,
+    writeFile: fsPromises.writeFile
+  };
+}
+function defaultGetRunDir(jobId, runId) {
+  return `${process.cwd()}/perstack/jobs/${jobId}/runs/${runId}`;
+}
+async function storeRunSetting(setting, fs, getRunDir = defaultGetRunDir) {
+  const fileSystem = fs ?? await createDefaultFileSystem();
+  const runDir = getRunDir(setting.jobId, setting.runId);
+  if (fileSystem.existsSync(runDir)) {
+    const runSettingPath = path2.resolve(runDir, "run-setting.json");
+    const runSetting = runSettingSchema.parse(
+      JSON.parse(await fileSystem.readFile(runSettingPath, "utf-8"))
+    );
+    runSetting.updatedAt = Date.now();
+    await fileSystem.writeFile(runSettingPath, JSON.stringify(runSetting), "utf-8");
+  } else {
+    await fileSystem.mkdir(runDir, { recursive: true });
+    await fileSystem.writeFile(
+      path2.resolve(runDir, "run-setting.json"),
+      JSON.stringify(setting),
+      "utf-8"
+    );
+  }
+}
+function getAllRuns() {
+  const jobsDir = getJobsDir();
+  if (!existsSync(jobsDir)) {
+    return [];
+  }
+  const jobDirNames = readdirSync(jobsDir, { withFileTypes: true }).filter((dir) => dir.isDirectory()).map((dir) => dir.name);
+  if (jobDirNames.length === 0) {
+    return [];
+  }
+  const runs = [];
+  for (const jobDirName of jobDirNames) {
+    const runsDir = path2.resolve(jobsDir, jobDirName, "runs");
+    if (!existsSync(runsDir)) {
+      continue;
+    }
+    const runDirNames = readdirSync(runsDir, { withFileTypes: true }).filter((dir) => dir.isDirectory()).map((dir) => dir.name);
+    for (const runDirName of runDirNames) {
+      const runSettingPath = path2.resolve(runsDir, runDirName, "run-setting.json");
+      if (!existsSync(runSettingPath)) {
+        continue;
+      }
+      try {
+        const content = readFileSync(runSettingPath, "utf-8");
+        runs.push(runSettingSchema.parse(JSON.parse(content)));
+      } catch {
+      }
+    }
+  }
+  return runs.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+
+// src/default-store.ts
+function getCheckpointDir(jobId) {
+  return `${getJobDir(jobId)}/checkpoints`;
+}
+function getCheckpointPath(jobId, checkpointId) {
+  return `${getCheckpointDir(jobId)}/${checkpointId}.json`;
+}
+async function defaultRetrieveCheckpoint(jobId, checkpointId) {
+  const checkpointPath = getCheckpointPath(jobId, checkpointId);
+  if (!existsSync(checkpointPath)) {
+    throw new Error(`checkpoint not found: ${checkpointId}`);
+  }
+  const checkpoint = await readFile(checkpointPath, "utf8");
+  return checkpointSchema.parse(JSON.parse(checkpoint));
+}
+async function defaultStoreCheckpoint(checkpoint) {
+  const { id, jobId } = checkpoint;
+  const checkpointDir = getCheckpointDir(jobId);
+  await mkdir(checkpointDir, { recursive: true });
+  await writeFile(getCheckpointPath(jobId, id), JSON.stringify(checkpoint));
+}
+async function defaultStoreEvent(event) {
+  const { timestamp, jobId, runId, stepNumber, type } = event;
+  const runDir = defaultGetRunDir(jobId, runId);
+  const eventPath = `${runDir}/event-${timestamp}-${stepNumber}-${type}.json`;
+  await mkdir(runDir, { recursive: true });
+  await writeFile(eventPath, JSON.stringify(event));
+}
+function getCheckpointsByJobId(jobId) {
+  const checkpointDir = getCheckpointDir(jobId);
+  if (!existsSync(checkpointDir)) {
+    return [];
+  }
+  const files = readdirSync(checkpointDir).filter((file) => file.endsWith(".json"));
+  const checkpoints = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync(path2.resolve(checkpointDir, file), "utf-8");
+      checkpoints.push(checkpointSchema.parse(JSON.parse(content)));
+    } catch {
+    }
+  }
+  return checkpoints.sort((a, b) => a.stepNumber - b.stepNumber);
+}
+function getEventsByRun(jobId, runId) {
+  const runDir = defaultGetRunDir(jobId, runId);
+  if (!existsSync(runDir)) {
+    return [];
+  }
+  return readdirSync(runDir).filter((file) => file.startsWith("event-")).map((file) => {
+    const [_, timestamp, stepNumber, type] = file.split(".")[0].split("-");
+    return { timestamp: Number(timestamp), stepNumber: Number(stepNumber), type };
+  }).sort((a, b) => a.stepNumber - b.stepNumber);
+}
+function getEventContents(jobId, runId, maxStepNumber) {
+  const runDir = defaultGetRunDir(jobId, runId);
+  if (!existsSync(runDir)) {
+    return [];
+  }
+  const eventFiles = readdirSync(runDir).filter((file) => file.startsWith("event-")).map((file) => {
+    const [_, timestamp, step, type] = file.split(".")[0].split("-");
+    return { file, timestamp: Number(timestamp), stepNumber: Number(step), type };
+  }).filter((e) => maxStepNumber === void 0 || e.stepNumber <= maxStepNumber).sort((a, b) => a.timestamp - b.timestamp);
+  const events = [];
+  for (const { file } of eventFiles) {
+    try {
+      const content = readFileSync(path2.resolve(runDir, file), "utf-8");
+      events.push(JSON.parse(content));
+    } catch {
+    }
+  }
+  return events;
+}
 function getModel(modelId, providerConfig) {
   switch (providerConfig.providerName) {
     case "anthropic": {
@@ -142,6 +344,7 @@ function sumUsage(a, b) {
 function createInitialCheckpoint(checkpointId, params) {
   return {
     id: checkpointId,
+    jobId: params.jobId,
     runId: params.runId,
     expert: {
       key: params.expertKey,
@@ -185,6 +388,7 @@ function buildDelegationReturnState(currentSetting, resultCheckpoint, parentChec
         interactiveToolCallResult: {
           toolCallId,
           toolName,
+          skillName: `delegate/${resultCheckpoint.expert.key}`,
           text: delegateText.text
         }
       }
@@ -192,16 +396,19 @@ function buildDelegationReturnState(currentSetting, resultCheckpoint, parentChec
     checkpoint: {
       ...parentCheckpoint,
       stepNumber: resultCheckpoint.stepNumber,
-      usage: resultCheckpoint.usage
+      usage: resultCheckpoint.usage,
+      pendingToolCalls: parentCheckpoint.pendingToolCalls,
+      partialToolResults: parentCheckpoint.partialToolResults
     }
   };
 }
 function buildDelegateToState(currentSetting, resultCheckpoint, currentExpert) {
   const { delegateTo } = resultCheckpoint;
-  if (!delegateTo) {
+  if (!delegateTo || delegateTo.length === 0) {
     throw new Error("delegateTo is required for buildDelegateToState");
   }
-  const { expert, toolCallId, toolName, query } = delegateTo;
+  const firstDelegation = delegateTo[0];
+  const { expert, toolCallId, toolName, query } = firstDelegation;
   return {
     setting: {
       ...currentSetting,
@@ -229,73 +436,12 @@ function buildDelegateToState(currentSetting, resultCheckpoint, currentExpert) {
         toolName,
         checkpointId: resultCheckpoint.id
       },
-      usage: resultCheckpoint.usage
+      usage: resultCheckpoint.usage,
+      pendingToolCalls: void 0,
+      partialToolResults: void 0
     }
   };
 }
-async function createDefaultFileSystem() {
-  const fs = await import('fs');
-  const fsPromises = await import('fs/promises');
-  return {
-    existsSync: fs.existsSync,
-    mkdir: async (p, options) => {
-      await fsPromises.mkdir(p, options);
-    },
-    readFile: fsPromises.readFile,
-    writeFile: fsPromises.writeFile
-  };
-}
-function defaultGetRunDir(runId) {
-  return `${process.cwd()}/perstack/runs/${runId}`;
-}
-async function storeRunSetting(setting, fs, getRunDir = defaultGetRunDir) {
-  const fileSystem = fs ?? await createDefaultFileSystem();
-  const runDir = getRunDir(setting.runId);
-  if (fileSystem.existsSync(runDir)) {
-    const runSettingPath = path.resolve(runDir, "run-setting.json");
-    const runSetting = runSettingSchema.parse(
-      JSON.parse(await fileSystem.readFile(runSettingPath, "utf-8"))
-    );
-    runSetting.updatedAt = Date.now();
-    await fileSystem.writeFile(runSettingPath, JSON.stringify(runSetting), "utf-8");
-  } else {
-    await fileSystem.mkdir(runDir, { recursive: true });
-    await fileSystem.writeFile(
-      path.resolve(runDir, "run-setting.json"),
-      JSON.stringify(setting),
-      "utf-8"
-    );
-  }
-}
-
-// src/default-store.ts
-async function defaultRetrieveCheckpoint(runId, checkpointId) {
-  const runDir = defaultGetRunDir(runId);
-  const checkpointFiles = await readdir(runDir, { withFileTypes: true }).then(
-    (files) => files.filter((file) => file.isFile() && file.name.startsWith("checkpoint-"))
-  );
-  const checkpointFile = checkpointFiles.find((file) => file.name.endsWith(`-${checkpointId}.json`));
-  if (!checkpointFile) {
-    throw new Error(`checkpoint not found: ${runId} ${checkpointId}`);
-  }
-  const checkpointPath = `${runDir}/${checkpointFile.name}`;
-  const checkpoint = await readFile(checkpointPath, "utf8");
-  return checkpointSchema.parse(JSON.parse(checkpoint));
-}
-async function defaultStoreCheckpoint(checkpoint, timestamp) {
-  const { id, runId, stepNumber } = checkpoint;
-  const runDir = defaultGetRunDir(runId);
-  const checkpointPath = `${runDir}/checkpoint-${timestamp}-${stepNumber}-${id}.json`;
-  await mkdir(runDir, { recursive: true });
-  await writeFile(checkpointPath, JSON.stringify(checkpoint));
-}
-async function defaultStoreEvent(event) {
-  const { timestamp, runId, stepNumber, type } = event;
-  const runDir = defaultGetRunDir(runId);
-  const eventPath = `${runDir}/event-${timestamp}-${stepNumber}-${type}.json`;
-  await mkdir(runDir, { recursive: true });
-  await writeFile(eventPath, JSON.stringify(event));
-}
 var RunEventEmitter = class {
   listeners = [];
   subscribe(listener) {
@@ -328,9 +474,11 @@ var BaseSkillManager = class {
   skill;
   interactiveSkill;
   expert;
+  _jobId;
   _runId;
   _eventListener;
-  constructor(runId, eventListener) {
+  constructor(jobId, runId, eventListener) {
+    this._jobId = jobId;
     this._runId = runId;
     this._eventListener = eventListener;
   }
@@ -381,8 +529,8 @@ var DelegateSkillManager = class extends BaseSkillManager {
   type = "delegate";
   lazyInit = false;
   expert;
-  constructor(expert, runId, eventListener) {
-    super(runId, eventListener);
+  constructor(expert, jobId, runId, eventListener) {
+    super(jobId, runId, eventListener);
     this.name = expert.name;
     this.expert = expert;
   }
@@ -414,8 +562,8 @@ var InteractiveSkillManager = class extends BaseSkillManager {
   type = "interactive";
   lazyInit = false;
   interactiveSkill;
-  constructor(interactiveSkill, runId, eventListener) {
-    super(runId, eventListener);
+  constructor(interactiveSkill, jobId, runId, eventListener) {
+    super(jobId, runId, eventListener);
     this.name = interactiveSkill.name;
     this.interactiveSkill = interactiveSkill;
   }
@@ -441,8 +589,8 @@ var McpSkillManager = class extends BaseSkillManager {
   skill;
   _mcpClient;
   _env;
-  constructor(skill, env, runId, eventListener) {
-    super(runId, eventListener);
+  constructor(skill, env, jobId, runId, eventListener) {
+    super(jobId, runId, eventListener);
     this.name = skill.name;
     this.skill = skill;
     this._env = env;
@@ -481,7 +629,7 @@ var McpSkillManager = class extends BaseSkillManager {
     const startTime = Date.now();
     const { command, args } = this._getCommandArgs(skill);
     if (this._eventListener) {
-      const event = createRuntimeEvent("skillStarting", this._runId, {
+      const event = createRuntimeEvent("skillStarting", this._jobId, this._runId, {
         skillName: skill.name,
         command,
         args
@@ -492,7 +640,7 @@ var McpSkillManager = class extends BaseSkillManager {
     if (transport.stderr) {
       transport.stderr.on("data", (chunk) => {
         if (this._eventListener) {
-          const event = createRuntimeEvent("skillStderr", this._runId, {
+          const event = createRuntimeEvent("skillStderr", this._jobId, this._runId, {
             skillName: skill.name,
             message: chunk.toString().trim()
           });
@@ -505,7 +653,7 @@ var McpSkillManager = class extends BaseSkillManager {
     const connectTime = Date.now();
     if (this._eventListener) {
       const serverInfo = this._mcpClient.getServerVersion();
-      const event = createRuntimeEvent("skillConnected", this._runId, {
+      const event = createRuntimeEvent("skillConnected", this._jobId, this._runId, {
         skillName: skill.name,
         serverInfo: serverInfo ? { name: serverInfo.name, version: serverInfo.version } : void 0,
         connectDurationMs: connectTime - connectStartTime,
@@ -541,7 +689,7 @@ var McpSkillManager = class extends BaseSkillManager {
     if (this._mcpClient) {
       await this._mcpClient.close();
       if (this._eventListener && this.skill) {
-        const event = createRuntimeEvent("skillDisconnected", this._runId, {
+        const event = createRuntimeEvent("skillDisconnected", this._jobId, this._runId, {
           skillName: this.skill.name
         });
         this._eventListener(event);
@@ -644,8 +792,8 @@ async function initSkillManagersWithCleanup(managers, allManagers) {
     throw firstRejected.reason;
   }
 }
-async function getSkillManagers(expert, experts, setting, eventListener) {
-  const { perstackBaseSkillCommand, env, runId } = setting;
+async function getSkillManagers(expert, experts, setting, eventListener, options) {
+  const { perstackBaseSkillCommand, env, jobId, runId } = setting;
   const { skills } = expert;
   if (!skills["@perstack/base"]) {
     throw new Error("Base skill is not defined");
@@ -672,20 +820,22 @@ async function getSkillManagers(expert, experts, setting, eventListener) {
     return skill;
   });
   const mcpSkillManagers = mcpSkills.map((skill) => {
-    const manager = new McpSkillManager(skill, env, runId, eventListener);
+    const manager = new McpSkillManager(skill, env, jobId, runId, eventListener);
     allManagers.push(manager);
     return manager;
   });
   await initSkillManagersWithCleanup(mcpSkillManagers, allManagers);
-  const interactiveSkills = Object.values(skills).filter(
-    (skill) => skill.type === "interactiveSkill"
-  );
-  const interactiveSkillManagers = interactiveSkills.map((interactiveSkill) => {
-    const manager = new InteractiveSkillManager(interactiveSkill, runId, eventListener);
-    allManagers.push(manager);
-    return manager;
-  });
-  await initSkillManagersWithCleanup(interactiveSkillManagers, allManagers);
+  if (!options?.isDelegatedRun) {
+    const interactiveSkills = Object.values(skills).filter(
+      (skill) => skill.type === "interactiveSkill"
+    );
+    const interactiveSkillManagers = interactiveSkills.map((interactiveSkill) => {
+      const manager = new InteractiveSkillManager(interactiveSkill, jobId, runId, eventListener);
+      allManagers.push(manager);
+      return manager;
+    });
+    await initSkillManagersWithCleanup(interactiveSkillManagers, allManagers);
+  }
   const delegateSkillManagers = [];
   for (const delegateExpertName of expert.delegates) {
     const delegate = experts[delegateExpertName];
@@ -694,7 +844,7 @@ async function getSkillManagers(expert, experts, setting, eventListener) {
       })));
       throw new Error(`Delegate expert "${delegateExpertName}" not found in experts`);
     }
-    const manager = new DelegateSkillManager(delegate, runId, eventListener);
+    const manager = new DelegateSkillManager(delegate, jobId, runId, eventListener);
     allManagers.push(manager);
     delegateSkillManagers.push(manager);
   }
@@ -735,37 +885,58 @@ async function getToolSet(skillManagers) {
 }
 
 // src/states/calling-delegate.ts
+async function getToolType(toolName, skillManagers) {
+  const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
+  return skillManager.type;
+}
 async function callingDelegateLogic({
   setting,
   checkpoint,
   step,
   skillManagers
 }) {
-  if (!step.toolCall) {
-    throw new Error("No tool call found");
-  }
-  const { id, toolName, args } = step.toolCall;
-  const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
-  if (!skillManager.expert) {
-    throw new Error(`Delegation error: skill manager "${toolName}" not found`);
-  }
-  if (!args || !args.query || typeof args.query !== "string") {
-    throw new Error("Delegation error: query is undefined");
-  }
-  return stopRunByDelegate(setting, checkpoint, {
-    checkpoint: {
-      ...checkpoint,
-      status: "stoppedByDelegate",
-      delegateTo: {
+  if (!step.pendingToolCalls || step.pendingToolCalls.length === 0) {
+    throw new Error("No pending tool calls found");
+  }
+  const toolCallTypes = await Promise.all(
+    step.pendingToolCalls.map(async (tc) => ({
+      toolCall: tc,
+      type: await getToolType(tc.toolName, skillManagers)
+    }))
+  );
+  const delegateToolCalls = toolCallTypes.filter((t) => t.type === "delegate").map((t) => t.toolCall);
+  const nonDelegateToolCalls = toolCallTypes.filter((t) => t.type !== "delegate").map((t) => t.toolCall);
+  if (delegateToolCalls.length === 0) {
+    throw new Error("No delegate tool calls found");
+  }
+  const delegations = await Promise.all(
+    delegateToolCalls.map(async (tc) => {
+      const skillManager = await getSkillManagerByToolName(skillManagers, tc.toolName);
+      if (!skillManager.expert) {
+        throw new Error(`Delegation error: skill manager "${tc.toolName}" not found`);
+      }
+      if (!tc.args || !tc.args.query || typeof tc.args.query !== "string") {
+        throw new Error(`Delegation error: query is undefined for ${tc.toolName}`);
+      }
+      return {
         expert: {
           key: skillManager.expert.key,
           name: skillManager.expert.name,
           version: skillManager.expert.version
         },
-        toolCallId: id,
-        toolName,
-        query: args.query
-      }
+        toolCallId: tc.id,
+        toolName: tc.toolName,
+        query: tc.args.query
+      };
+    })
+  );
+  return stopRunByDelegate(setting, checkpoint, {
+    checkpoint: {
+      ...checkpoint,
+      status: "stoppedByDelegate",
+      delegateTo: delegations,
+      pendingToolCalls: nonDelegateToolCalls.length > 0 ? nonDelegateToolCalls : void 0,
+      partialToolResults: step.partialToolResults
     },
     step: {
       ...step,
@@ -778,10 +949,17 @@ async function callingInteractiveToolLogic({
   checkpoint,
   step
 }) {
+  if (!step.pendingToolCalls || step.pendingToolCalls.length === 0) {
+    throw new Error("No pending tool calls found");
+  }
+  const currentToolCall = step.pendingToolCalls[0];
+  const remainingToolCalls = step.pendingToolCalls.slice(1);
   return stopRunByInteractiveTool(setting, checkpoint, {
     checkpoint: {
       ...checkpoint,
-      status: "stoppedByInteractiveTool"
+      status: "stoppedByInteractiveTool",
+      pendingToolCalls: [currentToolCall, ...remainingToolCalls],
+      partialToolResults: step.partialToolResults
     },
     step: {
       ...step,
@@ -789,37 +967,150 @@ async function callingInteractiveToolLogic({
     }
   });
 }
+function hasRemainingTodos(toolResult) {
+  const firstPart = toolResult.result[0];
+  if (!firstPart || firstPart.type !== "textPart") {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(firstPart.text);
+    return Array.isArray(parsed.remainingTodos) && parsed.remainingTodos.length > 0;
+  } catch {
+    return false;
+  }
+}
+function isFileInfo(value) {
+  return typeof value === "object" && value !== null && "path" in value && "mimeType" in value && "size" in value && typeof value.path === "string" && typeof value.mimeType === "string" && typeof value.size === "number";
+}
+async function processFileToolResult(toolResult, toolName) {
+  const processedContents = [];
+  for (const part of toolResult.result) {
+    if (part.type !== "textPart") {
+      processedContents.push(part);
+      continue;
+    }
+    let fileInfo;
+    try {
+      const parsed = JSON.parse(part.text);
+      if (isFileInfo(parsed)) {
+        fileInfo = parsed;
+      }
+    } catch {
+      processedContents.push(part);
+      continue;
+    }
+    if (!fileInfo) {
+      processedContents.push(part);
+      continue;
+    }
+    const { path: path4, mimeType } = fileInfo;
+    try {
+      const buffer = await readFile(path4);
+      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 "${path4}": ${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,
   step,
   skillManagers
 }) {
-  if (!step.toolCall) {
-    throw new Error("No tool call found");
+  const pendingToolCalls = step.pendingToolCalls ?? step.toolCalls ?? [];
+  if (pendingToolCalls.length === 0) {
+    throw new Error("No tool calls found");
   }
-  const { id, skillName, toolName, args } = step.toolCall;
-  const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
-  if (skillManager.type !== "mcp") {
-    throw new Error(`Incorrect SkillType, required MCP, got ${skillManager.type}`);
+  const toolResults = step.toolResults ? [...step.toolResults] : [];
+  const attemptCompletionTool = pendingToolCalls.find(
+    (tc) => tc.skillName === "@perstack/base" && tc.toolName === "attemptCompletion"
+  );
+  if (attemptCompletionTool) {
+    const toolResult = await executeMcpToolCall(attemptCompletionTool, skillManagers);
+    if (hasRemainingTodos(toolResult)) {
+      return resolveToolResults(setting, checkpoint, { toolResults: [toolResult] });
+    }
+    return attemptCompletion(setting, checkpoint, { toolResult });
+  }
+  const toolCallTypes = await Promise.all(
+    pendingToolCalls.map(async (tc) => ({
+      toolCall: tc,
+      type: await 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 mcpResults = await Promise.all(
+      mcpToolCalls.map((tc) => executeMcpToolCall(tc, skillManagers))
+    );
+    toolResults.push(...mcpResults);
+  }
+  if (delegateToolCalls.length > 0) {
+    step.partialToolResults = toolResults;
+    step.pendingToolCalls = [...delegateToolCalls, ...interactiveToolCalls];
+    return callDelegate(setting, checkpoint, {
+      newMessage: checkpoint.messages[checkpoint.messages.length - 1],
+      toolCalls: delegateToolCalls,
+      usage: step.usage
+    });
   }
-  const result = await skillManager.callTool(toolName, args);
-  const toolResult = { id, skillName, toolName, result };
-  if (skillName === "@perstack/base") {
-    if (toolName === "think") {
-      return resolveThought(setting, checkpoint, { toolResult });
-    }
-    if (toolName === "attemptCompletion") {
-      return attemptCompletion(setting, checkpoint, { toolResult });
-    }
-    if (toolName === "readPdfFile") {
-      return resolvePdfFile(setting, checkpoint, { toolResult });
-    }
-    if (toolName === "readImageFile") {
-      return resolveImageFile(setting, checkpoint, { toolResult });
-    }
+  if (interactiveToolCalls.length > 0) {
+    const interactiveToolCall = interactiveToolCalls[0];
+    if (!interactiveToolCall) {
+      throw new Error("No interactive tool call found");
+    }
+    step.partialToolResults = toolResults;
+    step.pendingToolCalls = interactiveToolCalls;
+    return callInteractiveTool(setting, checkpoint, {
+      newMessage: checkpoint.messages[checkpoint.messages.length - 1],
+      toolCall: interactiveToolCall,
+      usage: step.usage
+    });
   }
-  return resolveToolResult(setting, checkpoint, { toolResult });
+  return resolveToolResults(setting, checkpoint, { toolResults });
 }
 async function finishingStepLogic({
   setting,
@@ -1035,9 +1326,12 @@ function toolResultPartToCoreToolResultPart(part) {
       output: { type: "text", value: contents[0].text }
     };
   }
-  const contentValue = contents.map(
-    (content) => content.type === "textPart" ? { type: "text", text: content.text } : { type: "media", data: content.encodedData, mediaType: content.mimeType }
-  );
+  const contentValue = contents.map((content) => {
+    if (content.type === "textPart") {
+      return { type: "text", text: content.text };
+    }
+    return { type: "media", data: content.encodedData, mediaType: content.mimeType };
+  });
   return {
     type: "tool-result",
     toolCallId: part.toolCallId,
@@ -1052,21 +1346,21 @@ async function generatingRunResultLogic({
   checkpoint,
   step
 }) {
-  if (!step.toolCall || !step.toolResult) {
-    throw new Error("No tool call or tool result found");
+  if (!step.toolCalls || !step.toolResults || step.toolResults.length === 0) {
+    throw new Error("No tool calls or tool results found");
   }
-  const { id, toolName } = step.toolCall;
-  const { result } = step.toolResult;
-  const toolMessage = createToolMessage([
-    {
+  const toolResultParts = step.toolResults.map((toolResult) => {
+    const toolCall = step.toolCalls?.find((tc) => tc.id === toolResult.id);
+    return {
       type: "toolResultPart",
-      toolCallId: id,
-      toolName,
-      contents: result.filter(
-        (part) => part.type === "textPart" || part.type === "imageInlinePart"
+      toolCallId: toolResult.id,
+      toolName: toolCall?.toolName ?? toolResult.toolName,
+      contents: toolResult.result.filter(
+        (part) => part.type === "textPart" || part.type === "imageInlinePart" || part.type === "fileInlinePart"
       )
-    }
-  ]);
+    };
+  });
+  const toolMessage = createToolMessage(toolResultParts);
   const model = getModel(setting.model, setting.providerConfig);
   const { messages } = checkpoint;
   let generationResult;
@@ -1103,13 +1397,48 @@ async function generatingRunResultLogic({
     step: {
       ...step,
       newMessages: [...step.newMessages, ...newMessages],
-      finishedAt: (/* @__PURE__ */ new Date()).getTime(),
+      finishedAt: Date.now(),
       usage: sumUsage(step.usage, usage)
     },
     text,
     usage
   });
 }
+async function classifyToolCalls(toolCalls, skillManagers) {
+  return Promise.all(
+    toolCalls.map(async (tc) => {
+      const skillManager = await getSkillManagerByToolName(skillManagers, tc.toolName);
+      return {
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        input: tc.input,
+        skillManager
+      };
+    })
+  );
+}
+function sortToolCallsByPriority(toolCalls) {
+  const priority = { mcp: 0, delegate: 1, interactive: 2 };
+  return [...toolCalls].sort(
+    (a, b) => (priority[a.skillManager.type] ?? 99) - (priority[b.skillManager.type] ?? 99)
+  );
+}
+function buildToolCallParts(toolCalls) {
+  return toolCalls.map((tc) => ({
+    type: "toolCallPart",
+    toolCallId: tc.toolCallId,
+    toolName: tc.toolName,
+    args: tc.input
+  }));
+}
+function buildToolCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    id: tc.toolCallId,
+    skillName: tc.skillManager.name,
+    toolName: tc.toolName,
+    args: tc.input
+  }));
+}
 async function generatingToolCallLogic({
   setting,
   checkpoint,
@@ -1141,8 +1470,7 @@ async function generatingToolCallLogic({
   }
   const usage = usageFromGenerateTextResult(result);
   const { text, toolCalls, finishReason } = result;
-  const toolCall = toolCalls[0];
-  if (!toolCall) {
+  if (toolCalls.length === 0) {
     const reason = JSON.stringify({
       error: "Error: No tool call generated",
       message: "You must generate a tool call. Try again."
@@ -1153,42 +1481,26 @@ async function generatingToolCallLogic({
       usage
     });
   }
-  const contents = [
-    {
-      type: "toolCallPart",
-      toolCallId: toolCall.toolCallId,
-      toolName: toolCall.toolName,
-      args: toolCall.input
-    }
-  ];
-  if (text) {
-    contents.push({
-      type: "textPart",
-      text
-    });
-  }
-  const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
-  const eventPayload = {
-    newMessage: createExpertMessage(contents),
-    toolCall: {
-      id: toolCall.toolCallId,
-      skillName: skillManager.name,
-      toolName: toolCall.toolName,
-      args: toolCall.input
-    },
-    usage
-  };
+  const classified = await classifyToolCalls(toolCalls, skillManagers);
+  const sorted = sortToolCallsByPriority(classified);
   if (finishReason === "tool-calls" || finishReason === "stop") {
-    switch (skillManager.type) {
-      case "mcp":
-        return callTool(setting, checkpoint, eventPayload);
-      case "interactive":
-        return callInteractiveTool(setting, checkpoint, eventPayload);
-      case "delegate":
-        return callDelegate(setting, checkpoint, eventPayload);
-    }
+    const toolCallParts = buildToolCallParts(sorted);
+    const contents = [...toolCallParts];
+    if (text) {
+      contents.push({ type: "textPart", text });
+    }
+    const allToolCalls = buildToolCalls(sorted);
+    return callTools(setting, checkpoint, {
+      newMessage: createExpertMessage(contents),
+      toolCalls: allToolCalls,
+      usage
+    });
   }
   if (finishReason === "length") {
+    const firstToolCall = sorted[0];
+    if (!firstToolCall) {
+      throw new Error("No tool call found");
+    }
     const reason = JSON.stringify({
       error: "Error: Tool call generation failed",
       message: "Generation length exceeded. Try again."
@@ -1199,27 +1511,36 @@ async function generatingToolCallLogic({
         createExpertMessage([
           {
             type: "toolCallPart",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            args: toolCall.input
+            toolCallId: firstToolCall.toolCallId,
+            toolName: firstToolCall.toolName,
+            args: firstToolCall.input
           }
         ]),
         createToolMessage([
           {
             type: "toolResultPart",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
+            toolCallId: firstToolCall.toolCallId,
+            toolName: firstToolCall.toolName,
             contents: [{ type: "textPart", text: reason }]
           }
         ])
       ],
-      toolCall: eventPayload.toolCall,
-      toolResult: {
-        id: toolCall.toolCallId,
-        skillName: skillManager.name,
-        toolName: toolCall.toolName,
-        result: [{ type: "textPart", id: createId(), text: reason }]
-      },
+      toolCalls: [
+        {
+          id: firstToolCall.toolCallId,
+          skillName: firstToolCall.skillManager.name,
+          toolName: firstToolCall.toolName,
+          args: firstToolCall.input
+        }
+      ],
+      toolResults: [
+        {
+          id: firstToolCall.toolCallId,
+          skillName: firstToolCall.skillManager.name,
+          toolName: firstToolCall.toolName,
+          result: [{ type: "textPart", id: createId(), text: reason }]
+        }
+      ],
       usage
     });
   }
@@ -1348,18 +1669,24 @@ async function initLogic({
       if (!setting.input.interactiveToolCallResult) {
         throw new Error("Interactive tool call result is undefined");
       }
-      return startRun(setting, checkpoint, {
-        initialCheckpoint: checkpoint,
-        inputMessages: [
-          createToolMessage([
-            {
-              type: "toolResultPart",
-              toolCallId: setting.input.interactiveToolCallResult.toolCallId,
-              toolName: setting.input.interactiveToolCallResult.toolName,
-              contents: [{ type: "textPart", text: setting.input.interactiveToolCallResult.text }]
-            }
-          ])
-        ]
+      const { toolCallId, toolName, skillName, text } = setting.input.interactiveToolCallResult;
+      const pendingToolCalls = checkpoint.pendingToolCalls ?? [];
+      const newToolResult = {
+        id: toolCallId,
+        skillName,
+        toolName,
+        result: [{ type: "textPart", id: createId(), text }]
+      };
+      const updatedPartialResults = [...checkpoint.partialToolResults ?? [], newToolResult];
+      const updatedPendingToolCalls = pendingToolCalls.filter((tc) => tc.id !== toolCallId);
+      const updatedCheckpoint = {
+        ...checkpoint,
+        partialToolResults: updatedPartialResults,
+        pendingToolCalls: updatedPendingToolCalls.length > 0 ? updatedPendingToolCalls : void 0
+      };
+      return startRun(setting, updatedCheckpoint, {
+        initialCheckpoint: updatedCheckpoint,
+        inputMessages: []
       });
     }
     default:
@@ -1376,116 +1703,27 @@ async function preparingForStepLogic({
   setting,
   checkpoint
 }) {
-  return startGeneration(setting, checkpoint, {
-    messages: checkpoint.messages
-  });
-}
-async function resolvingImageFileLogic({
-  setting,
-  checkpoint,
-  step
-}) {
-  if (!step.toolCall || !step.toolResult) {
-    throw new Error("No tool call or tool result found");
-  }
-  const { id, toolName } = step.toolCall;
-  const { result } = step.toolResult;
-  const textParts = result.filter((part) => part.type === "textPart");
-  const files = [];
-  for (const textPart of textParts) {
-    let imageInfo;
-    try {
-      imageInfo = JSON.parse(textPart.text);
-    } catch {
-      files.push({
-        type: "textPart",
-        text: textPart.text
-      });
-      continue;
-    }
-    const { path: path2, mimeType, size } = imageInfo;
-    try {
-      const buffer = await readFile(path2);
-      files.push({
-        type: "imageInlinePart",
-        encodedData: buffer.toString("base64"),
-        mimeType
-      });
-    } catch (error) {
-      files.push({
-        type: "textPart",
-        text: `Failed to read image file "${path2}": ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
+  if (checkpoint.pendingToolCalls && checkpoint.pendingToolCalls.length > 0) {
+    return resumeToolCalls(setting, checkpoint, {
+      pendingToolCalls: checkpoint.pendingToolCalls,
+      partialToolResults: checkpoint.partialToolResults ?? []
+    });
   }
-  return finishToolCall(setting, checkpoint, {
-    newMessages: [
-      createToolMessage([
-        {
-          type: "toolResultPart",
-          toolCallId: id,
-          toolName,
-          contents: files
-        }
-      ])
-    ]
-  });
-}
-async function resolvingPdfFileLogic({
-  setting,
-  checkpoint,
-  step
-}) {
-  if (!step.toolCall || !step.toolResult) {
-    throw new Error("No tool call or tool result found");
-  }
-  const { id, toolName } = step.toolCall;
-  const { result } = step.toolResult;
-  const textParts = result.filter((part) => part.type === "textPart");
-  const files = [];
-  for (const textPart of textParts) {
-    let pdfInfo;
-    try {
-      pdfInfo = JSON.parse(textPart.text);
-    } catch {
-      files.push({
-        type: "textPart",
-        text: textPart.text
-      });
-      continue;
-    }
-    const { path: path2, mimeType, size } = pdfInfo;
-    try {
-      const buffer = await readFile(path2);
-      files.push({
-        type: "fileInlinePart",
-        encodedData: buffer.toString("base64"),
-        mimeType
-      });
-    } catch (error) {
-      files.push({
-        type: "textPart",
-        text: `Failed to read PDF file "${path2}": ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
+  if (checkpoint.partialToolResults && checkpoint.partialToolResults.length > 0) {
+    const toolResultParts = checkpoint.partialToolResults.map((tr) => ({
+      type: "toolResultPart",
+      toolCallId: tr.id,
+      toolName: tr.toolName,
+      contents: tr.result.filter(
+        (part) => part.type === "textPart" || part.type === "imageInlinePart" || part.type === "fileInlinePart"
+      )
+    }));
+    return finishAllToolCalls(setting, checkpoint, {
+      newMessages: [createToolMessage(toolResultParts)]
+    });
   }
-  return finishToolCall(setting, checkpoint, {
-    newMessages: [
-      createToolMessage([
-        {
-          type: "toolResultPart",
-          toolCallId: id,
-          toolName,
-          contents: [
-            {
-              type: "textPart",
-              text: "User uploads PDF file as follows."
-            }
-          ]
-        }
-      ]),
-      createUserMessage(files)
-    ]
+  return startGeneration(setting, checkpoint, {
+    messages: checkpoint.messages
   });
 }
 async function resolvingToolResultLogic({
@@ -1493,24 +1731,22 @@ async function resolvingToolResultLogic({
   checkpoint,
   step
 }) {
-  if (!step.toolCall || !step.toolResult) {
-    throw new Error("No tool call or tool result found");
+  if (!step.toolCalls || !step.toolResults || step.toolResults.length === 0) {
+    throw new Error("No tool calls or tool results found");
   }
-  const { id, toolName } = step.toolCall;
-  const { result } = step.toolResult;
+  const toolResultParts = step.toolResults.map((toolResult) => {
+    const toolCall = step.toolCalls?.find((tc) => tc.id === toolResult.id);
+    return {
+      type: "toolResultPart",
+      toolCallId: toolResult.id,
+      toolName: toolCall?.toolName ?? toolResult.toolName,
+      contents: toolResult.result.filter(
+        (part) => part.type === "textPart" || part.type === "imageInlinePart" || part.type === "fileInlinePart"
+      )
+    };
+  });
   return finishToolCall(setting, checkpoint, {
-    newMessages: [
-      createToolMessage([
-        {
-          type: "toolResultPart",
-          toolCallId: id,
-          toolName,
-          contents: result.filter(
-            (part) => part.type === "textPart" || part.type === "imageInlinePart"
-          )
-        }
-      ])
-    ]
+    newMessages: [createToolMessage(toolResultParts)]
   });
 }
 
@@ -1552,7 +1788,9 @@ var runtimeStateMachine = setup({
             checkpoint: ({ context, event }) => ({
               ...context.checkpoint,
               status: "proceeding",
-              messages: [...context.checkpoint.messages, ...event.inputMessages]
+              messages: [...context.checkpoint.messages, ...event.inputMessages],
+              pendingToolCalls: event.initialCheckpoint.pendingToolCalls,
+              partialToolResults: event.initialCheckpoint.partialToolResults
             }),
             step: ({ context, event }) => ({
               ...context.step,
@@ -1575,6 +1813,38 @@ var runtimeStateMachine = setup({
               startedAt: event.timestamp
             })
           })
+        },
+        resumeToolCalls: {
+          target: "CallingTool",
+          actions: assign({
+            step: ({ context, event }) => ({
+              stepNumber: context.checkpoint.stepNumber,
+              inputMessages: context.step.inputMessages ?? [],
+              newMessages: context.step.newMessages,
+              toolCalls: context.step.toolCalls,
+              toolResults: event.partialToolResults,
+              pendingToolCalls: event.pendingToolCalls,
+              usage: context.step.usage,
+              startedAt: context.step.startedAt
+            })
+          })
+        },
+        finishAllToolCalls: {
+          target: "FinishingStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, ...event.newMessages],
+              pendingToolCalls: void 0,
+              partialToolResults: void 0
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [...context.step.newMessages, ...event.newMessages],
+              toolResults: context.checkpoint.partialToolResults,
+              pendingToolCalls: void 0
+            })
+          })
         }
       }
     },
@@ -1591,13 +1861,13 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: event.newMessages,
-              toolCall: event.toolCall,
-              toolResult: event.toolResult,
+              toolCalls: event.toolCalls,
+              toolResults: event.toolResults,
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
         },
-        callTool: {
+        callTools: {
           target: "CallingTool",
           actions: assign({
             checkpoint: ({ context, event }) => ({
@@ -1609,7 +1879,7 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
-              toolCall: event.toolCall,
+              toolCalls: event.toolCalls,
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -1626,7 +1896,7 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
-              toolCall: event.toolCall,
+              toolCalls: [event.toolCall],
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -1643,7 +1913,7 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
-              toolCall: event.toolCall,
+              toolCalls: event.toolCalls,
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -1652,12 +1922,13 @@ var runtimeStateMachine = setup({
     },
     CallingTool: {
       on: {
-        resolveToolResult: {
+        resolveToolResults: {
           target: "ResolvingToolResult",
           actions: assign({
             step: ({ context, event }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolResults: event.toolResults,
+              pendingToolCalls: void 0
             })
           })
         },
@@ -1666,34 +1937,40 @@ var runtimeStateMachine = setup({
           actions: assign({
             step: ({ context, event }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolResults: [event.toolResult]
             })
           })
         },
-        resolvePdfFile: {
-          target: "ResolvingPdfFile",
+        attemptCompletion: {
+          target: "GeneratingRunResult",
           actions: assign({
             step: ({ context, event }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolResults: [event.toolResult]
             })
           })
         },
-        resolveImageFile: {
-          target: "ResolvingImageFile",
+        callDelegate: {
+          target: "CallingDelegate",
           actions: assign({
-            step: ({ context, event }) => ({
+            step: ({ context }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolCalls: context.step.toolCalls,
+              toolResults: context.step.toolResults,
+              pendingToolCalls: context.step.pendingToolCalls,
+              partialToolResults: context.step.partialToolResults
             })
           })
         },
-        attemptCompletion: {
-          target: "GeneratingRunResult",
+        callInteractiveTool: {
+          target: "CallingInteractiveTool",
           actions: assign({
-            step: ({ context, event }) => ({
+            step: ({ context }) => ({
               ...context.step,
-              toolResult: event.toolResult
+              toolCalls: context.step.toolCalls,
+              toolResults: context.step.toolResults,
+              pendingToolCalls: context.step.pendingToolCalls,
+              partialToolResults: context.step.partialToolResults
             })
           })
         }
@@ -1733,40 +2010,6 @@ var runtimeStateMachine = setup({
         }
       }
     },
-    ResolvingPdfFile: {
-      on: {
-        finishToolCall: {
-          target: "FinishingStep",
-          actions: assign({
-            checkpoint: ({ context, event }) => ({
-              ...context.checkpoint,
-              messages: [...context.checkpoint.messages, ...event.newMessages]
-            }),
-            step: ({ context, event }) => ({
-              ...context.step,
-              newMessages: [...context.step.newMessages, ...event.newMessages]
-            })
-          })
-        }
-      }
-    },
-    ResolvingImageFile: {
-      on: {
-        finishToolCall: {
-          target: "FinishingStep",
-          actions: assign({
-            checkpoint: ({ context, event }) => ({
-              ...context.checkpoint,
-              messages: [...context.checkpoint.messages, ...event.newMessages]
-            }),
-            step: ({ context, event }) => ({
-              ...context.step,
-              newMessages: [...context.step.newMessages, ...event.newMessages]
-            })
-          })
-        }
-      }
-    },
     GeneratingRunResult: {
       on: {
         retry: {
@@ -1780,8 +2023,8 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: event.newMessages,
-              toolCall: event.toolCall,
-              toolResult: event.toolResult,
+              toolCalls: event.toolCalls,
+              toolResults: event.toolResults,
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -1863,8 +2106,6 @@ var StateMachineLogics = {
   CallingTool: callingToolLogic,
   ResolvingToolResult: resolvingToolResultLogic,
   ResolvingThought: resolvingThoughtLogic,
-  ResolvingPdfFile: resolvingPdfFileLogic,
-  ResolvingImageFile: resolvingImageFileLogic,
   GeneratingRunResult: generatingRunResultLogic,
   CallingInteractiveTool: callingInteractiveToolLogic,
   CallingDelegate: callingDelegateLogic,
@@ -1903,7 +2144,7 @@ async function executeStateMachine(params) {
         } else {
           const event = await StateMachineLogics[runState.value](runState.context);
           if ("checkpoint" in event) {
-            await storeCheckpoint(event.checkpoint, event.timestamp);
+            await storeCheckpoint(event.checkpoint);
           }
           await eventEmitter.emit(event);
           if (shouldContinueRun) {
@@ -1992,10 +2233,15 @@ async function run(runInput, options) {
   const contextWindow = getContextWindow(setting.providerConfig.providerName, setting.model);
   const getRunDir = options?.getRunDir ?? defaultGetRunDir;
   await storeRunSetting(setting, options?.fileSystem, getRunDir);
+  let job = retrieveJob(setting.jobId) ?? createInitialJob(setting.jobId, setting.expertKey, setting.maxSteps);
+  if (job.status !== "running") {
+    job = { ...job, status: "running", finishedAt: void 0 };
+  }
+  storeJob(job);
   while (true) {
     const { expertToRun, experts } = await setupExperts(setting, options?.resolveExpertToRun);
     if (options?.eventListener) {
-      const initEvent = createRuntimeEvent("initializeRuntime", setting.runId, {
+      const initEvent = createRuntimeEvent("initializeRuntime", setting.jobId, setting.runId, {
         runtimeVersion: package_default.version,
         expertName: expertToRun.name,
         experts: Object.keys(experts),
@@ -2013,9 +2259,11 @@ async function run(runInput, options) {
       expertToRun,
       experts,
       setting,
-      options?.eventListener
+      options?.eventListener,
+      { isDelegatedRun: !!checkpoint?.delegatedBy }
     );
     const initialCheckpoint = checkpoint ? createNextStepCheckpoint(createId(), checkpoint) : createInitialCheckpoint(createId(), {
+      jobId: setting.jobId,
       runId: setting.runId,
       expertKey: setting.expertKey,
       expert: expertToRun,
@@ -2030,11 +2278,21 @@ async function run(runInput, options) {
       storeCheckpoint,
       shouldContinueRun: options?.shouldContinueRun
     });
+    job = {
+      ...job,
+      totalSteps: runResultCheckpoint.stepNumber,
+      usage: runResultCheckpoint.usage
+    };
     switch (runResultCheckpoint.status) {
       case "completed": {
+        if (options?.returnOnDelegationComplete) {
+          storeJob(job);
+          return runResultCheckpoint;
+        }
         if (runResultCheckpoint.delegatedBy) {
+          storeJob(job);
           const parentCheckpoint = await retrieveCheckpoint(
-            setting.runId,
+            setting.jobId,
             runResultCheckpoint.delegatedBy.checkpointId
           );
           const result = buildDelegationReturnState(setting, runResultCheckpoint, parentCheckpoint);
@@ -2042,21 +2300,80 @@ async function run(runInput, options) {
           checkpoint = result.checkpoint;
           break;
         }
+        storeJob({ ...job, status: "completed", finishedAt: Date.now() });
         return runResultCheckpoint;
       }
       case "stoppedByInteractiveTool": {
+        storeJob({ ...job, status: "stoppedByInteractiveTool" });
         return runResultCheckpoint;
       }
       case "stoppedByDelegate": {
-        const result = buildDelegateToState(setting, runResultCheckpoint, expertToRun);
-        setting = result.setting;
-        checkpoint = result.checkpoint;
+        storeJob(job);
+        const { delegateTo } = runResultCheckpoint;
+        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
+        );
+        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
+          ]
+        };
         break;
       }
       case "stoppedByExceededMaxSteps": {
+        storeJob({ ...job, status: "stoppedByMaxSteps", finishedAt: Date.now() });
         return runResultCheckpoint;
       }
       case "stoppedByError": {
+        storeJob({ ...job, status: "stoppedByError", finishedAt: Date.now() });
         return runResultCheckpoint;
       }
       default:
@@ -2073,10 +2390,65 @@ function getEventListener(options) {
     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
+  };
+}
 
 // src/index.ts
 var runtimeVersion = package_default.version;
 
-export { StateMachineLogics, calculateContextWindowUsage, getContextWindow, getModel, defaultGetRunDir as getRunDir, run, runtimeStateMachine, runtimeVersion };
+export { StateMachineLogics, calculateContextWindowUsage, createInitialJob, getAllJobs, getAllRuns, getCheckpointDir, getCheckpointPath, getCheckpointsByJobId, getContextWindow, getEventContents, getEventsByRun, getJobDir, getJobsDir, getModel, defaultGetRunDir as getRunDir, retrieveJob, run, runtimeStateMachine, runtimeVersion, storeJob };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map