@lostgradient/cinder 0.5.0 → 0.7.0

package/dist/server/index.server-3jr3n02r.js

@@ -1,1835 +0,0 @@
-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-n16wn1ps.js";
-import {
-  __require
-} from "./index.server-wckvcay0.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-d3jpz7nh.js")).openAIConversationAdapter;
-    case "anthropic":
-      return (await import("./index-2ynappje.js")).anthropicConversationAdapter;
-    case "gemini":
-      return (await import("./index-v5tk8a0j.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