@perstack/runtime 0.0.37 → 0.0.39

package/dist/src/index.js

@@ -1,24 +1,25 @@
-import { setup, assign, createActor } from 'xstate';
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createAzure } from '@ai-sdk/azure';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createOpenAI } from '@ai-sdk/openai';
-import { knownModels, stopRunByDelegate, stopRunByInteractiveTool, resolveThought, attemptCompletion, resolvePdfFile, resolveImageFile, resolveToolResult, stopRunByExceededMaxSteps, continueToNextStep, retry, completeRun, callDelegate, callInteractiveTool, callTool, startRun, startGeneration, finishToolCall, runParamsSchema, checkpointSchema } from '@perstack/core';
+import { knownModels, stopRunByDelegate, stopRunByInteractiveTool, resolveThought, attemptCompletion, resolvePdfFile, resolveImageFile, resolveToolResult, stopRunByExceededMaxSteps, continueToNextStep, retry, completeRun, callDelegate, callInteractiveTool, callTool, startRun, startGeneration, finishToolCall, runParamsSchema, createRuntimeEvent, checkpointSchema } from '@perstack/core';
 import { createOllama } from 'ollama-ai-provider-v2';
+import { existsSync } from 'fs';
+import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
+import path from 'path';
+import { createId } from '@paralleldrive/cuid2';
+import { setup, assign, createActor } from 'xstate';
+import { ApiV1Client } from '@perstack/api-client/v1';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
-import { createId } from '@paralleldrive/cuid2';
 import { generateText, tool, jsonSchema } from 'ai';
 import { dedent } from 'ts-dedent';
-import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
-import { existsSync } from 'fs';
-import path from 'path';
-import { ApiV1Client } from '@perstack/api-client/v1';
+import { createRequire } from 'module';
 
-// src/runtime-state-machine.ts
+// src/model.ts
 function getModel(modelId, providerConfig) {
   switch (providerConfig.name) {
     case "anthropic": {
@@ -76,39 +77,142 @@ function getContextWindow(providerName, modelId) {
 function calculateContextWindowUsage(usage, contextWindow) {
   return (usage.inputTokens + usage.cachedInputTokens + usage.outputTokens) / contextWindow;
 }
+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));
+}
+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));
+}
+var RunEventEmitter = class {
+  listeners = [];
+  subscribe(listener) {
+    this.listeners.push(listener);
+  }
+  async emit(event) {
+    for (const listener of this.listeners) {
+      await listener({
+        ...event,
+        id: createId(),
+        timestamp: Date.now()
+      });
+    }
+  }
+};
+async function resolveExpertToRun(expertKey, experts, clientOptions) {
+  if (experts[expertKey]) {
+    return experts[expertKey];
+  }
+  const client = new ApiV1Client({
+    baseUrl: clientOptions.perstackApiBaseUrl,
+    apiKey: clientOptions.perstackApiKey
+  });
+  const { expert } = await client.registry.experts.get({ expertKey });
+  experts[expertKey] = toRuntimeExpert(expert);
+  return experts[expertKey];
+}
+function toRuntimeExpert(expert) {
+  const skills = Object.fromEntries(
+    Object.entries(expert.skills).map(([name, skill]) => {
+      switch (skill.type) {
+        case "mcpStdioSkill":
+          return [name, { ...skill, name }];
+        case "mcpSseSkill":
+          return [name, { ...skill, name }];
+        case "interactiveSkill":
+          return [name, { ...skill, name }];
+        default: {
+          throw new Error(`Unknown skill type: ${skill.type}`);
+        }
+      }
+    })
+  );
+  return { ...expert, skills };
+}
 var SkillManager = class {
   _toolDefinitions = [];
   _initialized = false;
+  _initializing;
   name;
   type;
+  lazyInit;
   skill;
   interactiveSkill;
   expert;
   _mcpClient;
   _params;
   _env;
-  constructor(params) {
+  _runId;
+  _eventListener;
+  constructor(params, runId, eventListener) {
     this._params = params;
+    this._runId = runId;
+    this._eventListener = eventListener;
     this.type = params.type;
     switch (params.type) {
       case "mcp":
         this.name = params.skill.name;
         this.skill = params.skill;
         this._env = params.env;
+        this.lazyInit = this.skill.type === "mcpStdioSkill" && this.skill.lazyInit && this.skill.name !== "@perstack/base";
         break;
       case "interactive":
         this.name = params.interactiveSkill.name;
         this.interactiveSkill = params.interactiveSkill;
         this._env = {};
+        this.lazyInit = false;
         break;
       case "delegate":
         this.name = params.expert.name;
         this.expert = params.expert;
         this._env = {};
+        this.lazyInit = false;
         break;
     }
   }
   async init() {
+    if (this._initialized) {
+      throw new Error(`Skill ${this.name} is already initialized`);
+    }
+    if (this._initializing) {
+      throw new Error(`Skill ${this.name} is already initializing`);
+    }
+    const initPromise = this._performInit();
+    this._initializing = initPromise;
+    if (!this.lazyInit) {
+      try {
+        await initPromise;
+      } catch (error) {
+        this._initialized = false;
+        this._initializing = void 0;
+        throw error;
+      }
+    }
+  }
+  isInitialized() {
+    return this._initialized;
+  }
+  async _performInit() {
     switch (this._params.type) {
       case "mcp": {
         await this._initMcpSkill(this._params);
@@ -123,8 +227,13 @@ var SkillManager = class {
         break;
       }
     }
+    this._initialized = true;
+    this._initializing = void 0;
   }
   async _initMcpSkill(params) {
+    if (this.isInitialized()) {
+      throw new Error(`Skill ${params.skill.name} is already initialized`);
+    }
     this._mcpClient = new Client({
       name: `${params.skill.name}-mcp-client`,
       version: "1.0.0"
@@ -143,8 +252,16 @@ var SkillManager = class {
           env[envName] = this._env[envName];
         }
         const { command, args } = this._getCommandArgs(params.skill);
-        const transport = new StdioClientTransport({ command, args, env });
+        const transport = new StdioClientTransport({ command, args, env, stderr: "ignore" });
         await this._mcpClient.connect(transport);
+        if (this._eventListener) {
+          const serverInfo = this._mcpClient.getServerVersion();
+          const event = createRuntimeEvent("skillConnected", this._runId, {
+            skillName: params.skill.name,
+            serverInfo: serverInfo ? { name: serverInfo.name, version: serverInfo.version } : void 0
+          });
+          this._eventListener(event);
+        }
         break;
       }
       case "mcpSseSkill": {
@@ -164,7 +281,6 @@ var SkillManager = class {
       inputSchema: tool2.inputSchema,
       interactive: false
     }));
-    this._initialized = true;
   }
   _getCommandArgs(skill) {
     const { name, command, packageName, args } = skill;
@@ -183,6 +299,9 @@ var SkillManager = class {
     return { command, args: newArgs };
   }
   async _initInteractiveSkill(params) {
+    if (this.isInitialized()) {
+      throw new Error(`Skill ${params.interactiveSkill.name} is already initialized`);
+    }
     this._toolDefinitions = Object.values(params.interactiveSkill.tools).map((tool2) => ({
       skillName: params.interactiveSkill.name,
       name: tool2.name,
@@ -190,9 +309,11 @@ var SkillManager = class {
       inputSchema: JSON.parse(tool2.inputJsonSchema),
       interactive: true
     }));
-    this._initialized = true;
   }
   async _initDelegate(params) {
+    if (this.isInitialized()) {
+      throw new Error(`Skill ${params.expert.name} is already initialized`);
+    }
     this._toolDefinitions = [
       {
         skillName: params.expert.name,
@@ -206,16 +327,24 @@ var SkillManager = class {
         interactive: false
       }
     ];
-    this._initialized = true;
   }
   async close() {
     if (this._mcpClient) {
       await this._mcpClient.close();
+      if (this._eventListener && this.skill) {
+        const event = createRuntimeEvent("skillDisconnected", this._runId, {
+          skillName: this.skill.name
+        });
+        this._eventListener(event);
+      }
     }
   }
   async getToolDefinitions() {
-    if (!this._initialized) {
-      throw new Error(`${this.name} is not initialized`);
+    if (!this.isInitialized() && !this.lazyInit) {
+      throw new Error(`Skill ${this.name} is not initialized`);
+    }
+    if (!this.isInitialized() && this.lazyInit) {
+      return [];
     }
     if (this._params.type === "mcp") {
       const omit = this._params.skill.omit ?? [];
@@ -227,7 +356,7 @@ var SkillManager = class {
   async callTool(toolName, input) {
     switch (this._params.type) {
       case "mcp": {
-        if (!this._mcpClient) {
+        if (!this.isInitialized() || !this._mcpClient) {
           throw new Error(`${this.name} is not initialized`);
         }
         try {
@@ -314,8 +443,8 @@ var SkillManager = class {
     throw new Error(`Unsupported resource type: ${JSON.stringify(resource)}`);
   }
 };
-async function getSkillManagers(expert, experts, setting) {
-  const { perstackBaseSkillCommand, env } = setting;
+async function getSkillManagers(expert, experts, setting, eventListener) {
+  const { perstackBaseSkillCommand, env, runId } = setting;
   const skillManagers = {};
   const { skills } = expert;
   if (!skills["@perstack/base"]) {
@@ -334,23 +463,32 @@ async function getSkillManagers(expert, experts, setting) {
           skill.command = overrideCommand;
           skill.packageName = void 0;
           skill.args = overrideArgs;
+          skill.lazyInit = false;
         }
       }
-      const skillManager = new SkillManager({
-        type: "mcp",
-        skill,
-        env
-      });
+      const skillManager = new SkillManager(
+        {
+          type: "mcp",
+          skill,
+          env
+        },
+        runId,
+        eventListener
+      );
       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
-      });
+      const skillManager = new SkillManager(
+        {
+          type: "interactive",
+          interactiveSkill
+        },
+        runId,
+        eventListener
+      );
       await skillManager.init();
       return skillManager;
     })
@@ -358,10 +496,14 @@ async function getSkillManagers(expert, experts, setting) {
   const delegateSkillManagers = await Promise.all(
     expert.delegates.map(async (delegateExpertName) => {
       const delegate = experts[delegateExpertName];
-      const skillManager = new SkillManager({
-        type: "delegate",
-        expert: delegate
-      });
+      const skillManager = new SkillManager(
+        {
+          type: "delegate",
+          expert: delegate
+        },
+        runId,
+        eventListener
+      );
       await skillManager.init();
       return skillManager;
     })
@@ -1579,266 +1721,20 @@ var StateMachineLogics = {
   CallingDelegate: callingDelegateLogic,
   FinishingStep: finishingStepLogic
 };
-async function defaultRetrieveCheckpoint(runId, checkpointId) {
-  const runDir = getRunDir(runId);
-  const checkpointFiles = await readdir(runDir, { withFileTypes: true }).then(
-    (files) => files.filter((file) => file.isFile() && file.name.startsWith("checkpoint-"))
-  );
-  const checkpointFile = checkpointFiles.find((file) => file.name.endsWith(`-${checkpointId}.json`));
-  if (!checkpointFile) {
-    throw new Error(`checkpoint not found: ${runId} ${checkpointId}`);
+var getVersion = () => {
+  if (typeof __RUNTIME_VERSION__ !== "undefined") {
+    return __RUNTIME_VERSION__;
   }
-  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.37"};
-
-// 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}`;
+  const require2 = createRequire(import.meta.url);
+  const pkg = require2("../package.json");
+  return pkg.version;
 };
-async function defaultEventListener(e) {
-  await defaultStoreEvent(e);
-  switch (e.type) {
-    case "startRun": {
-      log(`${header(e)} Perstack@${package_default.version} started`);
-      break;
-    }
-    case "startGeneration": {
-      log(`${header(e)} Generating tool call`);
-      break;
-    }
-    case "retry": {
-      log(`${header(e)} Retrying tool call generation`);
-      debug(e.reason);
-      break;
-    }
-    case "callTool": {
-      log(`${header(e)} Calling tool`);
-      if (e.toolCall.skillName === "@perstack/base") {
-        switch (e.toolCall.toolName) {
-          case "think": {
-            const thought = e.toolCall.args.thought;
-            log(`${header(e)} Thought Updated:`);
-            debug(thought);
-            break;
-          }
-          case "readPdfFile": {
-            const path2 = e.toolCall.args.path;
-            log(`${header(e)} Reading PDF: ${path2}`);
-            break;
-          }
-          case "readImageFile": {
-            const path2 = e.toolCall.args.path;
-            log(`${header(e)} Reading Image: ${path2}`);
-            break;
-          }
-          default: {
-            log(`${header(e)} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
-            debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
-            break;
-          }
-        }
-      } else {
-        log(`${header(e)} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
-        debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
-      }
-      break;
-    }
-    case "callInteractiveTool": {
-      log(`${header(e)} Calling interactive tool`);
-      log(`${header(e)} Tool: ${e.toolCall.skillName}/${e.toolCall.toolName}`);
-      debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
-      break;
-    }
-    case "callDelegate": {
-      log(`${header(e)} Calling delegate`);
-      log(`${header(e)} Tool: ${e.toolCall.toolName}`);
-      debug(`${header(e)} Args: ${JSON.stringify(e.toolCall.args, null, 2)}`);
-      break;
-    }
-    case "resolveToolResult": {
-      log(`${header(e)} Resolved Tool Result`);
-      if (e.toolResult.skillName === "@perstack/base") {
-        switch (e.toolResult.toolName) {
-          case "todo": {
-            const text = e.toolResult.result.find((r) => r.type === "textPart")?.text;
-            const { todos } = JSON.parse(text ?? "{}");
-            log(`${header(e)} Todo:`);
-            for (const todo of todos) {
-              debug(`${todo.completed ? "[x]" : "[ ]"} ${todo.id}: ${todo.title}`);
-            }
-            break;
-          }
-          default: {
-            log(`${header(e)} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`);
-            debug(`${header(e)} Result: ${JSON.stringify(e.toolResult.result, null, 2)}`);
-            break;
-          }
-        }
-      } else {
-        log(`${header(e)} Tool: ${e.toolResult.skillName}/${e.toolResult.toolName}`);
-        debug(`${header(e)} Result: ${JSON.stringify(e.toolResult.result, null, 2)}`);
-      }
-      break;
-    }
-    case "resolveThought": {
-      log(`${header(e)} Resolved Thought:`, e.toolResult);
-      break;
-    }
-    case "resolvePdfFile": {
-      log(`${header(e)} Resolved PDF:`, e.toolResult);
-      break;
-    }
-    case "resolveImageFile": {
-      log(`${header(e)} Resolved Image:`, e.toolResult);
-      break;
-    }
-    case "attemptCompletion": {
-      log(`${header(e)} Attempting completion`);
-      break;
-    }
-    case "completeRun": {
-      logUsage(e);
-      log(`${header(e)} Completing run`);
-      debug(`${header(e)} Result:`, e.text);
-      break;
-    }
-    case "stopRunByInteractiveTool": {
-      logUsage(e);
-      log(`${header(e)} Stopping run by interactive tool`);
-      break;
-    }
-    case "stopRunByDelegate": {
-      logUsage(e);
-      log(`${header(e)} Stopping run by delegate`);
-      break;
-    }
-    case "stopRunByExceededMaxSteps": {
-      logUsage(e);
-      log(`${header(e)} Stopping run by exceeded max steps`);
-      break;
-    }
-    case "continueToNextStep": {
-      logUsage(e);
-      log(`${header(e)} Continuing to next step`);
-      if (e.checkpoint.contextWindowUsage) {
-        log(`${header(e)} Context window usage: ${e.checkpoint.contextWindowUsage.toFixed(2)}%`);
-      }
-      break;
-    }
-  }
-}
-function logUsage(e) {
-  const usageByStep = [
-    `In: ${e.step.usage.inputTokens.toLocaleString()}`,
-    `Reasoning: ${e.step.usage.reasoningTokens.toLocaleString()}`,
-    `Out: ${e.step.usage.outputTokens.toLocaleString()}`,
-    `Total: ${e.step.usage.totalTokens.toLocaleString()}`,
-    `Cache-read: ${e.step.usage.cachedInputTokens.toLocaleString()}`
-  ].join(", ");
-  const usageByRun = [
-    `In: ${e.checkpoint.usage.inputTokens.toLocaleString()}`,
-    `Reasoning: ${e.checkpoint.usage.reasoningTokens.toLocaleString()}`,
-    `Out: ${e.checkpoint.usage.outputTokens.toLocaleString()}`,
-    `Total: ${e.checkpoint.usage.totalTokens.toLocaleString()}`,
-    `Cache-read: ${e.checkpoint.usage.cachedInputTokens.toLocaleString()}`
-  ].join(", ");
-  log(`${header(e)} Tokens usage by step: ${usageByStep}`);
-  log(`${header(e)} Tokens usage by run: ${usageByRun}`);
-}
-var RunEventEmitter = class {
-  listeners = [];
-  subscribe(listener) {
-    this.listeners.push(listener);
-  }
-  async emit(event) {
-    for (const listener of this.listeners) {
-      await listener({
-        ...event,
-        id: createId(),
-        timestamp: Date.now()
-      });
-    }
-  }
-};
-async function resolveExpertToRun(expertKey, experts, clientOptions) {
-  console.log(experts);
-  if (experts[expertKey]) {
-    return experts[expertKey];
-  }
-  const client = new ApiV1Client({
-    baseUrl: clientOptions.perstackApiBaseUrl,
-    apiKey: clientOptions.perstackApiKey
-  });
-  const { expert } = await client.registry.experts.get({ expertKey });
-  experts[expertKey] = toRuntimeExpert(expert);
-  return experts[expertKey];
-}
-function toRuntimeExpert(expert) {
-  const skills = Object.fromEntries(
-    Object.entries(expert.skills).map(([name, skill]) => {
-      switch (skill.type) {
-        case "mcpStdioSkill":
-          return [
-            name,
-            {
-              ...skill,
-              name
-            }
-          ];
-        case "mcpSseSkill":
-          return [
-            name,
-            {
-              ...skill,
-              name
-            }
-          ];
-        case "interactiveSkill":
-          return [
-            name,
-            {
-              ...skill,
-              name
-            }
-          ];
-      }
-    })
-  );
-  return {
-    ...expert,
-    skills
-  };
-}
+var RUNTIME_VERSION = getVersion();
 
 // src/runtime.ts
 async function run(runInput, options) {
   const runParams = runParamsSchema.parse(runInput);
-  const eventListener = options?.eventListener ?? defaultEventListener;
+  const eventListener = getEventListener(options);
   const retrieveCheckpoint = options?.retrieveCheckpoint ?? defaultRetrieveCheckpoint;
   const storeCheckpoint = options?.storeCheckpoint ?? defaultStoreCheckpoint;
   const eventEmitter = new RunEventEmitter();
@@ -1854,8 +1750,27 @@ async function run(runInput, options) {
   await storeRunSetting(setting);
   while (true) {
     const { expertToRun, experts } = await setupExperts(setting);
-    printRunSetting(expertToRun.name, experts, setting);
-    const skillManagers = await getSkillManagers(expertToRun, experts, setting);
+    if (options?.eventListener) {
+      const initEvent = createRuntimeEvent("initializeRuntime", setting.runId, {
+        runtimeVersion: RUNTIME_VERSION,
+        expertName: expertToRun.name,
+        experts: Object.keys(experts),
+        model: setting.model,
+        temperature: setting.temperature,
+        maxSteps: setting.maxSteps,
+        maxRetries: setting.maxRetries,
+        timeout: setting.timeout,
+        query: setting.input.text,
+        interactiveToolCall: setting.input.interactiveToolCallResult
+      });
+      options.eventListener(initEvent);
+    }
+    const skillManagers = await getSkillManagers(
+      expertToRun,
+      experts,
+      setting,
+      options?.eventListener
+    );
     const runActor = createActor(runtimeStateMachine, {
       input: {
         setting: {
@@ -2021,23 +1936,14 @@ async function setupExperts(setting) {
   }
   return { expertToRun, experts };
 }
-function printRunSetting(expertName, experts, setting) {
-  console.log("Starting Perstack");
-  console.log(`Expert To Run: ${expertName}`);
-  console.log(`Experts: ${Object.keys(experts).join(", ")}`);
-  console.log(`Model: ${setting.model}`);
-  console.log(`Temperature: ${setting.temperature}`);
-  console.log(`Max Steps: ${setting.maxSteps}`);
-  console.log(`Max Retries: ${setting.maxRetries}`);
-  console.log(`Timeout: ${setting.timeout}`);
-  if (setting.input.text) {
-    console.log(`Query: ${setting.input.text}`);
-  }
-  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}`);
-  }
+function getEventListener(options) {
+  const listener = options?.eventListener ?? ((e) => console.log(JSON.stringify(e)));
+  return async (event) => {
+    if ("stepNumber" in event) {
+      await defaultStoreEvent(event);
+    }
+    listener(event);
+  };
 }
 async function storeRunSetting(setting) {
   const runDir = getRunDir(setting.runId);
@@ -2045,20 +1951,16 @@ async function storeRunSetting(setting) {
     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");
+    await writeFile(runSettingPath, JSON.stringify(runSetting), "utf-8");
   } else {
     await mkdir(runDir, { recursive: true });
-    await writeFile(
-      path.resolve(runDir, "run-setting.json"),
-      JSON.stringify(setting, null, 2),
-      "utf-8"
-    );
+    await writeFile(path.resolve(runDir, "run-setting.json"), JSON.stringify(setting), "utf-8");
   }
 }
 function getRunDir(runId) {
   return `${process.cwd()}/perstack/runs/${runId}`;
 }
 
-export { StateMachineLogics, calculateContextWindowUsage, defaultEventListener, getContextWindow, getModel, getRunDir, run, runtimeStateMachine };
+export { RUNTIME_VERSION, StateMachineLogics, calculateContextWindowUsage, getContextWindow, getModel, getRunDir, run, runtimeStateMachine };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map