@lostgradient/cinder 0.4.1 → 0.6.0

package/dist/server/index.server-dc35kh7d.js

@@ -0,0 +1,1835 @@
+import {
+  ConversationalistError,
+  appendAssistantMessage,
+  appendMessages,
+  appendStreamingMessage,
+  appendSystemMessage,
+  appendToolCall,
+  appendToolCalls,
+  appendToolResult,
+  appendToolResultAsync,
+  appendToolResults,
+  appendToolResultsAsync,
+  appendUserMessage,
+  assertConversationSafe,
+  cancelStreamingMessage,
+  collapseSystemMessages,
+  copyContent,
+  createConversationHistory,
+  createIntegrityError,
+  createMessage,
+  deserializeConversationHistory,
+  ensureConversationSafe,
+  finalizeStreamingMessage,
+  getFirstSystemMessage,
+  getMessageAtPosition,
+  getMessageById,
+  getMessageIds,
+  getMessages,
+  getOrderedMessages,
+  getPendingToolCalls,
+  getStatistics,
+  getStreamingMessage,
+  getSystemMessages,
+  getToolInteractions,
+  hasSystemMessage,
+  isAssistantMessage,
+  isConversationEnvironmentParameter,
+  isStreamingMessage,
+  pairToolCallsWithResults,
+  prependSystemMessage,
+  redactMessageAtPosition,
+  replaceSystemMessage,
+  resolveConversationEnvironment,
+  searchConversationMessages,
+  simpleTokenEstimator,
+  toChatMessages,
+  toIdRecord,
+  toReadonly,
+  toSessionInfo,
+  updateStreamingMessage
+} from "./index.server-rjap4k7y.js";
+import {
+  __require
+} from "./index.server-0v6na3yp.js";
+
+// src/components/chat/utilities/utilities.ts
+var CINDER_REASONING_METADATA_KEY = "cinder:reasoning";
+var CINDER_STEPS_METADATA_KEY = "cinder:steps";
+var CINDER_SUGGESTIONS_METADATA_KEY = "cinder:suggestions";
+var STEP_STATUSES = new Set([
+  "pending",
+  "running",
+  "done",
+  "error"
+]);
+function isStepInfo(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  if (!("title" in value) || !("content" in value) || !("status" in value))
+    return false;
+  return typeof value.title === "string" && typeof value.content === "string" && typeof value.status === "string" && STEP_STATUSES.has(value.status);
+}
+function runOverlayCallback(message, fromProp) {
+  if (fromProp === undefined)
+    return { handled: false, value: undefined };
+  try {
+    const value = fromProp(message);
+    return value === undefined ? { handled: false, value: undefined } : { handled: true, value };
+  } catch {
+    return { handled: false, value: undefined };
+  }
+}
+function resolveMessageReasoning(message, fromProp) {
+  const fromCallback = runOverlayCallback(message, fromProp);
+  if (fromCallback.handled && fromCallback.value === "")
+    return "";
+  const candidate = fromCallback.handled ? fromCallback.value : message.metadata[CINDER_REASONING_METADATA_KEY];
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : undefined;
+}
+function resolveMessageSteps(message, fromProp) {
+  const fromCallback = runOverlayCallback(message, fromProp);
+  const candidate = fromCallback.handled ? fromCallback.value : message.metadata[CINDER_STEPS_METADATA_KEY];
+  if (!Array.isArray(candidate))
+    return;
+  const steps = candidate.filter(isStepInfo);
+  return steps.length > 0 ? steps : undefined;
+}
+function resolveMessageSuggestions(message, fromProp) {
+  const fromCallback = runOverlayCallback(message, fromProp);
+  const candidate = fromCallback.handled ? fromCallback.value : message.metadata[CINDER_SUGGESTIONS_METADATA_KEY];
+  if (!Array.isArray(candidate))
+    return;
+  const suggestions = candidate.filter((entry) => typeof entry === "string");
+  return suggestions.length > 0 ? suggestions : undefined;
+}
+function toMultiModalArray(input) {
+  if (typeof input === "string")
+    return [{ type: "text", text: input }];
+  return "type" in input ? [input] : input;
+}
+function formatJSONValue(value) {
+  return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+function getServerContentText(part) {
+  switch (part.type) {
+    case "text":
+      return part.text;
+    case "server_tool_use":
+      return [`Server tool use: ${part.name}`, formatJSONValue(part.input)].join(`
+`);
+    case "web_search_tool_result":
+      return [`Web search result: ${part.tool_use_id}`, formatJSONValue(part.content)].join(`
+`);
+    case "code_execution_tool_result":
+    case "bash_code_execution_tool_result":
+    case "text_editor_code_execution_tool_result":
+    case "web_fetch_tool_result":
+      return [`Server tool result: ${part.tool_use_id}`, formatJSONValue(part.content)].join(`
+`);
+    case "container_upload":
+      return `Container upload: ${part.file_id}`;
+    default:
+      return;
+  }
+}
+function getMessageParts(message) {
+  return toMultiModalArray(message.content);
+}
+function getMessageText(message) {
+  return getMessageParts(message).map(getServerContentText).filter((text) => typeof text === "string" && text.length > 0).join(`
+`);
+}
+function deriveImageParts(message) {
+  if (typeof message.content === "string")
+    return [];
+  const parts = [];
+  message.content.forEach((segment, index) => {
+    if (segment.type === "image") {
+      parts.push({
+        type: "image",
+        key: `${message.id}:image:${index}`,
+        image: segment
+      });
+    }
+  });
+  return parts;
+}
+function deriveReasoningContent(message, explicitReasoning) {
+  if (explicitReasoning === "")
+    return;
+  const reasoningSegments = explicitReasoning && explicitReasoning.length > 0 ? [explicitReasoning] : [];
+  if (typeof message.content !== "string") {
+    let hasRedactedThinking = false;
+    for (const segment of message.content) {
+      if (segment.type === "thinking" && segment.thinking.length > 0) {
+        reasoningSegments.push(segment.thinking);
+      }
+      if (segment.type === "redacted_thinking") {
+        hasRedactedThinking = true;
+      }
+    }
+    if (hasRedactedThinking) {
+      reasoningSegments.push("Redacted reasoning is preserved in this transcript but cannot be displayed.");
+    }
+  }
+  return reasoningSegments.length > 0 ? reasoningSegments.join(`
+
+`) : undefined;
+}
+function deriveToolApprovalPart(messageId, result, context) {
+  const approved = context.approvedToolCallIds?.has(result.callId) ? true : context.deniedToolCallIds?.has(result.callId) ? false : undefined;
+  return {
+    type: "tool-approval",
+    key: `${messageId}:tool-approval:${result.callId}`,
+    toolCallId: result.callId,
+    toolName: context.toolCallPair?.call.name ?? result.callId,
+    action: result.action,
+    approved
+  };
+}
+function deriveMessageParts(message, context = {}) {
+  const imageParts = deriveImageParts(message);
+  if (message.role === "tool-call" && message.toolCall && context.toolCallPair) {
+    const result = context.toolCallPair.result;
+    const approvalPart = result && result.outcome === "action_required" && result.action ? deriveToolApprovalPart(message.id, result, context) : undefined;
+    return [
+      {
+        type: "tool-call",
+        key: `${message.id}:tool-call:${message.toolCall.id}`,
+        pair: context.toolCallPair
+      },
+      ...approvalPart ? [approvalPart] : [],
+      ...imageParts
+    ];
+  }
+  if (message.role === "tool-result" && message.toolResult) {
+    const result = message.toolResult;
+    if (result.outcome === "action_required" && result.action) {
+      return [deriveToolApprovalPart(message.id, result, context), ...imageParts];
+    }
+    return [
+      {
+        type: "tool-result",
+        key: `${message.id}:tool-result:${result.callId}`,
+        result
+      },
+      ...imageParts
+    ];
+  }
+  const content = context.overrideContent ?? getMessageText(message);
+  const bodyParts = [];
+  if (context.steps && context.steps.length > 0) {
+    for (let index = 0;index < context.steps.length; index++) {
+      const step = context.steps[index];
+      bodyParts.push({
+        type: "step",
+        key: `${message.id}:step:${index}`,
+        index,
+        title: step.title,
+        content: step.content,
+        status: step.status
+      });
+    }
+  }
+  const reasoningContent = deriveReasoningContent(message, context.reasoning);
+  if (reasoningContent) {
+    bodyParts.push({
+      type: "reasoning",
+      key: `${message.id}:reasoning`,
+      content: reasoningContent,
+      streaming: context.streaming ?? false
+    });
+  }
+  bodyParts.push({
+    type: "markdown",
+    key: `${message.id}:body`,
+    content,
+    streaming: context.streaming ?? false,
+    expanded: context.expanded ?? true
+  });
+  if (context.suggestions && context.suggestions.length > 0) {
+    for (let index = 0;index < context.suggestions.length; index++) {
+      const label = context.suggestions[index];
+      bodyParts.push({
+        type: "suggestion",
+        key: `${message.id}:suggestion:${index}`,
+        index,
+        label
+      });
+    }
+  }
+  return [...bodyParts, ...imageParts];
+}
+function getMessageRoleLabel(message) {
+  const labels = {
+    user: "User",
+    assistant: "Assistant",
+    system: "System",
+    developer: "Developer",
+    "tool-call": "Tool Call",
+    "tool-result": "Tool Result",
+    snapshot: "Snapshot"
+  };
+  return labels[message.role] ?? message.role;
+}
+function formatMessageAsMarkdown(message) {
+  return getMessageText(message);
+}
+function formatMessageWithRole(message) {
+  const roleLabel = getMessageRoleLabel(message);
+  const text = getMessageText(message);
+  return `**${roleLabel}:**
+
+${text}`;
+}
+function messagesToMarkdown(messages) {
+  return messages.filter((msg) => msg.role !== "system" && msg.role !== "developer").map(formatMessageWithRole).join(`
+
+---
+
+`);
+}
+
+// ../../node_modules/conversationalist/dist/context.js
+var cloneMessageWithPosition = (message, position, content) => {
+  const baseMessage = {
+    id: message.id,
+    role: message.role,
+    content,
+    position,
+    createdAt: message.createdAt,
+    metadata: { ...message.metadata },
+    hidden: message.hidden,
+    toolCall: message.toolCall ? { ...message.toolCall } : undefined,
+    toolResult: message.toolResult ? { ...message.toolResult } : undefined,
+    tokenUsage: message.tokenUsage ? { ...message.tokenUsage } : undefined
+  };
+  if (isAssistantMessage(message))
+    return createMessage({
+      ...baseMessage,
+      role: "assistant",
+      goalCompleted: message.goalCompleted
+    });
+  return createMessage(baseMessage);
+};
+var isPromiseLike = (value) => typeof value?.then === "function";
+var hasConversationTokenEstimator = (value) => Boolean(value && typeof value === "object" && typeof value["estimateConversationTokens"] === "function");
+var createMessageBlock = (message) => ({
+  messages: [message],
+  minPosition: message.position,
+  maxPosition: message.position,
+  tokenCount: 0
+});
+var estimateMessageBlockTokens = (messages, options, environment) => {
+  if (options.estimateConversationTokens)
+    return options.estimateConversationTokens(messages);
+  const estimator = options.estimateTokens ?? environment.estimateTokens;
+  return messages.reduce((total, message) => total + estimator(message), 0);
+};
+var buildMessageBlocks = (messages, estimateBlockTokens, preserveToolPairs) => {
+  if (!preserveToolPairs) {
+    const blocks2 = messages.map((message) => createMessageBlock(message));
+    for (const block of blocks2)
+      block.tokenCount = estimateBlockTokens(block.messages);
+    const messageToBlock2 = /* @__PURE__ */ new Map;
+    for (const block of blocks2) {
+      const message = block.messages[0];
+      if (message)
+        messageToBlock2.set(message.id, block);
+    }
+    return {
+      blocks: blocks2,
+      messageToBlock: messageToBlock2
+    };
+  }
+  const blocks = [];
+  const toolUses = /* @__PURE__ */ new Map;
+  for (const message of messages) {
+    if (message.role === "tool-call" && message.toolCall) {
+      const block = createMessageBlock(message);
+      toolUses.set(message.toolCall.id, block);
+      blocks.push(block);
+      continue;
+    }
+    if (message.role === "tool-result" && message.toolResult) {
+      const existing = toolUses.get(message.toolResult.callId);
+      if (existing) {
+        existing.messages.push(message);
+        existing.maxPosition = Math.max(existing.maxPosition, message.position);
+        continue;
+      }
+      const orphanBlock = createMessageBlock(message);
+      orphanBlock.orphanToolResult = true;
+      blocks.push(orphanBlock);
+      continue;
+    }
+    blocks.push(createMessageBlock(message));
+  }
+  const filteredBlocks = blocks.filter((block) => !block.orphanToolResult);
+  for (const block of filteredBlocks)
+    block.tokenCount = estimateBlockTokens(block.messages);
+  const messageToBlock = /* @__PURE__ */ new Map;
+  for (const block of filteredBlocks)
+    for (const message of block.messages)
+      messageToBlock.set(message.id, block);
+  return {
+    blocks: filteredBlocks,
+    messageToBlock
+  };
+};
+var buildMessageBlocksAsync = async (messages, estimateBlockTokens, preserveToolPairs) => {
+  const { blocks, messageToBlock } = buildMessageBlocks(messages, () => 0, preserveToolPairs);
+  await Promise.all(blocks.map(async (block) => {
+    block.tokenCount = await estimateBlockTokens(block.messages);
+  }));
+  return {
+    blocks,
+    messageToBlock
+  };
+};
+var estimateBlocksAsConversation = (blocks, options, environment) => estimateMessageBlockTokens(collectMessagesFromBlocks(blocks), options, environment);
+var collectBlocksForMessages = (messages, messageToBlock) => {
+  const blocks = [];
+  const seen = /* @__PURE__ */ new Set;
+  for (const message of messages) {
+    const block = messageToBlock.get(message.id);
+    if (block && !seen.has(block)) {
+      seen.add(block);
+      blocks.push(block);
+    }
+  }
+  return blocks;
+};
+var collectMessagesFromBlocks = (blocks) => {
+  const messages = [];
+  const seen = /* @__PURE__ */ new Set;
+  for (const block of blocks)
+    for (const message of block.messages)
+      if (!seen.has(message.id)) {
+        seen.add(message.id);
+        messages.push(message);
+      }
+  messages.sort((a, b) => a.position - b.position);
+  return messages;
+};
+var ensureTruncationSafe = (conversation, preserveToolPairs, operation) => {
+  try {
+    return ensureConversationSafe(conversation);
+  } catch (error) {
+    if (!preserveToolPairs && error instanceof ConversationalistError && error.code === "error:integrity")
+      throw createIntegrityError(`${operation} produced invalid tool linkage; use preserveToolPairs: true to keep tool interactions intact`, {
+        preserveToolPairs,
+        issues: error.context?.["issues"]
+      });
+    throw error;
+  }
+};
+function estimateConversationTokens(conversation, optionsOrEstimator, environment) {
+  let options = {};
+  let env = environment;
+  if (typeof optionsOrEstimator === "function")
+    options = { estimateTokens: optionsOrEstimator };
+  else if (optionsOrEstimator)
+    if (!environment && !hasConversationTokenEstimator(optionsOrEstimator) && isConversationEnvironmentParameter(optionsOrEstimator))
+      env = optionsOrEstimator;
+    else
+      options = optionsOrEstimator;
+  const resolvedEnvironment = resolveConversationEnvironment(env);
+  return estimateMessageBlockTokens(getOrderedMessages(conversation), options, resolvedEnvironment);
+}
+var truncateToTokenLimitFromBlocks = (conversation, maxTokens, currentTokens, orderedMessages, blocks, messageToBlock, options, environment) => {
+  if (currentTokens <= maxTokens)
+    return conversation;
+  const now = environment.now();
+  const preserveSystem = options.preserveSystemMessages ?? true;
+  const preserveLastN = options.preserveLastN ?? 0;
+  const preserveToolPairs = options.preserveToolPairs ?? true;
+  const systemMessages = preserveSystem ? orderedMessages.filter((m) => m.role === "system") : [];
+  const nonSystemMessages = orderedMessages.filter((m) => m.role !== "system");
+  const protectedMessages = preserveLastN > 0 ? nonSystemMessages.slice(-preserveLastN) : [];
+  const streamingMessages = orderedMessages.filter(isStreamingMessage);
+  const systemBlocks = collectBlocksForMessages(systemMessages, messageToBlock);
+  const protectedBlocks = collectBlocksForMessages(protectedMessages, messageToBlock);
+  const streamingBlocks = collectBlocksForMessages(streamingMessages, messageToBlock);
+  const lockedBlocks = new Set([
+    ...systemBlocks,
+    ...protectedBlocks,
+    ...streamingBlocks
+  ]);
+  const removableBlocks = blocks.filter((block) => !lockedBlocks.has(block));
+  const systemTokens = systemBlocks.reduce((sum, block) => sum + block.tokenCount, 0);
+  const protectedTokens = protectedBlocks.reduce((sum, block) => sum + block.tokenCount, 0);
+  const streamingTokens = streamingBlocks.reduce((sum, block) => sum + block.tokenCount, 0);
+  const availableTokens = maxTokens - systemTokens - protectedTokens - streamingTokens;
+  let selectedBlocks;
+  if (availableTokens <= 0)
+    selectedBlocks = [
+      ...systemBlocks,
+      ...protectedBlocks,
+      ...streamingBlocks
+    ];
+  else {
+    const sortedRemovable = [...removableBlocks].sort((a, b) => a.maxPosition - b.maxPosition);
+    const keptRemovable = [];
+    let usedTokens = 0;
+    for (let i = sortedRemovable.length - 1;i >= 0; i--) {
+      const block = sortedRemovable[i];
+      if (usedTokens + block.tokenCount <= availableTokens) {
+        keptRemovable.unshift(block);
+        usedTokens += block.tokenCount;
+      } else
+        break;
+    }
+    selectedBlocks = [
+      ...systemBlocks,
+      ...keptRemovable,
+      ...streamingBlocks,
+      ...protectedBlocks
+    ];
+  }
+  const renumbered = collectMessagesFromBlocks(selectedBlocks).map((message, index) => cloneMessageWithPosition(message, index, copyContent(message.content)));
+  return ensureTruncationSafe(toReadonly({
+    ...conversation,
+    ids: renumbered.map((message) => message.id),
+    messages: toIdRecord(renumbered),
+    updatedAt: now
+  }), preserveToolPairs, "truncateToTokenLimit");
+};
+var truncateToTokenLimitWithConversationEstimator = (conversation, maxTokens, orderedMessages, options, environment) => {
+  const preserveSystem = options.preserveSystemMessages ?? true;
+  const preserveLastN = options.preserveLastN ?? 0;
+  const preserveToolPairs = options.preserveToolPairs ?? true;
+  const { blocks, messageToBlock } = buildMessageBlocks(orderedMessages, () => 0, preserveToolPairs);
+  const countAllMessages = estimateMessageBlockTokens(orderedMessages, options, environment);
+  const selectBlocks = (currentTokens) => {
+    if (currentTokens <= maxTokens)
+      return blocks;
+    const systemMessages = preserveSystem ? orderedMessages.filter((m) => m.role === "system") : [];
+    const nonSystemMessages = orderedMessages.filter((m) => m.role !== "system");
+    const protectedMessages = preserveLastN > 0 ? nonSystemMessages.slice(-preserveLastN) : [];
+    const streamingMessages = orderedMessages.filter(isStreamingMessage);
+    const systemBlocks = collectBlocksForMessages(systemMessages, messageToBlock);
+    const protectedBlocks = collectBlocksForMessages(protectedMessages, messageToBlock);
+    const streamingBlocks = collectBlocksForMessages(streamingMessages, messageToBlock);
+    const lockedBlocks = new Set([
+      ...systemBlocks,
+      ...protectedBlocks,
+      ...streamingBlocks
+    ]);
+    const removableBlocks = blocks.filter((block) => !lockedBlocks.has(block));
+    const selectedLockedBlocks = [...lockedBlocks];
+    const sortedRemovable = [...removableBlocks].sort((a, b) => a.maxPosition - b.maxPosition);
+    const lockedTokens = estimateBlocksAsConversation(selectedLockedBlocks, options, environment);
+    const selectFromNewest = (lockedTokenCount) => {
+      if (lockedTokenCount >= maxTokens)
+        return selectedLockedBlocks;
+      const keptRemovable = [];
+      for (let index = sortedRemovable.length - 1;index >= 0; index--) {
+        const candidate = sortedRemovable[index];
+        const candidateTokens = estimateBlocksAsConversation([
+          ...selectedLockedBlocks,
+          candidate,
+          ...keptRemovable
+        ], options, environment);
+        if (isPromiseLike(candidateTokens))
+          return candidateTokens.then(async (resolvedCandidateTokens) => {
+            if (resolvedCandidateTokens > maxTokens)
+              return [...selectedLockedBlocks, ...keptRemovable];
+            keptRemovable.unshift(candidate);
+            for (let asyncIndex = index - 1;asyncIndex >= 0; asyncIndex--) {
+              const asyncCandidate = sortedRemovable[asyncIndex];
+              if (await estimateBlocksAsConversation([
+                ...selectedLockedBlocks,
+                asyncCandidate,
+                ...keptRemovable
+              ], options, environment) > maxTokens)
+                break;
+              keptRemovable.unshift(asyncCandidate);
+            }
+            return [...selectedLockedBlocks, ...keptRemovable];
+          });
+        if (candidateTokens > maxTokens)
+          break;
+        keptRemovable.unshift(candidate);
+      }
+      return [...selectedLockedBlocks, ...keptRemovable];
+    };
+    if (isPromiseLike(lockedTokens))
+      return lockedTokens.then(selectFromNewest);
+    return selectFromNewest(lockedTokens);
+  };
+  const finish = (selectedBlocks2) => {
+    if (selectedBlocks2 === blocks)
+      return conversation;
+    const renumbered = collectMessagesFromBlocks(selectedBlocks2).map((message, index) => cloneMessageWithPosition(message, index, copyContent(message.content)));
+    return ensureTruncationSafe(toReadonly({
+      ...conversation,
+      ids: renumbered.map((message) => message.id),
+      messages: toIdRecord(renumbered),
+      updatedAt: environment.now()
+    }), preserveToolPairs, "truncateToTokenLimit");
+  };
+  const finishAsync = async (currentTokens) => {
+    return finish(await selectBlocks(await currentTokens));
+  };
+  if (isPromiseLike(countAllMessages))
+    return finishAsync(countAllMessages);
+  const selectedBlocks = selectBlocks(countAllMessages);
+  return isPromiseLike(selectedBlocks) ? selectedBlocks.then(finish) : finish(selectedBlocks);
+};
+function truncateToTokenLimit(conversation, maxTokens, optionsOrEstimator, environment) {
+  assertConversationSafe(conversation);
+  let options = {};
+  let env = environment;
+  if (typeof optionsOrEstimator === "function")
+    options = { estimateTokens: optionsOrEstimator };
+  else if (optionsOrEstimator)
+    if (!environment && isConversationEnvironmentParameter(optionsOrEstimator)) {
+      const candidate = optionsOrEstimator;
+      if (!!(candidate["now"] || candidate["randomId"] || Array.isArray(candidate["plugins"]) && candidate["plugins"].length > 0))
+        env = optionsOrEstimator;
+      else
+        options = optionsOrEstimator;
+    } else
+      options = optionsOrEstimator;
+  const resolvedEnvironment = resolveConversationEnvironment(env);
+  const preserveToolPairs = options.preserveToolPairs ?? true;
+  const orderedMessages = getOrderedMessages(conversation);
+  if (options.estimateConversationTokens)
+    return truncateToTokenLimitWithConversationEstimator(conversation, maxTokens, orderedMessages, options, resolvedEnvironment);
+  const estimateBlockTokens = (messages) => estimateMessageBlockTokens(messages, options, resolvedEnvironment);
+  const currentTokens = estimateBlockTokens(orderedMessages);
+  if (isPromiseLike(currentTokens))
+    return currentTokens.then(async (resolvedCurrentTokens) => {
+      if (resolvedCurrentTokens <= maxTokens)
+        return conversation;
+      const { blocks: blocks2, messageToBlock: messageToBlock2 } = await buildMessageBlocksAsync(orderedMessages, estimateBlockTokens, preserveToolPairs);
+      return truncateToTokenLimitFromBlocks(conversation, maxTokens, resolvedCurrentTokens, orderedMessages, blocks2, messageToBlock2, options, resolvedEnvironment);
+    });
+  if (currentTokens <= maxTokens)
+    return conversation;
+  const { blocks, messageToBlock } = buildMessageBlocks(orderedMessages, (messages) => estimateMessageBlockTokens(messages, options, resolvedEnvironment), preserveToolPairs);
+  return truncateToTokenLimitFromBlocks(conversation, maxTokens, currentTokens, orderedMessages, blocks, messageToBlock, options, resolvedEnvironment);
+}
+function getRecentMessages(conversation, count, options) {
+  const includeHidden = options?.includeHidden ?? false;
+  const includeSystem = options?.includeSystem ?? false;
+  const preserveToolPairs = options?.preserveToolPairs ?? true;
+  const filtered = getOrderedMessages(conversation).filter((m) => {
+    if (!includeHidden && m.hidden)
+      return false;
+    if (!includeSystem && m.role === "system")
+      return false;
+    return true;
+  });
+  if (!preserveToolPairs)
+    return filtered.slice(-count);
+  const { messageToBlock } = buildMessageBlocks(filtered, () => 0, preserveToolPairs);
+  return collectMessagesFromBlocks(collectBlocksForMessages(filtered.slice(-count), messageToBlock));
+}
+function truncateFromPosition(conversation, position, options, environment) {
+  assertConversationSafe(conversation);
+  const preserveSystem = options?.preserveSystemMessages ?? true;
+  const preserveToolPairs = options?.preserveToolPairs ?? true;
+  const now = resolveConversationEnvironment(environment).now();
+  const ordered = getOrderedMessages(conversation);
+  const { messageToBlock } = buildMessageBlocks(ordered, () => 0, preserveToolPairs);
+  const systemMessages = preserveSystem ? ordered.filter((m) => m.role === "system" && m.position < position) : [];
+  const streamingMessages = ordered.filter((m) => isStreamingMessage(m) && m.position < position);
+  const keptMessages = ordered.filter((m) => m.position >= position);
+  const systemBlocks = collectBlocksForMessages(systemMessages, messageToBlock);
+  const streamingBlocks = collectBlocksForMessages(streamingMessages, messageToBlock);
+  const keptBlocks = collectBlocksForMessages(keptMessages, messageToBlock);
+  const renumbered = collectMessagesFromBlocks([
+    ...systemBlocks,
+    ...streamingBlocks,
+    ...keptBlocks
+  ]).map((message, index) => cloneMessageWithPosition(message, index, copyContent(message.content)));
+  return ensureTruncationSafe(toReadonly({
+    ...conversation,
+    ids: renumbered.map((message) => message.id),
+    messages: toIdRecord(renumbered),
+    updatedAt: now
+  }), preserveToolPairs, "truncateFromPosition");
+}
+
+// ../../node_modules/conversationalist/dist/history-5vdiTmMp.js
+function calculateChunkSize(totalTokens, averageMessageTokens, contextWindow, options) {
+  const baseRatio = options?.baseChunkRatio ?? 0.4;
+  const minRatio = options?.minimumChunkRatio ?? 0.15;
+  const safety = options?.safetyMargin ?? 1.2;
+  const ratio = averageMessageTokens > contextWindow * 0.1 ? minRatio : baseRatio;
+  return Math.max(1, Math.floor(totalTokens * ratio / safety));
+}
+function partitionMessages(conversation, options, _environment) {
+  const preserveRecent = options?.preserveRecentCount ?? 4;
+  const preserveSystem = options?.preserveSystemMessages ?? true;
+  const preserveToolPairs = options?.preserveToolPairs ?? true;
+  const allMessages = getMessages(conversation);
+  const systemMessages = preserveSystem ? allMessages.filter((m) => m.role === "system") : [];
+  const streamingMessages = allMessages.filter(isStreamingMessage);
+  const nonSystem = allMessages.filter((m) => m.role !== "system");
+  if (nonSystem.length <= preserveRecent)
+    return {
+      compactable: [],
+      preserved: [...allMessages]
+    };
+  let recentMessages = nonSystem.slice(-preserveRecent);
+  if (preserveToolPairs && recentMessages.length > 0) {
+    const firstRecent = recentMessages[0];
+    if (firstRecent.role === "tool-result" && firstRecent.toolResult) {
+      const callId = firstRecent.toolResult.callId;
+      const toolCallMsg = nonSystem.find((m) => m.role === "tool-call" && m.toolCall?.id === callId);
+      if (toolCallMsg && !recentMessages.includes(toolCallMsg))
+        recentMessages = [toolCallMsg, ...recentMessages];
+    }
+  }
+  const preservedSet = new Set([
+    ...systemMessages.map((m) => m.id),
+    ...recentMessages.map((m) => m.id),
+    ...streamingMessages.map((m) => m.id)
+  ]);
+  return {
+    compactable: allMessages.filter((m) => !preservedSet.has(m.id)),
+    preserved: allMessages.filter((m) => preservedSet.has(m.id))
+  };
+}
+function chunkMessages(messages, chunkTokenBudget, estimator) {
+  if (messages.length === 0)
+    return [];
+  const chunks = [];
+  let currentChunk = [];
+  let currentTokens = 0;
+  for (let i = 0;i < messages.length; i++) {
+    const message = messages[i];
+    const tokens = estimator(message);
+    let pairedMessages = [message];
+    let pairedTokens = tokens;
+    if (message.role === "tool-call" && message.toolCall) {
+      const nextIdx = i + 1;
+      if (nextIdx < messages.length) {
+        const next = messages[nextIdx];
+        if (next.role === "tool-result" && next.toolResult?.callId === message.toolCall.id) {
+          pairedMessages = [message, next];
+          pairedTokens = tokens + estimator(next);
+          i++;
+        }
+      }
+    }
+    if (currentTokens + pairedTokens > chunkTokenBudget && currentChunk.length > 0) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentTokens = 0;
+    }
+    currentChunk.push(...pairedMessages);
+    currentTokens += pairedTokens;
+  }
+  if (currentChunk.length > 0)
+    chunks.push(currentChunk);
+  return chunks;
+}
+var STRIPPED_PLACEHOLDER = "[tool result]";
+function stripStructuralToolBlocks(content) {
+  if (typeof content === "string")
+    return content;
+  return content.flatMap((part) => {
+    switch (part.type) {
+      case "server_tool_use":
+        return [{
+          ...part,
+          input: STRIPPED_PLACEHOLDER
+        }];
+      case "web_search_tool_result":
+      case "web_fetch_tool_result":
+      case "code_execution_tool_result":
+      case "bash_code_execution_tool_result":
+      case "text_editor_code_execution_tool_result":
+        return [{
+          ...part,
+          content: STRIPPED_PLACEHOLDER
+        }];
+      case "text": {
+        if (part.citations === undefined)
+          return [part];
+        const { citations: _citations, ...rest } = part;
+        return [rest];
+      }
+      case "thinking":
+      case "redacted_thinking":
+        return [];
+      default:
+        return [part];
+    }
+  });
+}
+function stripToolResultDetails(messages) {
+  return messages.map((message) => {
+    if (message.role === "tool-result" && message.toolResult)
+      return {
+        ...message,
+        content: STRIPPED_PLACEHOLDER,
+        toolResult: {
+          ...message.toolResult,
+          content: STRIPPED_PLACEHOLDER
+        }
+      };
+    if (typeof message.content !== "string")
+      return {
+        ...message,
+        content: stripStructuralToolBlocks(message.content)
+      };
+    return message;
+  });
+}
+async function compactConversation(conversation, summarizer, options, environment) {
+  const env = resolveConversationEnvironment(environment);
+  const estimator = env.estimateTokens ?? simpleTokenEstimator;
+  const { compactable, preserved } = partitionMessages(conversation, options, environment);
+  if (compactable.length === 0)
+    return {
+      conversation,
+      result: {
+        compacted: false,
+        chunksProcessed: 0,
+        messagesRemoved: 0,
+        summaryContent: ""
+      }
+    };
+  const totalTokens = compactable.reduce((sum, m) => sum + estimator(m), 0);
+  const chunkBudget = calculateChunkSize(totalTokens, totalTokens / compactable.length, totalTokens * 3, options);
+  const chunks = chunkMessages(stripToolResultDetails(compactable), chunkBudget, estimator);
+  const summaries = [];
+  for (const chunk of chunks) {
+    const summary = await summarizer(chunk, { maxTokens: options?.maxSummaryTokens });
+    summaries.push(summary);
+  }
+  const summaryContent = summaries.length === 1 ? summaries[0] : summaries.join(`
+
+---
+
+`);
+  let compacted = {
+    schemaVersion: 4,
+    id: conversation.id,
+    title: conversation.title,
+    status: conversation.status,
+    metadata: { ...conversation.metadata },
+    ids: [],
+    messages: {},
+    createdAt: conversation.createdAt,
+    updatedAt: env.now()
+  };
+  compacted = ensureConversationSafe(toReadonly(compacted));
+  compacted = appendMessages(compacted, {
+    role: "system",
+    content: summaryContent,
+    metadata: { compactionSummary: true }
+  }, env);
+  if (preserved.length > 0) {
+    const preservedInputs = preserved.map((m) => ({
+      role: m.role,
+      content: typeof m.content === "string" ? m.content : [...m.content],
+      metadata: { ...m.metadata },
+      hidden: m.hidden,
+      toolCall: m.toolCall ? { ...m.toolCall } : undefined,
+      toolResult: m.toolResult ? { ...m.toolResult } : undefined,
+      tokenUsage: m.tokenUsage ? { ...m.tokenUsage } : undefined
+    }));
+    compacted = appendMessages(compacted, ...preservedInputs, env);
+  }
+  return {
+    conversation: compacted,
+    result: {
+      compacted: true,
+      chunksProcessed: chunks.length,
+      messagesRemoved: compactable.length,
+      summaryContent
+    }
+  };
+}
+var ConversationEvent = class extends Event {
+  action;
+  conversation;
+  previousConversation;
+  messageIds;
+  toolCallIds;
+  constructor(type, detail) {
+    super(type);
+    this.action = detail.action;
+    this.conversation = detail.conversation;
+    this.previousConversation = detail.previousConversation;
+    if (detail.messageIds !== undefined)
+      this.messageIds = detail.messageIds;
+    if (detail.toolCallIds !== undefined)
+      this.toolCallIds = detail.toolCallIds;
+  }
+};
+var ConversationChangeEvent = class ConversationChangeEvent2 extends ConversationEvent {
+  static type = "change";
+  constructor(detail) {
+    super(ConversationChangeEvent2.type, detail);
+  }
+};
+var ConversationPushEvent = class ConversationPushEvent2 extends ConversationEvent {
+  static type = "push";
+  constructor(detail) {
+    super(ConversationPushEvent2.type, detail);
+  }
+};
+var ConversationUndoEvent = class ConversationUndoEvent2 extends ConversationEvent {
+  static type = "undo";
+  constructor(detail) {
+    super(ConversationUndoEvent2.type, detail);
+  }
+};
+var ConversationRedoEvent = class ConversationRedoEvent2 extends ConversationEvent {
+  static type = "redo";
+  constructor(detail) {
+    super(ConversationRedoEvent2.type, detail);
+  }
+};
+var ConversationSwitchEvent = class ConversationSwitchEvent2 extends ConversationEvent {
+  static type = "switch";
+  constructor(detail) {
+    super(ConversationSwitchEvent2.type, detail);
+  }
+};
+var MessagesAppendedEvent = class MessagesAppendedEvent2 extends ConversationEvent {
+  static type = "messages.appended";
+  constructor(detail) {
+    super(MessagesAppendedEvent2.type, detail);
+  }
+};
+var MessagesUpdatedEvent = class MessagesUpdatedEvent2 extends ConversationEvent {
+  static type = "messages.updated";
+  constructor(detail) {
+    super(MessagesUpdatedEvent2.type, detail);
+  }
+};
+var MessagesRemovedEvent = class MessagesRemovedEvent2 extends ConversationEvent {
+  static type = "messages.removed";
+  constructor(detail) {
+    super(MessagesRemovedEvent2.type, detail);
+  }
+};
+var ToolCallsAppendedEvent = class ToolCallsAppendedEvent2 extends ConversationEvent {
+  static type = "tool-calls.appended";
+  constructor(detail) {
+    super(ToolCallsAppendedEvent2.type, detail);
+  }
+};
+var ToolResultsAppendedEvent = class ToolResultsAppendedEvent2 extends ConversationEvent {
+  static type = "tool-results.appended";
+  constructor(detail) {
+    super(ToolResultsAppendedEvent2.type, detail);
+  }
+};
+var StreamStartedEvent = class StreamStartedEvent2 extends ConversationEvent {
+  static type = "stream.started";
+  constructor(detail) {
+    super(StreamStartedEvent2.type, detail);
+  }
+};
+var StreamUpdatedEvent = class StreamUpdatedEvent2 extends ConversationEvent {
+  static type = "stream.updated";
+  constructor(detail) {
+    super(StreamUpdatedEvent2.type, detail);
+  }
+};
+var StreamFinalizedEvent = class StreamFinalizedEvent2 extends ConversationEvent {
+  static type = "stream.finalized";
+  constructor(detail) {
+    super(StreamFinalizedEvent2.type, detail);
+  }
+};
+var StreamCancelledEvent = class StreamCancelledEvent2 extends ConversationEvent {
+  static type = "stream.cancelled";
+  constructor(detail) {
+    super(StreamCancelledEvent2.type, detail);
+  }
+};
+var CompactionStartedEvent = class CompactionStartedEvent2 extends ConversationEvent {
+  static type = "compaction.started";
+  constructor(detail) {
+    super(CompactionStartedEvent2.type, detail);
+  }
+};
+var CompactionCompletedEvent = class CompactionCompletedEvent2 extends ConversationEvent {
+  static type = "compaction.completed";
+  constructor(detail) {
+    super(CompactionCompletedEvent2.type, detail);
+  }
+};
+var SessionForkedEvent = class SessionForkedEvent2 extends ConversationEvent {
+  static type = "session.forked";
+  constructor(detail) {
+    super(SessionForkedEvent2.type, detail);
+  }
+};
+var SessionTaggedEvent = class SessionTaggedEvent2 extends ConversationEvent {
+  static type = "session.tagged";
+  constructor(detail) {
+    super(SessionTaggedEvent2.type, detail);
+  }
+};
+var SessionRenamedEvent = class SessionRenamedEvent2 extends ConversationEvent {
+  static type = "session.renamed";
+  constructor(detail) {
+    super(SessionRenamedEvent2.type, detail);
+  }
+};
+var PersistenceErrorEvent = class PersistenceErrorEvent2 extends Event {
+  static type = "persistence.error";
+  error;
+  constructor(error) {
+    super(PersistenceErrorEvent2.type);
+    this.error = error;
+  }
+};
+var conversationEventConstructors = {
+  [ConversationChangeEvent.type]: ConversationChangeEvent,
+  [ConversationPushEvent.type]: ConversationPushEvent,
+  [ConversationUndoEvent.type]: ConversationUndoEvent,
+  [ConversationRedoEvent.type]: ConversationRedoEvent,
+  [ConversationSwitchEvent.type]: ConversationSwitchEvent,
+  [MessagesAppendedEvent.type]: MessagesAppendedEvent,
+  [MessagesUpdatedEvent.type]: MessagesUpdatedEvent,
+  [MessagesRemovedEvent.type]: MessagesRemovedEvent,
+  [ToolCallsAppendedEvent.type]: ToolCallsAppendedEvent,
+  [ToolResultsAppendedEvent.type]: ToolResultsAppendedEvent,
+  [StreamStartedEvent.type]: StreamStartedEvent,
+  [StreamUpdatedEvent.type]: StreamUpdatedEvent,
+  [StreamFinalizedEvent.type]: StreamFinalizedEvent,
+  [StreamCancelledEvent.type]: StreamCancelledEvent,
+  [CompactionStartedEvent.type]: CompactionStartedEvent,
+  [CompactionCompletedEvent.type]: CompactionCompletedEvent,
+  [SessionForkedEvent.type]: SessionForkedEvent,
+  [SessionTaggedEvent.type]: SessionTaggedEvent,
+  [SessionRenamedEvent.type]: SessionRenamedEvent
+};
+function Y(H, f, R) {
+  let P = R?.bufferSize ?? 256, D = R?.signal, G = [], M = null, B = false;
+  function C(K) {
+    let Q = K;
+    if (M) {
+      let z = M;
+      M = null, z({
+        value: Q,
+        done: false
+      });
+    } else if (G.length < P)
+      G.push(Q);
+  }
+  function J() {
+    if (B)
+      return;
+    if (B = true, H.removeEventListener(f, C), M) {
+      let K = M;
+      M = null, K({
+        value: undefined,
+        done: true
+      });
+    }
+  }
+  if (D?.aborted)
+    B = true;
+  else
+    H.addEventListener(f, C), D?.addEventListener("abort", J, { once: true });
+  return {
+    next() {
+      if (G.length > 0)
+        return Promise.resolve({
+          value: G.shift(),
+          done: false
+        });
+      if (B)
+        return Promise.resolve({
+          value: undefined,
+          done: true
+        });
+      return new Promise((K) => {
+        M = K;
+      });
+    },
+    return() {
+      return J(), Promise.resolve({
+        value: undefined,
+        done: true
+      });
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function Z(H, f, R) {
+  return { subscribe(P, D, G) {
+    let M = typeof P === "function" ? {
+      next: P,
+      error: D,
+      complete: G
+    } : P ?? {}, B = new AbortController, C = false, J = {
+      unsubscribe() {
+        if (C)
+          return;
+        C = true, B.abort(), M.complete?.();
+      },
+      get closed() {
+        return C;
+      }
+    };
+    if (M.start?.(J), C)
+      return J;
+    function U(Q) {
+      M.next?.(Q);
+    }
+    let K = R?.signal ? AbortSignal.any([R.signal, B.signal]) : B.signal;
+    if (H.addEventListener(f, U, { signal: K }), R?.signal)
+      R.signal.addEventListener("abort", () => {
+        if (!C)
+          C = true, M.complete?.();
+      }, {
+        once: true,
+        signal: B.signal
+      });
+    return J;
+  } };
+}
+var W = class extends EventTarget {
+  constructor() {
+    super();
+  }
+  addEventListener(H, f, R) {
+    super.addEventListener(H, f, R);
+  }
+  removeEventListener(H, f, R) {
+    super.removeEventListener(H, f, R);
+  }
+  dispatch(H) {
+    return this.dispatchEvent(H);
+  }
+};
+var j = class extends W {
+  #H = new AbortController;
+  #f = /* @__PURE__ */ new Set;
+  constructor() {
+    super();
+  }
+  get completed() {
+    return this.#H.signal.aborted;
+  }
+  get signal() {
+    return this.#H.signal;
+  }
+  complete() {
+    if (!this.#H.signal.aborted)
+      this.#H.abort();
+  }
+  dispatchEvent(H) {
+    let f = super.dispatchEvent(H);
+    for (let R of this.#f)
+      R(H);
+    return f;
+  }
+  on(H, f) {
+    return Z(this, H, { signal: f?.signal ?? this.signal });
+  }
+  once(H, f) {
+    this.addEventListener(H, f, {
+      once: true,
+      signal: this.signal
+    });
+  }
+  subscribe(H, f, R, P) {
+    return this.on(H).subscribe(f, R, P);
+  }
+  toObservable() {
+    return { subscribe: (H, f, R) => {
+      let P = typeof H === "function" ? {
+        next: H,
+        error: f,
+        complete: R
+      } : H ?? {}, D = false, G = (B) => {
+        if (!D)
+          P.next?.(B);
+      };
+      this.#f.add(G);
+      let M = () => {
+        if (!D)
+          D = true, this.#f.delete(G), P.complete?.();
+      };
+      return this.signal.addEventListener("abort", M, { once: true }), {
+        unsubscribe: () => {
+          if (D)
+            return;
+          D = true, this.#f.delete(G), this.signal.removeEventListener("abort", M), P.complete?.();
+        },
+        get closed() {
+          return D;
+        }
+      };
+    } };
+  }
+  events(H, f) {
+    return Y(this, H, {
+      signal: f?.signal ?? this.signal,
+      bufferSize: f?.bufferSize
+    });
+  }
+};
+function diffConversationMessages(previousConversation, nextConversation) {
+  const previousIds = new Set(previousConversation.ids);
+  const nextIds = new Set(nextConversation.ids);
+  const appended = nextConversation.ids.filter((id) => !previousIds.has(id));
+  const removed = previousConversation.ids.filter((id) => !nextIds.has(id));
+  const updated = [];
+  for (const id of nextConversation.ids) {
+    if (!previousIds.has(id))
+      continue;
+    const previousMessage = previousConversation.messages[id];
+    const nextMessage = nextConversation.messages[id];
+    if (!previousMessage || !nextMessage)
+      continue;
+    if (JSON.stringify(previousMessage) !== JSON.stringify(nextMessage))
+      updated.push(id);
+  }
+  return {
+    appended,
+    updated,
+    removed
+  };
+}
+function collectToolCallIds(conversation, messageIds) {
+  if (!messageIds || messageIds.length === 0)
+    return;
+  const ids = /* @__PURE__ */ new Set;
+  for (const messageId of messageIds) {
+    const message = conversation.messages[messageId];
+    if (!message)
+      continue;
+    if (message.toolCall?.id)
+      ids.add(message.toolCall.id);
+    if (message.toolResult?.callId)
+      ids.add(message.toolResult.callId);
+  }
+  return ids.size > 0 ? [...ids] : undefined;
+}
+async function loadConversationAdapter(provider) {
+  switch (provider) {
+    case "openai":
+      return (await import("./index-8fhvxk30.js")).openAIConversationAdapter;
+    case "anthropic":
+      return (await import("./index-x2ysg8ds.js")).anthropicConversationAdapter;
+    case "gemini":
+      return (await import("./index-49we2xfs.js")).geminiConversationAdapter;
+  }
+}
+var Conversation = class Conversation2 {
+  currentNode;
+  environment;
+  emitter = new j;
+  constructor(initial = createConversationHistory(), environment) {
+    this.environment = resolveConversationEnvironment(environment);
+    const safeInitial = ensureConversationSafe(initial);
+    this.currentNode = {
+      conversation: safeInitial,
+      parent: null,
+      children: []
+    };
+    if (this.environment.persistence) {
+      const store = this.environment.persistence;
+      const setTimeoutFunction = this.environment.setTimeoutFunction ?? ((callback, milliseconds) => setTimeout(() => {
+        callback();
+      }, milliseconds));
+      const clearTimeoutFunction = this.environment.clearTimeoutFunction ?? ((handle) => clearTimeout(handle));
+      const debounceMilliseconds = this.environment.persistenceDebounceMilliseconds ?? 100;
+      let debounceTimer;
+      let hasDebounceTimer = false;
+      this.addEventListener("change", () => {
+        if (hasDebounceTimer)
+          clearTimeoutFunction(debounceTimer);
+        debounceTimer = setTimeoutFunction(() => {
+          const conversation = this.current;
+          return Promise.all([store.set(`session:${conversation.id}`, JSON.stringify(conversation)), store.set(`session-info:${conversation.id}`, JSON.stringify(toSessionInfo(conversation)))]).then(() => {
+            return;
+          }).catch((error) => {
+            this.emitter.dispatchEvent(new PersistenceErrorEvent(error));
+          });
+        }, debounceMilliseconds);
+        hasDebounceTimer = true;
+      });
+    }
+  }
+  buildEventDetail(action, previousConversation, context = {}) {
+    return {
+      action,
+      conversation: this.current,
+      previousConversation,
+      ...context.messageIds && context.messageIds.length > 0 ? { messageIds: context.messageIds } : {},
+      ...context.toolCallIds && context.toolCallIds.length > 0 ? { toolCallIds: context.toolCallIds } : {}
+    };
+  }
+  emitConversationEvent(type, detail) {
+    const EventConstructor = conversationEventConstructors[type];
+    if (EventConstructor)
+      this.emitter.dispatchEvent(new EventConstructor(detail));
+  }
+  commit(next, changeAction, emittedEvents, context) {
+    const previousConversation = this.current;
+    const newNode = {
+      conversation: next,
+      parent: this.currentNode,
+      children: []
+    };
+    this.currentNode.children.push(newNode);
+    this.currentNode = newNode;
+    if (this.environment.maxHistoryDepth !== undefined)
+      this.pruneToDepth(this.environment.maxHistoryDepth);
+    this.emitConversationEvent("change", this.buildEventDetail(changeAction, previousConversation, context));
+    for (const eventType of emittedEvents) {
+      if (eventType === "change")
+        continue;
+      const eventAction = eventType;
+      this.emitConversationEvent(eventType, this.buildEventDetail(eventAction, previousConversation, context));
+    }
+  }
+  pruneToDepth(maxDepth) {
+    let depth = 0;
+    let node = this.currentNode;
+    while (node) {
+      depth++;
+      node = node.parent;
+    }
+    while (depth > maxDepth) {
+      let root = this.currentNode;
+      while (root.parent)
+        root = root.parent;
+      const childOnPath = root.children.find((child) => {
+        let curr = this.currentNode;
+        while (curr) {
+          if (curr === child)
+            return true;
+          curr = curr.parent;
+        }
+        return false;
+      });
+      if (!childOnPath)
+        break;
+      childOnPath.parent = null;
+      depth--;
+    }
+  }
+  addEventListener(type, callback, options) {
+    const resolved = typeof options === "boolean" ? { capture: options } : { ...options };
+    resolved.signal ??= this.emitter.signal;
+    this.emitter.addEventListener(type, callback, resolved);
+  }
+  removeEventListener(type, callback, options) {
+    this.emitter.removeEventListener(type, callback, options);
+  }
+  dispatchEvent(event) {
+    return this.emitter.dispatchEvent(event);
+  }
+  watch(run) {
+    run(this.current);
+    const handler = (event) => {
+      run(event.conversation);
+    };
+    this.emitter.addEventListener("change", handler, { signal: this.emitter.signal });
+    return () => {
+      this.emitter.removeEventListener("change", handler);
+    };
+  }
+  on(type) {
+    return this.emitter.on(type);
+  }
+  once(type, listener) {
+    this.emitter.once(type, listener);
+  }
+  subscribe(type, observerOrNext, error, complete) {
+    return this.emitter.subscribe(type, observerOrNext, error, complete);
+  }
+  toObservable() {
+    return this.emitter.toObservable();
+  }
+  events(type, options) {
+    return this.emitter.events(type, options);
+  }
+  complete() {
+    this.emitter.complete();
+  }
+  get completed() {
+    return this.emitter.completed;
+  }
+  getSnapshot() {
+    return this.current;
+  }
+  get current() {
+    return this.currentNode.conversation;
+  }
+  get ids() {
+    return getMessageIds(this.current);
+  }
+  get canUndo() {
+    return this.currentNode.parent !== null;
+  }
+  get canRedo() {
+    return this.currentNode.children.length > 0;
+  }
+  get env() {
+    return this.environment;
+  }
+  get branchCount() {
+    return this.currentNode.parent ? this.currentNode.parent.children.length : 1;
+  }
+  get branchIndex() {
+    if (!this.currentNode.parent)
+      return 0;
+    return this.currentNode.parent.children.indexOf(this.currentNode);
+  }
+  get redoCount() {
+    return this.currentNode.children.length;
+  }
+  createChangeContext(previousConversation, nextConversation, action) {
+    const diff = diffConversationMessages(previousConversation, nextConversation);
+    const messageIds = action === "messages.appended" ? diff.appended : action === "messages.updated" ? diff.updated : diff.removed;
+    const toolCallIds = collectToolCallIds(action === "messages.removed" ? previousConversation : nextConversation, messageIds);
+    return {
+      ...messageIds.length > 0 ? { messageIds } : {},
+      ...toolCallIds ? { toolCallIds } : {}
+    };
+  }
+  pushWithEvents(next, changeAction, context) {
+    this.commit(next, changeAction, ["push", changeAction], context);
+  }
+  push(next) {
+    this.commit(next, "push", ["push"]);
+  }
+  undo() {
+    if (this.currentNode.parent) {
+      const previousConversation = this.current;
+      this.currentNode = this.currentNode.parent;
+      this.emitConversationEvent("change", this.buildEventDetail("undo", previousConversation));
+      this.emitConversationEvent("undo", this.buildEventDetail("undo", previousConversation));
+      return this.current;
+    }
+  }
+  redo(childIndex = 0) {
+    const next = this.currentNode.children[childIndex];
+    if (next) {
+      const previousConversation = this.current;
+      this.currentNode = next;
+      this.emitConversationEvent("change", this.buildEventDetail("redo", previousConversation));
+      this.emitConversationEvent("redo", this.buildEventDetail("redo", previousConversation));
+      return this.current;
+    }
+  }
+  switchToBranch(index) {
+    if (this.currentNode.parent) {
+      const target = this.currentNode.parent.children[index];
+      if (target) {
+        const previousConversation = this.current;
+        this.currentNode = target;
+        this.emitConversationEvent("change", this.buildEventDetail("switch", previousConversation));
+        this.emitConversationEvent("switch", this.buildEventDetail("switch", previousConversation));
+        return this.current;
+      }
+    }
+  }
+  fork(messageId) {
+    const previous = this.current;
+    const cloned = JSON.parse(JSON.stringify(this.current));
+    let forkedHistory;
+    if (messageId) {
+      const messageIndex = cloned.ids.indexOf(messageId);
+      if (messageIndex === -1)
+        throw new Error(`Message with id "${messageId}" not found`);
+      const truncatedIds = cloned.ids.slice(0, messageIndex + 1);
+      const truncatedMessages = {};
+      for (const id of truncatedIds) {
+        const message = cloned.messages[id];
+        if (message)
+          truncatedMessages[id] = message;
+      }
+      forkedHistory = {
+        ...cloned,
+        id: this.environment.randomId(),
+        ids: truncatedIds,
+        messages: truncatedMessages,
+        updatedAt: this.environment.now()
+      };
+    } else
+      forkedHistory = {
+        ...cloned,
+        id: this.environment.randomId(),
+        updatedAt: this.environment.now()
+      };
+    const detail = this.buildEventDetail("session.forked", previous);
+    this.emitConversationEvent("session.forked", detail);
+    this.emitConversationEvent("change", detail);
+    return new Conversation2(forkedHistory, this.environment);
+  }
+  tag(label) {
+    const previous = this.current;
+    const existingTags = previous.metadata["_tags"] ?? [];
+    if (existingTags.includes(label))
+      return;
+    const next = {
+      ...previous,
+      metadata: {
+        ...previous.metadata,
+        _tags: [...existingTags, label]
+      },
+      updatedAt: this.environment.now()
+    };
+    this.commit(next, "session.tagged", ["push", "session.tagged"]);
+  }
+  rename(title) {
+    const previous = this.current;
+    if (previous.title === title)
+      return;
+    const next = {
+      ...previous,
+      title,
+      updatedAt: this.environment.now()
+    };
+    this.commit(next, "session.renamed", ["push", "session.renamed"]);
+  }
+  getPath() {
+    const path = [];
+    let curr = this.currentNode;
+    while (curr) {
+      path.unshift(curr.conversation);
+      curr = curr.parent;
+    }
+    return path;
+  }
+  getMessages(options) {
+    return getMessages(this.current, options);
+  }
+  getMessageAtPosition(position) {
+    return getMessageAtPosition(this.current, position);
+  }
+  getMessageIds() {
+    return getMessageIds(this.current);
+  }
+  getMessageById(id) {
+    return getMessageById(this.current, id);
+  }
+  get(id) {
+    return getMessageById(this.current, id);
+  }
+  searchMessages(predicate) {
+    return searchConversationMessages(this.current, predicate);
+  }
+  getStatistics() {
+    return getStatistics(this.current);
+  }
+  hasSystemMessage() {
+    return hasSystemMessage(this.current);
+  }
+  getFirstSystemMessage() {
+    return getFirstSystemMessage(this.current);
+  }
+  getSystemMessages() {
+    return getSystemMessages(this.current);
+  }
+  toChatMessages() {
+    return toChatMessages(this.current);
+  }
+  estimateTokens(estimator) {
+    return estimateConversationTokens(this.current, estimator, this.env);
+  }
+  getRecentMessages(count, options) {
+    return getRecentMessages(this.current, count, options);
+  }
+  getStreamingMessage() {
+    return getStreamingMessage(this.current);
+  }
+  appendMessages(...inputs) {
+    const previousConversation = this.current;
+    const nextConversation = appendMessages(this.current, ...inputs, this.env);
+    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
+  }
+  appendUserMessage(content, metadata) {
+    const previousConversation = this.current;
+    const nextConversation = appendUserMessage(this.current, content, metadata, this.env);
+    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
+  }
+  appendAssistantMessage(content, metadata) {
+    const previousConversation = this.current;
+    const nextConversation = appendAssistantMessage(this.current, content, metadata, this.env);
+    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
+  }
+  appendSystemMessage(content, metadata) {
+    const previousConversation = this.current;
+    const nextConversation = appendSystemMessage(this.current, content, metadata, this.env);
+    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
+  }
+  prependSystemMessage(content, metadata) {
+    const previousConversation = this.current;
+    const nextConversation = prependSystemMessage(this.current, content, metadata, this.env);
+    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
+  }
+  replaceSystemMessage(content, metadata) {
+    const previousConversation = this.current;
+    const nextConversation = replaceSystemMessage(this.current, content, metadata, this.env);
+    this.pushWithEvents(nextConversation, "messages.updated", this.createChangeContext(previousConversation, nextConversation, "messages.updated"));
+  }
+  collapseSystemMessages() {
+    const previousConversation = this.current;
+    const nextConversation = collapseSystemMessages(this.current, this.env);
+    const action = previousConversation.ids.length === nextConversation.ids.length ? "messages.updated" : "messages.removed";
+    this.pushWithEvents(nextConversation, action, this.createChangeContext(previousConversation, nextConversation, action));
+  }
+  redactMessageAtPosition(position, placeholderOrOptions) {
+    const previousConversation = this.current;
+    const nextConversation = redactMessageAtPosition(this.current, position, placeholderOrOptions, this.env);
+    this.pushWithEvents(nextConversation, "messages.updated", this.createChangeContext(previousConversation, nextConversation, "messages.updated"));
+  }
+  truncateFromPosition(position, options) {
+    const previousConversation = this.current;
+    const nextConversation = truncateFromPosition(this.current, position, options, this.env);
+    this.pushWithEvents(nextConversation, "messages.removed", this.createChangeContext(previousConversation, nextConversation, "messages.removed"));
+  }
+  truncateToTokenLimit(maxTokens, options) {
+    const previousConversation = this.current;
+    const nextConversation = truncateToTokenLimit(this.current, maxTokens, options, this.env);
+    this.pushWithEvents(nextConversation, "messages.removed", this.createChangeContext(previousConversation, nextConversation, "messages.removed"));
+  }
+  async compact(summarizer, options) {
+    const previous = this.current;
+    this.emitConversationEvent("compaction.started", this.buildEventDetail("compaction.started", previous));
+    const { conversation, result } = await compactConversation(this.current, summarizer, options, this.env);
+    if (result.compacted)
+      this.pushWithEvents(conversation, "compaction.completed", this.createChangeContext(previous, conversation, "messages.removed"));
+    else
+      this.emitConversationEvent("compaction.completed", this.buildEventDetail("compaction.completed", previous));
+    return result;
+  }
+  appendStreamingMessage(role, metadata) {
+    const { conversation, messageId } = appendStreamingMessage(this.current, role, metadata, this.env);
+    this.commit(conversation, "stream.started", [
+      "push",
+      "messages.appended",
+      "stream.started"
+    ], { messageIds: [messageId] });
+    return messageId;
+  }
+  updateStreamingMessage(messageId, content) {
+    const nextConversation = updateStreamingMessage(this.current, messageId, content, this.env);
+    this.commit(nextConversation, "stream.updated", [
+      "push",
+      "messages.updated",
+      "stream.updated"
+    ], { messageIds: [messageId] });
+  }
+  finalizeStreamingMessage(messageId, options) {
+    const nextConversation = finalizeStreamingMessage(this.current, messageId, options, this.env);
+    this.commit(nextConversation, "stream.finalized", [
+      "push",
+      "messages.updated",
+      "stream.finalized"
+    ], { messageIds: [messageId] });
+  }
+  cancelStreamingMessage(messageId) {
+    const nextConversation = cancelStreamingMessage(this.current, messageId, this.env);
+    this.commit(nextConversation, "stream.cancelled", [
+      "push",
+      "messages.removed",
+      "stream.cancelled"
+    ], { messageIds: [messageId] });
+  }
+  appendToolCall(toolCall, options) {
+    const nextConversation = appendToolCall(this.current, toolCall, options, this.env);
+    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
+    this.commit(nextConversation, "tool-calls.appended", [
+      "push",
+      "messages.appended",
+      "tool-calls.appended"
+    ], context);
+  }
+  appendToolCalls(toolCalls) {
+    const nextConversation = appendToolCalls(this.current, toolCalls, this.env);
+    if (nextConversation === this.current)
+      return;
+    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
+    this.commit(nextConversation, "tool-calls.appended", [
+      "push",
+      "messages.appended",
+      "tool-calls.appended"
+    ], context);
+  }
+  appendToolResult(toolResult, options) {
+    const nextConversation = appendToolResult(this.current, toolResult, options, this.env);
+    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
+    this.commit(nextConversation, "tool-results.appended", [
+      "push",
+      "messages.appended",
+      "tool-results.appended"
+    ], context);
+  }
+  appendToolResults(toolResults) {
+    const nextConversation = appendToolResults(this.current, toolResults, this.env);
+    if (nextConversation === this.current)
+      return;
+    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
+    this.commit(nextConversation, "tool-results.appended", [
+      "push",
+      "messages.appended",
+      "tool-results.appended"
+    ], context);
+  }
+  async appendToolResultAsync(toolResult, options) {
+    const nextConversation = await appendToolResultAsync(this.current, toolResult, options, this.env);
+    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
+    this.commit(nextConversation, "tool-results.appended", [
+      "push",
+      "messages.appended",
+      "tool-results.appended"
+    ], context);
+  }
+  async appendToolResultsAsync(toolResults) {
+    const nextConversation = await appendToolResultsAsync(this.current, toolResults, this.env);
+    if (nextConversation === this.current)
+      return;
+    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
+    this.commit(nextConversation, "tool-results.appended", [
+      "push",
+      "messages.appended",
+      "tool-results.appended"
+    ], context);
+  }
+  getPendingToolCalls() {
+    return getPendingToolCalls(this.current);
+  }
+  getToolInteractions() {
+    return getToolInteractions(this.current);
+  }
+  static async fromProvider(provider, payload, environment) {
+    return new Conversation2((await loadConversationAdapter(provider)).import(payload), environment);
+  }
+  async toProvider(provider, options) {
+    return (await loadConversationAdapter(provider)).export(this.current, options);
+  }
+  async appendProvider(provider, payload) {
+    const nextConversation = (await loadConversationAdapter(provider)).append(this.current, payload);
+    if (nextConversation === this.current)
+      return;
+    const diff = diffConversationMessages(this.current, nextConversation);
+    const appendedIds = diff.appended;
+    const updatedIds = diff.updated;
+    const removedIds = diff.removed;
+    const action = removedIds.length > 0 ? "messages.removed" : updatedIds.length > 0 ? "messages.updated" : "messages.appended";
+    const messageIds = action === "messages.removed" ? removedIds : action === "messages.updated" ? updatedIds : appendedIds;
+    const toolCallIds = collectToolCallIds(nextConversation, messageIds);
+    this.commit(nextConversation, action, ["push", action], {
+      ...messageIds.length > 0 ? { messageIds } : {},
+      ...toolCallIds ? { toolCallIds } : {}
+    });
+  }
+  snapshot() {
+    const getPath = (node) => {
+      const path = [];
+      let curr = node;
+      while (curr.parent) {
+        path.unshift(curr.parent.children.indexOf(curr));
+        curr = curr.parent;
+      }
+      return path;
+    };
+    const serializeNode = (node) => ({
+      conversation: node.conversation,
+      children: node.children.map(serializeNode)
+    });
+    let root = this.currentNode;
+    while (root.parent)
+      root = root.parent;
+    return {
+      root: serializeNode(root),
+      currentPath: getPath(this.currentNode)
+    };
+  }
+  static from(json, environment) {
+    const conversation = new Conversation2(deserializeConversationHistory(json.root.conversation), environment);
+    const buildTree = (nodeJSON, parentNode) => {
+      const node = {
+        conversation: deserializeConversationHistory(nodeJSON.conversation),
+        parent: parentNode,
+        children: []
+      };
+      node.children = nodeJSON.children.map((child) => buildTree(child, node));
+      return node;
+    };
+    const rootNode = conversation.currentNode;
+    rootNode.children = json.root.children.map((child) => buildTree(child, rootNode));
+    let current = rootNode;
+    for (const index of json.currentPath) {
+      const target = current.children[index];
+      if (target)
+        current = target;
+    }
+    conversation.currentNode = current;
+    return conversation;
+  }
+  static async fromOpenAIMessages(messages, environment) {
+    return Conversation2.fromProvider("openai", [...messages], environment);
+  }
+  static async fromAnthropicMessages(payload, environment) {
+    return Conversation2.fromProvider("anthropic", payload, environment);
+  }
+  static async fromGeminiMessages(payload, environment) {
+    return Conversation2.fromProvider("gemini", payload, environment);
+  }
+  async toOpenAIMessages() {
+    return this.toProvider("openai", { groupToolCalls: false });
+  }
+  async toOpenAIMessagesGrouped() {
+    return this.toProvider("openai", { groupToolCalls: true });
+  }
+  async toAnthropicMessages() {
+    return this.toProvider("anthropic");
+  }
+  async toGeminiMessages() {
+    return this.toProvider("gemini");
+  }
+  bind(fn) {
+    return (...args) => {
+      const result = fn(this.current, ...args, this.env);
+      if (isConversationHistory(result))
+        this.push(result);
+      return result;
+    };
+  }
+  [Symbol.dispose]() {
+    this.complete();
+    let root = this.currentNode;
+    while (root?.parent)
+      root = root.parent;
+    const clearNode = (node) => {
+      for (const child of node.children)
+        clearNode(child);
+      node.children = [];
+      const n = node;
+      n.parent = null;
+      n.conversation = null;
+    };
+    if (root)
+      clearNode(root);
+  }
+};
+function isConversationHistory(value) {
+  return value !== null && typeof value === "object" && typeof value.schemaVersion === "number" && typeof value.id === "string" && typeof value.status === "string" && value.metadata !== null && typeof value.metadata === "object" && Array.isArray(value.ids) && typeof value.messages === "object" && value.messages !== null && !Array.isArray(value.messages) && typeof value.createdAt === "string" && typeof value.updatedAt === "string";
+}
+
+// src/components/chat/utilities/conversation.ts
+function hasPairableToolField(message) {
+  return message.role === "tool-call" && message.toolCall !== undefined || message.role === "tool-result" && message.toolResult !== undefined;
+}
+function pairToolCallsWithResults2(messages) {
+  return pairToolCallsWithResults(messages.filter(hasPairableToolField));
+}
+export { pairToolCallsWithResults2 as pairToolCallsWithResults, resolveMessageReasoning, resolveMessageSteps, resolveMessageSuggestions, getMessageText, deriveMessageParts, getMessageRoleLabel, formatMessageAsMarkdown, messagesToMarkdown };
+
+//# debugId=881E2782584A045764756E2164756E21