@lostgradient/cinder 0.7.0 → 0.9.0

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

@@ -51,3999 +51,26 @@ 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/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/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";
 
-`);
-  let compacted = {
-    schemaVersion: 4,
-    id: conversation.id,
-    title: conversation.title,
-    status: conversation.status,
-    metadata: { ...conversation.metadata },
-    ids: [],
-    messages: {},
-    createdAt: conversation.createdAt,
-    updatedAt: env.now()
-  };
-  compacted = ensureConversationSafe(toReadonly(compacted));
-  compacted = appendMessages(compacted, {
-    role: "system",
-    content: summaryContent,
-    metadata: { compactionSummary: true }
-  }, env);
-  if (preserved.length > 0) {
-    const preservedInputs = preserved.map((m) => ({
-      role: m.role,
-      content: typeof m.content === "string" ? m.content : [...m.content],
-      metadata: { ...m.metadata },
-      hidden: m.hidden,
-      toolCall: m.toolCall ? { ...m.toolCall } : undefined,
-      toolResult: m.toolResult ? { ...m.toolResult } : undefined,
-      tokenUsage: m.tokenUsage ? { ...m.tokenUsage } : undefined
-    }));
-    compacted = appendMessages(compacted, ...preservedInputs, env);
-  }
-  return {
-    conversation: compacted,
-    result: {
-      compacted: true,
-      chunksProcessed: chunks.length,
-      messagesRemoved: compactable.length,
-      summaryContent
-    }
-  };
-}
-var ConversationEvent = class extends Event {
-  action;
-  conversation;
-  previousConversation;
-  messageIds;
-  toolCallIds;
-  constructor(type, detail) {
-    super(type);
-    this.action = detail.action;
-    this.conversation = detail.conversation;
-    this.previousConversation = detail.previousConversation;
-    if (detail.messageIds !== undefined)
-      this.messageIds = detail.messageIds;
-    if (detail.toolCallIds !== undefined)
-      this.toolCallIds = detail.toolCallIds;
-  }
-};
-var ConversationChangeEvent = class ConversationChangeEvent2 extends ConversationEvent {
-  static type = "change";
-  constructor(detail) {
-    super(ConversationChangeEvent2.type, detail);
-  }
-};
-var ConversationPushEvent = class ConversationPushEvent2 extends ConversationEvent {
-  static type = "push";
-  constructor(detail) {
-    super(ConversationPushEvent2.type, detail);
-  }
-};
-var ConversationUndoEvent = class ConversationUndoEvent2 extends ConversationEvent {
-  static type = "undo";
-  constructor(detail) {
-    super(ConversationUndoEvent2.type, detail);
-  }
-};
-var ConversationRedoEvent = class ConversationRedoEvent2 extends ConversationEvent {
-  static type = "redo";
-  constructor(detail) {
-    super(ConversationRedoEvent2.type, detail);
-  }
-};
-var ConversationSwitchEvent = class ConversationSwitchEvent2 extends ConversationEvent {
-  static type = "switch";
-  constructor(detail) {
-    super(ConversationSwitchEvent2.type, detail);
-  }
-};
-var MessagesAppendedEvent = class MessagesAppendedEvent2 extends ConversationEvent {
-  static type = "messages.appended";
-  constructor(detail) {
-    super(MessagesAppendedEvent2.type, detail);
-  }
-};
-var MessagesUpdatedEvent = class MessagesUpdatedEvent2 extends ConversationEvent {
-  static type = "messages.updated";
-  constructor(detail) {
-    super(MessagesUpdatedEvent2.type, detail);
-  }
-};
-var MessagesRemovedEvent = class MessagesRemovedEvent2 extends ConversationEvent {
-  static type = "messages.removed";
-  constructor(detail) {
-    super(MessagesRemovedEvent2.type, detail);
-  }
-};
-var ToolCallsAppendedEvent = class ToolCallsAppendedEvent2 extends ConversationEvent {
-  static type = "tool-calls.appended";
-  constructor(detail) {
-    super(ToolCallsAppendedEvent2.type, detail);
-  }
-};
-var ToolResultsAppendedEvent = class ToolResultsAppendedEvent2 extends ConversationEvent {
-  static type = "tool-results.appended";
-  constructor(detail) {
-    super(ToolResultsAppendedEvent2.type, detail);
-  }
-};
-var StreamStartedEvent = class StreamStartedEvent2 extends ConversationEvent {
-  static type = "stream.started";
-  constructor(detail) {
-    super(StreamStartedEvent2.type, detail);
-  }
-};
-var StreamUpdatedEvent = class StreamUpdatedEvent2 extends ConversationEvent {
-  static type = "stream.updated";
-  constructor(detail) {
-    super(StreamUpdatedEvent2.type, detail);
-  }
-};
-var StreamFinalizedEvent = class StreamFinalizedEvent2 extends ConversationEvent {
-  static type = "stream.finalized";
-  constructor(detail) {
-    super(StreamFinalizedEvent2.type, detail);
-  }
-};
-var StreamCancelledEvent = class StreamCancelledEvent2 extends ConversationEvent {
-  static type = "stream.cancelled";
-  constructor(detail) {
-    super(StreamCancelledEvent2.type, detail);
-  }
-};
-var CompactionStartedEvent = class CompactionStartedEvent2 extends ConversationEvent {
-  static type = "compaction.started";
-  constructor(detail) {
-    super(CompactionStartedEvent2.type, detail);
-  }
-};
-var CompactionCompletedEvent = class CompactionCompletedEvent2 extends ConversationEvent {
-  static type = "compaction.completed";
-  constructor(detail) {
-    super(CompactionCompletedEvent2.type, detail);
-  }
-};
-var SessionForkedEvent = class SessionForkedEvent2 extends ConversationEvent {
-  static type = "session.forked";
-  constructor(detail) {
-    super(SessionForkedEvent2.type, detail);
-  }
-};
-var SessionTaggedEvent = class SessionTaggedEvent2 extends ConversationEvent {
-  static type = "session.tagged";
-  constructor(detail) {
-    super(SessionTaggedEvent2.type, detail);
-  }
-};
-var SessionRenamedEvent = class SessionRenamedEvent2 extends ConversationEvent {
-  static type = "session.renamed";
-  constructor(detail) {
-    super(SessionRenamedEvent2.type, detail);
-  }
-};
-var PersistenceErrorEvent = class PersistenceErrorEvent2 extends Event {
-  static type = "persistence.error";
-  error;
-  constructor(error) {
-    super(PersistenceErrorEvent2.type);
-    this.error = error;
-  }
-};
-var conversationEventConstructors = {
-  [ConversationChangeEvent.type]: ConversationChangeEvent,
-  [ConversationPushEvent.type]: ConversationPushEvent,
-  [ConversationUndoEvent.type]: ConversationUndoEvent,
-  [ConversationRedoEvent.type]: ConversationRedoEvent,
-  [ConversationSwitchEvent.type]: ConversationSwitchEvent,
-  [MessagesAppendedEvent.type]: MessagesAppendedEvent,
-  [MessagesUpdatedEvent.type]: MessagesUpdatedEvent,
-  [MessagesRemovedEvent.type]: MessagesRemovedEvent,
-  [ToolCallsAppendedEvent.type]: ToolCallsAppendedEvent,
-  [ToolResultsAppendedEvent.type]: ToolResultsAppendedEvent,
-  [StreamStartedEvent.type]: StreamStartedEvent,
-  [StreamUpdatedEvent.type]: StreamUpdatedEvent,
-  [StreamFinalizedEvent.type]: StreamFinalizedEvent,
-  [StreamCancelledEvent.type]: StreamCancelledEvent,
-  [CompactionStartedEvent.type]: CompactionStartedEvent,
-  [CompactionCompletedEvent.type]: CompactionCompletedEvent,
-  [SessionForkedEvent.type]: SessionForkedEvent,
-  [SessionTaggedEvent.type]: SessionTaggedEvent,
-  [SessionRenamedEvent.type]: SessionRenamedEvent
-};
-function Y(H, f, R) {
-  let P = R?.bufferSize ?? 256, D = R?.signal, G = [], M = null, B = false;
-  function C(K) {
-    let Q = K;
-    if (M) {
-      let 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
-      });
-    }
-  }
-  if (D?.aborted)
-    B = true;
-  else
-    H.addEventListener(f, C), D?.addEventListener("abort", J, { once: true });
-  return {
-    next() {
-      if (G.length > 0)
-        return Promise.resolve({
-          value: G.shift(),
-          done: false
-        });
-      if (B)
-        return Promise.resolve({
-          value: undefined,
-          done: true
-        });
-      return new Promise((K) => {
-        M = K;
-      });
-    },
-    return() {
-      return J(), Promise.resolve({
-        value: undefined,
-        done: true
-      });
-    },
-    [Symbol.asyncIterator]() {
-      return this;
-    }
-  };
-}
-function Z(H, f, R) {
-  return { subscribe(P, D, G) {
-    let M = typeof P === "function" ? {
-      next: P,
-      error: D,
-      complete: G
-    } : P ?? {}, B = new AbortController, C = false, J = {
-      unsubscribe() {
-        if (C)
-          return;
-        C = true, B.abort(), M.complete?.();
-      },
-      get closed() {
-        return C;
-      }
-    };
-    if (M.start?.(J), C)
-      return J;
-    function U(Q) {
-      M.next?.(Q);
-    }
-    let K = R?.signal ? AbortSignal.any([R.signal, B.signal]) : B.signal;
-    if (H.addEventListener(f, U, { signal: K }), R?.signal)
-      R.signal.addEventListener("abort", () => {
-        if (!C)
-          C = true, M.complete?.();
-      }, {
-        once: true,
-        signal: B.signal
-      });
-    return J;
-  } };
-}
-var W = class extends EventTarget {
-  constructor() {
-    super();
-  }
-  addEventListener(H, f, R) {
-    super.addEventListener(H, f, R);
-  }
-  removeEventListener(H, f, R) {
-    super.removeEventListener(H, f, R);
-  }
-  dispatch(H) {
-    return this.dispatchEvent(H);
-  }
-};
-var j = class extends W {
-  #H = new AbortController;
-  #f = /* @__PURE__ */ new Set;
-  constructor() {
-    super();
-  }
-  get completed() {
-    return this.#H.signal.aborted;
-  }
-  get signal() {
-    return this.#H.signal;
-  }
-  complete() {
-    if (!this.#H.signal.aborted)
-      this.#H.abort();
-  }
-  dispatchEvent(H) {
-    let f = super.dispatchEvent(H);
-    for (let R of this.#f)
-      R(H);
-    return f;
-  }
-  on(H, f) {
-    return Z(this, H, { signal: f?.signal ?? this.signal });
-  }
-  once(H, f) {
-    this.addEventListener(H, f, {
-      once: true,
-      signal: this.signal
-    });
-  }
-  subscribe(H, f, R, P) {
-    return this.on(H).subscribe(f, R, P);
-  }
-  toObservable() {
-    return { subscribe: (H, f, R) => {
-      let P = typeof H === "function" ? {
-        next: H,
-        error: f,
-        complete: R
-      } : H ?? {}, D = false, G = (B) => {
-        if (!D)
-          P.next?.(B);
-      };
-      this.#f.add(G);
-      let M = () => {
-        if (!D)
-          D = true, this.#f.delete(G), P.complete?.();
-      };
-      return this.signal.addEventListener("abort", M, { once: true }), {
-        unsubscribe: () => {
-          if (D)
-            return;
-          D = true, this.#f.delete(G), this.signal.removeEventListener("abort", M), P.complete?.();
-        },
-        get closed() {
-          return D;
-        }
-      };
-    } };
-  }
-  events(H, f) {
-    return Y(this, H, {
-      signal: f?.signal ?? this.signal,
-      bufferSize: f?.bufferSize
-    });
-  }
-};
-function diffConversationMessages(previousConversation, nextConversation) {
-  const previousIds = new Set(previousConversation.ids);
-  const nextIds = new Set(nextConversation.ids);
-  const appended = nextConversation.ids.filter((id) => !previousIds.has(id));
-  const removed = previousConversation.ids.filter((id) => !nextIds.has(id));
-  const updated = [];
-  for (const id of nextConversation.ids) {
-    if (!previousIds.has(id))
-      continue;
-    const previousMessage = previousConversation.messages[id];
-    const nextMessage = nextConversation.messages[id];
-    if (!previousMessage || !nextMessage)
-      continue;
-    if (JSON.stringify(previousMessage) !== JSON.stringify(nextMessage))
-      updated.push(id);
-  }
-  return {
-    appended,
-    updated,
-    removed
-  };
-}
-function collectToolCallIds(conversation, messageIds) {
-  if (!messageIds || messageIds.length === 0)
-    return;
-  const ids = /* @__PURE__ */ new Set;
-  for (const messageId of messageIds) {
-    const message = conversation.messages[messageId];
-    if (!message)
-      continue;
-    if (message.toolCall?.id)
-      ids.add(message.toolCall.id);
-    if (message.toolResult?.callId)
-      ids.add(message.toolResult.callId);
-  }
-  return ids.size > 0 ? [...ids] : undefined;
-}
-async function loadConversationAdapter(provider) {
-  switch (provider) {
-    case "openai":
-      return (await 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;
-      });
-    }
-  }
-  buildEventDetail(action, previousConversation, context = {}) {
-    return {
-      action,
-      conversation: this.current,
-      previousConversation,
-      ...context.messageIds && context.messageIds.length > 0 ? { messageIds: context.messageIds } : {},
-      ...context.toolCallIds && context.toolCallIds.length > 0 ? { toolCallIds: context.toolCallIds } : {}
-    };
-  }
-  emitConversationEvent(type, detail) {
-    const EventConstructor = conversationEventConstructors[type];
-    if (EventConstructor)
-      this.emitter.dispatchEvent(new EventConstructor(detail));
-  }
-  commit(next, changeAction, emittedEvents, context) {
-    const previousConversation = this.current;
-    const newNode = {
-      conversation: next,
-      parent: this.currentNode,
-      children: []
-    };
-    this.currentNode.children.push(newNode);
-    this.currentNode = newNode;
-    if (this.environment.maxHistoryDepth !== undefined)
-      this.pruneToDepth(this.environment.maxHistoryDepth);
-    this.emitConversationEvent("change", this.buildEventDetail(changeAction, previousConversation, context));
-    for (const eventType of emittedEvents) {
-      if (eventType === "change")
-        continue;
-      const eventAction = eventType;
-      this.emitConversationEvent(eventType, this.buildEventDetail(eventAction, previousConversation, context));
-    }
-  }
-  pruneToDepth(maxDepth) {
-    let depth = 0;
-    let node = this.currentNode;
-    while (node) {
-      depth++;
-      node = node.parent;
-    }
-    while (depth > maxDepth) {
-      let root = this.currentNode;
-      while (root.parent)
-        root = root.parent;
-      const childOnPath = root.children.find((child) => {
-        let curr = this.currentNode;
-        while (curr) {
-          if (curr === child)
-            return true;
-          curr = curr.parent;
-        }
-        return false;
-      });
-      if (!childOnPath)
-        break;
-      childOnPath.parent = null;
-      depth--;
-    }
-  }
-  addEventListener(type, callback, options) {
-    const resolved = typeof options === "boolean" ? { capture: options } : { ...options };
-    resolved.signal ??= this.emitter.signal;
-    this.emitter.addEventListener(type, callback, resolved);
-  }
-  removeEventListener(type, callback, options) {
-    this.emitter.removeEventListener(type, callback, options);
-  }
-  dispatchEvent(event) {
-    return this.emitter.dispatchEvent(event);
-  }
-  watch(run) {
-    run(this.current);
-    const handler = (event) => {
-      run(event.conversation);
-    };
-    this.emitter.addEventListener("change", handler, { signal: this.emitter.signal });
-    return () => {
-      this.emitter.removeEventListener("change", handler);
-    };
-  }
-  on(type) {
-    return this.emitter.on(type);
-  }
-  once(type, listener) {
-    this.emitter.once(type, listener);
-  }
-  subscribe(type, observerOrNext, error, complete) {
-    return this.emitter.subscribe(type, observerOrNext, error, complete);
-  }
-  toObservable() {
-    return this.emitter.toObservable();
-  }
-  events(type, options) {
-    return this.emitter.events(type, options);
-  }
-  complete() {
-    this.emitter.complete();
-  }
-  get completed() {
-    return this.emitter.completed;
-  }
-  getSnapshot() {
-    return this.current;
-  }
-  get current() {
-    return this.currentNode.conversation;
-  }
-  get ids() {
-    return getMessageIds(this.current);
-  }
-  get canUndo() {
-    return this.currentNode.parent !== null;
-  }
-  get canRedo() {
-    return this.currentNode.children.length > 0;
-  }
-  get env() {
-    return this.environment;
-  }
-  get branchCount() {
-    return this.currentNode.parent ? this.currentNode.parent.children.length : 1;
-  }
-  get branchIndex() {
-    if (!this.currentNode.parent)
-      return 0;
-    return this.currentNode.parent.children.indexOf(this.currentNode);
-  }
-  get redoCount() {
-    return this.currentNode.children.length;
-  }
-  createChangeContext(previousConversation, nextConversation, action) {
-    const diff = diffConversationMessages(previousConversation, nextConversation);
-    const messageIds = action === "messages.appended" ? diff.appended : action === "messages.updated" ? diff.updated : diff.removed;
-    const toolCallIds = collectToolCallIds(action === "messages.removed" ? previousConversation : nextConversation, messageIds);
-    return {
-      ...messageIds.length > 0 ? { messageIds } : {},
-      ...toolCallIds ? { toolCallIds } : {}
-    };
-  }
-  pushWithEvents(next, changeAction, context) {
-    this.commit(next, changeAction, ["push", changeAction], context);
-  }
-  push(next) {
-    this.commit(next, "push", ["push"]);
-  }
-  undo() {
-    if (this.currentNode.parent) {
-      const previousConversation = this.current;
-      this.currentNode = this.currentNode.parent;
-      this.emitConversationEvent("change", this.buildEventDetail("undo", previousConversation));
-      this.emitConversationEvent("undo", this.buildEventDetail("undo", previousConversation));
-      return this.current;
-    }
-  }
-  redo(childIndex = 0) {
-    const next = this.currentNode.children[childIndex];
-    if (next) {
-      const previousConversation = this.current;
-      this.currentNode = next;
-      this.emitConversationEvent("change", this.buildEventDetail("redo", previousConversation));
-      this.emitConversationEvent("redo", this.buildEventDetail("redo", previousConversation));
-      return this.current;
-    }
-  }
-  switchToBranch(index) {
-    if (this.currentNode.parent) {
-      const target = this.currentNode.parent.children[index];
-      if (target) {
-        const previousConversation = this.current;
-        this.currentNode = target;
-        this.emitConversationEvent("change", this.buildEventDetail("switch", previousConversation));
-        this.emitConversationEvent("switch", this.buildEventDetail("switch", previousConversation));
-        return this.current;
-      }
-    }
-  }
-  fork(messageId) {
-    const previous = this.current;
-    const cloned = JSON.parse(JSON.stringify(this.current));
-    let forkedHistory;
-    if (messageId) {
-      const messageIndex = cloned.ids.indexOf(messageId);
-      if (messageIndex === -1)
-        throw new Error(`Message with id "${messageId}" not found`);
-      const truncatedIds = cloned.ids.slice(0, messageIndex + 1);
-      const truncatedMessages = {};
-      for (const id of truncatedIds) {
-        const message = cloned.messages[id];
-        if (message)
-          truncatedMessages[id] = message;
-      }
-      forkedHistory = {
-        ...cloned,
-        id: this.environment.randomId(),
-        ids: truncatedIds,
-        messages: truncatedMessages,
-        updatedAt: this.environment.now()
-      };
-    } else
-      forkedHistory = {
-        ...cloned,
-        id: this.environment.randomId(),
-        updatedAt: this.environment.now()
-      };
-    const detail = this.buildEventDetail("session.forked", previous);
-    this.emitConversationEvent("session.forked", detail);
-    this.emitConversationEvent("change", detail);
-    return new Conversation2(forkedHistory, this.environment);
-  }
-  tag(label) {
-    const previous = this.current;
-    const existingTags = previous.metadata["_tags"] ?? [];
-    if (existingTags.includes(label))
-      return;
-    const next = {
-      ...previous,
-      metadata: {
-        ...previous.metadata,
-        _tags: [...existingTags, label]
-      },
-      updatedAt: this.environment.now()
-    };
-    this.commit(next, "session.tagged", ["push", "session.tagged"]);
-  }
-  rename(title) {
-    const previous = this.current;
-    if (previous.title === title)
-      return;
-    const next = {
-      ...previous,
-      title,
-      updatedAt: this.environment.now()
-    };
-    this.commit(next, "session.renamed", ["push", "session.renamed"]);
-  }
-  getPath() {
-    const path = [];
-    let curr = this.currentNode;
-    while (curr) {
-      path.unshift(curr.conversation);
-      curr = curr.parent;
-    }
-    return path;
-  }
-  getMessages(options) {
-    return getMessages(this.current, options);
-  }
-  getMessageAtPosition(position) {
-    return getMessageAtPosition(this.current, position);
-  }
-  getMessageIds() {
-    return getMessageIds(this.current);
-  }
-  getMessageById(id) {
-    return getMessageById(this.current, id);
-  }
-  get(id) {
-    return getMessageById(this.current, id);
-  }
-  searchMessages(predicate) {
-    return searchConversationMessages(this.current, predicate);
-  }
-  getStatistics() {
-    return getStatistics(this.current);
-  }
-  hasSystemMessage() {
-    return hasSystemMessage(this.current);
-  }
-  getFirstSystemMessage() {
-    return getFirstSystemMessage(this.current);
-  }
-  getSystemMessages() {
-    return getSystemMessages(this.current);
-  }
-  toChatMessages() {
-    return toChatMessages(this.current);
-  }
-  estimateTokens(estimator) {
-    return estimateConversationTokens(this.current, estimator, this.env);
-  }
-  getRecentMessages(count, options) {
-    return getRecentMessages(this.current, count, options);
-  }
-  getStreamingMessage() {
-    return getStreamingMessage(this.current);
-  }
-  appendMessages(...inputs) {
-    const previousConversation = this.current;
-    const nextConversation = appendMessages(this.current, ...inputs, this.env);
-    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
-  }
-  appendUserMessage(content, metadata) {
-    const previousConversation = this.current;
-    const nextConversation = appendUserMessage(this.current, content, metadata, this.env);
-    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
-  }
-  appendAssistantMessage(content, metadata) {
-    const previousConversation = this.current;
-    const nextConversation = appendAssistantMessage(this.current, content, metadata, this.env);
-    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
-  }
-  appendSystemMessage(content, metadata) {
-    const previousConversation = this.current;
-    const nextConversation = appendSystemMessage(this.current, content, metadata, this.env);
-    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
-  }
-  prependSystemMessage(content, metadata) {
-    const previousConversation = this.current;
-    const nextConversation = prependSystemMessage(this.current, content, metadata, this.env);
-    this.pushWithEvents(nextConversation, "messages.appended", this.createChangeContext(previousConversation, nextConversation, "messages.appended"));
-  }
-  replaceSystemMessage(content, metadata) {
-    const previousConversation = this.current;
-    const nextConversation = replaceSystemMessage(this.current, content, metadata, this.env);
-    this.pushWithEvents(nextConversation, "messages.updated", this.createChangeContext(previousConversation, nextConversation, "messages.updated"));
-  }
-  collapseSystemMessages() {
-    const previousConversation = this.current;
-    const nextConversation = collapseSystemMessages(this.current, this.env);
-    const action = previousConversation.ids.length === nextConversation.ids.length ? "messages.updated" : "messages.removed";
-    this.pushWithEvents(nextConversation, action, this.createChangeContext(previousConversation, nextConversation, action));
-  }
-  redactMessageAtPosition(position, placeholderOrOptions) {
-    const previousConversation = this.current;
-    const nextConversation = redactMessageAtPosition(this.current, position, placeholderOrOptions, this.env);
-    this.pushWithEvents(nextConversation, "messages.updated", this.createChangeContext(previousConversation, nextConversation, "messages.updated"));
-  }
-  truncateFromPosition(position, options) {
-    const previousConversation = this.current;
-    const nextConversation = truncateFromPosition(this.current, position, options, this.env);
-    this.pushWithEvents(nextConversation, "messages.removed", this.createChangeContext(previousConversation, nextConversation, "messages.removed"));
-  }
-  truncateToTokenLimit(maxTokens, options) {
-    const previousConversation = this.current;
-    const nextConversation = truncateToTokenLimit(this.current, maxTokens, options, this.env);
-    this.pushWithEvents(nextConversation, "messages.removed", this.createChangeContext(previousConversation, nextConversation, "messages.removed"));
-  }
-  async compact(summarizer, options) {
-    const previous = this.current;
-    this.emitConversationEvent("compaction.started", this.buildEventDetail("compaction.started", previous));
-    const { conversation, result } = await compactConversation(this.current, summarizer, options, this.env);
-    if (result.compacted)
-      this.pushWithEvents(conversation, "compaction.completed", this.createChangeContext(previous, conversation, "messages.removed"));
-    else
-      this.emitConversationEvent("compaction.completed", this.buildEventDetail("compaction.completed", previous));
-    return result;
-  }
-  appendStreamingMessage(role, metadata) {
-    const { conversation, messageId } = appendStreamingMessage(this.current, role, metadata, this.env);
-    this.commit(conversation, "stream.started", [
-      "push",
-      "messages.appended",
-      "stream.started"
-    ], { messageIds: [messageId] });
-    return messageId;
-  }
-  updateStreamingMessage(messageId, content) {
-    const nextConversation = updateStreamingMessage(this.current, messageId, content, this.env);
-    this.commit(nextConversation, "stream.updated", [
-      "push",
-      "messages.updated",
-      "stream.updated"
-    ], { messageIds: [messageId] });
-  }
-  finalizeStreamingMessage(messageId, options) {
-    const nextConversation = finalizeStreamingMessage(this.current, messageId, options, this.env);
-    this.commit(nextConversation, "stream.finalized", [
-      "push",
-      "messages.updated",
-      "stream.finalized"
-    ], { messageIds: [messageId] });
-  }
-  cancelStreamingMessage(messageId) {
-    const nextConversation = cancelStreamingMessage(this.current, messageId, this.env);
-    this.commit(nextConversation, "stream.cancelled", [
-      "push",
-      "messages.removed",
-      "stream.cancelled"
-    ], { messageIds: [messageId] });
-  }
-  appendToolCall(toolCall, options) {
-    const nextConversation = appendToolCall(this.current, toolCall, options, this.env);
-    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
-    this.commit(nextConversation, "tool-calls.appended", [
-      "push",
-      "messages.appended",
-      "tool-calls.appended"
-    ], context);
-  }
-  appendToolCalls(toolCalls) {
-    const nextConversation = appendToolCalls(this.current, toolCalls, this.env);
-    if (nextConversation === this.current)
-      return;
-    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
-    this.commit(nextConversation, "tool-calls.appended", [
-      "push",
-      "messages.appended",
-      "tool-calls.appended"
-    ], context);
-  }
-  appendToolResult(toolResult, options) {
-    const nextConversation = appendToolResult(this.current, toolResult, options, this.env);
-    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
-    this.commit(nextConversation, "tool-results.appended", [
-      "push",
-      "messages.appended",
-      "tool-results.appended"
-    ], context);
-  }
-  appendToolResults(toolResults) {
-    const nextConversation = appendToolResults(this.current, toolResults, this.env);
-    if (nextConversation === this.current)
-      return;
-    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
-    this.commit(nextConversation, "tool-results.appended", [
-      "push",
-      "messages.appended",
-      "tool-results.appended"
-    ], context);
-  }
-  async appendToolResultAsync(toolResult, options) {
-    const nextConversation = await appendToolResultAsync(this.current, toolResult, options, this.env);
-    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
-    this.commit(nextConversation, "tool-results.appended", [
-      "push",
-      "messages.appended",
-      "tool-results.appended"
-    ], context);
-  }
-  async appendToolResultsAsync(toolResults) {
-    const nextConversation = await appendToolResultsAsync(this.current, toolResults, this.env);
-    if (nextConversation === this.current)
-      return;
-    const context = this.createChangeContext(this.current, nextConversation, "messages.appended");
-    this.commit(nextConversation, "tool-results.appended", [
-      "push",
-      "messages.appended",
-      "tool-results.appended"
-    ], context);
-  }
-  getPendingToolCalls() {
-    return getPendingToolCalls(this.current);
-  }
-  getToolInteractions() {
-    return getToolInteractions(this.current);
-  }
-  static async fromProvider(provider, payload, environment) {
-    return new Conversation2((await loadConversationAdapter(provider)).import(payload), environment);
-  }
-  async toProvider(provider, options) {
-    return (await loadConversationAdapter(provider)).export(this.current, options);
-  }
-  async appendProvider(provider, payload) {
-    const nextConversation = (await loadConversationAdapter(provider)).append(this.current, payload);
-    if (nextConversation === this.current)
-      return;
-    const diff = diffConversationMessages(this.current, nextConversation);
-    const appendedIds = diff.appended;
-    const updatedIds = diff.updated;
-    const removedIds = diff.removed;
-    const action = removedIds.length > 0 ? "messages.removed" : updatedIds.length > 0 ? "messages.updated" : "messages.appended";
-    const messageIds = action === "messages.removed" ? removedIds : action === "messages.updated" ? updatedIds : appendedIds;
-    const toolCallIds = collectToolCallIds(nextConversation, messageIds);
-    this.commit(nextConversation, action, ["push", action], {
-      ...messageIds.length > 0 ? { messageIds } : {},
-      ...toolCallIds ? { toolCallIds } : {}
-    });
-  }
-  snapshot() {
-    const getPath = (node) => {
-      const path = [];
-      let curr = node;
-      while (curr.parent) {
-        path.unshift(curr.parent.children.indexOf(curr));
-        curr = curr.parent;
-      }
-      return path;
-    };
-    const serializeNode = (node) => ({
-      conversation: node.conversation,
-      children: node.children.map(serializeNode)
-    });
-    let root = this.currentNode;
-    while (root.parent)
-      root = root.parent;
-    return {
-      root: serializeNode(root),
-      currentPath: getPath(this.currentNode)
-    };
-  }
-  static from(json, environment) {
-    const conversation = new Conversation2(deserializeConversationHistory(json.root.conversation), environment);
-    const buildTree = (nodeJSON, parentNode) => {
-      const node = {
-        conversation: deserializeConversationHistory(nodeJSON.conversation),
-        parent: parentNode,
-        children: []
-      };
-      node.children = nodeJSON.children.map((child) => buildTree(child, node));
-      return node;
-    };
-    const rootNode = conversation.currentNode;
-    rootNode.children = json.root.children.map((child) => buildTree(child, rootNode));
-    let current = rootNode;
-    for (const index of json.currentPath) {
-      const target = current.children[index];
-      if (target)
-        current = target;
-    }
-    conversation.currentNode = current;
-    return conversation;
-  }
-  static async fromOpenAIMessages(messages, environment) {
-    return Conversation2.fromProvider("openai", [...messages], environment);
-  }
-  static async fromAnthropicMessages(payload, environment) {
-    return Conversation2.fromProvider("anthropic", payload, environment);
-  }
-  static async fromGeminiMessages(payload, environment) {
-    return Conversation2.fromProvider("gemini", payload, environment);
-  }
-  async toOpenAIMessages() {
-    return this.toProvider("openai", { groupToolCalls: false });
-  }
-  async toOpenAIMessagesGrouped() {
-    return this.toProvider("openai", { groupToolCalls: true });
-  }
-  async toAnthropicMessages() {
-    return this.toProvider("anthropic");
-  }
-  async toGeminiMessages() {
-    return this.toProvider("gemini");
-  }
-  bind(fn) {
-    return (...args) => {
-      const result = fn(this.current, ...args, this.env);
-      if (isConversationHistory(result))
-        this.push(result);
-      return result;
-    };
-  }
-  [Symbol.dispose]() {
-    this.complete();
-    let root = this.currentNode;
-    while (root?.parent)
-      root = root.parent;
-    const clearNode = (node) => {
-      for (const child of node.children)
-        clearNode(child);
-      node.children = [];
-      const n = node;
-      n.parent = null;
-      n.conversation = null;
-    };
-    if (root)
-      clearNode(root);
-  }
-};
-function isConversationHistory(value) {
-  return value !== null && typeof value === "object" && typeof value.schemaVersion === "number" && typeof value.id === "string" && typeof value.status === "string" && value.metadata !== null && typeof value.metadata === "object" && Array.isArray(value.ids) && typeof value.messages === "object" && value.messages !== null && !Array.isArray(value.messages) && typeof value.createdAt === "string" && typeof value.updatedAt === "string";
+// src/utilities/class-names.ts
+function classNames(...parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
 }
 
-// ../../node_modules/conversationalist/dist/utilities/index.js
-init_append_l_g0hmrj();
-init_message_BEjqY7Jv();
-init_transient_Bk0RaCFf();
-
 // src/components/chat/utilities/conversation.ts
+import { getMessages } from "conversationalist";
+import { pairToolCallsWithResults as pairConversationalistToolCallsWithResults } from "conversationalist/utilities";
 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));
+function pairToolCallsWithResults(messages) {
+  return pairConversationalistToolCallsWithResults(messages.filter(hasPairableToolField));
 }
 // src/components/chat/utilities/utilities.ts
 var CINDER_REASONING_METADATA_KEY = "cinder:reasoning";
@@ -4095,7 +122,7 @@ function resolveMessageSuggestions(message, fromProp) {
   const suggestions = candidate.filter((entry) => typeof entry === "string");
   return suggestions.length > 0 ? suggestions : undefined;
 }
-function toMultiModalArray2(input) {
+function toMultiModalArray(input) {
   if (typeof input === "string")
     return [{ type: "text", text: input }];
   return "type" in input ? [input] : input;
@@ -4126,7 +153,7 @@ function getServerContentText(part) {
   }
 }
 function getMessageParts(message) {
-  return toMultiModalArray2(message.content);
+  return toMultiModalArray(message.content);
 }
 function getMessageText(message) {
   return getMessageParts(message).map(getServerContentText).filter((text) => typeof text === "string" && text.length > 0).join(`
@@ -4493,4 +520,4 @@ export {
   Chat_conversation_list as ChatConversationList
 };
 
-//# debugId=90F6D3A37597B1CF64756E2164756E21
+//# debugId=FA6DE2C72C326CFB64756E2164756E21