happy-imou-cloud 2.0.12 → 2.0.13

package/dist/{runCodex-CA58KUHf.cjs → runCodex-Cik8VzFs.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
 var node_crypto = require('node:crypto');
-var api = require('./api-B4g8VLUn.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-Dr1inhTc.cjs');
-var index = require('./index-CWom7mSf.cjs');
+var api = require('./api-DH5-IqeM.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-BjkY-oUn.cjs');
+var index = require('./index-CryJfCh5.cjs');
 require('cross-spawn');
 require('@agentclientprotocol/sdk');
 require('ps-list');
@@ -14,7 +14,7 @@ require('child_process');
 require('node:fs');
 require('node:path');
 require('node:os');
-require('./persistence-DScOANDE.cjs');
+require('./persistence-Bl3FYvwd.cjs');
 require('node:fs/promises');
 require('fs/promises');
 require('crypto');
@@ -26,8 +26,8 @@ require('tweetnacl');
 require('open');
 var React = require('react');
 var ink = require('ink');
-var ProviderSelectionHandler = require('./ProviderSelectionHandler-BCDvmifJ.cjs');
-var BaseReasoningProcessor = require('./BaseReasoningProcessor-BrKUKAOr.cjs');
+var createKeepAliveController = require('./createKeepAliveController-DO8H6d5E.cjs');
+var ConversationHistory = require('./ConversationHistory-V3VLmjJf.cjs');
 require('socket.io-client');
 require('zod');
 require('expo-server-sdk');
@@ -146,7 +146,7 @@ class CodexSession {
     this.queue = opts.messageQueue;
     this.codexArgs = opts.codexArgs;
     this.onModeChangeCallback = opts.onModeChange;
-    this.keepAliveController = ProviderSelectionHandler.createKeepAliveController({
+    this.keepAliveController = createKeepAliveController.createKeepAliveController({
       initialMode: this.mode,
       initialThinking: this.thinking,
       send: (thinking, mode) => {
@@ -316,7 +316,7 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit, title }) => {
   ));
 };
 
-class CodexPermissionHandler extends registerKillSessionHandler.BasePermissionHandler {
+class CodexPermissionHandler extends ConversationHistory.BasePermissionHandler {
   constructor(session) {
     super(session);
   }
@@ -335,13 +335,220 @@ class CodexPermissionHandler extends registerKillSessionHandler.BasePermissionHa
   }
 }
 
-class CodexSelectionHandler extends ProviderSelectionHandler.ProviderSelectionHandler {
+class ProviderSelectionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  providerLabel;
+  constructor(session, providerLabel) {
+    this.session = session;
+    this.providerLabel = providerLabel;
+    this.setupRpcHandler();
+  }
+  updateSession(newSession) {
+    this.session = newSession;
+    this.setupRpcHandler();
+  }
+  async requestSelection(request) {
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        request
+      };
+      pending.timeoutHandle = setTimeout(() => {
+        this.handleSelectionTimeout(request.id, pending);
+      }, ConversationHistory.getPendingInteractionTimeoutMs());
+      this.pendingRequests.set(request.id, pending);
+      this.session.updateAgentState((currentState) => ({
+        ...currentState,
+        requests: {
+          ...currentState.requests,
+          [request.id]: {
+            tool: "AskUserQuestion",
+            arguments: {
+              requestKind: "selection",
+              questions: [
+                {
+                  header: this.providerLabel,
+                  question: request.message,
+                  multiSelect: false,
+                  options: request.options.map((option) => ({
+                    label: option.label,
+                    description: option.description || option.optionId,
+                    optionId: option.optionId
+                  }))
+                }
+              ]
+            },
+            createdAt: Date.now(),
+            requestKind: "selection",
+            options: request.options,
+            defaultOptionId: request.defaultOptionId
+          }
+        }
+      }));
+      api.logger.debug(`[${this.providerLabel}] Selection request sent (${request.id}) with ${request.options.length} options`);
+    });
+  }
+  hasPendingRequests() {
+    return this.pendingRequests.size > 0;
+  }
+  supersedePendingRequests(reason = ConversationHistory.INTERACTION_SUPERSEDED_ERROR) {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    if (pendingSnapshot.length === 0) {
+      return 0;
+    }
+    this.pendingRequests.clear();
+    const completedAt = Date.now();
+    for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
+      pending.reject(new Error(reason));
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind !== "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt,
+          status: "canceled",
+          reason,
+          requestKind: "selection"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+    api.logger.debug(`[${this.providerLabel}] Superseded ${pendingSnapshot.length} pending selection request(s)`);
+    return pendingSnapshot.length;
+  }
+  reset(reason = "Session reset") {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    this.pendingRequests.clear();
+    for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
+      pending.reject(new Error(reason));
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind !== "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason,
+          requestKind: "selection"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+  }
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler("selection", async (response) => {
+      const pending = this.pendingRequests.get(response.id);
+      if (!pending) {
+        api.logger.debug(`[${this.providerLabel}] Selection request not found or already resolved`);
+        return;
+      }
+      this.pendingRequests.delete(response.id);
+      this.clearPendingRequestTimeout(pending);
+      pending.resolve(response);
+      this.session.updateAgentState((currentState) => {
+        const request = currentState.requests?.[response.id];
+        if (!request) {
+          return currentState;
+        }
+        const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+        return {
+          ...currentState,
+          requests: remainingRequests,
+          completedRequests: {
+            ...currentState.completedRequests,
+            [response.id]: {
+              ...request,
+              completedAt: Date.now(),
+              status: "approved",
+              requestKind: "selection",
+              selectedOptionId: response.optionId
+            }
+          }
+        };
+      });
+    });
+  }
+  clearPendingRequestTimeout(pending) {
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+      pending.timeoutHandle = void 0;
+    }
+  }
+  handleSelectionTimeout(requestId, pending) {
+    const active = this.pendingRequests.get(requestId);
+    if (!active || active !== pending) {
+      return;
+    }
+    this.pendingRequests.delete(requestId);
+    this.clearPendingRequestTimeout(active);
+    active.reject(new Error(ConversationHistory.INTERACTION_TIMED_OUT_ERROR));
+    this.session.updateAgentState((currentState) => {
+      const request = currentState.requests?.[requestId] || {
+        tool: "AskUserQuestion",
+        arguments: {
+          requestKind: "selection",
+          questions: []
+        },
+        createdAt: Date.now(),
+        requestKind: "selection",
+        options: active.request.options,
+        defaultOptionId: active.request.defaultOptionId
+      };
+      const { [requestId]: _, ...remainingRequests } = currentState.requests || {};
+      return {
+        ...currentState,
+        requests: remainingRequests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [requestId]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: ConversationHistory.INTERACTION_TIMED_OUT_ERROR,
+            requestKind: "selection"
+          }
+        }
+      };
+    });
+    this.session.sendSessionEvent({
+      type: "message",
+      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
+    });
+    api.logger.debug(`[${this.providerLabel}] Selection request timed out (${requestId})`);
+  }
+}
+
+class CodexSelectionHandler extends ProviderSelectionHandler {
   constructor(session) {
     super(session, "Codex");
   }
 }
 
-class ReasoningProcessor extends BaseReasoningProcessor.BaseReasoningProcessor {
+class ReasoningProcessor extends ConversationHistory.BaseReasoningProcessor {
   getToolName() {
     return "CodexReasoning";
   }
@@ -492,7 +699,7 @@ async function codexRemoteLauncher(session) {
   let currentThinkingMessageId = null;
   const permissionHandler = new CodexPermissionHandler(session.client);
   const selectionHandler = new CodexSelectionHandler(session.client);
-  const conversationHistory = new registerKillSessionHandler.ConversationHistory({ maxMessages: 20, maxCharacters: 5e4 });
+  const conversationHistory = new ConversationHistory.ConversationHistory({ maxMessages: 20, maxCharacters: 5e4 });
   const reasoningProcessor = new ReasoningProcessor((message) => {
     session.runtimeSession.sendCodexMessage(message);
   });
@@ -586,7 +793,7 @@ async function codexRemoteLauncher(session) {
   };
   const setupRuntimeMessageHandler = (activeRuntimeHandle) => {
     const forwardAgentMessage = (agentMessage) => {
-      registerKillSessionHandler.forwardAgentMessageToProviderSession(agentMessage, {
+      ConversationHistory.forwardAgentMessageToProviderSession(agentMessage, {
         provider: "codex",
         send: (body) => session.runtimeSession.sendCodexMessage(body),
         toolResultType: "tool-call-result"
@@ -652,7 +859,7 @@ async function codexRemoteLauncher(session) {
           return;
         }
         case "tool-result": {
-          const isError = registerKillSessionHandler.inferToolResultError(msg.result);
+          const isError = ConversationHistory.inferToolResultError(msg.result);
           const resultText = index.truncateDisplayMessage(msg.result, 200) || (isError ? "Unknown error" : "");
           messageBuffer.addMessage(
             `${isError ? "Error:" : "Result:"} ${resultText}`.trim(),
@@ -739,7 +946,7 @@ async function codexRemoteLauncher(session) {
     if (!validation.ok) {
       throw new Error(validation.errorMessage);
     }
-    const { session: nextRuntimeHandle } = await registerKillSessionHandler.launchRuntimeHandleWithFactoryResult({
+    const { session: nextRuntimeHandle } = await ConversationHistory.launchRuntimeHandleWithFactoryResult({
       provider: "codex",
       cwd: session.path,
       createBackendResult: (opts) => index.createCodexBackend({
@@ -874,7 +1081,7 @@ async function codexRemoteLauncher(session) {
         }
         conversationHistory.addUserMessage(message.message);
         await activeRuntimeHandle.sendPrompt(promptToSend);
-        await registerKillSessionHandler.waitForResponseCompleteWithAbort(activeRuntimeHandle.backend, turnSignal);
+        await ConversationHistory.waitForResponseCompleteWithAbort(activeRuntimeHandle.backend, turnSignal);
         reasoningProcessor.completeCurrent();
         shouldCommitAccumulatedResponse = true;
         shouldInjectHistoryOnNextSession = false;
@@ -959,7 +1166,7 @@ async function codexLoop(opts) {
     await codexRemoteLauncher(opts.session);
     return { type: "exit", value: 0 };
   };
-  return await ProviderSelectionHandler.runModeLoop({
+  return await createKeepAliveController.runModeLoop({
     startingMode: displayMode,
     notifyInitialMode: true,
     onModeChange: async (mode) => {
@@ -1025,7 +1232,7 @@ async function runCodex(opts) {
   }
   let sessionClient;
   let codexSession = null;
-  const { metadata, session: initialSession, reconnectionHandle } = await BaseReasoningProcessor.bootstrapManagedProviderSession({
+  const { metadata, session: initialSession, reconnectionHandle } = await ConversationHistory.bootstrapManagedProviderSession({
     api: api$1,
     sessionTag,
     flavor: "codex",

package/dist/{runCodex-ClJUgipy.mjs → runCodex-DnGz1XES.mjs}

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
-import { l as logger, b as connectionState, A as ApiClient } from './api-BxXBKBUy.mjs';
-import { B as BasePermissionHandler, h as hashObject, d as MessageBuffer, C as ConversationHistory$1, w as waitForResponseCompleteWithAbort, r as registerKillSessionHandler, l as launchRuntimeHandleWithFactoryResult, i as inferToolResultError, j as forwardAgentMessageToProviderSession, f as closeProviderSession, e as ensureManagedProviderMachine, M as MissingMachineIdError, b as MessageQueue2, s as syncControlledByUserState } from './registerKillSessionHandler-CNNguWyD.mjs';
-import { f as formatDisplayMessage, v as validateCodexAcpSpawn, d as createCodexBackend, t as truncateDisplayMessage, b as stopCaffeinate } from './index-DaAkW0VN.mjs';
+import { l as logger, b as connectionState, A as ApiClient } from './api-D1meoL-9.mjs';
+import { h as hashObject, b as MessageBuffer, r as registerKillSessionHandler, c as closeProviderSession, e as ensureManagedProviderMachine, M as MissingMachineIdError, a as MessageQueue2, s as syncControlledByUserState } from './registerKillSessionHandler-BElGmD1E.mjs';
+import { f as formatDisplayMessage, v as validateCodexAcpSpawn, d as createCodexBackend, t as truncateDisplayMessage, b as stopCaffeinate } from './index-Cxrx9m5D.mjs';
 import 'cross-spawn';
 import '@agentclientprotocol/sdk';
 import 'ps-list';
@@ -12,7 +12,7 @@ import 'child_process';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
-import './persistence-8pNEvzaq.mjs';
+import './persistence-9Iu0wGNM.mjs';
 import 'node:fs/promises';
 import 'fs/promises';
 import 'crypto';
@@ -24,8 +24,8 @@ import 'tweetnacl';
 import 'open';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { useStdout, useInput, Box, Text, render } from 'ink';
-import { c as createKeepAliveController, P as ProviderSelectionHandler, r as runModeLoop } from './ProviderSelectionHandler-BuZarTDc.mjs';
-import { B as BaseReasoningProcessor, b as bootstrapManagedProviderSession } from './BaseReasoningProcessor-DrHf5B98.mjs';
+import { c as createKeepAliveController, r as runModeLoop } from './createKeepAliveController-C5cQlDRr.mjs';
+import { B as BasePermissionHandler, g as getPendingInteractionTimeoutMs, I as INTERACTION_SUPERSEDED_ERROR, c as INTERACTION_TIMED_OUT_ERROR, a as BaseReasoningProcessor, C as ConversationHistory$1, w as waitForResponseCompleteWithAbort, l as launchRuntimeHandleWithFactoryResult, i as inferToolResultError, f as forwardAgentMessageToProviderSession, b as bootstrapManagedProviderSession } from './ConversationHistory-_ciJNIgH.mjs';
 import 'socket.io-client';
 import 'zod';
 import 'expo-server-sdk';
@@ -333,6 +333,213 @@ class CodexPermissionHandler extends BasePermissionHandler {
   }
 }
 
+class ProviderSelectionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  providerLabel;
+  constructor(session, providerLabel) {
+    this.session = session;
+    this.providerLabel = providerLabel;
+    this.setupRpcHandler();
+  }
+  updateSession(newSession) {
+    this.session = newSession;
+    this.setupRpcHandler();
+  }
+  async requestSelection(request) {
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        request
+      };
+      pending.timeoutHandle = setTimeout(() => {
+        this.handleSelectionTimeout(request.id, pending);
+      }, getPendingInteractionTimeoutMs());
+      this.pendingRequests.set(request.id, pending);
+      this.session.updateAgentState((currentState) => ({
+        ...currentState,
+        requests: {
+          ...currentState.requests,
+          [request.id]: {
+            tool: "AskUserQuestion",
+            arguments: {
+              requestKind: "selection",
+              questions: [
+                {
+                  header: this.providerLabel,
+                  question: request.message,
+                  multiSelect: false,
+                  options: request.options.map((option) => ({
+                    label: option.label,
+                    description: option.description || option.optionId,
+                    optionId: option.optionId
+                  }))
+                }
+              ]
+            },
+            createdAt: Date.now(),
+            requestKind: "selection",
+            options: request.options,
+            defaultOptionId: request.defaultOptionId
+          }
+        }
+      }));
+      logger.debug(`[${this.providerLabel}] Selection request sent (${request.id}) with ${request.options.length} options`);
+    });
+  }
+  hasPendingRequests() {
+    return this.pendingRequests.size > 0;
+  }
+  supersedePendingRequests(reason = INTERACTION_SUPERSEDED_ERROR) {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    if (pendingSnapshot.length === 0) {
+      return 0;
+    }
+    this.pendingRequests.clear();
+    const completedAt = Date.now();
+    for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
+      pending.reject(new Error(reason));
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind !== "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt,
+          status: "canceled",
+          reason,
+          requestKind: "selection"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+    logger.debug(`[${this.providerLabel}] Superseded ${pendingSnapshot.length} pending selection request(s)`);
+    return pendingSnapshot.length;
+  }
+  reset(reason = "Session reset") {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    this.pendingRequests.clear();
+    for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
+      pending.reject(new Error(reason));
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind !== "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason,
+          requestKind: "selection"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+  }
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler("selection", async (response) => {
+      const pending = this.pendingRequests.get(response.id);
+      if (!pending) {
+        logger.debug(`[${this.providerLabel}] Selection request not found or already resolved`);
+        return;
+      }
+      this.pendingRequests.delete(response.id);
+      this.clearPendingRequestTimeout(pending);
+      pending.resolve(response);
+      this.session.updateAgentState((currentState) => {
+        const request = currentState.requests?.[response.id];
+        if (!request) {
+          return currentState;
+        }
+        const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+        return {
+          ...currentState,
+          requests: remainingRequests,
+          completedRequests: {
+            ...currentState.completedRequests,
+            [response.id]: {
+              ...request,
+              completedAt: Date.now(),
+              status: "approved",
+              requestKind: "selection",
+              selectedOptionId: response.optionId
+            }
+          }
+        };
+      });
+    });
+  }
+  clearPendingRequestTimeout(pending) {
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+      pending.timeoutHandle = void 0;
+    }
+  }
+  handleSelectionTimeout(requestId, pending) {
+    const active = this.pendingRequests.get(requestId);
+    if (!active || active !== pending) {
+      return;
+    }
+    this.pendingRequests.delete(requestId);
+    this.clearPendingRequestTimeout(active);
+    active.reject(new Error(INTERACTION_TIMED_OUT_ERROR));
+    this.session.updateAgentState((currentState) => {
+      const request = currentState.requests?.[requestId] || {
+        tool: "AskUserQuestion",
+        arguments: {
+          requestKind: "selection",
+          questions: []
+        },
+        createdAt: Date.now(),
+        requestKind: "selection",
+        options: active.request.options,
+        defaultOptionId: active.request.defaultOptionId
+      };
+      const { [requestId]: _, ...remainingRequests } = currentState.requests || {};
+      return {
+        ...currentState,
+        requests: remainingRequests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [requestId]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: INTERACTION_TIMED_OUT_ERROR,
+            requestKind: "selection"
+          }
+        }
+      };
+    });
+    this.session.sendSessionEvent({
+      type: "message",
+      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
+    });
+    logger.debug(`[${this.providerLabel}] Selection request timed out (${requestId})`);
+  }
+}
+
 class CodexSelectionHandler extends ProviderSelectionHandler {
   constructor(session) {
     super(session, "Codex");

package/dist/{runGemini-dAr7Gcn8.mjs → runGemini-B8tXMHeL.mjs}

@@ -1,10 +1,10 @@
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { randomUUID } from 'node:crypto';
-import { l as logger, b as connectionState, A as ApiClient } from './api-BxXBKBUy.mjs';
-import { B as BasePermissionHandler, C as ConversationHistory$1, e as ensureManagedProviderMachine, M as MissingMachineIdError, s as syncControlledByUserState, b as MessageQueue2, h as hashObject, d as MessageBuffer, r as registerKillSessionHandler, w as waitForResponseCompleteWithAbort, f as closeProviderSession, l as launchRuntimeHandleWithFactoryResult, i as inferToolResultError, j as forwardAgentMessageToProviderSession } from './registerKillSessionHandler-CNNguWyD.mjs';
-import { g as getInitialGeminiModel, r as readGeminiLocalConfig, G as GEMINI_MODEL_ENV, s as saveGeminiModelToConfig, a as createGeminiBackend, b as stopCaffeinate } from './index-DaAkW0VN.mjs';
-import { B as BaseReasoningProcessor, b as bootstrapManagedProviderSession } from './BaseReasoningProcessor-DrHf5B98.mjs';
+import { l as logger, b as connectionState, A as ApiClient } from './api-D1meoL-9.mjs';
+import { e as ensureManagedProviderMachine, M as MissingMachineIdError, s as syncControlledByUserState, a as MessageQueue2, h as hashObject, b as MessageBuffer, r as registerKillSessionHandler, c as closeProviderSession } from './registerKillSessionHandler-BElGmD1E.mjs';
+import { g as getInitialGeminiModel, r as readGeminiLocalConfig, G as GEMINI_MODEL_ENV, s as saveGeminiModelToConfig, a as createGeminiBackend, b as stopCaffeinate } from './index-Cxrx9m5D.mjs';
+import { B as BasePermissionHandler, a as BaseReasoningProcessor, C as ConversationHistory$1, b as bootstrapManagedProviderSession, w as waitForResponseCompleteWithAbort, l as launchRuntimeHandleWithFactoryResult, i as inferToolResultError, f as forwardAgentMessageToProviderSession } from './ConversationHistory-_ciJNIgH.mjs';
 import 'cross-spawn';
 import '@agentclientprotocol/sdk';
 import 'ps-list';
@@ -13,7 +13,7 @@ import 'node:path';
 import 'node:os';
 import 'tweetnacl';
 import 'axios';
-import './persistence-8pNEvzaq.mjs';
+import './persistence-9Iu0wGNM.mjs';
 import 'open';
 import 'chalk';
 import 'fs';