happy-imou-cloud 2.0.9 → 2.0.11

package/dist/ProviderSelectionHandler-BljOLMQn.mjs

@@ -0,0 +1,261 @@
+import { l as logger } from './api-BcWf5v4i.mjs';
+import { g as getPendingInteractionTimeoutMs, I as INTERACTION_SUPERSEDED_ERROR, a as INTERACTION_TIMED_OUT_ERROR } from './registerKillSessionHandler-Dxwg4L4J.mjs';
+
+async function runModeLoop(opts) {
+  let currentMode = opts.startingMode;
+  if (opts.notifyInitialMode) {
+    await opts.onModeChange?.(currentMode);
+  }
+  while (true) {
+    opts.onIteration?.(currentMode);
+    const result = await opts.launchers[currentMode]();
+    if (result.type === "exit") {
+      return result.value;
+    }
+    currentMode = result.mode;
+    await opts.onModeChange?.(currentMode);
+  }
+}
+
+function createKeepAliveController(opts) {
+  let thinking = opts.initialThinking ?? false;
+  let mode = opts.initialMode;
+  let disposed = false;
+  const sync = () => {
+    if (disposed) {
+      return;
+    }
+    opts.send(thinking, mode);
+  };
+  sync();
+  const intervalId = setInterval(sync, opts.intervalMs ?? 2e3);
+  return {
+    dispose: () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      clearInterval(intervalId);
+    },
+    getMode: () => mode,
+    getThinking: () => thinking,
+    setMode: (nextMode) => {
+      mode = nextMode;
+      sync();
+    },
+    setThinking: (nextThinking) => {
+      thinking = nextThinking;
+      sync();
+    },
+    sync
+  };
+}
+
+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})`);
+  }
+}
+
+export { ProviderSelectionHandler as P, createKeepAliveController as c, runModeLoop as r };

package/dist/ProviderSelectionHandler-DBGobhGZ.cjs

@@ -0,0 +1,265 @@
+'use strict';
+
+var api = require('./api-Ye-rPX6s.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-CH6yN0eG.cjs');
+
+async function runModeLoop(opts) {
+  let currentMode = opts.startingMode;
+  if (opts.notifyInitialMode) {
+    await opts.onModeChange?.(currentMode);
+  }
+  while (true) {
+    opts.onIteration?.(currentMode);
+    const result = await opts.launchers[currentMode]();
+    if (result.type === "exit") {
+      return result.value;
+    }
+    currentMode = result.mode;
+    await opts.onModeChange?.(currentMode);
+  }
+}
+
+function createKeepAliveController(opts) {
+  let thinking = opts.initialThinking ?? false;
+  let mode = opts.initialMode;
+  let disposed = false;
+  const sync = () => {
+    if (disposed) {
+      return;
+    }
+    opts.send(thinking, mode);
+  };
+  sync();
+  const intervalId = setInterval(sync, opts.intervalMs ?? 2e3);
+  return {
+    dispose: () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      clearInterval(intervalId);
+    },
+    getMode: () => mode,
+    getThinking: () => thinking,
+    setMode: (nextMode) => {
+      mode = nextMode;
+      sync();
+    },
+    setThinking: (nextThinking) => {
+      thinking = nextThinking;
+      sync();
+    },
+    sync
+  };
+}
+
+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);
+      }, registerKillSessionHandler.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 = registerKillSessionHandler.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(registerKillSessionHandler.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: registerKillSessionHandler.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})`);
+  }
+}
+
+exports.ProviderSelectionHandler = ProviderSelectionHandler;
+exports.createKeepAliveController = createKeepAliveController;
+exports.runModeLoop = runModeLoop;