@perstack/runtime 0.0.20 → 0.0.22

package/dist/index.js

@@ -2,7 +2,7 @@
 import { existsSync } from "fs";
 import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
 import path from "path";
-import { createId as createId7 } from "@paralleldrive/cuid2";
+import { createId as createId8 } from "@paralleldrive/cuid2";
 import TOML from "smol-toml";
 import { createActor } from "xstate";
 
@@ -33,30 +33,29 @@ var AnthropicModels = [
   // "claude-3-haiku-20240307", - No pdf support
 ];
 var GoogleModels = [
-  "gemini-2.5-pro-preview-05-06",
-  "gemini-2.5-pro-exp-03-25",
-  "gemini-2.5-flash-preview-04-17",
-  "gemini-2.0-pro-exp-02-05",
-  "gemini-2.0-flash-thinking-exp-01-21",
-  "gemini-2.0-flash",
-  "gemini-2.0-flash-001",
-  "gemini-2.0-flash-live-001",
-  "gemini-2.0-flash-lite",
-  "gemini-2.0-flash-exp",
-  "gemini-1.5-pro",
-  "gemini-1.5-pro-latest",
-  "gemini-1.5-pro-001",
-  "gemini-1.5-pro-002",
   "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-exp-1206", - Unclear model spec
-  // "gemma-3-27b-it", - Unclear model spec
-  // "learnlm-1.5-pro-experimental", - Unclear model spec
+  "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",
@@ -301,7 +300,10 @@ var ExpertSchema = z2.object({
       type: "mcpStdioSkill",
       description: "Base skill",
       command: "npx",
-      args: ["-y", "@perstack/base"]
+      args: ["-y", "@perstack/base"],
+      pick: [],
+      omit: [],
+      requiredEnv: []
     }
   }).transform((skills) => {
     return Object.fromEntries(
@@ -393,7 +395,8 @@ var RunParamsSchema = z2.object({
     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(10),
+    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())
@@ -463,7 +466,7 @@ async function defaultStoreEvent(event) {
 // package.json
 var package_default = {
   name: "@perstack/runtime",
-  version: "0.0.20",
+  version: "0.0.22",
   description: "PerStack Runtime",
   author: "Wintermute Technologies, Inc.",
   license: "Apache-2.0",
@@ -487,23 +490,23 @@ var package_default = {
     prepublishOnly: "npm run clean && npm run build"
   },
   dependencies: {
-    "@ai-sdk/anthropic": "^1.2.12",
-    "@ai-sdk/google": "^1.2.19",
-    "@ai-sdk/openai": "^1.3.22",
-    "@modelcontextprotocol/sdk": "^1.12.3",
+    "@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: "^4.3.16",
-    "smol-toml": "^1.3.4",
+    ai: "^5.0.4",
+    "smol-toml": "^1.4.1",
     "ts-dedent": "^2.2.0",
-    xstate: "^5.19.4",
-    zod: "^3.25.67"
+    xstate: "^5.20.1",
+    zod: "^4.0.14"
   },
   devDependencies: {
     "@tsconfig/node22": "^22.0.2",
-    "@types/node": "^24.0.3",
+    "@types/node": "^24.2.0",
     tsup: "^8.5.0",
-    typescript: "^5.8.3",
-    vitest: "^3.2.3"
+    typescript: "^5.9.2",
+    vitest: "^3.2.4"
   },
   engines: {
     node: ">=22.0.0"
@@ -523,7 +526,7 @@ async function defaultEventListener(e) {
   await defaultStoreEvent(e);
   switch (e.type) {
     case "startRun": {
-      log(`${header(e)} \u{1F99C} Perstack@${package_default.version} started`);
+      log(`${header(e)} Perstack@${package_default.version} started`);
       const { inputMessages } = e;
       for (const message of inputMessages) {
         if (message.type === "userMessage") {
@@ -535,122 +538,122 @@ async function defaultEventListener(e) {
       break;
     }
     case "startGeneration": {
-      log(`${header(e)} \u{1F99C} Generating tool call`);
+      log(`${header(e)} Generating tool call`);
       break;
     }
     case "retry": {
       logUsage(e);
-      log(`${header(e)} \u{1F99C} Retrying tool call generation`);
+      log(`${header(e)} Retrying tool call generation`);
       break;
     }
     case "callTool": {
       logUsage(e);
-      log(`${header(e)} \u{1F99C} Calling tool`);
+      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)} \u{1F4AD} Thought Updated:`);
+            log(`${header(e)} Thought Updated:`);
             debug(thought);
             break;
           }
           case "readPdfFile": {
             const path2 = e.toolCall.args.path;
-            log(`${header(e)} \u{1F4C4} Reading PDF: ${path2}`);
+            log(`${header(e)} Reading PDF: ${path2}`);
             break;
           }
           case "readImageFile": {
             const path2 = e.toolCall.args.path;
-            log(`${header(e)} \u{1F5BC}\uFE0F Reading Image: ${path2}`);
+            log(`${header(e)} Reading Image: ${path2}`);
             break;
           }
           default: {
-            log(`${header(e)} \u{1F527} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
-            log(`${header(e)} \u{1F527} Args: ${e.toolCall.args}`);
+            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)} \u{1F527} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
-        log(`${header(e)} \u{1F527} Args: ${e.toolCall.args}`);
+        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)} \u{1F99C} Calling interactive tool`);
-      log(`${header(e)} \u{1F527} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
-      log(`${header(e)} \u{1F527} Args: ${e.toolCall.args}`);
+      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)} \u{1F99C} Calling delegate`);
-      log(`${header(e)} \u{1F527} Tool: ${e.toolCall.toolName}`);
-      log(`${header(e)} \u{1F527} Args: ${e.toolCall.args}`);
+      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)} \u{1F527} Resolved Tool Result`);
+      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)} \u{1F4C4} Todo:`);
+            log(`${header(e)} Todo:`);
             for (const todo of todos) {
               debug(`${todo.completed ? "[x]" : "[ ]"} ${todo.id}: ${todo.title}`);
             }
             break;
           }
           default: {
-            log(`${header(e)} \u{1F527} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`);
-            log(`${header(e)} \u{1F527} Result: ${e.toolResult.result}`);
+            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)} \u{1F527} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`);
-        log(`${header(e)} \u{1F527} Result: ${e.toolResult.result}`);
+        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)} \u{1F4AD} Resolved Thought:`, e.toolResult);
+      log(`${header(e)} Resolved Thought:`, e.toolResult);
       break;
     }
     case "resolvePdfFile": {
-      log(`${header(e)} \u{1F4C4} Resolved PDF:`, e.toolResult);
+      log(`${header(e)} Resolved PDF:`, e.toolResult);
       break;
     }
     case "resolveImageFile": {
-      log(`${header(e)} \u{1F5BC}\uFE0F Resolved Image:`, e.toolResult);
+      log(`${header(e)} Resolved Image:`, e.toolResult);
       break;
     }
     case "attemptCompletion": {
-      log(`${header(e)} \u2705 Attempting completion`);
+      log(`${header(e)} Attempting completion`);
       break;
     }
     case "completeRun": {
       logUsage(e);
-      log(`${header(e)} \u{1F99C} Completing run`);
-      log(`${header(e)} \u{1F99C} Result:`, e.text);
+      log(`${header(e)} Completing run`);
+      debug(`${header(e)} Result:`, e.text);
       break;
     }
     case "stopRunByInteractiveTool": {
-      log(`${header(e)} \u{1F99C} Stopping run by interactive tool`);
+      log(`${header(e)} Stopping run by interactive tool`);
       break;
     }
     case "stopRunByDelegate": {
-      log(`${header(e)} \u{1F99C} Stopping run by delegate`);
+      log(`${header(e)} Stopping run by delegate`);
       break;
     }
     case "stopRunByExceededMaxSteps": {
-      log(`${header(e)} \u{1F99C} Stopping run by exceeded max steps`);
+      log(`${header(e)} Stopping run by exceeded max steps`);
       break;
     }
     case "continueToNextStep": {
-      log(`${header(e)} \u{1F99C} Continuing to next step`);
+      log(`${header(e)} Continuing to next step`);
       break;
     }
   }
@@ -660,19 +663,19 @@ function logUserMessage(message) {
   const contents = message.contents;
   for (const content of contents) {
     if (content.type === "textPart") {
-      log(`${t} \u{1F4AC} User: ${content.text}`);
+      log(`${t} User: ${content.text}`);
     } else if (content.type === "imageUrlPart") {
-      log(`${t} \u{1F5BC}\uFE0F User: ${content.url}`);
+      log(`${t} User: ${content.url}`);
     } else if (content.type === "imageInlinePart") {
-      log(`${t} \u{1F5BC}\uFE0F User: Inline image`);
+      log(`${t} User: Inline image`);
     } else if (content.type === "imageBinaryPart") {
-      log(`${t} \u{1F5BC}\uFE0F User: Binary image`);
+      log(`${t} User: Binary image`);
     } else if (content.type === "fileUrlPart") {
-      log(`${t} \u{1F4C4} User: ${content.url}`);
+      log(`${t} User: ${content.url}`);
     } else if (content.type === "fileInlinePart") {
-      log(`${t} \u{1F4C4} User: Inline file`);
+      log(`${t} User: Inline file`);
     } else if (content.type === "fileBinaryPart") {
-      log(`${t} \u{1F4C4} User: Binary file`);
+      log(`${t} User: Binary file`);
     }
   }
 }
@@ -684,9 +687,9 @@ function logToolMessage(message) {
       const { contents: contents2 } = content;
       for (const content2 of contents2) {
         if (content2.type === "textPart") {
-          log(`${t} \u{1F4AC} Tool Result: ${content2.text}`);
+          log(`${t} Tool Result: ${content2.text}`);
         } else if (content2.type === "imageInlinePart") {
-          log(`${t} \u{1F5BC}\uFE0F Tool Result: Inline image`);
+          log(`${t} Tool Result: Inline image`);
         }
       }
     }
@@ -700,7 +703,7 @@ function logUsage(e) {
     `Cache-read: ${e.usage.cacheReadInputTokens.toLocaleString()}`,
     `Cache-write: ${e.usage.cacheCreationInputTokens.toLocaleString()}`
   ].join(", ");
-  log(`${header(e)} \u{1F4CA} Tokens usage: ${usageByGeneration}`);
+  log(`${header(e)} Tokens usage: ${usageByGeneration}`);
   const usageByRun = [
     `In: ${e.usage.promptTokens.toLocaleString()}`,
     `Out: ${e.usage.completionTokens.toLocaleString()}`,
@@ -708,7 +711,7 @@ function logUsage(e) {
     `Cache-read: ${e.usage.cacheReadInputTokens.toLocaleString()}`,
     `Cache-write: ${e.usage.cacheCreationInputTokens.toLocaleString()}`
   ].join(", ");
-  log(`${header(e)} \u{1F4CA} Total usage: ${usageByRun}`);
+  log(`${header(e)} Total usage: ${usageByRun}`);
 }
 
 // src/events/event-emitter.ts
@@ -749,8 +752,8 @@ var RegistryV1ExpertSchema = z3.object({
   tags: z3.array(z3.string()),
   status: z3.string(),
   owner: z3.object({ name: z3.string() }),
-  createdAt: z3.string().datetime(),
-  updatedAt: z3.string().datetime()
+  createdAt: z3.iso.datetime(),
+  updatedAt: z3.iso.datetime()
 });
 var RegistryV1ExpertsGetResponseSchema = z3.object({
   data: z3.object({
@@ -818,7 +821,7 @@ 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 } from "ai";
+import { jsonSchema, tool } from "ai";
 import { ZodError } from "zod";
 var SkillManager = class {
   _toolDefinitions = [];
@@ -895,11 +898,11 @@ var SkillManager = class {
       }
     }
     const { tools } = await this._mcpClient.listTools();
-    this._toolDefinitions = tools.map((tool) => ({
+    this._toolDefinitions = tools.map((tool2) => ({
       skillName: params.skill.name,
-      name: tool.name,
-      description: tool.description,
-      inputSchema: tool.inputSchema,
+      name: tool2.name,
+      description: tool2.description,
+      inputSchema: tool2.inputSchema,
       interactive: false
     }));
     this._initialized = true;
@@ -921,11 +924,11 @@ var SkillManager = class {
     return { command, args: newArgs };
   }
   async _initInteractiveSkill(params) {
-    this._toolDefinitions = Object.values(params.interactiveSkill.tools).map((tool) => ({
+    this._toolDefinitions = Object.values(params.interactiveSkill.tools).map((tool2) => ({
       skillName: params.interactiveSkill.name,
-      name: tool.name,
-      description: tool.description,
-      inputSchema: JSON.parse(tool.inputJsonSchema),
+      name: tool2.name,
+      description: tool2.description,
+      inputSchema: JSON.parse(tool2.inputJsonSchema),
       interactive: true
     }));
     this._initialized = true;
@@ -958,7 +961,7 @@ var SkillManager = class {
     if (this._params.type === "mcp") {
       const omit = this._params.skill.omit ?? [];
       const pick = this._params.skill.pick ?? [];
-      return this._toolDefinitions.filter((tool) => omit.length > 0 ? !omit.includes(tool.name) : true).filter((tool) => pick.length > 0 ? pick.includes(tool.name) : true);
+      return this._toolDefinitions.filter((tool2) => omit.length > 0 ? !omit.includes(tool2.name) : true).filter((tool2) => pick.length > 0 ? pick.includes(tool2.name) : true);
     }
     return this._toolDefinitions;
   }
@@ -1133,10 +1136,10 @@ async function getToolSet(skillManagers) {
   for (const skillManager of Object.values(skillManagers)) {
     const toolDefinitions = await skillManager.getToolDefinitions();
     for (const toolDefinition of toolDefinitions) {
-      tools[toolDefinition.name] = {
+      tools[toolDefinition.name] = tool({
         description: toolDefinition.description,
-        parameters: jsonSchema(toolDefinition.inputSchema)
-      };
+        inputSchema: jsonSchema(toolDefinition.inputSchema)
+      });
     }
   }
   return tools;
@@ -1401,42 +1404,42 @@ function imageUrlPartToCoreImagePart(part) {
   return {
     type: "image",
     image: part.url,
-    mimeType: part.mimeType
+    mediaType: part.mimeType
   };
 }
 function imageInlinePartToCoreImagePart(part) {
   return {
     type: "image",
     image: part.encodedData,
-    mimeType: part.mimeType
+    mediaType: part.mimeType
   };
 }
 function imageBinaryPartToCoreImagePart(part) {
   return {
     type: "image",
     image: part.data,
-    mimeType: part.mimeType
+    mediaType: part.mimeType
   };
 }
 function fileUrlPartToCoreFilePart(part) {
   return {
     type: "file",
     data: part.url,
-    mimeType: part.mimeType
+    mediaType: part.mimeType
   };
 }
 function fileInlinePartToCoreFilePart(part) {
   return {
     type: "file",
     data: part.encodedData,
-    mimeType: part.mimeType
+    mediaType: part.mimeType
   };
 }
 function fileBinaryPartToCoreFilePart(part) {
   return {
     type: "file",
     data: part.data,
-    mimeType: part.mimeType
+    mediaType: part.mimeType
   };
 }
 function toolCallPartToCoreToolCallPart(part) {
@@ -1444,31 +1447,29 @@ function toolCallPartToCoreToolCallPart(part) {
     type: "tool-call",
     toolCallId: part.toolCallId,
     toolName: part.toolName,
-    args: part.args
+    input: part.args
   };
 }
 function toolResultPartToCoreToolResultPart(part) {
+  const content = part.contents[0];
+  const output = content.type === "textPart" ? {
+    type: "text",
+    value: content.text
+  } : {
+    type: "content",
+    value: [
+      {
+        type: "media",
+        data: content.encodedData,
+        mediaType: content.mimeType
+      }
+    ]
+  };
   return {
     type: "tool-result",
     toolCallId: part.toolCallId,
     toolName: part.toolName,
-    result: part.contents,
-    experimental_content: part.contents.map((part2) => {
-      switch (part2.type) {
-        case "textPart":
-          return {
-            type: "text",
-            text: part2.text
-          };
-        case "imageInlinePart":
-          return {
-            type: "image",
-            data: part2.encodedData,
-            mimeType: part2.mimeType
-          };
-      }
-    }),
-    isError: part.isError
+    output
   };
 }
 
@@ -1491,9 +1492,9 @@ function usageFromGenerateTextResult(result) {
     cacheReadInputTokens = anthropicMetadata.cacheReadInputTokens || 0;
   }
   return {
-    promptTokens: result.usage.promptTokens,
-    completionTokens: result.usage.completionTokens,
-    totalTokens: result.usage.totalTokens,
+    promptTokens: result.usage.inputTokens || 0,
+    completionTokens: result.usage.outputTokens || 0,
+    totalTokens: result.usage.totalTokens || 0,
     cacheCreationInputTokens,
     cacheReadInputTokens
   };
@@ -1531,12 +1532,32 @@ async function generatingRunResultLogic({
   ]);
   const model = getModel(setting.model);
   const { messages } = checkpoint;
-  const generationResult = await generateText({
-    model,
-    messages: [...messages, toolMessage].map(messageToCoreMessage),
-    temperature: setting.temperature,
-    maxRetries: setting.maxRetries
-  });
+  let generationResult;
+  try {
+    generationResult = await generateText({
+      model,
+      messages: [...messages, toolMessage].map(messageToCoreMessage),
+      temperature: setting.temperature,
+      maxRetries: setting.maxRetries,
+      abortSignal: AbortSignal.timeout(setting.timeout)
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      return retry(setting, checkpoint, {
+        newMessages: [
+          toolMessage,
+          createUserMessage([
+            {
+              type: "textPart",
+              text: JSON.stringify({ error: error.name, message: error.message })
+            }
+          ])
+        ],
+        usage: checkpoint.usage
+      });
+    }
+    throw error;
+  }
   const usage = usageFromGenerateTextResult(generationResult);
   const { text } = generationResult;
   const newMessages = [toolMessage, createExpertMessage(text ? [{ type: "textPart", text }] : [])];
@@ -1559,6 +1580,7 @@ async function generatingRunResultLogic({
 }
 
 // src/states/generating-tool-call.ts
+import { createId as createId6 } from "@paralleldrive/cuid2";
 import { generateText as generateText2 } from "ai";
 async function generatingToolCallLogic({
   setting,
@@ -1567,66 +1589,58 @@ async function generatingToolCallLogic({
 }) {
   const { messages } = checkpoint;
   const model = getModel(setting.model);
-  const result = await generateText2({
-    model,
-    messages: messages.map(messageToCoreMessage),
-    temperature: setting.temperature,
-    maxRetries: setting.maxRetries,
-    tools: await getToolSet(skillManagers),
-    toolChoice: "required"
-  });
+  let result;
+  try {
+    result = await generateText2({
+      model,
+      messages: messages.map(messageToCoreMessage),
+      temperature: setting.temperature,
+      maxRetries: setting.maxRetries,
+      tools: await getToolSet(skillManagers),
+      toolChoice: "required",
+      abortSignal: AbortSignal.timeout(setting.timeout)
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      return retry(setting, checkpoint, {
+        newMessages: [
+          createUserMessage([
+            {
+              type: "textPart",
+              text: JSON.stringify({ error: error.name, message: error.message })
+            }
+          ])
+        ],
+        usage: checkpoint.usage
+      });
+    }
+    throw error;
+  }
   const usage = usageFromGenerateTextResult(result);
   const { text, toolCalls, finishReason } = result;
   const toolCall = toolCalls[0];
   if (!toolCall) {
     return retry(setting, checkpoint, {
       newMessages: [
-        createExpertMessage(text ? [{ type: "textPart", text }] : []),
         createUserMessage([
           {
             type: "textPart",
-            text: "You must generate a tool call. Try again."
+            text: JSON.stringify({
+              error: "No tool call generated",
+              message: "You must generate a tool call. Try again."
+            })
           }
         ])
       ],
       usage
     });
   }
-  if (finishReason !== "tool-calls") {
-    switch (finishReason) {
-      case "length": {
-        return retry(setting, checkpoint, {
-          newMessages: [
-            createExpertMessage([
-              {
-                type: "toolCallPart",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                args: toolCall.args
-              }
-            ]),
-            createToolMessage([
-              {
-                type: "toolResultPart",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                contents: [{ type: "textPart", text: "Error: Generation length exceeded" }]
-              }
-            ])
-          ],
-          usage
-        });
-      }
-      default:
-        throw new Error(`Unexpected finish reason: ${finishReason}`);
-    }
-  }
   const contents = [
     {
       type: "toolCallPart",
       toolCallId: toolCall.toolCallId,
       toolName: toolCall.toolName,
-      args: toolCall.args
+      args: toolCall.input
     }
   ];
   if (text) {
@@ -1642,22 +1656,55 @@ async function generatingToolCallLogic({
       id: toolCall.toolCallId,
       skillName: skillManager.name,
       toolName: toolCall.toolName,
-      args: toolCall.args
+      args: toolCall.input
     },
     usage
   };
-  switch (skillManager.type) {
-    case "mcp":
-      return callTool(setting, checkpoint, eventPayload);
-    case "interactive":
-      return callInteractiveTool(setting, checkpoint, eventPayload);
-    case "delegate":
-      return callDelegate(setting, checkpoint, eventPayload);
+  if (finishReason === "tool-calls") {
+    switch (skillManager.type) {
+      case "mcp":
+        return callTool(setting, checkpoint, eventPayload);
+      case "interactive":
+        return callInteractiveTool(setting, checkpoint, eventPayload);
+      case "delegate":
+        return callDelegate(setting, checkpoint, eventPayload);
+    }
   }
+  if (finishReason === "length") {
+    return retry(setting, checkpoint, {
+      newMessages: [
+        createExpertMessage([
+          {
+            type: "toolCallPart",
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            args: toolCall.input
+          }
+        ]),
+        createToolMessage([
+          {
+            type: "toolResultPart",
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            contents: [{ type: "textPart", text: "Error: Generation length exceeded" }]
+          }
+        ])
+      ],
+      toolCall: eventPayload.toolCall,
+      toolResult: {
+        id: toolCall.toolCallId,
+        skillName: skillManager.name,
+        toolName: toolCall.toolName,
+        result: [{ type: "textPart", id: createId6(), text: "Error: Generation length exceeded" }]
+      },
+      usage
+    });
+  }
+  throw new Error(`Unexpected finish reason: ${finishReason}`);
 }
 
 // src/messages/instruction-message.ts
-import { createId as createId6 } from "@paralleldrive/cuid2";
+import { createId as createId7 } from "@paralleldrive/cuid2";
 import { dedent as dedent2 } from "ts-dedent";
 var metaInstruction = dedent2`
   IMPORTANT:
@@ -1731,12 +1778,12 @@ function createInstructionMessage(expert, experts) {
     type: "instructionMessage",
     contents: [
       {
-        id: createId6(),
+        id: createId7(),
         type: "textPart",
         text: instruction
       }
     ],
-    id: createId6(),
+    id: createId7(),
     cache: true
   };
 }
@@ -1797,6 +1844,19 @@ async function initLogic({
         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 }
+          ])
+        ]
+      });
+    }
     case "stoppedByInteractiveTool": {
       if (!setting.input.interactiveToolCallResult) {
         throw new Error("Interactive tool call result is undefined");
@@ -2045,6 +2105,8 @@ var runtimeStateMachine = setup({
             step: ({ context, event }) => ({
               ...context.step,
               newMessages: event.newMessages,
+              toolCall: event.toolCall,
+              toolResult: event.toolResult,
               usage: sumUsage(context.step.usage, event.usage)
             })
           })
@@ -2218,6 +2280,23 @@ var runtimeStateMachine = setup({
     },
     GeneratingRunResult: {
       on: {
+        retry: {
+          target: "FinishingStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, ...event.newMessages],
+              usage: sumUsage(context.checkpoint.usage, event.usage)
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: event.newMessages,
+              toolCall: event.toolCall,
+              toolResult: event.toolResult,
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        },
         completeRun: {
           target: "Stopped",
           actions: assign({
@@ -2301,6 +2380,7 @@ var PerstackConfigSchema = z4.object({
   temperature: z4.number().optional(),
   maxSteps: z4.number().optional(),
   maxRetries: z4.number().optional(),
+  timeout: z4.number().optional(),
   experts: z4.record(
     z4.string(),
     z4.object({
@@ -2358,6 +2438,9 @@ async function run(runInput, options) {
   const eventEmitter = new RunEventEmitter();
   eventEmitter.subscribe(eventListener);
   let { setting, checkpoint } = runParams;
+  if (checkpoint) {
+    checkpoint.status = "proceeding";
+  }
   if (setting.workspace) {
     if (!path.isAbsolute(setting.workspace)) {
       throw new Error(`Workspace path must be absolute: ${setting.workspace}`);
@@ -2376,19 +2459,11 @@ async function run(runInput, options) {
           experts
         },
         initialCheckpoint: checkpoint ? {
-          id: createId7(),
-          runId: setting.runId,
-          expert: {
-            key: setting.expertKey,
-            name: expertToRun.name,
-            version: expertToRun.version
-          },
-          stepNumber: checkpoint.stepNumber + 1,
-          status: "proceeding",
-          messages: checkpoint.messages,
-          usage: checkpoint.usage
+          ...checkpoint,
+          id: createId8(),
+          stepNumber: checkpoint.stepNumber + 1
         } : {
-          id: createId7(),
+          id: createId8(),
           runId: setting.runId,
           expert: {
             key: setting.expertKey,
@@ -2468,8 +2543,7 @@ async function run(runInput, options) {
           };
           checkpoint = {
             ...await retrieveCheckpoint(setting.runId, checkpointId),
-            id: createId7(),
-            stepNumber: runResultCheckpoint.stepNumber + 1,
+            stepNumber: runResultCheckpoint.stepNumber,
             usage: runResultCheckpoint.usage
           };
           break;
@@ -2492,10 +2566,8 @@ async function run(runInput, options) {
           }
         };
         checkpoint = {
-          id: createId7(),
-          runId: setting.runId,
+          ...runResultCheckpoint,
           status: "init",
-          stepNumber: runResultCheckpoint.stepNumber + 1,
           messages: [],
           expert: {
             key: expert.key,
@@ -2540,13 +2612,14 @@ async function setupExperts(setting) {
   return { expertToRun, experts };
 }
 function printRunSetting(expertName, experts, setting) {
-  console.log("\u{1F99C} Starting Perstack \u{1F99C}");
+  console.log("Starting Perstack");
   console.log(`Expert To Run: ${expertName}`);
   console.log(`Experts: ${Object.keys(experts).join(", ")}`);
   console.log(`Model: ${setting.model}`);
   console.log(`Temperature: ${setting.temperature}`);
   console.log(`Max Steps: ${setting.maxSteps}`);
   console.log(`Max Retries: ${setting.maxRetries}`);
+  console.log(`Timeout: ${setting.timeout}`);
   if (setting.input.text) {
     console.log(`Query: ${setting.input.text}`);
   }
@@ -2618,6 +2691,16 @@ var RunInputSchema = z5.object({
       }
       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()
   })
 });