@lostgradient/cinder 0.4.1 → 0.6.0

package/dist/components/chat-conversation-list/index.js

@@ -1,4 +1,34 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -21,44 +51,3999 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// ../../node_modules/conversationalist/dist/message-BEjqY7Jv.js
+function copyMultiModalContent(item) {
+  if (item.type === "text")
+    return {
+      type: "text",
+      text: item.text,
+      ...item.citations !== undefined ? { citations: structuredClone(item.citations) } : {}
+    };
+  if (item.type === "thinking")
+    return {
+      type: "thinking",
+      thinking: item.thinking,
+      signature: item.signature
+    };
+  if (item.type === "redacted_thinking")
+    return {
+      type: "redacted_thinking",
+      data: item.data
+    };
+  if (item.type === "server_tool_use")
+    return {
+      type: "server_tool_use",
+      id: item.id,
+      name: item.name,
+      input: structuredClone(item.input)
+    };
+  if (item.type === "web_search_tool_result")
+    return {
+      type: "web_search_tool_result",
+      tool_use_id: item.tool_use_id,
+      content: structuredClone(item.content)
+    };
+  if (item.type === "code_execution_tool_result" || item.type === "bash_code_execution_tool_result" || item.type === "text_editor_code_execution_tool_result" || item.type === "web_fetch_tool_result")
+    return {
+      type: item.type,
+      tool_use_id: item.tool_use_id,
+      content: structuredClone(item.content)
+    };
+  if (item.type === "container_upload")
+    return {
+      type: "container_upload",
+      file_id: item.file_id
+    };
+  const image = item;
+  return {
+    type: "image",
+    url: image.url,
+    ...image.mimeType !== undefined ? { mimeType: image.mimeType } : {},
+    ...image.text !== undefined ? { text: image.text } : {}
+  };
+}
+function copyContent(content) {
+  if (typeof content === "string")
+    return content;
+  return content.map(copyMultiModalContent);
+}
+function toReadonly(value) {
+  return value;
+}
+function createMessage(props) {
+  const content = typeof props.content === "string" ? props.content : toReadonly(structuredClone([...props.content]));
+  const message = {
+    id: props.id,
+    role: props.role,
+    content,
+    position: props.position,
+    createdAt: props.createdAt,
+    metadata: toReadonly({ ...props.metadata }),
+    hidden: props.hidden,
+    toolCall: props.toolCall ? toReadonly(structuredClone(props.toolCall)) : undefined,
+    toolResult: props.toolResult ? toReadonly(structuredClone(props.toolResult)) : undefined,
+    tokenUsage: props.tokenUsage ? toReadonly({ ...props.tokenUsage }) : undefined
+  };
+  if (isAssistantMessage(props))
+    return toReadonly({
+      ...message,
+      role: "assistant",
+      goalCompleted: props.goalCompleted
+    });
+  return toReadonly(message);
+}
+function messageParts(message) {
+  if (typeof message.content === "string")
+    return message.content ? [{
+      type: "text",
+      text: message.content
+    }] : [];
+  return message.content;
+}
+function messageHasImages(message) {
+  return messageParts(message).some((p) => p.type === "image");
+}
+function isAssistantMessage(message) {
+  return message.role === "assistant";
+}
+var init_message_BEjqY7Jv = () => {};
+
+// ../../node_modules/conversationalist/dist/schemas.js
+import { z } from "zod";
+var isPlainObject = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  const prototype = Reflect.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}, jsonValueSchema, multiModalContentSchema, messageRoleSchema, toolCallSchema, toolCallInputSchema, toolErrorCategorySchema, toolErrorSchema, toolActionSchema, toolResultSchema, tokenUsageSchema, messageInputSchema, messageSchema, conversationStatusSchema, conversationShape, conversationSchema;
+var init_schemas = __esm(() => {
+  jsonValueSchema = z.lazy(() => {
+    const jsonObjectSchema = z.preprocess((value, ctx) => {
+      if (!isPlainObject(value)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "expected a plain object"
+        });
+        return z.NEVER;
+      }
+      return value;
+    }, z.record(z.string(), jsonValueSchema));
+    return z.union([
+      z.string(),
+      z.number().refine((value) => Number.isFinite(value), { message: "expected a finite number" }),
+      z.boolean(),
+      z.null(),
+      z.array(jsonValueSchema),
+      jsonObjectSchema
+    ]);
+  });
+  multiModalContentSchema = z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("text"),
+      text: z.string(),
+      citations: jsonValueSchema.optional()
+    }),
+    z.object({
+      type: z.literal("image"),
+      url: z.string().url(),
+      mimeType: z.string().optional(),
+      text: z.string().optional()
+    }),
+    z.object({
+      type: z.literal("thinking"),
+      thinking: z.string(),
+      signature: z.string()
+    }),
+    z.object({
+      type: z.literal("redacted_thinking"),
+      data: z.string()
+    }),
+    z.object({
+      type: z.literal("server_tool_use"),
+      id: z.string(),
+      name: z.string(),
+      input: jsonValueSchema
+    }),
+    z.object({
+      type: z.literal("web_search_tool_result"),
+      tool_use_id: z.string(),
+      content: jsonValueSchema
+    }),
+    z.object({
+      type: z.enum([
+        "code_execution_tool_result",
+        "bash_code_execution_tool_result",
+        "text_editor_code_execution_tool_result",
+        "web_fetch_tool_result"
+      ]),
+      tool_use_id: z.string(),
+      content: jsonValueSchema
+    }),
+    z.object({
+      type: z.literal("container_upload"),
+      file_id: z.string()
+    })
+  ]).transform((value) => {
+    if (value.type === "image")
+      return {
+        type: "image",
+        url: value.url,
+        ...value.mimeType !== undefined ? { mimeType: value.mimeType } : {},
+        ...value.text !== undefined ? { text: value.text } : {}
+      };
+    if (value.type === "text")
+      return {
+        type: "text",
+        text: value.text,
+        ...value.citations !== undefined ? { citations: value.citations } : {}
+      };
+    return value;
+  });
+  messageRoleSchema = z.enum([
+    "user",
+    "assistant",
+    "system",
+    "developer",
+    "tool-call",
+    "tool-result",
+    "snapshot"
+  ]);
+  toolCallSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    arguments: jsonValueSchema
+  }).strict();
+  toolCallInputSchema = z.object({
+    id: z.string().optional(),
+    name: z.string(),
+    arguments: jsonValueSchema.optional()
+  }).strict();
+  toolErrorCategorySchema = z.enum([
+    "validation",
+    "permission",
+    "not_found",
+    "conflict",
+    "transient",
+    "timeout",
+    "cancelled",
+    "internal"
+  ]);
+  toolErrorSchema = z.object({
+    code: z.string(),
+    category: toolErrorCategorySchema,
+    retryable: z.boolean(),
+    message: z.string(),
+    details: jsonValueSchema.optional()
+  }).strict();
+  toolActionSchema = z.object({
+    type: z.enum(["approval", "input"]),
+    message: z.string().optional(),
+    schema: jsonValueSchema.optional()
+  }).strict();
+  toolResultSchema = z.object({
+    callId: z.string(),
+    outcome: z.enum([
+      "success",
+      "error",
+      "action_required"
+    ]),
+    content: jsonValueSchema,
+    error: toolErrorSchema.optional(),
+    action: toolActionSchema.optional(),
+    inputDigest: z.string().optional(),
+    outputDigest: z.string().optional()
+  }).strict();
+  tokenUsageSchema = z.object({
+    prompt: z.number().int().min(0),
+    completion: z.number().int().min(0),
+    total: z.number().int().min(0)
+  });
+  messageInputSchema = z.object({
+    role: messageRoleSchema,
+    content: z.union([z.string(), z.array(multiModalContentSchema)]),
+    metadata: z.record(z.string(), jsonValueSchema).optional(),
+    hidden: z.boolean().optional(),
+    toolCall: toolCallSchema.optional(),
+    toolResult: toolResultSchema.optional(),
+    tokenUsage: tokenUsageSchema.optional(),
+    goalCompleted: z.boolean().optional()
+  }).strict();
+  messageSchema = z.object({
+    id: z.string(),
+    role: messageRoleSchema,
+    content: z.union([z.string(), z.array(multiModalContentSchema)]),
+    position: z.number().int().min(0),
+    createdAt: z.string(),
+    metadata: z.record(z.string(), jsonValueSchema),
+    hidden: z.boolean(),
+    toolCall: toolCallSchema.optional(),
+    toolResult: toolResultSchema.optional(),
+    tokenUsage: tokenUsageSchema.optional(),
+    goalCompleted: z.boolean().optional()
+  }).strict();
+  conversationStatusSchema = z.enum([
+    "active",
+    "archived",
+    "deleted"
+  ]);
+  conversationShape = {
+    schemaVersion: z.number().int().min(1),
+    id: z.string(),
+    title: z.string().optional(),
+    status: conversationStatusSchema,
+    metadata: z.record(z.string(), jsonValueSchema),
+    ids: z.array(z.string()),
+    messages: z.record(z.string(), messageSchema),
+    createdAt: z.string(),
+    updatedAt: z.string()
+  };
+  conversationSchema = z.object(conversationShape).strict();
+});
+
+// ../../node_modules/conversationalist/dist/transient-Bk0RaCFf.js
+function getOrderedMessages(conversation) {
+  const ordered = [];
+  for (const id of conversation.ids) {
+    const message = conversation.messages[id];
+    if (message)
+      ordered.push(message);
+  }
+  return ordered;
+}
+function toIdRecord(items) {
+  const record = {};
+  for (const item of items)
+    record[item.id] = item;
+  return record;
+}
+function createInvalidPositionError(expected, actual) {
+  return new ConversationalistError("error:invalid-position", `invalid position: expected ${expected}, got ${actual}`, { context: {
+    expected,
+    actual
+  } });
+}
+function createInvalidToolReferenceError(callId) {
+  return new ConversationalistError("error:invalid-tool-reference", `tool result references non-existent tool-call: ${callId}`, { context: { callId } });
+}
+function createSerializationError(message, cause) {
+  return new ConversationalistError("error:serialization", message, { cause });
+}
+function createValidationError(message, context, cause) {
+  return new ConversationalistError("error:validation", message, {
+    context,
+    cause
+  });
+}
+function createIntegrityError(message, context) {
+  return new ConversationalistError("error:integrity", message, { context });
+}
+function validateConversationHistoryIntegrity(conversation) {
+  const issues = [];
+  const seenIds = /* @__PURE__ */ new Set;
+  conversation.ids.forEach((id, index) => {
+    if (seenIds.has(id))
+      issues.push({
+        code: "integrity:duplicate-message-id",
+        message: `duplicate message id in ids: ${id}`,
+        data: {
+          id,
+          position: index
+        }
+      });
+    else
+      seenIds.add(id);
+    if (!conversation.messages[id])
+      issues.push({
+        code: "integrity:missing-message",
+        message: `missing message for id ${id}`,
+        data: {
+          id,
+          position: index
+        }
+      });
+  });
+  for (const id of Object.keys(conversation.messages))
+    if (!seenIds.has(id))
+      issues.push({
+        code: "integrity:unlisted-message",
+        message: `message ${id} is not listed in ids`,
+        data: { id }
+      });
+  const toolCalls = /* @__PURE__ */ new Map;
+  conversation.ids.forEach((id, index) => {
+    const message = conversation.messages[id];
+    if (!message)
+      return;
+    if (message.role === "tool-call" && message.toolCall)
+      if (toolCalls.has(message.toolCall.id))
+        issues.push({
+          code: "integrity:duplicate-tool-call",
+          message: `duplicate toolCall.id ${message.toolCall.id}`,
+          data: {
+            toolCallId: message.toolCall.id,
+            messageId: message.id
+          }
+        });
+      else
+        toolCalls.set(message.toolCall.id, {
+          position: index,
+          messageId: message.id
+        });
+  });
+  conversation.ids.forEach((id, index) => {
+    const message = conversation.messages[id];
+    if (!message)
+      return;
+    if (message.role === "tool-result" && message.toolResult) {
+      const toolCall = toolCalls.get(message.toolResult.callId);
+      if (!toolCall)
+        issues.push({
+          code: "integrity:orphan-tool-result",
+          message: `tool-result references missing tool-call ${message.toolResult.callId}`,
+          data: {
+            callId: message.toolResult.callId,
+            messageId: message.id
+          }
+        });
+      else if (toolCall.position >= index)
+        issues.push({
+          code: "integrity:tool-result-before-call",
+          message: `tool-result ${message.toolResult.callId} occurs before tool-call`,
+          data: {
+            callId: message.toolResult.callId,
+            messageId: message.id,
+            toolCallMessageId: toolCall.messageId
+          }
+        });
+    }
+  });
+  return issues;
+}
+function assertConversationHistoryIntegrity(conversation) {
+  const issues = validateConversationHistoryIntegrity(conversation);
+  if (issues.length === 0)
+    return;
+  throw createIntegrityError("conversation integrity check failed", { issues });
+}
+function assertConversationSafe(conversation) {
+  const parsed = conversationSchema.safeParse(conversation);
+  if (!parsed.success)
+    throw createValidationError("conversation failed schema validation", { issues: parsed.error.issues });
+  assertConversationHistoryIntegrity(conversation);
+}
+function ensureConversationSafe(conversation) {
+  assertConversationSafe(conversation);
+  return conversation;
+}
+var ConversationalistError;
+var init_transient_Bk0RaCFf = __esm(() => {
+  init_message_BEjqY7Jv();
+  init_schemas();
+  ConversationalistError = class ConversationalistError2 extends Error {
+    code;
+    context;
+    cause;
+    constructor(code, message, options) {
+      super(message);
+      this.name = "ConversationalistError";
+      this.code = code;
+      this.context = options?.context;
+      this.cause = options?.cause;
+      if (Error.captureStackTrace)
+        Error.captureStackTrace(this, ConversationalistError2);
+    }
+    toDetailedString() {
+      const parts = [`[${this.code}] ${this.message}`];
+      if (this.context && Object.keys(this.context).length > 0)
+        parts.push(`Context: ${JSON.stringify(this.context, null, 2)}`);
+      if (this.cause)
+        parts.push(`Caused by: ${this.cause.message}`);
+      return parts.join(`
+`);
+    }
+  };
+});
+
+// ../../node_modules/conversationalist/dist/append-l_g0hmrj.js
+function normalizeContent(content) {
+  if (content === undefined)
+    return;
+  if (typeof content === "string")
+    return content;
+  return Array.isArray(content) ? content : [content];
+}
+function materializeToolCall(toolCall, options = {}) {
+  return {
+    id: toolCall.id ?? options.generateId?.() ?? crypto.randomUUID(),
+    name: toolCall.name,
+    arguments: normalizeJSONValue(toolCall.arguments ?? {})
+  };
+}
+function materializeToolCalls(toolCalls, options = {}) {
+  return toolCalls.map((toolCall) => materializeToolCall(toolCall, options));
+}
+function materializeToolResult(toolResult) {
+  if (hasStreamingPayload(toolResult))
+    throw new Error("materializeToolResult does not support streaming tool results. Use materializeToolResultAsync or materializeToolResultsAsync.");
+  return stripRuntimeToolResultFields(toolResult, normalizeJSONValue(toolResult.content));
+}
+function materializeToolResults(toolResults) {
+  return toolResults.map((toolResult) => materializeToolResult(toolResult));
+}
+async function materializeToolResultAsync(toolResult) {
+  const streamingPayload = getStreamingPayload(toolResult);
+  if (!streamingPayload)
+    return stripRuntimeToolResultFields(toolResult, normalizeJSONValue(toolResult.content));
+  return stripRuntimeToolResultFields(toolResult, normalizeJSONValue(await collectAsyncIterable(streamingPayload)));
+}
+async function materializeToolResultsAsync(toolResults) {
+  return Promise.all(toolResults.map((toolResult) => materializeToolResultAsync(toolResult)));
+}
+function stripRuntimeToolResultFields(toolResult, content) {
+  return {
+    callId: toolResult.callId,
+    outcome: toolResult.outcome,
+    content,
+    ...toolResult.error ? { error: {
+      code: toolResult.error.code,
+      category: toolResult.error.category,
+      retryable: toolResult.error.retryable,
+      message: toolResult.error.message,
+      ...toolResult.error.details !== undefined ? { details: normalizeJSONValue(toolResult.error.details) } : {}
+    } } : {},
+    ...toolResult.action ? { action: normalizeToolAction(toolResult.action) } : {},
+    ...toolResult.inputDigest ? { inputDigest: toolResult.inputDigest } : {},
+    ...toolResult.outputDigest ? { outputDigest: toolResult.outputDigest } : {}
+  };
+}
+function normalizeToolAction(action) {
+  return {
+    type: action.type,
+    ...action.message ? { message: action.message } : {},
+    ...action.schema !== undefined ? { schema: normalizeJSONValue(action.schema) } : {}
+  };
+}
+function hasStreamingPayload(toolResult) {
+  return getStreamingPayload(toolResult) !== undefined;
+}
+function getStreamingPayload(toolResult) {
+  if (toolResult.stream)
+    return toolResult.stream;
+  if (isAsyncIterable(toolResult.result))
+    return toolResult.result;
+}
+function isAsyncIterable(value) {
+  if (!value || typeof value !== "object" && typeof value !== "function")
+    return false;
+  return Symbol.asyncIterator in value;
+}
+function normalizeJSONValue(value) {
+  if (value === undefined)
+    return null;
+  try {
+    assertJSONValue(value, "tool materialization");
+    return value;
+  } catch {
+    try {
+      const serialized = JSON.stringify(value);
+      return serialized === undefined ? stringifyNonJSON(value) : JSON.parse(serialized);
+    } catch {
+      return stringifyNonJSON(value);
+    }
+  }
+}
+function stringifyNonJSON(value) {
+  return String(value);
+}
+function assertJSONValue(value, path) {
+  const stack = /* @__PURE__ */ new WeakSet;
+  const walk = (current, currentPath) => {
+    if (current === null)
+      return;
+    const type = typeof current;
+    if (type === "string" || type === "boolean")
+      return;
+    if (type === "number") {
+      if (Number.isFinite(current))
+        return;
+      throw new TypeError(`Non-finite number at ${currentPath}`);
+    }
+    if (type === "undefined" || type === "bigint" || type === "function" || type === "symbol")
+      throw new TypeError(`Invalid JSON value at ${currentPath}`);
+    if (Array.isArray(current)) {
+      if (stack.has(current))
+        throw new TypeError(`Circular reference detected at ${currentPath}`);
+      stack.add(current);
+      for (let index = 0;index < current.length; index += 1)
+        walk(current[index], `${currentPath}[${index}]`);
+      stack.delete(current);
+      return;
+    }
+    if (type === "object") {
+      if (!isPlainObject2(current))
+        throw new TypeError(`Non-plain object is not valid JSON at ${currentPath}`);
+      const record = current;
+      if (stack.has(record))
+        throw new TypeError(`Circular reference detected at ${currentPath}`);
+      stack.add(record);
+      for (const key of Object.keys(record))
+        walk(record[key], `${currentPath}.${key}`);
+      stack.delete(record);
+    }
+  };
+  walk(value, path);
+}
+function isPlainObject2(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const prototype = Reflect.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+async function collectAsyncIterable(stream) {
+  const chunks = [];
+  for await (const chunk of stream)
+    chunks.push(chunk);
+  return chunks;
+}
+function pairToolCallsWithResults(messages) {
+  const isMessageArray = (value) => Array.isArray(value);
+  const ordered = isMessageArray(messages) ? messages : Object.values(messages).sort((a, b) => a.position - b.position);
+  const pairs = [];
+  const resultsMap = /* @__PURE__ */ new Map;
+  for (const msg of ordered)
+    if (msg.toolResult)
+      resultsMap.set(msg.toolResult.callId, msg.toolResult);
+  for (const msg of ordered)
+    if (msg.toolCall)
+      pairs.push({
+        call: msg.toolCall,
+        result: resultsMap.get(msg.toolCall.id)
+      });
+  return pairs;
+}
+function appendToolCall(conversation, toolCall, options, environment) {
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(options) ? options : environment);
+  const resolvedOptions = isConversationEnvironmentParameter(options) ? undefined : options;
+  return appendMessages(conversation, createToolCallMessageInput(materializeToolCall(toolCall, { generateId: resolvedEnvironment.randomId }), resolvedOptions), resolvedEnvironment);
+}
+function appendToolCalls(conversation, toolCalls, environment) {
+  if (toolCalls.length === 0)
+    return conversation;
+  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  return appendMessages(conversation, ...materializeToolCalls(toolCalls, { generateId: resolvedEnvironment.randomId }).map((toolCall) => createToolCallMessageInput(toolCall, undefined)), resolvedEnvironment);
+}
+function appendToolResult(conversation, toolResult, options, environment) {
+  const resolvedOptions = isConversationEnvironmentParameter(options) ? undefined : options;
+  return appendMessages(conversation, createToolResultMessageInput(materializeToolResult(toolResult), resolvedOptions), isConversationEnvironmentParameter(options) ? options : environment);
+}
+function appendToolResults(conversation, toolResults, environment) {
+  if (toolResults.length === 0)
+    return conversation;
+  return appendMessages(conversation, ...materializeToolResults(toolResults).map((toolResult) => createToolResultMessageInput(toolResult, undefined)), environment);
+}
+async function appendToolResultAsync(conversation, toolResult, options, environment) {
+  const resolvedOptions = isConversationEnvironmentParameter(options) ? undefined : options;
+  return appendMessages(conversation, createToolResultMessageInput(await materializeToolResultAsync(toolResult), resolvedOptions), isConversationEnvironmentParameter(options) ? options : environment);
+}
+async function appendToolResultsAsync(conversation, toolResults, environment) {
+  if (toolResults.length === 0)
+    return conversation;
+  return appendMessages(conversation, ...(await materializeToolResultsAsync(toolResults)).map((toolResult) => createToolResultMessageInput(toolResult, undefined)), environment);
+}
+function getPendingToolCalls(conversation) {
+  const orderedMessages = getOrderedMessages(conversation);
+  const completedCallIdentifiers = /* @__PURE__ */ new Set;
+  for (const message of orderedMessages)
+    if (message.role === "tool-result" && message.toolResult)
+      completedCallIdentifiers.add(message.toolResult.callId);
+  const pendingToolCalls = [];
+  for (const message of orderedMessages)
+    if (message.role === "tool-call" && message.toolCall) {
+      if (!completedCallIdentifiers.has(message.toolCall.id))
+        pendingToolCalls.push(message.toolCall);
+    }
+  return pendingToolCalls;
+}
+function getToolInteractions(conversation) {
+  return pairToolCallsWithResults(getOrderedMessages(conversation));
+}
+function createToolCallMessageInput(toolCall, options) {
+  return {
+    role: "tool-call",
+    content: options?.content ?? "",
+    metadata: options?.metadata,
+    hidden: options?.hidden,
+    toolCall,
+    tokenUsage: options?.tokenUsage
+  };
+}
+function createToolResultMessageInput(toolResult, options) {
+  return {
+    role: "tool-result",
+    content: options?.content ?? "",
+    metadata: options?.metadata,
+    hidden: options?.hidden,
+    toolResult,
+    tokenUsage: options?.tokenUsage
+  };
+}
+function toSessionInfo(conversation) {
+  return {
+    id: conversation.id,
+    ...conversation.title !== undefined ? { title: conversation.title } : {},
+    tags: conversation.metadata["_tags"] ?? [],
+    createdAt: conversation.createdAt,
+    updatedAt: conversation.updatedAt,
+    messageCount: conversation.ids.length
+  };
+}
+function partCharLength(part) {
+  switch (part.type) {
+    case "text":
+      return part.text.length + (part.citations !== undefined ? JSON.stringify(part.citations).length : 0);
+    case "image":
+      return (part.text ?? "").length + (part.url?.length ?? 0);
+    case "thinking":
+      return part.thinking.length + part.signature.length;
+    case "redacted_thinking":
+      return part.data.length;
+    case "server_tool_use":
+      return part.name.length + JSON.stringify(part.input).length;
+    case "web_search_tool_result":
+      return JSON.stringify(part.content).length;
+    case "code_execution_tool_result":
+    case "bash_code_execution_tool_result":
+    case "text_editor_code_execution_tool_result":
+    case "web_fetch_tool_result":
+      return JSON.stringify(part.content).length;
+    case "container_upload":
+      return part.file_id.length;
+  }
+}
+function simpleTokenEstimator(message) {
+  if (typeof message.content === "string")
+    return Math.ceil(message.content.length / 4);
+  const total = messageParts(message).reduce((sum, part) => sum + partCharLength(part), 0);
+  return Math.ceil(total / 4);
+}
+function resolveConversationEnvironment(environment) {
+  return {
+    now: environment?.now ?? defaultConversationEnvironment.now,
+    randomId: environment?.randomId ?? defaultConversationEnvironment.randomId,
+    estimateTokens: environment?.estimateTokens ?? defaultConversationEnvironment.estimateTokens,
+    plugins: [...environment?.plugins ?? defaultConversationEnvironment.plugins],
+    ...environment?.persistence ? { persistence: environment.persistence } : {},
+    ...environment?.persistenceDebounceMilliseconds !== undefined ? { persistenceDebounceMilliseconds: environment.persistenceDebounceMilliseconds } : {},
+    ...environment?.setTimeoutFunction ? { setTimeoutFunction: environment.setTimeoutFunction } : {},
+    ...environment?.clearTimeoutFunction ? { clearTimeoutFunction: environment.clearTimeoutFunction } : {},
+    ...environment?.maxHistoryDepth !== undefined ? { maxHistoryDepth: environment.maxHistoryDepth } : {}
+  };
+}
+function isConversationEnvironmentParameter(value) {
+  if (!value || typeof value !== "object" || value === null)
+    return false;
+  if ("role" in value)
+    return false;
+  const candidate = value;
+  return typeof candidate["now"] === "function" || typeof candidate["randomId"] === "function" || typeof candidate["estimateTokens"] === "function" || Array.isArray(candidate["plugins"]) && candidate["plugins"].length > 0 || typeof candidate["persistence"] === "object" && candidate["persistence"] !== null;
+}
+function partitionAppendArgs(args) {
+  const filtered = args.filter((arg) => arg !== undefined);
+  if (filtered.length === 0)
+    return { inputs: [] };
+  const last = filtered[filtered.length - 1];
+  if (isConversationEnvironmentParameter(last))
+    return {
+      inputs: filtered.slice(0, -1),
+      environment: last
+    };
+  return { inputs: filtered };
+}
+function appendMessages(conversation, ...args) {
+  return appendMessagesInternal(conversation, args, true);
+}
+function appendUserMessage(conversation, content, metadata, environment) {
+  const resolvedEnvironment = isConversationEnvironmentParameter(metadata) ? metadata : environment;
+  return appendMessages(conversation, {
+    role: "user",
+    content,
+    metadata: isConversationEnvironmentParameter(metadata) ? undefined : metadata
+  }, resolvedEnvironment);
+}
+function appendAssistantMessage(conversation, content, metadata, environment) {
+  const resolvedEnvironment = isConversationEnvironmentParameter(metadata) ? metadata : environment;
+  return appendMessages(conversation, {
+    role: "assistant",
+    content,
+    metadata: isConversationEnvironmentParameter(metadata) ? undefined : metadata
+  }, resolvedEnvironment);
+}
+function appendSystemMessage(conversation, content, metadata, environment) {
+  const resolvedEnvironment = isConversationEnvironmentParameter(metadata) ? metadata : environment;
+  return appendMessages(conversation, {
+    role: "system",
+    content,
+    metadata: isConversationEnvironmentParameter(metadata) ? undefined : metadata
+  }, resolvedEnvironment);
+}
+var defaultConversationEnvironment, buildToolUseIndex = (messages) => messages.reduce((index, message) => {
+  if (message.role === "tool-call" && message.toolCall)
+    index.set(message.toolCall.id, { name: message.toolCall.name });
+  return index;
+}, /* @__PURE__ */ new Map), registerToolUse = (index, toolCall) => {
+  const next = new Map(index);
+  next.set(toolCall.id, { name: toolCall.name });
+  return next;
+}, assertToolReference = (index, callId) => {
+  if (!index.has(callId))
+    throw createInvalidToolReferenceError(callId);
+}, appendMessagesInternal = (conversation, args, validate) => {
+  const { inputs, environment } = partitionAppendArgs(args);
+  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const now = resolvedEnvironment.now();
+  const startPosition = conversation.ids.length;
+  const initialToolUses = validate ? buildToolUseIndex(getOrderedMessages(conversation)) : /* @__PURE__ */ new Map;
+  const { messages } = inputs.reduce((state, input, index) => {
+    const processedInput = resolvedEnvironment.plugins.reduce((acc, plugin) => plugin(acc), input);
+    if (validate && processedInput.role === "tool-result" && processedInput.toolResult)
+      assertToolReference(state.toolUses, processedInput.toolResult.callId);
+    const normalizedContent = normalizeContent(processedInput.content);
+    const baseMessage = {
+      id: resolvedEnvironment.randomId(),
+      role: processedInput.role,
+      content: normalizedContent,
+      position: startPosition + index,
+      createdAt: now,
+      metadata: { ...processedInput.metadata ?? {} },
+      hidden: processedInput.hidden ?? false,
+      toolCall: processedInput.toolCall,
+      toolResult: processedInput.toolResult,
+      tokenUsage: processedInput.tokenUsage
+    };
+    let message;
+    if (processedInput.role === "assistant")
+      message = createMessage({
+        ...baseMessage,
+        role: "assistant",
+        goalCompleted: processedInput.goalCompleted
+      });
+    else
+      message = createMessage(baseMessage);
+    let toolUses = state.toolUses;
+    if (processedInput.role === "tool-call" && processedInput.toolCall) {
+      if (validate && state.toolUses.has(processedInput.toolCall.id))
+        throw createIntegrityError("duplicate toolCall.id in conversation", {
+          toolCallId: processedInput.toolCall.id,
+          messageId: baseMessage.id
+        });
+      toolUses = validate ? registerToolUse(state.toolUses, processedInput.toolCall) : state.toolUses;
+    }
+    return {
+      toolUses,
+      messages: [...state.messages, message]
+    };
+  }, {
+    toolUses: initialToolUses,
+    messages: []
+  });
+  const messageIds = messages.map((message) => message.id);
+  const readonly = toReadonly({
+    ...conversation,
+    ids: [...conversation.ids, ...messageIds],
+    messages: {
+      ...conversation.messages,
+      ...toIdRecord(messages)
+    },
+    updatedAt: now
+  });
+  return validate ? ensureConversationSafe(readonly) : readonly;
+};
+var init_append_l_g0hmrj = __esm(() => {
+  init_message_BEjqY7Jv();
+  init_transient_Bk0RaCFf();
+  defaultConversationEnvironment = {
+    now: () => (/* @__PURE__ */ new Date()).toISOString(),
+    randomId: () => crypto.randomUUID(),
+    estimateTokens: simpleTokenEstimator,
+    plugins: []
+  };
+});
+
+// ../../node_modules/conversationalist/dist/types-C6g2sHGB.js
+var init_types_C6g2sHGB = () => {};
+
+// ../../node_modules/conversationalist/dist/tool-results-DKQs9ZGX.js
+function redactToolResult(toolResult, placeholder) {
+  return {
+    ...toolResult,
+    content: placeholder
+  };
+}
+var init_tool_results_DKQs9ZGX = () => {};
+
+// ../../node_modules/conversationalist/dist/conversation-7sbYchzO.js
+function createConversationHistory(options, environment) {
+  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const now = resolvedEnvironment.now();
+  return ensureConversationSafe(toReadonly({
+    schemaVersion: 4,
+    id: options?.id ?? resolvedEnvironment.randomId(),
+    title: options?.title,
+    status: options?.status ?? "active",
+    metadata: { ...options?.metadata ?? {} },
+    ids: [],
+    messages: {},
+    createdAt: now,
+    updatedAt: now
+  }));
+}
+function getMessages(conversation, options) {
+  const includeHidden = options?.includeHidden ?? false;
+  const ordered = getOrderedMessages(conversation);
+  return includeHidden ? ordered : ordered.filter((m) => !m.hidden);
+}
+function getMessageAtPosition(conversation, position) {
+  const id = conversation.ids[position];
+  return id ? conversation.messages[id] : undefined;
+}
+function getMessageIds(conversation) {
+  return [...conversation.ids];
+}
+function getMessageById(conversation, id) {
+  return conversation.messages[id];
+}
+function searchConversationMessages(conversation, predicate) {
+  return getOrderedMessages(conversation).filter(predicate);
+}
+function getStatistics(conversation) {
+  const ordered = getOrderedMessages(conversation);
+  const stats = ordered.reduce((acc, message) => {
+    return {
+      byRole: {
+        ...acc.byRole,
+        [message.role]: (acc.byRole[message.role] ?? 0) + 1
+      },
+      hidden: acc.hidden + (message.hidden ? 1 : 0),
+      withImages: acc.withImages + (messageHasImages(message) ? 1 : 0)
+    };
+  }, {
+    byRole: {},
+    hidden: 0,
+    withImages: 0
+  });
+  return {
+    total: ordered.length,
+    ...stats
+  };
+}
+function hasSystemMessage(conversation) {
+  return getOrderedMessages(conversation).some((m) => m.role === "system");
+}
+function getFirstSystemMessage(conversation) {
+  return getOrderedMessages(conversation).find((m) => m.role === "system");
+}
+function getSystemMessages(conversation) {
+  return getOrderedMessages(conversation).filter((m) => m.role === "system");
+}
+function prependSystemMessage(conversation, content, metadata, environment) {
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(metadata) ? metadata : environment);
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
+  const now = resolvedEnvironment.now();
+  const newMessage = createMessage({
+    id: resolvedEnvironment.randomId(),
+    role: "system",
+    content,
+    position: 0,
+    createdAt: now,
+    metadata: { ...resolvedMetadata ?? {} },
+    hidden: false,
+    toolCall: undefined,
+    toolResult: undefined,
+    tokenUsage: undefined
+  });
+  const ordered = getOrderedMessages(conversation);
+  const renumberedMessages = ordered.map((message) => createMessage({
+    id: message.id,
+    role: message.role,
+    content: copyContent(message.content),
+    position: message.position + 1,
+    createdAt: message.createdAt,
+    metadata: { ...message.metadata },
+    hidden: message.hidden,
+    toolCall: message.toolCall,
+    toolResult: message.toolResult,
+    tokenUsage: message.tokenUsage
+  }));
+  return ensureConversationSafe(toReadonly({
+    ...conversation,
+    ids: [newMessage.id, ...ordered.map((message) => message.id)],
+    messages: toIdRecord([newMessage, ...renumberedMessages]),
+    updatedAt: now
+  }));
+}
+function replaceSystemMessage(conversation, content, metadata, environment) {
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(metadata) ? metadata : environment);
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
+  const now = resolvedEnvironment.now();
+  const ordered = getOrderedMessages(conversation);
+  const firstSystemIndex = ordered.findIndex((m) => m.role === "system");
+  if (firstSystemIndex === -1)
+    return prependSystemMessage(conversation, content, resolvedMetadata, resolvedEnvironment);
+  const original = ordered[firstSystemIndex];
+  const replaced = createMessage({
+    id: original.id,
+    role: "system",
+    content,
+    position: original.position,
+    createdAt: original.createdAt,
+    metadata: { ...resolvedMetadata ?? original.metadata },
+    hidden: original.hidden,
+    toolCall: undefined,
+    toolResult: undefined,
+    tokenUsage: undefined
+  });
+  return ensureConversationSafe(toReadonly({
+    ...conversation,
+    ids: [...conversation.ids],
+    messages: {
+      ...conversation.messages,
+      [replaced.id]: replaced
+    },
+    updatedAt: now
+  }));
+}
+function collapseSystemMessages(conversation, environment) {
+  const ordered = getOrderedMessages(conversation);
+  const systemMessages = ordered.filter((m) => m.role === "system");
+  if (systemMessages.length <= 1)
+    return ensureConversationSafe(conversation);
+  const now = resolveConversationEnvironment(environment).now();
+  const { parts } = systemMessages.reduce((state, message) => {
+    const contentStr = typeof message.content === "string" ? message.content : message.content.map((part) => part.type === "text" ? part.text : "").join("");
+    if (!contentStr || state.seen.has(contentStr))
+      return state;
+    const seen = new Set(state.seen);
+    seen.add(contentStr);
+    return {
+      seen,
+      parts: [...state.parts, contentStr]
+    };
+  }, {
+    seen: /* @__PURE__ */ new Set,
+    parts: []
+  });
+  const collapsedContent = parts.join(`
+`);
+  const firstSystemMsg = systemMessages[0];
+  const collapsed = createMessage({
+    id: firstSystemMsg.id,
+    role: "system",
+    content: collapsedContent,
+    position: firstSystemMsg.position,
+    createdAt: firstSystemMsg.createdAt,
+    metadata: { ...firstSystemMsg.metadata },
+    hidden: firstSystemMsg.hidden,
+    toolCall: undefined,
+    toolResult: undefined,
+    tokenUsage: undefined
+  });
+  const systemIdsToRemove = systemMessages.slice(1).reduce((ids, message) => {
+    const nextIds = new Set(ids);
+    nextIds.add(message.id);
+    return nextIds;
+  }, /* @__PURE__ */ new Set);
+  const renumbered = ordered.filter((m) => !systemIdsToRemove.has(m.id)).map((m) => m.id === firstSystemMsg.id ? collapsed : m).map((message, index) => {
+    if (message.position === index)
+      return message;
+    return createMessage({
+      id: message.id,
+      role: message.role,
+      content: copyContent(message.content),
+      position: index,
+      createdAt: message.createdAt,
+      metadata: { ...message.metadata },
+      hidden: message.hidden,
+      toolCall: message.toolCall,
+      toolResult: message.toolResult,
+      tokenUsage: message.tokenUsage
+    });
+  });
+  return ensureConversationSafe(toReadonly({
+    ...conversation,
+    ids: renumbered.map((message) => message.id),
+    messages: toIdRecord(renumbered),
+    updatedAt: now
+  }));
+}
+function redactMessageAtPosition(conversation, position, placeholderOrOptions, environment) {
+  let placeholder = "[REDACTED]";
+  let options = {};
+  let env = environment;
+  if (typeof placeholderOrOptions === "string")
+    placeholder = placeholderOrOptions;
+  else if (placeholderOrOptions) {
+    if (!environment && isConversationEnvironmentParameter(placeholderOrOptions))
+      env = placeholderOrOptions;
+    else if (isRedactMessageOptions(placeholderOrOptions)) {
+      options = placeholderOrOptions;
+      if (options.placeholder)
+        placeholder = options.placeholder;
+    }
+  }
+  const redactToolArguments = options.redactToolArguments ?? true;
+  const redactToolResults = options.redactToolResults ?? true;
+  const clearToolMetadata = options.clearToolMetadata ?? false;
+  if (position < 0 || position >= conversation.ids.length)
+    throw createInvalidPositionError(conversation.ids.length - 1, position);
+  const id = conversation.ids[position];
+  const original = id ? conversation.messages[id] : undefined;
+  if (!original)
+    throw createInvalidPositionError(conversation.ids.length - 1, position);
+  let toolCall = original.toolCall ? { ...original.toolCall } : undefined;
+  let toolResult = original.toolResult ? { ...original.toolResult } : undefined;
+  if (clearToolMetadata) {
+    toolCall = undefined;
+    toolResult = undefined;
+  } else {
+    if (original.role === "tool-call" && toolCall)
+      toolCall = {
+        ...toolCall,
+        arguments: redactToolArguments ? placeholder : toolCall.arguments
+      };
+    if (original.role === "tool-result" && toolResult)
+      toolResult = redactToolResults ? redactToolResult(toolResult, placeholder) : { ...toolResult };
+  }
+  const redacted = createMessage({
+    id: original.id,
+    role: original.role,
+    content: placeholder,
+    position: original.position,
+    createdAt: original.createdAt,
+    metadata: { ...original.metadata },
+    hidden: original.hidden,
+    toolCall,
+    toolResult,
+    tokenUsage: original.tokenUsage ? { ...original.tokenUsage } : undefined
+  });
+  const now = resolveConversationEnvironment(env).now();
+  return ensureConversationSafe(toReadonly({
+    ...conversation,
+    ids: [...conversation.ids],
+    messages: {
+      ...conversation.messages,
+      [redacted.id]: redacted
+    },
+    updatedAt: now
+  }));
+}
+function normalizeLegacyToolCall(toolCall) {
+  if (!toolCall || typeof toolCall !== "object")
+    return toolCall;
+  const record = { ...toolCall };
+  if (!("arguments" in record) && "args" in record)
+    record["arguments"] = record["args"];
+  delete record["args"];
+  return record;
+}
+function normalizeLegacyToolResult(toolResult) {
+  if (!toolResult || typeof toolResult !== "object")
+    return toolResult;
+  const record = { ...toolResult };
+  if (!("content" in record) && "result" in record)
+    record["content"] = record["result"];
+  delete record["result"];
+  return record;
+}
+function normalizeLegacyConversationData(json) {
+  if (!json || typeof json !== "object")
+    return json;
+  const conversation = { ...json };
+  const messagesValue = conversation["messages"];
+  if (!messagesValue || typeof messagesValue !== "object")
+    return conversation;
+  const normalizedMessages = {};
+  for (const [messageId, messageValue] of Object.entries(messagesValue)) {
+    if (!messageValue || typeof messageValue !== "object") {
+      normalizedMessages[messageId] = messageValue;
+      continue;
+    }
+    const message = { ...messageValue };
+    if (message["role"] === "tool-use")
+      message["role"] = "tool-call";
+    if ("toolCall" in message)
+      message["toolCall"] = normalizeLegacyToolCall(message["toolCall"]);
+    if ("toolResult" in message)
+      message["toolResult"] = normalizeLegacyToolResult(message["toolResult"]);
+    normalizedMessages[messageId] = message;
+  }
+  conversation["messages"] = normalizedMessages;
+  return conversation;
+}
+function normalizeToolResult(toolResult) {
+  if (!toolResult)
+    return;
+  return {
+    callId: toolResult.callId,
+    outcome: toolResult.outcome,
+    content: toolResult.content,
+    ...toolResult.error ? { error: { ...toolResult.error } } : {},
+    ...toolResult.action ? { action: { ...toolResult.action } } : {},
+    ...toolResult.inputDigest ? { inputDigest: toolResult.inputDigest } : {},
+    ...toolResult.outputDigest ? { outputDigest: toolResult.outputDigest } : {}
+  };
+}
+function normalizeMessage(message) {
+  const base = {
+    id: message.id,
+    role: message.role,
+    content: message.content,
+    position: message.position,
+    createdAt: message.createdAt,
+    metadata: message.metadata,
+    hidden: message.hidden,
+    toolCall: message.toolCall ? { ...message.toolCall } : undefined,
+    toolResult: normalizeToolResult(message.toolResult),
+    tokenUsage: message.tokenUsage ? { ...message.tokenUsage } : undefined
+  };
+  if (isAssistantMessage(message))
+    return {
+      ...base,
+      role: "assistant",
+      goalCompleted: message.goalCompleted
+    };
+  return base;
+}
+function deserializeConversationHistory(json) {
+  const parsed = conversationSchema.safeParse(normalizeLegacyConversationData(json));
+  if (!parsed.success)
+    throw createSerializationError("failed to deserialize conversation: invalid data");
+  const data = parsed.data;
+  try {
+    const messageIds = new Set(Object.keys(data.messages));
+    const orderedMessages = data.ids.map((id, index) => {
+      const message = data.messages[id];
+      if (!message)
+        throw createSerializationError(`missing message for id ${id}`);
+      if (message.position !== index)
+        throw createInvalidPositionError(index, message.position);
+      messageIds.delete(id);
+      return normalizeMessage(message);
+    });
+    if (messageIds.size > 0)
+      throw createSerializationError(`messages not listed in ids: ${[...messageIds].join(", ")}`);
+    orderedMessages.reduce((state, message) => {
+      if (message.role === "tool-call" && message.toolCall)
+        return { toolUses: registerToolUse(state.toolUses, message.toolCall) };
+      if (message.role === "tool-result" && message.toolResult)
+        assertToolReference(state.toolUses, message.toolResult.callId);
+      return state;
+    }, { toolUses: /* @__PURE__ */ new Map });
+    const messageInstances = orderedMessages.map((message) => createMessage(message));
+    const readonly = toReadonly({
+      schemaVersion: data.schemaVersion,
+      id: data.id,
+      title: data.title,
+      status: data.status,
+      metadata: { ...data.metadata },
+      ids: orderedMessages.map((message) => message.id),
+      messages: toIdRecord(messageInstances),
+      createdAt: data.createdAt,
+      updatedAt: data.updatedAt
+    });
+    assertConversationHistoryIntegrity(readonly);
+    return readonly;
+  } catch (error) {
+    throw createSerializationError(`failed to deserialize conversation: ${error instanceof Error ? error.message : String(error)}`, error);
+  }
+}
+function toChatMessages(conversation) {
+  assertConversationSafe(conversation);
+  const roleMap = {
+    user: "user",
+    assistant: "assistant",
+    system: "system",
+    developer: "system",
+    "tool-call": "assistant",
+    "tool-result": "user",
+    snapshot: "system"
+  };
+  const result = [];
+  for (const message of getOrderedMessages(conversation)) {
+    if (message.hidden)
+      continue;
+    const externalRole = roleMap[message.role];
+    result.push({
+      role: externalRole,
+      content: message.content
+    });
+  }
+  return result;
+}
+var isRedactMessageOptions = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return "placeholder" in candidate || "redactToolArguments" in candidate || "redactToolResults" in candidate || "clearToolMetadata" in candidate;
+};
+var init_conversation_7sbYchzO = __esm(() => {
+  init_append_l_g0hmrj();
+  init_message_BEjqY7Jv();
+  init_transient_Bk0RaCFf();
+  init_schemas();
+  init_types_C6g2sHGB();
+  init_tool_results_DKQs9ZGX();
+});
+
+// ../../node_modules/conversationalist/dist/streaming.js
+function isStreamingMessage(message) {
+  return message.metadata[STREAMING_KEY] === true;
+}
+function getStreamingMessage(conversation) {
+  return getOrderedMessages(conversation).find(isStreamingMessage);
+}
+function appendStreamingMessage(conversation, role, metadata, environment) {
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(metadata) ? metadata : environment);
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
+  const now = resolvedEnvironment.now();
+  const messageId = resolvedEnvironment.randomId();
+  const newMessage = createMessage({
+    id: messageId,
+    role,
+    content: "",
+    position: conversation.ids.length,
+    createdAt: now,
+    metadata: {
+      ...resolvedMetadata ?? {},
+      [STREAMING_KEY]: true
+    },
+    hidden: false,
+    toolCall: undefined,
+    toolResult: undefined,
+    tokenUsage: undefined
+  });
+  return {
+    conversation: ensureConversationSafe(toReadonly({
+      ...conversation,
+      ids: [...conversation.ids, messageId],
+      messages: {
+        ...conversation.messages,
+        [messageId]: newMessage
+      },
+      updatedAt: now
+    })),
+    messageId
+  };
+}
+function updateStreamingMessage(conversation, messageId, content, environment) {
+  const now = resolveConversationEnvironment(environment).now();
+  const original = conversation.messages[messageId];
+  if (!original)
+    return ensureConversationSafe(conversation);
+  const overrides = { content: typeof content === "string" ? content : [...content] };
+  if (original.tokenUsage)
+    overrides.tokenUsage = { ...original.tokenUsage };
+  const updated = cloneMessage(original, overrides);
+  return ensureConversationSafe(toReadonly({
+    ...conversation,
+    ids: [...conversation.ids],
+    messages: {
+      ...conversation.messages,
+      [updated.id]: updated
+    },
+    updatedAt: now
+  }));
+}
+function finalizeStreamingMessage(conversation, messageId, options, environment) {
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(options) ? options : environment);
+  const resolvedOptions = isConversationEnvironmentParameter(options) ? undefined : options;
+  const now = resolvedEnvironment.now();
+  const original = conversation.messages[messageId];
+  if (!original)
+    return ensureConversationSafe(conversation);
+  const { [STREAMING_KEY]: _, ...restMetadata } = original.metadata;
+  const finalizeOverrides = { metadata: {
+    ...restMetadata,
+    ...resolvedOptions?.metadata ?? {}
+  } };
+  if (resolvedOptions?.tokenUsage)
+    finalizeOverrides.tokenUsage = { ...resolvedOptions.tokenUsage };
+  const updated = cloneMessage(original, finalizeOverrides);
+  return ensureConversationSafe(toReadonly({
+    ...conversation,
+    ids: [...conversation.ids],
+    messages: {
+      ...conversation.messages,
+      [updated.id]: updated
+    },
+    updatedAt: now
+  }));
+}
+function cancelStreamingMessage(conversation, messageId, environment) {
+  const now = resolveConversationEnvironment(environment).now();
+  if (!conversation.messages[messageId])
+    return ensureConversationSafe(conversation);
+  const messages = getOrderedMessages(conversation).filter((m) => m.id !== messageId).map((message, index) => message.position === index ? message : (() => {
+    const overrides = { position: index };
+    if (message.tokenUsage)
+      overrides.tokenUsage = { ...message.tokenUsage };
+    return cloneMessage(message, overrides);
+  })());
+  return ensureConversationSafe(toReadonly({
+    ...conversation,
+    ids: messages.map((message) => message.id),
+    messages: toIdRecord(messages),
+    updatedAt: now
+  }));
+}
+var STREAMING_KEY = "__streaming", cloneMessage = (original, overrides = {}) => {
+  const baseMessage = {
+    id: original.id,
+    role: original.role,
+    content: overrides.content ?? (typeof original.content === "string" ? original.content : [...original.content]),
+    position: overrides.position ?? original.position,
+    createdAt: original.createdAt,
+    metadata: overrides.metadata ?? { ...original.metadata },
+    hidden: original.hidden,
+    toolCall: original.toolCall ? { ...original.toolCall } : undefined,
+    toolResult: original.toolResult ? { ...original.toolResult } : undefined,
+    tokenUsage: overrides.tokenUsage
+  };
+  if (isAssistantMessage(original))
+    return createMessage({
+      ...baseMessage,
+      role: "assistant",
+      goalCompleted: original.goalCompleted
+    });
+  return createMessage(baseMessage);
+};
+var init_streaming = __esm(() => {
+  init_append_l_g0hmrj();
+  init_message_BEjqY7Jv();
+  init_transient_Bk0RaCFf();
+});
+
+// ../../node_modules/conversationalist/dist/shared-BylU-V4n.js
+function toJSONValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => toJSONValue(item));
+  if (value && typeof value === "object") {
+    const record = {};
+    for (const [key, entry] of Object.entries(value))
+      record[key] = toJSONValue(entry);
+    return record;
+  }
+  return String(value);
+}
+function parseJSONValue(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+}
+function isCanonicalToolResultPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  return "outcome" in value && (value["outcome"] === "success" || value["outcome"] === "error" || value["outcome"] === "action_required") && "content" in value;
+}
+var init_shared_BylU_V4n = () => {};
+
+// ../../node_modules/conversationalist/dist/adapters/openai/index.js
+var exports_openai = {};
+__export(exports_openai, {
+  toOpenAIMessagesGrouped: () => toOpenAIMessagesGrouped,
+  toOpenAIMessages: () => toOpenAIMessages,
+  openAIConversationAdapter: () => openAIConversationAdapter,
+  fromOpenAIMessages: () => fromOpenAIMessages,
+  appendOpenAIMessages: () => appendOpenAIMessages
+});
+function toOpenAIContent(content, options = {}) {
+  if (typeof content === "string")
+    return content;
+  const allowImages = options.allowImages ?? true;
+  const parts = [];
+  for (const part of content)
+    if (part.type === "text")
+      parts.push({
+        type: "text",
+        text: part.text ?? ""
+      });
+    else if (part.type === "image" && allowImages)
+      parts.push({
+        type: "image_url",
+        image_url: { url: part.url ?? "" }
+      });
+  if (parts.length === 0)
+    return "";
+  if (parts.length === 1 && parts[0]?.type === "text")
+    return parts[0].text;
+  return allowImages ? parts : parts;
+}
+function toOpenAITextContent(content) {
+  return toOpenAIContent(content, { allowImages: false });
+}
+function toOpenAIToolCall(toolCall) {
+  return {
+    id: toolCall.id,
+    type: "function",
+    function: {
+      name: toolCall.name,
+      arguments: typeof toolCall.arguments === "string" ? toolCall.arguments : JSON.stringify(toolCall.arguments)
+    }
+  };
+}
+function convertMessage(message) {
+  if (message.hidden)
+    return null;
+  if (isStreamingMessage(message))
+    return null;
+  switch (message.role) {
+    case "system":
+    case "developer":
+      return {
+        role: "system",
+        content: toOpenAITextContent(message.content)
+      };
+    case "user":
+      return {
+        role: "user",
+        content: toOpenAIContent(message.content)
+      };
+    case "assistant":
+      return {
+        role: "assistant",
+        content: toOpenAITextContent(message.content)
+      };
+    case "tool-call":
+      if (!message.toolCall)
+        return null;
+      return {
+        role: "assistant",
+        content: null,
+        tool_calls: [toOpenAIToolCall(message.toolCall)]
+      };
+    case "tool-result":
+      if (!message.toolResult)
+        return null;
+      return {
+        role: "tool",
+        content: stringifyToolResult(message.toolResult),
+        tool_call_id: message.toolResult.callId
+      };
+    case "snapshot":
+      return null;
+  }
+}
+function stringifyToolResult(result) {
+  const payload = result.outcome === "success" ? result.content : {
+    outcome: result.outcome,
+    content: result.content,
+    ...result.error ? { error: result.error } : {},
+    ...result.action ? { action: result.action } : {}
+  };
+  if (typeof payload === "string")
+    return payload;
+  return JSON.stringify(payload);
+}
+function toConversationContent(content) {
+  if (content === null)
+    return;
+  if (typeof content === "string")
+    return content;
+  const parts = content.map((part) => part.type === "text" ? {
+    type: "text",
+    text: part.text
+  } : {
+    type: "image",
+    url: part.image_url.url
+  });
+  if (parts.length === 0)
+    return "";
+  if (parts.length === 1 && parts[0]?.type === "text")
+    return parts[0].text ?? "";
+  return parts;
+}
+function parseToolArguments(value) {
+  return parseJSONValue(value) ?? value;
+}
+function parseToolResult(callId, content) {
+  const serialized = typeof content === "string" ? content : content.map((part) => part.text).join(`
+
+`);
+  const parsed = parseJSONValue(serialized);
+  if (parsed !== undefined && isCanonicalToolResultPayload(parsed))
+    return {
+      callId,
+      outcome: parsed.outcome,
+      content: parsed.content,
+      ...parsed.error ? { error: parsed.error } : {},
+      ...parsed.action ? { action: parsed.action } : {},
+      ...typeof parsed.inputDigest === "string" ? { inputDigest: parsed.inputDigest } : {},
+      ...typeof parsed.outputDigest === "string" ? { outputDigest: parsed.outputDigest } : {}
+    };
+  return {
+    callId,
+    outcome: "success",
+    content: parsed ?? serialized
+  };
+}
+function toMessageInputs(messages) {
+  const inputs = [];
+  for (const message of messages)
+    switch (message.role) {
+      case "system":
+        inputs.push({
+          role: "system",
+          content: toConversationContent(message.content) ?? ""
+        });
+        break;
+      case "user":
+        inputs.push({
+          role: "user",
+          content: toConversationContent(message.content) ?? ""
+        });
+        break;
+      case "assistant": {
+        const assistantContent = toConversationContent(message.content);
+        if (assistantContent !== undefined && (typeof assistantContent === "string" ? assistantContent.length > 0 : assistantContent.length > 0))
+          inputs.push({
+            role: "assistant",
+            content: assistantContent
+          });
+        for (const toolCall of message.tool_calls ?? [])
+          inputs.push({
+            role: "tool-call",
+            content: "",
+            toolCall: {
+              id: toolCall.id,
+              name: toolCall.function.name,
+              arguments: parseToolArguments(toolCall.function.arguments)
+            }
+          });
+        break;
+      }
+      case "tool":
+        inputs.push({
+          role: "tool-result",
+          content: "",
+          toolResult: parseToolResult(message.tool_call_id, message.content)
+        });
+        break;
+    }
+  return inputs;
+}
+function toOpenAIMessages(conversation) {
+  assertConversationSafe(conversation);
+  const messages = [];
+  for (const message of getOrderedMessages(conversation)) {
+    const converted = convertMessage(message);
+    if (converted)
+      messages.push(converted);
+  }
+  return messages;
+}
+function toOpenAIMessagesGrouped(conversation) {
+  assertConversationSafe(conversation);
+  const messages = [];
+  let pendingToolCalls = [];
+  for (const message of getOrderedMessages(conversation)) {
+    if (message.hidden)
+      continue;
+    if (isStreamingMessage(message))
+      continue;
+    if (message.role === "tool-call" && message.toolCall) {
+      pendingToolCalls.push(toOpenAIToolCall(message.toolCall));
+      continue;
+    }
+    if (pendingToolCalls.length > 0) {
+      messages.push({
+        role: "assistant",
+        content: null,
+        tool_calls: pendingToolCalls
+      });
+      pendingToolCalls = [];
+    }
+    const converted = convertMessage(message);
+    if (converted && message.role !== "tool-call")
+      messages.push(converted);
+  }
+  if (pendingToolCalls.length > 0)
+    messages.push({
+      role: "assistant",
+      content: null,
+      tool_calls: pendingToolCalls
+    });
+  return messages;
+}
+function fromOpenAIMessages(messages) {
+  let conversation = createConversationHistory();
+  const inputs = toMessageInputs(messages);
+  if (inputs.length > 0)
+    conversation = appendMessages(conversation, ...inputs);
+  return conversation;
+}
+function appendOpenAIMessages(conversation, messages) {
+  const inputs = toMessageInputs(messages);
+  if (inputs.length === 0)
+    return conversation;
+  return appendMessages(conversation, ...inputs);
+}
+var openAIConversationAdapter;
+var init_openai = __esm(() => {
+  init_append_l_g0hmrj();
+  init_transient_Bk0RaCFf();
+  init_conversation_7sbYchzO();
+  init_streaming();
+  init_shared_BylU_V4n();
+  openAIConversationAdapter = {
+    export(conversation, options = {}) {
+      return options.groupToolCalls === false ? toOpenAIMessages(conversation) : toOpenAIMessagesGrouped(conversation);
+    },
+    import(messages) {
+      return fromOpenAIMessages(messages);
+    },
+    append(conversation, messages) {
+      return appendOpenAIMessages(conversation, messages);
+    }
+  };
+});
+
+// ../../node_modules/conversationalist/dist/adapters/anthropic/index.js
+var exports_anthropic = {};
+__export(exports_anthropic, {
+  toAnthropicMessages: () => toAnthropicMessages,
+  fromAnthropicMessages: () => fromAnthropicMessages,
+  appendAnthropicMessages: () => appendAnthropicMessages,
+  anthropicConversationAdapter: () => anthropicConversationAdapter
+});
+function toAnthropicContent(content) {
+  if (typeof content === "string")
+    return content;
+  const blocks = [];
+  for (const part of content)
+    switch (part.type) {
+      case "text":
+        blocks.push({
+          type: "text",
+          text: part.text ?? "",
+          ...part.citations !== undefined ? { citations: part.citations } : {}
+        });
+        break;
+      case "thinking":
+        blocks.push({
+          type: "thinking",
+          thinking: part.thinking,
+          signature: part.signature
+        });
+        break;
+      case "redacted_thinking":
+        blocks.push({
+          type: "redacted_thinking",
+          data: part.data
+        });
+        break;
+      case "server_tool_use":
+        blocks.push({
+          type: "server_tool_use",
+          id: part.id,
+          name: part.name,
+          input: part.input
+        });
+        break;
+      case "web_search_tool_result":
+        blocks.push({
+          type: "web_search_tool_result",
+          tool_use_id: part.tool_use_id,
+          content: part.content
+        });
+        break;
+      case "code_execution_tool_result":
+      case "bash_code_execution_tool_result":
+      case "text_editor_code_execution_tool_result":
+      case "web_fetch_tool_result":
+        blocks.push({
+          type: part.type,
+          tool_use_id: part.tool_use_id,
+          content: part.content
+        });
+        break;
+      case "container_upload":
+        blocks.push({
+          type: "container_upload",
+          file_id: part.file_id
+        });
+        break;
+      case "image": {
+        const url = part.url ?? "";
+        const base64Match = url.startsWith("data:") ? url.match(/^data:([^;]+);base64,(.+)$/) : null;
+        if (base64Match && base64Match[1] && base64Match[2])
+          blocks.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: base64Match[1],
+              data: base64Match[2]
+            }
+          });
+        else
+          blocks.push({
+            type: "image",
+            source: {
+              type: "url",
+              url
+            }
+          });
+        break;
+      }
+    }
+  const only = blocks.length === 1 ? blocks[0] : undefined;
+  return only?.type === "text" && only.citations === undefined ? only.text : blocks;
+}
+function toToolUseBlock(toolCall) {
+  let input = toolCall.arguments;
+  if (typeof toolCall.arguments === "string")
+    try {
+      input = JSON.parse(toolCall.arguments);
+    } catch {
+      input = toolCall.arguments;
+    }
+  return {
+    type: "tool_use",
+    id: toolCall.id,
+    name: toolCall.name,
+    input
+  };
+}
+function toToolResultBlock(toolResult) {
+  const payload = toolResult.outcome === "success" ? toolResult.content : {
+    outcome: toolResult.outcome,
+    content: toolResult.content,
+    ...toolResult.error ? { error: toolResult.error } : {},
+    ...toolResult.action ? { action: toolResult.action } : {}
+  };
+  const result = {
+    type: "tool_result",
+    tool_use_id: toolResult.callId,
+    content: typeof payload === "string" ? payload : JSON.stringify(payload)
+  };
+  if (toolResult.outcome !== "success")
+    result.is_error = true;
+  return result;
+}
+function extractSystemContent(messages) {
+  const systemMessages = messages.filter((m) => (m.role === "system" || m.role === "developer") && !m.hidden && !isStreamingMessage(m));
+  if (systemMessages.length === 0)
+    return;
+  const parts = [];
+  for (const msg of systemMessages)
+    if (typeof msg.content === "string")
+      parts.push(msg.content);
+    else
+      for (const part of msg.content)
+        if (part.type === "text")
+          parts.push(part.text ?? "");
+  return parts.join(`
+
+`);
+}
+function toAnthropicMessages(conversation) {
+  assertConversationSafe(conversation);
+  const ordered = getOrderedMessages(conversation);
+  const system = extractSystemContent(ordered);
+  const messages = [];
+  let currentRole = null;
+  let currentBlocks = [];
+  const flushCurrent = () => {
+    if (currentRole && currentBlocks.length > 0) {
+      const onlyBlock = currentBlocks.length === 1 ? currentBlocks[0] : undefined;
+      const collapsible = onlyBlock?.type === "text" && onlyBlock.citations === undefined;
+      messages.push({
+        role: currentRole,
+        content: collapsible && onlyBlock?.type === "text" ? onlyBlock.text : currentBlocks
+      });
+      currentBlocks = [];
+    }
+    currentRole = null;
+  };
+  for (const message of ordered) {
+    if (message.hidden)
+      continue;
+    if (isStreamingMessage(message))
+      continue;
+    if (message.role === "system" || message.role === "developer")
+      continue;
+    if (message.role === "snapshot")
+      continue;
+    let targetRole;
+    let blocks;
+    if (message.role === "user") {
+      targetRole = "user";
+      const content = toAnthropicContent(message.content);
+      if (typeof content === "string")
+        blocks = [{
+          type: "text",
+          text: content
+        }];
+      else
+        blocks = content;
+    } else if (message.role === "assistant") {
+      targetRole = "assistant";
+      const content = toAnthropicContent(message.content);
+      if (typeof content === "string")
+        blocks = [{
+          type: "text",
+          text: content
+        }];
+      else
+        blocks = content;
+    } else if (message.role === "tool-call" && message.toolCall) {
+      targetRole = "assistant";
+      blocks = [toToolUseBlock(message.toolCall)];
+    } else if (message.role === "tool-result" && message.toolResult) {
+      targetRole = "user";
+      blocks = [toToolResultBlock(message.toolResult)];
+    } else
+      continue;
+    if (currentRole === targetRole)
+      currentBlocks.push(...blocks);
+    else {
+      flushCurrent();
+      currentRole = targetRole;
+      currentBlocks = blocks;
+    }
+  }
+  flushCurrent();
+  const result = { messages };
+  if (system !== undefined)
+    result.system = system;
+  return result;
+}
+function parseToolResultContent(callId, content, isError) {
+  const parsed = parseJSONValue(content);
+  if (parsed !== undefined && isCanonicalToolResultPayload(parsed))
+    return {
+      callId,
+      outcome: parsed.outcome,
+      content: parsed.content,
+      ...parsed.error ? { error: parsed.error } : {},
+      ...parsed.action ? { action: parsed.action } : {},
+      ...typeof parsed.inputDigest === "string" ? { inputDigest: parsed.inputDigest } : {},
+      ...typeof parsed.outputDigest === "string" ? { outputDigest: parsed.outputDigest } : {}
+    };
+  return {
+    callId,
+    outcome: isError ? "error" : "success",
+    content: parsed ?? content
+  };
+}
+function toMessageInputFromBlock(block) {
+  if (block.type === "tool_use")
+    return {
+      role: "tool-call",
+      content: "",
+      toolCall: {
+        id: block.id,
+        name: block.name,
+        arguments: toJSONValue(block.input)
+      }
+    };
+  return {
+    role: "tool-result",
+    content: "",
+    toolResult: parseToolResultContent(block.tool_use_id, block.content, block.is_error)
+  };
+}
+function toGroupableContentPart(block) {
+  switch (block.type) {
+    case "text":
+      return {
+        type: "text",
+        text: block.text,
+        ...block.citations !== undefined ? { citations: toJSONValue(block.citations) } : {}
+      };
+    case "thinking":
+      return {
+        type: "thinking",
+        thinking: block.thinking,
+        signature: block.signature
+      };
+    case "redacted_thinking":
+      return {
+        type: "redacted_thinking",
+        data: block.data
+      };
+    case "server_tool_use":
+      return {
+        type: "server_tool_use",
+        id: block.id,
+        name: block.name,
+        input: toJSONValue(block.input)
+      };
+    case "web_search_tool_result":
+      return {
+        type: "web_search_tool_result",
+        tool_use_id: block.tool_use_id,
+        content: toJSONValue(block.content)
+      };
+    case "code_execution_tool_result":
+    case "bash_code_execution_tool_result":
+    case "text_editor_code_execution_tool_result":
+    case "web_fetch_tool_result":
+      return {
+        type: block.type,
+        tool_use_id: block.tool_use_id,
+        content: toJSONValue(block.content)
+      };
+    case "container_upload":
+      return {
+        type: "container_upload",
+        file_id: block.file_id
+      };
+    case "image":
+      return block.source.type === "url" ? {
+        type: "image",
+        url: block.source.url
+      } : {
+        type: "image",
+        url: `data:${block.source.media_type};base64,${block.source.data}`,
+        mimeType: block.source.media_type
+      };
+    default:
+      return;
+  }
+}
+function toMessageInputs2(payload) {
+  const inputs = [];
+  if (payload.system !== undefined)
+    inputs.push({
+      role: "system",
+      content: payload.system
+    });
+  for (const message of payload.messages) {
+    if (typeof message.content === "string") {
+      inputs.push({
+        role: message.role,
+        content: message.content
+      });
+      continue;
+    }
+    let pendingParts = [];
+    const flushPending = () => {
+      if (pendingParts.length === 0)
+        return;
+      const first = pendingParts[0];
+      if (pendingParts.length === 1 && first?.type === "text" && first.citations === undefined)
+        inputs.push({
+          role: message.role,
+          content: first.text
+        });
+      else
+        inputs.push({
+          role: message.role,
+          content: pendingParts
+        });
+      pendingParts = [];
+    };
+    for (const block of message.content) {
+      const part = toGroupableContentPart(block);
+      if (part !== undefined)
+        pendingParts.push(part);
+      else if (block.type === "tool_use" || block.type === "tool_result") {
+        flushPending();
+        inputs.push(toMessageInputFromBlock(block));
+      }
+    }
+    flushPending();
+  }
+  return inputs;
+}
+function fromAnthropicMessages(payload) {
+  let conversation = createConversationHistory();
+  const inputs = toMessageInputs2(payload);
+  if (inputs.length > 0)
+    conversation = appendMessages(conversation, ...inputs);
+  return conversation;
+}
+function appendAnthropicMessages(conversation, payload) {
+  const inputs = toMessageInputs2(payload);
+  if (inputs.length === 0)
+    return conversation;
+  return appendMessages(conversation, ...inputs);
+}
+var anthropicConversationAdapter;
+var init_anthropic = __esm(() => {
+  init_append_l_g0hmrj();
+  init_transient_Bk0RaCFf();
+  init_conversation_7sbYchzO();
+  init_streaming();
+  init_shared_BylU_V4n();
+  anthropicConversationAdapter = {
+    export(conversation) {
+      return toAnthropicMessages(conversation);
+    },
+    import(payload) {
+      return fromAnthropicMessages(payload);
+    },
+    append(conversation, payload) {
+      return appendAnthropicMessages(conversation, payload);
+    }
+  };
+});
+
+// ../../node_modules/conversationalist/dist/adapters/gemini/index.js
+var exports_gemini = {};
+__export(exports_gemini, {
+  toGeminiMessages: () => toGeminiMessages,
+  geminiConversationAdapter: () => geminiConversationAdapter,
+  fromGeminiMessages: () => fromGeminiMessages,
+  appendGeminiMessages: () => appendGeminiMessages
+});
+function inferMimeType(url) {
+  const trimmed = url.split("#")[0]?.split("?")[0] ?? "";
+  const dotIndex = trimmed.lastIndexOf(".");
+  if (dotIndex === -1)
+    return;
+  return MIME_TYPE_BY_EXTENSION[trimmed.slice(dotIndex + 1).toLowerCase()];
+}
+function resolveMimeType(url, explicit) {
+  return explicit ?? inferMimeType(url) ?? DEFAULT_FILE_MIME_TYPE;
+}
+function normalizeGeminiResponse(toolResult) {
+  if (toolResult.outcome === "success") {
+    if (toolResult.content !== null && typeof toolResult.content === "object")
+      return toolResult.content;
+    return { result: toolResult.content };
+  }
+  return {
+    outcome: toolResult.outcome,
+    content: toolResult.content,
+    ...toolResult.error ? { error: toolResult.error } : {},
+    ...toolResult.action ? { action: toolResult.action } : {}
+  };
+}
+function toGeminiParts(content) {
+  if (typeof content === "string")
+    return content ? [{ text: content }] : [];
+  const parts = [];
+  for (const part of content)
+    if (part.type === "text") {
+      if (part.text)
+        parts.push({ text: part.text });
+    } else if (part.type === "image") {
+      const url = part.url ?? "";
+      if (url.startsWith("data:")) {
+        const matches = url.match(/^data:([^;]+);base64,(.+)$/);
+        if (matches)
+          parts.push({ inlineData: {
+            mimeType: matches[1],
+            data: matches[2]
+          } });
+      } else {
+        const fileData = {
+          fileUri: url,
+          mimeType: resolveMimeType(url, part.mimeType)
+        };
+        parts.push({ fileData });
+      }
+    }
+  return parts;
+}
+function toFunctionCallPart(toolCall) {
+  let args;
+  if (typeof toolCall.arguments === "string")
+    try {
+      const parsed = JSON.parse(toolCall.arguments);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+        args = parsed;
+      else
+        args = { _value: parsed };
+    } catch {
+      args = { _raw: toolCall.arguments };
+    }
+  else if (toolCall.arguments && typeof toolCall.arguments === "object" && !Array.isArray(toolCall.arguments))
+    args = toolCall.arguments;
+  else
+    args = { _value: toolCall.arguments };
+  return { functionCall: {
+    name: toolCall.name,
+    args
+  } };
+}
+function toFunctionResponsePart(toolResult, functionName) {
+  return { functionResponse: {
+    name: functionName,
+    response: normalizeGeminiResponse(toolResult)
+  } };
+}
+function extractSystemInstruction(messages) {
+  const systemMessages = messages.filter((m) => (m.role === "system" || m.role === "developer") && !m.hidden && !isStreamingMessage(m));
+  if (systemMessages.length === 0)
+    return;
+  const parts = [];
+  for (const msg of systemMessages)
+    parts.push(...toGeminiParts(msg.content));
+  if (parts.length === 0)
+    return;
+  return {
+    role: "user",
+    parts
+  };
+}
+function toGeminiMessages(conversation) {
+  assertConversationSafe(conversation);
+  const ordered = getOrderedMessages(conversation);
+  const systemInstruction = extractSystemInstruction(ordered);
+  const toolCallNames = /* @__PURE__ */ new Map;
+  for (const message of ordered)
+    if (message.role === "tool-call" && message.toolCall)
+      toolCallNames.set(message.toolCall.id, message.toolCall.name);
+  const contents = [];
+  let currentRole = null;
+  let currentParts = [];
+  const flushCurrent = () => {
+    if (currentRole && currentParts.length > 0) {
+      contents.push({
+        role: currentRole,
+        parts: currentParts
+      });
+      currentParts = [];
+    }
+    currentRole = null;
+  };
+  for (const message of ordered) {
+    if (message.hidden)
+      continue;
+    if (isStreamingMessage(message))
+      continue;
+    if (message.role === "system" || message.role === "developer")
+      continue;
+    if (message.role === "snapshot")
+      continue;
+    let targetRole;
+    let parts;
+    if (message.role === "user") {
+      targetRole = "user";
+      parts = toGeminiParts(message.content);
+    } else if (message.role === "assistant") {
+      targetRole = "model";
+      parts = toGeminiParts(message.content);
+    } else if (message.role === "tool-call" && message.toolCall) {
+      targetRole = "model";
+      parts = [toFunctionCallPart(message.toolCall)];
+    } else if (message.role === "tool-result" && message.toolResult) {
+      targetRole = "user";
+      const functionName = toolCallNames.get(message.toolResult.callId) ?? "unknown";
+      parts = [toFunctionResponsePart(message.toolResult, functionName)];
+    } else
+      continue;
+    if (parts.length === 0)
+      continue;
+    if (currentRole === targetRole)
+      currentParts.push(...parts);
+    else {
+      flushCurrent();
+      currentRole = targetRole;
+      currentParts = parts;
+    }
+  }
+  flushCurrent();
+  const result = { contents };
+  if (systemInstruction !== undefined)
+    result.systemInstruction = systemInstruction;
+  return result;
+}
+function parseFunctionArguments(args) {
+  if (Object.keys(args).length === 1 && Object.hasOwn(args, "_value"))
+    return toJSONValue(args["_value"]);
+  if (Object.keys(args).length === 1 && Object.hasOwn(args, "_raw") && typeof args["_raw"] === "string")
+    return args["_raw"];
+  return toJSONValue(args);
+}
+function parseFunctionResponse(callId, response) {
+  const value = toJSONValue(response);
+  if (isCanonicalToolResultPayload(value))
+    return {
+      callId,
+      outcome: value.outcome,
+      content: value.content,
+      ...value.error ? { error: value.error } : {},
+      ...value.action ? { action: value.action } : {},
+      ...typeof value.inputDigest === "string" ? { inputDigest: value.inputDigest } : {},
+      ...typeof value.outputDigest === "string" ? { outputDigest: value.outputDigest } : {}
+    };
+  if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 1 && Object.hasOwn(value, "result"))
+    return {
+      callId,
+      outcome: "success",
+      content: toJSONValue(value.result)
+    };
+  return {
+    callId,
+    outcome: "success",
+    content: value
+  };
+}
+function toContentFromGeminiPart(part) {
+  if ("text" in part)
+    return part.text;
+  if ("inlineData" in part)
+    return [{
+      type: "image",
+      url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
+      mimeType: part.inlineData.mimeType
+    }];
+  return [{
+    type: "image",
+    url: part.fileData.fileUri,
+    mimeType: part.fileData.mimeType
+  }];
+}
+function toSystemInstructionContent(parts) {
+  const contentParts = [];
+  for (const part of parts)
+    if ("text" in part)
+      contentParts.push({
+        type: "text",
+        text: part.text
+      });
+    else if ("inlineData" in part)
+      contentParts.push({
+        type: "image",
+        url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
+        mimeType: part.inlineData.mimeType
+      });
+    else if ("fileData" in part)
+      contentParts.push({
+        type: "image",
+        url: part.fileData.fileUri,
+        mimeType: part.fileData.mimeType
+      });
+  if (contentParts.length === 0)
+    return;
+  if (contentParts.length === 1 && contentParts[0]?.type === "text")
+    return contentParts[0].text ?? "";
+  return contentParts;
+}
+function toMessageInputs3(payload) {
+  const inputs = [];
+  let syntheticToolCallCount = 0;
+  const pendingToolCalls = /* @__PURE__ */ new Map;
+  const queueToolCall = (name, callId) => {
+    const queued = pendingToolCalls.get(name) ?? [];
+    queued.push(callId);
+    pendingToolCalls.set(name, queued);
+  };
+  const dequeueToolCall = (name) => {
+    const queued = pendingToolCalls.get(name);
+    if (!queued || queued.length === 0)
+      return;
+    const [callId, ...rest] = queued;
+    if (rest.length === 0)
+      pendingToolCalls.delete(name);
+    else
+      pendingToolCalls.set(name, rest);
+    return callId;
+  };
+  const systemContent = payload.systemInstruction ? toSystemInstructionContent(payload.systemInstruction.parts) : undefined;
+  if (systemContent !== undefined)
+    inputs.push({
+      role: "system",
+      content: systemContent
+    });
+  for (const content of payload.contents) {
+    const role = content.role === "model" ? "assistant" : "user";
+    for (const part of content.parts) {
+      if ("functionCall" in part) {
+        const callId = `gemini-call-${++syntheticToolCallCount}`;
+        queueToolCall(part.functionCall.name, callId);
+        inputs.push({
+          role: "tool-call",
+          content: "",
+          toolCall: {
+            id: callId,
+            name: part.functionCall.name,
+            arguments: parseFunctionArguments(part.functionCall.args)
+          }
+        });
+        continue;
+      }
+      if ("functionResponse" in part) {
+        const callId = dequeueToolCall(part.functionResponse.name) ?? `gemini-call-${++syntheticToolCallCount}`;
+        inputs.push({
+          role: "tool-result",
+          content: "",
+          toolResult: parseFunctionResponse(callId, part.functionResponse.response)
+        });
+        continue;
+      }
+      inputs.push({
+        role,
+        content: toContentFromGeminiPart(part)
+      });
+    }
+  }
+  return inputs;
+}
+function fromGeminiMessages(payload) {
+  let conversation = createConversationHistory();
+  const inputs = toMessageInputs3(payload);
+  if (inputs.length > 0)
+    conversation = appendMessages(conversation, ...inputs);
+  return conversation;
+}
+function appendGeminiMessages(conversation, payload) {
+  const inputs = toMessageInputs3(payload);
+  if (inputs.length === 0)
+    return conversation;
+  return appendMessages(conversation, ...inputs);
+}
+var DEFAULT_FILE_MIME_TYPE = "application/octet-stream", MIME_TYPE_BY_EXTENSION, geminiConversationAdapter;
+var init_gemini = __esm(() => {
+  init_append_l_g0hmrj();
+  init_transient_Bk0RaCFf();
+  init_conversation_7sbYchzO();
+  init_streaming();
+  init_shared_BylU_V4n();
+  MIME_TYPE_BY_EXTENSION = {
+    bmp: "image/bmp",
+    gif: "image/gif",
+    heic: "image/heic",
+    heif: "image/heif",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    png: "image/png",
+    svg: "image/svg+xml",
+    webp: "image/webp"
+  };
+  geminiConversationAdapter = {
+    export(conversation) {
+      return toGeminiMessages(conversation);
+    },
+    import(payload) {
+      return fromGeminiMessages(payload);
+    },
+    append(conversation, payload) {
+      return appendGeminiMessages(conversation, payload);
+    }
+  };
+});
+
 // src/components/chat-conversation-list/index.ts
 import"@lostgradient/cinder/chat-conversation-list/styles";
 
-// src/components/chat-conversation-list/chat-conversation-list.svelte
-import"svelte/internal/disclose-version";
-import * as $ from "svelte/internal/client";
+// src/components/chat-conversation-list/chat-conversation-list.svelte
+import"svelte/internal/disclose-version";
+import * as $ from "svelte/internal/client";
+
+// src/utilities/class-names.ts
+function classNames(...parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+
+// ../../node_modules/conversationalist/dist/index.js
+init_append_l_g0hmrj();
+init_transient_Bk0RaCFf();
+init_schemas();
+init_conversation_7sbYchzO();
+init_streaming();
+
+// ../../node_modules/conversationalist/dist/history-5vdiTmMp.js
+init_append_l_g0hmrj();
+init_message_BEjqY7Jv();
+init_transient_Bk0RaCFf();
+init_types_C6g2sHGB();
+init_conversation_7sbYchzO();
+init_streaming();
+
+// ../../node_modules/conversationalist/dist/context.js
+init_append_l_g0hmrj();
+init_message_BEjqY7Jv();
+init_transient_Bk0RaCFf();
+init_streaming();
+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(`
+
+---
 
-// src/utilities/class-names.ts
-function classNames(...parts) {
-  return parts.filter((part) => typeof part === "string" && part.length > 0).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
+    }
+  };
 }
-
-// src/components/chat/utilities/conversation.ts
-function getMessages(conversation, options) {
-  const includeHidden = options?.includeHidden ?? false;
-  const ordered = [];
-  for (const id of conversation.ids) {
-    const message = conversation.messages[id];
-    if (message && (includeHidden || !message.hidden)) {
-      ordered.push(message);
+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 z2 = M;
+      M = null, z2({
+        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
+      });
     }
   }
-  return ordered;
+  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 pairToolCallsWithResults(messages) {
-  const resultsByCallId = new Map;
-  for (const message of messages) {
-    if (message.role === "tool-result" && message.toolResult) {
-      resultsByCallId.set(message.toolResult.callId, message.toolResult);
+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();
   }
-  const pairs = [];
-  for (const message of messages) {
-    if (message.role === "tool-call" && message.toolCall) {
-      pairs.push({ call: message.toolCall, result: resultsByCallId.get(message.toolCall.id) });
+  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 Promise.resolve().then(() => (init_openai(), exports_openai))).openAIConversationAdapter;
+    case "anthropic":
+      return (await Promise.resolve().then(() => (init_anthropic(), exports_anthropic))).anthropicConversationAdapter;
+    case "gemini":
+      return (await Promise.resolve().then(() => (init_gemini(), exports_gemini))).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;
+      });
     }
   }
-  return pairs;
+  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";
+}
+
+// ../../node_modules/conversationalist/dist/utilities/index.js
+init_append_l_g0hmrj();
+init_message_BEjqY7Jv();
+init_transient_Bk0RaCFf();
+
+// 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));
 }
 // src/components/chat/utilities/utilities.ts
 var CINDER_REASONING_METADATA_KEY = "cinder:reasoning";
@@ -89,6 +4074,8 @@ function runOverlayCallback(message, fromProp) {
 }
 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;
 }
@@ -108,19 +4095,41 @@ function resolveMessageSuggestions(message, fromProp) {
   const suggestions = candidate.filter((entry) => typeof entry === "string");
   return suggestions.length > 0 ? suggestions : undefined;
 }
-function toMultiModalArray(input) {
+function toMultiModalArray2(input) {
   if (typeof input === "string")
     return [{ type: "text", text: input }];
   return "type" in input ? [input] : input;
 }
-function isTextPart(part) {
-  return part.type === "text";
+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);
+  return toMultiModalArray2(message.content);
 }
 function getMessageText(message) {
-  return getMessageParts(message).filter(isTextPart).map((part) => part.text).join(`
+  return getMessageParts(message).map(getServerContentText).filter((text) => typeof text === "string" && text.length > 0).join(`
 `);
 }
 function deriveImageParts(message) {
@@ -138,6 +4147,28 @@ function deriveImageParts(message) {
   });
   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 {
@@ -193,11 +4224,12 @@ function deriveMessageParts(message, context = {}) {
       });
     }
   }
-  if (context.reasoning && context.reasoning.length > 0) {
+  const reasoningContent = deriveReasoningContent(message, context.reasoning);
+  if (reasoningContent) {
     bodyParts.push({
       type: "reasoning",
       key: `${message.id}:reasoning`,
-      content: context.reasoning,
+      content: reasoningContent,
       streaming: context.streaming ?? false
     });
   }
@@ -461,4 +4493,4 @@ export {
   Chat_conversation_list as ChatConversationList
 };
 
-//# debugId=1FDD82A31F10ECB664756E2164756E21
+//# debugId=3C81B7400A45BF7064756E2164756E21