@perstack/runtime 0.0.48 → 0.0.50

package/dist/src/index.js

@@ -1,27 +1,27 @@
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createAzure } from '@ai-sdk/azure';
+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 } from '@perstack/core';
 import { createOllama } from 'ollama-ai-provider-v2';
-import { existsSync } from 'fs';
-import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
-import path from 'path';
 import { createId } from '@paralleldrive/cuid2';
+import { readFile, readdir, mkdir, writeFile } from 'fs/promises';
+import path from 'path';
 import { setup, assign, createActor } from 'xstate';
-import { ApiV1Client } from '@perstack/api-client/v1';
+import { generateText, tool, jsonSchema } from 'ai';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
-import { generateText, tool, jsonSchema } from 'ai';
 import { dedent } from 'ts-dedent';
+import { ApiV1Client } from '@perstack/api-client/v1';
 
 // package.json
 var package_default = {
-  version: "0.0.48"};
+  version: "0.0.50"};
 function getModel(modelId, providerConfig) {
   switch (providerConfig.providerName) {
     case "anthropic": {
@@ -87,6 +87,14 @@ function getModel(modelId, providerConfig) {
       });
       return vertex(modelId);
     }
+    case "deepseek": {
+      const deepseek = createDeepSeek({
+        apiKey: providerConfig.apiKey,
+        baseURL: providerConfig.baseUrl,
+        headers: providerConfig.headers
+      });
+      return deepseek(modelId);
+    }
   }
 }
 function getContextWindow(providerName, modelId) {
@@ -96,8 +104,167 @@ function getContextWindow(providerName, modelId) {
 function calculateContextWindowUsage(usage, contextWindow) {
   return (usage.inputTokens + usage.cachedInputTokens + usage.outputTokens) / contextWindow;
 }
+
+// src/usage.ts
+function createEmptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+    cachedInputTokens: 0
+  };
+}
+function usageFromGenerateTextResult(result) {
+  return {
+    inputTokens: result.usage.inputTokens || 0,
+    outputTokens: result.usage.outputTokens || 0,
+    reasoningTokens: result.usage.reasoningTokens || 0,
+    totalTokens: result.usage.totalTokens || 0,
+    cachedInputTokens: result.usage.cachedInputTokens || 0
+  };
+}
+function sumUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    reasoningTokens: a.reasoningTokens + b.reasoningTokens,
+    totalTokens: a.totalTokens + b.totalTokens,
+    cachedInputTokens: a.cachedInputTokens + b.cachedInputTokens
+  };
+}
+
+// src/checkpoint-helpers.ts
+function createInitialCheckpoint(checkpointId, params) {
+  return {
+    id: checkpointId,
+    runId: params.runId,
+    expert: {
+      key: params.expertKey,
+      name: params.expert.name,
+      version: params.expert.version
+    },
+    stepNumber: 1,
+    status: "init",
+    messages: [],
+    usage: createEmptyUsage(),
+    contextWindow: params.contextWindow,
+    contextWindowUsage: params.contextWindow ? 0 : void 0
+  };
+}
+function createNextStepCheckpoint(checkpointId, checkpoint) {
+  return {
+    ...checkpoint,
+    id: checkpointId,
+    stepNumber: checkpoint.stepNumber + 1
+  };
+}
+function buildDelegationReturnState(currentSetting, resultCheckpoint, parentCheckpoint) {
+  const { messages, delegatedBy } = resultCheckpoint;
+  if (!delegatedBy) {
+    throw new Error("delegatedBy is required for buildDelegationReturnState");
+  }
+  const delegateResultMessage = messages[messages.length - 1];
+  if (!delegateResultMessage || delegateResultMessage.type !== "expertMessage") {
+    throw new Error("Delegation error: delegation result message is incorrect");
+  }
+  const delegateText = delegateResultMessage.contents.find((content) => content.type === "textPart");
+  if (!delegateText) {
+    throw new Error("Delegation error: delegation result message does not contain a text");
+  }
+  const { expert, toolCallId, toolName } = delegatedBy;
+  return {
+    setting: {
+      ...currentSetting,
+      expertKey: expert.key,
+      input: {
+        interactiveToolCallResult: {
+          toolCallId,
+          toolName,
+          text: delegateText.text
+        }
+      }
+    },
+    checkpoint: {
+      ...parentCheckpoint,
+      stepNumber: resultCheckpoint.stepNumber,
+      usage: resultCheckpoint.usage
+    }
+  };
+}
+function buildDelegateToState(currentSetting, resultCheckpoint, currentExpert) {
+  const { delegateTo } = resultCheckpoint;
+  if (!delegateTo) {
+    throw new Error("delegateTo is required for buildDelegateToState");
+  }
+  const { expert, toolCallId, toolName, query } = delegateTo;
+  return {
+    setting: {
+      ...currentSetting,
+      expertKey: expert.key,
+      input: {
+        text: query
+      }
+    },
+    checkpoint: {
+      ...resultCheckpoint,
+      status: "init",
+      messages: [],
+      expert: {
+        key: expert.key,
+        name: expert.name,
+        version: expert.version
+      },
+      delegatedBy: {
+        expert: {
+          key: currentExpert.key,
+          name: currentExpert.name,
+          version: currentExpert.version
+        },
+        toolCallId,
+        toolName,
+        checkpointId: resultCheckpoint.id
+      },
+      usage: resultCheckpoint.usage
+    }
+  };
+}
+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 = 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 = getRunDir(runId);
+  const runDir = defaultGetRunDir(runId);
   const checkpointFiles = await readdir(runDir, { withFileTypes: true }).then(
     (files) => files.filter((file) => file.isFile() && file.name.startsWith("checkpoint-"))
   );
@@ -111,14 +278,14 @@ async function defaultRetrieveCheckpoint(runId, checkpointId) {
 }
 async function defaultStoreCheckpoint(checkpoint, timestamp) {
   const { id, runId, stepNumber } = checkpoint;
-  const runDir = getRunDir(runId);
+  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 = getRunDir(runId);
+  const runDir = defaultGetRunDir(runId);
   const eventPath = `${runDir}/event-${timestamp}-${stepNumber}-${type}.json`;
   await mkdir(runDir, { recursive: true });
   await writeFile(eventPath, JSON.stringify(event));
@@ -138,76 +305,20 @@ var RunEventEmitter = class {
     }
   }
 };
-async function resolveExpertToRun(expertKey, experts, clientOptions) {
-  if (experts[expertKey]) {
-    return experts[expertKey];
-  }
-  const client = new ApiV1Client({
-    baseUrl: clientOptions.perstackApiBaseUrl,
-    apiKey: clientOptions.perstackApiKey
-  });
-  const { expert } = await client.registry.experts.get({ expertKey });
-  experts[expertKey] = toRuntimeExpert(expert);
-  return experts[expertKey];
-}
-function toRuntimeExpert(expert) {
-  const skills = Object.fromEntries(
-    Object.entries(expert.skills).map(([name, skill]) => {
-      switch (skill.type) {
-        case "mcpStdioSkill":
-          return [name, { ...skill, name }];
-        case "mcpSseSkill":
-          return [name, { ...skill, name }];
-        case "interactiveSkill":
-          return [name, { ...skill, name }];
-        default: {
-          throw new Error(`Unknown skill type: ${skill.type}`);
-        }
-      }
-    })
-  );
-  return { ...expert, skills };
-}
-var SkillManager = class {
+
+// src/skill-manager/base.ts
+var BaseSkillManager = class {
   _toolDefinitions = [];
   _initialized = false;
   _initializing;
-  name;
-  type;
-  lazyInit;
   skill;
   interactiveSkill;
   expert;
-  _mcpClient;
-  _params;
-  _env;
   _runId;
   _eventListener;
-  constructor(params, runId, eventListener) {
-    this._params = params;
+  constructor(runId, eventListener) {
     this._runId = runId;
     this._eventListener = eventListener;
-    this.type = params.type;
-    switch (params.type) {
-      case "mcp":
-        this.name = params.skill.name;
-        this.skill = params.skill;
-        this._env = params.env;
-        this.lazyInit = this.skill.type === "mcpStdioSkill" && this.skill.lazyInit && this.skill.name !== "@perstack/base";
-        break;
-      case "interactive":
-        this.name = params.interactiveSkill.name;
-        this.interactiveSkill = params.interactiveSkill;
-        this._env = {};
-        this.lazyInit = false;
-        break;
-      case "delegate":
-        this.name = params.expert.name;
-        this.expert = params.expert;
-        this._env = {};
-        this.lazyInit = false;
-        break;
-    }
   }
   async init() {
     if (this._initialized) {
@@ -232,75 +343,146 @@ var SkillManager = class {
     return this._initialized;
   }
   async _performInit() {
-    switch (this._params.type) {
-      case "mcp": {
-        await this._initMcpSkill(this._params);
-        break;
-      }
-      case "interactive": {
-        await this._initInteractiveSkill(this._params);
-        break;
-      }
-      case "delegate": {
-        await this._initDelegate(this._params);
-        break;
-      }
-    }
+    await this._doInit();
     this._initialized = true;
     this._initializing = void 0;
   }
-  async _initMcpSkill(params) {
-    if (this.isInitialized()) {
-      throw new Error(`Skill ${params.skill.name} is already initialized`);
+  async getToolDefinitions() {
+    if (!this.isInitialized() && !this.lazyInit) {
+      throw new Error(`Skill ${this.name} is not initialized`);
+    }
+    if (!this.isInitialized() && this.lazyInit) {
+      return [];
     }
+    return this._filterTools(this._toolDefinitions);
+  }
+  _filterTools(tools) {
+    return tools;
+  }
+};
+
+// src/skill-manager/delegate.ts
+var DelegateSkillManager = class extends BaseSkillManager {
+  name;
+  type = "delegate";
+  lazyInit = false;
+  expert;
+  constructor(expert, runId, eventListener) {
+    super(runId, eventListener);
+    this.name = expert.name;
+    this.expert = expert;
+  }
+  async _doInit() {
+    this._toolDefinitions = [
+      {
+        skillName: this.expert.name,
+        name: this.expert.name.split("/").pop() ?? this.expert.name,
+        description: this.expert.description,
+        inputSchema: {
+          type: "object",
+          properties: { query: { type: "string" } },
+          required: ["query"]
+        },
+        interactive: false
+      }
+    ];
+  }
+  async close() {
+  }
+  async callTool(_toolName, _input) {
+    return [];
+  }
+};
+
+// src/skill-manager/interactive.ts
+var InteractiveSkillManager = class extends BaseSkillManager {
+  name;
+  type = "interactive";
+  lazyInit = false;
+  interactiveSkill;
+  constructor(interactiveSkill, runId, eventListener) {
+    super(runId, eventListener);
+    this.name = interactiveSkill.name;
+    this.interactiveSkill = interactiveSkill;
+  }
+  async _doInit() {
+    this._toolDefinitions = Object.values(this.interactiveSkill.tools).map((tool2) => ({
+      skillName: this.interactiveSkill.name,
+      name: tool2.name,
+      description: tool2.description,
+      inputSchema: JSON.parse(tool2.inputJsonSchema),
+      interactive: true
+    }));
+  }
+  async close() {
+  }
+  async callTool(_toolName, _input) {
+    return [];
+  }
+};
+var McpSkillManager = class extends BaseSkillManager {
+  name;
+  type = "mcp";
+  lazyInit;
+  skill;
+  _mcpClient;
+  _env;
+  constructor(skill, env, runId, eventListener) {
+    super(runId, eventListener);
+    this.name = skill.name;
+    this.skill = skill;
+    this._env = env;
+    this.lazyInit = skill.type === "mcpStdioSkill" && skill.lazyInit && skill.name !== "@perstack/base";
+  }
+  async _doInit() {
     this._mcpClient = new Client({
-      name: `${params.skill.name}-mcp-client`,
+      name: `${this.skill.name}-mcp-client`,
       version: "1.0.0"
     });
-    switch (params.skill.type) {
-      case "mcpStdioSkill": {
-        if (!params.skill.command) {
-          throw new Error(`Skill ${params.skill.name} has no command`);
-        }
-        const env = {};
-        const { requiredEnv } = params.skill;
-        for (const envName of requiredEnv) {
-          if (!this._env[envName]) {
-            throw new Error(`Skill ${params.skill.name} requires environment variable ${envName}`);
-          }
-          env[envName] = this._env[envName];
-        }
-        const { command, args } = this._getCommandArgs(params.skill);
-        const transport = new StdioClientTransport({ command, args, env, stderr: "ignore" });
-        await this._mcpClient.connect(transport);
-        if (this._eventListener) {
-          const serverInfo = this._mcpClient.getServerVersion();
-          const event = createRuntimeEvent("skillConnected", this._runId, {
-            skillName: params.skill.name,
-            serverInfo: serverInfo ? { name: serverInfo.name, version: serverInfo.version } : void 0
-          });
-          this._eventListener(event);
-        }
-        break;
-      }
-      case "mcpSseSkill": {
-        if (!params.skill.endpoint) {
-          throw new Error(`Skill ${params.skill.name} has no endpoint`);
-        }
-        const transport = new SSEClientTransport(new URL(params.skill.endpoint));
-        await this._mcpClient.connect(transport);
-        break;
-      }
+    if (this.skill.type === "mcpStdioSkill") {
+      await this._initStdio(this.skill);
+    } else {
+      await this._initSse(this.skill);
     }
     const { tools } = await this._mcpClient.listTools();
     this._toolDefinitions = tools.map((tool2) => ({
-      skillName: params.skill.name,
+      skillName: this.skill.name,
       name: tool2.name,
       description: tool2.description,
       inputSchema: tool2.inputSchema,
       interactive: false
     }));
   }
+  async _initStdio(skill) {
+    if (!skill.command) {
+      throw new Error(`Skill ${skill.name} has no command`);
+    }
+    const env = {};
+    for (const envName of skill.requiredEnv) {
+      if (!this._env[envName]) {
+        throw new Error(`Skill ${skill.name} requires environment variable ${envName}`);
+      }
+      env[envName] = this._env[envName];
+    }
+    const { command, args } = this._getCommandArgs(skill);
+    const transport = new StdioClientTransport({ command, args, env, stderr: "ignore" });
+    await this._mcpClient.connect(transport);
+    if (this._eventListener) {
+      const serverInfo = this._mcpClient.getServerVersion();
+      const event = createRuntimeEvent("skillConnected", this._runId, {
+        skillName: skill.name,
+        serverInfo: serverInfo ? { name: serverInfo.name, version: serverInfo.version } : void 0
+      });
+      this._eventListener(event);
+    }
+  }
+  async _initSse(skill) {
+    if (!skill.endpoint) {
+      throw new Error(`Skill ${skill.name} has no endpoint`);
+    }
+    const transport = new SSEClientTransport(new URL(skill.endpoint));
+    await this._mcpClient.connect(transport);
+  }
   _getCommandArgs(skill) {
     const { name, command, packageName, args } = skill;
     if (!packageName && (!args || args.length === 0)) {
@@ -317,36 +499,6 @@ var SkillManager = class {
     }
     return { command, args: newArgs };
   }
-  async _initInteractiveSkill(params) {
-    if (this.isInitialized()) {
-      throw new Error(`Skill ${params.interactiveSkill.name} is already initialized`);
-    }
-    this._toolDefinitions = Object.values(params.interactiveSkill.tools).map((tool2) => ({
-      skillName: params.interactiveSkill.name,
-      name: tool2.name,
-      description: tool2.description,
-      inputSchema: JSON.parse(tool2.inputJsonSchema),
-      interactive: true
-    }));
-  }
-  async _initDelegate(params) {
-    if (this.isInitialized()) {
-      throw new Error(`Skill ${params.expert.name} is already initialized`);
-    }
-    this._toolDefinitions = [
-      {
-        skillName: params.expert.name,
-        name: params.expert.name.split("/").pop() ?? params.expert.name,
-        description: params.expert.description,
-        inputSchema: {
-          type: "object",
-          properties: { query: { type: "string" } },
-          required: ["query"]
-        },
-        interactive: false
-      }
-    ];
-  }
   async close() {
     if (this._mcpClient) {
       await this._mcpClient.close();
@@ -358,42 +510,23 @@ var SkillManager = class {
       }
     }
   }
-  async getToolDefinitions() {
-    if (!this.isInitialized() && !this.lazyInit) {
-      throw new Error(`Skill ${this.name} is not initialized`);
-    }
-    if (!this.isInitialized() && this.lazyInit) {
-      return [];
-    }
-    if (this._params.type === "mcp") {
-      const omit = this._params.skill.omit ?? [];
-      const pick = this._params.skill.pick ?? [];
-      return this._toolDefinitions.filter((tool2) => omit.length > 0 ? !omit.includes(tool2.name) : true).filter((tool2) => pick.length > 0 ? pick.includes(tool2.name) : true);
-    }
-    return this._toolDefinitions;
+  _filterTools(tools) {
+    const omit = this.skill.omit ?? [];
+    const pick = this.skill.pick ?? [];
+    return tools.filter((tool2) => omit.length > 0 ? !omit.includes(tool2.name) : true).filter((tool2) => pick.length > 0 ? pick.includes(tool2.name) : true);
   }
   async callTool(toolName, input) {
-    switch (this._params.type) {
-      case "mcp": {
-        if (!this.isInitialized() || !this._mcpClient) {
-          throw new Error(`${this.name} is not initialized`);
-        }
-        try {
-          const result = await this._mcpClient.callTool({
-            name: toolName,
-            arguments: input
-          });
-          return this._convertToolResult(result, toolName, input);
-        } catch (error) {
-          return this._handleToolError(error, toolName);
-        }
-      }
-      case "interactive": {
-        return [];
-      }
-      case "delegate": {
-        return [];
-      }
+    if (!this.isInitialized() || !this._mcpClient) {
+      throw new Error(`${this.name} is not initialized`);
+    }
+    try {
+      const result = await this._mcpClient.callTool({
+        name: toolName,
+        arguments: input
+      });
+      return this._convertToolResult(result, toolName, input);
+    } catch (error) {
+      return this._handleToolError(error, toolName);
     }
   }
   _handleToolError(error, toolName) {
@@ -462,79 +595,68 @@ var SkillManager = class {
     throw new Error(`Unsupported resource type: ${JSON.stringify(resource)}`);
   }
 };
+
+// src/skill-manager/helpers.ts
+async function initSkillManagersWithCleanup(managers, allManagers) {
+  const results = await Promise.allSettled(managers.map((m) => m.init()));
+  const firstRejected = results.find((r) => r.status === "rejected");
+  if (firstRejected) {
+    await Promise.all(allManagers.map((m) => m.close().catch(() => {
+    })));
+    throw firstRejected.reason;
+  }
+}
 async function getSkillManagers(expert, experts, setting, eventListener) {
   const { perstackBaseSkillCommand, env, runId } = setting;
-  const skillManagers = {};
   const { skills } = expert;
   if (!skills["@perstack/base"]) {
     throw new Error("Base skill is not defined");
   }
-  const mcpSkillManagers = await Promise.all(
-    Object.values(skills).filter((skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill").map(async (skill) => {
-      if (perstackBaseSkillCommand && skill.type === "mcpStdioSkill") {
-        const matchesBaseByPackage = skill.command === "npx" && skill.packageName === "@perstack/base";
-        const matchesBaseByArgs = skill.command === "npx" && Array.isArray(skill.args) && skill.args.includes("@perstack/base");
-        if (matchesBaseByPackage || matchesBaseByArgs) {
-          const [overrideCommand, ...overrideArgs] = perstackBaseSkillCommand;
-          if (!overrideCommand) {
-            throw new Error("perstackBaseSkillCommand must have at least one element");
-          }
-          skill.command = overrideCommand;
-          skill.packageName = void 0;
-          skill.args = overrideArgs;
-          skill.lazyInit = false;
+  const allManagers = [];
+  const mcpSkills = Object.values(skills).filter(
+    (skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill"
+  );
+  for (const skill of mcpSkills) {
+    if (perstackBaseSkillCommand && skill.type === "mcpStdioSkill") {
+      const matchesBaseByPackage = skill.command === "npx" && skill.packageName === "@perstack/base";
+      const matchesBaseByArgs = skill.command === "npx" && Array.isArray(skill.args) && skill.args.includes("@perstack/base");
+      if (matchesBaseByPackage || matchesBaseByArgs) {
+        const [overrideCommand, ...overrideArgs] = perstackBaseSkillCommand;
+        if (!overrideCommand) {
+          throw new Error("perstackBaseSkillCommand must have at least one element");
         }
+        skill.command = overrideCommand;
+        skill.packageName = void 0;
+        skill.args = overrideArgs;
+        skill.lazyInit = false;
       }
-      const skillManager = new SkillManager(
-        {
-          type: "mcp",
-          skill,
-          env
-        },
-        runId,
-        eventListener
-      );
-      await skillManager.init();
-      return skillManager;
-    })
-  );
-  const interactiveSkillManagers = await Promise.all(
-    Object.values(skills).filter((skill) => skill.type === "interactiveSkill").map(async (interactiveSkill) => {
-      const skillManager = new SkillManager(
-        {
-          type: "interactive",
-          interactiveSkill
-        },
-        runId,
-        eventListener
-      );
-      await skillManager.init();
-      return skillManager;
-    })
-  );
-  const delegateSkillManagers = await Promise.all(
-    expert.delegates.map(async (delegateExpertName) => {
-      const delegate = experts[delegateExpertName];
-      const skillManager = new SkillManager(
-        {
-          type: "delegate",
-          expert: delegate
-        },
-        runId,
-        eventListener
-      );
-      await skillManager.init();
-      return skillManager;
-    })
-  );
-  for (const skillManager of mcpSkillManagers) {
-    skillManagers[skillManager.name] = skillManager;
-  }
-  for (const skillManager of interactiveSkillManagers) {
-    skillManagers[skillManager.name] = skillManager;
+    }
   }
-  for (const skillManager of delegateSkillManagers) {
-    skillManagers[skillManager.name] = skillManager;
+  const mcpSkillManagers = mcpSkills.map((skill) => {
+    const manager = new McpSkillManager(skill, env, 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);
+  const delegateSkillManagers = expert.delegates.map((delegateExpertName) => {
+    const delegate = experts[delegateExpertName];
+    const manager = new DelegateSkillManager(delegate, runId, eventListener);
+    allManagers.push(manager);
+    return manager;
+  });
+  await initSkillManagersWithCleanup(delegateSkillManagers, allManagers);
+  const skillManagers = {};
+  for (const manager of allManagers) {
+    skillManagers[manager.name] = manager;
   }
   return skillManagers;
 }
@@ -603,7 +725,7 @@ async function callingDelegateLogic({
     },
     step: {
       ...step,
-      finishedAt: (/* @__PURE__ */ new Date()).getTime()
+      finishedAt: Date.now()
     }
   });
 }
@@ -860,54 +982,23 @@ function toolCallPartToCoreToolCallPart(part) {
   };
 }
 function toolResultPartToCoreToolResultPart(part) {
-  const content = part.contents[0];
-  const output = content.type === "textPart" ? {
-    type: "text",
-    value: content.text
-  } : {
-    type: "content",
-    value: [
-      {
-        type: "media",
-        data: content.encodedData,
-        mediaType: content.mimeType
-      }
-    ]
-  };
+  const { contents } = part;
+  if (contents.length === 1 && contents[0].type === "textPart") {
+    return {
+      type: "tool-result",
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      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 }
+  );
   return {
     type: "tool-result",
     toolCallId: part.toolCallId,
     toolName: part.toolName,
-    output
-  };
-}
-
-// src/usage.ts
-function createEmptyUsage() {
-  return {
-    inputTokens: 0,
-    outputTokens: 0,
-    reasoningTokens: 0,
-    totalTokens: 0,
-    cachedInputTokens: 0
-  };
-}
-function usageFromGenerateTextResult(result) {
-  return {
-    inputTokens: result.usage.inputTokens || 0,
-    outputTokens: result.usage.outputTokens || 0,
-    reasoningTokens: result.usage.reasoningTokens || 0,
-    totalTokens: result.usage.totalTokens || 0,
-    cachedInputTokens: result.usage.cachedInputTokens || 0
-  };
-}
-function sumUsage(a, b) {
-  return {
-    inputTokens: a.inputTokens + b.inputTokens,
-    outputTokens: a.outputTokens + b.outputTokens,
-    reasoningTokens: a.reasoningTokens + b.reasoningTokens,
-    totalTokens: a.totalTokens + b.totalTokens,
-    cachedInputTokens: a.cachedInputTokens + b.cachedInputTokens
+    output: { type: "content", value: contentValue }
   };
 }
 
@@ -995,7 +1086,6 @@ async function generatingToolCallLogic({
     });
   } catch (error) {
     if (error instanceof Error) {
-      console.error(error);
       const reason = JSON.stringify({ error: error.name, message: error.message });
       return retry(setting, checkpoint, {
         reason,
@@ -1729,6 +1819,114 @@ var StateMachineLogics = {
   FinishingStep: finishingStepLogic
 };
 
+// src/execute-state-machine.ts
+async function executeStateMachine(params) {
+  const {
+    setting,
+    initialCheckpoint,
+    eventListener,
+    skillManagers,
+    eventEmitter,
+    storeCheckpoint,
+    shouldContinueRun
+  } = params;
+  const runActor = createActor(runtimeStateMachine, {
+    input: {
+      setting,
+      initialCheckpoint,
+      eventListener,
+      skillManagers
+    }
+  });
+  return new Promise((resolve, reject) => {
+    runActor.subscribe(async (runState) => {
+      try {
+        if (runState.value === "Stopped") {
+          const { checkpoint, skillManagers: skillManagers2 } = runState.context;
+          if (!checkpoint) {
+            throw new Error("Checkpoint is undefined");
+          }
+          await closeSkillManagers(skillManagers2);
+          resolve(checkpoint);
+        } else {
+          const event = await StateMachineLogics[runState.value](runState.context);
+          if ("checkpoint" in event) {
+            await storeCheckpoint(event.checkpoint, event.timestamp);
+          }
+          await eventEmitter.emit(event);
+          if (shouldContinueRun) {
+            const shouldContinue = await shouldContinueRun(
+              runState.context.setting,
+              runState.context.checkpoint,
+              runState.context.step
+            );
+            if (!shouldContinue) {
+              runActor.stop();
+              await closeSkillManagers(runState.context.skillManagers);
+              resolve(runState.context.checkpoint);
+              return;
+            }
+          }
+          runActor.send(event);
+        }
+      } catch (error) {
+        await closeSkillManagers(skillManagers).catch(() => {
+        });
+        reject(error);
+      }
+    });
+    runActor.start();
+  });
+}
+async function resolveExpertToRun(expertKey, experts, clientOptions) {
+  if (experts[expertKey]) {
+    return experts[expertKey];
+  }
+  const client = new ApiV1Client({
+    baseUrl: clientOptions.perstackApiBaseUrl,
+    apiKey: clientOptions.perstackApiKey
+  });
+  const { expert } = await client.registry.experts.get({ expertKey });
+  experts[expertKey] = toRuntimeExpert(expert);
+  return experts[expertKey];
+}
+function toRuntimeExpert(expert) {
+  const skills = Object.fromEntries(
+    Object.entries(expert.skills).map(([name, skill]) => {
+      switch (skill.type) {
+        case "mcpStdioSkill":
+          return [name, { ...skill, name }];
+        case "mcpSseSkill":
+          return [name, { ...skill, name }];
+        case "interactiveSkill":
+          return [name, { ...skill, name }];
+        default: {
+          throw new Error(`Unknown skill type: ${skill.type}`);
+        }
+      }
+    })
+  );
+  return { ...expert, skills };
+}
+
+// src/setup-experts.ts
+async function setupExperts(setting, resolveExpertToRun2 = resolveExpertToRun) {
+  const { expertKey } = setting;
+  const experts = { ...setting.experts };
+  const clientOptions = {
+    perstackApiBaseUrl: setting.perstackApiBaseUrl,
+    perstackApiKey: setting.perstackApiKey
+  };
+  const expertToRun = await resolveExpertToRun2(expertKey, experts, clientOptions);
+  for (const delegateName of expertToRun.delegates) {
+    const delegate = await resolveExpertToRun2(delegateName, experts, clientOptions);
+    if (!delegate) {
+      throw new Error(`Delegate ${delegateName} not found`);
+    }
+  }
+  return { expertToRun, experts };
+}
+
 // src/runtime.ts
 async function run(runInput, options) {
   const runParams = runParamsSchema.parse(runInput);
@@ -1739,15 +1937,10 @@ async function run(runInput, options) {
   eventEmitter.subscribe(eventListener);
   let { setting, checkpoint } = runParams;
   const contextWindow = getContextWindow(setting.providerConfig.providerName, setting.model);
-  if (setting.workspace) {
-    if (!path.isAbsolute(setting.workspace)) {
-      throw new Error(`Workspace path must be absolute: ${setting.workspace}`);
-    }
-    process.chdir(setting.workspace);
-  }
-  await storeRunSetting(setting);
+  const getRunDir = options?.getRunDir ?? defaultGetRunDir;
+  await storeRunSetting(setting, options?.fileSystem, getRunDir);
   while (true) {
-    const { expertToRun, experts } = await setupExperts(setting);
+    const { expertToRun, experts } = await setupExperts(setting, options?.resolveExpertToRun);
     if (options?.eventListener) {
       const initEvent = createRuntimeEvent("initializeRuntime", setting.runId, {
         runtimeVersion: package_default.version,
@@ -1769,102 +1962,31 @@ async function run(runInput, options) {
       setting,
       options?.eventListener
     );
-    const runActor = createActor(runtimeStateMachine, {
-      input: {
-        setting: {
-          ...setting,
-          experts
-        },
-        initialCheckpoint: checkpoint ? {
-          ...checkpoint,
-          id: createId(),
-          stepNumber: checkpoint.stepNumber + 1
-        } : {
-          id: createId(),
-          runId: setting.runId,
-          expert: {
-            key: setting.expertKey,
-            name: expertToRun.name,
-            version: expertToRun.version
-          },
-          stepNumber: 1,
-          status: "init",
-          messages: [],
-          usage: createEmptyUsage(),
-          contextWindow,
-          contextWindowUsage: contextWindow ? 0 : void 0
-        },
-        eventListener,
-        skillManagers
-      }
+    const initialCheckpoint = checkpoint ? createNextStepCheckpoint(createId(), checkpoint) : createInitialCheckpoint(createId(), {
+      runId: setting.runId,
+      expertKey: setting.expertKey,
+      expert: expertToRun,
+      contextWindow
     });
-    const runResultCheckpoint = await new Promise((resolve, reject) => {
-      runActor.subscribe(async (runState) => {
-        try {
-          if (runState.value === "Stopped") {
-            const { checkpoint: checkpoint2, skillManagers: skillManagers2 } = runState.context;
-            if (!checkpoint2) {
-              throw new Error("Checkpoint is undefined");
-            }
-            await closeSkillManagers(skillManagers2);
-            resolve(checkpoint2);
-          } else {
-            const event = await StateMachineLogics[runState.value](runState.context);
-            if ("checkpoint" in event) {
-              await storeCheckpoint(event.checkpoint, event.timestamp);
-            }
-            await eventEmitter.emit(event);
-            if (options?.shouldContinueRun) {
-              const shouldContinue = await options.shouldContinueRun(
-                runState.context.setting,
-                runState.context.checkpoint,
-                runState.context.step
-              );
-              if (!shouldContinue) {
-                runActor.stop();
-                resolve(runState.context.checkpoint);
-                return;
-              }
-            }
-            runActor.send(event);
-          }
-        } catch (error) {
-          reject(error);
-        }
-      });
-      runActor.start();
+    const runResultCheckpoint = await executeStateMachine({
+      setting: { ...setting, experts },
+      initialCheckpoint,
+      eventListener,
+      skillManagers,
+      eventEmitter,
+      storeCheckpoint,
+      shouldContinueRun: options?.shouldContinueRun
     });
     switch (runResultCheckpoint.status) {
       case "completed": {
         if (runResultCheckpoint.delegatedBy) {
-          const { messages, delegatedBy } = runResultCheckpoint;
-          const { expert, toolCallId, toolName, checkpointId } = delegatedBy;
-          const delegateResultMessage = messages[messages.length - 1];
-          if (delegateResultMessage.type !== "expertMessage") {
-            throw new Error("Delegation error: delegation result message is incorrect");
-          }
-          const delegateText = delegateResultMessage.contents.find(
-            (content) => content.type === "textPart"
+          const parentCheckpoint = await retrieveCheckpoint(
+            setting.runId,
+            runResultCheckpoint.delegatedBy.checkpointId
           );
-          if (!delegateText) {
-            throw new Error("Delegation error: delegation result message does not contain a text");
-          }
-          setting = {
-            ...setting,
-            expertKey: expert.key,
-            input: {
-              interactiveToolCallResult: {
-                toolCallId,
-                toolName,
-                text: delegateText.text
-              }
-            }
-          };
-          checkpoint = {
-            ...await retrieveCheckpoint(setting.runId, checkpointId),
-            stepNumber: runResultCheckpoint.stepNumber,
-            usage: runResultCheckpoint.usage
-          };
+          const result = buildDelegationReturnState(setting, runResultCheckpoint, parentCheckpoint);
+          setting = result.setting;
+          checkpoint = result.checkpoint;
           break;
         }
         return runResultCheckpoint;
@@ -1873,38 +1995,9 @@ async function run(runInput, options) {
         return runResultCheckpoint;
       }
       case "stoppedByDelegate": {
-        if (!runResultCheckpoint.delegateTo) {
-          throw new Error("Delegation error: delegate to is undefined");
-        }
-        const { expert, toolCallId, toolName, query } = runResultCheckpoint.delegateTo;
-        setting = {
-          ...setting,
-          expertKey: expert.key,
-          input: {
-            text: query
-          }
-        };
-        checkpoint = {
-          ...runResultCheckpoint,
-          status: "init",
-          messages: [],
-          expert: {
-            key: expert.key,
-            name: expert.name,
-            version: expert.version
-          },
-          delegatedBy: {
-            expert: {
-              key: expertToRun.key,
-              name: expertToRun.name,
-              version: expertToRun.version
-            },
-            toolCallId,
-            toolName,
-            checkpointId: runResultCheckpoint.id
-          },
-          usage: runResultCheckpoint.usage
-        };
+        const result = buildDelegateToState(setting, runResultCheckpoint, expertToRun);
+        setting = result.setting;
+        checkpoint = result.checkpoint;
         break;
       }
       case "stoppedByExceededMaxSteps": {
@@ -1918,22 +2011,6 @@ async function run(runInput, options) {
     }
   }
 }
-async function setupExperts(setting) {
-  const { expertKey } = setting;
-  const experts = { ...setting.experts };
-  const clientOptions = {
-    perstackApiBaseUrl: setting.perstackApiBaseUrl,
-    perstackApiKey: setting.perstackApiKey
-  };
-  const expertToRun = await resolveExpertToRun(expertKey, experts, clientOptions);
-  for (const delegateName of expertToRun.delegates) {
-    const delegate = await resolveExpertToRun(delegateName, experts, clientOptions);
-    if (!delegate) {
-      throw new Error(`Delegate ${delegateName} not found`);
-    }
-  }
-  return { expertToRun, experts };
-}
 function getEventListener(options) {
   const listener = options?.eventListener ?? ((e) => console.log(JSON.stringify(e)));
   return async (event) => {
@@ -1943,25 +2020,10 @@ function getEventListener(options) {
     listener(event);
   };
 }
-async function storeRunSetting(setting) {
-  const runDir = getRunDir(setting.runId);
-  if (existsSync(runDir)) {
-    const runSettingPath = path.resolve(runDir, "run-setting.json");
-    const runSetting = JSON.parse(await readFile(runSettingPath, "utf-8"));
-    runSetting.updatedAt = Date.now();
-    await writeFile(runSettingPath, JSON.stringify(runSetting), "utf-8");
-  } else {
-    await mkdir(runDir, { recursive: true });
-    await writeFile(path.resolve(runDir, "run-setting.json"), JSON.stringify(setting), "utf-8");
-  }
-}
-function getRunDir(runId) {
-  return `${process.cwd()}/perstack/runs/${runId}`;
-}
 
 // src/index.ts
 var runtimeVersion = package_default.version;
 
-export { StateMachineLogics, calculateContextWindowUsage, getContextWindow, getModel, getRunDir, run, runtimeStateMachine, runtimeVersion };
+export { StateMachineLogics, calculateContextWindowUsage, getContextWindow, getModel, defaultGetRunDir as getRunDir, run, runtimeStateMachine, runtimeVersion };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map