@lostgradient/cinder 0.8.0 → 0.9.0

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

@@ -1,1389 +0,0 @@
-// ../../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";
-}
-
-// ../../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;
-};
-var 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
-  ]);
-});
-var 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;
-});
-var messageRoleSchema = z.enum([
-  "user",
-  "assistant",
-  "system",
-  "developer",
-  "tool-call",
-  "tool-result",
-  "snapshot"
-]);
-var toolCallSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  arguments: jsonValueSchema
-}).strict();
-var toolCallInputSchema = z.object({
-  id: z.string().optional(),
-  name: z.string(),
-  arguments: jsonValueSchema.optional()
-}).strict();
-var toolErrorCategorySchema = z.enum([
-  "validation",
-  "permission",
-  "not_found",
-  "conflict",
-  "transient",
-  "timeout",
-  "cancelled",
-  "internal"
-]);
-var toolErrorSchema = z.object({
-  code: z.string(),
-  category: toolErrorCategorySchema,
-  retryable: z.boolean(),
-  message: z.string(),
-  details: jsonValueSchema.optional()
-}).strict();
-var toolActionSchema = z.object({
-  type: z.enum(["approval", "input"]),
-  message: z.string().optional(),
-  schema: jsonValueSchema.optional()
-}).strict();
-var 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();
-var tokenUsageSchema = z.object({
-  prompt: z.number().int().min(0),
-  completion: z.number().int().min(0),
-  total: z.number().int().min(0)
-});
-var 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();
-var 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();
-var conversationStatusSchema = z.enum([
-  "active",
-  "archived",
-  "deleted"
-]);
-var 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()
-};
-var 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;
-}
-var 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(`
-`);
-  }
-};
-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;
-}
-
-// ../../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);
-}
-var defaultConversationEnvironment = {
-  now: () => (/* @__PURE__ */ new Date()).toISOString(),
-  randomId: () => crypto.randomUUID(),
-  estimateTokens: simpleTokenEstimator,
-  plugins: []
-};
-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;
-}
-var 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);
-var registerToolUse = (index, toolCall) => {
-  const next = new Map(index);
-  next.set(toolCall.id, { name: toolCall.name });
-  return next;
-};
-var assertToolReference = (index, callId) => {
-  if (!index.has(callId))
-    throw createInvalidToolReferenceError(callId);
-};
-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);
-}
-var 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;
-};
-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);
-}
-
-// ../../node_modules/conversationalist/dist/tool-results-DKQs9ZGX.js
-function redactToolResult(toolResult, placeholder) {
-  return {
-    ...toolResult,
-    content: placeholder
-  };
-}
-
-// ../../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
-  }));
-}
-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;
-};
-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;
-}
-
-// ../../node_modules/conversationalist/dist/streaming.js
-var STREAMING_KEY = "__streaming";
-var 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);
-};
-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
-  }));
-}
-
-export { copyContent, toReadonly, createMessage, isAssistantMessage, getOrderedMessages, toIdRecord, ConversationalistError, createIntegrityError, assertConversationSafe, ensureConversationSafe, pairToolCallsWithResults, appendToolCall, appendToolCalls, appendToolResult, appendToolResults, appendToolResultAsync, appendToolResultsAsync, getPendingToolCalls, getToolInteractions, toSessionInfo, simpleTokenEstimator, resolveConversationEnvironment, isConversationEnvironmentParameter, appendMessages, appendUserMessage, appendAssistantMessage, appendSystemMessage, createConversationHistory, getMessages, getMessageAtPosition, getMessageIds, getMessageById, searchConversationMessages, getStatistics, hasSystemMessage, getFirstSystemMessage, getSystemMessages, prependSystemMessage, replaceSystemMessage, collapseSystemMessages, redactMessageAtPosition, deserializeConversationHistory, toChatMessages, isStreamingMessage, getStreamingMessage, appendStreamingMessage, updateStreamingMessage, finalizeStreamingMessage, cancelStreamingMessage };
-
-//# debugId=559319DDE09F498564756E2164756E21