happy-imou-cloud 2.0.12 → 2.0.13

package/dist/ConversationHistory-V3VLmjJf.cjs

@@ -0,0 +1,868 @@
+'use strict';
+
+var index = require('./index-CryJfCh5.cjs');
+var api = require('./api-DH5-IqeM.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-BjkY-oUn.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
+  };
+}
+
+async function launchRuntimeHandleWithFactoryResult(opts) {
+  const shell = opts.shell ?? new index.RuntimeShell();
+  let factoryResult;
+  const session = await shell.launch({
+    provider: opts.provider,
+    cwd: opts.cwd,
+    env: opts.env,
+    createBackend: (factoryOpts) => {
+      factoryResult = opts.createBackendResult(factoryOpts);
+      return factoryResult.backend;
+    }
+  });
+  if (factoryResult === void 0) {
+    throw new Error(`Runtime provider "${opts.provider}" did not create a backend result`);
+  }
+  return {
+    session,
+    factoryResult
+  };
+}
+
+function inferToolResultError(result) {
+  if (!result || typeof result !== "object") {
+    return false;
+  }
+  const record = result;
+  if (record.isError === true || record.is_error === true) {
+    return true;
+  }
+  if (typeof record.error === "string" && record.error.trim().length > 0) {
+    return true;
+  }
+  if (record.success === false) {
+    return true;
+  }
+  const status = typeof record.status === "string" ? record.status.toLowerCase() : "";
+  return status === "failed" || status === "cancelled" || status === "error" || status === "denied" || status === "aborted";
+}
+
+function buildToolHappierMetaV2(input) {
+  return {
+    ...input,
+    v: 2
+  };
+}
+function attachToolHappierMetaV2(value, meta) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  return {
+    ...value,
+    _happier: buildToolHappierMetaV2(meta)
+  };
+}
+
+function getDefaultExecToolName(provider) {
+  switch (provider) {
+    case "claude":
+      return "ClaudeBash";
+    case "codex":
+      return "CodexBash";
+    case "gemini":
+      return "GeminiBash";
+  }
+}
+function getDefaultPatchToolName(provider) {
+  switch (provider) {
+    case "claude":
+      return "ClaudePatch";
+    case "codex":
+      return "CodexPatch";
+    case "gemini":
+      return "GeminiPatch";
+  }
+}
+function attachToolMeta(provider, rawToolName, value) {
+  const canonicalToolName = index.resolveCanonicalToolNameV2(rawToolName);
+  return attachToolHappierMetaV2(value, {
+    v: 2,
+    protocol: "acp",
+    provider,
+    rawToolName,
+    canonicalToolName
+  });
+}
+function forwardAgentMessageToProviderSession(msg, options) {
+  const createId = options.createId ?? node_crypto.randomUUID;
+  const toolResultType = options.toolResultType ?? "tool-result";
+  switch (msg.type) {
+    case "tool-call": {
+      options.send({
+        type: "tool-call",
+        name: index.resolveCanonicalToolNameV2(msg.toolName),
+        callId: msg.callId,
+        input: attachToolMeta(options.provider, msg.toolName, msg.args),
+        id: createId()
+      });
+      return true;
+    }
+    case "tool-result": {
+      options.send({
+        type: toolResultType,
+        callId: msg.callId,
+        output: attachToolMeta(options.provider, msg.toolName, msg.result),
+        id: createId(),
+        isError: inferToolResultError(msg.result)
+      });
+      return true;
+    }
+    case "fs-edit": {
+      options.send({
+        type: "file-edit",
+        description: msg.description,
+        diff: msg.diff,
+        filePath: msg.path || "unknown",
+        id: createId()
+      });
+      return true;
+    }
+    case "terminal-output": {
+      options.send({
+        type: "terminal-output",
+        data: msg.data,
+        callId: msg.callId ?? createId()
+      });
+      return true;
+    }
+    case "permission-request": {
+      const payload = msg.payload && typeof msg.payload === "object" ? msg.payload : {};
+      options.send({
+        type: "permission-request",
+        permissionId: msg.id,
+        toolName: typeof payload.toolName === "string" ? payload.toolName : msg.reason || "unknown",
+        description: msg.reason || (typeof payload.toolName === "string" ? payload.toolName : ""),
+        options: payload
+      });
+      return true;
+    }
+    case "exec-approval-request": {
+      const rawToolName = options.execToolName ?? getDefaultExecToolName(options.provider);
+      const { call_id, type: _type, ...inputs } = msg;
+      options.send({
+        type: "tool-call",
+        name: index.resolveCanonicalToolNameV2(rawToolName),
+        callId: call_id,
+        input: attachToolMeta(options.provider, rawToolName, inputs),
+        id: createId()
+      });
+      return true;
+    }
+    case "patch-apply-begin": {
+      const rawToolName = options.patchToolName ?? getDefaultPatchToolName(options.provider);
+      options.send({
+        type: "tool-call",
+        name: index.resolveCanonicalToolNameV2(rawToolName),
+        callId: msg.call_id,
+        input: attachToolMeta(options.provider, rawToolName, {
+          auto_approved: msg.auto_approved,
+          changes: msg.changes
+        }),
+        id: createId()
+      });
+      return true;
+    }
+    case "patch-apply-end": {
+      const rawToolName = options.patchToolName ?? getDefaultPatchToolName(options.provider);
+      options.send({
+        type: toolResultType,
+        callId: msg.call_id,
+        output: attachToolMeta(options.provider, rawToolName, {
+          stdout: msg.stdout,
+          stderr: msg.stderr,
+          success: msg.success
+        }),
+        id: createId(),
+        isError: !msg.success
+      });
+      return true;
+    }
+    case "token-count": {
+      const { type: _type, ...payload } = msg;
+      options.send({
+        type: "token_count",
+        ...payload,
+        id: createId()
+      });
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+function createAbortError() {
+  const error = new Error("Operation aborted");
+  error.name = "AbortError";
+  return error;
+}
+async function waitForResponseCompleteWithAbort(backend, signal, timeoutMs = 12e4) {
+  if (!backend.waitForResponseComplete) {
+    return;
+  }
+  if (signal.aborted) {
+    throw createAbortError();
+  }
+  await new Promise((resolve, reject) => {
+    const onAbort = () => reject(createAbortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    backend.waitForResponseComplete(timeoutMs).then(resolve).catch(reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  });
+}
+
+const INTERACTION_SUPERSEDED_ERROR = "Interaction superseded by new user message";
+const INTERACTION_TIMED_OUT_ERROR = "Interaction timed out waiting for user response";
+const DEFAULT_INTERACTION_TIMEOUT_MS = 2 * 60 * 1e3;
+function getPendingInteractionTimeoutMs() {
+  const raw = Number(process.env.HAPPY_INTERACTION_TIMEOUT_MS);
+  if (Number.isFinite(raw) && raw > 0) {
+    return raw;
+  }
+  return DEFAULT_INTERACTION_TIMEOUT_MS;
+}
+class BasePermissionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  isResetting = false;
+  constructor(session) {
+    this.session = session;
+    this.setupRpcHandler();
+  }
+  /**
+   * Update the session reference (used after offline reconnection swaps sessions).
+   * This is critical for avoiding stale session references after onSessionSwap.
+   */
+  updateSession(newSession) {
+    api.logger.debug(`${this.getLogPrefix()} Session reference updated`);
+    this.session = newSession;
+    this.setupRpcHandler();
+  }
+  /**
+   * Setup RPC handler for permission responses.
+   */
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler(
+      "permission",
+      async (response) => {
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+          api.logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
+          return;
+        }
+        this.pendingRequests.delete(response.id);
+        this.clearPendingRequestTimeout(pending);
+        const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
+        pending.resolve(result);
+        this.session.updateAgentState((currentState) => {
+          const request = currentState.requests?.[response.id];
+          if (!request) return currentState;
+          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+          let res = {
+            ...currentState,
+            requests: remainingRequests,
+            completedRequests: {
+              ...currentState.completedRequests,
+              [response.id]: {
+                ...request,
+                completedAt: Date.now(),
+                status: response.approved ? "approved" : "denied",
+                decision: result.decision
+              }
+            }
+          };
+          return res;
+        });
+        api.logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
+      }
+    );
+  }
+  /**
+   * Add a pending request to the agent state.
+   */
+  addPendingRequestToState(toolCallId, toolName, input) {
+    this.session.updateAgentState((currentState) => ({
+      ...currentState,
+      requests: {
+        ...currentState.requests,
+        [toolCallId]: {
+          tool: toolName,
+          arguments: input,
+          createdAt: Date.now()
+        }
+      }
+    }));
+  }
+  registerPendingRequest(toolCallId, toolName, input, logSuffix = "") {
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        toolName,
+        input
+      };
+      pending.timeoutHandle = setTimeout(() => {
+        this.handlePendingRequestTimeout(toolCallId, pending);
+      }, getPendingInteractionTimeoutMs());
+      this.pendingRequests.set(toolCallId, pending);
+      this.addPendingRequestToState(toolCallId, toolName, input);
+      api.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})${logSuffix}`);
+    });
+  }
+  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.resolve({ decision: "abort" });
+    }
+    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: "denied",
+          reason,
+          decision: "abort",
+          requestKind: request.requestKind || "permission"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+    api.logger.debug(`${this.getLogPrefix()} Superseded ${pendingSnapshot.length} pending permission request(s)`);
+    return pendingSnapshot.length;
+  }
+  /**
+   * Reset state for new sessions.
+   * This method is idempotent - safe to call multiple times.
+   */
+  reset() {
+    if (this.isResetting) {
+      api.logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
+      return;
+    }
+    this.isResetting = true;
+    try {
+      const pendingSnapshot = Array.from(this.pendingRequests.entries());
+      this.pendingRequests.clear();
+      for (const [id, pending] of pendingSnapshot) {
+        try {
+          this.clearPendingRequestTimeout(pending);
+          pending.reject(new Error("Session reset"));
+        } catch (err) {
+          api.logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
+        }
+      }
+      this.session.updateAgentState((currentState) => {
+        const pendingRequests = currentState.requests || {};
+        const completedRequests = { ...currentState.completedRequests };
+        for (const [id, request] of Object.entries(pendingRequests)) {
+          completedRequests[id] = {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: "Session reset"
+          };
+        }
+        return {
+          ...currentState,
+          requests: {},
+          completedRequests
+        };
+      });
+      api.logger.debug(`${this.getLogPrefix()} Permission handler reset`);
+    } finally {
+      this.isResetting = false;
+    }
+  }
+  clearPendingRequestTimeout(pending) {
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+      pending.timeoutHandle = void 0;
+    }
+  }
+  handlePendingRequestTimeout(toolCallId, pending) {
+    const active = this.pendingRequests.get(toolCallId);
+    if (!active || active !== pending) {
+      return;
+    }
+    this.pendingRequests.delete(toolCallId);
+    this.clearPendingRequestTimeout(active);
+    active.resolve({ decision: "abort" });
+    this.session.updateAgentState((currentState) => {
+      const request = currentState.requests?.[toolCallId] || {
+        tool: active.toolName,
+        arguments: active.input,
+        createdAt: Date.now(),
+        requestKind: "permission"
+      };
+      const { [toolCallId]: _, ...remainingRequests } = currentState.requests || {};
+      return {
+        ...currentState,
+        requests: remainingRequests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [toolCallId]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: INTERACTION_TIMED_OUT_ERROR,
+            decision: "abort",
+            requestKind: request.requestKind || "permission"
+          }
+        }
+      };
+    });
+    this.session.sendSessionEvent({
+      type: "message",
+      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
+    });
+    api.logger.debug(`${this.getLogPrefix()} Permission request timed out for ${active.toolName} (${toolCallId})`);
+  }
+}
+
+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;
+  }
+}
+
+let ConversationHistory$1 = class ConversationHistory {
+  messages = [];
+  maxMessages;
+  maxCharacters;
+  constructor(options = {}) {
+    this.maxMessages = options.maxMessages ?? 20;
+    this.maxCharacters = options.maxCharacters ?? 5e4;
+  }
+  isDuplicate(role, content) {
+    if (this.messages.length === 0) {
+      return false;
+    }
+    for (let index = this.messages.length - 1; index >= 0; index -= 1) {
+      const message = this.messages[index];
+      if (message.role !== role) {
+        continue;
+      }
+      const normalizedIncoming = content.trim().replace(/\s+/g, " ");
+      const normalizedExisting = message.content.replace(/\s+/g, " ");
+      return normalizedIncoming === normalizedExisting;
+    }
+    return false;
+  }
+  addUserMessage(content) {
+    this.addMessage("user", content);
+  }
+  addAssistantMessage(content) {
+    this.addMessage("assistant", content);
+  }
+  hasHistory() {
+    return this.messages.length > 0;
+  }
+  size() {
+    return this.messages.length;
+  }
+  clear() {
+    this.messages = [];
+    api.logger.debug("[ConversationHistory] History cleared");
+  }
+  getContextForNewSession(prefixMessage = "Continue from the prior session using the conversation below as context.") {
+    if (this.messages.length === 0) {
+      return "";
+    }
+    const formattedMessages = this.messages.map((message) => {
+      const role = message.role === "user" ? "User" : "Assistant";
+      const content = message.content.length > 2e3 ? `${message.content.slice(0, 2e3)}... [truncated]` : message.content;
+      return `${role}: ${content}`;
+    }).join("\n\n");
+    return [
+      "[PREVIOUS CONVERSATION CONTEXT]",
+      prefixMessage,
+      "",
+      formattedMessages,
+      "",
+      "[END OF PREVIOUS CONTEXT]",
+      ""
+    ].join("\n");
+  }
+  getSummary() {
+    const totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
+    const userCount = this.messages.filter((message) => message.role === "user").length;
+    const assistantCount = this.messages.filter((message) => message.role === "assistant").length;
+    return `${this.messages.length} messages (${userCount} user, ${assistantCount} assistant), ${totalChars} chars`;
+  }
+  addMessage(role, content) {
+    const trimmedContent = content.trim();
+    if (!trimmedContent) {
+      return;
+    }
+    if (this.isDuplicate(role, trimmedContent)) {
+      api.logger.debug(`[ConversationHistory] Skipping duplicate ${role} message (${trimmedContent.length} chars)`);
+      return;
+    }
+    this.messages.push({
+      role,
+      content: trimmedContent,
+      timestamp: Date.now()
+    });
+    this.trimHistory();
+    api.logger.debug(`[ConversationHistory] Added ${role} message (${trimmedContent.length} chars), total: ${this.messages.length}`);
+  }
+  trimHistory() {
+    while (this.messages.length > this.maxMessages) {
+      this.messages.shift();
+    }
+    let totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
+    while (totalChars > this.maxCharacters && this.messages.length > 1) {
+      const removed = this.messages.shift();
+      if (removed) {
+        totalChars -= removed.content.length;
+      }
+    }
+  }
+};
+
+exports.BasePermissionHandler = BasePermissionHandler;
+exports.BaseReasoningProcessor = BaseReasoningProcessor;
+exports.ConversationHistory = ConversationHistory$1;
+exports.INTERACTION_SUPERSEDED_ERROR = INTERACTION_SUPERSEDED_ERROR;
+exports.INTERACTION_TIMED_OUT_ERROR = INTERACTION_TIMED_OUT_ERROR;
+exports.bootstrapManagedProviderSession = bootstrapManagedProviderSession;
+exports.forwardAgentMessageToProviderSession = forwardAgentMessageToProviderSession;
+exports.getPendingInteractionTimeoutMs = getPendingInteractionTimeoutMs;
+exports.inferToolResultError = inferToolResultError;
+exports.launchRuntimeHandleWithFactoryResult = launchRuntimeHandleWithFactoryResult;
+exports.waitForResponseCompleteWithAbort = waitForResponseCompleteWithAbort;