@perstack/runtime 0.0.70 → 0.0.71

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

@@ -1,3 +1,8 @@
+import { getSkillManagersFromLockfile, getSkillManagers, closeSkillManagers, getSkillManagerByToolName, getToolSet } from './chunk-RG4QHAGG.js';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { parseWithFriendlyError, lockfileSchema, runParamsSchema, createRuntimeEvent, knownModels, stopRunByExceededMaxSteps, continueToNextStep, stopRunByDelegate, stopRunByInteractiveTool, stopRunByError, retry, completeRun, finishToolCall, resolveToolResults, attemptCompletion, callDelegate, callInteractiveTool, callTools, resumeToolCalls, finishAllToolCalls, startGeneration, startRun } from '@perstack/core';
+import TOML from 'smol-toml';
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createAzure } from '@ai-sdk/azure';
@@ -5,24 +10,19 @@ import { createDeepSeek } from '@ai-sdk/deepseek';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createVertex } from '@ai-sdk/google-vertex';
 import { createOpenAI } from '@ai-sdk/openai';
-import { runParamsSchema, createRuntimeEvent, knownModels, getFilteredEnv, stopRunByExceededMaxSteps, continueToNextStep, stopRunByDelegate, stopRunByInteractiveTool, retry, completeRun, finishToolCall, resolveToolResults, attemptCompletion, callDelegate, callInteractiveTool, callTools, resumeToolCalls, finishAllToolCalls, startGeneration, startRun } from '@perstack/core';
 import { createOllama } from 'ollama-ai-provider-v2';
 import { ProxyAgent, fetch } from 'undici';
+import { ApiV1Client } from '@perstack/api-client/v1';
 import { setup, assign, createActor } from 'xstate';
-import { generateText, tool, jsonSchema } from 'ai';
-import { Client } from '@modelcontextprotocol/sdk/client/index.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 { createId } from '@paralleldrive/cuid2';
 import { dedent } from 'ts-dedent';
-import { ApiV1Client } from '@perstack/api-client/v1';
+import { generateText, streamText } from 'ai';
 
 // package.json
 var package_default = {
   name: "@perstack/runtime",
-  version: "0.0.70",
+  version: "0.0.71",
   description: "Perstack Runtime",
   author: "Wintermute Technologies, Inc.",
   license: "Apache-2.0",
@@ -54,21 +54,31 @@ var package_default = {
     typecheck: "tsc --noEmit"
   },
   dependencies: {
-    "@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",
+    "@ai-sdk/amazon-bedrock": "^3.0.0",
+    "@ai-sdk/anthropic": "^2.0.0",
+    "@ai-sdk/azure": "^2.0.0",
+    "@ai-sdk/deepseek": "^1.0.0",
+    "@ai-sdk/google": "^2.0.0",
+    "@ai-sdk/google-vertex": "^3.0.0",
+    "@ai-sdk/openai": "^2.0.0",
     "@modelcontextprotocol/sdk": "^1.25.1",
     "@paralleldrive/cuid2": "^3.0.4",
+    "@perstack/anthropic-provider": "workspace:*",
     "@perstack/api-client": "workspace:*",
+    "@perstack/base": "workspace:*",
+    "@perstack/azure-openai-provider": "workspace:*",
+    "@perstack/bedrock-provider": "workspace:*",
     "@perstack/core": "workspace:*",
+    "@perstack/deepseek-provider": "workspace:*",
+    "@perstack/google-provider": "workspace:*",
+    "@perstack/ollama-provider": "workspace:*",
+    "@perstack/openai-provider": "workspace:*",
+    "@perstack/provider-core": "workspace:*",
+    "@perstack/vertex-provider": "workspace:*",
     ai: "^5.0.115",
+    "ollama-ai-provider-v2": "^1.5.5",
     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",
     undici: "^7.16.0",
@@ -86,6 +96,56 @@ var package_default = {
     node: ">=22.0.0"
   }
 };
+function loadLockfile(lockfilePath) {
+  try {
+    const content = readFileSync(lockfilePath, "utf-8");
+    const parsed = TOML.parse(content);
+    return parseWithFriendlyError(lockfileSchema, parsed, "perstack.lock");
+  } catch {
+    return null;
+  }
+}
+function isRemoteUrl(configPath) {
+  const lower = configPath.toLowerCase();
+  return lower.startsWith("https://") || lower.startsWith("http://");
+}
+function findLockfile(configPath) {
+  if (configPath) {
+    if (isRemoteUrl(configPath)) {
+      return null;
+    }
+    const configDir = path.dirname(path.resolve(process.cwd(), configPath));
+    return path.join(configDir, "perstack.lock");
+  }
+  return findLockfileRecursively(process.cwd());
+}
+function findLockfileRecursively(cwd) {
+  const lockfilePath = path.resolve(cwd, "perstack.lock");
+  try {
+    readFileSync(lockfilePath);
+    return lockfilePath;
+  } catch {
+    if (cwd === path.parse(cwd).root) {
+      return null;
+    }
+    return findLockfileRecursively(path.dirname(cwd));
+  }
+}
+function getLockfileExpertToolDefinitions(lockfileExpert) {
+  const result = {};
+  for (const toolDef of lockfileExpert.toolDefinitions) {
+    if (!result[toolDef.skillName]) {
+      result[toolDef.skillName] = [];
+    }
+    result[toolDef.skillName].push({
+      skillName: toolDef.skillName,
+      name: toolDef.name,
+      description: toolDef.description,
+      inputSchema: toolDef.inputSchema
+    });
+  }
+  return result;
+}
 function createProxyFetch(proxyUrl) {
   const agent = new ProxyAgent(proxyUrl);
   return (input, init) => {
@@ -217,523 +277,133 @@ function sumUsage(a, b) {
   };
 }
 
-// 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/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/helpers/checkpoint.ts
+function createInitialCheckpoint(checkpointId, params) {
+  return {
+    id: checkpointId,
+    jobId: params.jobId,
+    runId: params.runId,
+    expert: {
+      key: params.expertKey,
+      name: params.expert.name,
+      version: params.expert.version
+    },
+    stepNumber: 1,
+    status: "init",
+    messages: [],
+    usage: createEmptyUsage(),
+    contextWindow: params.contextWindow,
+    contextWindowUsage: params.contextWindow ? 0 : void 0
+  };
 }
-
-// src/skill-manager/delegate.ts
-var DelegateSkillManager = class extends BaseSkillManager {
-  name;
-  type = "delegate";
-  lazyInit = false;
-  expert;
-  constructor(expert, jobId, runId, eventListener) {
-    super(jobId, runId, eventListener);
-    this.name = expert.name;
-    this.expert = expert;
-  }
-  async _doInit() {
-    this._toolDefinitions = [
-      {
-        skillName: this.expert.name,
-        name: this.expert.name.split("/").pop() ?? this.expert.name,
-        description: this.expert.description,
-        inputSchema: {
-          type: "object",
-          properties: {
-            query: { type: "string" }
-          },
-          required: ["query"]
-        },
-        interactive: false
-      }
-    ];
-  }
-  async close() {
-  }
-  async callTool(_toolName, _input) {
-    return [];
-  }
-};
-
-// src/skill-manager/interactive.ts
-var InteractiveSkillManager = class extends BaseSkillManager {
-  name;
-  type = "interactive";
-  lazyInit = false;
-  interactiveSkill;
-  constructor(interactiveSkill, jobId, runId, eventListener) {
-    super(jobId, runId, eventListener);
-    this.name = interactiveSkill.name;
-    this.interactiveSkill = interactiveSkill;
-  }
-  async _doInit() {
-    this._toolDefinitions = Object.values(this.interactiveSkill.tools).map((tool2) => ({
-      skillName: this.interactiveSkill.name,
-      name: tool2.name,
-      description: tool2.description,
-      inputSchema: JSON.parse(tool2.inputJsonSchema),
-      interactive: true
-    }));
-  }
-  async close() {
-  }
-  async callTool(_toolName, _input) {
-    return [];
-  }
-};
-
-// 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 createNextStepCheckpoint(checkpointId, checkpoint) {
+  return {
+    ...checkpoint,
+    id: checkpointId,
+    stepNumber: checkpoint.stepNumber + 1
+  };
 }
-function handleToolError(error, toolName, McpErrorClass) {
-  if (error instanceof McpErrorClass) {
-    return [
-      {
-        type: "textPart",
-        text: `Error calling tool ${toolName}: ${error.message}`,
-        id: createId()
-      }
-    ];
+function buildDelegationReturnState(currentSetting, resultCheckpoint, parentCheckpoint) {
+  const { messages, delegatedBy } = resultCheckpoint;
+  if (!delegatedBy) {
+    throw new Error("delegatedBy is required for buildDelegationReturnState");
   }
-  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()
-      }
-    ];
+  const delegateResultMessage = messages[messages.length - 1];
+  if (!delegateResultMessage || delegateResultMessage.type !== "expertMessage") {
+    throw new Error("Delegation error: delegation result message is incorrect");
   }
-  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);
+  const delegateText = delegateResultMessage.contents.find((content) => content.type === "textPart");
+  if (!delegateText) {
+    console.warn(
+      `Delegation result from ${resultCheckpoint.expert.key} has no text content. Parent expert ${delegatedBy.expert.key} will receive empty string.`
+    );
   }
+  const { expert, toolCallId, toolName } = delegatedBy;
+  return {
+    setting: {
+      ...currentSetting,
+      expertKey: expert.key,
+      input: {
+        interactiveToolCallResult: {
+          toolCallId,
+          toolName,
+          skillName: `delegate/${resultCheckpoint.expert.key}`,
+          text: delegateText?.text ?? ""
+        }
+      }
+    },
+    checkpoint: {
+      ...parentCheckpoint,
+      stepNumber: resultCheckpoint.stepNumber,
+      usage: resultCheckpoint.usage,
+      pendingToolCalls: parentCheckpoint.pendingToolCalls,
+      partialToolResults: parentCheckpoint.partialToolResults
+    }
+  };
 }
-function 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()
-    };
+async function resolveExpertToRun(expertKey, experts, clientOptions) {
+  if (experts[expertKey]) {
+    return experts[expertKey];
   }
-  throw new Error(`Unsupported resource type: ${JSON.stringify(resource)}`);
+  const client = new ApiV1Client({
+    baseUrl: clientOptions.perstackApiBaseUrl,
+    apiKey: clientOptions.perstackApiKey
+  });
+  const { expert } = await client.registry.experts.get({ expertKey });
+  return toRuntimeExpert(expert);
 }
-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";
-  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);
+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}`);
         }
-      });
-    }
-    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
-    );
-  }
-  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();
+    })
+  );
+  return { ...expert, skills };
+}
 
-// src/skill-manager/helpers.ts
-async function initSkillManagersWithCleanup(managers, allManagers) {
-  const results = await Promise.allSettled(managers.map((m) => m.init()));
-  const firstRejected = results.find((r) => r.status === "rejected");
-  if (firstRejected) {
-    await Promise.all(allManagers.map((m) => m.close().catch(() => {
-    })));
-    throw firstRejected.reason;
-  }
-}
-async function getSkillManagers(expert, experts, setting, eventListener, options) {
-  const { perstackBaseSkillCommand, env, jobId, runId } = setting;
-  const { skills } = expert;
-  const factory = options?.factory ?? defaultSkillManagerFactory;
-  if (!skills["@perstack/base"]) {
-    throw new Error("Base skill is not defined");
-  }
-  const factoryContext = {
-    env,
-    jobId,
-    runId,
-    eventListener
+// src/helpers/setup-experts.ts
+async function setupExperts(setting, resolveExpertToRun2 = resolveExpertToRun) {
+  const { expertKey } = setting;
+  const experts = { ...setting.experts };
+  const clientOptions = {
+    perstackApiBaseUrl: setting.perstackApiBaseUrl,
+    perstackApiKey: setting.perstackApiKey
   };
-  const allManagers = [];
-  const mcpSkills = Object.values(skills).filter(
-    (skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill"
-  ).map((skill) => {
-    if (perstackBaseSkillCommand && skill.type === "mcpStdioSkill") {
-      const matchesBaseByPackage = skill.command === "npx" && skill.packageName === "@perstack/base";
-      const matchesBaseByArgs = skill.command === "npx" && Array.isArray(skill.args) && skill.args.includes("@perstack/base");
-      if (matchesBaseByPackage || matchesBaseByArgs) {
-        const [overrideCommand, ...overrideArgs] = perstackBaseSkillCommand;
-        if (!overrideCommand) {
-          throw new Error("perstackBaseSkillCommand must have at least one element");
-        }
-        return {
-          ...skill,
-          command: overrideCommand,
-          packageName: void 0,
-          args: overrideArgs,
-          lazyInit: false
-        };
-      }
-    }
-    return skill;
-  });
-  const mcpSkillManagers = mcpSkills.map((skill) => {
-    const manager = 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];
+  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) {
-      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(`Delegate ${delegateName} not found`);
     }
+    experts[delegateName] = delegate;
   }
-  throw new Error(`Tool ${toolName} not found`);
+  return { expertToRun, experts };
 }
-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/helpers/thinking.ts
+function extractThinkingParts(reasoning) {
+  if (!reasoning) return [];
+  return reasoning.map((r) => ({
+    type: "thinkingPart",
+    thinking: r.text,
+    // Signature is in providerMetadata for Anthropic (output from API)
+    signature: r.providerMetadata?.anthropic?.signature
+  }));
+}
+function extractThinkingText(reasoning) {
+  if (!reasoning) return "";
+  return reasoning.filter((r) => r.text).map((r) => r.text).join("\n");
 }
 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";
@@ -759,9 +429,9 @@ async function processFileToolResult(toolResult, toolName) {
       processedContents.push(part);
       continue;
     }
-    const { path, mimeType } = fileInfo;
+    const { path: path2, mimeType } = fileInfo;
     try {
-      const buffer = await readFile(path);
+      const buffer = await readFile(path2);
       if (toolName === "readImageFile") {
         processedContents.push({
           type: "imageInlinePart",
@@ -781,7 +451,7 @@ async function processFileToolResult(toolResult, toolName) {
       processedContents.push({
         type: "textPart",
         id: part.id,
-        text: `Failed to read file "${path}": ${error instanceof Error ? error.message : String(error)}`
+        text: `Failed to read file "${path2}": ${error instanceof Error ? error.message : String(error)}`
       });
     }
   }
@@ -1157,6 +827,8 @@ function expertContentsToCoreContent(contents) {
         return textPartToCoreTextPart(part);
       case "toolCallPart":
         return toolCallPartToCoreToolCallPart(part);
+      case "thinkingPart":
+        return thinkingPartToCoreThinkingPart(part);
       default:
         throw new Error(`Unknown expert content type: ${part.type}`);
     }
@@ -1228,6 +900,13 @@ function toolCallPartToCoreToolCallPart(part) {
     input: part.args
   };
 }
+function thinkingPartToCoreThinkingPart(part) {
+  return {
+    type: "reasoning",
+    text: part.thinking,
+    providerOptions: part.signature ? { anthropic: { signature: part.signature } } : void 0
+  };
+}
 function toolResultPartToCoreToolResultPart(part) {
   const { contents } = part;
   if (contents.length === 1 && contents[0].type === "textPart") {
@@ -1256,7 +935,9 @@ function toolResultPartToCoreToolResultPart(part) {
 async function generatingRunResultLogic({
   setting,
   checkpoint,
-  step
+  step,
+  eventListener,
+  llmExecutor
 }) {
   if (!step.toolCalls || !step.toolResults || step.toolResults.length === 0) {
     throw new Error("No tool calls or tool results found");
@@ -1273,37 +954,90 @@ async function generatingRunResultLogic({
     };
   });
   const toolMessage = createToolMessage(toolResultParts);
-  const model = getModel(setting.model, setting.providerConfig, { proxyUrl: setting.proxyUrl });
   const { messages } = checkpoint;
-  let generationResult;
-  try {
-    generationResult = await generateText({
-      model,
-      messages: [...messages, toolMessage].map(messageToCoreMessage),
-      temperature: setting.temperature,
+  const coreMessages = [...messages, toolMessage].map(messageToCoreMessage);
+  let reasoningCompletedViaCallback = false;
+  const callbacks = {
+    onReasoningStart: () => {
+      eventListener(createRuntimeEvent("startReasoning", setting.jobId, setting.runId, {}));
+    },
+    onReasoningDelta: (delta) => {
+      eventListener(createRuntimeEvent("streamReasoning", setting.jobId, setting.runId, { delta }));
+    },
+    onReasoningComplete: (text2) => {
+      eventListener(createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, { text: text2 }));
+      reasoningCompletedViaCallback = true;
+    },
+    onResultStart: () => {
+      eventListener(createRuntimeEvent("startRunResult", setting.jobId, setting.runId, {}));
+    },
+    onResultDelta: (delta) => {
+      eventListener(createRuntimeEvent("streamRunResult", setting.jobId, setting.runId, { delta }));
+    }
+  };
+  const executionResult = await llmExecutor.streamText(
+    {
+      messages: coreMessages,
       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()
+      tools: {},
+      // No tools for run result generation
+      abortSignal: AbortSignal.timeout(setting.timeout),
+      reasoningBudget: setting.reasoningBudget
+    },
+    callbacks
+  );
+  if (!executionResult.success) {
+    const { error, isRetryable } = executionResult;
+    const currentRetryCount = checkpoint.retryCount ?? 0;
+    if (!isRetryable || currentRetryCount >= setting.maxRetries) {
+      return stopRunByError(setting, checkpoint, {
+        checkpoint: {
+          ...checkpoint,
+          status: "stoppedByError"
+        },
+        step: {
+          ...step,
+          finishedAt: Date.now()
+        },
+        error: {
+          name: error.name ?? "Error",
+          message: currentRetryCount >= setting.maxRetries ? `Max retries (${setting.maxRetries}) exceeded: ${error.message}` : error.message,
+          statusCode: error.statusCode,
+          isRetryable: false
+        }
       });
     }
-    throw error;
+    const reason = JSON.stringify({ error: error.name ?? "Error", message: error.message });
+    return retry(setting, checkpoint, {
+      reason,
+      newMessages: [toolMessage, createUserMessage([{ type: "textPart", text: reason }])],
+      usage: createEmptyUsage()
+    });
   }
+  const generationResult = executionResult.result;
   const usage = usageFromGenerateTextResult(generationResult);
-  const { text } = generationResult;
-  const newMessages = [toolMessage, createExpertMessage(text ? [{ type: "textPart", text }] : [])];
+  const { text, reasoning } = generationResult;
+  const thinkingParts = extractThinkingParts(reasoning);
+  const thinkingText = extractThinkingText(reasoning);
+  const expertContents = [
+    ...thinkingParts,
+    { type: "textPart", text: text ?? "" }
+  ];
+  const newMessages = [toolMessage, createExpertMessage(expertContents)];
+  if (thinkingText && !reasoningCompletedViaCallback) {
+    await eventListener(
+      createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, {
+        text: thinkingText
+      })
+    );
+  }
+  const newUsage = sumUsage(checkpoint.usage, usage);
   return completeRun(setting, checkpoint, {
     checkpoint: {
       ...checkpoint,
       messages: [...messages, ...newMessages],
-      usage: sumUsage(checkpoint.usage, usage),
-      contextWindowUsage: checkpoint.contextWindow ? calculateContextWindowUsage(usage, checkpoint.contextWindow) : void 0,
+      usage: newUsage,
+      contextWindowUsage: checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, checkpoint.contextWindow) : void 0,
       status: "completed"
     },
     step: {
@@ -1354,38 +1088,121 @@ function buildToolCalls(toolCalls) {
 async function generatingToolCallLogic({
   setting,
   checkpoint,
-  skillManagers
+  step,
+  skillManagers,
+  eventListener,
+  llmExecutor
 }) {
   const { messages } = checkpoint;
-  const model = getModel(setting.model, setting.providerConfig, { proxyUrl: setting.proxyUrl });
-  let result;
-  try {
-    result = await generateText({
-      model,
+  let reasoningCompletedViaCallback = false;
+  const callbacks = {
+    onReasoningStart: () => {
+      eventListener(createRuntimeEvent("startReasoning", setting.jobId, setting.runId, {}));
+    },
+    onReasoningDelta: (delta) => {
+      eventListener(createRuntimeEvent("streamReasoning", setting.jobId, setting.runId, { delta }));
+    },
+    onReasoningComplete: (text2) => {
+      eventListener(createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, { text: text2 }));
+      reasoningCompletedViaCallback = true;
+    }
+    // onResultStart and onResultDelta intentionally not set - result streaming only in GeneratingRunResult
+  };
+  const executionResult = await llmExecutor.streamText(
+    {
       messages: messages.map(messageToCoreMessage),
-      temperature: setting.temperature,
       maxRetries: setting.maxRetries,
       tools: await getToolSet(skillManagers),
-      toolChoice: "required",
-      abortSignal: AbortSignal.timeout(setting.timeout)
+      toolChoice: "auto",
+      abortSignal: AbortSignal.timeout(setting.timeout),
+      reasoningBudget: setting.reasoningBudget
+    },
+    callbacks
+  );
+  if (!executionResult.success) {
+    const { error, isRetryable } = executionResult;
+    const currentRetryCount = checkpoint.retryCount ?? 0;
+    if (!isRetryable || currentRetryCount >= setting.maxRetries) {
+      return stopRunByError(setting, checkpoint, {
+        checkpoint: {
+          ...checkpoint,
+          status: "stoppedByError"
+        },
+        step: {
+          ...step,
+          finishedAt: Date.now()
+        },
+        error: {
+          name: error.name ?? "Error",
+          message: currentRetryCount >= setting.maxRetries ? `Max retries (${setting.maxRetries}) exceeded: ${error.message}` : error.message,
+          statusCode: error.statusCode,
+          isRetryable: false
+        }
+      });
+    }
+    const reason = JSON.stringify({ error: error.name ?? "Error", message: error.message });
+    return retry(setting, checkpoint, {
+      reason,
+      newMessages: [createUserMessage([{ type: "textPart", text: reason }])],
+      usage: createEmptyUsage()
+    });
+  }
+  const result = executionResult.result;
+  const usage = usageFromGenerateTextResult(result);
+  const { text, toolCalls, finishReason, reasoning } = result;
+  const thinkingParts = extractThinkingParts(reasoning);
+  const thinkingText = extractThinkingText(reasoning);
+  if (toolCalls.length === 0 && text) {
+    const contents = [...thinkingParts, { type: "textPart", text }];
+    const newMessage = createExpertMessage(contents);
+    const newUsage = sumUsage(checkpoint.usage, usage);
+    if (thinkingText && !reasoningCompletedViaCallback) {
+      await eventListener(
+        createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, {
+          text: thinkingText
+        })
+      );
+    }
+    return completeRun(setting, checkpoint, {
+      checkpoint: {
+        ...checkpoint,
+        messages: [...messages, newMessage],
+        usage: newUsage,
+        contextWindowUsage: checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, checkpoint.contextWindow) : void 0,
+        status: "completed"
+      },
+      step: {
+        ...step,
+        newMessages: [...step.newMessages, newMessage],
+        finishedAt: Date.now(),
+        usage: sumUsage(step.usage, usage)
+      },
+      text,
+      usage
     });
-  } 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 currentRetryCount = checkpoint.retryCount ?? 0;
+    if (currentRetryCount >= setting.maxRetries) {
+      return stopRunByError(setting, checkpoint, {
+        checkpoint: {
+          ...checkpoint,
+          status: "stoppedByError"
+        },
+        step: {
+          ...step,
+          finishedAt: Date.now()
+        },
+        error: {
+          name: "MaxRetriesExceeded",
+          message: `Max retries (${setting.maxRetries}) exceeded: No tool call or text generated`,
+          isRetryable: false
+        }
+      });
+    }
     const reason = JSON.stringify({
-      error: "Error: No tool call generated",
-      message: "You must generate a tool call. Try again."
+      error: "Error: No tool call or text generated",
+      message: "You must generate a tool call or provide a response. Try again."
     });
     return retry(setting, checkpoint, {
       reason,
@@ -1397,11 +1214,15 @@ async function generatingToolCallLogic({
   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 contents = [...thinkingParts, ...text ? [{ type: "textPart", text }] : [], ...toolCallParts];
     const allToolCalls = buildToolCalls(sorted);
+    if (thinkingText && !reasoningCompletedViaCallback) {
+      await eventListener(
+        createRuntimeEvent("completeReasoning", setting.jobId, setting.runId, {
+          text: thinkingText
+        })
+      );
+    }
     return callTools(setting, checkpoint, {
       newMessage: createExpertMessage(contents),
       toolCalls: allToolCalls,
@@ -1413,6 +1234,24 @@ async function generatingToolCallLogic({
     if (!firstToolCall) {
       throw new Error("No tool call found");
     }
+    const currentRetryCount = checkpoint.retryCount ?? 0;
+    if (currentRetryCount >= setting.maxRetries) {
+      return stopRunByError(setting, checkpoint, {
+        checkpoint: {
+          ...checkpoint,
+          status: "stoppedByError"
+        },
+        step: {
+          ...step,
+          finishedAt: Date.now()
+        },
+        error: {
+          name: "MaxRetriesExceeded",
+          message: `Max retries (${setting.maxRetries}) exceeded: Generation length exceeded`,
+          isRetryable: false
+        }
+      });
+    }
     const reason = JSON.stringify({
       error: "Error: Tool call generation failed",
       message: "Generation length exceeded. Try again."
@@ -1662,11 +1501,6 @@ async function resolvingToolResultLogic({
   });
 }
 
-// src/state-machine/states/resolving-thought.ts
-async function resolvingThoughtLogic(context) {
-  return resolvingToolResultLogic(context);
-}
-
 // src/state-machine/machine.ts
 var runtimeStateMachine = setup({
   types: {
@@ -1689,7 +1523,8 @@ var runtimeStateMachine = setup({
       startedAt: Date.now()
     },
     eventListener: input.eventListener,
-    skillManagers: input.skillManagers
+    skillManagers: input.skillManagers,
+    llmExecutor: input.llmExecutor
   }),
   states: {
     Init: {
@@ -1768,7 +1603,8 @@ var runtimeStateMachine = setup({
             checkpoint: ({ context, event }) => ({
               ...context.checkpoint,
               messages: [...context.checkpoint.messages, ...event.newMessages],
-              usage: sumUsage(context.checkpoint.usage, event.usage)
+              usage: sumUsage(context.checkpoint.usage, event.usage),
+              retryCount: (context.checkpoint.retryCount ?? 0) + 1
             }),
             step: ({ context, event }) => ({
               ...context.step,
@@ -1779,15 +1615,42 @@ var runtimeStateMachine = setup({
             })
           })
         },
+        stopRunByError: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => ({
+              ...event.checkpoint,
+              error: event.error
+            }),
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          })
+        },
+        completeRun: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => ({ ...event.checkpoint, retryCount: 0 }),
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          })
+        },
         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
-            }),
+            checkpoint: ({ context, event }) => {
+              const newUsage = sumUsage(context.checkpoint.usage, event.usage);
+              return {
+                ...context.checkpoint,
+                messages: [...context.checkpoint.messages, event.newMessage],
+                usage: newUsage,
+                contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, context.checkpoint.contextWindow) : void 0,
+                retryCount: 0
+              };
+            },
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
@@ -1799,12 +1662,17 @@ var runtimeStateMachine = setup({
         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
-            }),
+            checkpoint: ({ context, event }) => {
+              const newUsage = sumUsage(context.checkpoint.usage, event.usage);
+              return {
+                ...context.checkpoint,
+                messages: [...context.checkpoint.messages, event.newMessage],
+                usage: newUsage,
+                contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, context.checkpoint.contextWindow) : void 0,
+                retryCount: 0
+                // Reset on successful generation
+              };
+            },
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
@@ -1816,12 +1684,17 @@ var runtimeStateMachine = setup({
         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
-            }),
+            checkpoint: ({ context, event }) => {
+              const newUsage = sumUsage(context.checkpoint.usage, event.usage);
+              return {
+                ...context.checkpoint,
+                messages: [...context.checkpoint.messages, event.newMessage],
+                usage: newUsage,
+                contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(newUsage, context.checkpoint.contextWindow) : void 0,
+                retryCount: 0
+                // Reset on successful generation
+              };
+            },
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: [event.newMessage],
@@ -1844,15 +1717,6 @@ var runtimeStateMachine = setup({
             })
           })
         },
-        resolveThought: {
-          target: "ResolvingThought",
-          actions: assign({
-            step: ({ context, event }) => ({
-              ...context.step,
-              toolResults: [event.toolResult]
-            })
-          })
-        },
         attemptCompletion: {
           target: "GeneratingRunResult",
           actions: assign({
@@ -1905,23 +1769,6 @@ var runtimeStateMachine = setup({
         }
       }
     },
-    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: {
@@ -1930,7 +1777,8 @@ var runtimeStateMachine = setup({
             checkpoint: ({ context, event }) => ({
               ...context.checkpoint,
               messages: [...context.checkpoint.messages, ...event.newMessages],
-              usage: sumUsage(context.checkpoint.usage, event.usage)
+              usage: sumUsage(context.checkpoint.usage, event.usage),
+              retryCount: (context.checkpoint.retryCount ?? 0) + 1
             }),
             step: ({ context, event }) => ({
               ...context.step,
@@ -1941,10 +1789,23 @@ var runtimeStateMachine = setup({
             })
           })
         },
+        stopRunByError: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => ({
+              ...event.checkpoint,
+              error: event.error
+            }),
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
+          })
+        },
         completeRun: {
           target: "Stopped",
           actions: assign({
-            checkpoint: ({ event }) => event.checkpoint,
+            checkpoint: ({ event }) => ({ ...event.checkpoint, retryCount: 0 }),
             step: ({ event }) => ({
               ...event.step,
               inputMessages: void 0
@@ -2017,7 +1878,6 @@ var StateMachineLogics = {
   GeneratingToolCall: generatingToolCallLogic,
   CallingTool: callingToolLogic,
   ResolvingToolResult: resolvingToolResultLogic,
-  ResolvingThought: resolvingThoughtLogic,
   GeneratingRunResult: generatingRunResultLogic,
   CallingInteractiveTool: callingInteractiveToolLogic,
   CallingDelegate: callingDelegateLogic,
@@ -2048,13 +1908,14 @@ var StateMachineCoordinator = class {
    * Execute the state machine and return the final checkpoint.
    */
   async execute() {
-    const { setting, initialCheckpoint, eventListener, skillManagers } = this.params;
+    const { setting, initialCheckpoint, eventListener, skillManagers, llmExecutor } = this.params;
     this.actor = this.actorFactory.create({
       input: {
         setting,
         initialCheckpoint,
         eventListener,
-        skillManagers
+        skillManagers,
+        llmExecutor
       }
     });
     return new Promise((resolve, reject) => {
@@ -2131,118 +1992,6 @@ async function executeStateMachine(params) {
   const coordinator = new StateMachineCoordinator(params);
   return coordinator.execute();
 }
-
-// src/helpers/checkpoint.ts
-function createInitialCheckpoint(checkpointId, params) {
-  return {
-    id: checkpointId,
-    jobId: params.jobId,
-    runId: params.runId,
-    expert: {
-      key: params.expertKey,
-      name: params.expert.name,
-      version: params.expert.version
-    },
-    stepNumber: 1,
-    status: "init",
-    messages: [],
-    usage: createEmptyUsage(),
-    contextWindow: params.contextWindow,
-    contextWindowUsage: params.contextWindow ? 0 : void 0
-  };
-}
-function createNextStepCheckpoint(checkpointId, checkpoint) {
-  return {
-    ...checkpoint,
-    id: checkpointId,
-    stepNumber: checkpoint.stepNumber + 1
-  };
-}
-function buildDelegationReturnState(currentSetting, resultCheckpoint, parentCheckpoint) {
-  const { messages, delegatedBy } = resultCheckpoint;
-  if (!delegatedBy) {
-    throw new Error("delegatedBy is required for buildDelegationReturnState");
-  }
-  const delegateResultMessage = messages[messages.length - 1];
-  if (!delegateResultMessage || delegateResultMessage.type !== "expertMessage") {
-    throw new Error("Delegation error: delegation result message is incorrect");
-  }
-  const delegateText = delegateResultMessage.contents.find((content) => content.type === "textPart");
-  if (!delegateText) {
-    throw new Error("Delegation error: delegation result message does not contain a text");
-  }
-  const { expert, toolCallId, toolName } = delegatedBy;
-  return {
-    setting: {
-      ...currentSetting,
-      expertKey: expert.key,
-      input: {
-        interactiveToolCallResult: {
-          toolCallId,
-          toolName,
-          skillName: `delegate/${resultCheckpoint.expert.key}`,
-          text: delegateText.text
-        }
-      }
-    },
-    checkpoint: {
-      ...parentCheckpoint,
-      stepNumber: resultCheckpoint.stepNumber,
-      usage: resultCheckpoint.usage,
-      pendingToolCalls: parentCheckpoint.pendingToolCalls,
-      partialToolResults: parentCheckpoint.partialToolResults
-    }
-  };
-}
-async function resolveExpertToRun(expertKey, experts, clientOptions) {
-  if (experts[expertKey]) {
-    return experts[expertKey];
-  }
-  const client = new ApiV1Client({
-    baseUrl: clientOptions.perstackApiBaseUrl,
-    apiKey: clientOptions.perstackApiKey
-  });
-  const { expert } = await client.registry.experts.get({ expertKey });
-  return toRuntimeExpert(expert);
-}
-function toRuntimeExpert(expert) {
-  const skills = Object.fromEntries(
-    Object.entries(expert.skills).map(([name, skill]) => {
-      switch (skill.type) {
-        case "mcpStdioSkill":
-          return [name, { ...skill, name }];
-        case "mcpSseSkill":
-          return [name, { ...skill, name }];
-        case "interactiveSkill":
-          return [name, { ...skill, name }];
-        default: {
-          throw new Error(`Unknown skill type: ${skill.type}`);
-        }
-      }
-    })
-  );
-  return { ...expert, skills };
-}
-
-// src/helpers/setup-experts.ts
-async function setupExperts(setting, resolveExpertToRun2 = resolveExpertToRun) {
-  const { expertKey } = setting;
-  const experts = { ...setting.experts };
-  const clientOptions = {
-    perstackApiBaseUrl: setting.perstackApiBaseUrl,
-    perstackApiKey: setting.perstackApiKey
-  };
-  const expertToRun = await resolveExpertToRun2(expertKey, experts, clientOptions);
-  experts[expertKey] = expertToRun;
-  for (const delegateName of expertToRun.delegates) {
-    const delegate = await resolveExpertToRun2(delegateName, experts, clientOptions);
-    if (!delegate) {
-      throw new Error(`Delegate ${delegateName} not found`);
-    }
-    experts[delegateName] = delegate;
-  }
-  return { expertToRun, experts };
-}
 var SingleDelegationStrategy = class {
   async execute(delegations, setting, context, parentExpert, _runFn, _parentOptions) {
     if (delegations.length !== 1) {
@@ -2409,13 +2158,15 @@ var ParallelDelegationStrategy = class {
     }
     const textPart = lastMessage.contents.find((c) => c.type === "textPart");
     if (!textPart || textPart.type !== "textPart") {
-      throw new Error("Delegation error: delegation result message does not contain text");
+      console.warn(
+        `Delegation result from ${expertKey} has no text content. Parent expert will receive empty string.`
+      );
     }
     return {
       toolCallId,
       toolName,
       expertKey,
-      text: textPart.text,
+      text: textPart?.type === "textPart" ? textPart.text : "",
       stepNumber: checkpoint.stepNumber,
       deltaUsage: checkpoint.usage
     };
@@ -2468,22 +2219,272 @@ var RunEventEmitter = class {
   }
 };
 
+// src/helpers/provider-adapter-factory.ts
+var PROVIDER_PACKAGE_NAMES = {
+  anthropic: "anthropic-provider",
+  openai: "openai-provider",
+  google: "google-provider",
+  ollama: "ollama-provider",
+  "azure-openai": "azure-openai-provider",
+  "amazon-bedrock": "bedrock-provider",
+  "google-vertex": "vertex-provider",
+  deepseek: "deepseek-provider"
+};
+var ProviderNotInstalledError = class extends Error {
+  constructor(providerName) {
+    const packageName = PROVIDER_PACKAGE_NAMES[providerName];
+    super(
+      `Provider "${providerName}" is not installed. Run: npm install @perstack/${packageName}`
+    );
+    this.name = "ProviderNotInstalledError";
+  }
+};
+var adapterRegistry = /* @__PURE__ */ new Map();
+var adapterInstances = /* @__PURE__ */ new Map();
+var pendingCreations = /* @__PURE__ */ new Map();
+function getCacheKey(config, options) {
+  return JSON.stringify({
+    providerName: config.providerName,
+    apiKey: "apiKey" in config ? config.apiKey : void 0,
+    baseUrl: "baseUrl" in config ? config.baseUrl : void 0,
+    proxyUrl: options?.proxyUrl
+  });
+}
+function registerProviderAdapter(providerName, loader) {
+  adapterRegistry.set(providerName, loader);
+}
+async function createProviderAdapter(config, options) {
+  const cacheKey = getCacheKey(config, options);
+  const cached = adapterInstances.get(cacheKey);
+  if (cached) return cached;
+  const pending = pendingCreations.get(cacheKey);
+  if (pending) return pending;
+  const loader = adapterRegistry.get(config.providerName);
+  if (!loader) {
+    throw new ProviderNotInstalledError(config.providerName);
+  }
+  const creationPromise = (async () => {
+    try {
+      const AdapterClass = await loader();
+      const adapter = new AdapterClass(config, options);
+      adapterInstances.set(cacheKey, adapter);
+      return adapter;
+    } finally {
+      pendingCreations.delete(cacheKey);
+    }
+  })();
+  pendingCreations.set(cacheKey, creationPromise);
+  return creationPromise;
+}
+
+// src/helpers/register-providers.ts
+registerProviderAdapter("anthropic", async () => {
+  const { AnthropicProviderAdapter } = await import('@perstack/anthropic-provider');
+  return AnthropicProviderAdapter;
+});
+registerProviderAdapter("openai", async () => {
+  const { OpenAIProviderAdapter } = await import('@perstack/openai-provider');
+  return OpenAIProviderAdapter;
+});
+registerProviderAdapter("google", async () => {
+  const { GoogleProviderAdapter } = await import('@perstack/google-provider');
+  return GoogleProviderAdapter;
+});
+registerProviderAdapter("ollama", async () => {
+  const { OllamaProviderAdapter } = await import('@perstack/ollama-provider');
+  return OllamaProviderAdapter;
+});
+registerProviderAdapter("azure-openai", async () => {
+  const { AzureOpenAIProviderAdapter } = await import('@perstack/azure-openai-provider');
+  return AzureOpenAIProviderAdapter;
+});
+registerProviderAdapter("amazon-bedrock", async () => {
+  const { BedrockProviderAdapter } = await import('@perstack/bedrock-provider');
+  return BedrockProviderAdapter;
+});
+registerProviderAdapter("google-vertex", async () => {
+  const { VertexProviderAdapter } = await import('@perstack/vertex-provider');
+  return VertexProviderAdapter;
+});
+registerProviderAdapter("deepseek", async () => {
+  const { DeepseekProviderAdapter } = await import('@perstack/deepseek-provider');
+  return DeepseekProviderAdapter;
+});
+var shouldEnableReasoning = (budget) => budget !== void 0 && budget !== "none" && budget !== 0;
+var LLMExecutor = class {
+  constructor(adapter, model) {
+    this.adapter = adapter;
+    this.model = model;
+  }
+  async generateText(params) {
+    const providerTools = this.adapter.getProviderTools(
+      params.providerToolNames ?? [],
+      params.providerToolOptions
+    );
+    const baseProviderOptions = this.adapter.getProviderOptions(params.providerOptionsConfig);
+    const reasoningEnabled = shouldEnableReasoning(params.reasoningBudget);
+    const reasoningOptions = reasoningEnabled && params.reasoningBudget ? this.adapter.getReasoningOptions(params.reasoningBudget) : void 0;
+    const providerOptions = this.mergeProviderOptions(baseProviderOptions, reasoningOptions);
+    try {
+      const result = await generateText({
+        model: this.model,
+        messages: params.messages,
+        maxRetries: params.maxRetries,
+        tools: { ...params.tools, ...providerTools },
+        toolChoice: params.toolChoice,
+        abortSignal: params.abortSignal,
+        providerOptions
+      });
+      return { success: true, result };
+    } catch (error) {
+      const providerError = this.adapter.normalizeError(error);
+      return {
+        success: false,
+        error: providerError,
+        isRetryable: this.adapter.isRetryable(error)
+      };
+    }
+  }
+  mergeProviderOptions(...options) {
+    const defined = options.filter(Boolean);
+    if (defined.length === 0) return void 0;
+    const result = {};
+    for (const opt of defined) {
+      for (const [provider, settings] of Object.entries(opt)) {
+        result[provider] = { ...result[provider], ...settings };
+      }
+    }
+    return result;
+  }
+  async generateTextWithoutTools(params) {
+    const baseProviderOptions = this.adapter.getProviderOptions(params.providerOptionsConfig);
+    const reasoningEnabled = shouldEnableReasoning(params.reasoningBudget);
+    const reasoningOptions = reasoningEnabled && params.reasoningBudget ? this.adapter.getReasoningOptions(params.reasoningBudget) : void 0;
+    const providerOptions = this.mergeProviderOptions(baseProviderOptions, reasoningOptions);
+    try {
+      const result = await generateText({
+        model: this.model,
+        messages: params.messages,
+        maxRetries: params.maxRetries,
+        abortSignal: params.abortSignal,
+        providerOptions
+      });
+      return { success: true, result };
+    } catch (error) {
+      const providerError = this.adapter.normalizeError(error);
+      return {
+        success: false,
+        error: providerError,
+        isRetryable: this.adapter.isRetryable(error)
+      };
+    }
+  }
+  async streamText(params, callbacks) {
+    const providerTools = this.adapter.getProviderTools(
+      params.providerToolNames ?? [],
+      params.providerToolOptions
+    );
+    const baseProviderOptions = this.adapter.getProviderOptions(params.providerOptionsConfig);
+    const reasoningEnabled = shouldEnableReasoning(params.reasoningBudget);
+    const reasoningOptions = reasoningEnabled && params.reasoningBudget ? this.adapter.getReasoningOptions(params.reasoningBudget) : void 0;
+    const providerOptions = this.mergeProviderOptions(baseProviderOptions, reasoningOptions);
+    const streamResult = streamText({
+      model: this.model,
+      messages: params.messages,
+      maxRetries: params.maxRetries,
+      tools: { ...params.tools, ...providerTools },
+      toolChoice: params.toolChoice,
+      abortSignal: params.abortSignal,
+      providerOptions
+    });
+    let reasoningStarted = false;
+    let reasoningCompleted = false;
+    let resultStarted = false;
+    let accumulatedReasoning = "";
+    try {
+      for await (const part of streamResult.fullStream) {
+        if (part.type === "reasoning-delta") {
+          if (!reasoningStarted) {
+            callbacks.onReasoningStart?.();
+            reasoningStarted = true;
+          }
+          accumulatedReasoning += part.text;
+          callbacks.onReasoningDelta?.(part.text);
+        }
+        if (part.type === "text-delta") {
+          if (reasoningStarted && !reasoningCompleted) {
+            callbacks.onReasoningComplete?.(accumulatedReasoning);
+            reasoningCompleted = true;
+          }
+          if (!resultStarted) {
+            callbacks.onResultStart?.();
+            resultStarted = true;
+          }
+          callbacks.onResultDelta?.(part.text);
+        }
+      }
+      if (reasoningStarted && !reasoningCompleted) {
+        callbacks.onReasoningComplete?.(accumulatedReasoning);
+        reasoningCompleted = true;
+      }
+      const text = await streamResult.text;
+      const toolCalls = await streamResult.toolCalls;
+      const finishReason = await streamResult.finishReason;
+      const usage = await streamResult.usage;
+      const reasoning = await streamResult.reasoning;
+      const response = await streamResult.response;
+      const result = {
+        text,
+        toolCalls,
+        finishReason,
+        usage,
+        reasoning,
+        response,
+        // These properties are required by GenerateTextResult but not available in streamText
+        // They're optional or have safe defaults
+        toolResults: [],
+        steps: [],
+        experimental_output: void 0,
+        providerMetadata: void 0,
+        request: { body: "" }
+      };
+      return { success: true, result };
+    } catch (error) {
+      const providerError = this.adapter.normalizeError(error);
+      return {
+        success: false,
+        error: providerError,
+        isRetryable: this.adapter.isRetryable(error)
+      };
+    }
+  }
+};
+
 // src/orchestration/single-run-executor.ts
 var SingleRunExecutor = class {
   constructor(options = {}) {
     this.options = options;
   }
   async execute(setting, checkpoint) {
+    const adapter = await createProviderAdapter(setting.providerConfig, {
+      proxyUrl: setting.proxyUrl
+    });
+    const model = adapter.createModel(setting.model);
+    const llmExecutor = new LLMExecutor(adapter, model);
     const contextWindow = getContextWindow(setting.providerConfig.providerName, setting.model);
     const { expertToRun, experts } = await setupExperts(setting, this.options.resolveExpertToRun);
     this.emitInitEvent(setting, expertToRun, experts);
-    const skillManagers = await getSkillManagers(
+    const lockfileExpert = this.options.lockfile?.experts[setting.expertKey];
+    const skillManagers = lockfileExpert ? await getSkillManagersFromLockfile(
       expertToRun,
       experts,
       setting,
+      getLockfileExpertToolDefinitions(lockfileExpert),
       this.options.eventListener,
       { isDelegatedRun: !!checkpoint?.delegatedBy }
-    );
+    ) : await getSkillManagers(expertToRun, experts, setting, this.options.eventListener, {
+      isDelegatedRun: !!checkpoint?.delegatedBy
+    });
     const initialCheckpoint = checkpoint ? createNextStepCheckpoint(createId(), checkpoint) : createInitialCheckpoint(createId(), {
       jobId: setting.jobId,
       runId: setting.runId,
@@ -2499,6 +2500,7 @@ var SingleRunExecutor = class {
       initialCheckpoint,
       eventListener,
       skillManagers,
+      llmExecutor,
       eventEmitter,
       storeCheckpoint: this.options.storeCheckpoint ?? (async () => {
       }),
@@ -2524,7 +2526,6 @@ var SingleRunExecutor = class {
       expertName: expertToRun.name,
       experts: Object.keys(experts),
       model: setting.model,
-      temperature: setting.temperature,
       maxSteps: setting.maxSteps,
       maxRetries: setting.maxRetries,
       timeout: setting.timeout,
@@ -2565,7 +2566,8 @@ async function run(runInput, options) {
     storeCheckpoint: options?.storeCheckpoint,
     storeEvent: options?.storeEvent,
     eventListener: options?.eventListener,
-    resolveExpertToRun: options?.resolveExpertToRun
+    resolveExpertToRun: options?.resolveExpertToRun,
+    lockfile: options?.lockfile
   });
   while (true) {
     const runResult = await runExecutor.execute(setting, checkpoint);
@@ -2633,6 +2635,6 @@ async function run(runInput, options) {
   }
 }
 
-export { getModel, package_default, run, runtimeStateMachine };
-//# sourceMappingURL=chunk-3RWT2GPO.js.map
-//# sourceMappingURL=chunk-3RWT2GPO.js.map
+export { findLockfile, getLockfileExpertToolDefinitions, getModel, loadLockfile, package_default, run, runtimeStateMachine };
+//# sourceMappingURL=chunk-LDJKVMQK.js.map
+//# sourceMappingURL=chunk-LDJKVMQK.js.map