@perstack/runtime 0.0.62 → 0.0.64

package/dist/chunk-C7AFEVYF.js

@@ -0,0 +1,2355 @@
+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 { runParamsSchema, createRuntimeEvent, knownModels, stopRunByExceededMaxSteps, continueToNextStep, stopRunByDelegate, stopRunByInteractiveTool, retry, completeRun, finishToolCall, resolveToolResults, attemptCompletion, callDelegate, callInteractiveTool, callTools, resumeToolCalls, finishAllToolCalls, startGeneration, startRun } from '@perstack/core';
+import { createOllama } from 'ollama-ai-provider-v2';
+import { ProxyAgent, fetch } from 'undici';
+import { setup, assign, createActor } from 'xstate';
+import { generateText, tool, jsonSchema } from 'ai';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+import { createId } from '@paralleldrive/cuid2';
+import { readFile } from 'fs/promises';
+import { dedent } from 'ts-dedent';
+import { ApiV1Client } from '@perstack/api-client/v1';
+
+// package.json
+var package_default = {
+  name: "@perstack/runtime",
+  version: "0.0.63",
+  description: "Perstack Runtime",
+  author: "Wintermute Technologies, Inc.",
+  license: "Apache-2.0",
+  type: "module",
+  bin: {
+    "perstack-runtime": "./bin/cli.ts"
+  },
+  exports: {
+    ".": "./src/index.ts"
+  },
+  publishConfig: {
+    access: "public",
+    bin: {
+      "perstack-runtime": "dist/bin/cli.js"
+    },
+    exports: {
+      ".": "./dist/src/index.js"
+    },
+    types: {
+      ".": "./dist/src/index.d.ts"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    clean: "rm -rf dist",
+    build: "pnpm run clean && tsup --config ./tsup.config.ts",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    commander: "^14.0.2",
+    dotenv: "^17.2.3",
+    "smol-toml": "^1.5.2",
+    "@ai-sdk/amazon-bedrock": "^3.0.62",
+    "@ai-sdk/anthropic": "^2.0.50",
+    "@ai-sdk/azure": "^2.0.77",
+    "@ai-sdk/deepseek": "^1.0.16",
+    "@ai-sdk/google": "^2.0.44",
+    "@ai-sdk/google-vertex": "^3.0.24",
+    "@ai-sdk/openai": "^2.0.75",
+    "@modelcontextprotocol/sdk": "^1.23.0",
+    "@paralleldrive/cuid2": "^3.0.4",
+    "@perstack/api-client": "workspace:*",
+    "@perstack/core": "workspace:*",
+    ai: "^5.0.104",
+    "ollama-ai-provider-v2": "^1.5.5",
+    "ts-dedent": "^2.2.0",
+    xstate: "^5.24.0",
+    undici: "^7.9.0"
+  },
+  devDependencies: {
+    "@tsconfig/node22": "^22.0.5",
+    "@types/node": "^24.10.1",
+    tsup: "^8.5.1",
+    typescript: "^5.9.3",
+    vitest: "^4.0.14"
+  },
+  engines: {
+    node: ">=22.0.0"
+  }
+};
+function createProxyFetch(proxyUrl) {
+  const agent = new ProxyAgent(proxyUrl);
+  return (input, init) => {
+    return fetch(input, { ...init, dispatcher: agent });
+  };
+}
+function getModel(modelId, providerConfig, options) {
+  const customFetch = options?.proxyUrl ? createProxyFetch(options.proxyUrl) : void 0;
+  switch (providerConfig.providerName) {
+    case "anthropic": {
+      const anthropic = createAnthropic({
+        apiKey: providerConfig.apiKey,
+        baseURL: providerConfig.baseUrl,
+        headers: providerConfig.headers,
+        fetch: customFetch
+      });
+      return anthropic(modelId);
+    }
+    case "google": {
+      const google = createGoogleGenerativeAI({
+        apiKey: providerConfig.apiKey,
+        baseURL: providerConfig.baseUrl,
+        headers: providerConfig.headers,
+        fetch: customFetch
+      });
+      return google(modelId);
+    }
+    case "openai": {
+      const openai = createOpenAI({
+        apiKey: providerConfig.apiKey,
+        baseURL: providerConfig.baseUrl,
+        organization: providerConfig.organization,
+        project: providerConfig.project,
+        name: providerConfig.name,
+        headers: providerConfig.headers,
+        fetch: customFetch
+      });
+      return openai(modelId);
+    }
+    case "ollama": {
+      const ollama = createOllama({
+        baseURL: providerConfig.baseUrl,
+        headers: providerConfig.headers,
+        fetch: customFetch
+      });
+      return ollama(modelId);
+    }
+    case "azure-openai": {
+      const azure = createAzure({
+        apiKey: providerConfig.apiKey,
+        resourceName: providerConfig.resourceName,
+        apiVersion: providerConfig.apiVersion,
+        baseURL: providerConfig.baseUrl,
+        headers: providerConfig.headers,
+        useDeploymentBasedUrls: providerConfig.useDeploymentBasedUrls,
+        fetch: customFetch
+      });
+      return azure(modelId);
+    }
+    case "amazon-bedrock": {
+      const amazonBedrock = createAmazonBedrock({
+        accessKeyId: providerConfig.accessKeyId,
+        secretAccessKey: providerConfig.secretAccessKey,
+        region: providerConfig.region,
+        sessionToken: providerConfig.sessionToken,
+        fetch: customFetch
+      });
+      return amazonBedrock(modelId);
+    }
+    case "google-vertex": {
+      const vertex = createVertex({
+        project: providerConfig.project,
+        location: providerConfig.location,
+        baseURL: providerConfig.baseUrl,
+        headers: providerConfig.headers,
+        fetch: customFetch
+      });
+      return vertex(modelId);
+    }
+    case "deepseek": {
+      const deepseek = createDeepSeek({
+        apiKey: providerConfig.apiKey,
+        baseURL: providerConfig.baseUrl,
+        headers: providerConfig.headers,
+        fetch: customFetch
+      });
+      return deepseek(modelId);
+    }
+    default: {
+      const _exhaustive = providerConfig;
+      throw new Error(`Unknown provider: ${_exhaustive.providerName}`);
+    }
+  }
+}
+function getContextWindow(providerName, modelId) {
+  const modelConfig = knownModels.find((model) => model.provider === providerName)?.models.find((model) => model.name === modelId);
+  return modelConfig?.contextWindow;
+}
+function calculateContextWindowUsage(usage, contextWindow) {
+  return (usage.inputTokens + usage.cachedInputTokens + usage.outputTokens) / contextWindow;
+}
+
+// src/helpers/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/skill-manager/base.ts
+var BaseSkillManager = class {
+  _toolDefinitions = [];
+  _initialized = false;
+  _initializing;
+  skill;
+  interactiveSkill;
+  expert;
+  _jobId;
+  _runId;
+  _eventListener;
+  constructor(jobId, runId, eventListener) {
+    this._jobId = jobId;
+    this._runId = runId;
+    this._eventListener = eventListener;
+  }
+  async init() {
+    if (this._initialized) {
+      throw new Error(`Skill ${this.name} is already initialized`);
+    }
+    if (this._initializing) {
+      throw new Error(`Skill ${this.name} is already initializing`);
+    }
+    const initPromise = this._performInit();
+    this._initializing = initPromise;
+    if (!this.lazyInit) {
+      try {
+        await initPromise;
+      } catch (error) {
+        this._initialized = false;
+        this._initializing = void 0;
+        throw error;
+      }
+    }
+  }
+  isInitialized() {
+    return this._initialized;
+  }
+  async _performInit() {
+    await this._doInit();
+    this._initialized = true;
+    this._initializing = void 0;
+  }
+  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, jobId, runId, eventListener) {
+    super(jobId, 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, jobId, runId, eventListener) {
+    super(jobId, 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, jobId, runId, eventListener) {
+    super(jobId, 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: `${this.skill.name}-mcp-client`,
+      version: "1.0.0"
+    });
+    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: 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 startTime = Date.now();
+    const { command, args } = this._getCommandArgs(skill);
+    if (this._eventListener) {
+      const event = createRuntimeEvent("skillStarting", this._jobId, this._runId, {
+        skillName: skill.name,
+        command,
+        args
+      });
+      this._eventListener(event);
+    }
+    const transport = new StdioClientTransport({ command, args, env, stderr: "pipe" });
+    if (transport.stderr) {
+      transport.stderr.on("data", (chunk) => {
+        if (this._eventListener) {
+          const event = createRuntimeEvent("skillStderr", this._jobId, this._runId, {
+            skillName: skill.name,
+            message: chunk.toString().trim()
+          });
+          this._eventListener(event);
+        }
+      });
+    }
+    const connectStartTime = Date.now();
+    await this._mcpClient.connect(transport);
+    const connectTime = Date.now();
+    if (this._eventListener) {
+      const serverInfo = this._mcpClient.getServerVersion();
+      const event = createRuntimeEvent("skillConnected", this._jobId, this._runId, {
+        skillName: skill.name,
+        serverInfo: serverInfo ? { name: serverInfo.name, version: serverInfo.version } : void 0,
+        connectDurationMs: connectTime - connectStartTime,
+        totalDurationMs: connectTime - startTime
+      });
+      this._eventListener(event);
+    }
+  }
+  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)) {
+      throw new Error(`Skill ${name} has no packageName or args. Please provide one of them.`);
+    }
+    if (packageName && args && args.length > 0) {
+      throw new Error(
+        `Skill ${name} has both packageName and args. Please provide only one of them.`
+      );
+    }
+    let newArgs = args && args.length > 0 ? args : [packageName];
+    if (command === "npx" && !newArgs.includes("-y")) {
+      newArgs = ["-y", ...newArgs];
+    }
+    return { command, args: newArgs };
+  }
+  async close() {
+    if (this._mcpClient) {
+      await this._mcpClient.close();
+      if (this._eventListener && this.skill) {
+        const event = createRuntimeEvent("skillDisconnected", this._jobId, this._runId, {
+          skillName: this.skill.name
+        });
+        this._eventListener(event);
+      }
+    }
+  }
+  _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) {
+    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) {
+    if (error instanceof McpError) {
+      return [
+        {
+          type: "textPart",
+          text: `Error calling tool ${toolName}: ${error.message}`,
+          id: createId()
+        }
+      ];
+    }
+    throw error;
+  }
+  _convertToolResult(result, toolName, input) {
+    if (!result.content || result.content.length === 0) {
+      return [
+        {
+          type: "textPart",
+          text: `Tool ${toolName} returned nothing with arguments: ${JSON.stringify(input)}`,
+          id: createId()
+        }
+      ];
+    }
+    return result.content.filter((part) => part.type !== "audio" && part.type !== "resource_link").map((part) => this._convertPart(part));
+  }
+  _convertPart(part) {
+    switch (part.type) {
+      case "text":
+        if (!part.text || part.text === "") {
+          return { type: "textPart", text: "Error: No content", id: createId() };
+        }
+        return { type: "textPart", text: part.text, id: createId() };
+      case "image":
+        if (!part.data || !part.mimeType) {
+          throw new Error("Image part must have both data and mimeType");
+        }
+        return {
+          type: "imageInlinePart",
+          encodedData: part.data,
+          mimeType: part.mimeType,
+          id: createId()
+        };
+      case "resource":
+        if (!part.resource) {
+          throw new Error("Resource part must have resource content");
+        }
+        return this._convertResource(part.resource);
+    }
+  }
+  _convertResource(resource) {
+    if (!resource.mimeType) {
+      throw new Error(`Resource ${JSON.stringify(resource)} has no mimeType`);
+    }
+    if (resource.text && typeof resource.text === "string") {
+      return { type: "textPart", text: resource.text, id: createId() };
+    }
+    if (resource.blob && typeof resource.blob === "string") {
+      return {
+        type: "fileInlinePart",
+        encodedData: resource.blob,
+        mimeType: resource.mimeType,
+        id: createId()
+      };
+    }
+    throw new Error(`Unsupported resource type: ${JSON.stringify(resource)}`);
+  }
+};
+
+// 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, options) {
+  const { perstackBaseSkillCommand, env, jobId, runId } = setting;
+  const { skills } = expert;
+  if (!skills["@perstack/base"]) {
+    throw new Error("Base skill is not defined");
+  }
+  const allManagers = [];
+  const mcpSkills = Object.values(skills).filter((skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill").map((skill) => {
+    if (perstackBaseSkillCommand && skill.type === "mcpStdioSkill") {
+      const matchesBaseByPackage = skill.command === "npx" && skill.packageName === "@perstack/base";
+      const matchesBaseByArgs = skill.command === "npx" && Array.isArray(skill.args) && skill.args.includes("@perstack/base");
+      if (matchesBaseByPackage || matchesBaseByArgs) {
+        const [overrideCommand, ...overrideArgs] = perstackBaseSkillCommand;
+        if (!overrideCommand) {
+          throw new Error("perstackBaseSkillCommand must have at least one element");
+        }
+        return {
+          ...skill,
+          command: overrideCommand,
+          packageName: void 0,
+          args: overrideArgs,
+          lazyInit: false
+        };
+      }
+    }
+    return skill;
+  });
+  const mcpSkillManagers = mcpSkills.map((skill) => {
+    const manager = new McpSkillManager(skill, env, jobId, runId, eventListener);
+    allManagers.push(manager);
+    return manager;
+  });
+  await initSkillManagersWithCleanup(mcpSkillManagers, 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];
+    if (!delegate) {
+      await Promise.all(allManagers.map((m) => m.close().catch(() => {
+      })));
+      throw new Error(`Delegate expert "${delegateExpertName}" not found in experts`);
+    }
+    const manager = new DelegateSkillManager(delegate, jobId, runId, eventListener);
+    allManagers.push(manager);
+    delegateSkillManagers.push(manager);
+  }
+  await initSkillManagersWithCleanup(delegateSkillManagers, allManagers);
+  const skillManagers = {};
+  for (const manager of allManagers) {
+    skillManagers[manager.name] = manager;
+  }
+  return skillManagers;
+}
+async function closeSkillManagers(skillManagers) {
+  await Promise.all(Object.values(skillManagers).map((m) => m.close().catch(() => {
+  })));
+}
+async function getSkillManagerByToolName(skillManagers, toolName) {
+  for (const skillManager of Object.values(skillManagers)) {
+    const toolDefinitions = await skillManager.getToolDefinitions();
+    for (const toolDefinition of toolDefinitions) {
+      if (toolDefinition.name === toolName) {
+        return skillManager;
+      }
+    }
+  }
+  throw new Error(`Tool ${toolName} not found`);
+}
+async function getToolSet(skillManagers) {
+  const tools = {};
+  for (const skillManager of Object.values(skillManagers)) {
+    const toolDefinitions = await skillManager.getToolDefinitions();
+    for (const toolDefinition of toolDefinitions) {
+      tools[toolDefinition.name] = tool({
+        description: toolDefinition.description,
+        inputSchema: jsonSchema(toolDefinition.inputSchema)
+      });
+    }
+  }
+  return tools;
+}
+
+// src/state-machine/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.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: 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,
+      finishedAt: Date.now()
+    }
+  });
+}
+async function callingInteractiveToolLogic({
+  setting,
+  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",
+      pendingToolCalls: [currentToolCall, ...remainingToolCalls],
+      partialToolResults: step.partialToolResults
+    },
+    step: {
+      ...step,
+      finishedAt: Date.now()
+    }
+  });
+}
+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, mimeType } = fileInfo;
+    try {
+      const buffer = await readFile(path);
+      if (toolName === "readImageFile") {
+        processedContents.push({
+          type: "imageInlinePart",
+          id: part.id,
+          encodedData: buffer.toString("base64"),
+          mimeType
+        });
+      } else {
+        processedContents.push({
+          type: "fileInlinePart",
+          id: part.id,
+          encodedData: buffer.toString("base64"),
+          mimeType
+        });
+      }
+    } catch (error) {
+      processedContents.push({
+        type: "textPart",
+        id: part.id,
+        text: `Failed to read file "${path}": ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  return { ...toolResult, result: processedContents };
+}
+async function executeMcpToolCall(toolCall, skillManagers) {
+  const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
+  if (skillManager.type !== "mcp") {
+    throw new Error(`Incorrect SkillType, required MCP, got ${skillManager.type}`);
+  }
+  const result = await skillManager.callTool(toolCall.toolName, toolCall.args);
+  const toolResult = {
+    id: toolCall.id,
+    skillName: toolCall.skillName,
+    toolName: toolCall.toolName,
+    result
+  };
+  if (toolCall.toolName === "readPdfFile" || toolCall.toolName === "readImageFile") {
+    return processFileToolResult(toolResult, toolCall.toolName);
+  }
+  return toolResult;
+}
+async function getToolType2(toolCall, skillManagers) {
+  const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
+  return skillManager.type;
+}
+async function callingToolLogic({
+  setting,
+  checkpoint,
+  step,
+  skillManagers
+}) {
+  const pendingToolCalls = step.pendingToolCalls ?? step.toolCalls ?? [];
+  if (pendingToolCalls.length === 0) {
+    throw new Error("No tool calls found");
+  }
+  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
+    });
+  }
+  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 resolveToolResults(setting, checkpoint, { toolResults });
+}
+async function finishingStepLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  if (setting.maxSteps !== void 0 && checkpoint.stepNumber >= setting.maxSteps) {
+    return stopRunByExceededMaxSteps(setting, checkpoint, {
+      checkpoint: {
+        ...checkpoint,
+        status: "stoppedByExceededMaxSteps"
+      },
+      step: {
+        ...step,
+        finishedAt: Date.now()
+      }
+    });
+  }
+  return continueToNextStep(setting, checkpoint, {
+    checkpoint: {
+      ...checkpoint
+    },
+    step: {
+      ...step,
+      finishedAt: Date.now()
+    },
+    nextCheckpoint: {
+      ...checkpoint,
+      id: createId(),
+      stepNumber: checkpoint.stepNumber + 1
+    }
+  });
+}
+function createUserMessage(contents) {
+  return {
+    type: "userMessage",
+    contents: contents.map((part) => ({
+      ...part,
+      id: createId()
+    })),
+    id: createId()
+  };
+}
+function createExpertMessage(contents) {
+  return {
+    type: "expertMessage",
+    contents: contents.map((part) => ({
+      ...part,
+      id: createId()
+    })),
+    id: createId()
+  };
+}
+function createToolMessage(contents) {
+  return {
+    type: "toolMessage",
+    contents: contents.map((part) => ({
+      ...part,
+      contents: part.contents.map((part2) => ({
+        ...part2,
+        id: createId()
+      })),
+      id: createId()
+    })),
+    id: createId()
+  };
+}
+function messageToCoreMessage(message) {
+  switch (message.type) {
+    case "instructionMessage":
+      return {
+        role: "system",
+        content: instructionContentsToCoreContent(message.contents),
+        providerOptions: message.cache ? {
+          anthropic: { cacheControl: { type: "ephemeral" } }
+        } : void 0
+      };
+    case "userMessage":
+      return {
+        role: "user",
+        content: userContentsToCoreContent(message.contents),
+        providerOptions: message.cache ? {
+          anthropic: { cacheControl: { type: "ephemeral" } }
+        } : void 0
+      };
+    case "expertMessage":
+      return {
+        role: "assistant",
+        content: expertContentsToCoreContent(message.contents),
+        providerOptions: message.cache ? {
+          anthropic: { cacheControl: { type: "ephemeral" } }
+        } : void 0
+      };
+    case "toolMessage":
+      return {
+        role: "tool",
+        content: toolContentsToCoreContent(message.contents),
+        providerOptions: message.cache ? {
+          anthropic: { cacheControl: { type: "ephemeral" } }
+        } : void 0
+      };
+  }
+}
+function instructionContentsToCoreContent(contents) {
+  return contents.reduce((acc, part) => {
+    return dedent`
+      ${acc}
+      ${part.text}
+    `.trim();
+  }, "");
+}
+function userContentsToCoreContent(contents) {
+  return contents.map((part) => {
+    switch (part.type) {
+      case "textPart":
+        return textPartToCoreTextPart(part);
+      case "imageUrlPart":
+        return imageUrlPartToCoreImagePart(part);
+      case "imageInlinePart":
+        return imageInlinePartToCoreImagePart(part);
+      case "imageBinaryPart":
+        return imageBinaryPartToCoreImagePart(part);
+      case "fileUrlPart":
+        return fileUrlPartToCoreFilePart(part);
+      case "fileInlinePart":
+        return fileInlinePartToCoreFilePart(part);
+      case "fileBinaryPart":
+        return fileBinaryPartToCoreFilePart(part);
+      default:
+        throw new Error(`Unknown user content type: ${part.type}`);
+    }
+  });
+}
+function expertContentsToCoreContent(contents) {
+  return contents.map((part) => {
+    switch (part.type) {
+      case "textPart":
+        return textPartToCoreTextPart(part);
+      case "toolCallPart":
+        return toolCallPartToCoreToolCallPart(part);
+      default:
+        throw new Error(`Unknown expert content type: ${part.type}`);
+    }
+  });
+}
+function toolContentsToCoreContent(contents) {
+  return contents.map((part) => {
+    switch (part.type) {
+      case "toolResultPart":
+        return toolResultPartToCoreToolResultPart(part);
+      default:
+        throw new Error(`Unknown tool content type: ${part.type}`);
+    }
+  });
+}
+function textPartToCoreTextPart(part) {
+  return {
+    type: "text",
+    text: part.text
+  };
+}
+function imageUrlPartToCoreImagePart(part) {
+  return {
+    type: "image",
+    image: part.url,
+    mediaType: part.mimeType
+  };
+}
+function imageInlinePartToCoreImagePart(part) {
+  return {
+    type: "image",
+    image: part.encodedData,
+    mediaType: part.mimeType
+  };
+}
+function imageBinaryPartToCoreImagePart(part) {
+  return {
+    type: "image",
+    image: part.data,
+    mediaType: part.mimeType
+  };
+}
+function fileUrlPartToCoreFilePart(part) {
+  return {
+    type: "file",
+    data: part.url,
+    mediaType: part.mimeType
+  };
+}
+function fileInlinePartToCoreFilePart(part) {
+  return {
+    type: "file",
+    data: part.encodedData,
+    mediaType: part.mimeType
+  };
+}
+function fileBinaryPartToCoreFilePart(part) {
+  return {
+    type: "file",
+    data: part.data,
+    mediaType: part.mimeType
+  };
+}
+function toolCallPartToCoreToolCallPart(part) {
+  return {
+    type: "tool-call",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    input: part.args
+  };
+}
+function toolResultPartToCoreToolResultPart(part) {
+  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) => {
+    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,
+    toolName: part.toolName,
+    output: { type: "content", value: contentValue }
+  };
+}
+
+// src/state-machine/states/generating-run-result.ts
+async function generatingRunResultLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  if (!step.toolCalls || !step.toolResults || step.toolResults.length === 0) {
+    throw new Error("No tool calls or tool results found");
+  }
+  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"
+      )
+    };
+  });
+  const toolMessage = createToolMessage(toolResultParts);
+  const model = getModel(setting.model, setting.providerConfig, { proxyUrl: setting.proxyUrl });
+  const { messages } = checkpoint;
+  let generationResult;
+  try {
+    generationResult = await generateText({
+      model,
+      messages: [...messages, toolMessage].map(messageToCoreMessage),
+      temperature: setting.temperature,
+      maxRetries: setting.maxRetries,
+      abortSignal: AbortSignal.timeout(setting.timeout)
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      const reason = JSON.stringify({ error: error.name, message: error.message });
+      return retry(setting, checkpoint, {
+        reason,
+        newMessages: [toolMessage, createUserMessage([{ type: "textPart", text: reason }])],
+        usage: createEmptyUsage()
+      });
+    }
+    throw error;
+  }
+  const usage = usageFromGenerateTextResult(generationResult);
+  const { text } = generationResult;
+  const newMessages = [toolMessage, createExpertMessage(text ? [{ type: "textPart", text }] : [])];
+  return completeRun(setting, checkpoint, {
+    checkpoint: {
+      ...checkpoint,
+      messages: [...messages, ...newMessages],
+      usage: sumUsage(checkpoint.usage, usage),
+      contextWindowUsage: checkpoint.contextWindow ? calculateContextWindowUsage(usage, checkpoint.contextWindow) : void 0,
+      status: "completed"
+    },
+    step: {
+      ...step,
+      newMessages: [...step.newMessages, ...newMessages],
+      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,
+  skillManagers
+}) {
+  const { messages } = checkpoint;
+  const model = getModel(setting.model, setting.providerConfig, { proxyUrl: setting.proxyUrl });
+  let result;
+  try {
+    result = await generateText({
+      model,
+      messages: messages.map(messageToCoreMessage),
+      temperature: setting.temperature,
+      maxRetries: setting.maxRetries,
+      tools: await getToolSet(skillManagers),
+      toolChoice: "required",
+      abortSignal: AbortSignal.timeout(setting.timeout)
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      const reason = JSON.stringify({ error: error.name, message: error.message });
+      return retry(setting, checkpoint, {
+        reason,
+        newMessages: [createUserMessage([{ type: "textPart", text: reason }])],
+        usage: createEmptyUsage()
+      });
+    }
+    throw error;
+  }
+  const usage = usageFromGenerateTextResult(result);
+  const { text, toolCalls, finishReason } = result;
+  if (toolCalls.length === 0) {
+    const reason = JSON.stringify({
+      error: "Error: No tool call generated",
+      message: "You must generate a tool call. Try again."
+    });
+    return retry(setting, checkpoint, {
+      reason,
+      newMessages: [createUserMessage([{ type: "textPart", text: reason }])],
+      usage
+    });
+  }
+  const classified = await classifyToolCalls(toolCalls, skillManagers);
+  const sorted = sortToolCallsByPriority(classified);
+  if (finishReason === "tool-calls" || finishReason === "stop") {
+    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."
+    });
+    return retry(setting, checkpoint, {
+      reason,
+      newMessages: [
+        createExpertMessage([
+          {
+            type: "toolCallPart",
+            toolCallId: firstToolCall.toolCallId,
+            toolName: firstToolCall.toolName,
+            args: firstToolCall.input
+          }
+        ]),
+        createToolMessage([
+          {
+            type: "toolResultPart",
+            toolCallId: firstToolCall.toolCallId,
+            toolName: firstToolCall.toolName,
+            contents: [{ type: "textPart", 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
+    });
+  }
+  throw new Error(`Unexpected finish reason: ${finishReason}`);
+}
+function getMetaInstruction(startedAt) {
+  return dedent`
+    IMPORTANT:
+    Based on the user's initial message, you must determine what needs to be done.
+    You must iterate through hypothesis and verification to fulfill the task.
+    YOU MUST CONTINUE TO CALL TOOLS UNTIL THE TASK IS COMPLETE.
+    If you do not call tools, the task will be considered complete, and the agent loop will end.
+
+    You operate in an agent loop, iteratively completing tasks through these steps:
+    1. Analyze Events: Understand user needs and current state through the event stream, focusing on the latest user messages and execution results
+    2. Select Tools: Choose the next tool call based on current state, task planning, relevant knowledge, and available data APIs
+    3. Wait for Execution: The selected tool action will be executed by the sandbox environment with new observations added to the event stream
+    4. Iterate: Choose only one tool call per iteration, patiently repeat the above steps until task completion
+    5. Notify Task Completion: Call the attemptCompletion tool to inform the user when the task is complete
+    6. Generate Final Results: Produce a final result that clearly describes each task you performed, step by step
+
+    Conditions for ending the agent loop:
+    If any of the following apply, **immediately call the attemptCompletion tool**.
+    When the agent loop must end, calling any tool other than attemptCompletion is highly dangerous.
+    Under all circumstances, strictly follow this rule.
+    - When the task is complete
+    - When the user's request is outside your expertise
+    - When the user's request is unintelligible
+
+    Rules for requests outside your area of expertise:
+    - Tell your area of expertise to the user in final results
+
+    Environment information:
+    - Current time is ${new Date(startedAt).toISOString()}
+    - Current working directory is ${process.cwd()}
+  `;
+}
+function createInstructionMessage(expert, experts, startedAt) {
+  const instruction = dedent`
+    You are Perstack, an AI expert that tackles tasks requested by users by utilizing all available tools.
+
+    (The following information describes your nature and role as an AI, the mechanisms of the AI system, and other meta-cognitive aspects.)
+
+    ${getMetaInstruction(startedAt)}
+
+    ---
+    (The following describes the objective, steps, rules, etc. regarding your expert task.)
+
+    ${expert.instruction}
+
+    ---
+    (The following is an overview of each skill and the rules for calling tools.)
+
+    ${getSkillRules(expert)}
+
+    ---
+    (The following is an overview of each delegate expert and the rules for calling tools.)
+
+    You can delegate tasks to the following experts by calling delegate expert name as a tool:
+
+    ${getDelegateRules(expert, experts)}
+  `;
+  return {
+    type: "instructionMessage",
+    contents: [
+      {
+        id: createId(),
+        type: "textPart",
+        text: instruction
+      }
+    ],
+    id: createId(),
+    cache: true
+  };
+}
+function getSkillRules(expert) {
+  return Object.values(expert.skills).reduce((acc, skill) => {
+    if (!skill.rule) {
+      return acc;
+    }
+    return dedent`
+      ${acc}
+
+      "${skill.name}" skill rules:
+      ${skill.rule}
+    `.trim();
+  }, "");
+}
+function getDelegateRules(expert, experts) {
+  return expert.delegates.reduce((acc, delegateExpertName) => {
+    const delegate = experts[delegateExpertName];
+    if (!delegate) {
+      return acc;
+    }
+    return dedent`
+      ${acc}
+
+      About "${delegate.name}":
+      ${delegate.description}
+    `.trim();
+  }, "");
+}
+
+// src/state-machine/states/init.ts
+async function initLogic({
+  setting,
+  checkpoint
+}) {
+  const { expertKey, experts } = setting;
+  const expert = experts[expertKey];
+  switch (checkpoint.status) {
+    case "init": {
+      if (!setting.input.text) {
+        throw new Error("Input message is undefined");
+      }
+      return startRun(setting, checkpoint, {
+        initialCheckpoint: checkpoint,
+        inputMessages: [
+          createInstructionMessage(expert, experts, setting.startedAt),
+          createUserMessage([{ type: "textPart", text: setting.input.text }])
+        ]
+      });
+    }
+    case "stoppedByDelegate":
+    case "stoppedByInteractiveTool": {
+      if (!setting.input.interactiveToolCallResult) {
+        throw new Error("Interactive tool call result is undefined");
+      }
+      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:
+      if (!setting.input.text) {
+        throw new Error("Input message is undefined");
+      }
+      return startRun(setting, checkpoint, {
+        initialCheckpoint: checkpoint,
+        inputMessages: [createUserMessage([{ type: "textPart", text: setting.input.text }])]
+      });
+  }
+}
+async function preparingForStepLogic({
+  setting,
+  checkpoint
+}) {
+  if (checkpoint.pendingToolCalls && checkpoint.pendingToolCalls.length > 0) {
+    return resumeToolCalls(setting, checkpoint, {
+      pendingToolCalls: checkpoint.pendingToolCalls,
+      partialToolResults: checkpoint.partialToolResults ?? []
+    });
+  }
+  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 startGeneration(setting, checkpoint, {
+    messages: checkpoint.messages
+  });
+}
+async function resolvingToolResultLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  if (!step.toolCalls || !step.toolResults || step.toolResults.length === 0) {
+    throw new Error("No tool calls or tool results found");
+  }
+  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(toolResultParts)]
+  });
+}
+
+// src/state-machine/states/resolving-thought.ts
+async function resolvingThoughtLogic(context) {
+  return resolvingToolResultLogic(context);
+}
+
+// src/state-machine/machine.ts
+var runtimeStateMachine = setup({
+  types: {
+    input: {},
+    context: {},
+    events: {}
+  }
+}).createMachine({
+  /** @xstate-layout N4IgpgJg5mDOIC5QCUCuA7AdASXQSwBcBiWAgQwCcC10BtABgF1FQAHAe1kL3fRZAAeiAKz0AzJgDsAJgAsksZNlixs+gDZZAGhABPRIszCAjGIAcY4crPHhJyQF8HOmpgAKFMK0p50UAGLsFADKBF4k5FQA4mDoYBRkBDx0TPwcXEm8-EIIZmaymPRK8saSopL00tI6+gjq9JjSltLG9HnqZkqdTi4YmDFxCUl+ACrs7AA2AMJkExNEngQUugzMSCDp3FnrOcam0pgAnHbS9GeSZsIq6jWIh2KHUsYd9MbSwl2S6j0grgPxiV8UDGkxmcyIAGNZhMQRNVmlOFs+DtEPt1Jg3odpGVbFcrLcENIzOjbGYipIZMpnmYfn9YgDhsDxtNoZDobgwgkIUkAG5gWHw9abTLI0C7ImSTDqYTY2S45TCCwE54HUr1WRXSqHcRVWl9f5DIGwsHzKFzAAiYAmYCgiTAgrYiJF2VRYnoj1ehwskkOZTEz2EBMMJnMFnezxUF2+zl+fRNRuZCzgkz5sOQcFQEwIDo2TuSLoQpWJUvowl9Flk0sqBLlZik2Mkpjyan90d6WHjo0TnlgKf5AAt2KgoP3s6khXntmLUT6JL6PkoFJX1MZtHoRKIpdrK3sqorpG3Yx3oQnJknexM+W4IAAzfx4a054X5lGFn2PMTYlSyWQH32WAl1DKKV1Q6L1V1EWQ9WPOZT3mHs+2wABbMgYHvR9x0dDIX2nN8zEeOVjGORsmgsMQCTJYRMGJORwP9MwDxpGNXE7Jkz0SMIkNYAgpnYLjrRFJ9J1FQQZzJTBPxUfDDjlN1OgJIkSUVUtDlXCpsUPVx0wvHk4O0zNiBvXw8FgftjWhITsKnUTCU-SU92JMlfSaGtjDrGQKSbfJxGeaDMG0lMjUHYdRyIIz8FM8y5kspECyabFGneRz3RkN011qOwGnUbcVzeJKDz8gLLyBa87wfMAwuMyLmRNGLnVfeL7KSl5nPI9c6mA9RQPwmwNVLQrk2KvxkNQsB0Iq8KTLMmqLMw3MrJEnJGsSxUWtSgkfSU-JDmIqNKj8g1AT8Gh9KzSE+NYASwBoOqcJs+K61sDo5SKBifwU4tSRUtTKi+KDmLjE9hvQTkyG5PBU0TUh2FYGgACFdA5AFwchyZbus3YyklYRst-DUlDEaU2tqFUMS+NyPmlPZDiAvzWMta1bTCCIYfh3QGZtO10cWmcLiOQnG3qHHiSDbGvM-Ex1EjYk-PvCL+yBUJwghXhhlQfl2AAOTAAQCCV1hubiqxjCMRUZXMGSvVUZV6A1LcuorDp8I0WWqoVvx9ZZ2GMARgBRAQITASBIAAWTIAR9dgQ2Gs0Ki8nyK4bCuDVRZNzRwxse4GK6pwY3QdgIDgfgaARBaCxUBosU0cw5TLUiCQAWlkR4nPdbVCeyld-vbHB8AIUvYtfRQ6yr6xa6xcwCTLaiadj1dKxk1phD8jwvB8PxAhCMJWAH+rcKAyuyVaa5Wi+KeW9njV59xpeDvpQ0u1BaFd7u3Y2keDpO7LW2FDLc+Z6AnsPEO4ZYAxghMOCL8MaojsJKYi8cHZ5C9EGNoRg1CdH3GcZeYD-KDV0o-CYp1+4TjLg1cQkp-SfjDE9Ew1R2o-hNnsUs1MfR-UuANHSQUhwjmIVhQeuFTg-ilF8GUblTgKDoRlBQhQJEaiJMnfCHDAp+FKuNKBPNCSlgaOIeQttWxS0DO1bKdY9HvH9D+FotMcFFXwVAEaaFyrqLirbBo1M7KvFUDJCiRJGgalUM3LEMk5R30GEdKAJ0MxZicWQlQEklAyillWVoZgUF1isG0MoDEsF0yBnYkGyNeQa0mNE3CtgiIYnEEBToFwvS+mVPkU20l8JWG1OIHJsE-AcyZmAEpNlbBqEwLo7yVRbY3HatPfCXUOgfCsGSTQmk+hyymorbevSloykeFYCkrxfqrmJiIaRRQ7JbP8Q8PyoQYasEgGsxA2JWiNB-jjdQTRqb1IkP6OwRF8KMSAbnBwQA */
+  id: "Run",
+  initial: "Init",
+  context: ({ input }) => ({
+    setting: input.setting,
+    checkpoint: input.initialCheckpoint,
+    step: {
+      stepNumber: input.initialCheckpoint.stepNumber,
+      inputMessages: [],
+      newMessages: [],
+      usage: createEmptyUsage(),
+      startedAt: Date.now()
+    },
+    eventListener: input.eventListener,
+    skillManagers: input.skillManagers
+  }),
+  states: {
+    Init: {
+      on: {
+        startRun: {
+          target: "PreparingForStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              status: "proceeding",
+              messages: [...context.checkpoint.messages, ...event.inputMessages],
+              pendingToolCalls: event.initialCheckpoint.pendingToolCalls,
+              partialToolResults: event.initialCheckpoint.partialToolResults
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              inputMessages: event.inputMessages
+            })
+          })
+        }
+      }
+    },
+    PreparingForStep: {
+      on: {
+        startGeneration: {
+          target: "GeneratingToolCall",
+          actions: assign({
+            step: ({ context, event }) => ({
+              stepNumber: context.checkpoint.stepNumber,
+              inputMessages: context.step.inputMessages ?? [],
+              newMessages: [],
+              usage: createEmptyUsage(),
+              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
+            })
+          })
+        }
+      }
+    },
+    GeneratingToolCall: {
+      on: {
+        retry: {
+          target: "FinishingStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, ...event.newMessages],
+              usage: sumUsage(context.checkpoint.usage, event.usage)
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: event.newMessages,
+              toolCalls: event.toolCalls,
+              toolResults: event.toolResults,
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        },
+        callTools: {
+          target: "CallingTool",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, event.newMessage],
+              usage: sumUsage(context.checkpoint.usage, event.usage),
+              contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(event.usage, context.checkpoint.contextWindow) : void 0
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [event.newMessage],
+              toolCalls: event.toolCalls,
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        },
+        callInteractiveTool: {
+          target: "CallingInteractiveTool",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, event.newMessage],
+              usage: sumUsage(context.checkpoint.usage, event.usage),
+              contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(event.usage, context.checkpoint.contextWindow) : void 0
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [event.newMessage],
+              toolCalls: [event.toolCall],
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        },
+        callDelegate: {
+          target: "CallingDelegate",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, event.newMessage],
+              usage: sumUsage(context.checkpoint.usage, event.usage),
+              contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(event.usage, context.checkpoint.contextWindow) : void 0
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [event.newMessage],
+              toolCalls: event.toolCalls,
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        }
+      }
+    },
+    CallingTool: {
+      on: {
+        resolveToolResults: {
+          target: "ResolvingToolResult",
+          actions: assign({
+            step: ({ context, event }) => ({
+              ...context.step,
+              toolResults: event.toolResults,
+              pendingToolCalls: void 0
+            })
+          })
+        },
+        resolveThought: {
+          target: "ResolvingThought",
+          actions: assign({
+            step: ({ context, event }) => ({
+              ...context.step,
+              toolResults: [event.toolResult]
+            })
+          })
+        },
+        attemptCompletion: {
+          target: "GeneratingRunResult",
+          actions: assign({
+            step: ({ context, event }) => ({
+              ...context.step,
+              toolResults: [event.toolResult]
+            })
+          })
+        },
+        callDelegate: {
+          target: "CallingDelegate",
+          actions: assign({
+            step: ({ context }) => ({
+              ...context.step,
+              toolCalls: context.step.toolCalls,
+              toolResults: context.step.toolResults,
+              pendingToolCalls: context.step.pendingToolCalls,
+              partialToolResults: context.step.partialToolResults
+            })
+          })
+        },
+        callInteractiveTool: {
+          target: "CallingInteractiveTool",
+          actions: assign({
+            step: ({ context }) => ({
+              ...context.step,
+              toolCalls: context.step.toolCalls,
+              toolResults: context.step.toolResults,
+              pendingToolCalls: context.step.pendingToolCalls,
+              partialToolResults: context.step.partialToolResults
+            })
+          })
+        }
+      }
+    },
+    ResolvingToolResult: {
+      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]
+            })
+          })
+        }
+      }
+    },
+    ResolvingThought: {
+      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: {
+          target: "FinishingStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, ...event.newMessages],
+              usage: sumUsage(context.checkpoint.usage, event.usage)
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: event.newMessages,
+              toolCalls: event.toolCalls,
+              toolResults: event.toolResults,
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        },
+        completeRun: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          })
+        }
+      }
+    },
+    CallingInteractiveTool: {
+      on: {
+        stopRunByInteractiveTool: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          })
+        }
+      }
+    },
+    CallingDelegate: {
+      on: {
+        stopRunByDelegate: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          })
+        }
+      }
+    },
+    FinishingStep: {
+      on: {
+        continueToNextStep: {
+          target: "PreparingForStep",
+          actions: assign({
+            checkpoint: ({ event }) => event.nextCheckpoint,
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          }),
+          reenter: true
+        },
+        stopRunByExceededMaxSteps: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          })
+        }
+      }
+    },
+    Stopped: {
+      type: "final"
+    }
+  }
+});
+var StateMachineLogics = {
+  Init: initLogic,
+  PreparingForStep: preparingForStepLogic,
+  GeneratingToolCall: generatingToolCallLogic,
+  CallingTool: callingToolLogic,
+  ResolvingToolResult: resolvingToolResultLogic,
+  ResolvingThought: resolvingThoughtLogic,
+  GeneratingRunResult: generatingRunResultLogic,
+  CallingInteractiveTool: callingInteractiveToolLogic,
+  CallingDelegate: callingDelegateLogic,
+  FinishingStep: finishingStepLogic
+};
+async function executeStateMachine(params) {
+  const {
+    setting,
+    initialCheckpoint,
+    eventListener,
+    skillManagers,
+    eventEmitter,
+    storeCheckpoint,
+    shouldContinueRun
+  } = params;
+  const runActor = createActor(runtimeStateMachine, {
+    input: {
+      setting,
+      initialCheckpoint,
+      eventListener,
+      skillManagers
+    }
+  });
+  return new Promise((resolve, reject) => {
+    runActor.subscribe(async (runState) => {
+      try {
+        if (runState.value === "Stopped") {
+          const { checkpoint, skillManagers: skillManagers2 } = runState.context;
+          if (!checkpoint) {
+            throw new Error("Checkpoint is undefined");
+          }
+          await closeSkillManagers(skillManagers2);
+          resolve(checkpoint);
+        } else {
+          const event = await StateMachineLogics[runState.value](runState.context);
+          if ("checkpoint" in event) {
+            await storeCheckpoint(event.checkpoint);
+          }
+          await eventEmitter.emit(event);
+          if (shouldContinueRun) {
+            const shouldContinue = await shouldContinueRun(
+              runState.context.setting,
+              runState.context.checkpoint,
+              runState.context.step
+            );
+            if (!shouldContinue) {
+              runActor.stop();
+              await closeSkillManagers(runState.context.skillManagers);
+              resolve(runState.context.checkpoint);
+              return;
+            }
+          }
+          runActor.send(event);
+        }
+      } catch (error) {
+        await closeSkillManagers(skillManagers).catch(() => {
+        });
+        reject(error);
+      }
+    });
+    runActor.start();
+  });
+}
+var RunEventEmitter = class {
+  listeners = [];
+  subscribe(listener) {
+    this.listeners.push(listener);
+  }
+  async emit(event) {
+    const errors = [];
+    for (const listener of this.listeners) {
+      try {
+        await listener({
+          ...event,
+          id: createId(),
+          timestamp: Date.now()
+        });
+      } catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "One or more event listeners failed");
+    }
+  }
+};
+
+// src/helpers/checkpoint.ts
+function createInitialCheckpoint(checkpointId, params) {
+  return {
+    id: checkpointId,
+    jobId: params.jobId,
+    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,
+          skillName: `delegate/${resultCheckpoint.expert.key}`,
+          text: delegateText.text
+        }
+      }
+    },
+    checkpoint: {
+      ...parentCheckpoint,
+      stepNumber: resultCheckpoint.stepNumber,
+      usage: resultCheckpoint.usage,
+      pendingToolCalls: parentCheckpoint.pendingToolCalls,
+      partialToolResults: parentCheckpoint.partialToolResults
+    }
+  };
+}
+function buildDelegateToState(currentSetting, resultCheckpoint, currentExpert) {
+  const { delegateTo } = resultCheckpoint;
+  if (!delegateTo || delegateTo.length === 0) {
+    throw new Error("delegateTo is required for buildDelegateToState");
+  }
+  const firstDelegation = delegateTo[0];
+  const { expert, toolCallId, toolName, query } = firstDelegation;
+  return {
+    setting: {
+      ...currentSetting,
+      expertKey: expert.key,
+      input: {
+        text: query
+      }
+    },
+    checkpoint: {
+      ...resultCheckpoint,
+      status: "init",
+      messages: [],
+      expert: {
+        key: expert.key,
+        name: expert.name,
+        version: expert.version
+      },
+      delegatedBy: {
+        expert: {
+          key: currentExpert.key,
+          name: currentExpert.name,
+          version: currentExpert.version
+        },
+        toolCallId,
+        toolName,
+        checkpointId: resultCheckpoint.id
+      },
+      usage: resultCheckpoint.usage,
+      pendingToolCalls: void 0,
+      partialToolResults: void 0
+    }
+  };
+}
+async function resolveExpertToRun(expertKey, experts, clientOptions) {
+  if (experts[expertKey]) {
+    return experts[expertKey];
+  }
+  const client = new ApiV1Client({
+    baseUrl: clientOptions.perstackApiBaseUrl,
+    apiKey: clientOptions.perstackApiKey
+  });
+  const { expert } = await client.registry.experts.get({ expertKey });
+  return toRuntimeExpert(expert);
+}
+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/helpers/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);
+  experts[expertKey] = expertToRun;
+  for (const delegateName of expertToRun.delegates) {
+    const delegate = await resolveExpertToRun2(delegateName, experts, clientOptions);
+    if (!delegate) {
+      throw new Error(`Delegate ${delegateName} not found`);
+    }
+    experts[delegateName] = delegate;
+  }
+  return { expertToRun, experts };
+}
+
+// src/run.ts
+var noopStoreCheckpoint = async () => {
+};
+var noopStoreEvent = async () => {
+};
+var noopStoreJob = () => {
+};
+var noopRetrieveJob = () => void 0;
+var noopRetrieveCheckpoint = async (_jobId, _checkpointId) => {
+  throw new Error("retrieveCheckpoint not provided");
+};
+var defaultCreateJob = (jobId, expertKey, maxSteps) => ({
+  id: jobId,
+  coordinatorExpertKey: expertKey,
+  status: "running",
+  totalSteps: 0,
+  startedAt: Date.now(),
+  maxSteps,
+  usage: createEmptyUsage()
+});
+async function run(runInput, options) {
+  const runParams = runParamsSchema.parse(runInput);
+  const storeCheckpoint = options?.storeCheckpoint ?? noopStoreCheckpoint;
+  const storeEvent = options?.storeEvent ?? noopStoreEvent;
+  const storeJob = options?.storeJob ?? noopStoreJob;
+  const retrieveJob = options?.retrieveJob ?? noopRetrieveJob;
+  const retrieveCheckpoint = options?.retrieveCheckpoint ?? noopRetrieveCheckpoint;
+  const createJob = options?.createJob ?? defaultCreateJob;
+  const eventListener = createEventListener(options?.eventListener, storeEvent);
+  const eventEmitter = new RunEventEmitter();
+  eventEmitter.subscribe(eventListener);
+  let { setting, checkpoint } = runParams;
+  const contextWindow = getContextWindow(setting.providerConfig.providerName, setting.model);
+  let job = retrieveJob(setting.jobId) ?? createJob(setting.jobId, setting.expertKey, setting.maxSteps);
+  if (job.status !== "running") {
+    job = { ...job, status: "running", finishedAt: void 0 };
+  }
+  storeJob(job);
+  while (true) {
+    const { expertToRun, experts } = await setupExperts(setting, options?.resolveExpertToRun);
+    if (options?.eventListener) {
+      const initEvent = createRuntimeEvent("initializeRuntime", setting.jobId, setting.runId, {
+        runtimeVersion: package_default.version,
+        runtime: "perstack",
+        expertName: expertToRun.name,
+        experts: Object.keys(experts),
+        model: setting.model,
+        temperature: setting.temperature,
+        maxSteps: setting.maxSteps,
+        maxRetries: setting.maxRetries,
+        timeout: setting.timeout,
+        query: setting.input.text,
+        interactiveToolCall: setting.input.interactiveToolCallResult
+      });
+      options.eventListener(initEvent);
+    }
+    const skillManagers = await getSkillManagers(
+      expertToRun,
+      experts,
+      setting,
+      options?.eventListener,
+      { isDelegatedRun: !!checkpoint?.delegatedBy }
+    );
+    const initialCheckpoint = checkpoint ? createNextStepCheckpoint(createId(), checkpoint) : createInitialCheckpoint(createId(), {
+      jobId: setting.jobId,
+      runId: setting.runId,
+      expertKey: setting.expertKey,
+      expert: expertToRun,
+      contextWindow
+    });
+    const runResultCheckpoint = await executeStateMachine({
+      setting: { ...setting, experts },
+      initialCheckpoint,
+      eventListener,
+      skillManagers,
+      eventEmitter,
+      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.jobId,
+            runResultCheckpoint.delegatedBy.checkpointId
+          );
+          const result = buildDelegationReturnState(setting, runResultCheckpoint, parentCheckpoint);
+          setting = result.setting;
+          checkpoint = result.checkpoint;
+          break;
+        }
+        storeJob({ ...job, status: "completed", finishedAt: Date.now() });
+        return runResultCheckpoint;
+      }
+      case "stoppedByInteractiveTool": {
+        storeJob({ ...job, status: "stoppedByInteractiveTool" });
+        return runResultCheckpoint;
+      }
+      case "stoppedByDelegate": {
+        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:
+        throw new Error("Run stopped by unknown reason");
+    }
+  }
+}
+function createEventListener(userListener, storeEvent) {
+  const listener = userListener ?? ((e) => console.log(JSON.stringify(e)));
+  return async (event) => {
+    if ("stepNumber" in event && storeEvent) {
+      await storeEvent(event);
+    }
+    listener(event);
+  };
+}
+async function runDelegate(delegation, parentSetting, parentCheckpoint, parentExpert, options) {
+  const { expert, toolCallId, toolName, query } = delegation;
+  const delegateRunId = createId();
+  const delegateSetting = {
+    ...parentSetting,
+    runId: delegateRunId,
+    expertKey: expert.key,
+    input: { text: query }
+  };
+  const delegateCheckpoint = {
+    id: createId(),
+    jobId: parentSetting.jobId,
+    runId: delegateRunId,
+    status: "init",
+    stepNumber: parentCheckpoint.stepNumber,
+    messages: [],
+    expert: {
+      key: expert.key,
+      name: expert.name,
+      version: expert.version
+    },
+    delegatedBy: {
+      expert: {
+        key: parentExpert.key,
+        name: parentExpert.name,
+        version: parentExpert.version
+      },
+      toolCallId,
+      toolName,
+      checkpointId: parentCheckpoint.id
+    },
+    usage: createEmptyUsage(),
+    contextWindow: parentCheckpoint.contextWindow
+  };
+  const resultCheckpoint = await run(
+    { setting: delegateSetting, checkpoint: delegateCheckpoint },
+    { ...options, returnOnDelegationComplete: true }
+  );
+  const lastMessage = resultCheckpoint.messages[resultCheckpoint.messages.length - 1];
+  if (!lastMessage || lastMessage.type !== "expertMessage") {
+    throw new Error("Delegation error: delegation result message is incorrect");
+  }
+  const textPart = lastMessage.contents.find((c) => c.type === "textPart");
+  if (!textPart || textPart.type !== "textPart") {
+    throw new Error("Delegation error: delegation result message does not contain text");
+  }
+  return {
+    toolCallId,
+    toolName,
+    expertKey: expert.key,
+    text: textPart.text,
+    stepNumber: resultCheckpoint.stepNumber,
+    deltaUsage: resultCheckpoint.usage
+  };
+}
+
+export { getModel, package_default, run, runtimeStateMachine };
+//# sourceMappingURL=chunk-C7AFEVYF.js.map
+//# sourceMappingURL=chunk-C7AFEVYF.js.map