@perstack/runtime 0.0.8 → 0.0.10

package/dist/index.js

@@ -1,7 +1,1582 @@
-import {existsSync}from'fs';import {readFile,writeFile,mkdir,readdir}from'fs/promises';import pe from'path';import {createId}from'@paralleldrive/cuid2';import ko from'smol-toml';import {setup,assign,createActor}from'xstate';import {z as z$1,ZodError}from'zod';import {anthropic}from'@ai-sdk/anthropic';import {google}from'@ai-sdk/google';import {openai}from'@ai-sdk/openai';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 {generateText,jsonSchema}from'ai';import {dedent}from'ts-dedent';var ft="claude-4-sonnet-20250514",ge=["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"],ue=["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"],de=["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","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"],ht=Object.fromEntries([...ge,...ue,...de].map(e=>[e,{default:e===ft,model:e}]));function te(){let e=Object.values(ht).find(t=>t.default);if(!e)throw new Error("No default model found");return e.model}function z(e){let t=e??te();if(ge.includes(t))return anthropic(t);if(ue.includes(t))return google(t);if(de.includes(t))return openai(t);throw new Error(`Unsupported model: ${t}`)}var I=z$1.object({id:z$1.string()}),A=I.extend({type:z$1.literal("textPart"),text:z$1.string()}),yt=I.extend({type:z$1.literal("imageUrlPart"),url:z$1.string().url(),mimeType:z$1.string()}),fe=I.extend({type:z$1.literal("imageInlinePart"),encodedData:z$1.string(),mimeType:z$1.string()}),xt=I.extend({type:z$1.literal("imageBinaryPart"),data:z$1.string(),mimeType:z$1.string()}),kt=I.extend({type:z$1.literal("fileUrlPart"),url:z$1.string().url(),mimeType:z$1.string()}),Tt=I.extend({type:z$1.literal("fileInlinePart"),encodedData:z$1.string(),mimeType:z$1.string()}),Rt=I.extend({type:z$1.literal("fileBinaryPart"),data:z$1.string(),mimeType:z$1.string()}),St=I.extend({type:z$1.literal("toolCallPart"),toolCallId:z$1.string(),toolName:z$1.string(),args:z$1.unknown()}),Pt=I.extend({type:z$1.literal("toolResultPart"),toolCallId:z$1.string(),toolName:z$1.string(),contents:z$1.array(z$1.union([A,fe])),isError:z$1.boolean().optional()}),L=z$1.object({id:z$1.string()}),Ct=L.extend({type:z$1.literal("instructionMessage"),contents:z$1.array(A),cache:z$1.boolean().optional()}),vt=L.extend({type:z$1.literal("userMessage"),contents:z$1.array(z$1.union([A,yt,fe,xt,kt,Tt,Rt])),cache:z$1.boolean().optional()}),wt=L.extend({type:z$1.literal("expertMessage"),contents:z$1.array(z$1.union([A,St])),cache:z$1.boolean().optional()}),It=L.extend({type:z$1.literal("toolMessage"),contents:z$1.array(Pt),cache:z$1.boolean().optional()}),he=z$1.union([Ct,vt,wt,It]);var Mt=/^(@[a-z0-9][a-z0-9_-]*\/)?[a-z0-9][a-z0-9_-]*$/,bt=/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?$/,Et=/^[a-z0-9][a-z0-9_-]*$/,D=/^((?:@[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_\.-]*))?$/,Uo=/^[a-z0-9][a-z0-9._-]*$/,$t=214;function jo(e){let t=e.match(D);if(!t)throw new Error(`Invalid expert key format: ${e}`);let[o,r,a,i]=t;return {key:o,name:r,version:a,tag:i}}var G=z$1.object({type:z$1.literal("mcpStdioSkill"),name:z$1.string(),description:z$1.string().optional(),rule:z$1.string().optional(),pick:z$1.array(z$1.string()).optional().default([]),omit:z$1.array(z$1.string()).optional().default([]),command:z$1.string(),packageName:z$1.string().optional(),args:z$1.array(z$1.string()).optional().default([]),requiredEnv:z$1.array(z$1.string()).optional().default([])}),K=z$1.object({type:z$1.literal("mcpSseSkill"),name:z$1.string(),description:z$1.string().optional(),rule:z$1.string().optional(),pick:z$1.array(z$1.string()).optional().default([]),omit:z$1.array(z$1.string()).optional().default([]),endpoint:z$1.string()}),ye=z$1.object({name:z$1.string(),description:z$1.string().optional(),inputJsonSchema:z$1.string()}),q=z$1.object({type:z$1.literal("interactiveSkill"),name:z$1.string(),description:z$1.string().optional(),rule:z$1.string().optional(),tools:z$1.record(z$1.string(),ye.omit({name:true})).transform(e=>Object.fromEntries(Object.entries(e).map(([t,o])=>[t,ye.parse({...o,name:t})])))}),J=z$1.object({key:z$1.string().regex(D).min(1),name:z$1.string().regex(Mt).min(1).max($t),version:z$1.string().regex(bt),description:z$1.string().min(1).max(1024*2).optional(),instruction:z$1.string().min(1).max(1024*20),skills:z$1.record(z$1.string(),z$1.discriminatedUnion("type",[G.omit({name:true}),K.omit({name:true}),q.omit({name:true})])).optional().default({"@perstack/base":{type:"mcpStdioSkill",description:"Base skill",command:"npx",args:["-y","@perstack/base"]}}).transform(e=>Object.fromEntries(Object.entries(e).map(([t,o])=>[t,z$1.discriminatedUnion("type",[G,K,q]).parse({...o,name:t})]))),delegates:z$1.array(z$1.string().regex(D).min(1)).optional().default([]),tags:z$1.array(z$1.string().regex(Et).min(1)).optional().default([])}),Nt=z$1.object({promptTokens:z$1.number(),completionTokens:z$1.number(),totalTokens:z$1.number(),cacheCreationInputTokens:z$1.number(),cacheReadInputTokens:z$1.number()}),Ft=z$1.enum(["init","proceeding","completed","stoppedByInteractiveTool","stoppedByDelegate","stoppedByExceededMaxSteps","stoppedByError"]),oe=z$1.object({id:z$1.string(),runId:z$1.string(),status:Ft,stepNumber:z$1.number(),messages:z$1.array(he),expert:z$1.object({key:z$1.string(),name:z$1.string(),version:z$1.string()}),delegateTo:z$1.object({expert:z$1.object({key:z$1.string(),name:z$1.string(),version:z$1.string()}),toolCallId:z$1.string(),toolName:z$1.string(),query:z$1.string()}).optional(),delegatedBy:z$1.object({expert:z$1.object({key:z$1.string(),name:z$1.string(),version:z$1.string()}),toolCallId:z$1.string(),toolName:z$1.string(),checkpointId:z$1.string()}).optional(),usage:Nt}),ke=z$1.object({setting:z$1.object({runId:z$1.string().optional().transform(e=>e??createId()),expertKey:z$1.string().regex(D).min(1),input:z$1.object({text:z$1.string().optional(),interactiveToolCallResult:z$1.object({toolCallId:z$1.string(),toolName:z$1.string(),text:z$1.string()}).optional()}),experts:z$1.record(z$1.string().regex(D).min(1),J.omit({key:true})).optional().default({}).transform(e=>Object.fromEntries(Object.entries(e).map(([t,o])=>[t,J.parse({...o,key:t})]))),model:z$1.string().optional().default(te()),temperature:z$1.number().min(0).max(1).optional().default(.3),maxSteps:z$1.number().min(1).optional(),maxRetries:z$1.number().min(0).optional().default(10),workspace:z$1.string().optional(),startedAt:z$1.number().optional().default(Date.now()),updatedAt:z$1.number().optional().default(Date.now())}),checkpoint:oe.optional()});function k(e){return (t,o,r)=>({type:e,id:createId(),expertKey:o.expert.key,timestamp:Date.now(),runId:t.runId,stepNumber:o.stepNumber,...r})}var ne=k("startRun"),Te=k("startGeneration"),re=k("retry"),Re=k("callTool"),Se=k("callInteractiveTool"),Pe=k("callDelegate"),Ce=k("resolveToolResult"),ve=k("resolveThought"),we=k("resolvePdfFile"),Ie=k("resolveImageFile"),Me=k("attemptCompletion"),$=k("finishToolCall"),be=k("completeRun"),Ee=k("stopRunByInteractiveTool"),$e=k("stopRunByDelegate"),Ne=k("stopRunByExceededMaxSteps"),Fe=k("continueToNextStep");async function De(e,t){let o=O(e),a=(await readdir(o,{withFileTypes:true}).then(s=>s.filter(u=>u.isFile()&&u.name.startsWith("checkpoint-")))).find(s=>s.name.endsWith(`-${t}.json`));if(!a)throw new Error(`checkpoint not found: ${e} ${t}`);let i=`${o}/${a.name}`,c=await readFile(i,"utf8");return oe.parse(JSON.parse(c))}async function Oe(e,t){let{id:o,runId:r,stepNumber:a}=e,i=O(r),c=`${i}/checkpoint-${t}-${a}-${o}.json`;await mkdir(i,{recursive:true}),await writeFile(c,JSON.stringify(e,null,2));}async function Be(e){let{timestamp:t,runId:o,stepNumber:r,type:a}=e,i=O(o),c=`${i}/event-${t}-${r}-${a}.json`;await mkdir(i,{recursive:true}),await writeFile(c,JSON.stringify(e,null,2));}var _e={version:"0.0.8"};var m=console.info,ze=console.debug,g=e=>{let t=new Date().toISOString(),o=e.stepNumber,r=e.expertKey;return `${t} ${o} ${r}`};async function se(e){switch(await Be(e),e.type){case "startRun":{m(`${g(e)} \u{1F99C} Perstack@${_e.version} started`);let{inputMessages:t}=e;for(let o of t)o.type==="userMessage"?Ot(o):o.type==="toolMessage"&&Bt(o);break}case "startGeneration":{m(`${g(e)} \u{1F99C} Generating tool call`);break}case "retry":{B(e),m(`${g(e)} \u{1F99C} Retrying tool call generation`);break}case "callTool":{if(B(e),m(`${g(e)} \u{1F99C} Calling tool`),e.toolCall.skillName==="@perstack/base")switch(e.toolCall.toolName){case "think":{let t=e.toolCall.args.thought;m(`${g(e)} \u{1F4AD} Thought Updated:`),ze(t);break}case "readPdfFile":{let t=e.toolCall.args.path;m(`${g(e)} \u{1F4C4} Reading PDF: ${t}`);break}case "readImageFile":{let t=e.toolCall.args.path;m(`${g(e)} \u{1F5BC}\uFE0F Reading Image: ${t}`);break}default:{m(`${g(e)} \u{1F527} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`),m(`${g(e)} \u{1F527} Args: ${e.toolCall.args}`);break}}else m(`${g(e)} \u{1F527} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`),m(`${g(e)} \u{1F527} Args: ${e.toolCall.args}`);break}case "callInteractiveTool":{B(e),m(`${g(e)} \u{1F99C} Calling interactive tool`),m(`${g(e)} \u{1F527} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`),m(`${g(e)} \u{1F527} Args: ${e.toolCall.args}`);break}case "callDelegate":{B(e),m(`${g(e)} \u{1F99C} Calling delegate`),m(`${g(e)} \u{1F527} Tool: ${e.toolCall.toolName}`),m(`${g(e)} \u{1F527} Args: ${e.toolCall.args}`);break}case "resolveToolResult":{if(m(`${g(e)} \u{1F527} Resolved Tool Result`),e.toolResult.skillName==="@perstack/base")switch(e.toolResult.toolName){case "todo":{let t=e.toolResult.result.find(r=>r.type==="textPart")?.text,{todos:o}=JSON.parse(t??"{}");m(`${g(e)} \u{1F4C4} Todo:`);for(let r of o)ze(`${r.completed?"[x]":"[ ]"} ${r.id}: ${r.title}`);break}default:{m(`${g(e)} \u{1F527} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`),m(`${g(e)} \u{1F527} Result: ${e.toolResult.result}`);break}}else m(`${g(e)} \u{1F527} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`),m(`${g(e)} \u{1F527} Result: ${e.toolResult.result}`);break}case "resolveThought":{m(`${g(e)} \u{1F4AD} Resolved Thought:`,e.toolResult);break}case "resolvePdfFile":{m(`${g(e)} \u{1F4C4} Resolved PDF:`,e.toolResult);break}case "resolveImageFile":{m(`${g(e)} \u{1F5BC}\uFE0F Resolved Image:`,e.toolResult);break}case "attemptCompletion":{m(`${g(e)} \u2705 Attempting completion`);break}case "completeRun":{B(e),m(`${g(e)} \u{1F99C} Completing run`),m(`${g(e)} \u{1F99C} Result:`,e.text);break}case "stopRunByInteractiveTool":{m(`${g(e)} \u{1F99C} Stopping run by interactive tool`);break}case "stopRunByDelegate":{m(`${g(e)} \u{1F99C} Stopping run by delegate`);break}case "stopRunByExceededMaxSteps":{m(`${g(e)} \u{1F99C} Stopping run by exceeded max steps`);break}case "continueToNextStep":{m(`${g(e)} \u{1F99C} Continuing to next step`);break}}}function Ot(e){let t=new Date().toISOString(),o=e.contents;for(let r of o)r.type==="textPart"?m(`${t} \u{1F4AC} User: ${r.text}`):r.type==="imageUrlPart"?m(`${t} \u{1F5BC}\uFE0F User: ${r.url}`):r.type==="imageInlinePart"?m(`${t} \u{1F5BC}\uFE0F User: Inline image`):r.type==="imageBinaryPart"?m(`${t} \u{1F5BC}\uFE0F User: Binary image`):r.type==="fileUrlPart"?m(`${t} \u{1F4C4} User: ${r.url}`):r.type==="fileInlinePart"?m(`${t} \u{1F4C4} User: Inline file`):r.type==="fileBinaryPart"&&m(`${t} \u{1F4C4} User: Binary file`);}function Bt(e){let t=new Date().toISOString(),o=e.contents;for(let r of o)if(r.type==="toolResultPart"){let{contents:a}=r;for(let i of a)i.type==="textPart"?m(`${t} \u{1F4AC} Tool Result: ${i.text}`):i.type==="imageInlinePart"&&m(`${t} \u{1F5BC}\uFE0F Tool Result: Inline image`);}}function B(e){let t=[`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(", ");m(`${g(e)} \u{1F4CA} Tokens usage: ${t}`);let o=[`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(", ");m(`${g(e)} \u{1F4CA} Total usage: ${o}`);}var V=class{listeners=[];subscribe(t){this.listeners.push(t);}async emit(t){for(let o of this.listeners)await o({...t,id:createId(),timestamp:Date.now()});}};var zt=z$1.object({name:z$1.string(),version:z$1.string(),minRuntimeVersion:z$1.string(),description:z$1.string(),instruction:z$1.string(),skills:z$1.record(z$1.string(),z$1.discriminatedUnion("type",[G.omit({name:true}),K.omit({name:true}),q.omit({name:true})])),delegates:z$1.array(z$1.string()),tags:z$1.array(z$1.string()),status:z$1.string(),owner:z$1.object({name:z$1.string()}),createdAt:z$1.string().datetime(),updatedAt:z$1.string().datetime()}),Ae=z$1.object({data:z$1.object({expert:zt})});var Y=class{baseUrl;registry;apiKey;constructor(t){this.baseUrl=t?.baseUrl??process.env.PERSTACK_API_BASE_URL??"https://api.perstack.ai",this.apiKey=t?.apiKey??process.env.PERSTACK_API_KEY,this.registry=new ae(this);}},ae=class{client;endpoint;constructor(t){this.client=t,this.endpoint="/api/registry/v1/experts";}async get(t){let o=encodeURIComponent(t),r=new URL(`${this.endpoint}/${o}`,this.client.baseUrl),a={"Content-Type":"application/json",Authorization:`Bearer ${this.client.apiKey}`},i=await fetch(r.toString(),{headers:a});if(!i.ok)throw new Error(`Registry returned non-200 status code: ${i.status}, reason: ${i.statusText}`);let c=await i.json();return Ae.parse(c)}};async function ie(e,t){if(t[e])return t[e];let o=new Y,{data:r}=await o.registry.get(e),a=J.parse({...r.expert,key:e});return t[e]=a,a}var _=class{_toolDefinitions=[];_initialized=false;name;type;skill;interactiveSkill;expert;_mcpClient;_params;constructor(t){switch(this._params=t,this.type=t.type,t.type){case "mcp":this.name=t.skill.name,this.skill=t.skill;break;case "interactive":this.name=t.interactiveSkill.name,this.interactiveSkill=t.interactiveSkill;break;case "delegate":this.name=t.expert.name,this.expert=t.expert;break}}async init(){switch(this._params.type){case "mcp":{await this._initMcpSkill(this._params);break}case "interactive":{await this._initInteractiveSkill(this._params);break}case "delegate":{await this._initDelegate(this._params);break}}}async _initMcpSkill(t){switch(this._mcpClient=new Client({name:`${t.skill.name}-mcp-client`,version:"1.0.0"}),t.skill.type){case "mcpStdioSkill":{if(!t.skill.command)throw new Error(`Skill ${t.skill.name} has no command`);let{command:r,args:a}=this._getCommandArgs(t.skill),i=new StdioClientTransport({command:r,args:a,env:Object.fromEntries(Object.entries(process.env).filter(([c,s])=>s!==void 0&&s!=="").map(([c,s])=>[c,s]))});await this._mcpClient.connect(i);break}case "mcpSseSkill":{if(!t.skill.endpoint)throw new Error(`Skill ${t.skill.name} has no endpoint`);let r=new SSEClientTransport(new URL(t.skill.endpoint));await this._mcpClient.connect(r);break}}let{tools:o}=await this._mcpClient.listTools();this._toolDefinitions=o.map(r=>({skillName:t.skill.name,name:r.name,description:r.description,inputSchema:r.inputSchema,interactive:false})),this._initialized=true;}_getCommandArgs(t){let{name:o,command:r,packageName:a,args:i}=t;if(!a&&(!i||i.length===0))throw new Error(`Skill ${o} has no packageName or args. Please provide one of them.`);if(a&&i&&i.length>0)throw new Error(`Skill ${o} has both packageName and args. Please provide only one of them.`);let c=i?[...i]:[a];return r==="npx"&&!c.includes("-y")&&c.unshift("-y"),{command:r,args:c}}async _initInteractiveSkill(t){this._toolDefinitions=Object.values(t.interactiveSkill.tools).map(o=>({skillName:t.interactiveSkill.name,name:o.name,description:o.description,inputSchema:JSON.parse(o.inputJsonSchema),interactive:true})),this._initialized=true;}async _initDelegate(t){this._toolDefinitions=[{skillName:t.expert.name,name:t.expert.name.split("/").pop()??t.expert.name,description:t.expert.description,inputSchema:{type:"object",properties:{query:{type:"string"}},required:["query"]},interactive:false}],this._initialized=true;}async close(){this._mcpClient&&await this._mcpClient.close();}async getToolDefinitions(){if(!this._initialized)throw new Error(`${this.name} is not initialized`);if(this._params.type==="mcp"){let t=this._params.skill.omit??[],o=this._params.skill.pick??[];return this._toolDefinitions.filter(r=>t.length>0?!t.includes(r.name):true).filter(r=>o.length>0?o.includes(r.name):true)}return this._toolDefinitions}async callTool(t,o){switch(this._params.type){case "mcp":{if(!this._mcpClient)throw new Error(`${this.name} is not initialized`);try{let r=await this._mcpClient.callTool({name:t,arguments:o});return this._convertToolResult(r,t,o)}catch(r){return this._handleToolError(r,t)}}case "interactive":return [];case "delegate":return []}}_handleToolError(t,o){if(t instanceof McpError)return [{type:"textPart",text:`Error calling tool ${o}: ${t.message}`,id:createId()}];if(t instanceof ZodError)return [{type:"textPart",text:`Invalid tool call arguments: ${t}`,id:createId()}];throw t}_convertToolResult(t,o,r){return !t.content||t.content.length===0?[{type:"textPart",text:`Tool ${o} returned nothing with arguments: ${JSON.stringify(r)}`,id:createId()}]:t.content.filter(a=>a.type!=="audio"&&a.type!=="resource_link").map(a=>this._convertPart(a))}_convertPart(t){switch(t.type){case "text":return !t.text||t.text===""?{type:"textPart",text:"Error: No content",id:createId()}:{type:"textPart",text:t.text,id:createId()};case "image":if(!t.data||!t.mimeType)throw new Error("Image part must have both data and mimeType");return {type:"imageInlinePart",encodedData:t.data,mimeType:t.mimeType,id:createId()};case "resource":if(!t.resource)throw new Error("Resource part must have resource content");return this._convertResource(t.resource)}}_convertResource(t){if(!t.mimeType)throw new Error(`Resource ${JSON.stringify(t)} has no mimeType`);if(t.text&&typeof t.text=="string")return {type:"textPart",text:t.text,id:createId()};if(t.blob&&typeof t.blob=="string")return {type:"fileInlinePart",encodedData:t.blob,mimeType:t.mimeType,id:createId()};throw new Error(`Unsupported resource type: ${JSON.stringify(t)}`)}};async function Le(e,t){let o={},{skills:r}=e;r["@perstack/base"]||(r["@perstack/base"]={type:"mcpStdioSkill",name:"@perstack/base",description:"The base skill for Perstack",pick:[],omit:[],command:"npx",args:["-y","@perstack/base"],requiredEnv:[]});let a=await Promise.all(Object.values(r).filter(s=>s.type==="mcpStdioSkill"||s.type==="mcpSseSkill").map(async s=>{let u=new _({type:"mcp",skill:s});return await u.init(),u})),i=await Promise.all(Object.values(r).filter(s=>s.type==="interactiveSkill").map(async s=>{let u=new _({type:"interactive",interactiveSkill:s});return await u.init(),u})),c=await Promise.all(e.delegates.map(async s=>{let u=t[s],h=new _({type:"delegate",expert:u});return await h.init(),h}));for(let s of a)o[s.name]=s;for(let s of i)o[s.name]=s;for(let s of c)o[s.name]=s;return o}async function Ge(e){for(let t of Object.values(e))await t.close();}async function N(e,t){for(let o of Object.values(e)){let r=await o.getToolDefinitions();for(let a of r)if(a.name===t)return o}throw new Error(`Tool ${t} not found`)}async function Ke(e){let t={};for(let o of Object.values(e)){let r=await o.getToolDefinitions();for(let a of r)t[a.name]={description:a.description,parameters:jsonSchema(a.inputSchema)};}return t}async function qe({setting:e,checkpoint:t,step:o,skillManagers:r}){if(!o?.toolCall)throw new Error("No tool call found");let{id:a,toolName:i,args:c}=o.toolCall,s=await N(r,i);if(!s||!s.expert)throw new Error(`Delegation error: skill manager "${i}" not found`);if(!c||!c.query||typeof c.query!="string")throw new Error("Delegation error: query is undefined");return $e(e,t,{checkpoint:{...t,status:"stoppedByDelegate",delegateTo:{expert:{key:s.expert.key,name:s.expert.name,version:s.expert.version},toolCallId:a,toolName:i,query:c.query}},step:{...o,finishedAt:new Date().getTime()}})}async function Je({setting:e,checkpoint:t,step:o}){return Ee(e,t,{checkpoint:{...t,status:"stoppedByInteractiveTool"},step:{...o,finishedAt:new Date().getTime()}})}async function Ve({setting:e,checkpoint:t,step:o,skillManagers:r}){if(!o?.toolCall)throw new Error("No tool call found");let{id:a,skillName:i,toolName:c,args:s}=o.toolCall,u=await N(r,c);if(u.type!=="mcp")throw new Error(`Incorrect SkillType, required MCP, got ${u.type}`);let h=await u.callTool(c,s),d={id:a,skillName:i,toolName:c,result:h};if(i==="@perstack/base"){if(c==="think")return ve(e,t,{toolResult:d});if(c==="attemptCompletion")return Me(e,t,{toolResult:d});if(c==="readPdfFile")return we(e,t,{toolResult:d});if(c==="readImageFile")return Ie(e,t,{toolResult:d})}return Ce(e,t,{toolResult:d})}async function Ye({setting:e,checkpoint:t,step:o}){return e.maxSteps!==void 0&&t.stepNumber>e.maxSteps?Ne(e,t,{checkpoint:{...t,status:"stoppedByExceededMaxSteps"},step:{...o,finishedAt:new Date().getTime()}}):Fe(e,t,{checkpoint:{...t},step:{...o,finishedAt:new Date().getTime()},nextCheckpoint:{...t,id:createId(),stepNumber:t.stepNumber+1}})}function F(e){return {type:"userMessage",contents:e.map(t=>({...t,id:createId()})),id:createId()}}function U(e){return {type:"expertMessage",contents:e.map(t=>({...t,id:createId()})),id:createId()}}function C(e){return {type:"toolMessage",contents:e.map(t=>({...t,contents:t.contents.map(o=>({...o,id:createId()})),id:createId()})),id:createId()}}function W(e){switch(e.type){case "instructionMessage":return {role:"system",content:Wt(e.contents),providerOptions:e.cache?{anthropic:{cacheControl:{type:"ephemeral"}}}:void 0};case "userMessage":return {role:"user",content:Ht(e.contents),providerOptions:e.cache?{anthropic:{cacheControl:{type:"ephemeral"}}}:void 0};case "expertMessage":return {role:"assistant",content:Qt(e.contents),providerOptions:e.cache?{anthropic:{cacheControl:{type:"ephemeral"}}}:void 0};case "toolMessage":return {role:"tool",content:Zt(e.contents),providerOptions:e.cache?{anthropic:{cacheControl:{type:"ephemeral"}}}:void 0}}}function Wt(e){return e.reduce((t,o)=>dedent`
-      ${t}
-      ${o.text}
-    `.trim(),"")}function Ht(e){return e.map(t=>{switch(t.type){case "textPart":return We(t);case "imageUrlPart":return Xt(t);case "imageInlinePart":return eo(t);case "imageBinaryPart":return to(t);case "fileUrlPart":return oo(t);case "fileInlinePart":return no(t);case "fileBinaryPart":return ro(t)}})}function Qt(e){return e.map(t=>{switch(t.type){case "textPart":return We(t);case "toolCallPart":return so(t)}})}function Zt(e){return e.map(t=>{switch(t.type){case "toolResultPart":return ao(t)}})}function We(e){return {type:"text",text:e.text}}function Xt(e){return {type:"image",image:e.url,mimeType:e.mimeType}}function eo(e){return {type:"image",image:e.encodedData,mimeType:e.mimeType}}function to(e){return {type:"image",image:e.data,mimeType:e.mimeType}}function oo(e){return {type:"file",data:e.url,mimeType:e.mimeType}}function no(e){return {type:"file",data:e.encodedData,mimeType:e.mimeType}}function ro(e){return {type:"file",data:e.data,mimeType:e.mimeType}}function so(e){return {type:"tool-call",toolCallId:e.toolCallId,toolName:e.toolName,args:e.args}}function ao(e){return {type:"tool-result",toolCallId:e.toolCallId,toolName:e.toolName,result:e.contents,experimental_content:e.contents.map(t=>{switch(t.type){case "textPart":return {type:"text",text:t.text};case "imageInlinePart":return {type:"image",data:t.encodedData,mimeType:t.mimeType}}}),isError:e.isError}}function H(){return {promptTokens:0,completionTokens:0,totalTokens:0,cacheCreationInputTokens:0,cacheReadInputTokens:0}}function Q(e){let t=0,o=0;if(e.providerMetadata?.anthropic){let r=e.providerMetadata.anthropic;t=r.cacheCreationInputTokens||0,o=r.cacheReadInputTokens||0;}return {promptTokens:e.usage.promptTokens,completionTokens:e.usage.completionTokens,totalTokens:e.usage.totalTokens,cacheCreationInputTokens:t,cacheReadInputTokens:o}}function v(e,t){return {promptTokens:e.promptTokens+t.promptTokens,completionTokens:e.completionTokens+t.completionTokens,totalTokens:e.totalTokens+t.totalTokens,cacheCreationInputTokens:e.cacheCreationInputTokens+t.cacheCreationInputTokens,cacheReadInputTokens:e.cacheReadInputTokens+t.cacheReadInputTokens}}async function He({setting:e,checkpoint:t,step:o}){if(!o?.toolCall||!o?.toolResult)throw new Error("No tool call or tool result found");let{id:r,toolName:a}=o.toolCall,{result:i}=o.toolResult,c=C([{type:"toolResultPart",toolCallId:r,toolName:a,contents:i.filter(f=>f.type==="textPart"||f.type==="imageInlinePart")}]),s=z(e.model),{messages:u}=t,h=await generateText({model:s,messages:[...u,c].map(W),temperature:e.temperature,maxRetries:e.maxRetries}),d=Q(h),{text:P}=h,R=[c,U(P?[{type:"textPart",text:P}]:[])];return be(e,t,{checkpoint:{...t,messages:[...u,...R],usage:v(t.usage,d),status:"completed"},step:{...o,newMessages:[...o.newMessages,...R],finishedAt:new Date().getTime(),usage:v(o.usage,d)},text:P,usage:d})}async function Qe({setting:e,checkpoint:t,skillManagers:o}){let{messages:r}=t,a=z(e.model),i=await generateText({model:a,messages:r.map(W),temperature:e.temperature,maxRetries:e.maxRetries,tools:await Ke(o),toolChoice:"required"}),c=Q(i),{text:s,toolCalls:u,finishReason:h}=i,d=u[0];if(!d)return re(e,t,{newMessages:[U(s?[{type:"textPart",text:s}]:[]),F([{type:"textPart",text:"You must generate a tool call. Try again."}])],usage:c});if(h!=="tool-calls")switch(h){case "length":return re(e,t,{newMessages:[U([{type:"toolCallPart",toolCallId:d.toolCallId,toolName:d.toolName,args:d.args}]),C([{type:"toolResultPart",toolCallId:d.toolCallId,toolName:d.toolName,contents:[{type:"textPart",text:"Error: Generation length exceeded"}]}])],usage:c});default:throw new Error(`Unexpected finish reason: ${h}`)}let P=[{type:"toolCallPart",toolCallId:d.toolCallId,toolName:d.toolName,args:d.args}];s&&P.push({type:"textPart",text:s});let R=await N(o,d.toolName),f={newMessage:U(P),toolCall:{id:d.toolCallId,skillName:R.name,toolName:d.toolName,args:d.args},usage:c};switch(R.type){case "mcp":return Re(e,t,f);case "interactive":return Se(e,t,f);case "delegate":return Pe(e,t,f)}}var po=dedent`
+import { existsSync } from 'fs';
+import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
+import path from 'path';
+import { createId } from '@paralleldrive/cuid2';
+import TOML from 'smol-toml';
+import { setup, assign, createActor } from 'xstate';
+import { z, ZodError } from 'zod';
+import { anthropic } from '@ai-sdk/anthropic';
+import { google } from '@ai-sdk/google';
+import { openai } from '@ai-sdk/openai';
+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 { generateText, jsonSchema } from 'ai';
+import { dedent } from 'ts-dedent';
+
+// src/runtime.ts
+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-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
+];
+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}`);
+}
+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 = z.object({
+  type: z.literal("mcpStdioSkill"),
+  name: z.string(),
+  description: z.string().optional(),
+  rule: z.string().optional(),
+  pick: z.array(z.string()).optional().default([]),
+  omit: z.array(z.string()).optional().default([]),
+  command: z.string(),
+  packageName: z.string().optional(),
+  args: z.array(z.string()).optional().default([]),
+  requiredEnv: z.array(z.string()).optional().default([])
+});
+var McpSseSkillSchema = z.object({
+  type: z.literal("mcpSseSkill"),
+  name: z.string(),
+  description: z.string().optional(),
+  rule: z.string().optional(),
+  pick: z.array(z.string()).optional().default([]),
+  omit: z.array(z.string()).optional().default([]),
+  endpoint: z.string()
+});
+var InteractiveToolSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  inputJsonSchema: z.string()
+});
+var InteractiveSkillSchema = z.object({
+  type: z.literal("interactiveSkill"),
+  name: z.string(),
+  description: z.string().optional(),
+  rule: z.string().optional(),
+  tools: z.record(z.string(), InteractiveToolSchema.omit({ name: true })).transform((tools) => {
+    return Object.fromEntries(
+      Object.entries(tools).map(([key, toolWithoutName]) => [
+        key,
+        InteractiveToolSchema.parse({ ...toolWithoutName, name: key })
+      ])
+    );
+  })
+});
+var ExpertSchema = z.object({
+  key: z.string().regex(expertKeyRegex).min(1),
+  name: z.string().regex(expertNameRegex).min(1).max(maxNameLength),
+  version: z.string().regex(versionRegex),
+  description: z.string().min(1).max(1024 * 2).optional(),
+  instruction: z.string().min(1).max(1024 * 20),
+  skills: z.record(
+    z.string(),
+    z.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"]
+    }
+  }).transform((skills) => {
+    return Object.fromEntries(
+      Object.entries(skills).map(([key, skillWithoutName]) => [
+        key,
+        z.discriminatedUnion("type", [
+          McpStdioSkillSchema,
+          McpSseSkillSchema,
+          InteractiveSkillSchema
+        ]).parse({ ...skillWithoutName, name: key })
+      ])
+    );
+  }),
+  delegates: z.array(z.string().regex(expertKeyRegex).min(1)).optional().default([]),
+  tags: z.array(z.string().regex(tagNameRegex).min(1)).optional().default([])
+});
+var UsageSchema = z.object({
+  promptTokens: z.number(),
+  completionTokens: z.number(),
+  totalTokens: z.number(),
+  cacheCreationInputTokens: z.number(),
+  cacheReadInputTokens: z.number()
+});
+var CheckpointStatusSchema = z.enum([
+  "init",
+  "proceeding",
+  "completed",
+  "stoppedByInteractiveTool",
+  "stoppedByDelegate",
+  "stoppedByExceededMaxSteps",
+  "stoppedByError"
+]);
+var CheckpointSchema = z.object({
+  id: z.string(),
+  runId: z.string(),
+  status: CheckpointStatusSchema,
+  stepNumber: z.number(),
+  messages: z.array(MessageSchema),
+  expert: z.object({
+    key: z.string(),
+    name: z.string(),
+    version: z.string()
+  }),
+  delegateTo: z.object({
+    expert: z.object({
+      key: z.string(),
+      name: z.string(),
+      version: z.string()
+    }),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    query: z.string()
+  }).optional(),
+  delegatedBy: z.object({
+    expert: z.object({
+      key: z.string(),
+      name: z.string(),
+      version: z.string()
+    }),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    checkpointId: z.string()
+  }).optional(),
+  usage: UsageSchema
+});
+var RunParamsSchema = z.object({
+  setting: z.object({
+    runId: z.string().optional().transform((value) => value ?? createId()),
+    expertKey: z.string().regex(expertKeyRegex).min(1),
+    input: z.object({
+      text: z.string().optional(),
+      interactiveToolCallResult: z.object({
+        toolCallId: z.string(),
+        toolName: z.string(),
+        text: z.string()
+      }).optional()
+    }),
+    experts: z.record(z.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: z.string().optional().default(getDefaultModelName()),
+    temperature: z.number().min(0).max(1).optional().default(0.3),
+    maxSteps: z.number().min(1).optional(),
+    maxRetries: z.number().min(0).optional().default(10),
+    /** Optional workspace directory path. If provided, sets WORKSPACE_DIR environment variable for skill execution. */
+    workspace: z.string().optional(),
+    startedAt: z.number().optional().default(Date.now()),
+    updatedAt: z.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));
+}
+
+// package.json
+var package_default = {
+  version: "0.0.10"};
+
+// 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)} \u{1F99C} 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)} \u{1F99C} Generating tool call`);
+      break;
+    }
+    case "retry": {
+      logUsage(e);
+      log(`${header(e)} \u{1F99C} Retrying tool call generation`);
+      break;
+    }
+    case "callTool": {
+      logUsage(e);
+      log(`${header(e)} \u{1F99C} 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:`);
+            debug(thought);
+            break;
+          }
+          case "readPdfFile": {
+            const path2 = e.toolCall.args.path;
+            log(`${header(e)} \u{1F4C4} Reading PDF: ${path2}`);
+            break;
+          }
+          case "readImageFile": {
+            const path2 = e.toolCall.args.path;
+            log(`${header(e)} \u{1F5BC}\uFE0F 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}`);
+            break;
+          }
+        }
+      } else {
+        log(`${header(e)} \u{1F527} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
+        log(`${header(e)} \u{1F527} Args: ${e.toolCall.args}`);
+      }
+      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}`);
+      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}`);
+      break;
+    }
+    case "resolveToolResult": {
+      log(`${header(e)} \u{1F527} 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:`);
+            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}`);
+            break;
+          }
+        }
+      } else {
+        log(`${header(e)} \u{1F527} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`);
+        log(`${header(e)} \u{1F527} Result: ${e.toolResult.result}`);
+      }
+      break;
+    }
+    case "resolveThought": {
+      log(`${header(e)} \u{1F4AD} Resolved Thought:`, e.toolResult);
+      break;
+    }
+    case "resolvePdfFile": {
+      log(`${header(e)} \u{1F4C4} Resolved PDF:`, e.toolResult);
+      break;
+    }
+    case "resolveImageFile": {
+      log(`${header(e)} \u{1F5BC}\uFE0F Resolved Image:`, e.toolResult);
+      break;
+    }
+    case "attemptCompletion": {
+      log(`${header(e)} \u2705 Attempting completion`);
+      break;
+    }
+    case "completeRun": {
+      logUsage(e);
+      log(`${header(e)} \u{1F99C} Completing run`);
+      log(`${header(e)} \u{1F99C} Result:`, e.text);
+      break;
+    }
+    case "stopRunByInteractiveTool": {
+      log(`${header(e)} \u{1F99C} Stopping run by interactive tool`);
+      break;
+    }
+    case "stopRunByDelegate": {
+      log(`${header(e)} \u{1F99C} Stopping run by delegate`);
+      break;
+    }
+    case "stopRunByExceededMaxSteps": {
+      log(`${header(e)} \u{1F99C} Stopping run by exceeded max steps`);
+      break;
+    }
+    case "continueToNextStep": {
+      log(`${header(e)} \u{1F99C} Continuing to next step`);
+      break;
+    }
+  }
+}
+function logUserMessage(message) {
+  const t = (/* @__PURE__ */ new Date()).toISOString();
+  const contents = message.contents;
+  for (const content of contents) {
+    if (content.type === "textPart") {
+      log(`${t} \u{1F4AC} User: ${content.text}`);
+    } else if (content.type === "imageUrlPart") {
+      log(`${t} \u{1F5BC}\uFE0F User: ${content.url}`);
+    } else if (content.type === "imageInlinePart") {
+      log(`${t} \u{1F5BC}\uFE0F User: Inline image`);
+    } else if (content.type === "imageBinaryPart") {
+      log(`${t} \u{1F5BC}\uFE0F User: Binary image`);
+    } else if (content.type === "fileUrlPart") {
+      log(`${t} \u{1F4C4} User: ${content.url}`);
+    } else if (content.type === "fileInlinePart") {
+      log(`${t} \u{1F4C4} User: Inline file`);
+    } else if (content.type === "fileBinaryPart") {
+      log(`${t} \u{1F4C4} User: Binary file`);
+    }
+  }
+}
+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} \u{1F4AC} Tool Result: ${content2.text}`);
+        } else if (content2.type === "imageInlinePart") {
+          log(`${t} \u{1F5BC}\uFE0F Tool Result: Inline image`);
+        }
+      }
+    }
+  }
+}
+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)} \u{1F4CA} 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)} \u{1F4CA} Total usage: ${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()
+      });
+    }
+  }
+};
+var RegistryV1ExpertSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  minRuntimeVersion: z.string(),
+  description: z.string(),
+  instruction: z.string(),
+  skills: z.record(
+    z.string(),
+    z.discriminatedUnion("type", [
+      McpStdioSkillSchema.omit({ name: true }),
+      McpSseSkillSchema.omit({ name: true }),
+      InteractiveSkillSchema.omit({ name: true })
+    ])
+  ),
+  delegates: z.array(z.string()),
+  tags: z.array(z.string()),
+  status: z.string(),
+  owner: z.object({ name: z.string() }),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+var RegistryV1ExpertsGetResponseSchema = z.object({
+  data: z.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;
+}
+var SkillManager = class {
+  _toolDefinitions = [];
+  _initialized = false;
+  name;
+  type;
+  skill;
+  interactiveSkill;
+  expert;
+  _mcpClient;
+  _params;
+  constructor(params) {
+    this._params = params;
+    this.type = params.type;
+    switch (params.type) {
+      case "mcp":
+        this.name = params.skill.name;
+        this.skill = params.skill;
+        break;
+      case "interactive":
+        this.name = params.interactiveSkill.name;
+        this.interactiveSkill = params.interactiveSkill;
+        break;
+      case "delegate":
+        this.name = params.expert.name;
+        this.expert = params.expert;
+        break;
+    }
+  }
+  async init() {
+    switch (this._params.type) {
+      case "mcp": {
+        await this._initMcpSkill(this._params);
+        break;
+      }
+      case "interactive": {
+        await this._initInteractiveSkill(this._params);
+        break;
+      }
+      case "delegate": {
+        await this._initDelegate(this._params);
+        break;
+      }
+    }
+  }
+  async _initMcpSkill(params) {
+    this._mcpClient = new Client({
+      name: `${params.skill.name}-mcp-client`,
+      version: "1.0.0"
+    });
+    switch (params.skill.type) {
+      case "mcpStdioSkill": {
+        if (!params.skill.command) {
+          throw new Error(`Skill ${params.skill.name} has no command`);
+        }
+        const { command, args } = this._getCommandArgs(params.skill);
+        console.error(command, args);
+        const transport = new StdioClientTransport({
+          command,
+          args,
+          env: Object.fromEntries(
+            Object.entries(process.env).filter(([_, value]) => value !== void 0 && value !== "").map(([key, value]) => [key, value])
+          )
+        });
+        await this._mcpClient.connect(transport);
+        break;
+      }
+      case "mcpSseSkill": {
+        if (!params.skill.endpoint) {
+          throw new Error(`Skill ${params.skill.name} has no endpoint`);
+        }
+        const transport = new SSEClientTransport(new URL(params.skill.endpoint));
+        await this._mcpClient.connect(transport);
+        break;
+      }
+    }
+    const { tools } = await this._mcpClient.listTools();
+    this._toolDefinitions = tools.map((tool) => ({
+      skillName: params.skill.name,
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      interactive: false
+    }));
+    this._initialized = true;
+  }
+  _getCommandArgs(skill) {
+    const { name, command, packageName, args } = skill;
+    if (!packageName && (!args || args.length === 0)) {
+      throw new Error(`Skill ${name} has no packageName or args. Please provide one of them.`);
+    }
+    if (packageName && args && args.length > 0) {
+      throw new Error(
+        `Skill ${name} has both packageName and args. Please provide only one of them.`
+      );
+    }
+    let newArgs = args && args.length > 0 ? args : [packageName];
+    if (command === "npx" && !newArgs.includes("-y")) {
+      newArgs = ["-y", ...newArgs];
+    }
+    return { command, args: newArgs };
+  }
+  async _initInteractiveSkill(params) {
+    this._toolDefinitions = Object.values(params.interactiveSkill.tools).map((tool) => ({
+      skillName: params.interactiveSkill.name,
+      name: tool.name,
+      description: tool.description,
+      inputSchema: JSON.parse(tool.inputJsonSchema),
+      interactive: true
+    }));
+    this._initialized = true;
+  }
+  async _initDelegate(params) {
+    this._toolDefinitions = [
+      {
+        skillName: params.expert.name,
+        name: params.expert.name.split("/").pop() ?? params.expert.name,
+        description: params.expert.description,
+        inputSchema: {
+          type: "object",
+          properties: { query: { type: "string" } },
+          required: ["query"]
+        },
+        interactive: false
+      }
+    ];
+    this._initialized = true;
+  }
+  async close() {
+    if (this._mcpClient) {
+      await this._mcpClient.close();
+    }
+  }
+  async getToolDefinitions() {
+    if (!this._initialized) {
+      throw new Error(`${this.name} is not initialized`);
+    }
+    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;
+  }
+  async callTool(toolName, input) {
+    switch (this._params.type) {
+      case "mcp": {
+        if (!this._mcpClient) {
+          throw new Error(`${this.name} is not initialized`);
+        }
+        try {
+          const result = await this._mcpClient.callTool({
+            name: toolName,
+            arguments: input
+          });
+          return this._convertToolResult(result, toolName, input);
+        } catch (error) {
+          return this._handleToolError(error, toolName);
+        }
+      }
+      case "interactive": {
+        return [];
+      }
+      case "delegate": {
+        return [];
+      }
+    }
+  }
+  _handleToolError(error, toolName) {
+    if (error instanceof McpError) {
+      return [
+        {
+          type: "textPart",
+          text: `Error calling tool ${toolName}: ${error.message}`,
+          id: createId()
+        }
+      ];
+    }
+    if (error instanceof ZodError) {
+      return [{ type: "textPart", text: `Invalid tool call arguments: ${error}`, id: createId() }];
+    }
+    throw error;
+  }
+  _convertToolResult(result, toolName, input) {
+    if (!result.content || result.content.length === 0) {
+      return [
+        {
+          type: "textPart",
+          text: `Tool ${toolName} returned nothing with arguments: ${JSON.stringify(input)}`,
+          id: createId()
+        }
+      ];
+    }
+    return result.content.filter((part) => part.type !== "audio" && part.type !== "resource_link").map((part) => this._convertPart(part));
+  }
+  _convertPart(part) {
+    switch (part.type) {
+      case "text":
+        if (!part.text || part.text === "") {
+          return { type: "textPart", text: "Error: No content", id: createId() };
+        }
+        return { type: "textPart", text: part.text, id: createId() };
+      case "image":
+        if (!part.data || !part.mimeType) {
+          throw new Error("Image part must have both data and mimeType");
+        }
+        return {
+          type: "imageInlinePart",
+          encodedData: part.data,
+          mimeType: part.mimeType,
+          id: createId()
+        };
+      case "resource":
+        if (!part.resource) {
+          throw new Error("Resource part must have resource content");
+        }
+        return this._convertResource(part.resource);
+    }
+  }
+  _convertResource(resource) {
+    if (!resource.mimeType) {
+      throw new Error(`Resource ${JSON.stringify(resource)} has no mimeType`);
+    }
+    if (resource.text && typeof resource.text === "string") {
+      return { type: "textPart", text: resource.text, id: createId() };
+    }
+    if (resource.blob && typeof resource.blob === "string") {
+      return {
+        type: "fileInlinePart",
+        encodedData: resource.blob,
+        mimeType: resource.mimeType,
+        id: createId()
+      };
+    }
+    throw new Error(`Unsupported resource type: ${JSON.stringify(resource)}`);
+  }
+};
+async function getSkillManagers(expert, experts) {
+  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: []
+    };
+  }
+  const mcpSkillManagers = await Promise.all(
+    Object.values(skills).filter((skill) => skill.type === "mcpStdioSkill" || skill.type === "mcpSseSkill").map(async (skill) => {
+      const skillManager = new SkillManager({
+        type: "mcp",
+        skill
+      });
+      await skillManager.init();
+      return skillManager;
+    })
+  );
+  const interactiveSkillManagers = await Promise.all(
+    Object.values(skills).filter((skill) => skill.type === "interactiveSkill").map(async (interactiveSkill) => {
+      const skillManager = new SkillManager({
+        type: "interactive",
+        interactiveSkill
+      });
+      await skillManager.init();
+      return skillManager;
+    })
+  );
+  const delegateSkillManagers = await Promise.all(
+    expert.delegates.map(async (delegateExpertName) => {
+      const delegate = experts[delegateExpertName];
+      const skillManager = new SkillManager({
+        type: "delegate",
+        expert: delegate
+      });
+      await skillManager.init();
+      return skillManager;
+    })
+  );
+  for (const skillManager of mcpSkillManagers) {
+    skillManagers[skillManager.name] = skillManager;
+  }
+  for (const skillManager of interactiveSkillManagers) {
+    skillManagers[skillManager.name] = skillManager;
+  }
+  for (const skillManager of delegateSkillManagers) {
+    skillManagers[skillManager.name] = skillManager;
+  }
+  return skillManagers;
+}
+async function closeSkillManagers(skillManagers) {
+  for (const skillManager of Object.values(skillManagers)) {
+    await skillManager.close();
+  }
+}
+async function getSkillManagerByToolName(skillManagers, toolName) {
+  for (const skillManager of Object.values(skillManagers)) {
+    const toolDefinitions = await skillManager.getToolDefinitions();
+    for (const toolDefinition of toolDefinitions) {
+      if (toolDefinition.name === toolName) {
+        return skillManager;
+      }
+    }
+  }
+  throw new Error(`Tool ${toolName} not found`);
+}
+async function getToolSet(skillManagers) {
+  const tools = {};
+  for (const skillManager of Object.values(skillManagers)) {
+    const toolDefinitions = await skillManager.getToolDefinitions();
+    for (const toolDefinition of toolDefinitions) {
+      tools[toolDefinition.name] = {
+        description: toolDefinition.description,
+        parameters: jsonSchema(toolDefinition.inputSchema)
+      };
+    }
+  }
+  return tools;
+}
+
+// src/states/calling-delegate.ts
+async function callingDelegateLogic({
+  setting,
+  checkpoint,
+  step,
+  skillManagers
+}) {
+  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) {
+    throw new Error(`Delegation error: skill manager "${toolName}" not found`);
+  }
+  if (!args || !args.query || typeof args.query !== "string") {
+    throw new Error("Delegation error: query is undefined");
+  }
+  return stopRunByDelegate(setting, checkpoint, {
+    checkpoint: {
+      ...checkpoint,
+      status: "stoppedByDelegate",
+      delegateTo: {
+        expert: {
+          key: skillManager.expert.key,
+          name: skillManager.expert.name,
+          version: skillManager.expert.version
+        },
+        toolCallId: id,
+        toolName,
+        query: args.query
+      }
+    },
+    step: {
+      ...step,
+      finishedAt: (/* @__PURE__ */ new Date()).getTime()
+    }
+  });
+}
+
+// src/states/calling-interactive-tool.ts
+async function callingInteractiveToolLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  return stopRunByInteractiveTool(setting, checkpoint, {
+    checkpoint: {
+      ...checkpoint,
+      status: "stoppedByInteractiveTool"
+    },
+    step: {
+      ...step,
+      finishedAt: (/* @__PURE__ */ new Date()).getTime()
+    }
+  });
+}
+
+// src/states/calling-tool.ts
+async function callingToolLogic({
+  setting,
+  checkpoint,
+  step,
+  skillManagers
+}) {
+  if (!step?.toolCall) {
+    throw new Error("No tool call found");
+  }
+  const { id, skillName, toolName, args } = step.toolCall;
+  const skillManager = await getSkillManagerByToolName(skillManagers, toolName);
+  if (skillManager.type !== "mcp") {
+    throw new Error(`Incorrect SkillType, required MCP, got ${skillManager.type}`);
+  }
+  const result = await skillManager.callTool(toolName, args);
+  const toolResult = { id, skillName, toolName, result };
+  if (skillName === "@perstack/base") {
+    if (toolName === "think") {
+      return resolveThought(setting, checkpoint, { toolResult });
+    }
+    if (toolName === "attemptCompletion") {
+      return attemptCompletion(setting, checkpoint, { toolResult });
+    }
+    if (toolName === "readPdfFile") {
+      return resolvePdfFile(setting, checkpoint, { toolResult });
+    }
+    if (toolName === "readImageFile") {
+      return resolveImageFile(setting, checkpoint, { toolResult });
+    }
+  }
+  return resolveToolResult(setting, checkpoint, { toolResult });
+}
+async function finishingStepLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  if (setting.maxSteps !== void 0 && checkpoint.stepNumber > setting.maxSteps) {
+    return stopRunByExceededMaxSteps(setting, checkpoint, {
+      checkpoint: {
+        ...checkpoint,
+        status: "stoppedByExceededMaxSteps"
+      },
+      step: {
+        ...step,
+        finishedAt: (/* @__PURE__ */ new Date()).getTime()
+      }
+    });
+  }
+  return continueToNextStep(setting, checkpoint, {
+    checkpoint: {
+      ...checkpoint
+    },
+    step: {
+      ...step,
+      finishedAt: (/* @__PURE__ */ new Date()).getTime()
+    },
+    nextCheckpoint: {
+      ...checkpoint,
+      id: createId(),
+      stepNumber: checkpoint.stepNumber + 1
+    }
+  });
+}
+function createUserMessage(contents) {
+  return {
+    type: "userMessage",
+    contents: contents.map((part) => ({
+      ...part,
+      id: createId()
+    })),
+    id: createId()
+  };
+}
+function createExpertMessage(contents) {
+  return {
+    type: "expertMessage",
+    contents: contents.map((part) => ({
+      ...part,
+      id: createId()
+    })),
+    id: createId()
+  };
+}
+function createToolMessage(contents) {
+  return {
+    type: "toolMessage",
+    contents: contents.map((part) => ({
+      ...part,
+      contents: part.contents.map((part2) => ({
+        ...part2,
+        id: createId()
+      })),
+      id: createId()
+    })),
+    id: createId()
+  };
+}
+function messageToCoreMessage(message) {
+  switch (message.type) {
+    case "instructionMessage":
+      return {
+        role: "system",
+        content: instructionContentsToCoreContent(message.contents),
+        providerOptions: message.cache ? {
+          anthropic: { cacheControl: { type: "ephemeral" } }
+        } : void 0
+      };
+    case "userMessage":
+      return {
+        role: "user",
+        content: userContentsToCoreContent(message.contents),
+        providerOptions: message.cache ? {
+          anthropic: { cacheControl: { type: "ephemeral" } }
+        } : void 0
+      };
+    case "expertMessage":
+      return {
+        role: "assistant",
+        content: expertContentsToCoreContent(message.contents),
+        providerOptions: message.cache ? {
+          anthropic: { cacheControl: { type: "ephemeral" } }
+        } : void 0
+      };
+    case "toolMessage":
+      return {
+        role: "tool",
+        content: toolContentsToCoreContent(message.contents),
+        providerOptions: message.cache ? {
+          anthropic: { cacheControl: { type: "ephemeral" } }
+        } : void 0
+      };
+  }
+}
+function instructionContentsToCoreContent(contents) {
+  return contents.reduce((acc, part) => {
+    return dedent`
+      ${acc}
+      ${part.text}
+    `.trim();
+  }, "");
+}
+function userContentsToCoreContent(contents) {
+  return contents.map((part) => {
+    switch (part.type) {
+      case "textPart":
+        return textPartToCoreTextPart(part);
+      case "imageUrlPart":
+        return imageUrlPartToCoreImagePart(part);
+      case "imageInlinePart":
+        return imageInlinePartToCoreImagePart(part);
+      case "imageBinaryPart":
+        return imageBinaryPartToCoreImagePart(part);
+      case "fileUrlPart":
+        return fileUrlPartToCoreFilePart(part);
+      case "fileInlinePart":
+        return fileInlinePartToCoreFilePart(part);
+      case "fileBinaryPart":
+        return fileBinaryPartToCoreFilePart(part);
+    }
+  });
+}
+function expertContentsToCoreContent(contents) {
+  return contents.map((part) => {
+    switch (part.type) {
+      case "textPart":
+        return textPartToCoreTextPart(part);
+      case "toolCallPart":
+        return toolCallPartToCoreToolCallPart(part);
+    }
+  });
+}
+function toolContentsToCoreContent(contents) {
+  return contents.map((part) => {
+    switch (part.type) {
+      case "toolResultPart":
+        return toolResultPartToCoreToolResultPart(part);
+    }
+  });
+}
+function textPartToCoreTextPart(part) {
+  return {
+    type: "text",
+    text: part.text
+  };
+}
+function imageUrlPartToCoreImagePart(part) {
+  return {
+    type: "image",
+    image: part.url,
+    mimeType: part.mimeType
+  };
+}
+function imageInlinePartToCoreImagePart(part) {
+  return {
+    type: "image",
+    image: part.encodedData,
+    mimeType: part.mimeType
+  };
+}
+function imageBinaryPartToCoreImagePart(part) {
+  return {
+    type: "image",
+    image: part.data,
+    mimeType: part.mimeType
+  };
+}
+function fileUrlPartToCoreFilePart(part) {
+  return {
+    type: "file",
+    data: part.url,
+    mimeType: part.mimeType
+  };
+}
+function fileInlinePartToCoreFilePart(part) {
+  return {
+    type: "file",
+    data: part.encodedData,
+    mimeType: part.mimeType
+  };
+}
+function fileBinaryPartToCoreFilePart(part) {
+  return {
+    type: "file",
+    data: part.data,
+    mimeType: part.mimeType
+  };
+}
+function toolCallPartToCoreToolCallPart(part) {
+  return {
+    type: "tool-call",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    args: part.args
+  };
+}
+function toolResultPartToCoreToolResultPart(part) {
+  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
+  };
+}
+
+// src/usage.ts
+function createEmptyUsage() {
+  return {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheReadInputTokens: 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.promptTokens,
+    completionTokens: result.usage.completionTokens,
+    totalTokens: result.usage.totalTokens,
+    cacheCreationInputTokens,
+    cacheReadInputTokens
+  };
+}
+function sumUsage(a, b) {
+  return {
+    promptTokens: a.promptTokens + b.promptTokens,
+    completionTokens: a.completionTokens + b.completionTokens,
+    totalTokens: a.totalTokens + b.totalTokens,
+    cacheCreationInputTokens: a.cacheCreationInputTokens + b.cacheCreationInputTokens,
+    cacheReadInputTokens: a.cacheReadInputTokens + b.cacheReadInputTokens
+  };
+}
+
+// src/states/generating-run-result.ts
+async function generatingRunResultLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  if (!step?.toolCall || !step?.toolResult) {
+    throw new Error("No tool call or tool result found");
+  }
+  const { id, toolName } = step.toolCall;
+  const { result } = step.toolResult;
+  const toolMessage = createToolMessage([
+    {
+      type: "toolResultPart",
+      toolCallId: id,
+      toolName,
+      contents: result.filter(
+        (part) => part.type === "textPart" || part.type === "imageInlinePart"
+      )
+    }
+  ]);
+  const model = getModel(setting.model);
+  const { messages } = checkpoint;
+  const generationResult = await generateText({
+    model,
+    messages: [...messages, toolMessage].map(messageToCoreMessage),
+    temperature: setting.temperature,
+    maxRetries: setting.maxRetries
+  });
+  const usage = usageFromGenerateTextResult(generationResult);
+  const { text } = generationResult;
+  const newMessages = [toolMessage, createExpertMessage(text ? [{ type: "textPart", text }] : [])];
+  return completeRun(setting, checkpoint, {
+    checkpoint: {
+      ...checkpoint,
+      messages: [...messages, ...newMessages],
+      usage: sumUsage(checkpoint.usage, usage),
+      status: "completed"
+    },
+    step: {
+      ...step,
+      newMessages: [...step.newMessages, ...newMessages],
+      finishedAt: (/* @__PURE__ */ new Date()).getTime(),
+      usage: sumUsage(step.usage, usage)
+    },
+    text,
+    usage
+  });
+}
+async function generatingToolCallLogic({
+  setting,
+  checkpoint,
+  skillManagers
+}) {
+  const { messages } = checkpoint;
+  const model = getModel(setting.model);
+  const result = await generateText({
+    model,
+    messages: messages.map(messageToCoreMessage),
+    temperature: setting.temperature,
+    maxRetries: setting.maxRetries,
+    tools: await getToolSet(skillManagers),
+    toolChoice: "required"
+  });
+  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."
+          }
+        ])
+      ],
+      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
+    }
+  ];
+  if (text) {
+    contents.push({
+      type: "textPart",
+      text
+    });
+  }
+  const skillManager = await getSkillManagerByToolName(skillManagers, toolCall.toolName);
+  const eventPayload = {
+    newMessage: createExpertMessage(contents),
+    toolCall: {
+      id: toolCall.toolCallId,
+      skillName: skillManager.name,
+      toolName: toolCall.toolName,
+      args: toolCall.args
+    },
+    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);
+  }
+}
+var metaInstruction = dedent`
   IMPORTANT:
   You are NOT an "interactive" AI agent.
   From the start of the agent loop until the completion of the task,
@@ -41,40 +1616,857 @@ import {existsSync}from'fs';import {readFile,writeFile,mkdir,readdir}from'fs/pro
   - 専門家である以上、ユーザーが期待する以上の品質のアウトプットを行ってください
 
   Environment information:
-  - Current time is ${new Date().toISOString()}
+  - Current time is ${(/* @__PURE__ */ new Date()).toISOString()}
   - Current working directory is ${process.cwd()}
-`;function Xe(e,t){let o=dedent`
+`;
+function createInstructionMessage(expert, experts) {
+  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.)
 
-    ${po}
+    ${metaInstruction}
 
     ---
     (The following describes the objective, steps, rules, etc. regarding your expert task.)
 
-    ${e.instruction}
+    ${expert.instruction}
 
     ---
     (The following is an overview of each skill and the rules for calling tools.)
 
-    ${co(e)}
+    ${getSkillRules(expert)}
 
     ---
     (The following is an overview of each delegate expert and the rules for calling tools.)
 
     You can delegate tasks to the following experts by calling delegate expert name as a tool:
 
-    ${mo(e,t)}
-  `;return {type:"instructionMessage",contents:[{id:createId(),type:"textPart",text:o}],id:createId(),cache:true}}function co(e){return Object.values(e.skills).reduce((t,o)=>o.rule?dedent`
-      ${t}
+    ${getDelegateRules(expert, experts)}
+  `;
+  return {
+    type: "instructionMessage",
+    contents: [
+      {
+        id: createId(),
+        type: "textPart",
+        text: instruction
+      }
+    ],
+    id: createId(),
+    cache: true
+  };
+}
+function getSkillRules(expert) {
+  return Object.values(expert.skills).reduce((acc, skill) => {
+    if (!skill.rule) {
+      return acc;
+    }
+    return dedent`
+      ${acc}
+
+      "${skill.name}" skill rules:
+      ${skill.rule}
+    `.trim();
+  }, "");
+}
+function getDelegateRules(expert, experts) {
+  return expert.delegates.reduce((acc, delegateExpertName) => {
+    const delegate = experts[delegateExpertName];
+    if (!delegate) {
+      return acc;
+    }
+    return dedent`
+      ${acc}
+
+      About "${delegate.name}":
+      ${delegate.description}
+    `.trim();
+  }, "");
+}
+
+// src/states/init.ts
+async function initLogic({
+  setting,
+  checkpoint
+}) {
+  const { expertKey, experts } = setting;
+  const expert = experts[expertKey];
+  switch (checkpoint.status) {
+    case "init":
+      return startRun(setting, checkpoint, {
+        initialCheckpoint: checkpoint,
+        inputMessages: [createInstructionMessage(expert, experts), getInputMessage(setting.input)]
+      });
+    default:
+      return startRun(setting, checkpoint, {
+        initialCheckpoint: checkpoint,
+        inputMessages: [getInputMessage(setting.input)]
+      });
+  }
+}
+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 }]
+      }
+    ]);
+  }
+  throw new Error("Input message is undefined");
+}
+
+// src/states/preparing-for-step.ts
+async function preparingForStepLogic({
+  setting,
+  checkpoint
+}) {
+  return startGeneration(setting, checkpoint, {
+    messages: checkpoint.messages
+  });
+}
+async function resolvingImageFileLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  if (!step?.toolCall || !step?.toolResult) {
+    throw new Error("No tool call or tool result found");
+  }
+  const { id, toolName } = step.toolCall;
+  const { result } = step.toolResult;
+  const textParts = result.filter((part) => part.type === "textPart");
+  const files = [];
+  for (const textPart of textParts) {
+    let imageInfo;
+    try {
+      imageInfo = JSON.parse(textPart.text);
+    } catch {
+      files.push({
+        type: "textPart",
+        text: textPart.text
+      });
+      continue;
+    }
+    const { path: path2, mimeType, size } = imageInfo;
+    const file = await readFile(path2).then((buffer) => ({
+      encodedData: buffer.toString("base64"),
+      mimeType,
+      size
+    }));
+    files.push({
+      type: "imageInlinePart",
+      encodedData: file.encodedData,
+      mimeType: file.mimeType
+    });
+  }
+  return finishToolCall(setting, checkpoint, {
+    newMessages: [
+      createToolMessage([
+        {
+          type: "toolResultPart",
+          toolCallId: id,
+          toolName,
+          contents: files
+        }
+      ])
+    ]
+  });
+}
+async function resolvingPdfFileLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  if (!step?.toolCall || !step?.toolResult) {
+    throw new Error("No tool call or tool result found");
+  }
+  const { id, toolName } = step.toolCall;
+  const { result } = step.toolResult;
+  const textParts = result.filter((part) => part.type === "textPart");
+  const files = [];
+  for (const textPart of textParts) {
+    let pdfInfo;
+    try {
+      pdfInfo = JSON.parse(textPart.text);
+    } catch {
+      files.push({
+        type: "textPart",
+        text: textPart.text
+      });
+      continue;
+    }
+    const { path: path2, mimeType, size } = pdfInfo;
+    const file = await readFile(path2).then((buffer) => ({
+      encodedData: buffer.toString("base64"),
+      mimeType,
+      size
+    }));
+    files.push({
+      type: "fileInlinePart",
+      encodedData: file.encodedData,
+      mimeType: file.mimeType
+    });
+  }
+  return finishToolCall(setting, checkpoint, {
+    newMessages: [
+      createToolMessage([
+        {
+          type: "toolResultPart",
+          toolCallId: id,
+          toolName,
+          contents: [
+            {
+              type: "textPart",
+              text: "User uploads PDF file as follows."
+            }
+          ]
+        }
+      ]),
+      createUserMessage(files)
+    ]
+  });
+}
+
+// src/states/resolving-tool-result.ts
+async function resolvingToolResultLogic({
+  setting,
+  checkpoint,
+  step
+}) {
+  if (!step?.toolCall || !step?.toolResult) {
+    throw new Error("No tool call or tool result found");
+  }
+  const { id, toolName } = step.toolCall;
+  const { result } = step.toolResult;
+  return finishToolCall(setting, checkpoint, {
+    newMessages: [
+      createToolMessage([
+        {
+          type: "toolResultPart",
+          toolCallId: id,
+          toolName,
+          contents: result.filter(
+            (part) => part.type === "textPart" || part.type === "imageInlinePart"
+          )
+        }
+      ])
+    ]
+  });
+}
+
+// src/states/resolving-thought.ts
+async function resolvingThoughtLogic(context) {
+  return resolvingToolResultLogic(context);
+}
+
+// src/runtime-state-machine.ts
+var runtimeStateMachine = setup({
+  types: {
+    input: {},
+    context: {},
+    events: {}
+  }
+}).createMachine({
+  /** @xstate-layout N4IgpgJg5mDOIC5QCUCuA7AdASXQSwBcBiWAgQwCcC10BtABgF1FQAHAe1kL3fRZAAeiAKz0AzJgDsAJgAsksZNlixs+gDZZAGhABPRIszCAjGIAcY4crPHhJyQF8HOmpgAKFMK0p50UAGLsFADKBF4k5FQA4mDoYBRkBDx0TPwcXEm8-EIIZmaymPRK8saSopL00tI6+gjq9JjSltLG9HnqZkqdTi4YmDFxCUl+ACrs7AA2AMJkExNEngQUugzMSCDp3FnrOcam0pgAnHbS9GeSZsIq6jWIh2KHUsYd9MbSwl2S6j0grgPxiV8UDGkxmcyIAGNZhMQRNVmlOFs+DtEPt1Jg3odpGVbFcrLcENIzOjbGYipIZMpnmYfn9YgDhsDxtNoZDobgwgkIUkAG5gWHw9abTLI0C7ImSTDqYTY2S45TCCwE54HUr1WRXSqHcRVWl9f5DIGwsHzKFzAAiYAmYCgiTAgrYiJF2VRYnoj1ehwskkOZTEz2EBMMJnMFnezxUF2+zl+fRNRuZCzgkz5sOQcFQEwIDo2TuSLoQpWJUvowl9Flk0sqBLlZik2Mkpjyan90d6WHjo0TnlgKf5AAt2KgoP3s6khXntmLUT6JL6PkoFJX1MZtHoRKIpdrK3sqorpG3Yx3oQnJknexM+W4IAAzfx4a054X5lGFn2PMTYlSyWQH32WAl1DKKV1Q6L1V1EWQ9WPOZT3mHs+2wABbMgYHvR9x0dDIX2nN8zEeOVjGORsmgsMQCTJYRMGJORwP9MwDxpGNXE7Jkz0SMIkNYAgpnYLjrRFJ9J1FQQZzJTBPxUfDDjlN1OgJIkSUVUtDlXCpsUPVx0wvHk4O0zNiBvXw8FgftjWhITsKnUTCU-SU92JMlfSaGtjDrGQKSbfJxGeaDMG0lMjUHYdRyIIz8FM8y5kspECyabFGneRz3RkN011qOwGnUbcVzeJKDz8gLLyBa87wfMAwuMyLmRNGLnVfeL7KSl5nPI9c6mA9RQPwmwNVLQrk2KvxkNQsB0Iq8KTLMmqLMw3MrJEnJGsSxUWtSgkfSU-JDmIqNKj8g1AT8Gh9KzSE+NYASwBoOqcJs+K61sDo5SKBifwU4tSRUtTKi+KDmLjE9hvQTkyG5PBU0TUh2FYGgACFdA5AFwchyZbus3YyklYRst-DUlDEaU2tqFUMS+NyPmlPZDiAvzWMta1bTCCIYfh3QGZtO10cWmcLiOQnG3qHHiSDbGvM-Ex1EjYk-PvCL+yBUJwghXhhlQfl2AAOTAAQCCV1hubiqxjCMRUZXMGSvVUZV6A1LcuorDp8I0WWqoVvx9ZZ2GMARgBRAQITASBIAAWTIAR9dgQ2Gs0Ki8nyK4bCuDVRZNzRwxse4GK6pwY3QdgIDgfgaARBaCxUBosU0cw5TLUiCQAWlkR4nPdbVCeyld-vbHB8AIUvYtfRQ6yr6xa6xcwCTLaiadj1dKxk1phD8jwvB8PxAhCMJWAH+rcKAyuyVaa5Wi+KeW9njV59xpeDvpQ0u1BaFd7u3Y2keDpO7LW2FDLc+Z6AnsPEO4ZYAxghMOCL8MaojsJKYi8cHZ5C9EGNoRg1CdH3GcZeYD-KDV0o-CYp1+4TjLg1cQkp-SfjDE9Ew1R2o-hNnsUs1MfR-UuANHSQUhwjmIVhQeuFTg-ilF8GUblTgKDoRlBQhQJEaiJMnfCHDAp+FKuNKBPNCSlgaOIeQttWxS0DO1bKdY9HvH9D+FotMcFFXwVAEaaFyrqLirbBo1M7KvFUDJCiRJGgalUM3LEMk5R30GEdKAJ0MxZicWQlQEklAyillWVoZgUF1isG0MoDEsF0yBnYkGyNeQa0mNE3CtgiIYnEEBToFwvS+mVPkU20l8JWG1OIHJsE-AcyZmAEpNlbBqEwLo7yVRbY3HatPfCXUOgfCsGSTQmk+hyymorbevSloykeFYCkrxfqrmJiIaRRQ7JbP8Q8PyoQYasEgGsxA2JWiNB-jjdQTRqb1IkP6OwRF8KMSAbnBwQA */
+  id: "Run",
+  initial: "Init",
+  context: ({ input }) => ({
+    setting: input.setting,
+    checkpoint: input.initialCheckpoint,
+    eventListener: input.eventListener,
+    skillManagers: input.skillManagers
+  }),
+  states: {
+    Init: {
+      on: {
+        startRun: {
+          target: "PreparingForStep",
+          actions: assign({
+            checkpoint: ({ event }) => ({
+              ...event.initialCheckpoint,
+              messages: [...event.initialCheckpoint.messages, ...event.inputMessages],
+              status: "proceeding"
+            })
+          })
+        }
+      }
+    },
+    PreparingForStep: {
+      on: {
+        startGeneration: {
+          target: "GeneratingToolCall",
+          actions: assign({
+            step: ({ context, event }) => ({
+              stepNumber: context.checkpoint.stepNumber,
+              newMessages: [],
+              usage: createEmptyUsage(),
+              startedAt: event.timestamp
+            })
+          })
+        }
+      }
+    },
+    GeneratingToolCall: {
+      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)
+            })
+          })
+        },
+        callTool: {
+          target: "CallingTool",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, event.newMessage],
+              usage: sumUsage(context.checkpoint.usage, event.usage)
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [event.newMessage],
+              toolCall: event.toolCall,
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        },
+        callInteractiveTool: {
+          target: "CallingInteractiveTool",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, event.newMessage],
+              usage: sumUsage(context.checkpoint.usage, event.usage)
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [event.newMessage],
+              toolCall: event.toolCall,
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        },
+        callDelegate: {
+          target: "CallingDelegate",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, event.newMessage],
+              usage: sumUsage(context.checkpoint.usage, event.usage)
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [event.newMessage],
+              toolCall: event.toolCall,
+              usage: sumUsage(context.step.usage, event.usage)
+            })
+          })
+        }
+      }
+    },
+    CallingTool: {
+      on: {
+        resolveToolResult: {
+          target: "ResolvingToolResult",
+          actions: assign({
+            step: ({ context, event }) => ({
+              ...context.step,
+              toolResult: event.toolResult
+            })
+          })
+        },
+        resolveThought: {
+          target: "ResolvingThought",
+          actions: assign({
+            step: ({ context, event }) => ({
+              ...context.step,
+              toolResult: event.toolResult
+            })
+          })
+        },
+        resolvePdfFile: {
+          target: "ResolvingPdfFile",
+          actions: assign({
+            step: ({ context, event }) => ({
+              ...context.step,
+              toolResult: event.toolResult
+            })
+          })
+        },
+        resolveImageFile: {
+          target: "ResolvingImageFile",
+          actions: assign({
+            step: ({ context, event }) => ({
+              ...context.step,
+              toolResult: event.toolResult
+            })
+          })
+        },
+        attemptCompletion: {
+          target: "GeneratingRunResult",
+          actions: assign({
+            step: ({ context, event }) => ({
+              ...context.step,
+              toolResult: event.toolResult
+            })
+          })
+        }
+      }
+    },
+    ResolvingToolResult: {
+      on: {
+        finishToolCall: {
+          target: "FinishingStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, ...event.newMessages]
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [...context.step.newMessages, ...event.newMessages]
+            })
+          })
+        }
+      }
+    },
+    ResolvingThought: {
+      on: {
+        finishToolCall: {
+          target: "FinishingStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, ...event.newMessages]
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [...context.step.newMessages, ...event.newMessages]
+            })
+          })
+        }
+      }
+    },
+    ResolvingPdfFile: {
+      on: {
+        finishToolCall: {
+          target: "FinishingStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, ...event.newMessages]
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [...context.step.newMessages, ...event.newMessages]
+            })
+          })
+        }
+      }
+    },
+    ResolvingImageFile: {
+      on: {
+        finishToolCall: {
+          target: "FinishingStep",
+          actions: assign({
+            checkpoint: ({ context, event }) => ({
+              ...context.checkpoint,
+              messages: [...context.checkpoint.messages, ...event.newMessages]
+            }),
+            step: ({ context, event }) => ({
+              ...context.step,
+              newMessages: [...context.step.newMessages, ...event.newMessages]
+            })
+          })
+        }
+      }
+    },
+    GeneratingRunResult: {
+      on: {
+        completeRun: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => event.step
+          })
+        }
+      }
+    },
+    CallingInteractiveTool: {
+      on: {
+        stopRunByInteractiveTool: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => event.step
+          })
+        }
+      }
+    },
+    CallingDelegate: {
+      on: {
+        stopRunByDelegate: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => event.step
+          })
+        }
+      }
+    },
+    FinishingStep: {
+      on: {
+        continueToNextStep: {
+          target: "PreparingForStep",
+          actions: assign({
+            checkpoint: ({ event }) => event.nextCheckpoint,
+            step: ({ event }) => event.step
+          }),
+          reenter: true
+        },
+        stopRunByExceededMaxSteps: {
+          target: "Stopped",
+          actions: assign({
+            checkpoint: ({ event }) => event.checkpoint,
+            step: ({ event }) => event.step
+          })
+        }
+      }
+    },
+    Stopped: {
+      type: "final"
+    }
+  }
+});
+var StateMachineLogics = {
+  Init: initLogic,
+  PreparingForStep: preparingForStepLogic,
+  GeneratingToolCall: generatingToolCallLogic,
+  CallingTool: callingToolLogic,
+  ResolvingToolResult: resolvingToolResultLogic,
+  ResolvingThought: resolvingThoughtLogic,
+  ResolvingPdfFile: resolvingPdfFileLogic,
+  ResolvingImageFile: resolvingImageFileLogic,
+  GeneratingRunResult: generatingRunResultLogic,
+  CallingInteractiveTool: callingInteractiveToolLogic,
+  CallingDelegate: callingDelegateLogic,
+  FinishingStep: finishingStepLogic
+};
+var PerstackConfigSchema = z.object({
+  model: z.string().optional(),
+  temperature: z.number().optional(),
+  maxSteps: z.number().optional(),
+  maxRetries: z.number().optional(),
+  experts: z.record(
+    z.string(),
+    z.object({
+      version: z.string().optional(),
+      minRuntimeVersion: z.string().optional(),
+      description: z.string().optional(),
+      instruction: z.string(),
+      skills: z.record(
+        z.string(),
+        z.discriminatedUnion("type", [
+          z.object({
+            type: z.literal("mcpStdioSkill"),
+            description: z.string().optional(),
+            rule: z.string().optional(),
+            pick: z.array(z.string()).optional(),
+            omit: z.array(z.string()).optional(),
+            command: z.string(),
+            packageName: z.string().optional(),
+            args: z.array(z.string()).optional(),
+            requiredEnv: z.array(z.string()).optional()
+          }),
+          z.object({
+            type: z.literal("mcpSseSkill"),
+            description: z.string().optional(),
+            rule: z.string().optional(),
+            pick: z.array(z.string()).optional(),
+            omit: z.array(z.string()).optional(),
+            endpoint: z.string()
+          }),
+          z.object({
+            type: z.literal("interactiveSkill"),
+            description: z.string().optional(),
+            rule: z.string().optional(),
+            tools: z.record(
+              z.string(),
+              z.object({
+                description: z.string().optional(),
+                inputJsonSchema: z.string()
+              })
+            )
+          })
+        ])
+      ).optional(),
+      delegates: z.array(z.string()).optional()
+    })
+  ).optional()
+});
 
-      "${o.name}" skill rules:
-      ${o.rule}
-    `.trim():t,"")}function mo(e,t){return e.delegates.reduce((o,r)=>{let a=t[r];return a?dedent`
-      ${o}
+// src/runtime.ts
+async function run(runInput, options) {
+  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 (setting.workspace) {
+    if (!path.isAbsolute(setting.workspace)) {
+      throw new Error(`Workspace path must be absolute: ${setting.workspace}`);
+    }
+    process.chdir(setting.workspace);
+  }
+  await storeRunSetting(setting);
+  while (true) {
+    const { expertToRun, experts } = await setupExperts(setting);
+    printRunSetting(expertToRun.name, experts, setting);
+    const skillManagers = await getSkillManagers(expertToRun, experts);
+    const runActor = createActor(runtimeStateMachine, {
+      input: {
+        setting: {
+          ...setting,
+          experts
+        },
+        initialCheckpoint: checkpoint ?? {
+          id: createId(),
+          runId: setting.runId,
+          expert: {
+            key: setting.expertKey,
+            name: expertToRun.name,
+            version: expertToRun.version
+          },
+          stepNumber: 1,
+          status: "init",
+          messages: [],
+          usage: createEmptyUsage()
+        },
+        eventListener,
+        skillManagers
+      }
+    });
+    const runResultCheckpoint = await new Promise((resolve, reject) => {
+      runActor.subscribe(async (runState) => {
+        try {
+          if (runState.value === "Stopped") {
+            const { checkpoint: checkpoint2, skillManagers: skillManagers2 } = runState.context;
+            if (!checkpoint2) {
+              throw new Error("Checkpoint is undefined");
+            }
+            await closeSkillManagers(skillManagers2);
+            resolve(checkpoint2);
+          } else {
+            const event = await StateMachineLogics[runState.value](runState.context);
+            if ("checkpoint" in event) {
+              await storeCheckpoint(event.checkpoint, event.timestamp);
+            }
+            await eventEmitter.emit(event);
+            runActor.send(event);
+          }
+        } catch (error) {
+          reject(error);
+        }
+      });
+      runActor.start();
+    });
+    switch (runResultCheckpoint.status) {
+      case "completed": {
+        if (runResultCheckpoint.delegatedBy) {
+          const { messages, delegatedBy } = runResultCheckpoint;
+          const { expert, toolCallId, toolName, checkpointId } = delegatedBy;
+          const delegateResultMessage = messages[messages.length - 1];
+          if (delegateResultMessage.type !== "expertMessage") {
+            throw new Error("Delegation error: delegation result message is incorrect");
+          }
+          const delegateText = delegateResultMessage.contents.find(
+            (content) => content.type === "textPart"
+          );
+          if (!delegateText) {
+            throw new Error("Delegation error: delegation result message does not contain a text");
+          }
+          setting = {
+            ...setting,
+            expertKey: expert.key,
+            input: {
+              interactiveToolCallResult: {
+                toolCallId,
+                toolName,
+                text: delegateText.text
+              }
+            }
+          };
+          checkpoint = {
+            ...await retrieveCheckpoint(setting.runId, checkpointId),
+            id: createId(),
+            stepNumber: runResultCheckpoint.stepNumber + 1,
+            usage: runResultCheckpoint.usage
+          };
+          break;
+        }
+        return runResultCheckpoint;
+      }
+      case "stoppedByInteractiveTool": {
+        return runResultCheckpoint;
+      }
+      case "stoppedByDelegate": {
+        if (!runResultCheckpoint.delegateTo) {
+          throw new Error("Delegation error: delegate to is undefined");
+        }
+        const { expert, toolCallId, toolName, query } = runResultCheckpoint.delegateTo;
+        setting = {
+          ...setting,
+          expertKey: expert.key,
+          input: {
+            text: query
+          }
+        };
+        checkpoint = {
+          id: createId(),
+          runId: setting.runId,
+          status: "init",
+          stepNumber: runResultCheckpoint.stepNumber + 1,
+          messages: [],
+          expert: {
+            key: expert.key,
+            name: expert.name,
+            version: expert.version
+          },
+          delegatedBy: {
+            expert: {
+              key: expertToRun.key,
+              name: expertToRun.name,
+              version: expertToRun.version
+            },
+            toolCallId,
+            toolName,
+            checkpointId: runResultCheckpoint.id
+          },
+          usage: runResultCheckpoint.usage
+        };
+        break;
+      }
+      case "stoppedByExceededMaxSteps": {
+        return runResultCheckpoint;
+      }
+      case "stoppedByError": {
+        return runResultCheckpoint;
+      }
+      default:
+        throw new Error("Run stopped by unknown reason");
+    }
+  }
+}
+async function setupExperts(setting) {
+  const { expertKey } = setting;
+  const experts = { ...setting.experts };
+  const expertToRun = await resolveExpertToRun(expertKey, experts);
+  for (const delegateName of expertToRun.delegates) {
+    const delegate = await resolveExpertToRun(delegateName, experts);
+    if (!delegate) {
+      throw new Error(`Delegate ${delegateName} not found`);
+    }
+  }
+  return { expertToRun, experts };
+}
+function printRunSetting(expertName, experts, setting) {
+  console.log("\u{1F99C} Starting Perstack \u{1F99C}");
+  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}`);
+  if (setting.input.text) {
+    console.log(`Query: ${setting.input.text}`);
+  }
+  if (setting.input.interactiveToolCallResult) {
+    console.log(`Tool: ${setting.input.interactiveToolCallResult.toolName}`);
+    console.log(`Tool Call ID: ${setting.input.interactiveToolCallResult.toolCallId}`);
+    console.log(`Tool Result: ${setting.input.interactiveToolCallResult.text}`);
+  }
+}
+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 readFile(runSettingPath, "utf-8"));
+    runSetting.updatedAt = Date.now();
+    await writeFile(runSettingPath, JSON.stringify(runSetting, null, 2), "utf-8");
+  } else {
+    await mkdir(runDir, { recursive: true });
+    await writeFile(
+      path.resolve(runDir, "run-setting.json"),
+      JSON.stringify(setting, null, 2),
+      "utf-8"
+    );
+  }
+}
+function getRunDir(runId) {
+  return `${process.cwd()}/perstack/runs/${runId}`;
+}
+async function parseConfig(config) {
+  const toml = TOML.parse(config ?? "");
+  return PerstackConfigSchema.parse(toml);
+}
+var RunInputSchema = z.object({
+  expertKey: z.string(),
+  query: z.string(),
+  options: z.object({
+    config: z.string().optional(),
+    model: z.string().optional(),
+    temperature: z.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: z.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: z.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: z.string().optional()
+  })
+});
 
-      About "${a.name}":
-      ${a.description}
-    `.trim():o},"")}async function tt({setting:e,checkpoint:t}){let{expertKey:o,experts:r}=e,a=r[o];switch(t.status){case "init":return ne(e,t,{initialCheckpoint:t,inputMessages:[Xe(a,r),et(e.input)]});default:return ne(e,t,{initialCheckpoint:t,inputMessages:[et(e.input)]})}}function et(e){if(e.text)return F([{type:"textPart",text:e.text}]);if(e.interactiveToolCallResult)return C([{type:"toolResultPart",toolCallId:e.interactiveToolCallResult.toolCallId,toolName:e.interactiveToolCallResult.toolName,contents:[{type:"textPart",text:e.interactiveToolCallResult.text}]}]);throw new Error("Input message is undefined")}async function ot({setting:e,checkpoint:t}){return Te(e,t,{messages:t.messages})}async function nt({setting:e,checkpoint:t,step:o}){if(!o?.toolCall||!o?.toolResult)throw new Error("No tool call or tool result found");let{id:r,toolName:a}=o.toolCall,{result:i}=o.toolResult,c=i.filter(u=>u.type==="textPart"),s=[];for(let u of c){let h;try{h=JSON.parse(u.text);}catch{s.push({type:"textPart",text:u.text});continue}let{path:d,mimeType:P,size:R}=h,f=await readFile(d).then(S=>({encodedData:S.toString("base64"),mimeType:P,size:R}));s.push({type:"imageInlinePart",encodedData:f.encodedData,mimeType:f.mimeType});}return $(e,t,{newMessages:[C([{type:"toolResultPart",toolCallId:r,toolName:a,contents:s}])]})}async function rt({setting:e,checkpoint:t,step:o}){if(!o?.toolCall||!o?.toolResult)throw new Error("No tool call or tool result found");let{id:r,toolName:a}=o.toolCall,{result:i}=o.toolResult,c=i.filter(u=>u.type==="textPart"),s=[];for(let u of c){let h;try{h=JSON.parse(u.text);}catch{s.push({type:"textPart",text:u.text});continue}let{path:d,mimeType:P,size:R}=h,f=await readFile(d).then(S=>({encodedData:S.toString("base64"),mimeType:P,size:R}));s.push({type:"fileInlinePart",encodedData:f.encodedData,mimeType:f.mimeType});}return $(e,t,{newMessages:[C([{type:"toolResultPart",toolCallId:r,toolName:a,contents:[{type:"textPart",text:"User uploads PDF file as follows."}]}]),F(s)]})}async function X({setting:e,checkpoint:t,step:o}){if(!o?.toolCall||!o?.toolResult)throw new Error("No tool call or tool result found");let{id:r,toolName:a}=o.toolCall,{result:i}=o.toolResult;return $(e,t,{newMessages:[C([{type:"toolResultPart",toolCallId:r,toolName:a,contents:i.filter(c=>c.type==="textPart"||c.type==="imageInlinePart")}])]})}async function st(e){return X(e)}var at=setup({types:{input:{},context:{},events:{}}}).createMachine({id:"Run",initial:"Init",context:({input:e})=>({setting:e.setting,checkpoint:e.initialCheckpoint,eventListener:e.eventListener,skillManagers:e.skillManagers}),states:{Init:{on:{startRun:{target:"PreparingForStep",actions:assign({checkpoint:({event:e})=>({...e.initialCheckpoint,messages:[...e.initialCheckpoint.messages,...e.inputMessages],status:"proceeding"})})}}},PreparingForStep:{on:{startGeneration:{target:"GeneratingToolCall",actions:assign({step:({context:e,event:t})=>({stepNumber:e.checkpoint.stepNumber,newMessages:[],usage:H(),startedAt:t.timestamp})})}}},GeneratingToolCall:{on:{retry:{target:"FinishingStep",actions:assign({checkpoint:({context:e,event:t})=>({...e.checkpoint,messages:[...e.checkpoint.messages,...t.newMessages],usage:v(e.checkpoint.usage,t.usage)}),step:({context:e,event:t})=>({...e.step,newMessages:t.newMessages,usage:v(e.step.usage,t.usage)})})},callTool:{target:"CallingTool",actions:assign({checkpoint:({context:e,event:t})=>({...e.checkpoint,messages:[...e.checkpoint.messages,t.newMessage],usage:v(e.checkpoint.usage,t.usage)}),step:({context:e,event:t})=>({...e.step,newMessages:[t.newMessage],toolCall:t.toolCall,usage:v(e.step.usage,t.usage)})})},callInteractiveTool:{target:"CallingInteractiveTool",actions:assign({checkpoint:({context:e,event:t})=>({...e.checkpoint,messages:[...e.checkpoint.messages,t.newMessage],usage:v(e.checkpoint.usage,t.usage)}),step:({context:e,event:t})=>({...e.step,newMessages:[t.newMessage],toolCall:t.toolCall,usage:v(e.step.usage,t.usage)})})},callDelegate:{target:"CallingDelegate",actions:assign({checkpoint:({context:e,event:t})=>({...e.checkpoint,messages:[...e.checkpoint.messages,t.newMessage],usage:v(e.checkpoint.usage,t.usage)}),step:({context:e,event:t})=>({...e.step,newMessages:[t.newMessage],toolCall:t.toolCall,usage:v(e.step.usage,t.usage)})})}}},CallingTool:{on:{resolveToolResult:{target:"ResolvingToolResult",actions:assign({step:({context:e,event:t})=>({...e.step,toolResult:t.toolResult})})},resolveThought:{target:"ResolvingThought",actions:assign({step:({context:e,event:t})=>({...e.step,toolResult:t.toolResult})})},resolvePdfFile:{target:"ResolvingPdfFile",actions:assign({step:({context:e,event:t})=>({...e.step,toolResult:t.toolResult})})},resolveImageFile:{target:"ResolvingImageFile",actions:assign({step:({context:e,event:t})=>({...e.step,toolResult:t.toolResult})})},attemptCompletion:{target:"GeneratingRunResult",actions:assign({step:({context:e,event:t})=>({...e.step,toolResult:t.toolResult})})}}},ResolvingToolResult:{on:{finishToolCall:{target:"FinishingStep",actions:assign({checkpoint:({context:e,event:t})=>({...e.checkpoint,messages:[...e.checkpoint.messages,...t.newMessages]}),step:({context:e,event:t})=>({...e.step,newMessages:[...e.step.newMessages,...t.newMessages]})})}}},ResolvingThought:{on:{finishToolCall:{target:"FinishingStep",actions:assign({checkpoint:({context:e,event:t})=>({...e.checkpoint,messages:[...e.checkpoint.messages,...t.newMessages]}),step:({context:e,event:t})=>({...e.step,newMessages:[...e.step.newMessages,...t.newMessages]})})}}},ResolvingPdfFile:{on:{finishToolCall:{target:"FinishingStep",actions:assign({checkpoint:({context:e,event:t})=>({...e.checkpoint,messages:[...e.checkpoint.messages,...t.newMessages]}),step:({context:e,event:t})=>({...e.step,newMessages:[...e.step.newMessages,...t.newMessages]})})}}},ResolvingImageFile:{on:{finishToolCall:{target:"FinishingStep",actions:assign({checkpoint:({context:e,event:t})=>({...e.checkpoint,messages:[...e.checkpoint.messages,...t.newMessages]}),step:({context:e,event:t})=>({...e.step,newMessages:[...e.step.newMessages,...t.newMessages]})})}}},GeneratingRunResult:{on:{completeRun:{target:"Stopped",actions:assign({checkpoint:({event:e})=>e.checkpoint,step:({event:e})=>e.step})}}},CallingInteractiveTool:{on:{stopRunByInteractiveTool:{target:"Stopped",actions:assign({checkpoint:({event:e})=>e.checkpoint,step:({event:e})=>e.step})}}},CallingDelegate:{on:{stopRunByDelegate:{target:"Stopped",actions:assign({checkpoint:({event:e})=>e.checkpoint,step:({event:e})=>e.step})}}},FinishingStep:{on:{continueToNextStep:{target:"PreparingForStep",actions:assign({checkpoint:({event:e})=>e.nextCheckpoint,step:({event:e})=>e.step}),reenter:true},stopRunByExceededMaxSteps:{target:"Stopped",actions:assign({checkpoint:({event:e})=>e.checkpoint,step:({event:e})=>e.step})}}},Stopped:{type:"final"}}}),it={Init:tt,PreparingForStep:ot,GeneratingToolCall:Qe,CallingTool:Ve,ResolvingToolResult:X,ResolvingThought:st,ResolvingPdfFile:rt,ResolvingImageFile:nt,GeneratingRunResult:He,CallingInteractiveTool:Je,CallingDelegate:qe,FinishingStep:Ye};var lt=z$1.object({model:z$1.string().optional(),temperature:z$1.number().optional(),maxSteps:z$1.number().optional(),maxRetries:z$1.number().optional(),experts:z$1.record(z$1.string(),z$1.object({version:z$1.string().optional(),minRuntimeVersion:z$1.string().optional(),description:z$1.string().optional(),instruction:z$1.string(),skills:z$1.record(z$1.string(),z$1.discriminatedUnion("type",[z$1.object({type:z$1.literal("mcpStdioSkill"),description:z$1.string().optional(),rule:z$1.string().optional(),pick:z$1.array(z$1.string()).optional(),omit:z$1.array(z$1.string()).optional(),command:z$1.string(),packageName:z$1.string().optional(),args:z$1.array(z$1.string()).optional(),requiredEnv:z$1.array(z$1.string()).optional()}),z$1.object({type:z$1.literal("mcpSseSkill"),description:z$1.string().optional(),rule:z$1.string().optional(),pick:z$1.array(z$1.string()).optional(),omit:z$1.array(z$1.string()).optional(),endpoint:z$1.string()}),z$1.object({type:z$1.literal("interactiveSkill"),description:z$1.string().optional(),rule:z$1.string().optional(),tools:z$1.record(z$1.string(),z$1.object({description:z$1.string().optional(),inputJsonSchema:z$1.string()}))})])).optional(),delegates:z$1.array(z$1.string()).optional()})).optional()});async function Br(e,t){let o=ke.parse(e),r=t?.eventListener??se,a=t?.retrieveCheckpoint??De,i=t?.storeCheckpoint??Oe,c=new V;c.subscribe(r);let{setting:s,checkpoint:u}=o;if(s.workspace){if(!pe.isAbsolute(s.workspace))throw new Error(`Workspace path must be absolute: ${s.workspace}`);process.chdir(s.workspace);}for(await Po(s);;){let{expertToRun:h,experts:d}=await Ro(s);So(h.name,d,s);let P=await Le(h,d),R=createActor(at,{input:{setting:{...s,experts:d},initialCheckpoint:u??{id:createId(),runId:s.runId,expert:{key:s.expertKey,name:h.name,version:h.version},stepNumber:1,status:"init",messages:[],usage:H()},eventListener:r,skillManagers:P}}),f=await new Promise((S,j)=>{R.subscribe(async M=>{try{if(M.value==="Stopped"){let{checkpoint:T,skillManagers:ee}=M.context;if(!T)throw new Error("Checkpoint is undefined");await Ge(ee),S(T);}else {let T=await it[M.value](M.context);"checkpoint"in T&&await i(T.checkpoint,T.timestamp),await c.emit(T),R.send(T);}}catch(T){j(T);}}),R.start();});switch(f.status){case "completed":{if(f.delegatedBy){let{messages:S,delegatedBy:j}=f,{expert:M,toolCallId:T,toolName:ee,checkpointId:ct}=j,ce=S[S.length-1];if(ce.type!=="expertMessage")throw new Error("Delegation error: delegation result message is incorrect");let me=ce.contents.find(mt=>mt.type==="textPart");if(!me)throw new Error("Delegation error: delegation result message does not contain a text");s={...s,expertKey:M.key,input:{interactiveToolCallResult:{toolCallId:T,toolName:ee,text:me.text}}},u={...await a(s.runId,ct),id:createId(),stepNumber:f.stepNumber+1,usage:f.usage};break}return f}case "stoppedByInteractiveTool":return f;case "stoppedByDelegate":{if(!f.delegateTo)throw new Error("Delegation error: delegate to is undefined");let{expert:S,toolCallId:j,toolName:M,query:T}=f.delegateTo;s={...s,expertKey:S.key,input:{text:T}},u={id:createId(),runId:s.runId,status:"init",stepNumber:f.stepNumber+1,messages:[],expert:{key:S.key,name:S.name,version:S.version},delegatedBy:{expert:{key:h.key,name:h.name,version:h.version},toolCallId:j,toolName:M,checkpointId:f.id},usage:f.usage};break}case "stoppedByExceededMaxSteps":return f;case "stoppedByError":return f;default:throw new Error("Run stopped by unknown reason")}}}async function Ro(e){let{expertKey:t}=e,o={...e.experts},r=await ie(t,o);for(let a of r.delegates)if(!await ie(a,o))throw new Error(`Delegate ${a} not found`);return {expertToRun:r,experts:o}}function So(e,t,o){console.log("\u{1F99C} Starting Perstack \u{1F99C}"),console.log(`Expert To Run: ${e}`),console.log(`Experts: ${Object.keys(t).join(", ")}`),console.log(`Model: ${o.model}`),console.log(`Temperature: ${o.temperature}`),console.log(`Max Steps: ${o.maxSteps}`),console.log(`Max Retries: ${o.maxRetries}`),o.input.text&&console.log(`Query: ${o.input.text}`),o.input.interactiveToolCallResult&&(console.log(`Tool: ${o.input.interactiveToolCallResult.toolName}`),console.log(`Tool Call ID: ${o.input.interactiveToolCallResult.toolCallId}`),console.log(`Tool Result: ${o.input.interactiveToolCallResult.text}`));}async function Po(e){let t=O(e.runId);if(existsSync(t)){let o=pe.resolve(t,"run-setting.json"),r=JSON.parse(await readFile(o,"utf-8"));r.updatedAt=Date.now(),await writeFile(o,JSON.stringify(r,null,2),"utf-8");}else await mkdir(t,{recursive:true}),await writeFile(pe.resolve(t,"run-setting.json"),JSON.stringify(e,null,2),"utf-8");}function O(e){return `${process.cwd()}/perstack/runs/${e}`}async function _r(e){let t=ko.parse(e??"");return lt.parse(t)}var Lr=z$1.object({expertKey:z$1.string(),query:z$1.string(),options:z$1.object({config:z$1.string().optional(),model:z$1.string().optional(),temperature:z$1.string().optional().transform(e=>{if(e===void 0)return;let t=Number.parseFloat(e);if(!Number.isNaN(t))return t}),maxSteps:z$1.string().optional().transform(e=>{if(e===void 0)return;let t=Number.parseInt(e);if(!Number.isNaN(t))return t}),maxRetries:z$1.string().optional().transform(e=>{if(e===void 0)return;let t=Number.parseInt(e);if(!Number.isNaN(t))return t}),runId:z$1.string().optional()})});export{oe as CheckpointSchema,Ft as CheckpointStatusSchema,wt as ExpertMessageSchema,J as ExpertSchema,Rt as FileBinaryPartSchema,Tt as FileInlinePartSchema,kt as FileUrlPartSchema,xt as ImageBinaryPartSchema,fe as ImageInlinePartSchema,yt as ImageUrlPartSchema,Ct as InstructionMessageSchema,q as InteractiveSkillSchema,ye as InteractiveToolSchema,K as McpSseSkillSchema,G as McpStdioSkillSchema,he as MessageSchema,lt as PerstackConfigSchema,Ae as RegistryV1ExpertsGetResponseSchema,Lr as RunInputSchema,ke as RunParamsSchema,it as StateMachineLogics,A as TextPartSchema,St as ToolCallPartSchema,It as ToolMessageSchema,Pt as ToolResultPartSchema,Nt as UsageSchema,vt as UserMessageSchema,Me as attemptCompletion,Pe as callDelegate,Se as callInteractiveTool,Re as callTool,be as completeRun,Fe as continueToNextStep,k as createEvent,se as defaultEventListener,D as expertKeyRegex,Mt as expertNameRegex,$ as finishToolCall,O as getRunDir,$t as maxNameLength,_r as parseConfig,jo as parseExpertKey,Ie as resolveImageFile,we as resolvePdfFile,ve as resolveThought,Ce as resolveToolResult,re as retry,Br as run,at as runtimeStateMachine,Uo as skillNameRegex,Te as startGeneration,ne as startRun,$e as stopRunByDelegate,Ne as stopRunByExceededMaxSteps,Ee as stopRunByInteractiveTool,Et as tagNameRegex,bt as versionRegex};//# sourceMappingURL=index.js.map
+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 };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map