@perstack/runtime 0.0.19 → 0.0.21

package/dist/index.js

@@ -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.19",
+  version: "0.0.21",
   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, errorMessage: error.message })
+            }
+          ])
+        ],
+        usage: checkpoint.usage
+      });
+    }
+    throw error;
+  }
   const usage = usageFromGenerateTextResult(generationResult);
   const { text } = generationResult;
   const newMessages = [toolMessage, createExpertMessage(text ? [{ type: "textPart", text }] : [])];
@@ -1567,14 +1588,33 @@ 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, errorMessage: error.message })
+            }
+          ])
+        ],
+        usage: checkpoint.usage
+      });
+    }
+    throw error;
+  }
   const usage = usageFromGenerateTextResult(result);
   const { text, toolCalls, finishReason } = result;
   const toolCall = toolCalls[0];
@@ -1602,7 +1642,7 @@ async function generatingToolCallLogic({
                 type: "toolCallPart",
                 toolCallId: toolCall.toolCallId,
                 toolName: toolCall.toolName,
-                args: toolCall.args
+                args: toolCall.input
               }
             ]),
             createToolMessage([
@@ -1626,7 +1666,7 @@ async function generatingToolCallLogic({
       type: "toolCallPart",
       toolCallId: toolCall.toolCallId,
       toolName: toolCall.toolName,
-      args: toolCall.args
+      args: toolCall.input
     }
   ];
   if (text) {
@@ -1642,7 +1682,7 @@ async function generatingToolCallLogic({
       id: toolCall.toolCallId,
       skillName: skillManager.name,
       toolName: toolCall.toolName,
-      args: toolCall.args
+      args: toolCall.input
     },
     usage
   };
@@ -1776,33 +1816,61 @@ async function initLogic({
   const { expertKey, experts } = setting;
   const expert = experts[expertKey];
   switch (checkpoint.status) {
-    case "init":
+    case "init": {
+      if (!setting.input.text) {
+        throw new Error("Input message is undefined");
+      }
       return startRun(setting, checkpoint, {
         initialCheckpoint: checkpoint,
-        inputMessages: [createInstructionMessage(expert, experts), getInputMessage(setting.input)]
+        inputMessages: [
+          createInstructionMessage(expert, experts),
+          createUserMessage([{ type: "textPart", text: setting.input.text }])
+        ]
       });
-    default:
+    }
+    case "proceeding": {
+      if (!setting.input.text) {
+        throw new Error("Input message is undefined");
+      }
       return startRun(setting, checkpoint, {
         initialCheckpoint: checkpoint,
-        inputMessages: [getInputMessage(setting.input)]
+        inputMessages: [createUserMessage([{ type: "textPart", text: setting.input.text }])]
       });
-  }
-}
-function getInputMessage(input) {
-  if (input.text) {
-    return createUserMessage([{ type: "textPart", text: input.text }]);
-  }
-  if (input.interactiveToolCallResult) {
-    return createToolMessage([
-      {
-        type: "toolResultPart",
-        toolCallId: input.interactiveToolCallResult.toolCallId,
-        toolName: input.interactiveToolCallResult.toolName,
-        contents: [{ type: "textPart", text: input.interactiveToolCallResult.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");
       }
-    ]);
+      return startRun(setting, checkpoint, {
+        initialCheckpoint: checkpoint,
+        inputMessages: [
+          createToolMessage([
+            {
+              type: "toolResultPart",
+              toolCallId: setting.input.interactiveToolCallResult.toolCallId,
+              toolName: setting.input.interactiveToolCallResult.toolName,
+              contents: [{ type: "textPart", text: setting.input.interactiveToolCallResult.text }]
+            }
+          ])
+        ]
+      });
+    }
+    default:
+      throw new Error(`Unexpected checkpoint status: ${checkpoint.status}`);
   }
-  throw new Error("Input message is undefined");
 }
 
 // src/states/preparing-for-step.ts
@@ -1969,6 +2037,13 @@ var runtimeStateMachine = setup({
   context: ({ input }) => ({
     setting: input.setting,
     checkpoint: input.initialCheckpoint,
+    step: {
+      stepNumber: input.initialCheckpoint.stepNumber,
+      inputMessages: [],
+      newMessages: [],
+      usage: createEmptyUsage(),
+      startedAt: Date.now()
+    },
     eventListener: input.eventListener,
     skillManagers: input.skillManagers
   }),
@@ -1982,6 +2057,13 @@ var runtimeStateMachine = setup({
               ...event.initialCheckpoint,
               messages: [...event.initialCheckpoint.messages, ...event.inputMessages],
               status: "proceeding"
+            }),
+            step: ({ event }) => ({
+              stepNumber: event.initialCheckpoint.stepNumber,
+              inputMessages: event.inputMessages,
+              newMessages: [],
+              usage: createEmptyUsage(),
+              startedAt: event.timestamp
             })
           })
         }
@@ -1994,6 +2076,7 @@ var runtimeStateMachine = setup({
           actions: assign({
             step: ({ context, event }) => ({
               stepNumber: context.checkpoint.stepNumber,
+              inputMessages: context.step.inputMessages,
               newMessages: [],
               usage: createEmptyUsage(),
               startedAt: event.timestamp
@@ -2188,6 +2271,21 @@ 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,
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        },
         completeRun: {
           target: "Stopped",
           actions: assign({
@@ -2225,7 +2323,10 @@ var runtimeStateMachine = setup({
           target: "PreparingForStep",
           actions: assign({
             checkpoint: ({ event }) => event.nextCheckpoint,
-            step: ({ event }) => event.step
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
           }),
           reenter: true
         },
@@ -2233,7 +2334,10 @@ var runtimeStateMachine = setup({
           target: "Stopped",
           actions: assign({
             checkpoint: ({ event }) => event.checkpoint,
-            step: ({ event }) => event.step
+            step: ({ event }) => ({
+              ...event.step,
+              inputMessages: void 0
+            })
           })
         }
       }
@@ -2265,6 +2369,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({
@@ -2322,6 +2427,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}`);
@@ -2340,17 +2448,9 @@ async function run(runInput, options) {
           experts
         },
         initialCheckpoint: checkpoint ? {
+          ...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
+          stepNumber: checkpoint.stepNumber + 1
         } : {
           id: createId7(),
           runId: setting.runId,
@@ -2384,6 +2484,18 @@ async function run(runInput, options) {
               await storeCheckpoint(event.checkpoint, event.timestamp);
             }
             await eventEmitter.emit(event);
+            if (options?.shouldContinueRun) {
+              const shouldContinue = await options.shouldContinueRun(
+                runState.context.setting,
+                runState.context.checkpoint,
+                runState.context.step
+              );
+              if (!shouldContinue) {
+                runActor.stop();
+                resolve(runState.context.checkpoint);
+                return;
+              }
+            }
             runActor.send(event);
           }
         } catch (error) {
@@ -2420,8 +2532,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;
@@ -2444,10 +2555,8 @@ async function run(runInput, options) {
           }
         };
         checkpoint = {
-          id: createId7(),
-          runId: setting.runId,
+          ...runResultCheckpoint,
           status: "init",
-          stepNumber: runResultCheckpoint.stepNumber + 1,
           messages: [],
           expert: {
             key: expert.key,
@@ -2492,13 +2601,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}`);
   }
@@ -2570,6 +2680,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()
   })
 });