conversationalist 0.0.2 → 0.0.3

package/dist/index.js

@@ -95,24 +95,103 @@ var conversationShape = {
   updatedAt: z.string()
 };
 var conversationSchema = z.object(conversationShape);
+// src/utilities.ts
+function pairToolCallsWithResults(messages) {
+  const pairs = [];
+  const resultsMap = new Map;
+  for (const msg of messages) {
+    if (msg.toolResult) {
+      resultsMap.set(msg.toolResult.callId, msg.toolResult);
+    }
+  }
+  for (const msg of messages) {
+    if (msg.toolCall) {
+      pairs.push({
+        call: msg.toolCall,
+        result: resultsMap.get(msg.toolCall.id)
+      });
+    }
+  }
+  return pairs;
+}
+function toReadonly(value) {
+  return value;
+}
+function createMessage(props) {
+  const content = Array.isArray(props.content) ? toReadonly([...props.content]) : 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({ ...props.toolCall }) : undefined,
+    toolResult: props.toolResult ? toReadonly({ ...props.toolResult }) : undefined,
+    tokenUsage: props.tokenUsage ? toReadonly({ ...props.tokenUsage }) : undefined,
+    goalCompleted: props.goalCompleted
+  };
+  return toReadonly(message);
+}
+function toMultiModalArray(input) {
+  if (typeof input === "string")
+    return [{ type: "text", text: input }];
+  return Array.isArray(input) ? input : [input];
+}
+function normalizeContent(content) {
+  if (content === undefined)
+    return;
+  if (typeof content === "string")
+    return content;
+  return Array.isArray(content) ? content : [content];
+}
+function messageParts(message) {
+  if (typeof message.content === "string") {
+    return message.content ? [{ type: "text", text: message.content }] : [];
+  }
+  return message.content;
+}
+function messageText(message, joiner = `
+
+`) {
+  if (typeof message.content === "string")
+    return message.content;
+  return messageParts(message).filter((p) => p.type === "text").map((p) => p.type === "text" ? p.text : "").join(joiner);
+}
+function messageHasImages(message) {
+  return messageParts(message).some((p) => p.type === "image");
+}
+
 // src/environment.ts
+function simpleTokenEstimator(message) {
+  const text = messageText(message);
+  return Math.ceil(text.length / 4);
+}
 var defaultConversationEnvironment = {
   now: () => new Date().toISOString(),
-  randomId: () => crypto.randomUUID()
+  randomId: () => crypto.randomUUID(),
+  estimateTokens: simpleTokenEstimator,
+  plugins: []
 };
 function resolveConversationEnvironment(environment) {
   return {
     now: environment?.now ?? defaultConversationEnvironment.now,
-    randomId: environment?.randomId ?? defaultConversationEnvironment.randomId
+    randomId: environment?.randomId ?? defaultConversationEnvironment.randomId,
+    estimateTokens: environment?.estimateTokens ?? defaultConversationEnvironment.estimateTokens,
+    plugins: [...environment?.plugins ?? defaultConversationEnvironment.plugins]
   };
 }
 function isConversationEnvironmentParameter(value) {
-  if (!value || typeof value !== "object")
+  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";
+  return typeof candidate["now"] === "function" || typeof candidate["randomId"] === "function" || typeof candidate["estimateTokens"] === "function" || Array.isArray(candidate["plugins"]) && candidate["plugins"].length > 0;
+}
+function withEnvironment(environment, fn) {
+  return (...args) => fn(...args, environment);
 }
 
 // src/errors.ts
@@ -169,74 +248,6 @@ function createValidationError(message, context, cause) {
   return new ConversationalistError("error:validation", message, { context, cause });
 }
 
-// src/utilities.ts
-function pairToolCallsWithResults(messages) {
-  const pairs = [];
-  const resultsMap = new Map;
-  for (const msg of messages) {
-    if (msg.toolResult) {
-      resultsMap.set(msg.toolResult.callId, msg.toolResult);
-    }
-  }
-  for (const msg of messages) {
-    if (msg.toolCall) {
-      pairs.push({
-        call: msg.toolCall,
-        result: resultsMap.get(msg.toolCall.id)
-      });
-    }
-  }
-  return pairs;
-}
-function toReadonly(value) {
-  return value;
-}
-function createMessage(props) {
-  const content = Array.isArray(props.content) ? toReadonly([...props.content]) : 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({ ...props.toolCall }) : undefined,
-    toolResult: props.toolResult ? toReadonly({ ...props.toolResult }) : undefined,
-    tokenUsage: props.tokenUsage ? toReadonly({ ...props.tokenUsage }) : undefined,
-    goalCompleted: props.goalCompleted
-  };
-  return toReadonly(message);
-}
-function toMultiModalArray(input) {
-  if (typeof input === "string")
-    return [{ type: "text", text: input }];
-  return Array.isArray(input) ? input : [input];
-}
-function normalizeContent(content) {
-  if (content === undefined)
-    return;
-  if (typeof content === "string")
-    return content;
-  return Array.isArray(content) ? content : [content];
-}
-function messageParts(message) {
-  if (typeof message.content === "string") {
-    return message.content ? [{ type: "text", text: message.content }] : [];
-  }
-  return message.content;
-}
-function messageText(message, joiner = `
-
-`) {
-  if (typeof message.content === "string")
-    return message.content;
-  return messageParts(message).filter((p) => p.type === "text").map((p) => p.type === "text" ? p.text : "").join(joiner);
-}
-function messageHasImages(message) {
-  return messageParts(message).some((p) => p.type === "image");
-}
-
 // src/conversation.ts
 var buildToolUseIndex = (messages) => messages.reduce((index, message) => {
   if (message.role === "tool-use" && message.toolCall) {
@@ -289,24 +300,25 @@ function appendMessages(conversation, ...args) {
   const startPosition = conversation.messages.length;
   const initialToolUses = buildToolUseIndex(conversation.messages);
   const { messages } = inputs.reduce((state, input, index) => {
-    if (input.role === "tool-result" && input.toolResult) {
-      assertToolReference(state.toolUses, input.toolResult.callId);
+    const processedInput = resolvedEnvironment.plugins.reduce((acc, plugin) => plugin(acc), input);
+    if (processedInput.role === "tool-result" && processedInput.toolResult) {
+      assertToolReference(state.toolUses, processedInput.toolResult.callId);
     }
-    const normalizedContent = normalizeContent(input.content);
+    const normalizedContent = normalizeContent(processedInput.content);
     const message = createMessage({
       id: resolvedEnvironment.randomId(),
-      role: input.role,
+      role: processedInput.role,
       content: normalizedContent,
       position: startPosition + index,
       createdAt: now,
-      metadata: { ...input.metadata ?? {} },
-      hidden: input.hidden ?? false,
-      toolCall: input.toolCall,
-      toolResult: input.toolResult,
-      tokenUsage: input.tokenUsage,
-      goalCompleted: input.goalCompleted
+      metadata: { ...processedInput.metadata ?? {} },
+      hidden: processedInput.hidden ?? false,
+      toolCall: processedInput.toolCall,
+      toolResult: processedInput.toolResult,
+      tokenUsage: processedInput.tokenUsage,
+      goalCompleted: processedInput.goalCompleted
     });
-    const toolUses = input.role === "tool-use" && input.toolCall ? registerToolUse(state.toolUses, input.toolCall) : state.toolUses;
+    const toolUses = processedInput.role === "tool-use" && processedInput.toolCall ? registerToolUse(state.toolUses, processedInput.toolCall) : state.toolUses;
     return {
       toolUses,
       messages: [...state.messages, message]
@@ -583,73 +595,57 @@ function toChatMessages(conversation) {
   return result;
 }
 // src/context.ts
-function getRecentMessages(conversation, count, options) {
-  const includeHidden = options?.includeHidden ?? false;
-  const includeSystem = options?.includeSystem ?? false;
-  const filtered = conversation.messages.filter((m) => {
-    if (!includeHidden && m.hidden)
-      return false;
-    if (!includeSystem && m.role === "system")
-      return false;
-    return true;
-  });
-  return filtered.slice(-count);
-}
-function truncateFromPosition(conversation, position, options, environment) {
-  const preserveSystem = options?.preserveSystemMessages ?? true;
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
-  const now = resolvedEnvironment.now();
-  const systemMessages = preserveSystem ? conversation.messages.filter((m) => m.role === "system" && m.position < position) : [];
-  const keptMessages = conversation.messages.filter((m) => m.position >= position);
-  const allMessages = [...systemMessages, ...keptMessages];
-  const renumbered = allMessages.map((message, index) => createMessage({
-    id: message.id,
-    role: message.role,
-    content: typeof message.content === "string" ? message.content : [...message.content],
-    position: index,
-    createdAt: message.createdAt,
-    metadata: { ...message.metadata },
-    hidden: message.hidden,
-    toolCall: message.toolCall ? { ...message.toolCall } : undefined,
-    toolResult: message.toolResult ? { ...message.toolResult } : undefined,
-    tokenUsage: message.tokenUsage ? { ...message.tokenUsage } : undefined,
-    goalCompleted: message.goalCompleted
-  }));
-  return toReadonly({
-    ...conversation,
-    messages: renumbered,
-    updatedAt: now
-  });
-}
-function estimateConversationTokens(conversation, estimateTokens) {
-  return conversation.messages.reduce((total, message) => total + estimateTokens(message), 0);
-}
-function simpleTokenEstimator(message) {
-  const text = messageText(message);
-  return Math.ceil(text.length / 4);
+function estimateConversationTokens(conversation, estimateTokens, environment) {
+  let estimator = estimateTokens;
+  let env = environment;
+  if (!environment && estimateTokens && isConversationEnvironmentParameter(estimateTokens)) {
+    env = estimateTokens;
+    estimator = undefined;
+  }
+  const resolvedEnvironment = resolveConversationEnvironment(env);
+  const finalEstimator = typeof estimator === "function" ? estimator : resolvedEnvironment.estimateTokens;
+  return conversation.messages.reduce((total, message) => total + finalEstimator(message), 0);
 }
-function truncateToTokenLimit(conversation, maxTokens, estimateTokens, options, environment) {
-  const preserveSystem = options?.preserveSystemMessages ?? true;
-  const preserveLastN = options?.preserveLastN ?? 0;
-  const currentTokens = estimateConversationTokens(conversation, estimateTokens);
+function truncateToTokenLimit(conversation, maxTokens, optionsOrEstimator, environment) {
+  let options = {};
+  let env = environment;
+  if (typeof optionsOrEstimator === "function") {
+    options = { estimateTokens: optionsOrEstimator };
+  } else if (optionsOrEstimator) {
+    if (!environment && isConversationEnvironmentParameter(optionsOrEstimator)) {
+      const candidate = optionsOrEstimator;
+      const hasEnvFields = !!(candidate["now"] || candidate["randomId"] || Array.isArray(candidate["plugins"]) && candidate["plugins"].length > 0);
+      if (hasEnvFields) {
+        env = optionsOrEstimator;
+      } else {
+        options = optionsOrEstimator;
+      }
+    } else {
+      options = optionsOrEstimator;
+    }
+  }
+  const resolvedEnvironment = resolveConversationEnvironment(env);
+  const estimator = options.estimateTokens ?? resolvedEnvironment.estimateTokens;
+  const preserveSystem = options.preserveSystemMessages ?? true;
+  const preserveLastN = options.preserveLastN ?? 0;
+  const currentTokens = estimateConversationTokens(conversation, estimator, resolvedEnvironment);
   if (currentTokens <= maxTokens) {
     return conversation;
   }
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
   const systemMessages = preserveSystem ? conversation.messages.filter((m) => m.role === "system") : [];
   const nonSystemMessages = conversation.messages.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 + estimateTokens(m), 0);
-  const protectedTokens = protectedMessages.reduce((sum, m) => sum + estimateTokens(m), 0);
+  const systemTokens = systemMessages.reduce((sum, m) => sum + estimator(m), 0);
+  const protectedTokens = protectedMessages.reduce((sum, m) => sum + estimator(m), 0);
   const availableTokens = maxTokens - systemTokens - protectedTokens;
   if (availableTokens <= 0) {
     const allMessages2 = [...systemMessages, ...protectedMessages];
     const renumbered2 = allMessages2.map((message, index) => createMessage({
       id: message.id,
       role: message.role,
-      content: typeof message.content === "string" ? message.content : [...message.content],
+      content: copyContent(message.content),
       position: index,
       createdAt: message.createdAt,
       metadata: { ...message.metadata },
@@ -669,7 +665,7 @@ function truncateToTokenLimit(conversation, maxTokens, estimateTokens, options,
   let usedTokens = 0;
   for (let i = removableMessages.length - 1;i >= 0; i--) {
     const message = removableMessages[i];
-    const messageTokens = estimateTokens(message);
+    const messageTokens = estimator(message);
     if (usedTokens + messageTokens <= availableTokens) {
       keptRemovable.unshift(message);
       usedTokens += messageTokens;
@@ -682,7 +678,45 @@ function truncateToTokenLimit(conversation, maxTokens, estimateTokens, options,
   const renumbered = allMessages.map((message, index) => createMessage({
     id: message.id,
     role: message.role,
-    content: typeof message.content === "string" ? message.content : [...message.content],
+    content: copyContent(message.content),
+    position: index,
+    createdAt: message.createdAt,
+    metadata: { ...message.metadata },
+    hidden: message.hidden,
+    toolCall: message.toolCall ? { ...message.toolCall } : undefined,
+    toolResult: message.toolResult ? { ...message.toolResult } : undefined,
+    tokenUsage: message.tokenUsage ? { ...message.tokenUsage } : undefined,
+    goalCompleted: message.goalCompleted
+  }));
+  return toReadonly({
+    ...conversation,
+    messages: renumbered,
+    updatedAt: now
+  });
+}
+function getRecentMessages(conversation, count, options) {
+  const includeHidden = options?.includeHidden ?? false;
+  const includeSystem = options?.includeSystem ?? false;
+  const filtered = conversation.messages.filter((m) => {
+    if (!includeHidden && m.hidden)
+      return false;
+    if (!includeSystem && m.role === "system")
+      return false;
+    return true;
+  });
+  return filtered.slice(-count);
+}
+function truncateFromPosition(conversation, position, options, environment) {
+  const preserveSystem = options?.preserveSystemMessages ?? true;
+  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const now = resolvedEnvironment.now();
+  const systemMessages = preserveSystem ? conversation.messages.filter((m) => m.role === "system" && m.position < position) : [];
+  const keptMessages = conversation.messages.filter((m) => m.position >= position);
+  const allMessages = [...systemMessages, ...keptMessages];
+  const renumbered = allMessages.map((message, index) => createMessage({
+    id: message.id,
+    role: message.role,
+    content: copyContent(message.content),
     position: index,
     createdAt: message.createdAt,
     metadata: { ...message.metadata },
@@ -875,8 +909,8 @@ function createDraft(initial) {
       current = truncateFromPosition(current, position, options);
       return draft;
     },
-    truncateToTokenLimit: (maxTokens, estimateTokens, options) => {
-      current = truncateToTokenLimit(current, maxTokens, estimateTokens, options);
+    truncateToTokenLimit: (maxTokens, options) => {
+      current = truncateToTokenLimit(current, maxTokens, options);
       return draft;
     }
   };
@@ -893,7 +927,291 @@ function withConversation(conversation, fn) {
 function pipeConversation(conversation, ...fns) {
   return fns.reduce((current, fn) => fn(current), conversation);
 }
+// src/history.ts
+class ConversationHistoryEvent extends CustomEvent {
+  constructor(type, detail) {
+    super(type, { detail });
+  }
+}
+
+class ConversationHistory extends EventTarget {
+  currentNode;
+  environment;
+  constructor(initial, environment) {
+    super();
+    this.environment = resolveConversationEnvironment(environment);
+    this.currentNode = {
+      conversation: initial,
+      parent: null,
+      children: []
+    };
+  }
+  notifyChange(type) {
+    const detail = {
+      type,
+      conversation: this.current
+    };
+    this.dispatchEvent(new ConversationHistoryEvent("change", detail));
+    this.dispatchEvent(new ConversationHistoryEvent(type, detail));
+  }
+  addEventListener(type, callback, options) {
+    if (!callback)
+      return;
+    super.addEventListener(type, callback, options);
+    const unsubscribe = () => this.removeEventListener(type, callback, options);
+    return unsubscribe;
+  }
+  subscribe(run) {
+    run(this.current);
+    const handler = (event) => {
+      if (event instanceof ConversationHistoryEvent) {
+        run(event.detail.conversation);
+      }
+    };
+    const unsubscribe = this.addEventListener("change", handler);
+    return unsubscribe || (() => {});
+  }
+  getSnapshot() {
+    return this.current;
+  }
+  get current() {
+    return this.currentNode.conversation;
+  }
+  get canUndo() {
+    return this.currentNode.parent !== null;
+  }
+  get canRedo() {
+    return this.currentNode.children.length > 0;
+  }
+  get env() {
+    return this.environment;
+  }
+  get branchCount() {
+    return this.currentNode.parent ? this.currentNode.parent.children.length : 1;
+  }
+  get branchIndex() {
+    if (!this.currentNode.parent)
+      return 0;
+    return this.currentNode.parent.children.indexOf(this.currentNode);
+  }
+  get redoCount() {
+    return this.currentNode.children.length;
+  }
+  push(next) {
+    const newNode = {
+      conversation: next,
+      parent: this.currentNode,
+      children: []
+    };
+    this.currentNode.children.push(newNode);
+    this.currentNode = newNode;
+    this.notifyChange("push");
+  }
+  undo() {
+    if (this.currentNode.parent) {
+      this.currentNode = this.currentNode.parent;
+      this.notifyChange("undo");
+      return this.current;
+    }
+    return;
+  }
+  redo(childIndex = 0) {
+    const next = this.currentNode.children[childIndex];
+    if (next) {
+      this.currentNode = next;
+      this.notifyChange("redo");
+      return this.current;
+    }
+    return;
+  }
+  switchToBranch(index) {
+    if (this.currentNode.parent) {
+      const target = this.currentNode.parent.children[index];
+      if (target) {
+        this.currentNode = target;
+        this.notifyChange("switch");
+        return this.current;
+      }
+    }
+    return;
+  }
+  getPath() {
+    const path = [];
+    let curr = this.currentNode;
+    while (curr) {
+      path.unshift(curr.conversation);
+      curr = curr.parent;
+    }
+    return path;
+  }
+  getMessages(options) {
+    return getConversationMessages(this.current, options);
+  }
+  getMessageAtPosition(position) {
+    return getMessageAtPosition(this.current, position);
+  }
+  getMessageByIdentifier(id) {
+    return getMessageByIdentifier(this.current, id);
+  }
+  searchMessages(predicate) {
+    return searchConversationMessages(this.current, predicate);
+  }
+  getStatistics() {
+    return computeConversationStatistics(this.current);
+  }
+  hasSystemMessage() {
+    return hasSystemMessage(this.current);
+  }
+  getFirstSystemMessage() {
+    return getFirstSystemMessage(this.current);
+  }
+  getSystemMessages() {
+    return getSystemMessages(this.current);
+  }
+  serialize() {
+    return serializeConversation(this.current);
+  }
+  toChatMessages() {
+    return toChatMessages(this.current);
+  }
+  estimateTokens(estimator) {
+    return estimateConversationTokens(this.current, estimator, this.env);
+  }
+  getRecentMessages(count, options) {
+    return getRecentMessages(this.current, count, options);
+  }
+  getStreamingMessage() {
+    return getStreamingMessage(this.current);
+  }
+  appendMessages(...inputs) {
+    this.push(appendMessages(this.current, ...inputs, this.env));
+  }
+  appendUserMessage(content, metadata) {
+    this.push(appendUserMessage(this.current, content, metadata, this.env));
+  }
+  appendAssistantMessage(content, metadata) {
+    this.push(appendAssistantMessage(this.current, content, metadata, this.env));
+  }
+  appendSystemMessage(content, metadata) {
+    this.push(appendSystemMessage(this.current, content, metadata, this.env));
+  }
+  prependSystemMessage(content, metadata) {
+    this.push(prependSystemMessage(this.current, content, metadata, this.env));
+  }
+  replaceSystemMessage(content, metadata) {
+    this.push(replaceSystemMessage(this.current, content, metadata, this.env));
+  }
+  collapseSystemMessages() {
+    this.push(collapseSystemMessages(this.current, this.env));
+  }
+  redactMessageAtPosition(position, placeholder) {
+    this.push(redactMessageAtPosition(this.current, position, placeholder, this.env));
+  }
+  truncateFromPosition(position, options) {
+    this.push(truncateFromPosition(this.current, position, options, this.env));
+  }
+  truncateToTokenLimit(maxTokens, options) {
+    this.push(truncateToTokenLimit(this.current, maxTokens, options, this.env));
+  }
+  appendStreamingMessage(role, metadata) {
+    const { conversation, messageId } = appendStreamingMessage(this.current, role, metadata, this.env);
+    this.push(conversation);
+    return messageId;
+  }
+  updateStreamingMessage(messageId, content) {
+    this.push(updateStreamingMessage(this.current, messageId, content, this.env));
+  }
+  finalizeStreamingMessage(messageId, options) {
+    this.push(finalizeStreamingMessage(this.current, messageId, options, this.env));
+  }
+  cancelStreamingMessage(messageId) {
+    this.push(cancelStreamingMessage(this.current, messageId, this.env));
+  }
+  toJSON() {
+    const getPath = (node) => {
+      const path = [];
+      let curr = node;
+      while (curr.parent) {
+        path.unshift(curr.parent.children.indexOf(curr));
+        curr = curr.parent;
+      }
+      return path;
+    };
+    const serializeNode = (node) => ({
+      conversation: serializeConversation(node.conversation),
+      children: node.children.map(serializeNode)
+    });
+    let root = this.currentNode;
+    while (root.parent) {
+      root = root.parent;
+    }
+    return {
+      root: serializeNode(root),
+      currentPath: getPath(this.currentNode)
+    };
+  }
+  static from(json, environment) {
+    const rootConv = deserializeConversation(json.root.conversation);
+    const history = new ConversationHistory(rootConv, environment);
+    const buildTree = (nodeJSON, parentNode) => {
+      const nodeConv = deserializeConversation(nodeJSON.conversation);
+      const node = {
+        conversation: nodeConv,
+        parent: parentNode,
+        children: []
+      };
+      node.children = nodeJSON.children.map((child) => buildTree(child, node));
+      return node;
+    };
+    const h = history;
+    const rootNode = h.currentNode;
+    rootNode.children = json.root.children.map((child) => buildTree(child, rootNode));
+    let current = rootNode;
+    for (const index of json.currentPath) {
+      const target = current.children[index];
+      if (target) {
+        current = target;
+      }
+    }
+    h.currentNode = current;
+    return history;
+  }
+  bind(fn) {
+    return bindToConversationHistory(this, fn);
+  }
+  [Symbol.dispose]() {
+    let root = this.currentNode;
+    while (root?.parent) {
+      root = root.parent;
+    }
+    const clearNode = (node) => {
+      for (const child of node.children) {
+        clearNode(child);
+      }
+      node.children = [];
+      const n = node;
+      n.parent = null;
+      n.conversation = null;
+    };
+    if (root)
+      clearNode(root);
+  }
+}
+function bindToConversationHistory(history, fn) {
+  return (...args) => {
+    const boundFn = fn;
+    const result = boundFn(history.current, ...args, history.env);
+    if (isConversation(result)) {
+      history.push(result);
+    }
+    return result;
+  };
+}
+function isConversation(value) {
+  return value !== null && typeof value === "object" && typeof value.id === "string" && typeof value.status === "string" && value.metadata !== null && typeof value.metadata === "object" && Array.isArray(value.tags) && Array.isArray(value.messages) && typeof value.createdAt === "string" && typeof value.updatedAt === "string";
+}
 export {
+  withEnvironment,
   withConversation,
   updateStreamingMessage,
   truncateToTokenLimit,
@@ -945,12 +1263,14 @@ export {
   computeConversationStatistics,
   collapseSystemMessages,
   cancelStreamingMessage,
+  bindToConversationHistory,
   appendUserMessage,
   appendSystemMessage,
   appendStreamingMessage,
   appendMessages,
   appendAssistantMessage,
-  ConversationalistError
+  ConversationalistError,
+  ConversationHistory
 };
 
-//# debugId=A73ACE8C678CC64D64756E2164756E21
+//# debugId=A4607F063A1411CC64756E2164756E21