@lostgradient/cinder 0.9.0 → 0.11.0

package/dist/server/{index.server-yz4k36cw.js → index.server-z7hxtqs1.js}

@@ -1,6 +1,6 @@
 import {
   conversationSummaryTimestamp
-} from "./index.server-mzzb7dnm.js";
+} from "./index.server-2bbwajb2.js";
 import {
   classNames
 } from "./index.server-z7nvkz8v.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lostgradient/cinder",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "A Svelte 5 component library and design system focused on accessibility, theming, and per-component tree-shaking.",
   "keywords": [
     "svelte",
@@ -1563,6 +1563,38 @@
       "import": "./src/components/confirm-dialog/confirm-dialog.examples.json",
       "default": "./src/components/confirm-dialog/confirm-dialog.examples.json"
     },
+    "./connection-indicator": {
+      "types": "./dist/components/connection-indicator/index.d.ts",
+      "browser": "./src/components/connection-indicator/index.ts",
+      "node": "./dist/server/components/connection-indicator/index.js",
+      "svelte": "./src/components/connection-indicator/index.ts",
+      "import": "./src/components/connection-indicator/index.ts",
+      "default": "./dist/components/connection-indicator/index.js"
+    },
+    "./connection-indicator/schema": {
+      "types": "./dist/components/connection-indicator/connection-indicator.schema.d.ts",
+      "browser": "./src/components/connection-indicator/connection-indicator.schema.ts",
+      "node": "./dist/components/connection-indicator/connection-indicator.schema.js",
+      "svelte": "./src/components/connection-indicator/connection-indicator.schema.ts",
+      "import": "./src/components/connection-indicator/connection-indicator.schema.ts",
+      "default": "./dist/components/connection-indicator/connection-indicator.schema.js"
+    },
+    "./connection-indicator/variables": {
+      "types": "./dist/components/connection-indicator/connection-indicator.variables.d.ts",
+      "browser": "./src/components/connection-indicator/connection-indicator.variables.ts",
+      "node": "./dist/components/connection-indicator/connection-indicator.variables.js",
+      "svelte": "./src/components/connection-indicator/connection-indicator.variables.ts",
+      "import": "./src/components/connection-indicator/connection-indicator.variables.ts",
+      "default": "./dist/components/connection-indicator/connection-indicator.variables.js"
+    },
+    "./connection-indicator/styles": {
+      "types": "./dist/components/connection-indicator/connection-indicator.css.d.ts",
+      "default": "./dist/components/connection-indicator/connection-indicator.css"
+    },
+    "./connection-indicator/examples": {
+      "import": "./src/components/connection-indicator/connection-indicator.examples.json",
+      "default": "./src/components/connection-indicator/connection-indicator.examples.json"
+    },
     "./container": {
       "types": "./dist/components/container/index.d.ts",
       "browser": "./src/components/container/index.ts",
@@ -4275,6 +4307,38 @@
       "import": "./src/components/run-step-timeline/run-step-timeline.examples.json",
       "default": "./src/components/run-step-timeline/run-step-timeline.examples.json"
     },
+    "./schedule-builder": {
+      "types": "./dist/components/schedule-builder/index.d.ts",
+      "browser": "./src/components/schedule-builder/index.ts",
+      "node": "./dist/server/components/schedule-builder/index.js",
+      "svelte": "./src/components/schedule-builder/index.ts",
+      "import": "./src/components/schedule-builder/index.ts",
+      "default": "./dist/components/schedule-builder/index.js"
+    },
+    "./schedule-builder/schema": {
+      "types": "./dist/components/schedule-builder/schedule-builder.schema.d.ts",
+      "browser": "./src/components/schedule-builder/schedule-builder.schema.ts",
+      "node": "./dist/components/schedule-builder/schedule-builder.schema.js",
+      "svelte": "./src/components/schedule-builder/schedule-builder.schema.ts",
+      "import": "./src/components/schedule-builder/schedule-builder.schema.ts",
+      "default": "./dist/components/schedule-builder/schedule-builder.schema.js"
+    },
+    "./schedule-builder/variables": {
+      "types": "./dist/components/schedule-builder/schedule-builder.variables.d.ts",
+      "browser": "./src/components/schedule-builder/schedule-builder.variables.ts",
+      "node": "./dist/components/schedule-builder/schedule-builder.variables.js",
+      "svelte": "./src/components/schedule-builder/schedule-builder.variables.ts",
+      "import": "./src/components/schedule-builder/schedule-builder.variables.ts",
+      "default": "./dist/components/schedule-builder/schedule-builder.variables.js"
+    },
+    "./schedule-builder/styles": {
+      "types": "./dist/components/schedule-builder/schedule-builder.css.d.ts",
+      "default": "./dist/components/schedule-builder/schedule-builder.css"
+    },
+    "./schedule-builder/examples": {
+      "import": "./src/components/schedule-builder/schedule-builder.examples.json",
+      "default": "./src/components/schedule-builder/schedule-builder.examples.json"
+    },
     "./schema-form": {
       "types": "./dist/components/schema-form/index.d.ts",
       "browser": "./src/components/schema-form/index.ts",
@@ -6446,6 +6510,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@tanstack/virtual-core": "^3.17.1",
     "ajv": "^8",
+    "conversationalist": "^0.2.1",
     "diff-match-patch": "^1.0.5",
     "esm-env": "^1.2.0",
     "libphonenumber-js": "^1.13.3",
@@ -6461,7 +6526,6 @@
     "@types/qrcode": "^1.5.6",
     "chalk": "^5.6.2",
     "change-case": "^5.4.4",
-    "conversationalist": "^0.2.1",
     "happy-dom": "^15.11.7",
     "js-yaml": "^4.1.0",
     "lucide-svelte": "^0.503.0",
@@ -6492,7 +6556,6 @@
     "@types/mdast": "^4.0.4",
     "@types/unist": "^3.0.0",
     "comlink": "^4.4.2",
-    "conversationalist": "^0.2.1",
     "hast-util-sanitize": "^5.0.0",
     "js-yaml": "^4.1.0",
     "lucide-svelte": ">=0.400.0 <1",

package/src/components/chat/builders.ts

@@ -1,33 +1,464 @@
 /**
  * Conversation builders for the Chat component.
  *
- * Chat renders a {@link ConversationHistory} snapshot. These are thin aliases
- * over the published `conversationalist` builders so examples, demos, tests, and
- * simple apps construct the same transcript shape Chat consumes.
+ * Chat renders a {@link ConversationHistory} snapshot. These helpers construct
+ * the published Conversationalist shape without importing the package runtime
+ * into Cinder's browser graph.
  */
 
-import {
-  appendAssistantMessage as appendConversationalistAssistantMessage,
-  appendMessages as appendConversationalistMessages,
-  appendUserMessage as appendConversationalistUserMessage,
-  createConversationHistory,
-} from 'conversationalist';
+import type {
+  ConversationEnvironment,
+  ConversationHistory,
+  ConversationStatus,
+  JSONValue,
+  Message,
+  MessageInput,
+  MultiModalContent,
+  TokenUsage,
+  ToolCall,
+  ToolResult,
+} from './conversation-model.ts';
 
-import type { ConversationHistory, MessageInput } from './conversation-model.ts';
+type CreateConversationOptions = {
+  id?: string;
+  title?: string;
+  status?: ConversationStatus;
+  metadata?: Record<string, JSONValue>;
+};
+
+type ConversationEnvironmentInput = Partial<ConversationEnvironment>;
+type MessageContentInput = MessageInput['content'] | MultiModalContent;
+type LooseMessageInput = Omit<MessageInput, 'content'> & { content: MessageContentInput };
+
+const MESSAGE_ROLES = new Set([
+  'user',
+  'assistant',
+  'system',
+  'developer',
+  'tool-call',
+  'tool-result',
+  'snapshot',
+]);
+const CONVERSATION_STATUSES = new Set<ConversationStatus>(['active', 'archived', 'deleted']);
+
+function createId(): string {
+  return globalThis.crypto?.randomUUID?.() ?? `message-${Date.now()}-${Math.random()}`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function isJsonObject(value: unknown): value is Record<string, JSONValue> {
+  if (!isRecord(value) || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function isJsonValue(value: unknown): value is JSONValue {
+  if (value === null) return true;
+  switch (typeof value) {
+    case 'string':
+    case 'boolean':
+      return true;
+    case 'number':
+      return Number.isFinite(value);
+    case 'object':
+      if (Array.isArray(value)) return value.every(isJsonValue);
+      return isJsonObject(value) && Object.values(value).every(isJsonValue);
+    default:
+      return false;
+  }
+}
+
+function assertJsonObject(
+  value: unknown,
+  label: string,
+): asserts value is Record<string, JSONValue> {
+  if (!isJsonObject(value) || !Object.values(value).every(isJsonValue)) {
+    throw new Error(`${label} must be a JSON-compatible object`);
+  }
+}
+
+function isConversationEnvironmentParameter(value: unknown): value is ConversationEnvironmentInput {
+  if (!isRecord(value) || 'role' in value) return false;
+  return (
+    typeof value['now'] === 'function' ||
+    typeof value['randomId'] === 'function' ||
+    typeof value['estimateTokens'] === 'function' ||
+    (Array.isArray(value['plugins']) &&
+      value['plugins'].every((plugin) => typeof plugin === 'function'))
+  );
+}
+
+function isRoleHelperEnvironmentParameter(value: unknown): value is ConversationEnvironmentInput {
+  if (!isRecord(value) || 'role' in value) return false;
+  return (
+    typeof value['now'] === 'function' ||
+    typeof value['randomId'] === 'function' ||
+    typeof value['estimateTokens'] === 'function' ||
+    (Array.isArray(value['plugins']) &&
+      value['plugins'].length > 0 &&
+      value['plugins'].every((plugin) => typeof plugin === 'function'))
+  );
+}
+
+function isMultiModalContentPart(value: unknown): value is MultiModalContent {
+  if (!isJsonObject(value) || typeof value['type'] !== 'string') return false;
+  if (!Object.values(value).every(isJsonValue)) return false;
+  switch (value['type']) {
+    case 'text':
+      return typeof value['text'] === 'string';
+    case 'image':
+      return typeof value['url'] === 'string';
+    case 'thinking':
+      return typeof value['thinking'] === 'string';
+    case 'redacted_thinking':
+      return typeof value['data'] === 'string';
+    case 'server_tool_use':
+      return typeof value['id'] === 'string' && typeof value['name'] === 'string';
+    case 'web_search_tool_result':
+      return typeof value['tool_use_id'] === 'string' && 'content' in value;
+    case 'container_upload':
+      return typeof value['file_id'] === 'string';
+    default:
+      return false;
+  }
+}
+
+function isMessageContentInput(value: unknown): value is MessageContentInput {
+  return (
+    typeof value === 'string' ||
+    (Array.isArray(value) && value.every(isMultiModalContentPart)) ||
+    isMultiModalContentPart(value)
+  );
+}
+
+function isLooseMessageInput(value: unknown): value is LooseMessageInput {
+  return (
+    isRecord(value) &&
+    typeof value['role'] === 'string' &&
+    MESSAGE_ROLES.has(value['role']) &&
+    isMessageContentInput(value['content']) &&
+    (value['hidden'] === undefined || typeof value['hidden'] === 'boolean') &&
+    (value['goalCompleted'] === undefined || typeof value['goalCompleted'] === 'boolean')
+  );
+}
+
+function isMetadataRecord(value: unknown): value is Record<string, JSONValue> {
+  return isJsonObject(value);
+}
+
+function resolveEnvironment(environment?: ConversationEnvironmentInput): {
+  now: () => string;
+  randomId: () => string;
+  plugins: NonNullable<ConversationEnvironmentInput['plugins']>;
+} {
+  const plugins = environment?.plugins ?? [];
+  if (!Array.isArray(plugins) || plugins.some((plugin) => typeof plugin !== 'function')) {
+    throw new Error('conversation environment plugins must be functions');
+  }
+  return {
+    now: environment?.now ?? (() => new Date().toISOString()),
+    randomId: environment?.randomId ?? createId,
+    plugins: [...plugins],
+  };
+}
+
+function cloneStructuredValue<T>(value: T): T {
+  return structuredClone(value);
+}
+
+function cloneMetadata(metadata: Record<string, JSONValue> | undefined): Record<string, JSONValue> {
+  if (metadata === undefined) return {};
+  assertJsonObject(metadata, 'metadata');
+  return cloneStructuredValue(metadata);
+}
+
+function normalizeContent(content: MessageContentInput): MessageInput['content'] {
+  if (typeof content === 'string') return content;
+  return Array.isArray(content) ? cloneStructuredValue(content) : [cloneStructuredValue(content)];
+}
+
+function cloneTokenUsage(tokenUsage: TokenUsage): TokenUsage {
+  assertJsonObject(tokenUsage, 'tokenUsage');
+  const values = Object.values(tokenUsage);
+  if (values.some((value) => typeof value !== 'number')) {
+    throw new Error('tokenUsage values must be numbers');
+  }
+  if (
+    values.some((value) => typeof value === 'number' && (!Number.isInteger(value) || value < 0))
+  ) {
+    throw new Error('tokenUsage values must be non-negative integers');
+  }
+  return cloneStructuredValue(tokenUsage);
+}
+
+function cloneToolCall(toolCall: ToolCall): ToolCall {
+  assertJsonObject(toolCall, 'toolCall');
+  if (
+    typeof toolCall.id !== 'string' ||
+    typeof toolCall.name !== 'string' ||
+    !('arguments' in toolCall) ||
+    !isJsonValue(toolCall.arguments)
+  ) {
+    throw new Error('toolCall must include string id, string name, and JSON arguments');
+  }
+  return cloneStructuredValue(toolCall);
+}
+
+function cloneToolResult(toolResult: ToolResult): ToolResult {
+  assertJsonObject(toolResult, 'toolResult');
+  if (
+    typeof toolResult.callId !== 'string' ||
+    !['success', 'error', 'action_required'].includes(String(toolResult.outcome)) ||
+    !('content' in toolResult) ||
+    !isJsonValue(toolResult.content)
+  ) {
+    throw new Error('toolResult must include string callId, valid outcome, and JSON content');
+  }
+  return cloneStructuredValue(toolResult);
+}
+
+function getOrderedMessages(conversation: ConversationHistory): Message[] {
+  return conversation.ids
+    .map((id) => conversation.messages[id])
+    .filter((message): message is Message => message !== undefined);
+}
+
+function buildToolCallIds(messages: ReadonlyArray<Message>): Set<string> {
+  const toolCallIds = new Set<string>();
+  for (const message of messages) {
+    if (message.role === 'tool-call' && message.toolCall !== undefined) {
+      if (toolCallIds.has(message.toolCall.id)) {
+        throw new Error(`duplicate toolCall.id in conversation: ${message.toolCall.id}`);
+      }
+      toolCallIds.add(message.toolCall.id);
+    }
+  }
+  return toolCallIds;
+}
+
+function assertValidToolMessage(input: LooseMessageInput, toolCallIds: Set<string>): void {
+  if (input.role === 'tool-result' && input.toolResult !== undefined) {
+    if (!toolCallIds.has(input.toolResult.callId)) {
+      throw new Error(`tool result references non-existent tool-call: ${input.toolResult.callId}`);
+    }
+  }
+  if (input.role === 'tool-call' && input.toolCall !== undefined) {
+    if (toolCallIds.has(input.toolCall.id)) {
+      throw new Error(`duplicate toolCall.id in conversation: ${input.toolCall.id}`);
+    }
+    toolCallIds.add(input.toolCall.id);
+  }
+}
 
 /** Creates a new empty conversation snapshot. */
-const createConversation = createConversationHistory;
+function createConversation(
+  options: CreateConversationOptions = {},
+  environment?: ConversationEnvironmentInput,
+): ConversationHistory {
+  const resolvedEnvironment = resolveEnvironment(environment);
+  const createdAt = resolvedEnvironment.now();
+  const conversationId = options.id ?? resolvedEnvironment.randomId();
+  if (typeof conversationId !== 'string') {
+    throw new Error('conversation id must be a string');
+  }
+  if (typeof createdAt !== 'string') {
+    throw new Error('conversation timestamp must be a string');
+  }
+  if (options.title !== undefined && typeof options.title !== 'string') {
+    throw new Error('conversation title must be a string');
+  }
+  if (options.status !== undefined && !CONVERSATION_STATUSES.has(options.status)) {
+    throw new Error('conversation status must be active, archived, or deleted');
+  }
+  return {
+    schemaVersion: 4,
+    id: conversationId,
+    ...(options.title !== undefined ? { title: options.title } : {}),
+    status: options.status ?? 'active',
+    metadata: cloneMetadata(options.metadata),
+    ids: [],
+    messages: {},
+    createdAt,
+    updatedAt: createdAt,
+  };
+}
+
+function materializeMessage(
+  input: LooseMessageInput,
+  position: number,
+  createdAt: string,
+  id: string,
+): Message {
+  return {
+    id,
+    role: input.role,
+    content: normalizeContent(input.content),
+    position,
+    createdAt,
+    metadata: cloneMetadata(input.metadata),
+    hidden: input.hidden ?? false,
+    ...(input.toolCall !== undefined ? { toolCall: cloneToolCall(input.toolCall) } : {}),
+    ...(input.toolResult !== undefined ? { toolResult: cloneToolResult(input.toolResult) } : {}),
+    ...(input.tokenUsage !== undefined ? { tokenUsage: cloneTokenUsage(input.tokenUsage) } : {}),
+    ...(input.role === 'assistant' && input.goalCompleted !== undefined
+      ? { goalCompleted: input.goalCompleted }
+      : {}),
+  };
+}
+
+function partitionAppendArguments(args: unknown[]): {
+  inputs: LooseMessageInput[];
+  environment?: ConversationEnvironmentInput;
+} {
+  const filteredArguments = args.at(-1) === undefined ? args.slice(0, -1) : args;
+  if (filteredArguments.some((argument) => argument === undefined)) {
+    throw new Error(
+      'appendMessages expected MessageInput arguments before the optional environment',
+    );
+  }
+  const lastArgument = filteredArguments.at(-1);
+  const inputArguments = isConversationEnvironmentParameter(lastArgument)
+    ? filteredArguments.slice(0, -1)
+    : filteredArguments;
+  const inputs: LooseMessageInput[] = [];
+  for (const argument of inputArguments) {
+    if (!isLooseMessageInput(argument)) {
+      throw new Error(
+        'appendMessages expected MessageInput arguments before the optional environment',
+      );
+    }
+    inputs.push(argument);
+  }
+  if (isConversationEnvironmentParameter(lastArgument)) {
+    return { inputs, environment: lastArgument };
+  }
+  return { inputs };
+}
 
 /** Appends one or more messages, preserving the previous no-op identity contract. */
 function appendMessages(
   conversation: ConversationHistory,
   ...inputs: MessageInput[]
+): ConversationHistory;
+function appendMessages(
+  conversation: ConversationHistory,
+  ...inputsAndEnvironment: [...MessageInput[], ConversationEnvironmentInput | undefined]
+): ConversationHistory;
+function appendMessages(
+  conversation: ConversationHistory,
+  ...args: unknown[]
 ): ConversationHistory {
+  const { inputs, environment } = partitionAppendArguments(args);
   if (inputs.length === 0) return conversation;
-  return appendConversationalistMessages(conversation, ...inputs);
+  const resolvedEnvironment = resolveEnvironment(environment);
+  const updatedAt = resolvedEnvironment.now();
+  if (typeof updatedAt !== 'string') {
+    throw new Error('conversation timestamp must be a string');
+  }
+  const nextIds = [...conversation.ids];
+  const nextMessages = { ...conversation.messages };
+  const toolCallIds = buildToolCallIds(getOrderedMessages(conversation));
+
+  inputs.forEach((input, index) => {
+    const normalizedInput: MessageInput = { ...input, content: normalizeContent(input.content) };
+    const processedInput = resolvedEnvironment.plugins.reduce(
+      (current, plugin) => plugin(current),
+      normalizedInput,
+    );
+    if (!isLooseMessageInput(processedInput)) {
+      throw new Error('conversation plugin returned an invalid MessageInput');
+    }
+    assertValidToolMessage(processedInput, toolCallIds);
+    const messageId = resolvedEnvironment.randomId();
+    if (typeof messageId !== 'string') {
+      throw new Error('generated message id must be a string');
+    }
+    if (nextMessages[messageId] !== undefined || nextIds.includes(messageId)) {
+      throw new Error(`duplicate message id in conversation: ${messageId}`);
+    }
+    const message = materializeMessage(
+      processedInput,
+      conversation.ids.length + index,
+      updatedAt,
+      messageId,
+    );
+    nextIds.push(message.id);
+    nextMessages[message.id] = message;
+  });
+
+  return {
+    ...conversation,
+    ids: nextIds,
+    messages: nextMessages,
+    updatedAt,
+  };
 }
 
-const appendUserMessage = appendConversationalistUserMessage;
-const appendAssistantMessage = appendConversationalistAssistantMessage;
+function appendUserMessage(
+  conversation: ConversationHistory,
+  content: MessageInput['content'],
+  metadata?: Record<string, JSONValue>,
+  environment?: ConversationEnvironmentInput,
+): ConversationHistory;
+function appendUserMessage(
+  conversation: ConversationHistory,
+  content: MessageInput['content'],
+  environment?: ConversationEnvironmentInput,
+): ConversationHistory;
+function appendUserMessage(
+  conversation: ConversationHistory,
+  content: MessageInput['content'],
+  metadataOrEnvironment?: Record<string, JSONValue> | ConversationEnvironmentInput,
+  environment?: ConversationEnvironmentInput,
+): ConversationHistory {
+  const metadata = resolveRoleHelperMetadata(metadataOrEnvironment, environment);
+  const resolvedEnvironment =
+    environment ??
+    (isRoleHelperEnvironmentParameter(metadataOrEnvironment) ? metadataOrEnvironment : undefined);
+  return appendMessages(conversation, { role: 'user', content, metadata }, resolvedEnvironment);
+}
+
+function appendAssistantMessage(
+  conversation: ConversationHistory,
+  content: MessageInput['content'],
+  metadata?: Record<string, JSONValue>,
+  environment?: ConversationEnvironmentInput,
+): ConversationHistory;
+function appendAssistantMessage(
+  conversation: ConversationHistory,
+  content: MessageInput['content'],
+  environment?: ConversationEnvironmentInput,
+): ConversationHistory;
+function appendAssistantMessage(
+  conversation: ConversationHistory,
+  content: MessageInput['content'],
+  metadataOrEnvironment?: Record<string, JSONValue> | ConversationEnvironmentInput,
+  environment?: ConversationEnvironmentInput,
+): ConversationHistory {
+  const metadata = resolveRoleHelperMetadata(metadataOrEnvironment, environment);
+  const resolvedEnvironment =
+    environment ??
+    (isRoleHelperEnvironmentParameter(metadataOrEnvironment) ? metadataOrEnvironment : undefined);
+  return appendMessages(
+    conversation,
+    { role: 'assistant', content, metadata },
+    resolvedEnvironment,
+  );
+}
+
+function resolveRoleHelperMetadata(
+  metadataOrEnvironment: Record<string, JSONValue> | ConversationEnvironmentInput | undefined,
+  environment: ConversationEnvironmentInput | undefined,
+): Record<string, JSONValue> | undefined {
+  if (metadataOrEnvironment === undefined) return undefined;
+  if (environment === undefined && isRoleHelperEnvironmentParameter(metadataOrEnvironment)) {
+    return undefined;
+  }
+  if (isMetadataRecord(metadataOrEnvironment)) return metadataOrEnvironment;
+  throw new Error('metadata must be a JSON-compatible object');
+}
 
 export { appendAssistantMessage, appendMessages, appendUserMessage, createConversation };

package/src/components/chat/conversation-model.ts

@@ -13,6 +13,7 @@ import type { ToMarkdownOptions as ConversationalistToMarkdownOptions } from 'co
 export type {
   AssistantMessage,
   ContainerUploadContent,
+  ConversationEnvironment,
   ConversationHistory,
   ConversationStatus,
   ImageContent,

package/src/components/chat/index.ts

@@ -46,6 +46,7 @@ export {
 export type {
   AssistantMessage,
   ContainerUploadContent,
+  ConversationEnvironment,
   ConversationHistory,
   ConversationStatus,
   ExportOptions,

package/src/components/chat/utilities/conversation.ts

@@ -1,26 +1,44 @@
 /**
  * Conversation-reading helpers for Chat.
  *
- * These delegate to `conversationalist` so message ordering stays aligned with
- * the published conversation package. Tool pairing keeps Chat's role gate so an
- * incidental tool-shaped field on a non-tool message never renders as a pair.
+ * These helpers operate on the Conversationalist transcript shape while keeping
+ * Cinder's browser runtime free of the full conversation package.
  */
 
-import { getMessages } from 'conversationalist';
-import { pairToolCallsWithResults as pairConversationalistToolCallsWithResults } from 'conversationalist/utilities';
+import type {
+  ConversationHistory,
+  Message,
+  ToolCallPair,
+  ToolResult,
+} from '../conversation-model.ts';
 
-import type { Message, ToolCallPair } from '../conversation-model.ts';
-
-function hasPairableToolField(message: Message): boolean {
-  return (
-    (message.role === 'tool-call' && message.toolCall !== undefined) ||
-    (message.role === 'tool-result' && message.toolResult !== undefined)
-  );
+export function getMessages(
+  conversation: ConversationHistory,
+  options: { includeHidden?: boolean } = {},
+): Message[] {
+  return conversation.ids
+    .map((id) => conversation.messages[id])
+    .filter((message): message is Message => message !== undefined)
+    .filter((message) => options.includeHidden === true || !message.hidden);
 }
 
 /** Pairs tool calls with role-valid tool results from an already-ordered message array. */
 export function pairToolCallsWithResults(messages: ReadonlyArray<Message>): ToolCallPair[] {
-  return pairConversationalistToolCallsWithResults(messages.filter(hasPairableToolField));
-}
+  const resultsByCallId = new Map<string, ToolResult>();
+  for (const message of messages) {
+    if (message.role === 'tool-result' && message.toolResult !== undefined) {
+      resultsByCallId.set(message.toolResult.callId, message.toolResult);
+    }
+  }
 
-export { getMessages };
+  const pairs: ToolCallPair[] = [];
+  for (const message of messages) {
+    if (message.role === 'tool-call' && message.toolCall !== undefined) {
+      pairs.push({
+        call: message.toolCall,
+        result: resultsByCallId.get(message.toolCall.id),
+      });
+    }
+  }
+  return pairs;
+}