@lostgradient/cinder 0.4.1 → 0.6.0

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

@@ -0,0 +1,1389 @@
+// ../../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