@perstack/runtime 0.0.62 → 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, resolveToolResults, attemptCompletion, callDelegate, callInteractiveTool, stopRunByExceededMaxSteps, continueToNextStep, retry, completeRun, callTools, startRun, resumeToolCalls, finishAllToolCalls, startGeneration, finishToolCall, runParamsSchema, createRuntimeEvent, checkpointSchema, runSettingSchema } from '@perstack/core';
 import { createOllama } from 'ollama-ai-provider-v2';
 import { createId } from '@paralleldrive/cuid2';
-import { readdir, readFile, 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.62"};
+  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
         }
       }
@@ -200,10 +404,11 @@ function buildDelegationReturnState(currentSetting, resultCheckpoint, parentChec
 }
 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,
@@ -237,69 +442,6 @@ function buildDelegateToState(currentSetting, resultCheckpoint, currentExpert) {
     }
   };
 }
-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) {
@@ -332,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;
   }
@@ -385,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;
   }
@@ -418,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;
   }
@@ -445,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;
@@ -485,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
@@ -496,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()
           });
@@ -509,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,
@@ -545,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);
@@ -648,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");
@@ -676,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];
@@ -698,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);
   }
@@ -739,6 +885,10 @@ 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,
@@ -748,35 +898,44 @@ async function callingDelegateLogic({
   if (!step.pendingToolCalls || step.pendingToolCalls.length === 0) {
     throw new Error("No pending tool calls found");
   }
-  const toolCall = step.pendingToolCalls[0];
-  if (!toolCall) {
-    throw new Error("No pending tool call found");
-  }
-  const { id, toolName, args } = toolCall;
-  const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
-  if (!skillManager.expert) {
-    throw new Error(`Delegation error: skill manager "${toolName}" not found`);
-  }
-  if (!args || !args.query || typeof args.query !== "string") {
-    throw new Error("Delegation error: query is undefined");
+  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 currentToolCall = step.pendingToolCalls[0];
-  const remainingToolCalls = step.pendingToolCalls.slice(1);
-  return stopRunByDelegate(setting, checkpoint, {
-    checkpoint: {
-      ...checkpoint,
-      status: "stoppedByDelegate",
-      delegateTo: {
+  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
-      },
-      pendingToolCalls: [currentToolCall, ...remainingToolCalls],
+        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: {
@@ -844,9 +1003,9 @@ async function processFileToolResult(toolResult, toolName) {
       processedContents.push(part);
       continue;
     }
-    const { path: path2, mimeType } = fileInfo;
+    const { path: path4, mimeType } = fileInfo;
     try {
-      const buffer = await readFile(path2);
+      const buffer = await readFile(path4);
       if (toolName === "readImageFile") {
         processedContents.push({
           type: "imageInlinePart",
@@ -866,7 +1025,7 @@ async function processFileToolResult(toolResult, toolName) {
       processedContents.push({
         type: "textPart",
         id: part.id,
-        text: `Failed to read file "${path2}": ${error instanceof Error ? error.message : String(error)}`
+        text: `Failed to read file "${path4}": ${error instanceof Error ? error.message : String(error)}`
       });
     }
   }
@@ -889,7 +1048,7 @@ async function executeMcpToolCall(toolCall, skillManagers) {
   }
   return toolResult;
 }
-async function getToolType(toolCall, skillManagers) {
+async function getToolType2(toolCall, skillManagers) {
   const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
   return skillManager.type;
 }
@@ -917,7 +1076,7 @@ async function callingToolLogic({
   const toolCallTypes = await Promise.all(
     pendingToolCalls.map(async (tc) => ({
       toolCall: tc,
-      type: await getToolType(tc, skillManagers)
+      type: await getToolType2(tc, skillManagers)
     }))
   );
   const mcpToolCalls = toolCallTypes.filter((t) => t.type === "mcp").map((t) => t.toolCall);
@@ -929,17 +1088,12 @@ async function callingToolLogic({
     );
     toolResults.push(...mcpResults);
   }
-  const remainingToolCalls = [...delegateToolCalls, ...interactiveToolCalls];
   if (delegateToolCalls.length > 0) {
-    const delegateToolCall = delegateToolCalls[0];
-    if (!delegateToolCall) {
-      throw new Error("No delegate tool call found");
-    }
     step.partialToolResults = toolResults;
-    step.pendingToolCalls = remainingToolCalls;
+    step.pendingToolCalls = [...delegateToolCalls, ...interactiveToolCalls];
     return callDelegate(setting, checkpoint, {
       newMessage: checkpoint.messages[checkpoint.messages.length - 1],
-      toolCall: delegateToolCall,
+      toolCalls: delegateToolCalls,
       usage: step.usage
     });
   }
@@ -949,7 +1103,7 @@ async function callingToolLogic({
       throw new Error("No interactive tool call found");
     }
     step.partialToolResults = toolResults;
-    step.pendingToolCalls = remainingToolCalls;
+    step.pendingToolCalls = interactiveToolCalls;
     return callInteractiveTool(setting, checkpoint, {
       newMessage: checkpoint.messages[checkpoint.messages.length - 1],
       toolCall: interactiveToolCall,
@@ -1515,10 +1669,8 @@ async function initLogic({
       if (!setting.input.interactiveToolCallResult) {
         throw new Error("Interactive tool call result is undefined");
       }
-      const { toolCallId, toolName, text } = setting.input.interactiveToolCallResult;
+      const { toolCallId, toolName, skillName, text } = setting.input.interactiveToolCallResult;
       const pendingToolCalls = checkpoint.pendingToolCalls ?? [];
-      const completedToolCall = pendingToolCalls.find((tc) => tc.id === toolCallId);
-      const skillName = completedToolCall?.skillName ?? (checkpoint.status === "stoppedByDelegate" ? checkpoint.delegateTo?.expert.key : "") ?? "";
       const newToolResult = {
         id: toolCallId,
         skillName,
@@ -1761,7 +1913,7 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
-              toolCalls: [event.toolCall],
+              toolCalls: event.toolCalls,
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -1992,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) {
@@ -2081,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),
@@ -2102,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,
@@ -2119,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);
@@ -2131,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:
@@ -2162,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