@perstack/runtime 0.0.23 → 0.0.25

package/dist/index.js

@@ -1,828 +1,81 @@
-// src/runtime.ts
-import { existsSync } from "fs";
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import path from "path";
-import { createId as createId8 } from "@paralleldrive/cuid2";
-import TOML from "smol-toml";
-import { createActor } from "xstate";
-
-// src/default-store.ts
-import { mkdir, readFile, readdir, writeFile } from "fs/promises";
-
-// src/schemas/runtime.ts
-import { createId } from "@paralleldrive/cuid2";
-import { z as z2 } from "zod";
-
-// src/model.ts
-import { anthropic } from "@ai-sdk/anthropic";
-import { google } from "@ai-sdk/google";
-import { openai } from "@ai-sdk/openai";
-var DefaultModel = "claude-4-sonnet-20250514";
-var AnthropicModels = [
-  "claude-4-opus-20250514",
-  "claude-4-sonnet-20250514",
-  "claude-3-7-sonnet-20250219",
-  "claude-3-5-sonnet-latest",
-  "claude-3-5-sonnet-20241022",
-  "claude-3-5-sonnet-20240620",
-  "claude-3-5-haiku-latest",
-  "claude-3-5-haiku-20241022"
-  // "claude-3-opus-latest", - No pdf support
-  // "claude-3-opus-20240229", - No pdf support
-  // "claude-3-sonnet-20240229", - No pdf support
-  // "claude-3-haiku-20240307", - No pdf support
-];
-var GoogleModels = [
-  "gemini-1.5-flash",
-  "gemini-1.5-flash-latest",
-  "gemini-1.5-flash-001",
-  "gemini-1.5-flash-002",
-  "gemini-1.5-flash-8b",
-  "gemini-1.5-flash-8b-latest",
-  "gemini-1.5-flash-8b-001",
-  "gemini-1.5-pro",
-  "gemini-1.5-pro-latest",
-  "gemini-1.5-pro-001",
-  "gemini-1.5-pro-002",
-  "gemini-2.0-flash",
-  "gemini-2.0-flash-001",
-  "gemini-2.0-flash-live-001",
-  "gemini-2.0-flash-lite",
-  "gemini-2.0-pro-exp-02-05",
-  "gemini-2.0-flash-thinking-exp-01-21",
-  "gemini-2.0-flash-exp",
-  "gemini-2.5-pro",
-  "gemini-2.5-flash",
-  "gemini-2.5-flash-lite",
-  "gemini-2.5-pro-exp-03-25",
-  "gemini-2.5-flash-preview-04-17"
-];
-var OpenAIModels = [
-  "o4-mini",
-  "o4-mini-2025-04-16",
-  "o3",
-  "o3-2025-04-16",
-  "o3-mini",
-  "o3-mini-2025-01-31",
-  "o1",
-  "o1-2024-12-17",
-  "o1-mini",
-  "o1-mini-2024-09-12",
-  // "o1-preview", - No tool support
-  // "o1-preview-2024-09-12", - No tool support
-  "gpt-4.5-preview",
-  "gpt-4.5-preview-2025-02-27",
-  "gpt-4.1",
-  "gpt-4.1-2025-04-14",
-  "gpt-4.1-mini",
-  "gpt-4.1-mini-2025-04-14",
-  "gpt-4.1-nano",
-  "gpt-4.1-nano-2025-04-14",
-  "gpt-4o",
-  "gpt-4o-2024-05-13",
-  "gpt-4o-2024-08-06",
-  "gpt-4o-2024-11-20",
-  "gpt-4o-audio-preview",
-  "gpt-4o-audio-preview-2024-10-01",
-  "gpt-4o-audio-preview-2024-12-17",
-  "gpt-4o-search-preview",
-  "gpt-4o-search-preview-2025-03-11",
-  "gpt-4o-mini-search-preview",
-  "gpt-4o-mini-search-preview-2025-03-11",
-  "gpt-4o-mini",
-  "gpt-4o-mini-2024-07-18"
-  // "gpt-4-turbo", - Legacy model
-  // "gpt-4-turbo-2024-04-09", - Legacy model
-  // "gpt-4-turbo-preview", - Legacy model
-  // "gpt-4-0125-preview", - No image input support
-  // "gpt-4-1106-preview", - No image input support
-  // "gpt-4", - No image input support
-  // "gpt-4-0613", - No image input support
-  // "gpt-3.5-turbo-0125", - Legacy model
-  // "gpt-3.5-turbo", - Legacy model
-  // "gpt-3.5-turbo-1106", - Legacy model
-  // "chatgpt-4o-latest", - No tool support
-];
-var SupportedModels = Object.fromEntries(
-  [...AnthropicModels, ...GoogleModels, ...OpenAIModels].map((model) => [
-    model,
-    { default: model === DefaultModel, model }
-  ])
-);
-function getDefaultModelName() {
-  const model = Object.values(SupportedModels).find((model2) => model2.default);
-  if (!model) {
-    throw new Error("No default model found");
-  }
-  return model.model;
-}
-function getModel(modelId) {
-  const unwrappedModelId = modelId ?? getDefaultModelName();
-  if (AnthropicModels.includes(unwrappedModelId)) {
-    return anthropic(unwrappedModelId);
-  }
-  if (GoogleModels.includes(unwrappedModelId)) {
-    return google(unwrappedModelId);
-  }
-  if (OpenAIModels.includes(unwrappedModelId)) {
-    return openai(unwrappedModelId);
-  }
-  throw new Error(`Unsupported model: ${unwrappedModelId}`);
-}
-
-// src/schemas/messages.ts
-import { z } from "zod";
-var BasePartSchema = z.object({
-  id: z.string()
-});
-var TextPartSchema = BasePartSchema.extend({
-  type: z.literal("textPart"),
-  text: z.string()
-});
-var ImageUrlPartSchema = BasePartSchema.extend({
-  type: z.literal("imageUrlPart"),
-  url: z.string().url(),
-  mimeType: z.string()
-});
-var ImageInlinePartSchema = BasePartSchema.extend({
-  type: z.literal("imageInlinePart"),
-  encodedData: z.string(),
-  mimeType: z.string()
-});
-var ImageBinaryPartSchema = BasePartSchema.extend({
-  type: z.literal("imageBinaryPart"),
-  data: z.string(),
-  mimeType: z.string()
-});
-var FileUrlPartSchema = BasePartSchema.extend({
-  type: z.literal("fileUrlPart"),
-  url: z.string().url(),
-  mimeType: z.string()
-});
-var FileInlinePartSchema = BasePartSchema.extend({
-  type: z.literal("fileInlinePart"),
-  encodedData: z.string(),
-  mimeType: z.string()
-});
-var FileBinaryPartSchema = BasePartSchema.extend({
-  type: z.literal("fileBinaryPart"),
-  data: z.string(),
-  mimeType: z.string()
-});
-var ToolCallPartSchema = BasePartSchema.extend({
-  type: z.literal("toolCallPart"),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  args: z.unknown()
-});
-var ToolResultPartSchema = BasePartSchema.extend({
-  type: z.literal("toolResultPart"),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  contents: z.array(z.union([TextPartSchema, ImageInlinePartSchema])),
-  isError: z.boolean().optional()
-});
-var BaseMessageSchema = z.object({
-  id: z.string()
-});
-var InstructionMessageSchema = BaseMessageSchema.extend({
-  type: z.literal("instructionMessage"),
-  contents: z.array(TextPartSchema),
-  cache: z.boolean().optional()
-});
-var UserMessageSchema = BaseMessageSchema.extend({
-  type: z.literal("userMessage"),
-  contents: z.array(
-    z.union([
-      TextPartSchema,
-      ImageUrlPartSchema,
-      ImageInlinePartSchema,
-      ImageBinaryPartSchema,
-      FileUrlPartSchema,
-      FileInlinePartSchema,
-      FileBinaryPartSchema
-    ])
-  ),
-  cache: z.boolean().optional()
-});
-var ExpertMessageSchema = BaseMessageSchema.extend({
-  type: z.literal("expertMessage"),
-  contents: z.array(z.union([TextPartSchema, ToolCallPartSchema])),
-  cache: z.boolean().optional()
-});
-var ToolMessageSchema = BaseMessageSchema.extend({
-  type: z.literal("toolMessage"),
-  contents: z.array(ToolResultPartSchema),
-  cache: z.boolean().optional()
-});
-var MessageSchema = z.union([
-  InstructionMessageSchema,
-  UserMessageSchema,
-  ExpertMessageSchema,
-  ToolMessageSchema
-]);
-
-// src/schemas/runtime.ts
-var expertNameRegex = /^(@[a-z0-9][a-z0-9_-]*\/)?[a-z0-9][a-z0-9_-]*$/;
-var versionRegex = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?$/;
-var tagNameRegex = /^[a-z0-9][a-z0-9_-]*$/;
-var expertKeyRegex = /^((?:@[a-z0-9][a-z0-9_\.-]*\/)?[a-z0-9][a-z0-9_\.-]*)(?:@((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?)|@([a-z0-9][a-z0-9_\.-]*))?$/;
-var skillNameRegex = /^[a-z0-9][a-z0-9._-]*$/;
-var maxNameLength = 214;
-function parseExpertKey(expertKey) {
-  const match = expertKey.match(expertKeyRegex);
-  if (!match) {
-    throw new Error(`Invalid expert key format: ${expertKey}`);
-  }
-  const [key, name, version, tag] = match;
-  return {
-    key,
-    name,
-    version,
-    tag
-  };
-}
-var McpStdioSkillSchema = z2.object({
-  type: z2.literal("mcpStdioSkill"),
-  name: z2.string(),
-  description: z2.string().optional(),
-  rule: z2.string().optional(),
-  pick: z2.array(z2.string()).optional().default([]),
-  omit: z2.array(z2.string()).optional().default([]),
-  command: z2.string(),
-  packageName: z2.string().optional(),
-  args: z2.array(z2.string()).optional().default([]),
-  requiredEnv: z2.array(z2.string()).optional().default([])
-});
-var McpSseSkillSchema = z2.object({
-  type: z2.literal("mcpSseSkill"),
-  name: z2.string(),
-  description: z2.string().optional(),
-  rule: z2.string().optional(),
-  pick: z2.array(z2.string()).optional().default([]),
-  omit: z2.array(z2.string()).optional().default([]),
-  endpoint: z2.string()
-});
-var InteractiveToolSchema = z2.object({
-  name: z2.string(),
-  description: z2.string().optional(),
-  inputJsonSchema: z2.string()
-});
-var InteractiveSkillSchema = z2.object({
-  type: z2.literal("interactiveSkill"),
-  name: z2.string(),
-  description: z2.string().optional(),
-  rule: z2.string().optional(),
-  tools: z2.record(z2.string(), InteractiveToolSchema.omit({ name: true })).transform((tools) => {
-    return Object.fromEntries(
-      Object.entries(tools).map(([key, toolWithoutName]) => [
-        key,
-        InteractiveToolSchema.parse({ ...toolWithoutName, name: key })
-      ])
-    );
-  })
-});
-var ExpertSchema = z2.object({
-  key: z2.string().regex(expertKeyRegex).min(1),
-  name: z2.string().regex(expertNameRegex).min(1).max(maxNameLength),
-  version: z2.string().regex(versionRegex),
-  description: z2.string().min(1).max(1024 * 2).optional(),
-  instruction: z2.string().min(1).max(1024 * 20),
-  skills: z2.record(
-    z2.string(),
-    z2.discriminatedUnion("type", [
-      McpStdioSkillSchema.omit({ name: true }),
-      McpSseSkillSchema.omit({ name: true }),
-      InteractiveSkillSchema.omit({ name: true })
-    ])
-  ).optional().default({
-    "@perstack/base": {
-      type: "mcpStdioSkill",
-      description: "Base skill",
-      command: "npx",
-      args: ["-y", "@perstack/base"],
-      pick: [],
-      omit: [],
-      requiredEnv: []
-    }
-  }).transform((skills) => {
-    return Object.fromEntries(
-      Object.entries(skills).map(([key, skillWithoutName]) => [
-        key,
-        z2.discriminatedUnion("type", [
-          McpStdioSkillSchema,
-          McpSseSkillSchema,
-          InteractiveSkillSchema
-        ]).parse({ ...skillWithoutName, name: key })
-      ])
-    );
-  }),
-  delegates: z2.array(z2.string().regex(expertKeyRegex).min(1)).optional().default([]),
-  tags: z2.array(z2.string().regex(tagNameRegex).min(1)).optional().default([])
-});
-var UsageSchema = z2.object({
-  promptTokens: z2.number(),
-  completionTokens: z2.number(),
-  totalTokens: z2.number(),
-  cacheCreationInputTokens: z2.number(),
-  cacheReadInputTokens: z2.number()
-});
-var CheckpointStatusSchema = z2.enum([
-  "init",
-  "proceeding",
-  "completed",
-  "stoppedByInteractiveTool",
-  "stoppedByDelegate",
-  "stoppedByExceededMaxSteps",
-  "stoppedByError"
-]);
-var CheckpointSchema = z2.object({
-  id: z2.string(),
-  runId: z2.string(),
-  status: CheckpointStatusSchema,
-  stepNumber: z2.number(),
-  messages: z2.array(MessageSchema),
-  expert: z2.object({
-    key: z2.string(),
-    name: z2.string(),
-    version: z2.string()
-  }),
-  delegateTo: z2.object({
-    expert: z2.object({
-      key: z2.string(),
-      name: z2.string(),
-      version: z2.string()
-    }),
-    toolCallId: z2.string(),
-    toolName: z2.string(),
-    query: z2.string()
-  }).optional(),
-  delegatedBy: z2.object({
-    expert: z2.object({
-      key: z2.string(),
-      name: z2.string(),
-      version: z2.string()
-    }),
-    toolCallId: z2.string(),
-    toolName: z2.string(),
-    checkpointId: z2.string()
-  }).optional(),
-  usage: UsageSchema
-});
-var RunParamsSchema = z2.object({
-  setting: z2.object({
-    runId: z2.string().optional().transform((value) => value ?? createId()),
-    expertKey: z2.string().regex(expertKeyRegex).min(1),
-    input: z2.object({
-      text: z2.string().optional(),
-      interactiveToolCallResult: z2.object({
-        toolCallId: z2.string(),
-        toolName: z2.string(),
-        text: z2.string()
-      }).optional()
-    }),
-    experts: z2.record(z2.string().regex(expertKeyRegex).min(1), ExpertSchema.omit({ key: true })).optional().default({}).transform(
-      (experts) => Object.fromEntries(
-        Object.entries(experts).map(([key, expertWithoutKey]) => [
-          key,
-          ExpertSchema.parse({
-            ...expertWithoutKey,
-            key
-          })
-        ])
-      )
-    ),
-    model: z2.string().optional().default(getDefaultModelName()),
-    temperature: z2.number().min(0).max(1).optional().default(0.3),
-    maxSteps: z2.number().min(1).optional(),
-    maxRetries: z2.number().min(0).optional().default(5),
-    timeout: z2.number().min(0).optional().default(1e3 * 60),
-    workspace: z2.string().optional(),
-    startedAt: z2.number().optional().default(Date.now()),
-    updatedAt: z2.number().optional().default(Date.now())
-  }),
-  checkpoint: CheckpointSchema.optional()
-});
-function createEvent(type) {
-  return (setting, checkpoint, data) => {
-    return {
-      type,
-      id: createId(),
-      expertKey: checkpoint.expert.key,
-      timestamp: Date.now(),
-      runId: setting.runId,
-      stepNumber: checkpoint.stepNumber,
-      ...data
-    };
-  };
-}
-var startRun = createEvent("startRun");
-var startGeneration = createEvent("startGeneration");
-var retry = createEvent("retry");
-var callTool = createEvent("callTool");
-var callInteractiveTool = createEvent("callInteractiveTool");
-var callDelegate = createEvent("callDelegate");
-var resolveToolResult = createEvent("resolveToolResult");
-var resolveThought = createEvent("resolveThought");
-var resolvePdfFile = createEvent("resolvePdfFile");
-var resolveImageFile = createEvent("resolveImageFile");
-var attemptCompletion = createEvent("attemptCompletion");
-var finishToolCall = createEvent("finishToolCall");
-var completeRun = createEvent("completeRun");
-var stopRunByInteractiveTool = createEvent("stopRunByInteractiveTool");
-var stopRunByDelegate = createEvent("stopRunByDelegate");
-var stopRunByExceededMaxSteps = createEvent("stopRunByExceededMaxSteps");
-var continueToNextStep = createEvent("continueToNextStep");
-
-// src/default-store.ts
-async function defaultRetrieveCheckpoint(runId, checkpointId) {
-  const runDir = getRunDir(runId);
-  const checkpointFiles = await readdir(runDir, { withFileTypes: true }).then(
-    (files) => files.filter((file) => file.isFile() && file.name.startsWith("checkpoint-"))
-  );
-  const checkpointFile = checkpointFiles.find((file) => file.name.endsWith(`-${checkpointId}.json`));
-  if (!checkpointFile) {
-    throw new Error(`checkpoint not found: ${runId} ${checkpointId}`);
-  }
-  const checkpointPath = `${runDir}/${checkpointFile.name}`;
-  const checkpoint = await readFile(checkpointPath, "utf8");
-  return CheckpointSchema.parse(JSON.parse(checkpoint));
-}
-async function defaultStoreCheckpoint(checkpoint, timestamp) {
-  const { id, runId, stepNumber } = checkpoint;
-  const runDir = getRunDir(runId);
-  const checkpointPath = `${runDir}/checkpoint-${timestamp}-${stepNumber}-${id}.json`;
-  await mkdir(runDir, { recursive: true });
-  await writeFile(checkpointPath, JSON.stringify(checkpoint, null, 2));
-}
-async function defaultStoreEvent(event) {
-  const { timestamp, runId, stepNumber, type } = event;
-  const runDir = getRunDir(runId);
-  const eventPath = `${runDir}/event-${timestamp}-${stepNumber}-${type}.json`;
-  await mkdir(runDir, { recursive: true });
-  await writeFile(eventPath, JSON.stringify(event, null, 2));
-}
+import { setup, assign, createActor } from 'xstate';
+import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createAzure } from '@ai-sdk/azure';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createOpenAI } from '@ai-sdk/openai';
+import { knownModels, stopRunByDelegate, stopRunByInteractiveTool, resolveThought, attemptCompletion, resolvePdfFile, resolveImageFile, resolveToolResult, stopRunByExceededMaxSteps, continueToNextStep, retry, completeRun, callDelegate, callInteractiveTool, callTool, startRun, startGeneration, finishToolCall, runParamsSchema, checkpointSchema } from '@perstack/core';
+import { createOllama } from 'ollama-ai-provider-v2';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+import { createId } from '@paralleldrive/cuid2';
+import { generateText, tool, jsonSchema } from 'ai';
+import { dedent } from 'ts-dedent';
+import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import { ApiV1Client } from '@perstack/api-client/v1';
 
-// package.json
-var package_default = {
-  name: "@perstack/runtime",
-  version: "0.0.23",
-  description: "PerStack Runtime",
-  author: "Wintermute Technologies, Inc.",
-  license: "Apache-2.0",
-  type: "module",
-  exports: {
-    ".": "./src/index.ts"
-  },
-  publishConfig: {
-    exports: {
-      ".": "./dist/index.js"
-    },
-    types: "./dist/index.d.ts"
-  },
-  files: [
-    "dist"
-  ],
-  scripts: {
-    clean: "rm -rf dist",
-    dev: "tsup --watch --config ../../tsup.config.ts",
-    build: "npm run clean && tsup --config ../../tsup.config.ts",
-    prepublishOnly: "npm run clean && npm run build"
-  },
-  dependencies: {
-    "@ai-sdk/anthropic": "^2.0.1",
-    "@ai-sdk/google": "^2.0.2",
-    "@ai-sdk/openai": "^2.0.3",
-    "@modelcontextprotocol/sdk": "^1.17.1",
-    "@paralleldrive/cuid2": "^2.2.2",
-    ai: "^5.0.4",
-    "smol-toml": "^1.4.1",
-    "ts-dedent": "^2.2.0",
-    xstate: "^5.20.1",
-    zod: "^4.0.14"
-  },
-  devDependencies: {
-    "@tsconfig/node22": "^22.0.2",
-    "@types/node": "^24.2.0",
-    tsup: "^8.5.0",
-    typescript: "^5.9.2",
-    vitest: "^3.2.4"
-  },
-  engines: {
-    node: ">=22.0.0"
-  }
-};
-
-// src/events/default-event-listener.ts
-var log = console.info;
-var debug = console.debug;
-var header = (e) => {
-  const t = (/* @__PURE__ */ new Date()).toISOString();
-  const stepNumber = e.stepNumber;
-  const key = e.expertKey;
-  return `${t} ${stepNumber} ${key}`;
-};
-async function defaultEventListener(e) {
-  await defaultStoreEvent(e);
-  switch (e.type) {
-    case "startRun": {
-      log(`${header(e)} Perstack@${package_default.version} started`);
-      const { inputMessages } = e;
-      for (const message of inputMessages) {
-        if (message.type === "userMessage") {
-          logUserMessage(message);
-        } else if (message.type === "toolMessage") {
-          logToolMessage(message);
-        }
-      }
-      break;
-    }
-    case "startGeneration": {
-      log(`${header(e)} Generating tool call`);
-      break;
-    }
-    case "retry": {
-      logUsage(e);
-      log(`${header(e)} Retrying tool call generation`);
-      break;
-    }
-    case "callTool": {
-      logUsage(e);
-      log(`${header(e)} Calling tool`);
-      if (e.toolCall.skillName === "@perstack/base") {
-        switch (e.toolCall.toolName) {
-          case "think": {
-            const thought = e.toolCall.args.thought;
-            log(`${header(e)} Thought Updated:`);
-            debug(thought);
-            break;
-          }
-          case "readPdfFile": {
-            const path2 = e.toolCall.args.path;
-            log(`${header(e)} Reading PDF: ${path2}`);
-            break;
-          }
-          case "readImageFile": {
-            const path2 = e.toolCall.args.path;
-            log(`${header(e)} Reading Image: ${path2}`);
-            break;
-          }
-          default: {
-            log(`${header(e)} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
-            debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
-            break;
-          }
-        }
-      } else {
-        log(`${header(e)} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
-        debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
-      }
-      break;
-    }
-    case "callInteractiveTool": {
-      logUsage(e);
-      log(`${header(e)} Calling interactive tool`);
-      log(`${header(e)} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
-      debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
-      break;
-    }
-    case "callDelegate": {
-      logUsage(e);
-      log(`${header(e)} Calling delegate`);
-      log(`${header(e)} Tool: ${e.toolCall.toolName}`);
-      debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
-      break;
-    }
-    case "resolveToolResult": {
-      log(`${header(e)} Resolved Tool Result`);
-      if (e.toolResult.skillName === "@perstack/base") {
-        switch (e.toolResult.toolName) {
-          case "todo": {
-            const text = e.toolResult.result.find((r) => r.type === "textPart")?.text;
-            const { todos } = JSON.parse(text ?? "{}");
-            log(`${header(e)} Todo:`);
-            for (const todo of todos) {
-              debug(`${todo.completed ? "[x]" : "[ ]"} ${todo.id}: ${todo.title}`);
-            }
-            break;
-          }
-          default: {
-            log(`${header(e)} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`);
-            debug(`${header(e)} Result: ${JSON.stringify(e.toolResult.result, null, 2)}`);
-            break;
-          }
-        }
-      } else {
-        log(`${header(e)} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`);
-        debug(`${header(e)} Result: ${JSON.stringify(e.toolResult.result, null, 2)}`);
-      }
-      break;
-    }
-    case "resolveThought": {
-      log(`${header(e)} Resolved Thought:`, e.toolResult);
-      break;
-    }
-    case "resolvePdfFile": {
-      log(`${header(e)} Resolved PDF:`, e.toolResult);
-      break;
-    }
-    case "resolveImageFile": {
-      log(`${header(e)} Resolved Image:`, e.toolResult);
-      break;
-    }
-    case "attemptCompletion": {
-      log(`${header(e)} Attempting completion`);
-      break;
-    }
-    case "completeRun": {
-      logUsage(e);
-      log(`${header(e)} Completing run`);
-      debug(`${header(e)} Result:`, e.text);
-      break;
-    }
-    case "stopRunByInteractiveTool": {
-      log(`${header(e)} Stopping run by interactive tool`);
-      break;
-    }
-    case "stopRunByDelegate": {
-      log(`${header(e)} Stopping run by delegate`);
-      break;
-    }
-    case "stopRunByExceededMaxSteps": {
-      log(`${header(e)} Stopping run by exceeded max steps`);
-      break;
+// src/runtime-state-machine.ts
+function getModel(modelId, providerConfig) {
+  switch (providerConfig.name) {
+    case "anthropic": {
+      const anthropic = createAnthropic({
+        apiKey: providerConfig.apiKey,
+        baseURL: providerConfig.baseUrl
+      });
+      return anthropic(modelId);
     }
-    case "continueToNextStep": {
-      log(`${header(e)} Continuing to next step`);
-      break;
+    case "google": {
+      const google = createGoogleGenerativeAI({
+        apiKey: providerConfig.apiKey,
+        baseURL: providerConfig.baseUrl
+      });
+      return google(modelId);
+    }
+    case "openai": {
+      const openai = createOpenAI({
+        apiKey: providerConfig.apiKey,
+        baseURL: providerConfig.baseUrl,
+        organization: providerConfig.organization,
+        project: providerConfig.project
+      });
+      return openai(modelId);
     }
-  }
-}
-function logUserMessage(message) {
-  const t = (/* @__PURE__ */ new Date()).toISOString();
-  const contents = message.contents;
-  for (const content of contents) {
-    if (content.type === "textPart") {
-      log(`${t} User: ${content.text}`);
-    } else if (content.type === "imageUrlPart") {
-      log(`${t} User: ${content.url}`);
-    } else if (content.type === "imageInlinePart") {
-      log(`${t} User: Inline image`);
-    } else if (content.type === "imageBinaryPart") {
-      log(`${t} User: Binary image`);
-    } else if (content.type === "fileUrlPart") {
-      log(`${t} User: ${content.url}`);
-    } else if (content.type === "fileInlinePart") {
-      log(`${t} User: Inline file`);
-    } else if (content.type === "fileBinaryPart") {
-      log(`${t} User: Binary file`);
+    case "ollama": {
+      const ollama = createOllama({
+        baseURL: providerConfig.baseUrl
+      });
+      return ollama(modelId);
     }
-  }
-}
-function logToolMessage(message) {
-  const t = (/* @__PURE__ */ new Date()).toISOString();
-  const contents = message.contents;
-  for (const content of contents) {
-    if (content.type === "toolResultPart") {
-      const { contents: contents2 } = content;
-      for (const content2 of contents2) {
-        if (content2.type === "textPart") {
-          log(`${t} Tool Result: ${content2.text}`);
-        } else if (content2.type === "imageInlinePart") {
-          log(`${t} Tool Result: Inline image`);
-        }
-      }
+    case "azure-openai": {
+      const azure = createAzure({
+        apiKey: providerConfig.apiKey,
+        resourceName: providerConfig.resourceName,
+        apiVersion: providerConfig.apiVersion
+      });
+      return azure(modelId);
+    }
+    case "amazon-bedrock": {
+      const amazonBedrock = createAmazonBedrock({
+        accessKeyId: providerConfig.accessKeyId,
+        secretAccessKey: providerConfig.secretAccessKey,
+        region: providerConfig.region,
+        sessionToken: providerConfig.sessionToken
+      });
+      return amazonBedrock(modelId);
     }
   }
 }
-function logUsage(e) {
-  const usageByGeneration = [
-    `In: ${e.usage.promptTokens.toLocaleString()}`,
-    `Out: ${e.usage.completionTokens.toLocaleString()}`,
-    `Total: ${e.usage.totalTokens.toLocaleString()}`,
-    `Cache-read: ${e.usage.cacheReadInputTokens.toLocaleString()}`,
-    `Cache-write: ${e.usage.cacheCreationInputTokens.toLocaleString()}`
-  ].join(", ");
-  log(`${header(e)} Tokens usage: ${usageByGeneration}`);
-  const usageByRun = [
-    `In: ${e.usage.promptTokens.toLocaleString()}`,
-    `Out: ${e.usage.completionTokens.toLocaleString()}`,
-    `Total: ${e.usage.totalTokens.toLocaleString()}`,
-    `Cache-read: ${e.usage.cacheReadInputTokens.toLocaleString()}`,
-    `Cache-write: ${e.usage.cacheCreationInputTokens.toLocaleString()}`
-  ].join(", ");
-  log(`${header(e)} Total usage: ${usageByRun}`);
+function getContextWindow(providerName, modelId) {
+  const modelConfig = knownModels.find((model) => model.provider === providerName)?.models.find((model) => model.name === modelId);
+  return modelConfig?.contextWindow;
 }
-
-// src/events/event-emitter.ts
-import { createId as createId2 } from "@paralleldrive/cuid2";
-var RunEventEmitter = class {
-  listeners = [];
-  subscribe(listener) {
-    this.listeners.push(listener);
-  }
-  async emit(event) {
-    for (const listener of this.listeners) {
-      await listener({
-        ...event,
-        id: createId2(),
-        timestamp: Date.now()
-      });
-    }
-  }
-};
-
-// src/schemas/api-registry.ts
-import { z as z3 } from "zod";
-var RegistryV1ExpertSchema = z3.object({
-  name: z3.string(),
-  version: z3.string(),
-  minRuntimeVersion: z3.string(),
-  description: z3.string(),
-  instruction: z3.string(),
-  skills: z3.record(
-    z3.string(),
-    z3.discriminatedUnion("type", [
-      McpStdioSkillSchema.omit({ name: true }),
-      McpSseSkillSchema.omit({ name: true }),
-      InteractiveSkillSchema.omit({ name: true })
-    ])
-  ),
-  delegates: z3.array(z3.string()),
-  tags: z3.array(z3.string()),
-  status: z3.string(),
-  owner: z3.object({ name: z3.string() }),
-  createdAt: z3.iso.datetime(),
-  updatedAt: z3.iso.datetime()
-});
-var RegistryV1ExpertsGetResponseSchema = z3.object({
-  data: z3.object({
-    expert: RegistryV1ExpertSchema
-  })
-});
-
-// src/api-clinent.ts
-var Perstack = class {
-  baseUrl;
-  registry;
-  apiKey;
-  constructor(params) {
-    this.baseUrl = params?.baseUrl ?? process.env.PERSTACK_API_BASE_URL ?? "https://api.perstack.ai";
-    this.apiKey = params?.apiKey ?? process.env.PERSTACK_API_KEY;
-    this.registry = new RegistryClientV1(this);
-  }
-};
-var RegistryClientV1 = class {
-  client;
-  endpoint;
-  constructor(client) {
-    this.client = client;
-    this.endpoint = "/api/registry/v1/experts";
-  }
-  async get(expertKey) {
-    const safeExpertKey = encodeURIComponent(expertKey);
-    const url = new URL(`${this.endpoint}/${safeExpertKey}`, this.client.baseUrl);
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.client.apiKey}`
-    };
-    const result = await fetch(url.toString(), { headers });
-    if (!result.ok) {
-      throw new Error(
-        `Registry returned non-200 status code: ${result.status}, reason: ${result.statusText}`
-      );
-    }
-    const json = await result.json();
-    return RegistryV1ExpertsGetResponseSchema.parse(json);
-  }
-};
-
-// src/resolve-expert-to-run.ts
-async function resolveExpertToRun(expertKey, experts) {
-  if (experts[expertKey]) {
-    return experts[expertKey];
-  }
-  const client = new Perstack();
-  const { data } = await client.registry.get(expertKey);
-  const expert = ExpertSchema.parse({
-    ...data.expert,
-    key: expertKey
-  });
-  experts[expertKey] = expert;
-  return expert;
+function calculateContextWindowUsage(usage, contextWindow) {
+  return (usage.inputTokens + usage.cachedInputTokens + usage.outputTokens) / contextWindow;
 }
-
-// src/runtime-state-machine.ts
-import { assign, setup } from "xstate";
-
-// src/skill-manager.ts
-import { Client as McpClient } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { McpError } from "@modelcontextprotocol/sdk/types.js";
-import { createId as createId3 } from "@paralleldrive/cuid2";
-import { jsonSchema, tool } from "ai";
-import { ZodError } from "zod";
 var SkillManager = class {
   _toolDefinitions = [];
   _initialized = false;
@@ -833,6 +86,7 @@ var SkillManager = class {
   expert;
   _mcpClient;
   _params;
+  _env;
   constructor(params) {
     this._params = params;
     this.type = params.type;
@@ -840,14 +94,17 @@ var SkillManager = class {
       case "mcp":
         this.name = params.skill.name;
         this.skill = params.skill;
+        this._env = params.env;
         break;
       case "interactive":
         this.name = params.interactiveSkill.name;
         this.interactiveSkill = params.interactiveSkill;
+        this._env = {};
         break;
       case "delegate":
         this.name = params.expert.name;
         this.expert = params.expert;
+        this._env = {};
         break;
     }
   }
@@ -868,7 +125,7 @@ var SkillManager = class {
     }
   }
   async _initMcpSkill(params) {
-    this._mcpClient = new McpClient({
+    this._mcpClient = new Client({
       name: `${params.skill.name}-mcp-client`,
       version: "1.0.0"
     });
@@ -877,14 +134,16 @@ var SkillManager = class {
         if (!params.skill.command) {
           throw new Error(`Skill ${params.skill.name} has no command`);
         }
+        const env = {};
+        const { requiredEnv } = params.skill;
+        for (const envName of requiredEnv) {
+          if (!this._env[envName]) {
+            throw new Error(`Skill ${params.skill.name} requires environment variable ${envName}`);
+          }
+          env[envName] = this._env[envName];
+        }
         const { command, args } = this._getCommandArgs(params.skill);
-        const transport = new StdioClientTransport({
-          command,
-          args,
-          env: Object.fromEntries(
-            Object.entries(process.env).filter(([_, value]) => value !== void 0 && value !== "").map(([key, value]) => [key, value])
-          )
-        });
+        const transport = new StdioClientTransport({ command, args, env });
         await this._mcpClient.connect(transport);
         break;
       }
@@ -995,13 +254,10 @@ var SkillManager = class {
         {
           type: "textPart",
           text: `Error calling tool ${toolName}: ${error.message}`,
-          id: createId3()
+          id: createId()
         }
       ];
     }
-    if (error instanceof ZodError) {
-      return [{ type: "textPart", text: `Invalid tool call arguments: ${error}`, id: createId3() }];
-    }
     throw error;
   }
   _convertToolResult(result, toolName, input) {
@@ -1010,7 +266,7 @@ var SkillManager = class {
         {
           type: "textPart",
           text: `Tool ${toolName} returned nothing with arguments: ${JSON.stringify(input)}`,
-          id: createId3()
+          id: createId()
         }
       ];
     }
@@ -1020,9 +276,9 @@ var SkillManager = class {
     switch (part.type) {
       case "text":
         if (!part.text || part.text === "") {
-          return { type: "textPart", text: "Error: No content", id: createId3() };
+          return { type: "textPart", text: "Error: No content", id: createId() };
         }
-        return { type: "textPart", text: part.text, id: createId3() };
+        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");
@@ -1031,7 +287,7 @@ var SkillManager = class {
           type: "imageInlinePart",
           encodedData: part.data,
           mimeType: part.mimeType,
-          id: createId3()
+          id: createId()
         };
       case "resource":
         if (!part.resource) {
@@ -1045,39 +301,36 @@ var SkillManager = class {
       throw new Error(`Resource ${JSON.stringify(resource)} has no mimeType`);
     }
     if (resource.text && typeof resource.text === "string") {
-      return { type: "textPart", text: resource.text, id: createId3() };
+      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: createId3()
+        id: createId()
       };
     }
     throw new Error(`Unsupported resource type: ${JSON.stringify(resource)}`);
   }
 };
-async function getSkillManagers(expert, experts) {
+async function getSkillManagers(expert, experts, setting) {
+  const { perstackBaseSkillArgs, env } = setting;
   const skillManagers = {};
   const { skills } = expert;
   if (!skills["@perstack/base"]) {
-    skills["@perstack/base"] = {
-      type: "mcpStdioSkill",
-      name: "@perstack/base",
-      description: "The base skill for Perstack",
-      pick: [],
-      omit: [],
-      command: "npx",
-      args: ["-y", "@perstack/base"],
-      requiredEnv: []
-    };
+    throw new Error("Base skill is not defined");
   }
   const mcpSkillManagers = await Promise.all(
     Object.values(skills).filter((skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill").map(async (skill) => {
+      if (perstackBaseSkillArgs && skill.type === "mcpStdioSkill" && skill.name === "@perstack/base") {
+        skill.packageName = void 0;
+        skill.args = ["-y", ...perstackBaseSkillArgs];
+      }
       const skillManager = new SkillManager({
         type: "mcp",
-        skill
+        skill,
+        env
       });
       await skillManager.init();
       return skillManager;
@@ -1152,12 +405,12 @@ async function callingDelegateLogic({
   step,
   skillManagers
 }) {
-  if (!step?.toolCall) {
+  if (!step.toolCall) {
     throw new Error("No tool call found");
   }
   const { id, toolName, args } = step.toolCall;
   const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
-  if (!skillManager || !skillManager.expert) {
+  if (!skillManager.expert) {
     throw new Error(`Delegation error: skill manager "${toolName}" not found`);
   }
   if (!args || !args.query || typeof args.query !== "string") {
@@ -1184,8 +437,6 @@ async function callingDelegateLogic({
     }
   });
 }
-
-// src/states/calling-interactive-tool.ts
 async function callingInteractiveToolLogic({
   setting,
   checkpoint,
@@ -1202,15 +453,13 @@ async function callingInteractiveToolLogic({
     }
   });
 }
-
-// src/states/calling-tool.ts
 async function callingToolLogic({
   setting,
   checkpoint,
   step,
   skillManagers
 }) {
-  if (!step?.toolCall) {
+  if (!step.toolCall) {
     throw new Error("No tool call found");
   }
   const { id, skillName, toolName, args } = step.toolCall;
@@ -1236,9 +485,6 @@ async function callingToolLogic({
   }
   return resolveToolResult(setting, checkpoint, { toolResult });
 }
-
-// src/states/finishing-step.ts
-import { createId as createId4 } from "@paralleldrive/cuid2";
 async function finishingStepLogic({
   setting,
   checkpoint,
@@ -1266,26 +512,19 @@ async function finishingStepLogic({
     },
     nextCheckpoint: {
       ...checkpoint,
-      id: createId4(),
+      id: createId(),
       stepNumber: checkpoint.stepNumber + 1
     }
   });
 }
-
-// src/states/generating-run-result.ts
-import { generateText } from "ai";
-
-// src/messages/message.ts
-import { createId as createId5 } from "@paralleldrive/cuid2";
-import { dedent } from "ts-dedent";
 function createUserMessage(contents) {
   return {
     type: "userMessage",
     contents: contents.map((part) => ({
       ...part,
-      id: createId5()
+      id: createId()
     })),
-    id: createId5()
+    id: createId()
   };
 }
 function createExpertMessage(contents) {
@@ -1293,9 +532,9 @@ function createExpertMessage(contents) {
     type: "expertMessage",
     contents: contents.map((part) => ({
       ...part,
-      id: createId5()
+      id: createId()
     })),
-    id: createId5()
+    id: createId()
   };
 }
 function createToolMessage(contents) {
@@ -1305,11 +544,11 @@ function createToolMessage(contents) {
       ...part,
       contents: part.contents.map((part2) => ({
         ...part2,
-        id: createId5()
+        id: createId()
       })),
-      id: createId5()
+      id: createId()
     })),
-    id: createId5()
+    id: createId()
   };
 }
 function messageToCoreMessage(message) {
@@ -1476,36 +715,29 @@ function toolResultPartToCoreToolResultPart(part) {
 // src/usage.ts
 function createEmptyUsage() {
   return {
-    promptTokens: 0,
-    completionTokens: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
     totalTokens: 0,
-    cacheCreationInputTokens: 0,
-    cacheReadInputTokens: 0
+    cachedInputTokens: 0
   };
 }
 function usageFromGenerateTextResult(result) {
-  let cacheCreationInputTokens = 0;
-  let cacheReadInputTokens = 0;
-  if (result.providerMetadata?.anthropic) {
-    const anthropicMetadata = result.providerMetadata.anthropic;
-    cacheCreationInputTokens = anthropicMetadata.cacheCreationInputTokens || 0;
-    cacheReadInputTokens = anthropicMetadata.cacheReadInputTokens || 0;
-  }
   return {
-    promptTokens: result.usage.inputTokens || 0,
-    completionTokens: result.usage.outputTokens || 0,
+    inputTokens: result.usage.inputTokens || 0,
+    outputTokens: result.usage.outputTokens || 0,
+    reasoningTokens: result.usage.reasoningTokens || 0,
     totalTokens: result.usage.totalTokens || 0,
-    cacheCreationInputTokens,
-    cacheReadInputTokens
+    cachedInputTokens: result.usage.cachedInputTokens || 0
   };
 }
 function sumUsage(a, b) {
   return {
-    promptTokens: a.promptTokens + b.promptTokens,
-    completionTokens: a.completionTokens + b.completionTokens,
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    reasoningTokens: a.reasoningTokens + b.reasoningTokens,
     totalTokens: a.totalTokens + b.totalTokens,
-    cacheCreationInputTokens: a.cacheCreationInputTokens + b.cacheCreationInputTokens,
-    cacheReadInputTokens: a.cacheReadInputTokens + b.cacheReadInputTokens
+    cachedInputTokens: a.cachedInputTokens + b.cachedInputTokens
   };
 }
 
@@ -1515,7 +747,7 @@ async function generatingRunResultLogic({
   checkpoint,
   step
 }) {
-  if (!step?.toolCall || !step?.toolResult) {
+  if (!step.toolCall || !step.toolResult) {
     throw new Error("No tool call or tool result found");
   }
   const { id, toolName } = step.toolCall;
@@ -1530,7 +762,7 @@ async function generatingRunResultLogic({
       )
     }
   ]);
-  const model = getModel(setting.model);
+  const model = getModel(setting.model, setting.providerConfig);
   const { messages } = checkpoint;
   let generationResult;
   try {
@@ -1543,17 +775,11 @@ async function generatingRunResultLogic({
     });
   } catch (error) {
     if (error instanceof Error) {
+      const reason = JSON.stringify({ error: error.name, message: error.message });
       return retry(setting, checkpoint, {
-        newMessages: [
-          toolMessage,
-          createUserMessage([
-            {
-              type: "textPart",
-              text: JSON.stringify({ error: error.name, message: error.message })
-            }
-          ])
-        ],
-        usage: checkpoint.usage
+        reason,
+        newMessages: [toolMessage, createUserMessage([{ type: "textPart", text: reason }])],
+        usage: createEmptyUsage()
       });
     }
     throw error;
@@ -1566,6 +792,7 @@ async function generatingRunResultLogic({
       ...checkpoint,
       messages: [...messages, ...newMessages],
       usage: sumUsage(checkpoint.usage, usage),
+      contextWindowUsage: checkpoint.contextWindow ? calculateContextWindowUsage(usage, checkpoint.contextWindow) : void 0,
       status: "completed"
     },
     step: {
@@ -1578,20 +805,16 @@ async function generatingRunResultLogic({
     usage
   });
 }
-
-// src/states/generating-tool-call.ts
-import { createId as createId6 } from "@paralleldrive/cuid2";
-import { generateText as generateText2 } from "ai";
 async function generatingToolCallLogic({
   setting,
   checkpoint,
   skillManagers
 }) {
   const { messages } = checkpoint;
-  const model = getModel(setting.model);
+  const model = getModel(setting.model, setting.providerConfig);
   let result;
   try {
-    result = await generateText2({
+    result = await generateText({
       model,
       messages: messages.map(messageToCoreMessage),
       temperature: setting.temperature,
@@ -1602,16 +825,12 @@ async function generatingToolCallLogic({
     });
   } catch (error) {
     if (error instanceof Error) {
+      console.error(error);
+      const reason = JSON.stringify({ error: error.name, message: error.message });
       return retry(setting, checkpoint, {
-        newMessages: [
-          createUserMessage([
-            {
-              type: "textPart",
-              text: JSON.stringify({ error: error.name, message: error.message })
-            }
-          ])
-        ],
-        usage: checkpoint.usage
+        reason,
+        newMessages: [createUserMessage([{ type: "textPart", text: reason }])],
+        usage: createEmptyUsage()
       });
     }
     throw error;
@@ -1620,18 +839,13 @@ async function generatingToolCallLogic({
   const { text, toolCalls, finishReason } = result;
   const toolCall = toolCalls[0];
   if (!toolCall) {
+    const reason = JSON.stringify({
+      error: "Error: No tool call generated",
+      message: "You must generate a tool call. Try again."
+    });
     return retry(setting, checkpoint, {
-      newMessages: [
-        createUserMessage([
-          {
-            type: "textPart",
-            text: JSON.stringify({
-              error: "Error: No tool call generated",
-              message: "You must generate a tool call. Try again."
-            })
-          }
-        ])
-      ],
+      reason,
+      newMessages: [createUserMessage([{ type: "textPart", text: reason }])],
       usage
     });
   }
@@ -1660,7 +874,7 @@ async function generatingToolCallLogic({
     },
     usage
   };
-  if (finishReason === "tool-calls") {
+  if (finishReason === "tool-calls" || finishReason === "stop") {
     switch (skillManager.type) {
       case "mcp":
         return callTool(setting, checkpoint, eventPayload);
@@ -1671,7 +885,12 @@ async function generatingToolCallLogic({
     }
   }
   if (finishReason === "length") {
+    const reason = JSON.stringify({
+      error: "Error: Tool call generation failed",
+      message: "Generation length exceeded. Try again."
+    });
     return retry(setting, checkpoint, {
+      reason,
       newMessages: [
         createExpertMessage([
           {
@@ -1686,15 +905,7 @@ async function generatingToolCallLogic({
             type: "toolResultPart",
             toolCallId: toolCall.toolCallId,
             toolName: toolCall.toolName,
-            contents: [
-              {
-                type: "textPart",
-                text: JSON.stringify({
-                  error: "Error: Tool call generation failed",
-                  message: "Generation length exceeded. Try again."
-                })
-              }
-            ]
+            contents: [{ type: "textPart", text: reason }]
           }
         ])
       ],
@@ -1703,27 +914,14 @@ async function generatingToolCallLogic({
         id: toolCall.toolCallId,
         skillName: skillManager.name,
         toolName: toolCall.toolName,
-        result: [
-          {
-            type: "textPart",
-            id: createId6(),
-            text: JSON.stringify({
-              error: "Error: Tool call generation failed",
-              message: "Generation length exceeded. Try again."
-            })
-          }
-        ]
+        result: [{ type: "textPart", id: createId(), text: reason }]
       },
       usage
     });
   }
   throw new Error(`Unexpected finish reason: ${finishReason}`);
 }
-
-// src/messages/instruction-message.ts
-import { createId as createId7 } from "@paralleldrive/cuid2";
-import { dedent as dedent2 } from "ts-dedent";
-var metaInstruction = dedent2`
+var metaInstruction = dedent`
   IMPORTANT:
   You are NOT an "interactive" AI agent.
   From the start of the agent loop until the completion of the task,
@@ -1741,33 +939,32 @@ var metaInstruction = dedent2`
   5. Notify Task Completion: Call the attemptCompletion tool to inform the user when the task is complete
   6. Generate Final Results: Produce a final result that clearly describes each task you performed, step by step
 
-  エージェントループの終了条件:
-  以下の条件に該当した場合は、**即座にattemptCompletionツールを呼び出してください**。
-  エージェントループを終了しなければならない状況で、attemptCompletion以外のツールを呼び出すことは非常に危険です。
-  絶対に、何があってもこのルールは守るようにしてください。
-  - タスクが完了した時
-  - ユーザーの依頼があなたの専門外だった時
-  - ユーザーが倫理的に不正な要求をした時
-  - ユーザーの依頼が理解不能である時
-  - ユーザーの依頼によって、セキュリティに危険が生じる恐れがある時
-  - ユーザーの依頼によって、他人に迷惑をかける恐れがある時
-  - ユーザーの依頼に、不適切な言葉や、性的な内容が含まれている時
+  Conditions for ending the agent loop:
+  If any of the following apply, **immediately call the attemptCompletion tool**.
+  When the agent loop must end, calling any tool other than attemptCompletion is highly dangerous.
+  Under all circumstances, strictly follow this rule.
+  - When the task is complete
+  - When the user's request is outside your expertise
+  - When the user makes an unethical request
+  - When the user's request is unintelligible
+  - When the request may pose security risks
+  - When the request may harm or inconvenience others
+  - When the request contains inappropriate or sexual content
 
   Rules for requests outside your area of expertise:
   - Tell your area of expertise to the user in final results
-  - In the Final Result, you can show the user how to create an expert that they might need; This can be done by running the \`parrot new\` (no arguments required) command.
 
-  全般的なタスクの取り組み方や、アウトプット品質に関するルール:
-  - ユーザはあなたのことを、その分野の『専門家』であると認識しています
-  - 専門家である以上、タスクの実行においては、徹底した考察を行いつつ、確証を持って一つ一つのタスクを実行してください
-  - 専門家である以上、ユーザーが期待する以上の品質のアウトプットを行ってください
+  General approach and output quality rules:
+  - The user recognizes you as an expert in this domain
+  - As an expert, execute each step with thorough reasoning and high confidence
+  - As an expert, deliver output exceeding the user's expectations
 
   Environment information:
   - Current time is ${(/* @__PURE__ */ new Date()).toISOString()}
   - Current working directory is ${process.cwd()}
 `;
 function createInstructionMessage(expert, experts) {
-  const instruction = dedent2`
+  const instruction = dedent`
     You are Perstack, an AI expert that tackles tasks requested by users by utilizing all available tools.
 
     (The following information describes your nature and role as an AI, the mechanisms of the AI system, and other meta-cognitive aspects.)
@@ -1795,12 +992,12 @@ function createInstructionMessage(expert, experts) {
     type: "instructionMessage",
     contents: [
       {
-        id: createId7(),
+        id: createId(),
         type: "textPart",
         text: instruction
       }
     ],
-    id: createId7(),
+    id: createId(),
     cache: true
   };
 }
@@ -1809,7 +1006,7 @@ function getSkillRules(expert) {
     if (!skill.rule) {
       return acc;
     }
-    return dedent2`
+    return dedent`
       ${acc}
 
       "${skill.name}" skill rules:
@@ -1823,7 +1020,7 @@ function getDelegateRules(expert, experts) {
     if (!delegate) {
       return acc;
     }
-    return dedent2`
+    return dedent`
       ${acc}
 
       About "${delegate.name}":
@@ -1847,33 +1044,12 @@ async function initLogic({
       return startRun(setting, checkpoint, {
         initialCheckpoint: checkpoint,
         inputMessages: [
-          createInstructionMessage(expert, experts),
-          createUserMessage([{ type: "textPart", text: setting.input.text }])
-        ]
-      });
-    }
-    case "proceeding": {
-      if (!setting.input.text) {
-        throw new Error("Input message is undefined");
-      }
-      return startRun(setting, checkpoint, {
-        initialCheckpoint: checkpoint,
-        inputMessages: [createUserMessage([{ type: "textPart", text: setting.input.text }])]
-      });
-    }
-    case "stoppedByDelegate": {
-      if (!setting.input.interactiveToolCallResult) {
-        throw new Error("Interactive tool call result is undefined");
-      }
-      return startRun(setting, checkpoint, {
-        initialCheckpoint: checkpoint,
-        inputMessages: [
-          createUserMessage([
-            { type: "textPart", text: setting.input.interactiveToolCallResult.text }
-          ])
+          createInstructionMessage(expert, experts),
+          createUserMessage([{ type: "textPart", text: setting.input.text }])
         ]
       });
     }
+    case "stoppedByDelegate":
     case "stoppedByInteractiveTool": {
       if (!setting.input.interactiveToolCallResult) {
         throw new Error("Interactive tool call result is undefined");
@@ -1893,11 +1069,15 @@ async function initLogic({
       });
     }
     default:
-      throw new Error(`Unexpected checkpoint status: ${checkpoint.status}`);
+      if (!setting.input.text) {
+        throw new Error("Input message is undefined");
+      }
+      return startRun(setting, checkpoint, {
+        initialCheckpoint: checkpoint,
+        inputMessages: [createUserMessage([{ type: "textPart", text: setting.input.text }])]
+      });
   }
 }
-
-// src/states/preparing-for-step.ts
 async function preparingForStepLogic({
   setting,
   checkpoint
@@ -1906,15 +1086,12 @@ async function preparingForStepLogic({
     messages: checkpoint.messages
   });
 }
-
-// src/states/resolving-image-file.ts
-import { readFile as readFile2 } from "fs/promises";
 async function resolvingImageFileLogic({
   setting,
   checkpoint,
   step
 }) {
-  if (!step?.toolCall || !step?.toolResult) {
+  if (!step.toolCall || !step.toolResult) {
     throw new Error("No tool call or tool result found");
   }
   const { id, toolName } = step.toolCall;
@@ -1933,7 +1110,7 @@ async function resolvingImageFileLogic({
       continue;
     }
     const { path: path2, mimeType, size } = imageInfo;
-    const file = await readFile2(path2).then((buffer) => ({
+    const file = await readFile(path2).then((buffer) => ({
       encodedData: buffer.toString("base64"),
       mimeType,
       size
@@ -1957,15 +1134,12 @@ async function resolvingImageFileLogic({
     ]
   });
 }
-
-// src/states/resolving-pdf-file.ts
-import { readFile as readFile3 } from "fs/promises";
 async function resolvingPdfFileLogic({
   setting,
   checkpoint,
   step
 }) {
-  if (!step?.toolCall || !step?.toolResult) {
+  if (!step.toolCall || !step.toolResult) {
     throw new Error("No tool call or tool result found");
   }
   const { id, toolName } = step.toolCall;
@@ -1984,7 +1158,7 @@ async function resolvingPdfFileLogic({
       continue;
     }
     const { path: path2, mimeType, size } = pdfInfo;
-    const file = await readFile3(path2).then((buffer) => ({
+    const file = await readFile(path2).then((buffer) => ({
       encodedData: buffer.toString("base64"),
       mimeType,
       size
@@ -2014,14 +1188,12 @@ async function resolvingPdfFileLogic({
     ]
   });
 }
-
-// src/states/resolving-tool-result.ts
 async function resolvingToolResultLogic({
   setting,
   checkpoint,
   step
 }) {
-  if (!step?.toolCall || !step?.toolResult) {
+  if (!step.toolCall || !step.toolResult) {
     throw new Error("No tool call or tool result found");
   }
   const { id, toolName } = step.toolCall;
@@ -2077,17 +1249,14 @@ var runtimeStateMachine = setup({
         startRun: {
           target: "PreparingForStep",
           actions: assign({
-            checkpoint: ({ event }) => ({
-              ...event.initialCheckpoint,
-              messages: [...event.initialCheckpoint.messages, ...event.inputMessages],
-              status: "proceeding"
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              status: "proceeding",
+              messages: [...context.checkpoint.messages, ...event.inputMessages]
             }),
-            step: ({ event }) => ({
-              stepNumber: event.initialCheckpoint.stepNumber,
-              inputMessages: event.inputMessages,
-              newMessages: [],
-              usage: createEmptyUsage(),
-              startedAt: event.timestamp
+            step: ({ context, event }) => ({
+              ...context.step,
+              inputMessages: event.inputMessages
             })
           })
         }
@@ -2100,7 +1269,7 @@ var runtimeStateMachine = setup({
           actions: assign({
             step: ({ context, event }) => ({
               stepNumber: context.checkpoint.stepNumber,
-              inputMessages: context.step.inputMessages,
+              inputMessages: context.step.inputMessages ?? [],
               newMessages: [],
               usage: createEmptyUsage(),
               startedAt: event.timestamp
@@ -2134,7 +1303,8 @@ var runtimeStateMachine = setup({
             checkpoint: ({ context, event }) => ({
               ...context.checkpoint,
               messages: [...context.checkpoint.messages, event.newMessage],
-              usage: sumUsage(context.checkpoint.usage, event.usage)
+              usage: sumUsage(context.checkpoint.usage, event.usage),
+              contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(event.usage, context.checkpoint.contextWindow) : void 0
             }),
             step: ({ context, event }) => ({
               ...context.step,
@@ -2150,7 +1320,8 @@ var runtimeStateMachine = setup({
             checkpoint: ({ context, event }) => ({
               ...context.checkpoint,
               messages: [...context.checkpoint.messages, event.newMessage],
-              usage: sumUsage(context.checkpoint.usage, event.usage)
+              usage: sumUsage(context.checkpoint.usage, event.usage),
+              contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(event.usage, context.checkpoint.contextWindow) : void 0
             }),
             step: ({ context, event }) => ({
               ...context.step,
@@ -2166,7 +1337,8 @@ var runtimeStateMachine = setup({
             checkpoint: ({ context, event }) => ({
               ...context.checkpoint,
               messages: [...context.checkpoint.messages, event.newMessage],
-              usage: sumUsage(context.checkpoint.usage, event.usage)
+              usage: sumUsage(context.checkpoint.usage, event.usage),
+              contextWindowUsage: context.checkpoint.contextWindow ? calculateContextWindowUsage(event.usage, context.checkpoint.contextWindow) : void 0
             }),
             step: ({ context, event }) => ({
               ...context.step,
@@ -2318,7 +1490,10 @@ var runtimeStateMachine = setup({
           target: "Stopped",
           actions: assign({
             checkpoint: ({ event }) => event.checkpoint,
-            step: ({ event }) => event.step
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
           })
         }
       }
@@ -2329,7 +1504,10 @@ var runtimeStateMachine = setup({
           target: "Stopped",
           actions: assign({
             checkpoint: ({ event }) => event.checkpoint,
-            step: ({ event }) => event.step
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
           })
         }
       }
@@ -2340,7 +1518,10 @@ var runtimeStateMachine = setup({
           target: "Stopped",
           actions: assign({
             checkpoint: ({ event }) => event.checkpoint,
-            step: ({ event }) => event.step
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
           })
         }
       }
@@ -2389,75 +1570,272 @@ var StateMachineLogics = {
   CallingDelegate: callingDelegateLogic,
   FinishingStep: finishingStepLogic
 };
+async function defaultRetrieveCheckpoint(runId, checkpointId) {
+  const runDir = getRunDir(runId);
+  const checkpointFiles = await readdir(runDir, { withFileTypes: true }).then(
+    (files) => files.filter((file) => file.isFile() && file.name.startsWith("checkpoint-"))
+  );
+  const checkpointFile = checkpointFiles.find((file) => file.name.endsWith(`-${checkpointId}.json`));
+  if (!checkpointFile) {
+    throw new Error(`checkpoint not found: ${runId} ${checkpointId}`);
+  }
+  const checkpointPath = `${runDir}/${checkpointFile.name}`;
+  const checkpoint = await readFile(checkpointPath, "utf8");
+  return checkpointSchema.parse(JSON.parse(checkpoint));
+}
+async function defaultStoreCheckpoint(checkpoint, timestamp) {
+  const { id, runId, stepNumber } = checkpoint;
+  const runDir = getRunDir(runId);
+  const checkpointPath = `${runDir}/checkpoint-${timestamp}-${stepNumber}-${id}.json`;
+  await mkdir(runDir, { recursive: true });
+  await writeFile(checkpointPath, JSON.stringify(checkpoint, null, 2));
+}
+async function defaultStoreEvent(event) {
+  const { timestamp, runId, stepNumber, type } = event;
+  const runDir = getRunDir(runId);
+  const eventPath = `${runDir}/event-${timestamp}-${stepNumber}-${type}.json`;
+  await mkdir(runDir, { recursive: true });
+  await writeFile(eventPath, JSON.stringify(event, null, 2));
+}
 
-// src/schemas/perstack-toml.ts
-import { z as z4 } from "zod";
-var PerstackConfigSchema = z4.object({
-  model: z4.string().optional(),
-  temperature: z4.number().optional(),
-  maxSteps: z4.number().optional(),
-  maxRetries: z4.number().optional(),
-  timeout: z4.number().optional(),
-  experts: z4.record(
-    z4.string(),
-    z4.object({
-      version: z4.string().optional(),
-      minRuntimeVersion: z4.string().optional(),
-      description: z4.string().optional(),
-      instruction: z4.string(),
-      skills: z4.record(
-        z4.string(),
-        z4.discriminatedUnion("type", [
-          z4.object({
-            type: z4.literal("mcpStdioSkill"),
-            description: z4.string().optional(),
-            rule: z4.string().optional(),
-            pick: z4.array(z4.string()).optional(),
-            omit: z4.array(z4.string()).optional(),
-            command: z4.string(),
-            packageName: z4.string().optional(),
-            args: z4.array(z4.string()).optional(),
-            requiredEnv: z4.array(z4.string()).optional()
-          }),
-          z4.object({
-            type: z4.literal("mcpSseSkill"),
-            description: z4.string().optional(),
-            rule: z4.string().optional(),
-            pick: z4.array(z4.string()).optional(),
-            omit: z4.array(z4.string()).optional(),
-            endpoint: z4.string()
-          }),
-          z4.object({
-            type: z4.literal("interactiveSkill"),
-            description: z4.string().optional(),
-            rule: z4.string().optional(),
-            tools: z4.record(
-              z4.string(),
-              z4.object({
-                description: z4.string().optional(),
-                inputJsonSchema: z4.string()
-              })
-            )
-          })
-        ])
-      ).optional(),
-      delegates: z4.array(z4.string()).optional()
+// package.json
+var package_default = {
+  version: "0.0.25"};
+
+// src/events/default-event-listener.ts
+var log = console.info;
+var debug = console.debug;
+var header = (e) => {
+  const t = (/* @__PURE__ */ new Date()).toISOString();
+  const stepNumber = e.stepNumber;
+  const key = e.expertKey;
+  return `${t} ${stepNumber} ${key}`;
+};
+async function defaultEventListener(e) {
+  await defaultStoreEvent(e);
+  switch (e.type) {
+    case "startRun": {
+      log(`${header(e)} Perstack@${package_default.version} started`);
+      break;
+    }
+    case "startGeneration": {
+      log(`${header(e)} Generating tool call`);
+      break;
+    }
+    case "retry": {
+      log(`${header(e)} Retrying tool call generation`);
+      debug(e.reason);
+      break;
+    }
+    case "callTool": {
+      log(`${header(e)} Calling tool`);
+      if (e.toolCall.skillName === "@perstack/base") {
+        switch (e.toolCall.toolName) {
+          case "think": {
+            const thought = e.toolCall.args.thought;
+            log(`${header(e)} Thought Updated:`);
+            debug(thought);
+            break;
+          }
+          case "readPdfFile": {
+            const path2 = e.toolCall.args.path;
+            log(`${header(e)} Reading PDF: ${path2}`);
+            break;
+          }
+          case "readImageFile": {
+            const path2 = e.toolCall.args.path;
+            log(`${header(e)} Reading Image: ${path2}`);
+            break;
+          }
+          default: {
+            log(`${header(e)} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
+            debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
+            break;
+          }
+        }
+      } else {
+        log(`${header(e)} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
+        debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
+      }
+      break;
+    }
+    case "callInteractiveTool": {
+      log(`${header(e)} Calling interactive tool`);
+      log(`${header(e)} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
+      debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
+      break;
+    }
+    case "callDelegate": {
+      log(`${header(e)} Calling delegate`);
+      log(`${header(e)} Tool: ${e.toolCall.toolName}`);
+      debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
+      break;
+    }
+    case "resolveToolResult": {
+      log(`${header(e)} Resolved Tool Result`);
+      if (e.toolResult.skillName === "@perstack/base") {
+        switch (e.toolResult.toolName) {
+          case "todo": {
+            const text = e.toolResult.result.find((r) => r.type === "textPart")?.text;
+            const { todos } = JSON.parse(text ?? "{}");
+            log(`${header(e)} Todo:`);
+            for (const todo of todos) {
+              debug(`${todo.completed ? "[x]" : "[ ]"} ${todo.id}: ${todo.title}`);
+            }
+            break;
+          }
+          default: {
+            log(`${header(e)} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`);
+            debug(`${header(e)} Result: ${JSON.stringify(e.toolResult.result, null, 2)}`);
+            break;
+          }
+        }
+      } else {
+        log(`${header(e)} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`);
+        debug(`${header(e)} Result: ${JSON.stringify(e.toolResult.result, null, 2)}`);
+      }
+      break;
+    }
+    case "resolveThought": {
+      log(`${header(e)} Resolved Thought:`, e.toolResult);
+      break;
+    }
+    case "resolvePdfFile": {
+      log(`${header(e)} Resolved PDF:`, e.toolResult);
+      break;
+    }
+    case "resolveImageFile": {
+      log(`${header(e)} Resolved Image:`, e.toolResult);
+      break;
+    }
+    case "attemptCompletion": {
+      log(`${header(e)} Attempting completion`);
+      break;
+    }
+    case "completeRun": {
+      logUsage(e);
+      log(`${header(e)} Completing run`);
+      debug(`${header(e)} Result:`, e.text);
+      break;
+    }
+    case "stopRunByInteractiveTool": {
+      logUsage(e);
+      log(`${header(e)} Stopping run by interactive tool`);
+      break;
+    }
+    case "stopRunByDelegate": {
+      logUsage(e);
+      log(`${header(e)} Stopping run by delegate`);
+      break;
+    }
+    case "stopRunByExceededMaxSteps": {
+      logUsage(e);
+      log(`${header(e)} Stopping run by exceeded max steps`);
+      break;
+    }
+    case "continueToNextStep": {
+      logUsage(e);
+      log(`${header(e)} Continuing to next step`);
+      if (e.checkpoint.contextWindowUsage) {
+        log(`${header(e)} Context window usage: ${e.checkpoint.contextWindowUsage.toFixed(2)}%`);
+      }
+      break;
+    }
+  }
+}
+function logUsage(e) {
+  const usageByStep = [
+    `In: ${e.step.usage.inputTokens.toLocaleString()}`,
+    `Reasoning: ${e.step.usage.reasoningTokens.toLocaleString()}`,
+    `Out: ${e.step.usage.outputTokens.toLocaleString()}`,
+    `Total: ${e.step.usage.totalTokens.toLocaleString()}`,
+    `Cache-read: ${e.step.usage.cachedInputTokens.toLocaleString()}`
+  ].join(", ");
+  const usageByRun = [
+    `In: ${e.checkpoint.usage.inputTokens.toLocaleString()}`,
+    `Reasoning: ${e.checkpoint.usage.reasoningTokens.toLocaleString()}`,
+    `Out: ${e.checkpoint.usage.outputTokens.toLocaleString()}`,
+    `Total: ${e.checkpoint.usage.totalTokens.toLocaleString()}`,
+    `Cache-read: ${e.checkpoint.usage.cachedInputTokens.toLocaleString()}`
+  ].join(", ");
+  log(`${header(e)} Tokens usage by step: ${usageByStep}`);
+  log(`${header(e)} Tokens usage by run: ${usageByRun}`);
+}
+var RunEventEmitter = class {
+  listeners = [];
+  subscribe(listener) {
+    this.listeners.push(listener);
+  }
+  async emit(event) {
+    for (const listener of this.listeners) {
+      await listener({
+        ...event,
+        id: createId(),
+        timestamp: Date.now()
+      });
+    }
+  }
+};
+async function resolveExpertToRun(expertKey, experts, clientOptions) {
+  console.log(experts);
+  if (experts[expertKey]) {
+    return experts[expertKey];
+  }
+  const client = new ApiV1Client({
+    baseUrl: clientOptions.perstackApiBaseUrl,
+    apiKey: clientOptions.perstackApiKey
+  });
+  const { expert } = await client.registry.experts.get({ expertKey });
+  experts[expertKey] = toRuntimeExpert(expert);
+  return experts[expertKey];
+}
+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
+            }
+          ];
+      }
     })
-  ).optional()
-});
+  );
+  return {
+    ...expert,
+    skills
+  };
+}
 
 // src/runtime.ts
 async function run(runInput, options) {
-  const runParams = RunParamsSchema.parse(runInput);
+  const runParams = runParamsSchema.parse(runInput);
   const eventListener = options?.eventListener ?? defaultEventListener;
   const retrieveCheckpoint = options?.retrieveCheckpoint ?? defaultRetrieveCheckpoint;
   const storeCheckpoint = options?.storeCheckpoint ?? defaultStoreCheckpoint;
   const eventEmitter = new RunEventEmitter();
   eventEmitter.subscribe(eventListener);
   let { setting, checkpoint } = runParams;
-  if (checkpoint) {
-    checkpoint.status = "proceeding";
-  }
+  const contextWindow = getContextWindow(setting.providerConfig.name, setting.model);
   if (setting.workspace) {
     if (!path.isAbsolute(setting.workspace)) {
       throw new Error(`Workspace path must be absolute: ${setting.workspace}`);
@@ -2468,7 +1846,7 @@ async function run(runInput, options) {
   while (true) {
     const { expertToRun, experts } = await setupExperts(setting);
     printRunSetting(expertToRun.name, experts, setting);
-    const skillManagers = await getSkillManagers(expertToRun, experts);
+    const skillManagers = await getSkillManagers(expertToRun, experts, setting);
     const runActor = createActor(runtimeStateMachine, {
       input: {
         setting: {
@@ -2477,10 +1855,10 @@ async function run(runInput, options) {
         },
         initialCheckpoint: checkpoint ? {
           ...checkpoint,
-          id: createId8(),
+          id: createId(),
           stepNumber: checkpoint.stepNumber + 1
         } : {
-          id: createId8(),
+          id: createId(),
           runId: setting.runId,
           expert: {
             key: setting.expertKey,
@@ -2490,7 +1868,9 @@ async function run(runInput, options) {
           stepNumber: 1,
           status: "init",
           messages: [],
-          usage: createEmptyUsage()
+          usage: createEmptyUsage(),
+          contextWindow,
+          contextWindowUsage: contextWindow ? 0 : void 0
         },
         eventListener,
         skillManagers
@@ -2619,9 +1999,13 @@ async function run(runInput, options) {
 async function setupExperts(setting) {
   const { expertKey } = setting;
   const experts = { ...setting.experts };
-  const expertToRun = await resolveExpertToRun(expertKey, experts);
+  const clientOptions = {
+    perstackApiBaseUrl: setting.perstackApiBaseUrl,
+    perstackApiKey: setting.perstackApiKey
+  };
+  const expertToRun = await resolveExpertToRun(expertKey, experts, clientOptions);
   for (const delegateName of expertToRun.delegates) {
-    const delegate = await resolveExpertToRun(delegateName, experts);
+    const delegate = await resolveExpertToRun(delegateName, experts, clientOptions);
     if (!delegate) {
       throw new Error(`Delegate ${delegateName} not found`);
     }
@@ -2650,12 +2034,12 @@ async function storeRunSetting(setting) {
   const runDir = getRunDir(setting.runId);
   if (existsSync(runDir)) {
     const runSettingPath = path.resolve(runDir, "run-setting.json");
-    const runSetting = JSON.parse(await readFile4(runSettingPath, "utf-8"));
+    const runSetting = JSON.parse(await readFile(runSettingPath, "utf-8"));
     runSetting.updatedAt = Date.now();
-    await writeFile2(runSettingPath, JSON.stringify(runSetting, null, 2), "utf-8");
+    await writeFile(runSettingPath, JSON.stringify(runSetting, null, 2), "utf-8");
   } else {
-    await mkdir2(runDir, { recursive: true });
-    await writeFile2(
+    await mkdir(runDir, { recursive: true });
+    await writeFile(
       path.resolve(runDir, "run-setting.json"),
       JSON.stringify(setting, null, 2),
       "utf-8"
@@ -2665,119 +2049,7 @@ async function storeRunSetting(setting) {
 function getRunDir(runId) {
   return `${process.cwd()}/perstack/runs/${runId}`;
 }
-async function parseConfig(config) {
-  const toml = TOML.parse(config ?? "");
-  return PerstackConfigSchema.parse(toml);
-}
 
-// src/schemas/command-run.ts
-import { z as z5 } from "zod";
-var RunInputSchema = z5.object({
-  expertKey: z5.string(),
-  query: z5.string(),
-  options: z5.object({
-    config: z5.string().optional(),
-    model: z5.string().optional(),
-    temperature: z5.string().optional().transform((value) => {
-      if (value === void 0) {
-        return void 0;
-      }
-      const parsedValue = Number.parseFloat(value);
-      if (Number.isNaN(parsedValue)) {
-        return void 0;
-      }
-      return parsedValue;
-    }),
-    maxSteps: z5.string().optional().transform((value) => {
-      if (value === void 0) {
-        return void 0;
-      }
-      const parsedValue = Number.parseInt(value);
-      if (Number.isNaN(parsedValue)) {
-        return void 0;
-      }
-      return parsedValue;
-    }),
-    maxRetries: z5.string().optional().transform((value) => {
-      if (value === void 0) {
-        return void 0;
-      }
-      const parsedValue = Number.parseInt(value);
-      if (Number.isNaN(parsedValue)) {
-        return void 0;
-      }
-      return parsedValue;
-    }),
-    timeout: z5.string().optional().transform((value) => {
-      if (value === void 0) {
-        return void 0;
-      }
-      const parsedValue = Number.parseInt(value);
-      if (Number.isNaN(parsedValue)) {
-        return void 0;
-      }
-      return parsedValue;
-    }),
-    runId: z5.string().optional()
-  })
-});
-export {
-  CheckpointSchema,
-  CheckpointStatusSchema,
-  ExpertMessageSchema,
-  ExpertSchema,
-  FileBinaryPartSchema,
-  FileInlinePartSchema,
-  FileUrlPartSchema,
-  ImageBinaryPartSchema,
-  ImageInlinePartSchema,
-  ImageUrlPartSchema,
-  InstructionMessageSchema,
-  InteractiveSkillSchema,
-  InteractiveToolSchema,
-  McpSseSkillSchema,
-  McpStdioSkillSchema,
-  MessageSchema,
-  PerstackConfigSchema,
-  RegistryV1ExpertsGetResponseSchema,
-  RunInputSchema,
-  RunParamsSchema,
-  StateMachineLogics,
-  TextPartSchema,
-  ToolCallPartSchema,
-  ToolMessageSchema,
-  ToolResultPartSchema,
-  UsageSchema,
-  UserMessageSchema,
-  attemptCompletion,
-  callDelegate,
-  callInteractiveTool,
-  callTool,
-  completeRun,
-  continueToNextStep,
-  createEvent,
-  defaultEventListener,
-  expertKeyRegex,
-  expertNameRegex,
-  finishToolCall,
-  getRunDir,
-  maxNameLength,
-  parseConfig,
-  parseExpertKey,
-  resolveImageFile,
-  resolvePdfFile,
-  resolveThought,
-  resolveToolResult,
-  retry,
-  run,
-  runtimeStateMachine,
-  skillNameRegex,
-  startGeneration,
-  startRun,
-  stopRunByDelegate,
-  stopRunByExceededMaxSteps,
-  stopRunByInteractiveTool,
-  tagNameRegex,
-  versionRegex
-};
+export { StateMachineLogics, calculateContextWindowUsage, defaultEventListener, getContextWindow, getModel, getRunDir, run, runtimeStateMachine };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map