conversationalist 0.0.10 → 0.0.11

package/dist/index.js

@@ -23,6 +23,12 @@ function copyContent(content) {
 }
 // src/schemas.ts
 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;
+};
 function toMultiModalContent(value) {
   const result = { type: value.type };
   if (value.text !== undefined)
@@ -33,14 +39,28 @@ function toMultiModalContent(value) {
     result.mimeType = value.mimeType;
   return result;
 }
-var jsonValueSchema = z.lazy(() => z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.null(),
-  z.array(jsonValueSchema),
-  z.record(z.string(), jsonValueSchema)
-]));
+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"),
@@ -66,16 +86,12 @@ var toolCallSchema = z.object({
   id: z.string(),
   name: z.string(),
   arguments: jsonValueSchema
-});
+}).strict();
 var toolResultSchema = z.object({
   callId: z.string(),
   outcome: z.enum(["success", "error"]),
-  content: jsonValueSchema,
-  toolCallId: z.string().optional(),
-  toolName: z.string().optional(),
-  result: jsonValueSchema.optional(),
-  error: z.string().optional()
-});
+  content: jsonValueSchema
+}).strict();
 var tokenUsageSchema = z.object({
   prompt: z.number().int().min(0),
   completion: z.number().int().min(0),
@@ -90,7 +106,7 @@ var messageInputSchema = z.object({
   toolResult: toolResultSchema.optional(),
   tokenUsage: tokenUsageSchema.optional(),
   goalCompleted: z.boolean().optional()
-});
+}).strict();
 var messageSchema = z.object({
   id: z.string(),
   role: messageRoleSchema,
@@ -103,7 +119,7 @@ var messageSchema = z.object({
   toolResult: toolResultSchema.optional(),
   tokenUsage: tokenUsageSchema.optional(),
   goalCompleted: z.boolean().optional()
-}).loose();
+}).strict();
 var conversationStatusSchema = z.enum([
   "active",
   "archived",
@@ -120,7 +136,7 @@ var conversationShape = {
   createdAt: z.string(),
   updatedAt: z.string()
 };
-var conversationSchema = z.object(conversationShape);
+var conversationSchema = z.object(conversationShape).strict();
 // src/utilities/content.ts
 function toMultiModalArray(input) {
   if (typeof input === "string")
@@ -203,6 +219,160 @@ function pairToolCallsWithResults(messages) {
   }
   return pairs;
 }
+// src/errors.ts
+class ConversationalistError 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, ConversationalistError);
+    }
+  }
+  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 createLockedError(conversationId) {
+  return new ConversationalistError("error:locked", `conversation ${conversationId} is locked (concurrent modification detected)`, { context: { conversationId } });
+}
+function createInvalidInputError(message, context) {
+  return new ConversationalistError("error:invalid-input", message, { context });
+}
+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-use: ${callId}`, { context: { callId } });
+}
+function createDuplicateIdError(id) {
+  return new ConversationalistError("error:duplicate-id", `conversation with id ${id} already exists`, { context: { id } });
+}
+function createNotFoundError(id) {
+  return new ConversationalistError("error:not-found", `conversation with id ${id} not found`, {
+    context: { id }
+  });
+}
+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 });
+}
+
+// src/conversation/integrity.ts
+function validateConversationIntegrity(conversation) {
+  const issues = [];
+  const seenIds = 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 toolUses = new Map;
+  conversation.ids.forEach((id, index) => {
+    const message = conversation.messages[id];
+    if (!message)
+      return;
+    if (message.role === "tool-use" && message.toolCall) {
+      if (toolUses.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 {
+        toolUses.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 toolUse = toolUses.get(message.toolResult.callId);
+      if (!toolUse) {
+        issues.push({
+          code: "integrity:orphan-tool-result",
+          message: `tool-result references missing tool-use ${message.toolResult.callId}`,
+          data: { callId: message.toolResult.callId, messageId: message.id }
+        });
+      } else if (toolUse.position >= index) {
+        issues.push({
+          code: "integrity:tool-result-before-call",
+          message: `tool-result ${message.toolResult.callId} occurs before tool-use`,
+          data: {
+            callId: message.toolResult.callId,
+            messageId: message.id,
+            toolUseMessageId: toolUse.messageId
+          }
+        });
+      }
+    }
+  });
+  return issues;
+}
+function assertConversationIntegrity(conversation) {
+  const issues = validateConversationIntegrity(conversation);
+  if (issues.length === 0)
+    return;
+  throw createIntegrityError("conversation integrity check failed", { issues });
+}
+
+// src/conversation/validation.ts
+function assertConversationSafe(conversation) {
+  const parsed = conversationSchema.safeParse(conversation);
+  if (!parsed.success) {
+    throw createValidationError("conversation failed schema validation", {
+      issues: parsed.error.issues
+    });
+  }
+  assertConversationIntegrity(conversation);
+}
+function ensureConversationSafe(conversation) {
+  assertConversationSafe(conversation);
+  return conversation;
+}
+
 // src/utilities/message-store.ts
 function getOrderedMessages(conversation) {
   const ordered = [];
@@ -259,7 +429,7 @@ function stripTransientMetadata(conversation) {
     }
     return toReadonly(baseMessage);
   });
-  return toReadonly({
+  return ensureConversationSafe(toReadonly({
     schemaVersion: conversation.schemaVersion,
     id: conversation.id,
     title: conversation.title,
@@ -269,7 +439,7 @@ function stripTransientMetadata(conversation) {
     messages: toIdRecord(strippedMessages),
     createdAt: conversation.createdAt,
     updatedAt: conversation.updatedAt
-  });
+  }));
 }
 // src/environment.ts
 function simpleTokenEstimator(message) {
@@ -302,64 +472,43 @@ function withEnvironment(environment, fn) {
   return (...args) => fn(...args, environment);
 }
 
-// src/errors.ts
-class ConversationalistError 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, ConversationalistError);
-    }
-  }
-  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 createLockedError(conversationId) {
-  return new ConversationalistError("error:locked", `conversation ${conversationId} is locked (concurrent modification detected)`, { context: { conversationId } });
-}
-function createInvalidInputError(message, context) {
-  return new ConversationalistError("error:invalid-input", message, { context });
-}
-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-use: ${callId}`, { context: { callId } });
-}
-function createDuplicateIdError(id) {
-  return new ConversationalistError("error:duplicate-id", `conversation with id ${id} already exists`, { context: { id } });
-}
-function createNotFoundError(id) {
-  return new ConversationalistError("error:not-found", `conversation with id ${id} not found`, {
-    context: { id }
-  });
-}
-function createSerializationError(message, cause) {
-  return new ConversationalistError("error:serialization", message, { cause });
-}
-function createValidationError(message, context, cause) {
-  return new ConversationalistError("error:validation", message, { context, cause });
-}
-
 // src/types.ts
 var CURRENT_SCHEMA_VERSION = 3;
 
-// src/conversation.ts
+// src/conversation/create.ts
+function createConversation(options, environment) {
+  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const now = resolvedEnvironment.now();
+  const conv = {
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    id: options?.id ?? resolvedEnvironment.randomId(),
+    title: options?.title,
+    status: options?.status ?? "active",
+    metadata: { ...options?.metadata ?? {} },
+    ids: [],
+    messages: {},
+    createdAt: now,
+    updatedAt: now
+  };
+  return ensureConversationSafe(toReadonly(conv));
+}
+function createConversationUnsafe(options, environment) {
+  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const now = resolvedEnvironment.now();
+  const conv = {
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    id: options?.id ?? resolvedEnvironment.randomId(),
+    title: options?.title,
+    status: options?.status ?? "active",
+    metadata: { ...options?.metadata ?? {} },
+    ids: [],
+    messages: {},
+    createdAt: now,
+    updatedAt: now
+  };
+  return toReadonly(conv);
+}
+// src/conversation/tool-tracking.ts
 var buildToolUseIndex = (messages) => messages.reduce((index, message) => {
   if (message.role === "tool-use" && message.toolCall) {
     index.set(message.toolCall.id, { name: message.toolCall.name });
@@ -376,44 +525,37 @@ var assertToolReference = (index, callId) => {
     throw createInvalidToolReferenceError(callId);
   }
 };
+
+// src/conversation/append.ts
 function partitionAppendArgs(args) {
-  if (args.length === 0) {
+  const filtered = args.filter((arg) => arg !== undefined);
+  if (filtered.length === 0) {
     return { inputs: [] };
   }
-  const last = args[args.length - 1];
+  const last = filtered[filtered.length - 1];
   if (isConversationEnvironmentParameter(last)) {
     return {
-      inputs: args.slice(0, -1),
+      inputs: filtered.slice(0, -1),
       environment: last
     };
   }
-  return { inputs: args };
-}
-function createConversation(options, environment) {
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
-  const now = resolvedEnvironment.now();
-  const conv = {
-    schemaVersion: CURRENT_SCHEMA_VERSION,
-    id: options?.id ?? resolvedEnvironment.randomId(),
-    title: options?.title,
-    status: options?.status ?? "active",
-    metadata: { ...options?.metadata ?? {} },
-    ids: [],
-    messages: {},
-    createdAt: now,
-    updatedAt: now
-  };
-  return toReadonly(conv);
+  return { inputs: filtered };
 }
 function appendMessages(conversation, ...args) {
+  return appendMessagesInternal(conversation, args, true);
+}
+function appendUnsafeMessage(conversation, input, environment) {
+  return appendMessagesInternal(conversation, [input, environment], false);
+}
+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 = buildToolUseIndex(getOrderedMessages(conversation));
+  const initialToolUses = validate ? buildToolUseIndex(getOrderedMessages(conversation)) : new Map;
   const { messages } = inputs.reduce((state, input, index) => {
     const processedInput = resolvedEnvironment.plugins.reduce((acc, plugin) => plugin(acc), input);
-    if (processedInput.role === "tool-result" && processedInput.toolResult) {
+    if (validate && processedInput.role === "tool-result" && processedInput.toolResult) {
       assertToolReference(state.toolUses, processedInput.toolResult.callId);
     }
     const normalizedContent = normalizeContent(processedInput.content);
@@ -440,7 +582,16 @@ function appendMessages(conversation, ...args) {
     } else {
       message = createMessage(baseMessage);
     }
-    const toolUses = processedInput.role === "tool-use" && processedInput.toolCall ? registerToolUse(state.toolUses, processedInput.toolCall) : state.toolUses;
+    let toolUses = state.toolUses;
+    if (processedInput.role === "tool-use" && 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]
@@ -453,17 +604,25 @@ function appendMessages(conversation, ...args) {
     messages: { ...conversation.messages, ...toIdRecord(messages) },
     updatedAt: now
   };
-  return toReadonly(next);
-}
+  const readonly = toReadonly(next);
+  return validate ? ensureConversationSafe(readonly) : readonly;
+};
 function appendUserMessage(conversation, content, metadata, environment) {
-  return environment ? appendMessages(conversation, { role: "user", content, metadata }, environment) : appendMessages(conversation, { role: "user", content, metadata });
+  const resolvedEnvironment = isConversationEnvironmentParameter(metadata) ? metadata : environment;
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
+  return appendMessages(conversation, { role: "user", content, metadata: resolvedMetadata }, resolvedEnvironment);
 }
 function appendAssistantMessage(conversation, content, metadata, environment) {
-  return environment ? appendMessages(conversation, { role: "assistant", content, metadata }, environment) : appendMessages(conversation, { role: "assistant", content, metadata });
+  const resolvedEnvironment = isConversationEnvironmentParameter(metadata) ? metadata : environment;
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
+  return appendMessages(conversation, { role: "assistant", content, metadata: resolvedMetadata }, resolvedEnvironment);
 }
 function appendSystemMessage(conversation, content, metadata, environment) {
-  return environment ? appendMessages(conversation, { role: "system", content, metadata }, environment) : appendMessages(conversation, { role: "system", content, metadata });
+  const resolvedEnvironment = isConversationEnvironmentParameter(metadata) ? metadata : environment;
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
+  return appendMessages(conversation, { role: "system", content, metadata: resolvedMetadata }, resolvedEnvironment);
 }
+// src/conversation/query.ts
 function getMessages(conversation, options) {
   const includeHidden = options?.includeHidden ?? false;
   const ordered = getOrderedMessages(conversation);
@@ -497,6 +656,7 @@ function getStatistics(conversation) {
   }, { byRole: {}, hidden: 0, withImages: 0 });
   return { total: ordered.length, ...stats };
 }
+// src/conversation/system-messages.ts
 function hasSystemMessage(conversation) {
   return getOrderedMessages(conversation).some((m) => m.role === "system");
 }
@@ -507,7 +667,8 @@ function getSystemMessages(conversation) {
   return getOrderedMessages(conversation).filter((m) => m.role === "system");
 }
 function prependSystemMessage(conversation, content, metadata, environment) {
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(metadata) ? metadata : environment);
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
   const now = resolvedEnvironment.now();
   const newMessage = createMessage({
     id: resolvedEnvironment.randomId(),
@@ -515,7 +676,7 @@ function prependSystemMessage(conversation, content, metadata, environment) {
     content,
     position: 0,
     createdAt: now,
-    metadata: { ...metadata ?? {} },
+    metadata: { ...resolvedMetadata ?? {} },
     hidden: false,
     toolCall: undefined,
     toolResult: undefined,
@@ -534,20 +695,21 @@ function prependSystemMessage(conversation, content, metadata, environment) {
     toolResult: message.toolResult,
     tokenUsage: message.tokenUsage
   }));
-  return toReadonly({
+  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(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, metadata, resolvedEnvironment);
+    return prependSystemMessage(conversation, content, resolvedMetadata, resolvedEnvironment);
   }
   const original = ordered[firstSystemIndex];
   const replaced = createMessage({
@@ -556,7 +718,7 @@ function replaceSystemMessage(conversation, content, metadata, environment) {
     content,
     position: original.position,
     createdAt: original.createdAt,
-    metadata: { ...metadata ?? original.metadata },
+    metadata: { ...resolvedMetadata ?? original.metadata },
     hidden: original.hidden,
     toolCall: undefined,
     toolResult: undefined,
@@ -568,13 +730,13 @@ function replaceSystemMessage(conversation, content, metadata, environment) {
     messages: { ...conversation.messages, [replaced.id]: replaced },
     updatedAt: now
   };
-  return toReadonly(next);
+  return ensureConversationSafe(toReadonly(next));
 }
 function collapseSystemMessages(conversation, environment) {
   const ordered = getOrderedMessages(conversation);
   const systemMessages = ordered.filter((m) => m.role === "system");
   if (systemMessages.length <= 1) {
-    return conversation;
+    return ensureConversationSafe(conversation);
   }
   const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
@@ -630,9 +792,39 @@ function collapseSystemMessages(conversation, environment) {
     messages: toIdRecord(renumbered),
     updatedAt: now
   };
-  return toReadonly(next);
+  return ensureConversationSafe(toReadonly(next));
 }
-function redactMessageAtPosition(conversation, position, placeholder = "[REDACTED]", environment) {
+// src/utilities/tool-results.ts
+function redactToolResult(toolResult, placeholder) {
+  return { ...toolResult, content: placeholder };
+}
+
+// src/conversation/modify.ts
+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);
   }
@@ -641,6 +833,22 @@ function redactMessageAtPosition(conversation, position, placeholder = "[REDACTE
   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-use" && 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,
@@ -649,11 +857,11 @@ function redactMessageAtPosition(conversation, position, placeholder = "[REDACTE
     createdAt: original.createdAt,
     metadata: { ...original.metadata },
     hidden: original.hidden,
-    toolCall: undefined,
-    toolResult: undefined,
-    tokenUsage: undefined
+    toolCall,
+    toolResult,
+    tokenUsage: original.tokenUsage ? { ...original.tokenUsage } : undefined
   });
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const resolvedEnvironment = resolveConversationEnvironment(env);
   const now = resolvedEnvironment.now();
   const next = {
     ...conversation,
@@ -661,70 +869,62 @@ function redactMessageAtPosition(conversation, position, placeholder = "[REDACTE
     messages: { ...conversation.messages, [redacted.id]: redacted },
     updatedAt: now
   };
-  return toReadonly(next);
+  return ensureConversationSafe(toReadonly(next));
 }
-function migrateConversation(json) {
-  if (typeof json !== "object" || json === null || Array.isArray(json)) {
-    return {
-      schemaVersion: CURRENT_SCHEMA_VERSION,
-      id: "",
-      status: "active",
-      metadata: {},
-      ids: [],
-      messages: {},
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString()
-    };
-  }
-  const data = json;
-  const rawMessages = data.messages;
-  let messages = {};
-  let ids = [];
-  const rawIds = data.ids;
-  const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
-  if (Array.isArray(rawMessages)) {
-    const rawMessageArray = rawMessages;
-    ids = rawMessageArray.map((message) => message.id);
-    messages = Object.fromEntries(rawMessageArray.map((message) => [message.id, message]));
-  } else if (rawMessages && typeof rawMessages === "object") {
-    messages = { ...rawMessages };
-    if (isStringArray(rawIds) && rawIds.length > 0) {
-      ids = [...rawIds];
-    } else {
-      ids = Object.values(messages).sort((a, b) => a.position - b.position).map((message) => message.id);
-    }
-  }
-  if (ids.length > 0) {
-    ids = ids.filter((id) => (id in messages));
-    const missing = Object.keys(messages).filter((id) => !ids.includes(id));
-    if (missing.length > 0) {
-      const sortedMissing = missing.sort((a, b) => (messages[a]?.position ?? 0) - (messages[b]?.position ?? 0));
-      ids = [...ids, ...sortedMissing];
-    }
-  }
-  if (!("schemaVersion" in json)) {
+// src/conversation/serialization.ts
+function normalizeToolResult(toolResult) {
+  if (!toolResult)
+    return;
+  return {
+    callId: toolResult.callId,
+    outcome: toolResult.outcome,
+    content: toolResult.content
+  };
+}
+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 {
-      ...data,
-      schemaVersion: CURRENT_SCHEMA_VERSION,
-      ids,
-      messages
+      ...base,
+      role: "assistant",
+      goalCompleted: message.goalCompleted
     };
   }
-  return { ...data, ids, messages };
+  return base;
 }
 function deserializeConversation(json) {
-  const migrated = migrateConversation(json);
+  const parsed = conversationSchema.safeParse(json);
+  if (!parsed.success) {
+    throw createSerializationError("failed to deserialize conversation: invalid data");
+  }
+  const data = parsed.data;
   try {
-    const orderedMessages = migrated.ids.map((id, index) => {
-      const message = migrated.messages[id];
+    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);
       }
-      return message;
+      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-use" && message.toolCall) {
         return {
@@ -736,24 +936,28 @@ function deserializeConversation(json) {
       }
       return state;
     }, { toolUses: new Map });
-    const messageInstances = orderedMessages.map((m) => createMessage(m));
+    const messageInstances = orderedMessages.map((message) => createMessage(message));
     const conv = {
-      schemaVersion: migrated.schemaVersion,
-      id: migrated.id,
-      title: migrated.title,
-      status: migrated.status,
-      metadata: { ...migrated.metadata },
+      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: migrated.createdAt,
-      updatedAt: migrated.updatedAt
+      createdAt: data.createdAt,
+      updatedAt: data.updatedAt
     };
-    return toReadonly(conv);
+    const readonly = toReadonly(conv);
+    assertConversationIntegrity(readonly);
+    return readonly;
   } catch (error) {
     throw createSerializationError(`failed to deserialize conversation: ${error instanceof Error ? error.message : String(error)}`, error);
   }
 }
+// src/conversation/transform.ts
 function toChatMessages(conversation) {
+  assertConversationSafe(conversation);
   const roleMap = {
     user: "user",
     assistant: "assistant",
@@ -775,6 +979,62 @@ function toChatMessages(conversation) {
   }
   return result;
 }
+// src/conversation/tool-interactions.ts
+function appendToolUse(conversation, toolCall, options, environment) {
+  const resolved = resolveConversationEnvironment(isConversationEnvironmentParameter(options) ? options : environment);
+  const resolvedOptions = isConversationEnvironmentParameter(options) ? undefined : options;
+  const callId = toolCall.callId ?? resolved.randomId();
+  const toolCallMeta = {
+    id: callId,
+    name: toolCall.toolId,
+    arguments: toolCall.args
+  };
+  return appendMessages(conversation, {
+    role: "tool-use",
+    content: resolvedOptions?.content ?? "",
+    metadata: resolvedOptions?.metadata,
+    hidden: resolvedOptions?.hidden,
+    toolCall: toolCallMeta,
+    tokenUsage: resolvedOptions?.tokenUsage
+  }, resolved);
+}
+function appendToolResult(conversation, toolResult, options, environment) {
+  const resolvedOptions = isConversationEnvironmentParameter(options) ? undefined : options;
+  const toolResultMeta = {
+    callId: toolResult.callId,
+    outcome: toolResult.outcome,
+    content: toolResult.result
+  };
+  return appendMessages(conversation, {
+    role: "tool-result",
+    content: resolvedOptions?.content ?? "",
+    metadata: resolvedOptions?.metadata,
+    hidden: resolvedOptions?.hidden,
+    toolResult: toolResultMeta,
+    tokenUsage: resolvedOptions?.tokenUsage
+  }, isConversationEnvironmentParameter(options) ? options : environment);
+}
+function getPendingToolCalls(conversation) {
+  const ordered = getOrderedMessages(conversation);
+  const completed = new Set;
+  for (const message of ordered) {
+    if (message.role === "tool-result" && message.toolResult) {
+      completed.add(message.toolResult.callId);
+    }
+  }
+  const pending = [];
+  for (const message of ordered) {
+    if (message.role === "tool-use" && message.toolCall) {
+      if (!completed.has(message.toolCall.id)) {
+        pending.push(message.toolCall);
+      }
+    }
+  }
+  return pending;
+}
+function getToolInteractions(conversation) {
+  return pairToolCallsWithResults(getOrderedMessages(conversation));
+}
 // src/guards.ts
 function isSchema(schema, value) {
   return schema.safeParse(value).success;
@@ -833,6 +1093,92 @@ var cloneMessageWithPosition = (message, position, content) => {
   }
   return createMessage(baseMessage);
 };
+var createMessageBlock = (message, estimator) => ({
+  messages: [message],
+  minPosition: message.position,
+  maxPosition: message.position,
+  tokenCount: estimator(message)
+});
+var buildMessageBlocks = (messages, estimator, preserveToolPairs) => {
+  if (!preserveToolPairs) {
+    const blocks2 = messages.map((message) => createMessageBlock(message, estimator));
+    const messageToBlock2 = new Map;
+    for (const block of blocks2) {
+      const message = block.messages[0];
+      if (message) {
+        messageToBlock2.set(message.id, block);
+      }
+    }
+    return { blocks: blocks2, messageToBlock: messageToBlock2 };
+  }
+  const blocks = [];
+  const toolUses = new Map;
+  for (const message of messages) {
+    if (message.role === "tool-use" && message.toolCall) {
+      const block = createMessageBlock(message, estimator);
+      toolUses.set(message.toolCall.id, block);
+      blocks.push(block);
+      continue;
+    }
+    if (message.role === "tool-result" && message.toolResult) {
+      const existing = toolUses.get(message.toolResult.callId);
+      if (existing) {
+        existing.messages.push(message);
+        existing.maxPosition = Math.max(existing.maxPosition, message.position);
+        existing.tokenCount += estimator(message);
+        continue;
+      }
+      const orphanBlock = createMessageBlock(message, estimator);
+      orphanBlock.orphanToolResult = true;
+      blocks.push(orphanBlock);
+      continue;
+    }
+    blocks.push(createMessageBlock(message, estimator));
+  }
+  const filteredBlocks = blocks.filter((block) => !block.orphanToolResult);
+  const messageToBlock = new Map;
+  for (const block of filteredBlocks) {
+    for (const message of block.messages) {
+      messageToBlock.set(message.id, block);
+    }
+  }
+  return { blocks: filteredBlocks, messageToBlock };
+};
+var collectBlocksForMessages = (messages, messageToBlock) => {
+  const blocks = [];
+  const seen = new Set;
+  for (const message of messages) {
+    const block = messageToBlock.get(message.id);
+    if (block && !seen.has(block)) {
+      seen.add(block);
+      blocks.push(block);
+    }
+  }
+  return blocks;
+};
+var collectMessagesFromBlocks = (blocks) => {
+  const messages = [];
+  const seen = new Set;
+  for (const block of blocks) {
+    for (const message of block.messages) {
+      if (!seen.has(message.id)) {
+        seen.add(message.id);
+        messages.push(message);
+      }
+    }
+  }
+  messages.sort((a, b) => a.position - b.position);
+  return messages;
+};
+var ensureTruncationSafe = (conversation, preserveToolPairs, operation) => {
+  try {
+    return ensureConversationSafe(conversation);
+  } catch (error) {
+    if (!preserveToolPairs && error instanceof ConversationalistError && error.code === "error:integrity")
+      throw createIntegrityError(`${operation} produced invalid tool linkage; use preserveToolPairs: true to keep tool interactions intact`, { preserveToolPairs, issues: error.context?.["issues"] });
+    throw error;
+  }
+};
 function estimateConversationTokens(conversation, estimateTokens, environment) {
   let estimator = estimateTokens;
   let env = environment;
@@ -845,6 +1191,7 @@ function estimateConversationTokens(conversation, estimateTokens, environment) {
   return getOrderedMessages(conversation).reduce((total, message) => total + finalEstimator(message), 0);
 }
 function truncateToTokenLimit(conversation, maxTokens, optionsOrEstimator, environment) {
+  assertConversationSafe(conversation);
   let options = {};
   let env = environment;
   if (typeof optionsOrEstimator === "function") {
@@ -866,54 +1213,56 @@ function truncateToTokenLimit(conversation, maxTokens, optionsOrEstimator, envir
   const estimator = options.estimateTokens ?? resolvedEnvironment.estimateTokens;
   const preserveSystem = options.preserveSystemMessages ?? true;
   const preserveLastN = options.preserveLastN ?? 0;
+  const preserveToolPairs = options.preserveToolPairs ?? true;
   const currentTokens = estimateConversationTokens(conversation, estimator, resolvedEnvironment);
   if (currentTokens <= maxTokens) {
     return conversation;
   }
   const now = resolvedEnvironment.now();
   const orderedMessages = getOrderedMessages(conversation);
+  const { blocks, messageToBlock } = buildMessageBlocks(orderedMessages, estimator, preserveToolPairs);
   const systemMessages = preserveSystem ? orderedMessages.filter((m) => m.role === "system") : [];
   const nonSystemMessages = orderedMessages.filter((m) => m.role !== "system");
   const protectedMessages = preserveLastN > 0 ? nonSystemMessages.slice(-preserveLastN) : [];
-  const removableMessages = preserveLastN > 0 ? nonSystemMessages.slice(0, -preserveLastN) : nonSystemMessages;
-  const systemTokens = systemMessages.reduce((sum, m) => sum + estimator(m), 0);
-  const protectedTokens = protectedMessages.reduce((sum, m) => sum + estimator(m), 0);
+  const systemBlocks = collectBlocksForMessages(systemMessages, messageToBlock);
+  const protectedBlocks = collectBlocksForMessages(protectedMessages, messageToBlock);
+  const lockedBlocks = new Set([...systemBlocks, ...protectedBlocks]);
+  const removableBlocks = blocks.filter((block) => !lockedBlocks.has(block));
+  const systemTokens = systemBlocks.reduce((sum, block) => sum + block.tokenCount, 0);
+  const protectedTokens = protectedBlocks.reduce((sum, block) => sum + block.tokenCount, 0);
   const availableTokens = maxTokens - systemTokens - protectedTokens;
+  let selectedBlocks = [];
   if (availableTokens <= 0) {
-    const allMessages2 = [...systemMessages, ...protectedMessages];
-    const renumbered2 = allMessages2.map((message, index) => cloneMessageWithPosition(message, index, copyContent(message.content)));
-    return toReadonly({
-      ...conversation,
-      ids: renumbered2.map((message) => message.id),
-      messages: toIdRecord(renumbered2),
-      updatedAt: now
-    });
-  }
-  const keptRemovable = [];
-  let usedTokens = 0;
-  for (let i = removableMessages.length - 1;i >= 0; i--) {
-    const message = removableMessages[i];
-    const messageTokens = estimator(message);
-    if (usedTokens + messageTokens <= availableTokens) {
-      keptRemovable.unshift(message);
-      usedTokens += messageTokens;
-    } else {
-      break;
+    selectedBlocks = [...systemBlocks, ...protectedBlocks];
+  } else {
+    const sortedRemovable = [...removableBlocks].sort((a, b) => a.maxPosition - b.maxPosition);
+    const keptRemovable = [];
+    let usedTokens = 0;
+    for (let i = sortedRemovable.length - 1;i >= 0; i--) {
+      const block = sortedRemovable[i];
+      if (usedTokens + block.tokenCount <= availableTokens) {
+        keptRemovable.unshift(block);
+        usedTokens += block.tokenCount;
+      } else {
+        break;
+      }
     }
+    selectedBlocks = [...systemBlocks, ...keptRemovable, ...protectedBlocks];
   }
-  const allMessages = [...systemMessages, ...keptRemovable, ...protectedMessages];
-  allMessages.sort((a, b) => a.position - b.position);
+  const allMessages = collectMessagesFromBlocks(selectedBlocks);
   const renumbered = allMessages.map((message, index) => cloneMessageWithPosition(message, index, copyContent(message.content)));
-  return toReadonly({
+  const next = toReadonly({
     ...conversation,
     ids: renumbered.map((message) => message.id),
     messages: toIdRecord(renumbered),
     updatedAt: now
   });
+  return ensureTruncationSafe(next, preserveToolPairs, "truncateToTokenLimit");
 }
 function getRecentMessages(conversation, count, options) {
   const includeHidden = options?.includeHidden ?? false;
   const includeSystem = options?.includeSystem ?? false;
+  const preserveToolPairs = options?.preserveToolPairs ?? true;
   const filtered = getOrderedMessages(conversation).filter((m) => {
     if (!includeHidden && m.hidden)
       return false;
@@ -921,23 +1270,35 @@ function getRecentMessages(conversation, count, options) {
       return false;
     return true;
   });
-  return filtered.slice(-count);
+  if (!preserveToolPairs) {
+    return filtered.slice(-count);
+  }
+  const { messageToBlock } = buildMessageBlocks(filtered, () => 0, preserveToolPairs);
+  const tail = filtered.slice(-count);
+  const blocks = collectBlocksForMessages(tail, messageToBlock);
+  return collectMessagesFromBlocks(blocks);
 }
 function truncateFromPosition(conversation, position, options, environment) {
+  assertConversationSafe(conversation);
   const preserveSystem = options?.preserveSystemMessages ?? true;
+  const preserveToolPairs = options?.preserveToolPairs ?? true;
   const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
   const ordered = getOrderedMessages(conversation);
+  const { messageToBlock } = buildMessageBlocks(ordered, () => 0, preserveToolPairs);
   const systemMessages = preserveSystem ? ordered.filter((m) => m.role === "system" && m.position < position) : [];
   const keptMessages = ordered.filter((m) => m.position >= position);
-  const allMessages = [...systemMessages, ...keptMessages];
+  const systemBlocks = collectBlocksForMessages(systemMessages, messageToBlock);
+  const keptBlocks = collectBlocksForMessages(keptMessages, messageToBlock);
+  const allMessages = collectMessagesFromBlocks([...systemBlocks, ...keptBlocks]);
   const renumbered = allMessages.map((message, index) => cloneMessageWithPosition(message, index, copyContent(message.content)));
-  return toReadonly({
+  const next = toReadonly({
     ...conversation,
     ids: renumbered.map((message) => message.id),
     messages: toIdRecord(renumbered),
     updatedAt: now
   });
+  return ensureTruncationSafe(next, preserveToolPairs, "truncateFromPosition");
 }
 
 // src/streaming.ts
@@ -972,7 +1333,8 @@ function getStreamingMessage(conversation) {
   return getOrderedMessages(conversation).find(isStreamingMessage);
 }
 function appendStreamingMessage(conversation, role, metadata, environment) {
-  const resolvedEnvironment = resolveConversationEnvironment(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({
@@ -981,7 +1343,7 @@ function appendStreamingMessage(conversation, role, metadata, environment) {
     content: "",
     position: conversation.ids.length,
     createdAt: now,
-    metadata: { ...metadata ?? {}, [STREAMING_KEY]: true },
+    metadata: { ...resolvedMetadata ?? {}, [STREAMING_KEY]: true },
     hidden: false,
     toolCall: undefined,
     toolResult: undefined,
@@ -993,14 +1355,14 @@ function appendStreamingMessage(conversation, role, metadata, environment) {
     messages: { ...conversation.messages, [messageId]: newMessage },
     updatedAt: now
   });
-  return { conversation: updatedConversation, messageId };
+  return { conversation: ensureConversationSafe(updatedConversation), messageId };
 }
 function updateStreamingMessage(conversation, messageId, content, environment) {
   const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
   const original = conversation.messages[messageId];
   if (!original) {
-    return conversation;
+    return ensureConversationSafe(conversation);
   }
   const overrides = {
     content: typeof content === "string" ? content : [...content]
@@ -1009,44 +1371,45 @@ function updateStreamingMessage(conversation, messageId, content, environment) {
     overrides.tokenUsage = { ...original.tokenUsage };
   }
   const updated = cloneMessage(original, overrides);
-  return toReadonly({
+  return ensureConversationSafe(toReadonly({
     ...conversation,
     ids: [...conversation.ids],
     messages: { ...conversation.messages, [updated.id]: updated },
     updatedAt: now
-  });
+  }));
 }
 function finalizeStreamingMessage(conversation, messageId, options, environment) {
-  const resolvedEnvironment = resolveConversationEnvironment(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 conversation;
+    return ensureConversationSafe(conversation);
   }
   const { [STREAMING_KEY]: _, ...restMetadata } = original.metadata;
   const finalMetadata = {
     ...restMetadata,
-    ...options?.metadata ?? {}
+    ...resolvedOptions?.metadata ?? {}
   };
   const finalizeOverrides = {
     metadata: finalMetadata
   };
-  if (options?.tokenUsage) {
-    finalizeOverrides.tokenUsage = { ...options.tokenUsage };
+  if (resolvedOptions?.tokenUsage) {
+    finalizeOverrides.tokenUsage = { ...resolvedOptions.tokenUsage };
   }
   const updated = cloneMessage(original, finalizeOverrides);
-  return toReadonly({
+  return ensureConversationSafe(toReadonly({
     ...conversation,
     ids: [...conversation.ids],
     messages: { ...conversation.messages, [updated.id]: updated },
     updatedAt: now
-  });
+  }));
 }
 function cancelStreamingMessage(conversation, messageId, environment) {
   const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
   if (!conversation.messages[messageId]) {
-    return conversation;
+    return ensureConversationSafe(conversation);
   }
   const messages = getOrderedMessages(conversation).filter((m) => m.id !== messageId).map((message, index) => message.position === index ? message : (() => {
     const overrides = {
@@ -1057,12 +1420,12 @@ function cancelStreamingMessage(conversation, messageId, environment) {
     }
     return cloneMessage(message, overrides);
   })());
-  return toReadonly({
+  return ensureConversationSafe(toReadonly({
     ...conversation,
     ids: messages.map((message) => message.id),
     messages: toIdRecord(messages),
     updatedAt: now
-  });
+  }));
 }
 
 // src/with-conversation.ts
@@ -1100,8 +1463,8 @@ function createDraft(initial) {
       current = collapseSystemMessages(current);
       return draft;
     },
-    redactMessageAtPosition: (position, placeholder) => {
-      current = redactMessageAtPosition(current, position, placeholder);
+    redactMessageAtPosition: (position, placeholderOrOptions) => {
+      current = redactMessageAtPosition(current, position, placeholderOrOptions);
       return draft;
     },
     appendStreamingMessage: (role, metadata) => {
@@ -1133,15 +1496,16 @@ function createDraft(initial) {
   return draft;
 }
 function withConversation(conversation, fn) {
-  const draft = createDraft(conversation);
+  const draft = createDraft(ensureConversationSafe(conversation));
   const maybePromise = fn(draft);
   if (maybePromise && typeof maybePromise === "object" && typeof maybePromise.then === "function") {
-    return maybePromise.then(() => draft.value);
+    return maybePromise.then(() => ensureConversationSafe(draft.value));
   }
-  return draft.value;
+  return ensureConversationSafe(draft.value);
 }
 function pipeConversation(conversation, ...fns) {
-  return fns.reduce((current, fn) => fn(current), conversation);
+  const result = fns.reduce((current, fn) => fn(current), conversation);
+  return ensureConversationSafe(result);
 }
 // node_modules/event-emission/dist/index.js
 var SymbolObservable = typeof Symbol === "function" && Symbol.observable || Symbol.for("@@observable");
@@ -2662,8 +3026,9 @@ class ConversationHistory extends EventTarget {
     super();
     this.environment = resolveConversationEnvironment(environment);
     this.events = createEventTarget();
+    const safeInitial = ensureConversationSafe(initial);
     this.currentNode = {
-      conversation: initial,
+      conversation: safeInitial,
       parent: null,
       children: []
     };
@@ -2861,8 +3226,8 @@ class ConversationHistory extends EventTarget {
   collapseSystemMessages() {
     this.push(collapseSystemMessages(this.current, this.env));
   }
-  redactMessageAtPosition(position, placeholder) {
-    this.push(redactMessageAtPosition(this.current, position, placeholder, this.env));
+  redactMessageAtPosition(position, placeholderOrOptions) {
+    this.push(redactMessageAtPosition(this.current, position, placeholderOrOptions, this.env));
   }
   truncateFromPosition(position, options) {
     this.push(truncateFromPosition(this.current, position, options, this.env));
@@ -2968,6 +3333,7 @@ function isConversation2(value) {
 export {
   withEnvironment,
   withConversation,
+  validateConversationIntegrity,
   updateStreamingMessage,
   truncateToTokenLimit,
   truncateFromPosition,
@@ -3005,10 +3371,12 @@ export {
   isConversation,
   isAssistantMessage,
   hasSystemMessage,
+  getToolInteractions,
   getSystemMessages,
   getStreamingMessage,
   getStatistics,
   getRecentMessages,
+  getPendingToolCalls,
   getMessages,
   getMessageIds,
   getMessageById,
@@ -3026,6 +3394,7 @@ export {
   createInvalidPositionError,
   createInvalidInputError,
   createDuplicateIdError,
+  createConversationUnsafe,
   createConversation,
   copyMultiModalContent,
   copyContent,
@@ -3033,7 +3402,11 @@ export {
   conversationSchema,
   collapseSystemMessages,
   cancelStreamingMessage,
+  assertConversationIntegrity,
   appendUserMessage,
+  appendUnsafeMessage,
+  appendToolUse,
+  appendToolResult,
   appendSystemMessage,
   appendStreamingMessage,
   appendMessages,
@@ -3042,4 +3415,4 @@ export {
   ConversationHistory
 };
 
-//# debugId=684D5332D9139AFC64756E2164756E21
+//# debugId=F37C8EF457F39BC364756E2164756E21