@perstack/runtime 0.0.70 → 0.0.71

package/dist/chunk-RG4QHAGG.js

@@ -0,0 +1,935 @@
+import { tool, jsonSchema } from 'ai';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+import { BASE_SKILL_NAME, createBaseServer, BASE_SKILL_VERSION } from '@perstack/base';
+import { createRuntimeEvent, getFilteredEnv } from '@perstack/core';
+import { createId } from '@paralleldrive/cuid2';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+
+// src/skill-manager/base.ts
+var BaseSkillManager = class {
+  _toolDefinitions = [];
+  _initialized = false;
+  _initializing;
+  skill;
+  interactiveSkill;
+  expert;
+  _jobId;
+  _runId;
+  _eventListener;
+  constructor(jobId, runId, eventListener) {
+    this._jobId = jobId;
+    this._runId = runId;
+    this._eventListener = eventListener;
+  }
+  async init() {
+    if (this._initialized) {
+      throw new Error(`Skill ${this.name} is already initialized`);
+    }
+    if (this._initializing) {
+      throw new Error(`Skill ${this.name} is already initializing`);
+    }
+    const initPromise = this._performInit();
+    this._initializing = initPromise;
+    if (!this.lazyInit) {
+      try {
+        await initPromise;
+      } catch (error) {
+        this._initialized = false;
+        this._initializing = void 0;
+        throw error;
+      }
+    }
+  }
+  isInitialized() {
+    return this._initialized;
+  }
+  async _performInit() {
+    await this._doInit();
+    this._initialized = true;
+    this._initializing = void 0;
+  }
+  async getToolDefinitions() {
+    if (!this.isInitialized() && this._initializing) {
+      await this._initializing;
+    }
+    if (!this.isInitialized()) {
+      throw new Error(`Skill ${this.name} is not initialized`);
+    }
+    return this._filterTools(this._toolDefinitions);
+  }
+  _filterTools(tools) {
+    return tools;
+  }
+};
+
+// src/skill-manager/delegate.ts
+var DelegateSkillManager = class extends BaseSkillManager {
+  name;
+  type = "delegate";
+  lazyInit = false;
+  expert;
+  constructor(expert, jobId, runId, eventListener) {
+    super(jobId, runId, eventListener);
+    this.name = expert.name;
+    this.expert = expert;
+  }
+  async _doInit() {
+    this._toolDefinitions = [
+      {
+        skillName: this.expert.name,
+        name: this.expert.name.split("/").pop() ?? this.expert.name,
+        description: this.expert.description,
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string" }
+          },
+          required: ["query"]
+        },
+        interactive: false
+      }
+    ];
+  }
+  async close() {
+  }
+  async callTool(_toolName, _input) {
+    return [];
+  }
+};
+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);
+  }
+  createInMemoryPair() {
+    return InMemoryTransport.createLinkedPair();
+  }
+};
+var defaultTransportFactory = new DefaultTransportFactory();
+
+// src/skill-manager/in-memory-base.ts
+var InMemoryBaseSkillManager = class extends BaseSkillManager {
+  name = BASE_SKILL_NAME;
+  type = "mcp";
+  lazyInit = false;
+  skill;
+  _mcpServer;
+  _mcpClient;
+  _transportFactory;
+  constructor(skill, jobId, runId, eventListener, options) {
+    super(jobId, runId, eventListener);
+    this.skill = skill;
+    this._transportFactory = options?.transportFactory ?? defaultTransportFactory;
+  }
+  _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 _doInit() {
+    const startTime = Date.now();
+    const [clientTransport, serverTransport] = this._transportFactory.createInMemoryPair();
+    this._mcpServer = createBaseServer();
+    await this._mcpServer.connect(serverTransport);
+    this._mcpClient = new Client({
+      name: `${BASE_SKILL_NAME}-in-memory-client`,
+      version: "1.0.0"
+    });
+    const handshakeStartTime = Date.now();
+    await this._mcpClient.connect(clientTransport);
+    const handshakeDurationMs = Date.now() - handshakeStartTime;
+    const toolDiscoveryStartTime = Date.now();
+    const { tools } = await this._mcpClient.listTools();
+    const toolDiscoveryDurationMs = Date.now() - toolDiscoveryStartTime;
+    this._toolDefinitions = tools.map((tool2) => ({
+      skillName: BASE_SKILL_NAME,
+      name: tool2.name,
+      description: tool2.description,
+      inputSchema: tool2.inputSchema,
+      interactive: false
+    }));
+    if (this._eventListener) {
+      const totalDurationMs = Date.now() - startTime;
+      const event = createRuntimeEvent("skillConnected", this._jobId, this._runId, {
+        skillName: BASE_SKILL_NAME,
+        serverInfo: { name: BASE_SKILL_NAME, version: BASE_SKILL_VERSION },
+        spawnDurationMs: 0,
+        // No process spawn for in-memory
+        handshakeDurationMs,
+        toolDiscoveryDurationMs,
+        connectDurationMs: handshakeDurationMs,
+        totalDurationMs
+      });
+      this._eventListener(event);
+    }
+  }
+  async close() {
+    if (this._mcpClient) {
+      await this._mcpClient.close();
+    }
+    if (this._mcpServer) {
+      await this._mcpServer.close();
+    }
+    if (this._eventListener && (this._mcpClient || this._mcpServer)) {
+      const event = createRuntimeEvent("skillDisconnected", this._jobId, this._runId, {
+        skillName: BASE_SKILL_NAME
+      });
+      this._eventListener(event);
+    }
+  }
+  async callTool(toolName, input) {
+    if (!this.isInitialized() || !this._mcpClient) {
+      throw new Error(`${this.name} is not initialized`);
+    }
+    try {
+      const result = await this._mcpClient.callTool({
+        name: toolName,
+        arguments: input
+      });
+      return convertToolResult(result, toolName, input);
+    } catch (error) {
+      return handleToolError(error, toolName, McpError);
+    }
+  }
+};
+
+// src/skill-manager/interactive.ts
+var InteractiveSkillManager = class extends BaseSkillManager {
+  name;
+  type = "interactive";
+  lazyInit = false;
+  interactiveSkill;
+  constructor(interactiveSkill, jobId, runId, eventListener) {
+    super(jobId, runId, eventListener);
+    this.name = interactiveSkill.name;
+    this.interactiveSkill = interactiveSkill;
+  }
+  async _doInit() {
+    this._toolDefinitions = Object.values(this.interactiveSkill.tools).map((tool2) => ({
+      skillName: this.interactiveSkill.name,
+      name: tool2.name,
+      description: tool2.description,
+      inputSchema: JSON.parse(tool2.inputJsonSchema),
+      interactive: true
+    }));
+  }
+  async close() {
+  }
+  async callTool(_toolName, _input) {
+    return [];
+  }
+};
+
+// 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/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;
+}
+
+// src/skill-manager/mcp.ts
+var McpSkillManager = class extends BaseSkillManager {
+  name;
+  type = "mcp";
+  lazyInit;
+  skill;
+  _mcpClient;
+  _env;
+  _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() {
+    this._mcpClient = new Client({
+      name: `${this.skill.name}-mcp-client`,
+      version: "1.0.0"
+    });
+    let timingInfo;
+    if (this.skill.type === "mcpStdioSkill") {
+      timingInfo = await this._initStdio(this.skill);
+    } else {
+      await this._initSse(this.skill);
+    }
+    const toolDiscoveryStartTime = Date.now();
+    const { tools } = await this._mcpClient.listTools();
+    const toolDiscoveryDurationMs = Date.now() - toolDiscoveryStartTime;
+    this._toolDefinitions = tools.map((tool2) => ({
+      skillName: this.skill.name,
+      name: tool2.name,
+      description: tool2.description,
+      inputSchema: tool2.inputSchema,
+      interactive: false
+    }));
+    if (this._eventListener && timingInfo) {
+      const totalDurationMs = Date.now() - timingInfo.startTime;
+      const event = createRuntimeEvent("skillConnected", this._jobId, this._runId, {
+        skillName: this.skill.name,
+        serverInfo: timingInfo.serverInfo,
+        spawnDurationMs: timingInfo.spawnDurationMs,
+        handshakeDurationMs: timingInfo.handshakeDurationMs,
+        toolDiscoveryDurationMs,
+        connectDurationMs: timingInfo.spawnDurationMs + timingInfo.handshakeDurationMs,
+        totalDurationMs
+      });
+      this._eventListener(event);
+    }
+  }
+  async _initStdio(skill) {
+    if (!skill.command) {
+      throw new Error(`Skill ${skill.name} has no command`);
+    }
+    const requiredEnv = {};
+    for (const envName of skill.requiredEnv) {
+      if (!this._env[envName]) {
+        throw new Error(`Skill ${skill.name} requires environment variable ${envName}`);
+      }
+      requiredEnv[envName] = this._env[envName];
+    }
+    const env = getFilteredEnv(requiredEnv);
+    const startTime = Date.now();
+    const { command, args } = getCommandArgs(skill);
+    if (this._eventListener) {
+      const event = createRuntimeEvent("skillStarting", this._jobId, this._runId, {
+        skillName: skill.name,
+        command,
+        args
+      });
+      this._eventListener(event);
+    }
+    const transport = this._transportFactory.createStdio({ command, args, env, stderr: "pipe" });
+    const spawnDurationMs = Date.now() - startTime;
+    if (transport.stderr) {
+      transport.stderr.on("data", (chunk) => {
+        if (this._eventListener) {
+          const event = createRuntimeEvent("skillStderr", this._jobId, this._runId, {
+            skillName: skill.name,
+            message: chunk.toString().trim()
+          });
+          this._eventListener(event);
+        }
+      });
+    }
+    const connectStartTime = Date.now();
+    await this._mcpClient.connect(transport);
+    const handshakeDurationMs = Date.now() - connectStartTime;
+    const serverVersion = this._mcpClient.getServerVersion();
+    return {
+      startTime,
+      spawnDurationMs,
+      handshakeDurationMs,
+      serverInfo: serverVersion ? { name: serverVersion.name, version: serverVersion.version } : void 0
+    };
+  }
+  async _initSse(skill) {
+    if (!skill.endpoint) {
+      throw new Error(`Skill ${skill.name} has no endpoint`);
+    }
+    const url = new URL(skill.endpoint);
+    if (url.protocol !== "https:") {
+      throw new Error(`Skill ${skill.name} SSE endpoint must use HTTPS: ${skill.endpoint}`);
+    }
+    if (isPrivateOrLocalIP(url.hostname)) {
+      throw new Error(
+        `Skill ${skill.name} SSE endpoint cannot use private/local IP: ${skill.endpoint}`
+      );
+    }
+    const transport = this._transportFactory.createSse({ url });
+    await this._mcpClient.connect(transport);
+  }
+  async close() {
+    if (this._mcpClient) {
+      await this._mcpClient.close();
+      if (this._eventListener && this.skill) {
+        const event = createRuntimeEvent("skillDisconnected", this._jobId, this._runId, {
+          skillName: this.skill.name
+        });
+        this._eventListener(event);
+      }
+    }
+  }
+  _filterTools(tools) {
+    const omit = this.skill.omit ?? [];
+    const pick = this.skill.pick ?? [];
+    return tools.filter((tool2) => omit.length > 0 ? !omit.includes(tool2.name) : true).filter((tool2) => pick.length > 0 ? pick.includes(tool2.name) : true);
+  }
+  async callTool(toolName, input) {
+    if (!this.isInitialized() || !this._mcpClient) {
+      throw new Error(`${this.name} is not initialized`);
+    }
+    try {
+      const result = await this._mcpClient.callTool({
+        name: toolName,
+        arguments: input
+      });
+      return convertToolResult(result, toolName, input);
+    } catch (error) {
+      return handleToolError(error, toolName, McpError);
+    }
+  }
+};
+
+// 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
+    );
+  }
+  createInMemoryBase(skill, context) {
+    return new InMemoryBaseSkillManager(skill, context.jobId, context.runId, context.eventListener);
+  }
+  createInteractive(skill, context) {
+    return new InteractiveSkillManager(skill, context.jobId, context.runId, context.eventListener);
+  }
+  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) {
+  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;
+  }
+}
+function hasExplicitBaseVersion(skill) {
+  if (skill.packageName) {
+    const atSignIndex = skill.packageName.indexOf("@", 1);
+    if (atSignIndex > 0) {
+      return true;
+    }
+  }
+  if (skill.args) {
+    for (const arg of skill.args) {
+      if (arg.startsWith("@perstack/base@")) {
+        const versionStart = "@perstack/base@".length;
+        if (arg.length > versionStart) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function isBaseSkill(skill) {
+  if (skill.name === "@perstack/base") {
+    return true;
+  }
+  if (skill.type === "mcpStdioSkill") {
+    const stdioSkill = skill;
+    if (stdioSkill.packageName?.startsWith("@perstack/base")) {
+      return true;
+    }
+    if (stdioSkill.args?.some((arg) => arg.startsWith("@perstack/base"))) {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldUseBundledBase(baseSkill, perstackBaseSkillCommand) {
+  if (perstackBaseSkillCommand && perstackBaseSkillCommand.length > 0) {
+    return false;
+  }
+  if (baseSkill.type === "mcpSseSkill") {
+    return false;
+  }
+  if (hasExplicitBaseVersion(baseSkill)) {
+    return false;
+  }
+  return true;
+}
+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 baseSkill = skills["@perstack/base"];
+  const useBundledBase = (baseSkill.type === "mcpStdioSkill" || baseSkill.type === "mcpSseSkill") && shouldUseBundledBase(baseSkill, perstackBaseSkillCommand);
+  if (useBundledBase && baseSkill.type === "mcpStdioSkill") {
+    if (baseSkill.requiredEnv.length > 0) {
+      console.warn(
+        `[perstack] requiredEnv is ignored for bundled @perstack/base. Pin a version to enable it.`
+      );
+    }
+    const baseManager = factory.createInMemoryBase(baseSkill, factoryContext);
+    allManagers.push(baseManager);
+    await initSkillManagersWithCleanup([baseManager], allManagers);
+  }
+  const mcpSkills = Object.values(skills).filter(
+    (skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill"
+  ).filter((skill) => {
+    if (useBundledBase && isBaseSkill(skill)) {
+      return false;
+    }
+    return true;
+  }).map((skill) => {
+    if (perstackBaseSkillCommand && skill.type === "mcpStdioSkill") {
+      const matchesBaseByPackage = skill.command === "npx" && skill.packageName === "@perstack/base";
+      const matchesBaseByArgs = skill.command === "npx" && Array.isArray(skill.args) && skill.args.includes("@perstack/base");
+      if (matchesBaseByPackage || matchesBaseByArgs) {
+        const [overrideCommand, ...overrideArgs] = perstackBaseSkillCommand;
+        if (!overrideCommand) {
+          throw new Error("perstackBaseSkillCommand must have at least one element");
+        }
+        return {
+          ...skill,
+          command: overrideCommand,
+          packageName: void 0,
+          args: overrideArgs,
+          lazyInit: false
+        };
+      }
+    }
+    return skill;
+  });
+  const mcpSkillManagers = mcpSkills.map((skill) => {
+    const manager = factory.createMcp(skill, factoryContext);
+    allManagers.push(manager);
+    return manager;
+  });
+  await initSkillManagersWithCleanup(mcpSkillManagers, allManagers);
+  if (!options?.isDelegatedRun) {
+    const interactiveSkills = Object.values(skills).filter(
+      (skill) => skill.type === "interactiveSkill"
+    );
+    const interactiveSkillManagers = interactiveSkills.map((interactiveSkill) => {
+      const manager = factory.createInteractive(interactiveSkill, factoryContext);
+      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 = factory.createDelegate(delegate, factoryContext);
+    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;
+}
+async function collectToolDefinitionsForExpert(expert, options) {
+  const { env, perstackBaseSkillCommand, factory = defaultSkillManagerFactory } = options;
+  const { skills } = expert;
+  if (!skills["@perstack/base"]) {
+    throw new Error("Base skill is not defined");
+  }
+  const factoryContext = {
+    env,
+    jobId: "lockfile-generation",
+    runId: "lockfile-generation",
+    eventListener: void 0
+  };
+  const allManagers = [];
+  const baseSkill = skills["@perstack/base"];
+  const useBundledBase = (baseSkill.type === "mcpStdioSkill" || baseSkill.type === "mcpSseSkill") && shouldUseBundledBase(baseSkill, perstackBaseSkillCommand);
+  try {
+    if (useBundledBase && baseSkill.type === "mcpStdioSkill") {
+      const baseManager = factory.createInMemoryBase(baseSkill, factoryContext);
+      allManagers.push(baseManager);
+      await initSkillManagersWithCleanup([baseManager], allManagers);
+    }
+    const mcpSkills = Object.values(skills).filter(
+      (skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill"
+    ).filter((skill) => {
+      if (useBundledBase && isBaseSkill(skill)) {
+        return false;
+      }
+      return true;
+    }).map((skill) => {
+      if (perstackBaseSkillCommand && skill.type === "mcpStdioSkill") {
+        const matchesBaseByPackage = skill.command === "npx" && skill.packageName === "@perstack/base";
+        const matchesBaseByArgs = skill.command === "npx" && Array.isArray(skill.args) && skill.args.includes("@perstack/base");
+        if (matchesBaseByPackage || matchesBaseByArgs) {
+          const [overrideCommand, ...overrideArgs] = perstackBaseSkillCommand;
+          if (!overrideCommand) {
+            throw new Error("perstackBaseSkillCommand must have at least one element");
+          }
+          return {
+            ...skill,
+            command: overrideCommand,
+            packageName: void 0,
+            args: overrideArgs,
+            lazyInit: false
+          };
+        }
+      }
+      return skill;
+    });
+    const mcpSkillManagers = mcpSkills.map((skill) => {
+      const manager = factory.createMcp(skill, factoryContext);
+      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 = factory.createInteractive(interactiveSkill, factoryContext);
+      allManagers.push(manager);
+      return manager;
+    });
+    await initSkillManagersWithCleanup(interactiveSkillManagers, allManagers);
+    const toolDefinitions = [];
+    for (const manager of allManagers) {
+      const definitions = await manager.getToolDefinitions();
+      for (const def of definitions) {
+        toolDefinitions.push({
+          skillName: def.skillName,
+          name: def.name,
+          description: def.description,
+          inputSchema: def.inputSchema
+        });
+      }
+    }
+    return toolDefinitions;
+  } finally {
+    await Promise.all(allManagers.map((m) => m.close().catch(() => {
+    })));
+  }
+}
+async function getSkillManagersFromLockfile(expert, experts, setting, lockfileToolDefinitions, eventListener, options) {
+  const { LockfileSkillManager: LockfileSkillManager2 } = await import('./lockfile-skill-manager-LG2E4KAZ.js');
+  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"
+  );
+  for (const skill of mcpSkills) {
+    const skillToolDefs = lockfileToolDefinitions[skill.name] ?? [];
+    const manager = new LockfileSkillManager2({
+      skill,
+      toolDefinitions: skillToolDefs,
+      env,
+      jobId,
+      runId,
+      eventListener,
+      perstackBaseSkillCommand
+    });
+    await manager.init();
+    allManagers.push(manager);
+  }
+  if (!options?.isDelegatedRun) {
+    const interactiveSkills = Object.values(skills).filter(
+      (skill) => skill.type === "interactiveSkill"
+    );
+    const interactiveSkillManagers = interactiveSkills.map((interactiveSkill) => {
+      const manager = factory.createInteractive(interactiveSkill, factoryContext);
+      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 = factory.createDelegate(delegate, factoryContext);
+    allManagers.push(manager);
+    delegateSkillManagers.push(manager);
+  }
+  await initSkillManagersWithCleanup(delegateSkillManagers, allManagers);
+  const skillManagers = {};
+  for (const manager of allManagers) {
+    skillManagers[manager.name] = manager;
+  }
+  return skillManagers;
+}
+
+// src/skill-manager/lockfile-skill-manager.ts
+var LockfileSkillManager = class extends BaseSkillManager {
+  name;
+  type = "mcp";
+  lazyInit = true;
+  skill;
+  _cachedToolDefinitions;
+  _realManager;
+  _pendingInit;
+  _env;
+  _perstackBaseSkillCommand;
+  constructor(options) {
+    super(options.jobId, options.runId, options.eventListener);
+    this.name = options.skill.name;
+    this.skill = options.skill;
+    this._env = options.env;
+    this._perstackBaseSkillCommand = options.perstackBaseSkillCommand;
+    this._cachedToolDefinitions = options.toolDefinitions.map((def) => ({
+      skillName: def.skillName,
+      name: def.name,
+      description: def.description,
+      inputSchema: def.inputSchema,
+      interactive: false
+    }));
+  }
+  async _doInit() {
+  }
+  async getToolDefinitions() {
+    return this._filterTools(this._cachedToolDefinitions);
+  }
+  _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 _ensureRealManager() {
+    if (this._realManager) {
+      return this._realManager;
+    }
+    if (this._pendingInit) {
+      return this._pendingInit;
+    }
+    this._pendingInit = this._initRealManager();
+    try {
+      this._realManager = await this._pendingInit;
+      return this._realManager;
+    } finally {
+      this._pendingInit = void 0;
+    }
+  }
+  async _initRealManager() {
+    const useBundledBase = this.skill.type === "mcpStdioSkill" && isBaseSkill(this.skill) && shouldUseBundledBase(this.skill, this._perstackBaseSkillCommand);
+    let manager;
+    if (useBundledBase && this.skill.type === "mcpStdioSkill") {
+      manager = new InMemoryBaseSkillManager(
+        this.skill,
+        this._jobId,
+        this._runId,
+        this._eventListener
+      );
+    } else {
+      const skillToUse = this._applyBaseSkillCommandOverride(this.skill);
+      manager = new McpSkillManager(
+        skillToUse,
+        this._env,
+        this._jobId,
+        this._runId,
+        this._eventListener
+      );
+    }
+    await manager.init();
+    return manager;
+  }
+  _applyBaseSkillCommandOverride(skill) {
+    if (!this._perstackBaseSkillCommand || skill.type !== "mcpStdioSkill") {
+      return skill;
+    }
+    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] = this._perstackBaseSkillCommand;
+      if (!overrideCommand) {
+        return skill;
+      }
+      return {
+        ...skill,
+        command: overrideCommand,
+        packageName: void 0,
+        args: overrideArgs,
+        lazyInit: false
+      };
+    }
+    return skill;
+  }
+  async callTool(toolName, input) {
+    const realManager = await this._ensureRealManager();
+    return realManager.callTool(toolName, input);
+  }
+  async close() {
+    if (this._realManager) {
+      await this._realManager.close();
+    }
+  }
+};
+
+export { LockfileSkillManager, closeSkillManagers, collectToolDefinitionsForExpert, getSkillManagerByToolName, getSkillManagers, getSkillManagersFromLockfile, getToolSet };
+//# sourceMappingURL=chunk-RG4QHAGG.js.map
+//# sourceMappingURL=chunk-RG4QHAGG.js.map