happy-imou-cloud 2.0.9 → 2.0.11

package/dist/BaseReasoningProcessor-5ACv9gKu.mjs

@@ -0,0 +1,320 @@
+import { p as publishSessionRegistration } from './index-DnsqY6I_.mjs';
+import { s as startOfflineReconnection, c as configuration, i as isAuthenticationRequiredError, l as logger } from './api-BcWf5v4i.mjs';
+import { c as createSessionMetadata } from './registerKillSessionHandler-Dxwg4L4J.mjs';
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+
+function createOfflineSessionStub(sessionTag) {
+  const emitter = new EventEmitter();
+  let metadata = null;
+  let agentState = null;
+  const stub = {
+    sessionId: `offline-${sessionTag}`,
+    sendCodexMessage: () => {
+    },
+    sendAgentMessage: () => {
+    },
+    sendClaudeSessionMessage: () => {
+    },
+    keepAlive: () => {
+    },
+    sendSessionEvent: () => {
+    },
+    sendSessionDeath: () => {
+    },
+    updateLifecycleState: () => {
+    },
+    requestControlTransfer: async () => {
+    },
+    flush: async () => {
+    },
+    close: async () => {
+    },
+    updateMetadata: (handler) => {
+      metadata = handler(metadata || {});
+      emitter.emit("metadata-updated", metadata);
+    },
+    updateAgentState: (handler) => {
+      agentState = handler(agentState || {});
+      emitter.emit("agent-state-updated", agentState);
+    },
+    getMetadataSnapshot: () => metadata,
+    getAgentStateSnapshot: () => agentState,
+    waitForMetadataUpdate: async () => metadata,
+    onUserMessage: () => {
+    },
+    rpcHandlerManager: {
+      registerHandler: () => {
+      }
+    },
+    on: emitter.on.bind(emitter),
+    once: emitter.once.bind(emitter),
+    off: emitter.off.bind(emitter),
+    emit: emitter.emit.bind(emitter)
+  };
+  return stub;
+}
+
+function setupOfflineReconnection(opts) {
+  const { api, sessionTag, metadata, state, response, onSessionSwap } = opts;
+  let session;
+  let reconnectionHandle = null;
+  if (!response) {
+    session = createOfflineSessionStub(sessionTag);
+    reconnectionHandle = startOfflineReconnection({
+      serverUrl: configuration.serverUrl,
+      onReconnected: async () => {
+        const resp = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+        if (!resp) throw new Error("Server unavailable");
+        const realSession = api.sessionSyncClient(resp);
+        onSessionSwap(realSession);
+        return realSession;
+      },
+      onNotify: (msg) => {
+        console.log(msg);
+      }
+    });
+    return { session, reconnectionHandle, isOffline: true };
+  } else {
+    session = api.sessionSyncClient(response);
+    return { session, reconnectionHandle: null, isOffline: false };
+  }
+}
+
+async function bootstrapManagedProviderSession(opts) {
+  const { state, metadata } = createSessionMetadata({
+    flavor: opts.flavor,
+    machineId: opts.machineId,
+    startedBy: opts.startedBy
+  });
+  let response = null;
+  try {
+    response = await opts.api.getOrCreateSession({
+      tag: opts.sessionTag,
+      metadata,
+      state
+    });
+  } catch (error) {
+    if (!isAuthenticationRequiredError(error)) {
+      throw error;
+    }
+    logger.debug(opts.authFallbackLogMessage);
+  }
+  const { session, reconnectionHandle } = setupOfflineReconnection({
+    api: opts.api,
+    sessionTag: opts.sessionTag,
+    metadata,
+    state,
+    response,
+    onSessionSwap: (newSession) => {
+      opts.onSessionSwap?.(newSession, metadata);
+      void publishSessionRegistration(newSession.sessionId, metadata);
+    }
+  });
+  if (response) {
+    await publishSessionRegistration(response.id, metadata);
+  }
+  return {
+    state,
+    metadata,
+    response,
+    session,
+    reconnectionHandle
+  };
+}
+
+class BaseReasoningProcessor {
+  accumulator = "";
+  inTitleCapture = false;
+  titleBuffer = "";
+  contentBuffer = "";
+  hasTitle = false;
+  currentCallId = null;
+  toolCallStarted = false;
+  currentTitle = null;
+  onMessage = null;
+  constructor(onMessage) {
+    this.onMessage = onMessage || null;
+    this.reset();
+  }
+  /**
+   * Set the message callback for sending messages directly.
+   */
+  setMessageCallback(callback) {
+    this.onMessage = callback;
+  }
+  /**
+   * Process a reasoning section break - indicates a new reasoning section is starting.
+   */
+  handleSectionBreak() {
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+    logger.debug(`${this.getLogPrefix()} Section break - reset state`);
+  }
+  /**
+   * Process a reasoning delta/chunk and accumulate content.
+   */
+  processInput(input) {
+    this.accumulator += input;
+    if (!this.inTitleCapture && !this.hasTitle && !this.contentBuffer) {
+      if (this.accumulator.startsWith("**")) {
+        this.inTitleCapture = true;
+        this.titleBuffer = this.accumulator.substring(2);
+        logger.debug(`${this.getLogPrefix()} Started title capture`);
+      } else if (this.accumulator.length > 0) {
+        this.contentBuffer = this.accumulator;
+      }
+    } else if (this.inTitleCapture) {
+      this.titleBuffer = this.accumulator.substring(2);
+      const titleEndIndex = this.titleBuffer.indexOf("**");
+      if (titleEndIndex !== -1) {
+        const title = this.titleBuffer.substring(0, titleEndIndex);
+        const afterTitle = this.titleBuffer.substring(titleEndIndex + 2);
+        this.hasTitle = true;
+        this.inTitleCapture = false;
+        this.currentTitle = title;
+        this.contentBuffer = afterTitle;
+        this.currentCallId = randomUUID();
+        logger.debug(`${this.getLogPrefix()} Title captured: "${title}"`);
+        this.sendToolCallStart(title);
+      }
+    } else if (this.hasTitle) {
+      const titleStartIndex = this.accumulator.indexOf("**");
+      if (titleStartIndex !== -1) {
+        this.contentBuffer = this.accumulator.substring(
+          titleStartIndex + 2 + this.currentTitle.length + 2
+        );
+      }
+    } else {
+      this.contentBuffer = this.accumulator;
+    }
+  }
+  /**
+   * Send the tool call start message.
+   */
+  sendToolCallStart(title) {
+    if (!this.currentCallId || this.toolCallStarted) {
+      return;
+    }
+    const toolCall = {
+      type: "tool-call",
+      name: this.getToolName(),
+      callId: this.currentCallId,
+      input: {
+        title
+      },
+      id: randomUUID()
+    };
+    logger.debug(`${this.getLogPrefix()} Sending tool call start for: "${title}"`);
+    this.onMessage?.(toolCall);
+    this.toolCallStarted = true;
+  }
+  /**
+   * Complete the reasoning section.
+   * Returns true if reasoning was completed, false if there was nothing to complete.
+   */
+  completeReasoning(fullText) {
+    const text = fullText ?? this.accumulator;
+    if (!text.trim() && !this.toolCallStarted) {
+      logger.debug(`${this.getLogPrefix()} Complete called but no content accumulated, skipping`);
+      return false;
+    }
+    let title;
+    let content = text;
+    if (text.startsWith("**")) {
+      const titleEndIndex = text.indexOf("**", 2);
+      if (titleEndIndex !== -1) {
+        title = text.substring(2, titleEndIndex);
+        content = text.substring(titleEndIndex + 2).trim();
+      }
+    }
+    logger.debug(`${this.getLogPrefix()} Complete reasoning - Title: "${title}", Has content: ${content.length > 0}`);
+    if (title && !this.toolCallStarted) {
+      this.currentCallId = this.currentCallId || randomUUID();
+      this.sendToolCallStart(title);
+    }
+    if (this.toolCallStarted && this.currentCallId) {
+      const toolResult = {
+        type: "tool-call-result",
+        callId: this.currentCallId,
+        output: {
+          content,
+          status: "completed"
+        },
+        id: randomUUID()
+      };
+      logger.debug(`${this.getLogPrefix()} Sending tool call result`);
+      this.onMessage?.(toolResult);
+    } else if (content.trim()) {
+      const reasoningMessage = {
+        type: "reasoning",
+        message: content,
+        id: randomUUID()
+      };
+      logger.debug(`${this.getLogPrefix()} Sending reasoning message`);
+      this.onMessage?.(reasoningMessage);
+    }
+    this.resetState();
+    return true;
+  }
+  /**
+   * Abort the current reasoning section.
+   */
+  abort() {
+    logger.debug(`${this.getLogPrefix()} Abort called`);
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+  }
+  /**
+   * Reset the processor state.
+   */
+  reset() {
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+  }
+  /**
+   * Finish current tool call if one is in progress.
+   */
+  finishCurrentToolCall(status) {
+    if (this.toolCallStarted && this.currentCallId) {
+      const toolResult = {
+        type: "tool-call-result",
+        callId: this.currentCallId,
+        output: {
+          content: this.contentBuffer || "",
+          status
+        },
+        id: randomUUID()
+      };
+      logger.debug(`${this.getLogPrefix()} Sending tool call result with status: ${status}`);
+      this.onMessage?.(toolResult);
+    }
+  }
+  /**
+   * Reset internal state.
+   */
+  resetState() {
+    this.accumulator = "";
+    this.inTitleCapture = false;
+    this.titleBuffer = "";
+    this.contentBuffer = "";
+    this.hasTitle = false;
+    this.currentCallId = null;
+    this.toolCallStarted = false;
+    this.currentTitle = null;
+  }
+  /**
+   * Get the current call ID for tool result matching.
+   */
+  getCurrentCallId() {
+    return this.currentCallId;
+  }
+  /**
+   * Check if a tool call has been started.
+   */
+  hasStartedToolCall() {
+    return this.toolCallStarted;
+  }
+}
+
+export { BaseReasoningProcessor as B, bootstrapManagedProviderSession as b };

package/dist/BaseReasoningProcessor-COrRWyn0.cjs

@@ -0,0 +1,323 @@
+'use strict';
+
+var index = require('./index-J7QKJ8lc.cjs');
+var api = require('./api-Ye-rPX6s.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-CH6yN0eG.cjs');
+var node_events = require('node:events');
+var node_crypto = require('node:crypto');
+
+function createOfflineSessionStub(sessionTag) {
+  const emitter = new node_events.EventEmitter();
+  let metadata = null;
+  let agentState = null;
+  const stub = {
+    sessionId: `offline-${sessionTag}`,
+    sendCodexMessage: () => {
+    },
+    sendAgentMessage: () => {
+    },
+    sendClaudeSessionMessage: () => {
+    },
+    keepAlive: () => {
+    },
+    sendSessionEvent: () => {
+    },
+    sendSessionDeath: () => {
+    },
+    updateLifecycleState: () => {
+    },
+    requestControlTransfer: async () => {
+    },
+    flush: async () => {
+    },
+    close: async () => {
+    },
+    updateMetadata: (handler) => {
+      metadata = handler(metadata || {});
+      emitter.emit("metadata-updated", metadata);
+    },
+    updateAgentState: (handler) => {
+      agentState = handler(agentState || {});
+      emitter.emit("agent-state-updated", agentState);
+    },
+    getMetadataSnapshot: () => metadata,
+    getAgentStateSnapshot: () => agentState,
+    waitForMetadataUpdate: async () => metadata,
+    onUserMessage: () => {
+    },
+    rpcHandlerManager: {
+      registerHandler: () => {
+      }
+    },
+    on: emitter.on.bind(emitter),
+    once: emitter.once.bind(emitter),
+    off: emitter.off.bind(emitter),
+    emit: emitter.emit.bind(emitter)
+  };
+  return stub;
+}
+
+function setupOfflineReconnection(opts) {
+  const { api: api$1, sessionTag, metadata, state, response, onSessionSwap } = opts;
+  let session;
+  let reconnectionHandle = null;
+  if (!response) {
+    session = createOfflineSessionStub(sessionTag);
+    reconnectionHandle = api.startOfflineReconnection({
+      serverUrl: api.configuration.serverUrl,
+      onReconnected: async () => {
+        const resp = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
+        if (!resp) throw new Error("Server unavailable");
+        const realSession = api$1.sessionSyncClient(resp);
+        onSessionSwap(realSession);
+        return realSession;
+      },
+      onNotify: (msg) => {
+        console.log(msg);
+      }
+    });
+    return { session, reconnectionHandle, isOffline: true };
+  } else {
+    session = api$1.sessionSyncClient(response);
+    return { session, reconnectionHandle: null, isOffline: false };
+  }
+}
+
+async function bootstrapManagedProviderSession(opts) {
+  const { state, metadata } = registerKillSessionHandler.createSessionMetadata({
+    flavor: opts.flavor,
+    machineId: opts.machineId,
+    startedBy: opts.startedBy
+  });
+  let response = null;
+  try {
+    response = await opts.api.getOrCreateSession({
+      tag: opts.sessionTag,
+      metadata,
+      state
+    });
+  } catch (error) {
+    if (!api.isAuthenticationRequiredError(error)) {
+      throw error;
+    }
+    api.logger.debug(opts.authFallbackLogMessage);
+  }
+  const { session, reconnectionHandle } = setupOfflineReconnection({
+    api: opts.api,
+    sessionTag: opts.sessionTag,
+    metadata,
+    state,
+    response,
+    onSessionSwap: (newSession) => {
+      opts.onSessionSwap?.(newSession, metadata);
+      void index.publishSessionRegistration(newSession.sessionId, metadata);
+    }
+  });
+  if (response) {
+    await index.publishSessionRegistration(response.id, metadata);
+  }
+  return {
+    state,
+    metadata,
+    response,
+    session,
+    reconnectionHandle
+  };
+}
+
+class BaseReasoningProcessor {
+  accumulator = "";
+  inTitleCapture = false;
+  titleBuffer = "";
+  contentBuffer = "";
+  hasTitle = false;
+  currentCallId = null;
+  toolCallStarted = false;
+  currentTitle = null;
+  onMessage = null;
+  constructor(onMessage) {
+    this.onMessage = onMessage || null;
+    this.reset();
+  }
+  /**
+   * Set the message callback for sending messages directly.
+   */
+  setMessageCallback(callback) {
+    this.onMessage = callback;
+  }
+  /**
+   * Process a reasoning section break - indicates a new reasoning section is starting.
+   */
+  handleSectionBreak() {
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+    api.logger.debug(`${this.getLogPrefix()} Section break - reset state`);
+  }
+  /**
+   * Process a reasoning delta/chunk and accumulate content.
+   */
+  processInput(input) {
+    this.accumulator += input;
+    if (!this.inTitleCapture && !this.hasTitle && !this.contentBuffer) {
+      if (this.accumulator.startsWith("**")) {
+        this.inTitleCapture = true;
+        this.titleBuffer = this.accumulator.substring(2);
+        api.logger.debug(`${this.getLogPrefix()} Started title capture`);
+      } else if (this.accumulator.length > 0) {
+        this.contentBuffer = this.accumulator;
+      }
+    } else if (this.inTitleCapture) {
+      this.titleBuffer = this.accumulator.substring(2);
+      const titleEndIndex = this.titleBuffer.indexOf("**");
+      if (titleEndIndex !== -1) {
+        const title = this.titleBuffer.substring(0, titleEndIndex);
+        const afterTitle = this.titleBuffer.substring(titleEndIndex + 2);
+        this.hasTitle = true;
+        this.inTitleCapture = false;
+        this.currentTitle = title;
+        this.contentBuffer = afterTitle;
+        this.currentCallId = node_crypto.randomUUID();
+        api.logger.debug(`${this.getLogPrefix()} Title captured: "${title}"`);
+        this.sendToolCallStart(title);
+      }
+    } else if (this.hasTitle) {
+      const titleStartIndex = this.accumulator.indexOf("**");
+      if (titleStartIndex !== -1) {
+        this.contentBuffer = this.accumulator.substring(
+          titleStartIndex + 2 + this.currentTitle.length + 2
+        );
+      }
+    } else {
+      this.contentBuffer = this.accumulator;
+    }
+  }
+  /**
+   * Send the tool call start message.
+   */
+  sendToolCallStart(title) {
+    if (!this.currentCallId || this.toolCallStarted) {
+      return;
+    }
+    const toolCall = {
+      type: "tool-call",
+      name: this.getToolName(),
+      callId: this.currentCallId,
+      input: {
+        title
+      },
+      id: node_crypto.randomUUID()
+    };
+    api.logger.debug(`${this.getLogPrefix()} Sending tool call start for: "${title}"`);
+    this.onMessage?.(toolCall);
+    this.toolCallStarted = true;
+  }
+  /**
+   * Complete the reasoning section.
+   * Returns true if reasoning was completed, false if there was nothing to complete.
+   */
+  completeReasoning(fullText) {
+    const text = fullText ?? this.accumulator;
+    if (!text.trim() && !this.toolCallStarted) {
+      api.logger.debug(`${this.getLogPrefix()} Complete called but no content accumulated, skipping`);
+      return false;
+    }
+    let title;
+    let content = text;
+    if (text.startsWith("**")) {
+      const titleEndIndex = text.indexOf("**", 2);
+      if (titleEndIndex !== -1) {
+        title = text.substring(2, titleEndIndex);
+        content = text.substring(titleEndIndex + 2).trim();
+      }
+    }
+    api.logger.debug(`${this.getLogPrefix()} Complete reasoning - Title: "${title}", Has content: ${content.length > 0}`);
+    if (title && !this.toolCallStarted) {
+      this.currentCallId = this.currentCallId || node_crypto.randomUUID();
+      this.sendToolCallStart(title);
+    }
+    if (this.toolCallStarted && this.currentCallId) {
+      const toolResult = {
+        type: "tool-call-result",
+        callId: this.currentCallId,
+        output: {
+          content,
+          status: "completed"
+        },
+        id: node_crypto.randomUUID()
+      };
+      api.logger.debug(`${this.getLogPrefix()} Sending tool call result`);
+      this.onMessage?.(toolResult);
+    } else if (content.trim()) {
+      const reasoningMessage = {
+        type: "reasoning",
+        message: content,
+        id: node_crypto.randomUUID()
+      };
+      api.logger.debug(`${this.getLogPrefix()} Sending reasoning message`);
+      this.onMessage?.(reasoningMessage);
+    }
+    this.resetState();
+    return true;
+  }
+  /**
+   * Abort the current reasoning section.
+   */
+  abort() {
+    api.logger.debug(`${this.getLogPrefix()} Abort called`);
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+  }
+  /**
+   * Reset the processor state.
+   */
+  reset() {
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+  }
+  /**
+   * Finish current tool call if one is in progress.
+   */
+  finishCurrentToolCall(status) {
+    if (this.toolCallStarted && this.currentCallId) {
+      const toolResult = {
+        type: "tool-call-result",
+        callId: this.currentCallId,
+        output: {
+          content: this.contentBuffer || "",
+          status
+        },
+        id: node_crypto.randomUUID()
+      };
+      api.logger.debug(`${this.getLogPrefix()} Sending tool call result with status: ${status}`);
+      this.onMessage?.(toolResult);
+    }
+  }
+  /**
+   * Reset internal state.
+   */
+  resetState() {
+    this.accumulator = "";
+    this.inTitleCapture = false;
+    this.titleBuffer = "";
+    this.contentBuffer = "";
+    this.hasTitle = false;
+    this.currentCallId = null;
+    this.toolCallStarted = false;
+    this.currentTitle = null;
+  }
+  /**
+   * Get the current call ID for tool result matching.
+   */
+  getCurrentCallId() {
+    return this.currentCallId;
+  }
+  /**
+   * Check if a tool call has been started.
+   */
+  hasStartedToolCall() {
+    return this.toolCallStarted;
+  }
+}
+
+exports.BaseReasoningProcessor = BaseReasoningProcessor;
+exports.bootstrapManagedProviderSession = bootstrapManagedProviderSession;