openfox 2.0.142 → 2.0.144

package/dist/chunk-2DVAF6HY.js

@@ -0,0 +1,447 @@
+import {
+  getEventStore
+} from "./chunk-YRSZJ7IZ.js";
+import {
+  buildContextMessagesFromEventHistory,
+  buildMessagesFromStoredEvents,
+  foldContextState,
+  foldSessionState,
+  spreadOptionalMessageFields
+} from "./chunk-E4F32L4Q.js";
+import {
+  updateSessionMessageCount
+} from "./chunk-CCIG3YLG.js";
+import {
+  getRuntimeConfig
+} from "./chunk-YEW4YEJU.js";
+
+// src/server/events/types.ts
+function isTurnEvent(event) {
+  return typeof event === "object" && event !== null && "type" in event && "data" in event && typeof event.type === "string";
+}
+function isStoredEvent(event) {
+  return typeof event === "object" && event !== null && "seq" in event && "timestamp" in event && "sessionId" in event && "type" in event && "data" in event;
+}
+function createEvent(type, data) {
+  return { type, data };
+}
+
+// src/server/events/session.ts
+function combineEventsWithSnapshot(sessionId, snapshot, events) {
+  if (!snapshot) return events;
+  const snapshotEvent = {
+    seq: 0,
+    timestamp: snapshot.snapshotAt,
+    sessionId,
+    type: "turn.snapshot",
+    data: snapshot
+  };
+  return [snapshotEvent, ...events];
+}
+function toSnapshotMessage(message) {
+  return {
+    id: message.id,
+    role: message.role,
+    content: message.content,
+    timestamp: new Date(message.timestamp).getTime(),
+    ...spreadOptionalMessageFields(message)
+  };
+}
+function getSessionState(sessionId, maxTokens, defaultMode) {
+  const eventStore = getEventStore();
+  const { snapshot: latestSnapshot, events: rawEvents } = eventStore.getEventsSinceSnapshot(sessionId);
+  const events = combineEventsWithSnapshot(sessionId, latestSnapshot, rawEvents);
+  if (events.length === 0) {
+    return void 0;
+  }
+  let initialWindowId;
+  for (const event of events) {
+    if (event.type === "session.initialized") {
+      const data = event.data;
+      initialWindowId = data.contextWindowId;
+      break;
+    }
+  }
+  if (!initialWindowId) {
+    for (const event of events) {
+      if (event.type === "turn.snapshot") {
+        const snapshotData = event.data;
+        if (snapshotData.sessionInit?.contextWindowId) {
+          initialWindowId = snapshotData.sessionInit.contextWindowId;
+          break;
+        }
+      }
+    }
+  }
+  if (!initialWindowId) {
+    for (const event of events) {
+      if (event.type === "turn.snapshot") {
+        const snapshotData = event.data;
+        if (snapshotData.currentContextWindowId) {
+          initialWindowId = snapshotData.currentContextWindowId;
+          break;
+        }
+      }
+    }
+  }
+  if (!initialWindowId) {
+    return void 0;
+  }
+  const config = getRuntimeConfig();
+  const effectiveMaxTokens = maxTokens ?? config.context.maxTokens;
+  if (latestSnapshot) {
+    const state = foldSessionState(events, initialWindowId, effectiveMaxTokens, void 0, defaultMode);
+    return {
+      ...state,
+      messages: buildMessagesFromStoredEvents(events).messages.map(toSnapshotMessage)
+    };
+  }
+  return foldSessionState(events, initialWindowId, effectiveMaxTokens, void 0, defaultMode);
+}
+function getCurrentWindowMessages(sessionId) {
+  const currentWindowId = getCurrentContextWindowId(sessionId);
+  if (!currentWindowId) return [];
+  const state = getSessionState(sessionId);
+  if (!state) return [];
+  return state.messages.filter((m) => m.contextWindowId === currentWindowId);
+}
+function getContextMessages(sessionId) {
+  const eventStore = getEventStore();
+  const currentWindowId = getCurrentContextWindowId(sessionId);
+  if (!currentWindowId) return [];
+  const { snapshot: ctxSnapshot, events: ctxRawEvents } = eventStore.getEventsSinceSnapshot(sessionId);
+  const events = combineEventsWithSnapshot(sessionId, ctxSnapshot, ctxRawEvents);
+  if (events.length === 0) return [];
+  return buildContextMessagesFromEventHistory(events, currentWindowId, { includeVerifier: false });
+}
+function getCurrentContextWindowId(sessionId) {
+  const eventStore = getEventStore();
+  const events = eventStore.getEvents(sessionId);
+  const contextResult = foldContextState(events, "");
+  return contextResult.currentContextWindowId || void 0;
+}
+function getCurrentWindowMessageOptions(sessionId) {
+  const contextWindowId = getCurrentContextWindowId(sessionId);
+  return contextWindowId ? { contextWindowId } : void 0;
+}
+function getReadFilesCache(sessionId) {
+  const state = getSessionState(sessionId);
+  return state?.readFiles ?? [];
+}
+function isFileInCache(sessionId, path) {
+  const cache = getReadFilesCache(sessionId);
+  return cache.some((f) => f.path === path);
+}
+function emitSessionInitialized(sessionId, projectId, workdir, contextWindowId, title) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "session.initialized",
+    data: {
+      projectId,
+      workdir,
+      contextWindowId,
+      ...title !== void 0 && { title }
+    }
+  });
+}
+function emitUserMessage(sessionId, content, options) {
+  const eventStore = getEventStore();
+  const messageId = crypto.randomUUID();
+  eventStore.append(sessionId, {
+    type: "message.start",
+    data: {
+      messageId,
+      role: "user",
+      content,
+      ...options?.contextWindowId !== void 0 && { contextWindowId: options.contextWindowId },
+      ...options?.isSystemGenerated !== void 0 && { isSystemGenerated: options.isSystemGenerated },
+      ...options?.messageKind !== void 0 && { messageKind: options.messageKind },
+      ...options?.isCompactionSummary !== void 0 && { isCompactionSummary: options.isCompactionSummary },
+      ...options?.tokenCount !== void 0 && { tokenCount: options.tokenCount },
+      ...options?.attachments !== void 0 && { attachments: options.attachments },
+      ...options?.subAgentId !== void 0 && { subAgentId: options.subAgentId },
+      ...options?.subAgentType !== void 0 && { subAgentType: options.subAgentType },
+      ...options?.metadata !== void 0 && { metadata: options.metadata }
+    }
+  });
+  eventStore.append(sessionId, {
+    type: "message.done",
+    data: { messageId }
+  });
+  updateSessionMessageCount(sessionId, 1);
+  return messageId;
+}
+function emitAssistantMessageStart(sessionId, options) {
+  const eventStore = getEventStore();
+  const messageId = crypto.randomUUID();
+  eventStore.append(sessionId, {
+    type: "message.start",
+    data: {
+      messageId,
+      role: "assistant",
+      ...options?.contextWindowId !== void 0 && { contextWindowId: options.contextWindowId },
+      ...options?.subAgentId !== void 0 && { subAgentId: options.subAgentId },
+      ...options?.subAgentType !== void 0 && { subAgentType: options.subAgentType }
+    }
+  });
+  updateSessionMessageCount(sessionId, 1);
+  return messageId;
+}
+function emitMessageDelta(sessionId, messageId, content) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "message.delta",
+    data: { messageId, content }
+  });
+}
+function emitMessageThinking(sessionId, messageId, content) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "message.thinking",
+    data: { messageId, content }
+  });
+}
+function emitMessageDone(sessionId, messageId, options) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "message.done",
+    data: {
+      messageId,
+      ...options?.stats !== void 0 && { stats: options.stats },
+      ...options?.segments !== void 0 && { segments: options.segments },
+      ...options?.partial !== void 0 && { partial: options.partial },
+      ...options?.tokenCount !== void 0 && { tokenCount: options.tokenCount }
+    }
+  });
+}
+function emitToolPreparing(sessionId, messageId, index, name) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "tool.preparing",
+    data: { messageId, index, name }
+  });
+}
+function emitToolCall(sessionId, messageId, toolCall) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "tool.call",
+    data: { messageId, toolCall }
+  });
+}
+function emitToolOutput(sessionId, messageId, toolCallId, stream, content) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "tool.output",
+    data: { messageId, toolCallId, stream, content }
+  });
+}
+function emitToolResult(sessionId, messageId, toolCallId, result) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "tool.result",
+    data: { messageId, toolCallId, result }
+  });
+}
+function emitModeChanged(sessionId, mode, auto, reason) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "mode.changed",
+    data: {
+      mode,
+      auto,
+      ...reason !== void 0 && { reason }
+    }
+  });
+}
+function emitPhaseChanged(sessionId, phase) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "phase.changed",
+    data: { phase }
+  });
+}
+function emitRunningChanged(sessionId, isRunning) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "running.changed",
+    data: { isRunning }
+  });
+}
+function emitWorkflowExecutionChanged(sessionId, executionId, workflowId, workflowName, workflowColor, status, currentStepId, currentStepName, pendingChoices) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "workflow.execution_changed",
+    data: {
+      executionId,
+      workflowId,
+      workflowName,
+      ...workflowColor ? { workflowColor } : {},
+      status,
+      ...currentStepId ? { currentStepId } : {},
+      ...currentStepName ? { currentStepName } : {},
+      ...pendingChoices !== void 0 ? { pendingChoices } : {}
+    }
+  });
+}
+function emitCriteriaSet(sessionId, criteria) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "criteria.set",
+    data: { criteria }
+  });
+}
+function emitCriterionUpdated(sessionId, criterionId, status) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "criterion.updated",
+    data: { criterionId, status }
+  });
+}
+function emitTodosUpdated(sessionId, todos) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "todo.updated",
+    data: { todos }
+  });
+}
+function emitMetadataSet(sessionId, key, entries) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "metadata.set",
+    data: { key, entries }
+  });
+}
+function emitFileRead(sessionId, path, tokenCount, contextWindowId) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "file.read",
+    data: { path, tokenCount, contextWindowId }
+  });
+}
+function emitContextCompacted(sessionId, closedWindowId, newWindowId, beforeTokens, afterTokens, summary) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "context.compacted",
+    data: {
+      closedWindowId,
+      newWindowId,
+      beforeTokens,
+      afterTokens,
+      summary
+    }
+  });
+}
+function emitContextState(sessionId, currentTokens, maxTokens, compactionCount, dangerZone, canCompact, subAgentId, dynamicContextChanged) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "context.state",
+    data: {
+      currentTokens,
+      maxTokens,
+      compactionCount,
+      dangerZone,
+      canCompact,
+      dynamicContextChanged: dynamicContextChanged ?? false,
+      ...subAgentId !== void 0 && { subAgentId }
+    }
+  });
+}
+function emitChatDone(sessionId, messageId, reason, stats) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "chat.done",
+    data: {
+      messageId,
+      reason,
+      ...stats !== void 0 && { stats }
+    }
+  });
+}
+function emitChatError(sessionId, error, recoverable) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "chat.error",
+    data: { error, recoverable }
+  });
+}
+function emitPatternRetry(sessionId, messageId, pattern, field, attempt, maxAttempts, matchedContent) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "pattern.retry",
+    data: { messageId, pattern, field, attempt, maxAttempts, matchedContent }
+  });
+}
+function emitTurnSnapshot(sessionId, snapshot) {
+  const eventStore = getEventStore();
+  eventStore.append(sessionId, {
+    type: "turn.snapshot",
+    data: snapshot
+  });
+}
+function truncateSessionMessages(sessionId, messageIndex) {
+  const eventStore = getEventStore();
+  const snapshotEvent = eventStore.getLatestSnapshot(sessionId);
+  if (!snapshotEvent) return;
+  const snapshot = snapshotEvent.data;
+  const messages = snapshot.messages;
+  const lastKept = messageIndex + 1;
+  if (lastKept < 0 || lastKept >= messages.length) return;
+  const truncatedSnapshot = { ...snapshot, messages: messages.slice(0, lastKept) };
+  eventStore.deleteEventsAfterSeq(sessionId, snapshotEvent.seq);
+  eventStore.append(sessionId, {
+    type: "turn.snapshot",
+    data: truncatedSnapshot
+  });
+  const removed = messages.length - lastKept;
+  updateSessionMessageCount(sessionId, -removed);
+}
+function getRecentUserPromptsForSession(sessionId, limit = 10) {
+  try {
+    const eventStore = getEventStore();
+    return eventStore.getRecentUserPrompts(sessionId, limit);
+  } catch {
+    return [];
+  }
+}
+
+export {
+  isTurnEvent,
+  isStoredEvent,
+  createEvent,
+  combineEventsWithSnapshot,
+  getSessionState,
+  getCurrentWindowMessages,
+  getContextMessages,
+  getCurrentContextWindowId,
+  getCurrentWindowMessageOptions,
+  getReadFilesCache,
+  isFileInCache,
+  emitSessionInitialized,
+  emitUserMessage,
+  emitAssistantMessageStart,
+  emitMessageDelta,
+  emitMessageThinking,
+  emitMessageDone,
+  emitToolPreparing,
+  emitToolCall,
+  emitToolOutput,
+  emitToolResult,
+  emitModeChanged,
+  emitPhaseChanged,
+  emitRunningChanged,
+  emitWorkflowExecutionChanged,
+  emitCriteriaSet,
+  emitCriterionUpdated,
+  emitTodosUpdated,
+  emitMetadataSet,
+  emitFileRead,
+  emitContextCompacted,
+  emitContextState,
+  emitChatDone,
+  emitChatError,
+  emitPatternRetry,
+  emitTurnSnapshot,
+  truncateSessionMessages,
+  getRecentUserPromptsForSession
+};
+//# sourceMappingURL=chunk-2DVAF6HY.js.map

package/dist/{chunk-ACILWRPU.js → chunk-3IVJ65IG.js}

@@ -1,27 +1,29 @@
 import {
-  getPendingQuestionsForSession
-} from "./chunk-V5AC2TV7.js";
+  combineEventsWithSnapshot
+} from "./chunk-2DVAF6HY.js";
 import {
-  combineEventsWithSnapshot,
   getEventStore
-} from "./chunk-NJFXYSXP.js";
+} from "./chunk-YRSZJ7IZ.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-EFEHIJXF.js";
+} from "./chunk-E4F32L4Q.js";
 import {
   updateSessionMetadata
-} from "./chunk-F3R4YS3F.js";
+} from "./chunk-CCIG3YLG.js";
 import {
   getRuntimeConfig
-} from "./chunk-DRIR2IZR.js";
+} from "./chunk-YEW4YEJU.js";
+import {
+  getPendingQuestionsForSession
+} from "./chunk-V5AC2TV7.js";
 import {
   createContextStateMessage,
   createSessionStateMessage
 } from "./chunk-OVAHNEFG.js";
 import {
   getMaxVisibleItems
-} from "./chunk-SKNPOZYP.js";
+} from "./chunk-X6SWZEK7.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -162,7 +164,7 @@ async function generateSessionNameForSession(sessionId, userMessage, deps, signa
       client = deps.getLLMClient();
       client.setModel(providerConfig.model);
     } else if (providerConfig) {
-      const { createLLMClient } = await import("./client-2A766XZK.js");
+      const { createLLMClient } = await import("./client-L4PANCG4.js");
       client = createLLMClient(
         {
           llm: {
@@ -217,4 +219,4 @@ export {
   needsNameGeneration,
   generateSessionNameForSession
 };
-//# sourceMappingURL=chunk-ACILWRPU.js.map
+//# sourceMappingURL=chunk-3IVJ65IG.js.map