@perstack/runtime 0.0.62 → 0.0.64

package/dist/src/index.js

@@ -1,2171 +1,185 @@
-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, resolveToolResults, attemptCompletion, callDelegate, callInteractiveTool, stopRunByExceededMaxSteps, continueToNextStep, retry, completeRun, callTools, startRun, resumeToolCalls, finishAllToolCalls, startGeneration, finishToolCall, runParamsSchema, createRuntimeEvent, checkpointSchema, runSettingSchema } from '@perstack/core';
-import { createOllama } from 'ollama-ai-provider-v2';
-import { createId } from '@paralleldrive/cuid2';
-import { readdir, readFile, mkdir, writeFile } from 'fs/promises';
-import path from 'path';
-import { setup, assign, createActor } from 'xstate';
-import { generateText, tool, jsonSchema } from 'ai';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { McpError } from '@modelcontextprotocol/sdk/types.js';
-import { dedent } from 'ts-dedent';
-import { ApiV1Client } from '@perstack/api-client/v1';
-
-// package.json
-var package_default = {
-  version: "0.0.62"};
-function getModel(modelId, providerConfig) {
-  switch (providerConfig.providerName) {
-    case "anthropic": {
-      const anthropic = createAnthropic({
-        apiKey: providerConfig.apiKey,
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers
-      });
-      return anthropic(modelId);
-    }
-    case "google": {
-      const google = createGoogleGenerativeAI({
-        apiKey: providerConfig.apiKey,
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers
-      });
-      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
-      });
-      return openai(modelId);
-    }
-    case "ollama": {
-      const ollama = createOllama({
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers
-      });
-      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
-      });
-      return azure(modelId);
-    }
-    case "amazon-bedrock": {
-      const amazonBedrock = createAmazonBedrock({
-        accessKeyId: providerConfig.accessKeyId,
-        secretAccessKey: providerConfig.secretAccessKey,
-        region: providerConfig.region,
-        sessionToken: providerConfig.sessionToken
-      });
-      return amazonBedrock(modelId);
-    }
-    case "google-vertex": {
-      const vertex = createVertex({
-        project: providerConfig.project,
-        location: providerConfig.location,
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers
-      });
-      return vertex(modelId);
-    }
-    case "deepseek": {
-      const deepseek = createDeepSeek({
-        apiKey: providerConfig.apiKey,
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers
-      });
-      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/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,
-      pendingToolCalls: parentCheckpoint.pendingToolCalls,
-      partialToolResults: parentCheckpoint.partialToolResults
-    }
-  };
-}
-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,
-      pendingToolCalls: void 0,
-      partialToolResults: void 0
-    }
-  };
-}
-async function createDefaultFileSystem() {
-  const fs = await import('fs');
-  const fsPromises = await import('fs/promises');
-  return {
-    existsSync: fs.existsSync,
-    mkdir: async (p, options) => {
-      await fsPromises.mkdir(p, options);
-    },
-    readFile: fsPromises.readFile,
-    writeFile: fsPromises.writeFile
-  };
-}
-function defaultGetRunDir(runId) {
-  return `${process.cwd()}/perstack/runs/${runId}`;
-}
-async function storeRunSetting(setting, fs, getRunDir = defaultGetRunDir) {
-  const fileSystem = fs ?? await createDefaultFileSystem();
-  const runDir = getRunDir(setting.runId);
-  if (fileSystem.existsSync(runDir)) {
-    const runSettingPath = path.resolve(runDir, "run-setting.json");
-    const runSetting = runSettingSchema.parse(
-      JSON.parse(await fileSystem.readFile(runSettingPath, "utf-8"))
-    );
-    runSetting.updatedAt = Date.now();
-    await fileSystem.writeFile(runSettingPath, JSON.stringify(runSetting), "utf-8");
-  } else {
-    await fileSystem.mkdir(runDir, { recursive: true });
-    await fileSystem.writeFile(
-      path.resolve(runDir, "run-setting.json"),
-      JSON.stringify(setting),
-      "utf-8"
-    );
-  }
-}
-
-// src/default-store.ts
-async function defaultRetrieveCheckpoint(runId, checkpointId) {
-  const runDir = defaultGetRunDir(runId);
-  const checkpointFiles = await readdir(runDir, { withFileTypes: true }).then(
-    (files) => files.filter((file) => file.isFile() && file.name.startsWith("checkpoint-"))
-  );
-  const checkpointFile = checkpointFiles.find((file) => file.name.endsWith(`-${checkpointId}.json`));
-  if (!checkpointFile) {
-    throw new Error(`checkpoint not found: ${runId} ${checkpointId}`);
-  }
-  const checkpointPath = `${runDir}/${checkpointFile.name}`;
-  const checkpoint = await readFile(checkpointPath, "utf8");
-  return checkpointSchema.parse(JSON.parse(checkpoint));
-}
-async function defaultStoreCheckpoint(checkpoint, timestamp) {
-  const { id, runId, stepNumber } = checkpoint;
-  const runDir = defaultGetRunDir(runId);
-  const checkpointPath = `${runDir}/checkpoint-${timestamp}-${stepNumber}-${id}.json`;
-  await mkdir(runDir, { recursive: true });
-  await writeFile(checkpointPath, JSON.stringify(checkpoint));
-}
-async function defaultStoreEvent(event) {
-  const { timestamp, runId, stepNumber, type } = event;
-  const runDir = defaultGetRunDir(runId);
-  const eventPath = `${runDir}/event-${timestamp}-${stepNumber}-${type}.json`;
-  await mkdir(runDir, { recursive: true });
-  await writeFile(eventPath, JSON.stringify(event));
-}
-var RunEventEmitter = class {
-  listeners = [];
-  subscribe(listener) {
-    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/skill-manager/base.ts
-var BaseSkillManager = class {
-  _toolDefinitions = [];
-  _initialized = false;
-  _initializing;
-  skill;
-  interactiveSkill;
-  expert;
-  _runId;
-  _eventListener;
-  constructor(runId, eventListener) {
-    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, 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: `${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._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._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._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._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`);
+import { package_default, run } from '../chunk-C7AFEVYF.js';
+export { getModel, run, runtimeStateMachine } from '../chunk-C7AFEVYF.js';
+import { registerAdapter, BaseAdapter, checkpointSchema } from '@perstack/core';
+import { spawn } from 'child_process';
+
+var PerstackAdapter = class extends BaseAdapter {
+  name = "perstack";
+  version = "unknown";
+  useDirectExecution;
+  constructor(options) {
+    super();
+    this.useDirectExecution = options?.useDirectExecution ?? true;
+  }
+  async checkPrerequisites() {
+    if (this.useDirectExecution) {
+      return { ok: true };
     }
     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) {
-  const { perstackBaseSkillCommand, env, 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");
-        }
+      const result = await this.execCommand(["perstack-runtime", "--version"]);
+      if (result.exitCode !== 0) {
         return {
-          ...skill,
-          command: overrideCommand,
-          packageName: void 0,
-          args: overrideArgs,
-          lazyInit: false
+          ok: false,
+          error: {
+            type: "cli-not-found",
+            message: "perstack-runtime CLI is not available."
+          }
         };
       }
-    }
-    return skill;
-  });
-  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 = [];
-  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, 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/states/calling-delegate.ts
-async function callingDelegateLogic({
-  setting,
-  checkpoint,
-  step,
-  skillManagers
-}) {
-  if (!step.pendingToolCalls || step.pendingToolCalls.length === 0) {
-    throw new Error("No pending tool calls found");
-  }
-  const toolCall = step.pendingToolCalls[0];
-  if (!toolCall) {
-    throw new Error("No pending tool call found");
-  }
-  const { id, toolName, args } = toolCall;
-  const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
-  if (!skillManager.expert) {
-    throw new Error(`Delegation error: skill manager "${toolName}" not found`);
-  }
-  if (!args || !args.query || typeof args.query !== "string") {
-    throw new Error("Delegation error: query is undefined");
-  }
-  const currentToolCall = step.pendingToolCalls[0];
-  const remainingToolCalls = step.pendingToolCalls.slice(1);
-  return stopRunByDelegate(setting, checkpoint, {
-    checkpoint: {
-      ...checkpoint,
-      status: "stoppedByDelegate",
-      delegateTo: {
-        expert: {
-          key: skillManager.expert.key,
-          name: skillManager.expert.name,
-          version: skillManager.expert.version
-        },
-        toolCallId: id,
-        toolName,
-        query: args.query
-      },
-      pendingToolCalls: [currentToolCall, ...remainingToolCalls],
-      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: (/* @__PURE__ */ new Date()).getTime()
-    }
-  });
-}
-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;
-      }
+      this.version = result.stdout.trim() || "unknown";
     } catch {
-      processedContents.push(part);
-      continue;
-    }
-    if (!fileInfo) {
-      processedContents.push(part);
-      continue;
-    }
-    const { path: path2, mimeType } = fileInfo;
-    try {
-      const buffer = await readFile(path2);
-      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 "${path2}": ${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 getToolType(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 getToolType(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);
-  }
-  const remainingToolCalls = [...delegateToolCalls, ...interactiveToolCalls];
-  if (delegateToolCalls.length > 0) {
-    const delegateToolCall = delegateToolCalls[0];
-    if (!delegateToolCall) {
-      throw new Error("No delegate tool call found");
-    }
-    step.partialToolResults = toolResults;
-    step.pendingToolCalls = remainingToolCalls;
-    return callDelegate(setting, checkpoint, {
-      newMessage: checkpoint.messages[checkpoint.messages.length - 1],
-      toolCall: delegateToolCall,
-      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 = remainingToolCalls;
-    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);
-    }
-  });
-}
-function expertContentsToCoreContent(contents) {
-  return contents.map((part) => {
-    switch (part.type) {
-      case "textPart":
-        return textPartToCoreTextPart(part);
-      case "toolCallPart":
-        return toolCallPartToCoreToolCallPart(part);
-    }
-  });
-}
-function toolContentsToCoreContent(contents) {
-  return contents.map((part) => {
-    switch (part.type) {
-      case "toolResultPart":
-        return toolResultPartToCoreToolResultPart(part);
-    }
-  });
-}
-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/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);
-  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);
-  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 }]
+        ok: false,
+        error: {
+          type: "cli-not-found",
+          message: "perstack-runtime CLI is not available."
         }
-      ],
-      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/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, text } = setting.input.interactiveToolCallResult;
-      const pendingToolCalls = checkpoint.pendingToolCalls ?? [];
-      const completedToolCall = pendingToolCalls.find((tc) => tc.id === toolCallId);
-      const skillName = completedToolCall?.skillName ?? (checkpoint.status === "stoppedByDelegate" ? checkpoint.delegateTo?.expert.key : "") ?? "";
-      const newToolResult = {
-        id: toolCallId,
-        skillName,
-        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 }])]
-      });
+    return { ok: true };
   }
-}
-async function preparingForStepLogic({
-  setting,
-  checkpoint
-}) {
-  if (checkpoint.pendingToolCalls && checkpoint.pendingToolCalls.length > 0) {
-    return resumeToolCalls(setting, checkpoint, {
-      pendingToolCalls: checkpoint.pendingToolCalls,
-      partialToolResults: checkpoint.partialToolResults ?? []
-    });
+  convertExpert(expert) {
+    return { instruction: expert.instruction };
   }
-  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");
+  async run(params) {
+    if (this.useDirectExecution) {
+      return this.runDirect(params);
+    }
+    return this.runViaCli(params);
   }
-  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"
-      )
+  async runDirect(params) {
+    const events = [];
+    const eventListener = (event) => {
+      events.push(event);
+      params.eventListener?.(event);
     };
-  });
-  return finishToolCall(setting, checkpoint, {
-    newMessages: [createToolMessage(toolResultParts)]
-  });
-}
-
-// src/states/resolving-thought.ts
-async function resolvingThoughtLogic(context) {
-  return resolvingToolResultLogic(context);
-}
-
-// src/runtime-state-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.toolCall],
-              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
-            })
-          })
-        }
+    const checkpoint = await run(
+      { setting: params.setting, checkpoint: params.checkpoint },
+      {
+        eventListener,
+        storeCheckpoint: params.storeCheckpoint,
+        retrieveCheckpoint: params.retrieveCheckpoint
       }
-    },
-    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
-};
-
-// 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;
+    );
+    return { checkpoint, events };
+  }
+  async runViaCli(params) {
+    const { setting, eventListener } = params;
+    const events = [];
+    const args = this.buildCliArgs(setting);
+    const maxSteps = setting.maxSteps ?? 100;
+    const processTimeout = (setting.timeout ?? 6e4) * maxSteps;
+    const result = await this.executeRuntimeCli(args, processTimeout, (event) => {
+      events.push(event);
+      eventListener?.(event);
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`perstack-runtime CLI failed with exit code ${result.exitCode}`);
+    }
+    const terminalEventTypes = [
+      "completeRun",
+      "stopRunByInteractiveTool",
+      "stopRunByDelegate",
+      "stopRunByExceededMaxSteps"
+    ];
+    const terminalEvent = events.find((e) => terminalEventTypes.includes(e.type));
+    if (!terminalEvent?.checkpoint) {
+      throw new Error("No terminal event with checkpoint received from CLI");
+    }
+    return { checkpoint: terminalEvent.checkpoint, events };
+  }
+  buildCliArgs(setting) {
+    const args = ["run"];
+    if (setting.jobId) {
+      args.push("--job-id", setting.jobId);
+    }
+    if (setting.runId) {
+      args.push("--run-id", setting.runId);
+    }
+    if (setting.maxSteps !== void 0) {
+      args.push("--max-steps", String(setting.maxSteps));
+    }
+    if (setting.maxRetries !== void 0) {
+      args.push("--max-retries", String(setting.maxRetries));
+    }
+    if (setting.timeout !== void 0) {
+      args.push("--timeout", String(setting.timeout));
+    }
+    if (setting.temperature !== void 0) {
+      args.push("--temperature", String(setting.temperature));
+    }
+    if (setting.model) {
+      args.push("--model", setting.model);
+    }
+    if (setting.providerConfig?.providerName) {
+      args.push("--provider", setting.providerConfig.providerName);
+    }
+    args.push(setting.expertKey, setting.input.text ?? "");
+    return args;
+  }
+  executeRuntimeCli(args, timeout, eventListener) {
+    const proc = spawn("perstack-runtime", args, {
+      cwd: process.cwd(),
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    proc.stdin.end();
+    return this.executeWithStreaming(proc, timeout, eventListener);
+  }
+  executeWithStreaming(proc, timeout, eventListener) {
+    return new Promise((resolve, reject) => {
+      let stdout = "";
+      let stderr = "";
+      let buffer = "";
+      const timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`perstack-runtime timed out after ${timeout}ms`));
+      }, timeout);
+      proc.stdout?.on("data", (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+        buffer += chunk;
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const parsed = JSON.parse(trimmed);
+            const terminalEventTypes = [
+              "completeRun",
+              "stopRunByInteractiveTool",
+              "stopRunByDelegate",
+              "stopRunByExceededMaxSteps"
+            ];
+            if (terminalEventTypes.includes(parsed.type) && "checkpoint" in parsed) {
+              const checkpointData = parsed.checkpoint;
+              parsed.checkpoint = checkpointSchema.parse(checkpointData);
             }
+            eventListener(parsed);
+          } catch {
           }
-          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 });
-  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/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/runtime.ts
-async function run(runInput, options) {
-  const runParams = runParamsSchema.parse(runInput);
-  const eventListener = getEventListener(options);
-  const retrieveCheckpoint = options?.retrieveCheckpoint ?? defaultRetrieveCheckpoint;
-  const storeCheckpoint = options?.storeCheckpoint ?? defaultStoreCheckpoint;
-  const eventEmitter = new RunEventEmitter();
-  eventEmitter.subscribe(eventListener);
-  let { setting, checkpoint } = runParams;
-  const contextWindow = getContextWindow(setting.providerConfig.providerName, setting.model);
-  const getRunDir = options?.getRunDir ?? defaultGetRunDir;
-  await storeRunSetting(setting, options?.fileSystem, getRunDir);
-  while (true) {
-    const { expertToRun, experts } = await setupExperts(setting, options?.resolveExpertToRun);
-    if (options?.eventListener) {
-      const initEvent = createRuntimeEvent("initializeRuntime", setting.runId, {
-        runtimeVersion: package_default.version,
-        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
-    );
-    const initialCheckpoint = checkpoint ? createNextStepCheckpoint(createId(), checkpoint) : createInitialCheckpoint(createId(), {
-      runId: setting.runId,
-      expertKey: setting.expertKey,
-      expert: expertToRun,
-      contextWindow
-    });
-    const runResultCheckpoint = await executeStateMachine({
-      setting: { ...setting, experts },
-      initialCheckpoint,
-      eventListener,
-      skillManagers,
-      eventEmitter,
-      storeCheckpoint,
-      shouldContinueRun: options?.shouldContinueRun
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        resolve({ stdout, stderr, exitCode: code ?? 127 });
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
     });
-    switch (runResultCheckpoint.status) {
-      case "completed": {
-        if (runResultCheckpoint.delegatedBy) {
-          const parentCheckpoint = await retrieveCheckpoint(
-            setting.runId,
-            runResultCheckpoint.delegatedBy.checkpointId
-          );
-          const result = buildDelegationReturnState(setting, runResultCheckpoint, parentCheckpoint);
-          setting = result.setting;
-          checkpoint = result.checkpoint;
-          break;
-        }
-        return runResultCheckpoint;
-      }
-      case "stoppedByInteractiveTool": {
-        return runResultCheckpoint;
-      }
-      case "stoppedByDelegate": {
-        const result = buildDelegateToState(setting, runResultCheckpoint, expertToRun);
-        setting = result.setting;
-        checkpoint = result.checkpoint;
-        break;
-      }
-      case "stoppedByExceededMaxSteps": {
-        return runResultCheckpoint;
-      }
-      case "stoppedByError": {
-        return runResultCheckpoint;
-      }
-      default:
-        throw new Error("Run stopped by unknown reason");
-    }
   }
-}
-function getEventListener(options) {
-  const listener = options?.eventListener ?? ((e) => console.log(JSON.stringify(e)));
-  return async (event) => {
-    if ("stepNumber" in event) {
-      await defaultStoreEvent(event);
-    }
-    listener(event);
-  };
-}
+};
 
 // src/index.ts
+registerAdapter("perstack", () => new PerstackAdapter());
 var runtimeVersion = package_default.version;
 
-export { StateMachineLogics, calculateContextWindowUsage, getContextWindow, getModel, defaultGetRunDir as getRunDir, run, runtimeStateMachine, runtimeVersion };
+export { PerstackAdapter, runtimeVersion };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map