@perstack/runtime 0.0.68 → 0.0.70

package/dist/bin/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { package_default, run } from '../chunk-7QLRRSNX.js';
+import { package_default, run } from '../chunk-3RWT2GPO.js';
 import { parseWithFriendlyError, runCommandInputSchema, perstackConfigSchema } from '@perstack/core';
 import { Command } from 'commander';
 import dotenv from 'dotenv';

package/dist/{chunk-7QLRRSNX.js → chunk-3RWT2GPO.js}

@@ -11,10 +11,10 @@ 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 { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { readFile } from 'fs/promises';
 import { dedent } from 'ts-dedent';
 import { ApiV1Client } from '@perstack/api-client/v1';
@@ -22,7 +22,7 @@ import { ApiV1Client } from '@perstack/api-client/v1';
 // package.json
 var package_default = {
   name: "@perstack/runtime",
-  version: "0.0.68",
+  version: "0.0.70",
   description: "Perstack Runtime",
   author: "Wintermute Technologies, Inc.",
   license: "Apache-2.0",
@@ -54,32 +54,33 @@ var package_default = {
     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.24.0",
+    "@ai-sdk/amazon-bedrock": "^3.0.71",
+    "@ai-sdk/anthropic": "^2.0.56",
+    "@ai-sdk/azure": "^2.0.90",
+    "@ai-sdk/deepseek": "^1.0.32",
+    "@ai-sdk/google": "^2.0.49",
+    "@ai-sdk/google-vertex": "^3.0.94",
+    "@ai-sdk/openai": "^2.0.88",
+    "@modelcontextprotocol/sdk": "^1.25.1",
     "@paralleldrive/cuid2": "^3.0.4",
     "@perstack/api-client": "workspace:*",
     "@perstack/core": "workspace:*",
-    ai: "^5.0.104",
+    ai: "^5.0.115",
+    commander: "^14.0.2",
+    dotenv: "^17.2.3",
     "ollama-ai-provider-v2": "^1.5.5",
+    "smol-toml": "^1.5.2",
     "ts-dedent": "^2.2.0",
-    xstate: "^5.24.0",
-    undici: "^7.9.0"
+    undici: "^7.16.0",
+    xstate: "^5.25.0"
   },
   devDependencies: {
     "@tsconfig/node22": "^22.0.5",
-    "@types/node": "^24.10.1",
+    "@types/node": "^25.0.3",
+    memfs: "^4.51.1",
     tsup: "^8.5.1",
     typescript: "^5.9.3",
-    vitest: "^4.0.14"
+    vitest: "^4.0.16"
   },
   engines: {
     node: ">=22.0.0"
@@ -260,11 +261,11 @@ var BaseSkillManager = class {
     this._initializing = void 0;
   }
   async getToolDefinitions() {
-    if (!this.isInitialized() && !this.lazyInit) {
-      throw new Error(`Skill ${this.name} is not initialized`);
+    if (!this.isInitialized() && this._initializing) {
+      await this._initializing;
     }
-    if (!this.isInitialized() && this.lazyInit) {
-      return [];
+    if (!this.isInitialized()) {
+      throw new Error(`Skill ${this.name} is not initialized`);
     }
     return this._filterTools(this._toolDefinitions);
   }
@@ -273,6 +274,22 @@ var BaseSkillManager = class {
   }
 };
 
+// src/skill-manager/command-args.ts
+function 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 };
+}
+
 // src/skill-manager/delegate.ts
 var DelegateSkillManager = class extends BaseSkillManager {
   name;
@@ -334,6 +351,114 @@ var InteractiveSkillManager = class extends BaseSkillManager {
     return [];
   }
 };
+
+// src/skill-manager/ip-validator.ts
+function isPrivateOrLocalIP(hostname) {
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "0.0.0.0") {
+    return true;
+  }
+  const ipv4Match = hostname.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+  if (ipv4Match) {
+    const [, a, b] = ipv4Match.map(Number);
+    if (a === 10) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 169 && b === 254) return true;
+    if (a === 127) return true;
+  }
+  if (hostname.includes(":")) {
+    if (hostname.startsWith("fe80:")) return true;
+    if (hostname.startsWith("fc") || hostname.startsWith("fd")) return true;
+  }
+  if (hostname.startsWith("::ffff:")) {
+    const ipv4Part = hostname.slice(7);
+    if (isPrivateOrLocalIP(ipv4Part)) {
+      return true;
+    }
+  }
+  return false;
+}
+function handleToolError(error, toolName, McpErrorClass) {
+  if (error instanceof McpErrorClass) {
+    return [
+      {
+        type: "textPart",
+        text: `Error calling tool ${toolName}: ${error.message}`,
+        id: createId()
+      }
+    ];
+  }
+  throw error;
+}
+function 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) => convertPart(part));
+}
+function 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 convertResource(part.resource);
+  }
+}
+function 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)}`);
+}
+var DefaultTransportFactory = class {
+  createStdio(options) {
+    return new StdioClientTransport({
+      command: options.command,
+      args: options.args,
+      env: options.env,
+      stderr: options.stderr
+    });
+  }
+  createSse(options) {
+    return new SSEClientTransport(options.url);
+  }
+};
+var defaultTransportFactory = new DefaultTransportFactory();
+
+// src/skill-manager/mcp.ts
 var McpSkillManager = class extends BaseSkillManager {
   name;
   type = "mcp";
@@ -341,11 +466,13 @@ var McpSkillManager = class extends BaseSkillManager {
   skill;
   _mcpClient;
   _env;
-  constructor(skill, env, jobId, runId, eventListener) {
+  _transportFactory;
+  constructor(skill, env, jobId, runId, eventListener, options) {
     super(jobId, runId, eventListener);
     this.name = skill.name;
     this.skill = skill;
     this._env = env;
+    this._transportFactory = options?.transportFactory ?? defaultTransportFactory;
     this.lazyInit = skill.type === "mcpStdioSkill" && skill.lazyInit && skill.name !== "@perstack/base";
   }
   async _doInit() {
@@ -396,7 +523,7 @@ var McpSkillManager = class extends BaseSkillManager {
     }
     const env = getFilteredEnv(requiredEnv);
     const startTime = Date.now();
-    const { command, args } = this._getCommandArgs(skill);
+    const { command, args } = getCommandArgs(skill);
     if (this._eventListener) {
       const event = createRuntimeEvent("skillStarting", this._jobId, this._runId, {
         skillName: skill.name,
@@ -405,7 +532,7 @@ var McpSkillManager = class extends BaseSkillManager {
       });
       this._eventListener(event);
     }
-    const transport = new StdioClientTransport({ command, args, env, stderr: "pipe" });
+    const transport = this._transportFactory.createStdio({ command, args, env, stderr: "pipe" });
     const spawnDurationMs = Date.now() - startTime;
     if (transport.stderr) {
       transport.stderr.on("data", (chunk) => {
@@ -437,56 +564,14 @@ var McpSkillManager = class extends BaseSkillManager {
     if (url.protocol !== "https:") {
       throw new Error(`Skill ${skill.name} SSE endpoint must use HTTPS: ${skill.endpoint}`);
     }
-    if (this._isPrivateOrLocalIP(url.hostname)) {
+    if (isPrivateOrLocalIP(url.hostname)) {
       throw new Error(
         `Skill ${skill.name} SSE endpoint cannot use private/local IP: ${skill.endpoint}`
       );
     }
-    const transport = new SSEClientTransport(url);
+    const transport = this._transportFactory.createSse({ url });
     await this._mcpClient.connect(transport);
   }
-  _isPrivateOrLocalIP(hostname) {
-    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "0.0.0.0") {
-      return true;
-    }
-    const ipv4Match = hostname.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
-    if (ipv4Match) {
-      const [, a, b] = ipv4Match.map(Number);
-      if (a === 10) return true;
-      if (a === 172 && b >= 16 && b <= 31) return true;
-      if (a === 192 && b === 168) return true;
-      if (a === 169 && b === 254) return true;
-      if (a === 127) return true;
-    }
-    if (hostname.includes(":")) {
-      if (hostname.startsWith("fe80:") || hostname.startsWith("fc") || hostname.startsWith("fd")) {
-        return true;
-      }
-    }
-    if (hostname.startsWith("::ffff:")) {
-      const ipv4Part = hostname.slice(7);
-      if (this._isPrivateOrLocalIP(ipv4Part)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  _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();
@@ -512,77 +597,33 @@ var McpSkillManager = class extends BaseSkillManager {
         name: toolName,
         arguments: input
       });
-      return this._convertToolResult(result, toolName, input);
+      return convertToolResult(result, toolName, input);
     } catch (error) {
-      return this._handleToolError(error, toolName);
+      return handleToolError(error, toolName, McpError);
     }
   }
-  _handleToolError(error, toolName) {
-    if (error instanceof McpError) {
-      return [
-        {
-          type: "textPart",
-          text: `Error calling tool ${toolName}: ${error.message}`,
-          id: createId()
-        }
-      ];
-    }
-    throw error;
+};
+
+// src/skill-manager/skill-manager-factory.ts
+var DefaultSkillManagerFactory = class {
+  createMcp(skill, context) {
+    return new McpSkillManager(
+      skill,
+      context.env,
+      context.jobId,
+      context.runId,
+      context.eventListener,
+      context.mcpOptions
+    );
   }
-  _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));
+  createInteractive(skill, context) {
+    return new InteractiveSkillManager(skill, context.jobId, context.runId, context.eventListener);
   }
-  _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)}`);
+  createDelegate(expert, context) {
+    return new DelegateSkillManager(expert, context.jobId, context.runId, context.eventListener);
   }
 };
+var defaultSkillManagerFactory = new DefaultSkillManagerFactory();
 
 // src/skill-manager/helpers.ts
 async function initSkillManagersWithCleanup(managers, allManagers) {
@@ -597,11 +638,20 @@ async function initSkillManagersWithCleanup(managers, allManagers) {
 async function getSkillManagers(expert, experts, setting, eventListener, options) {
   const { perstackBaseSkillCommand, env, jobId, runId } = setting;
   const { skills } = expert;
+  const factory = options?.factory ?? defaultSkillManagerFactory;
   if (!skills["@perstack/base"]) {
     throw new Error("Base skill is not defined");
   }
+  const factoryContext = {
+    env,
+    jobId,
+    runId,
+    eventListener
+  };
   const allManagers = [];
-  const mcpSkills = Object.values(skills).filter((skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill").map((skill) => {
+  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");
@@ -622,7 +672,7 @@ async function getSkillManagers(expert, experts, setting, eventListener, options
     return skill;
   });
   const mcpSkillManagers = mcpSkills.map((skill) => {
-    const manager = new McpSkillManager(skill, env, jobId, runId, eventListener);
+    const manager = factory.createMcp(skill, factoryContext);
     allManagers.push(manager);
     return manager;
   });
@@ -632,7 +682,7 @@ async function getSkillManagers(expert, experts, setting, eventListener, options
       (skill) => skill.type === "interactiveSkill"
     );
     const interactiveSkillManagers = interactiveSkills.map((interactiveSkill) => {
-      const manager = new InteractiveSkillManager(interactiveSkill, jobId, runId, eventListener);
+      const manager = factory.createInteractive(interactiveSkill, factoryContext);
       allManagers.push(manager);
       return manager;
     });
@@ -646,7 +696,7 @@ async function getSkillManagers(expert, experts, setting, eventListener, options
       })));
       throw new Error(`Delegate expert "${delegateExpertName}" not found in experts`);
     }
-    const manager = new DelegateSkillManager(delegate, jobId, runId, eventListener);
+    const manager = factory.createDelegate(delegate, factoryContext);
     allManagers.push(manager);
     delegateSkillManagers.push(manager);
   }
@@ -1973,63 +2023,113 @@ var StateMachineLogics = {
   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(() => {
+var DefaultActorFactory = class {
+  create(input) {
+    return createActor(runtimeStateMachine, input);
+  }
+};
+var defaultActorFactory = new DefaultActorFactory();
+
+// src/state-machine/coordinator.ts
+var StateMachineCoordinator = class {
+  constructor(params, deps = {}) {
+    this.params = params;
+    this.actorFactory = deps.actorFactory ?? defaultActorFactory;
+    this.closeManagers = deps.closeSkillManagers ?? closeSkillManagers;
+    this.logics = deps.logics ?? StateMachineLogics;
+  }
+  actorFactory;
+  closeManagers;
+  logics;
+  actor = null;
+  resolvePromise = null;
+  rejectPromise = null;
+  /**
+   * Execute the state machine and return the final checkpoint.
+   */
+  async execute() {
+    const { setting, initialCheckpoint, eventListener, skillManagers } = this.params;
+    this.actor = this.actorFactory.create({
+      input: {
+        setting,
+        initialCheckpoint,
+        eventListener,
+        skillManagers
+      }
+    });
+    return new Promise((resolve, reject) => {
+      this.resolvePromise = resolve;
+      this.rejectPromise = reject;
+      this.actor.subscribe((runState) => {
+        this.handleStateChange(runState).catch((error) => {
+          this.handleError(error);
         });
-        reject(error);
+      });
+      this.actor.start();
+    });
+  }
+  /**
+   * Handle state changes from the actor.
+   * Exported for testing purposes.
+   */
+  async handleStateChange(runState) {
+    if (runState.value === "Stopped") {
+      await this.handleStoppedState(runState);
+    } else {
+      await this.handleActiveState(runState);
+    }
+  }
+  /**
+   * Handle the stopped state - cleanup and resolve.
+   */
+  async handleStoppedState(runState) {
+    const { checkpoint, skillManagers } = runState.context;
+    if (!checkpoint) {
+      throw new Error("Checkpoint is undefined");
+    }
+    await this.closeManagers(skillManagers);
+    this.resolvePromise?.(checkpoint);
+  }
+  /**
+   * Handle active states - execute logic, store checkpoint, emit events.
+   */
+  async handleActiveState(runState) {
+    const { eventEmitter, storeCheckpoint, shouldContinueRun } = this.params;
+    const stateValue = runState.value;
+    const event = await this.logics[stateValue](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) {
+        this.actor?.stop();
+        await this.closeManagers(runState.context.skillManagers);
+        this.resolvePromise?.(runState.context.checkpoint);
+        return;
       }
+    }
+    this.actor?.send(event);
+  }
+  /**
+   * Handle errors - cleanup and reject.
+   */
+  async handleError(error) {
+    await this.closeManagers(this.params.skillManagers).catch(() => {
     });
-    runActor.start();
-  });
+    this.rejectPromise?.(error instanceof Error ? error : new Error(String(error)));
+  }
+};
+
+// src/state-machine/executor.ts
+async function executeStateMachine(params) {
+  const coordinator = new StateMachineCoordinator(params);
+  return coordinator.execute();
 }
 
 // src/helpers/checkpoint.ts
@@ -2534,5 +2634,5 @@ async function run(runInput, options) {
 }
 
 export { getModel, package_default, run, runtimeStateMachine };
-//# sourceMappingURL=chunk-7QLRRSNX.js.map
-//# sourceMappingURL=chunk-7QLRRSNX.js.map
+//# sourceMappingURL=chunk-3RWT2GPO.js.map
+//# sourceMappingURL=chunk-3RWT2GPO.js.map