openfox 0.2.4 → 1.0.1

package/dist/chunk-2KSCZSXQ.js

@@ -0,0 +1,680 @@
+// src/server/events/folding.ts
+function cloneMessage(message) {
+  return {
+    ...message,
+    ...message.attachments ? { attachments: [...message.attachments] } : {},
+    ...message.toolCalls ? {
+      toolCalls: message.toolCalls.map((toolCall) => ({
+        ...toolCall,
+        ...toolCall.streamingOutput ? { streamingOutput: [...toolCall.streamingOutput] } : {},
+        ...toolCall.result ? { result: { ...toolCall.result } } : {}
+      }))
+    } : {},
+    ...message.segments ? { segments: [...message.segments] } : {},
+    ...message.preparingToolCalls ? { preparingToolCalls: [...message.preparingToolCalls] } : {}
+  };
+}
+function snapshotMessageToMessage(message) {
+  return cloneMessage({
+    id: message.id,
+    role: message.role,
+    content: message.content,
+    timestamp: new Date(message.timestamp).toISOString(),
+    ...message.tokenCount !== void 0 && { tokenCount: message.tokenCount },
+    ...message.isStreaming !== void 0 && { isStreaming: message.isStreaming },
+    ...message.contextWindowId !== void 0 && { contextWindowId: message.contextWindowId },
+    ...message.subAgentId !== void 0 && { subAgentId: message.subAgentId },
+    ...message.subAgentType !== void 0 && { subAgentType: message.subAgentType },
+    ...message.isSystemGenerated !== void 0 && { isSystemGenerated: message.isSystemGenerated },
+    ...message.messageKind !== void 0 && { messageKind: message.messageKind },
+    ...message.isCompactionSummary !== void 0 && { isCompactionSummary: message.isCompactionSummary },
+    ...message.attachments !== void 0 && { attachments: message.attachments },
+    ...message.thinkingContent !== void 0 && { thinkingContent: message.thinkingContent },
+    ...message.toolCalls !== void 0 && { toolCalls: message.toolCalls },
+    ...message.segments !== void 0 && { segments: message.segments },
+    ...message.stats !== void 0 && { stats: message.stats },
+    ...message.partial !== void 0 && { partial: message.partial },
+    ...message.promptContext !== void 0 && { promptContext: message.promptContext },
+    ...message.metadata !== void 0 && { metadata: message.metadata }
+  });
+}
+function shouldIncludeContextMessage(message, windowId, options) {
+  const includeVerifier = options?.includeVerifier ?? true;
+  return message.role !== "system" && (windowId === void 0 || message.contextWindowId === windowId) && (includeVerifier || message.subAgentType !== "verifier") && !message.subAgentId;
+}
+function appendSnapshotMessageContext(result, message) {
+  const contextMsg = {
+    role: message.role,
+    content: message.content
+  };
+  if (message.toolCalls && message.toolCalls.length > 0) {
+    contextMsg.toolCalls = message.toolCalls.map((toolCall) => ({
+      id: toolCall.id,
+      name: toolCall.name,
+      arguments: toolCall.arguments
+    }));
+  }
+  if (message.attachments !== void 0) {
+    contextMsg.attachments = message.attachments;
+  }
+  result.push(contextMsg);
+  if (!message.toolCalls) {
+    return;
+  }
+  for (const toolCall of message.toolCalls) {
+    if (!toolCall.result) {
+      continue;
+    }
+    result.push({
+      role: "tool",
+      content: toolCall.result.success ? toolCall.result.output ?? "Success" : toolCall.result.output ? `${toolCall.result.output}
+
+Error: ${toolCall.result.error}` : `Error: ${toolCall.result.error}`,
+      toolCallId: toolCall.id
+    });
+  }
+}
+function applyStoredMessageEvents(initialMessages, events) {
+  const messages = new Map(initialMessages.map((message) => [message.id, cloneMessage(message)]));
+  for (const event of events) {
+    switch (event.type) {
+      case "message.start": {
+        const data = event.data;
+        const isUserOrSystem = data.role === "user" || data.role === "system";
+        messages.set(data.messageId, {
+          id: data.messageId,
+          role: data.role,
+          content: data.content ?? "",
+          timestamp: new Date(event.timestamp).toISOString(),
+          tokenCount: data.tokenCount ?? 0,
+          isStreaming: !isUserOrSystem,
+          ...data.contextWindowId !== void 0 && { contextWindowId: data.contextWindowId },
+          ...data.subAgentId !== void 0 && { subAgentId: data.subAgentId },
+          ...data.subAgentType !== void 0 && { subAgentType: data.subAgentType },
+          ...data.isSystemGenerated !== void 0 && { isSystemGenerated: data.isSystemGenerated },
+          ...data.messageKind !== void 0 && { messageKind: data.messageKind },
+          ...data.isCompactionSummary !== void 0 && { isCompactionSummary: data.isCompactionSummary },
+          ...data.attachments !== void 0 && { attachments: data.attachments },
+          ...data.metadata !== void 0 && { metadata: data.metadata }
+        });
+        break;
+      }
+      case "message.delta": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg) {
+          msg.content += data.content;
+        }
+        break;
+      }
+      case "message.thinking": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg) {
+          msg.thinkingContent = (msg.thinkingContent ?? "") + data.content;
+        }
+        break;
+      }
+      case "message.done": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg) {
+          msg.isStreaming = false;
+          if (data.stats) msg.stats = data.stats;
+          if (data.segments) msg.segments = data.segments;
+          if (data.partial) msg.partial = data.partial;
+          if (data.promptContext) msg.promptContext = data.promptContext;
+          if (data.tokenCount !== void 0) msg.tokenCount = data.tokenCount;
+        }
+        break;
+      }
+      case "tool.call": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg) {
+          const existingToolCalls = msg.toolCalls ?? [];
+          msg.toolCalls = [...existingToolCalls, data.toolCall];
+        }
+        break;
+      }
+      case "tool.result": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg?.toolCalls) {
+          const toolCall = msg.toolCalls.find((tc) => tc.id === data.toolCallId);
+          if (toolCall) {
+            toolCall.result = data.result;
+          }
+        }
+        break;
+      }
+      case "session.initialized":
+      case "turn.snapshot":
+      case "phase.changed":
+      case "mode.changed":
+      case "running.changed":
+      case "criteria.set":
+      case "criterion.updated":
+      case "context.state":
+      case "context.compacted":
+      case "file.read":
+      case "todo.updated":
+      case "chat.done":
+      case "chat.error":
+      case "format.retry":
+      case "tool.preparing":
+      case "tool.output":
+        break;
+    }
+  }
+  return Array.from(messages.values());
+}
+function cloneSnapshotMessage(message) {
+  return {
+    ...message,
+    ...message.attachments ? { attachments: [...message.attachments] } : {},
+    ...message.toolCalls ? {
+      toolCalls: message.toolCalls.map((toolCall) => ({
+        ...toolCall,
+        ...toolCall.streamingOutput ? { streamingOutput: [...toolCall.streamingOutput] } : {},
+        ...toolCall.result ? { result: { ...toolCall.result } } : {}
+      }))
+    } : {},
+    ...message.segments ? { segments: [...message.segments] } : {}
+  };
+}
+function applyTurnEventsToSnapshotMessages(initialMessages, events) {
+  const messages = new Map(initialMessages.map((message) => [message.id, cloneSnapshotMessage(message)]));
+  for (const event of events) {
+    switch (event.type) {
+      case "message.start": {
+        const data = event.data;
+        const msg = {
+          id: data.messageId,
+          role: data.role,
+          content: data.content ?? "",
+          timestamp: typeof event.timestamp === "number" ? event.timestamp : Date.now(),
+          isStreaming: true
+        };
+        if (data.tokenCount !== void 0) msg.tokenCount = data.tokenCount;
+        if (data.contextWindowId !== void 0) msg.contextWindowId = data.contextWindowId;
+        if (data.subAgentId !== void 0) msg.subAgentId = data.subAgentId;
+        if (data.subAgentType !== void 0) msg.subAgentType = data.subAgentType;
+        if (data.isSystemGenerated !== void 0) msg.isSystemGenerated = data.isSystemGenerated;
+        if (data.messageKind !== void 0) msg.messageKind = data.messageKind;
+        if (data.isCompactionSummary !== void 0) msg.isCompactionSummary = data.isCompactionSummary;
+        if (data.attachments !== void 0) msg.attachments = data.attachments;
+        if (data.metadata !== void 0) msg.metadata = data.metadata;
+        messages.set(data.messageId, msg);
+        break;
+      }
+      case "message.delta": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg) {
+          msg.content += data.content;
+        }
+        break;
+      }
+      case "message.thinking": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg) {
+          msg.thinkingContent = (msg.thinkingContent ?? "") + data.content;
+        }
+        break;
+      }
+      case "message.done": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg) {
+          msg.isStreaming = false;
+          if (data.stats) msg.stats = data.stats;
+          if (data.segments) msg.segments = data.segments;
+          if (data.partial) msg.partial = data.partial;
+          if (data.promptContext) msg.promptContext = data.promptContext;
+          if (data.tokenCount !== void 0) msg.tokenCount = data.tokenCount;
+        }
+        break;
+      }
+      case "tool.call": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg) {
+          const toolCalls = msg.toolCalls ?? [];
+          msg.toolCalls = [...toolCalls, data.toolCall];
+        }
+        break;
+      }
+      case "tool.result": {
+        const data = event.data;
+        const msg = messages.get(data.messageId);
+        if (msg?.toolCalls) {
+          const toolCall = msg.toolCalls.find((tc) => tc.id === data.toolCallId);
+          if (toolCall) {
+            toolCall.result = data.result;
+          }
+        }
+        break;
+      }
+    }
+  }
+  return Array.from(messages.values());
+}
+function buildMessagesFromStoredEvents(events) {
+  const snapshotEvent = [...events].reverse().find((event) => event.type === "turn.snapshot");
+  if (snapshotEvent) {
+    const snapshot = snapshotEvent.data;
+    const snapshotMessages = snapshot.messages.map(snapshotMessageToMessage);
+    const laterEvents = events.filter((event) => event.seq > snapshotEvent.seq);
+    return applyStoredMessageEvents(snapshotMessages, laterEvents);
+  }
+  return applyStoredMessageEvents([], events);
+}
+function buildContextMessagesFromStoredEvents(events, windowId, options) {
+  const includeVerifier = options?.includeVerifier ?? true;
+  const messages = [];
+  const messageMap = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    switch (event.type) {
+      case "message.start": {
+        const data = event.data;
+        if (data.role !== "system" && (windowId === void 0 || data.contextWindowId === windowId) && (includeVerifier || data.subAgentType !== "verifier") && !data.subAgentId) {
+          const message = {
+            id: data.messageId,
+            role: data.role,
+            content: data.content ?? "",
+            ...data.attachments !== void 0 && { attachments: data.attachments }
+          };
+          messageMap.set(data.messageId, message);
+          messages.push(message);
+        }
+        break;
+      }
+      case "message.delta": {
+        const data = event.data;
+        const msg = messageMap.get(data.messageId);
+        if (msg) {
+          msg.content += data.content;
+        }
+        break;
+      }
+      case "tool.call": {
+        const data = event.data;
+        const msg = messageMap.get(data.messageId);
+        if (msg) {
+          if (!msg.toolCalls) msg.toolCalls = [];
+          msg.toolCalls.push(data.toolCall);
+        }
+        break;
+      }
+      case "tool.result": {
+        const data = event.data;
+        if (messageMap.has(data.messageId)) {
+          const imageMeta = data.result.metadata;
+          const msg = {
+            id: `tool-${data.toolCallId}`,
+            role: "tool",
+            content: data.result.success ? data.result.output ?? "Success" : data.result.output ? `${data.result.output}
+
+Error: ${data.result.error}` : `Error: ${data.result.error}`,
+            toolCallId: data.toolCallId
+          };
+          if (imageMeta?.dataUrl && imageMeta?.mimeType?.startsWith("image/")) {
+            msg.attachments = [{
+              id: crypto.randomUUID(),
+              filename: imageMeta.path ?? "image",
+              mimeType: imageMeta.mimeType,
+              size: imageMeta.size ?? 0,
+              data: imageMeta.dataUrl
+            }];
+          }
+          messages.push(msg);
+        }
+        break;
+      }
+    }
+  }
+  return messages.map(({ id: _id, ...message }) => message);
+}
+function buildContextMessagesFromEventHistory(events, windowId, options) {
+  const snapshotEvent = [...events].reverse().find((event) => event.type === "turn.snapshot");
+  if (!snapshotEvent) {
+    return buildContextMessagesFromStoredEvents(events, windowId, options);
+  }
+  const snapshot = snapshotEvent.data;
+  const snapshotMessages = snapshot.messages.reduce((result, message) => {
+    if (!shouldIncludeContextMessage(message, windowId, options)) {
+      return result;
+    }
+    appendSnapshotMessageContext(result, message);
+    return result;
+  }, []);
+  const laterEvents = events.filter((event) => event.seq > snapshotEvent.seq);
+  return [
+    ...snapshotMessages,
+    ...buildContextMessagesFromStoredEvents(laterEvents, windowId, options)
+  ];
+}
+function foldTurnEventsToSnapshotMessages(events) {
+  return applyTurnEventsToSnapshotMessages([], events);
+}
+function foldCriteria(events) {
+  let criteria = [];
+  for (const event of events) {
+    switch (event.type) {
+      case "criteria.set": {
+        const data = event.data;
+        criteria = data.criteria;
+        break;
+      }
+      case "criterion.updated": {
+        const data = event.data;
+        criteria = criteria.map(
+          (c) => c.id === data.criterionId ? { ...c, status: data.status } : c
+        );
+        break;
+      }
+    }
+  }
+  return criteria;
+}
+function foldTodos(events) {
+  let todos = [];
+  for (const event of events) {
+    if (event.type === "todo.updated") {
+      const data = event.data;
+      todos = data.todos;
+    }
+  }
+  return todos;
+}
+function foldContextState(events, initialWindowId) {
+  let currentContextWindowId = initialWindowId;
+  let compactionCount = 0;
+  let latestContextState = null;
+  const readFilesMap = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    switch (event.type) {
+      case "session.initialized": {
+        const data = event.data;
+        currentContextWindowId = data.contextWindowId;
+        break;
+      }
+      case "turn.snapshot": {
+        const data = event.data;
+        currentContextWindowId = data.currentContextWindowId;
+        compactionCount = data.contextState.compactionCount;
+        latestContextState = data.contextState;
+        readFilesMap.clear();
+        for (const entry of data.readFiles) {
+          readFilesMap.set(entry.path, { ...entry });
+        }
+        break;
+      }
+      case "context.state": {
+        const data = event.data;
+        latestContextState = data;
+        break;
+      }
+      case "context.compacted": {
+        const data = event.data;
+        currentContextWindowId = data.newWindowId;
+        compactionCount++;
+        readFilesMap.clear();
+        latestContextState = null;
+        break;
+      }
+      case "file.read": {
+        const data = event.data;
+        if (data.contextWindowId === currentContextWindowId) {
+          readFilesMap.set(data.path, {
+            path: data.path,
+            tokenCount: data.tokenCount
+          });
+        }
+        break;
+      }
+    }
+  }
+  return {
+    currentContextWindowId,
+    compactionCount,
+    readFiles: Array.from(readFilesMap.values()),
+    latestContextState
+  };
+}
+function foldMode(events) {
+  let mode = "planner";
+  for (const event of events) {
+    if (event.type === "mode.changed") {
+      const data = event.data;
+      mode = data.mode;
+    }
+  }
+  return mode;
+}
+function foldPhase(events) {
+  let phase = "plan";
+  for (const event of events) {
+    if (event.type === "phase.changed") {
+      const data = event.data;
+      phase = data.phase;
+    }
+  }
+  return phase;
+}
+function foldIsRunning(events) {
+  let isRunning = false;
+  for (const event of events) {
+    if (event.type === "running.changed") {
+      const data = event.data;
+      isRunning = data.isRunning;
+    }
+  }
+  return isRunning;
+}
+function foldPendingConfirmations(events) {
+  const pending = [];
+  const responded = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.type === "path.confirmation_responded") {
+      const data = event.data;
+      responded.add(data.callId);
+    }
+  }
+  for (const event of events) {
+    if (event.type === "path.confirmation_pending") {
+      const data = event.data;
+      if (!responded.has(data.callId)) {
+        pending.push({
+          callId: data.callId,
+          tool: data.tool,
+          paths: data.paths,
+          workdir: data.workdir,
+          reason: data.reason
+        });
+      }
+    }
+  }
+  return pending;
+}
+function foldSessionState(events, initialWindowId, maxTokens) {
+  const mode = foldMode(events);
+  const phase = foldPhase(events);
+  const isRunning = foldIsRunning(events);
+  const messages = foldTurnEventsToSnapshotMessages(events);
+  const criteria = foldCriteria(events);
+  const todos = foldTodos(events);
+  const contextResult = foldContextState(events, initialWindowId);
+  const pendingConfirmations = foldPendingConfirmations(events);
+  const baseContextState = contextResult.latestContextState ?? {
+    currentTokens: 0,
+    maxTokens,
+    compactionCount: contextResult.compactionCount,
+    dangerZone: false,
+    canCompact: false
+  };
+  const contextState = baseContextState.compactionCount !== contextResult.compactionCount || baseContextState.maxTokens !== maxTokens ? { ...baseContextState, compactionCount: contextResult.compactionCount, maxTokens } : { ...baseContextState, maxTokens };
+  let lastModeWithReminder;
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.type === "turn.snapshot") {
+      const snapshotData = event.data;
+      if (snapshotData.lastModeWithReminder) {
+        lastModeWithReminder = snapshotData.lastModeWithReminder;
+        break;
+      }
+      for (let j = snapshotData.messages.length - 1; j >= 0; j--) {
+        const msg = snapshotData.messages[j];
+        if (msg.role === "user" && msg.messageKind === "auto-prompt" && msg.content?.includes("<system-reminder>")) {
+          if (msg.content.includes("Plan Mode")) {
+            lastModeWithReminder = "planner";
+          } else if (msg.content.includes("Build Mode")) {
+            lastModeWithReminder = "builder";
+          }
+          break;
+        }
+      }
+      if (lastModeWithReminder) break;
+    }
+  }
+  if (lastModeWithReminder === void 0) {
+    for (let i = events.length - 1; i >= 0; i--) {
+      const event = events[i];
+      if (event.type === "message.start") {
+        const data = event.data;
+        if (data.role === "user" && data.messageKind === "auto-prompt" && data.content?.includes("<system-reminder>")) {
+          if (data.content.includes("Plan Mode")) {
+            lastModeWithReminder = "planner";
+          } else if (data.content.includes("Build Mode")) {
+            lastModeWithReminder = "builder";
+          }
+          break;
+        }
+      }
+    }
+  }
+  return {
+    mode,
+    phase,
+    isRunning,
+    messages,
+    criteria,
+    todos,
+    contextState,
+    currentContextWindowId: contextResult.currentContextWindowId,
+    readFiles: contextResult.readFiles,
+    ...lastModeWithReminder !== void 0 && { lastModeWithReminder },
+    pendingConfirmations
+  };
+}
+function buildSnapshot(foldedState, latestSeq, snapshotAt = Date.now()) {
+  return {
+    mode: foldedState.mode,
+    phase: foldedState.phase,
+    isRunning: foldedState.isRunning,
+    messages: foldedState.messages,
+    criteria: foldedState.criteria,
+    contextState: foldedState.contextState,
+    currentContextWindowId: foldedState.currentContextWindowId,
+    todos: foldedState.todos,
+    readFiles: foldedState.readFiles,
+    ...foldedState.lastModeWithReminder !== void 0 && { lastModeWithReminder: foldedState.lastModeWithReminder },
+    snapshotSeq: latestSeq,
+    snapshotAt
+  };
+}
+function stripPromptContextMessages(messages) {
+  let lastAssistantIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    if (msg.role === "assistant" && msg.promptContext) {
+      lastAssistantIdx = i;
+      break;
+    }
+  }
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const pc = msg.promptContext;
+    if (pc && i !== lastAssistantIdx) {
+      const { messages: _msgs, ...rest } = pc;
+      msg.promptContext = { ...rest, messages: [] };
+    }
+  }
+}
+function buildSnapshotFromSessionState(input) {
+  const { session, events, latestSeq, snapshotAt = Date.now(), maxTokens = 2e5 } = input;
+  let initialWindowId = "";
+  for (const event of events) {
+    if (event.type === "session.initialized") {
+      const data = event.data;
+      initialWindowId = data.contextWindowId;
+      break;
+    }
+  }
+  if (!initialWindowId) {
+    initialWindowId = "legacy-window-1";
+  }
+  const foldedState = foldSessionState(events, initialWindowId, maxTokens);
+  const latestSnapshotIndex = events.map((event) => event.type).lastIndexOf("turn.snapshot");
+  const latestSnapshotEvent = latestSnapshotIndex >= 0 ? events[latestSnapshotIndex] : void 0;
+  const messages = latestSnapshotEvent ? applyTurnEventsToSnapshotMessages(
+    latestSnapshotEvent.data.messages,
+    events.slice(latestSnapshotIndex + 1)
+  ) : foldedState.messages;
+  stripPromptContextMessages(messages);
+  return {
+    mode: session.mode,
+    phase: session.phase,
+    isRunning: session.isRunning,
+    messages,
+    criteria: session.criteria,
+    contextState: {
+      currentTokens: session.executionState?.currentTokenCount ?? foldedState.contextState.currentTokens,
+      maxTokens: foldedState.contextState.maxTokens,
+      compactionCount: session.executionState?.compactionCount ?? foldedState.contextState.compactionCount,
+      dangerZone: foldedState.contextState.dangerZone,
+      canCompact: foldedState.contextState.canCompact
+    },
+    currentContextWindowId: foldedState.currentContextWindowId,
+    todos: foldedState.todos,
+    readFiles: foldedState.readFiles,
+    snapshotSeq: latestSeq,
+    snapshotAt
+  };
+}
+function getMessagesForWindow(messages, windowId) {
+  return messages.filter((m) => m.contextWindowId === windowId);
+}
+function buildContextMessagesFromMessages(messages, windowId) {
+  return getMessagesForWindow(messages, windowId).reduce((result, message) => {
+    if (!shouldIncludeContextMessage(message, windowId)) {
+      return result;
+    }
+    appendSnapshotMessageContext(result, message);
+    return result;
+  }, []);
+}
+
+export {
+  buildMessagesFromStoredEvents,
+  buildContextMessagesFromStoredEvents,
+  buildContextMessagesFromEventHistory,
+  foldTurnEventsToSnapshotMessages,
+  foldCriteria,
+  foldTodos,
+  foldContextState,
+  foldMode,
+  foldPhase,
+  foldIsRunning,
+  foldPendingConfirmations,
+  foldSessionState,
+  buildSnapshot,
+  buildSnapshotFromSessionState,
+  getMessagesForWindow,
+  buildContextMessagesFromMessages
+};
+//# sourceMappingURL=chunk-2KSCZSXQ.js.map