@capekai/core 1.0.0

package/src/storage/contracts.ts

@@ -0,0 +1,159 @@
+import type { AutoApproveSeverity, Message, MessageWithParts, Part, QueuedMessage, ResponseFormat, Session, ToolPart, Workspace } from '@capekai/types';
+import type { AttachmentKind } from '@capekai/types';
+
+export interface StreamingPartSnapshot {
+  id: string;
+  messageId: string;
+  sessionId: string;
+  type: 'text' | 'reasoning';
+  createdAt: number;
+  text: string;
+}
+
+export interface AttachmentRecord {
+  id: string;
+  sessionId: string;
+  workspaceId: string;
+  kind: AttachmentKind;
+  filename: string;
+  mimeType: string;
+  sizeBytes: number;
+  absolutePath: string;
+  createdAt: string;
+  accessKey: string;
+}
+
+export interface EffectiveContextHistory {
+  messages: MessageWithParts[];
+  latestCompactionBoundary: string | null;
+  hasCompaction: boolean;
+}
+
+export interface TranscriptPageResult {
+  messages: MessageWithParts[];
+  pagination: {
+    hasOlder: boolean;
+    oldestSequence: number | null;
+    newestSequence: number | null;
+    limit: number;
+  };
+}
+
+export type SessionUpdates = Partial<Pick<Session,
+  | 'title'
+  | 'status'
+  | 'metadata'
+  | 'preconfigId'
+  | 'selectedModel'
+  | 'selectedProvider'
+  | 'selectedVariant'
+  | 'promptTokens'
+  | 'completionTokens'
+  | 'totalTokens'
+  | 'cacheReadTokens'
+  | 'cacheWriteTokens'
+  | 'noCacheTokens'
+  | 'parentId'
+  | 'agentName'
+  | 'subagentStatus'
+  | 'runningAt'
+  | 'compacting'
+  | 'tags'
+  | 'autoApproveSeverity'
+  | 'agentId'
+>>;
+
+export interface ConversationStore {
+  createSession(session: Omit<Session, 'createdAt' | 'updatedAt'> & { createdAt?: string; updatedAt?: string }): Promise<Session>;
+  getSession(id: string): Promise<Session | null>;
+  updateSession(id: string, updates: SessionUpdates): Promise<Session | null>;
+  getChildSessions(parentId: string): Promise<Session[]>;
+  createMessage(message: Message): Promise<Message>;
+  getMessage(id: string): Promise<Message | null>;
+  getMessageWithParts(messageId: string): Promise<MessageWithParts | null>;
+  updateMessage(id: string, updates: Partial<Message>): Promise<Message | null>;
+  deleteMessage(messageId: string): Promise<boolean>;
+  listMessagesWithParts(sessionId: string): Promise<MessageWithParts[]>;
+  listLatestMessagesWithPartsPage(sessionId: string, limit?: number): Promise<TranscriptPageResult>;
+  buildEffectiveContextHistory(sessionId: string): Promise<EffectiveContextHistory>;
+  createPart(part: Part, sessionId: string): Promise<Part>;
+  getPart(id: string): Promise<Part | null>;
+  getPartsByMessage(messageId: string): Promise<Part[]>;
+  getPartsBySession(sessionId: string): Promise<Part[]>;
+  updatePart(id: string, updates: Record<string, unknown>): Promise<Part | null>;
+  persistStreamingPartSnapshots(snapshots: StreamingPartSnapshot[]): Promise<number>;
+  transitionToolToRunningByCallId(sessionId: string, callId: string, childSessionId?: string): Promise<ToolPart | null>;
+  transitionToolToInterrupted(partId: string, reason: 'user_request' | 'timeout' | 'error' | 'cascade'): Promise<ToolPart | null>;
+}
+
+export type ToolOutputArtifactFormat = 'json' | 'text';
+
+export interface ToolOutputArtifact {
+  id: string;
+  sessionId: string;
+  workspaceId?: string;
+  toolCallId: string;
+  toolName: string;
+  content: string;
+  format: ToolOutputArtifactFormat;
+  size: number;
+  createdAt: number;
+}
+
+export type CreateToolOutputArtifact = Omit<ToolOutputArtifact, 'id' | 'size' | 'createdAt'>;
+
+export interface ToolOutputArtifactPage {
+  artifactId: string;
+  toolCallId: string;
+  toolName: string;
+  format: ToolOutputArtifactFormat;
+  content: string;
+  offset: number;
+  limit: number;
+  totalChars: number;
+  nextOffset: number | null;
+  complete: boolean;
+}
+
+export interface ToolOutputArtifactStore {
+  create(input: CreateToolOutputArtifact): Promise<ToolOutputArtifact>;
+  getPage(sessionId: string, artifactId: string, offset?: number, limit?: number): Promise<ToolOutputArtifactPage | null>;
+}
+
+export interface MessageQueueStore {
+  addMessage(sessionId: string, content: string, attachments?: Array<{ id: string; kind: string }>): Promise<QueuedMessage>;
+  peek(sessionId: string): Promise<QueuedMessage | null>;
+  delete(id: string): Promise<boolean>;
+}
+
+export interface AttachmentStore {
+  get(sessionId: string, attachmentId: string): Promise<AttachmentRecord | null>;
+}
+
+export interface WorkspaceStore {
+  get(id: string): Promise<Workspace | null>;
+  getAutoApproveSeverity(workspaceId: string): Promise<AutoApproveSeverity>;
+}
+
+export interface ResponseFormatStore {
+  get(id: string): Promise<ResponseFormat | null>;
+}
+
+export interface ConversationIndex {
+  syncMessage(messageId: string): Promise<void>;
+  removeMessage?(messageId: string): Promise<void>;
+}
+
+export interface StorageBundle {
+  conversation: ConversationStore;
+  toolOutputArtifacts: ToolOutputArtifactStore;
+  queue: MessageQueueStore;
+  attachments: AttachmentStore;
+  workspaces: WorkspaceStore;
+  responseFormats: ResponseFormatStore;
+  index: ConversationIndex;
+}
+
+export interface ClosableStore {
+  close(): void;
+}

package/src/storage/memory.ts

@@ -0,0 +1,321 @@
+import type { Message, MessageWithParts, Part, QueuedMessage, ResponseFormat, Session, ToolPart, Workspace } from '@capekai/types';
+import { createInMemoryToolOutputArtifactStore } from './tool-output-artifacts';
+import type {
+  AttachmentRecord,
+  AttachmentStore,
+  ConversationIndex,
+  ConversationStore,
+  MessageQueueStore,
+  ResponseFormatStore,
+  SessionUpdates,
+  StorageBundle,
+  StreamingPartSnapshot,
+  TranscriptPageResult,
+  WorkspaceStore,
+} from './contracts';
+
+interface StoredMessage {
+  message: Message;
+  sequence: number;
+}
+
+interface StoredPart {
+  part: Part;
+  sessionId: string;
+  insertionOrder: number;
+}
+
+function copy<T>(value: T): T {
+  return structuredClone(value);
+}
+
+function compareParts(left: Part, right: Part): number {
+  return left.createdAt - right.createdAt;
+}
+
+export function createInMemoryConversationStore(): ConversationStore {
+  const sessions = new Map<string, Session>();
+  const messages = new Map<string, StoredMessage>();
+  const parts = new Map<string, StoredPart>();
+  const nextSequence = new Map<string, number>();
+  let nextPartInsertionOrder = 0;
+
+  const getPartsByMessage = (messageId: string): Part[] => [...parts.values()]
+    .filter(record => record.part.messageId === messageId)
+    .map(record => copy(record.part))
+    .sort(compareParts);
+
+  const orderedMessages = (sessionId: string): StoredMessage[] => [...messages.values()]
+    .filter(record => record.message.sessionId === sessionId)
+    .sort((left, right) => left.sequence - right.sequence);
+
+  const listMessagesWithParts = (sessionId: string): MessageWithParts[] => orderedMessages(sessionId)
+    .map(record => ({
+      message: copy(record.message),
+      parts: getPartsByMessage(record.message.id),
+    }));
+
+  const store: ConversationStore = {
+    async createSession(input) {
+      const now = new Date().toISOString();
+      const session = copy({
+        ...input,
+        tags: input.tags ?? [],
+        createdAt: input.createdAt || now,
+        updatedAt: input.updatedAt || now,
+      }) as Session;
+      if (sessions.has(session.id)) throw new Error(`Session already exists: ${session.id}`);
+      sessions.set(session.id, session);
+      return copy(session);
+    },
+    async getSession(id) {
+      const session = sessions.get(id);
+      return session ? copy(session) : null;
+    },
+    async updateSession(id, updates: SessionUpdates) {
+      const current = sessions.get(id);
+      if (!current) return null;
+      const updated = copy({ ...current, ...updates, updatedAt: new Date().toISOString() }) as Session;
+      sessions.set(id, updated);
+      return copy(updated);
+    },
+    async getChildSessions(parentId) {
+      return [...sessions.values()]
+        .filter(session => session.parentId === parentId)
+        .sort((left, right) => left.createdAt.localeCompare(right.createdAt))
+        .map(copy);
+    },
+    async createMessage(message) {
+      if (!sessions.has(message.sessionId)) throw new Error(`Session does not exist: ${message.sessionId}`);
+      if (messages.has(message.id)) throw new Error(`Message already exists: ${message.id}`);
+      const sequence = nextSequence.get(message.sessionId) ?? 1;
+      nextSequence.set(message.sessionId, sequence + 1);
+      messages.set(message.id, { message: copy(message), sequence });
+      return copy(message);
+    },
+    async getMessage(id) {
+      const record = messages.get(id);
+      return record ? copy(record.message) : null;
+    },
+    async getMessageWithParts(messageId) {
+      const record = messages.get(messageId);
+      return record ? { message: copy(record.message), parts: getPartsByMessage(messageId) } : null;
+    },
+    async updateMessage(id, updates) {
+      const current = messages.get(id);
+      if (!current) return null;
+      current.message = copy({ ...current.message, ...updates }) as Message;
+      return copy(current.message);
+    },
+    async deleteMessage(messageId) {
+      if (!messages.delete(messageId)) return false;
+      for (const [id, record] of parts) {
+        if (record.part.messageId === messageId) parts.delete(id);
+      }
+      return true;
+    },
+    async listMessagesWithParts(sessionId) { return listMessagesWithParts(sessionId); },
+    async listLatestMessagesWithPartsPage(sessionId, limit = 50): Promise<TranscriptPageResult> {
+      const effectiveLimit = Math.min(Math.max(limit, 1), 100);
+      const ordered = orderedMessages(sessionId);
+      const selected = ordered.slice(-effectiveLimit);
+      return {
+        messages: selected.map(record => ({
+          message: copy(record.message),
+          parts: getPartsByMessage(record.message.id),
+        })),
+        pagination: {
+          hasOlder: ordered.length > selected.length,
+          oldestSequence: selected[0]?.sequence ?? null,
+          newestSequence: selected.at(-1)?.sequence ?? null,
+          limit: effectiveLimit,
+        },
+      };
+    },
+    async buildEffectiveContextHistory(sessionId) {
+      const ordered = orderedMessages(sessionId);
+      let boundary: StoredMessage | undefined;
+      for (let index = ordered.length - 1; index >= 0; index -= 1) {
+        const candidate = ordered[index];
+        const message = candidate.message;
+        if (message.role !== 'assistant' || message.summary !== true || message.mode !== 'compaction' || !message.parentId) continue;
+        const trigger = messages.get(message.parentId);
+        if (!trigger || trigger.message.sessionId !== sessionId) continue;
+        if (!getPartsByMessage(trigger.message.id).some(part => part.type === 'compaction')) continue;
+        boundary = trigger;
+        break;
+      }
+      const effective = boundary
+        ? ordered.filter(record => record.sequence >= boundary.sequence)
+        : ordered;
+      return {
+        messages: effective.map(record => ({
+          message: copy(record.message),
+          parts: getPartsByMessage(record.message.id),
+        })),
+        latestCompactionBoundary: boundary?.message.id ?? null,
+        hasCompaction: Boolean(boundary),
+      };
+    },
+    async createPart(part, sessionId) {
+      const message = messages.get(part.messageId);
+      if (!message || message.message.sessionId !== sessionId) throw new Error(`Message does not exist in session: ${part.messageId}`);
+      if (parts.has(part.id)) throw new Error(`Part already exists: ${part.id}`);
+      parts.set(part.id, {
+        part: copy(part),
+        sessionId,
+        insertionOrder: nextPartInsertionOrder++,
+      });
+      return copy(part);
+    },
+    async getPart(id) {
+      const record = parts.get(id);
+      return record ? copy(record.part) : null;
+    },
+    async getPartsByMessage(messageId) {
+      return getPartsByMessage(messageId);
+    },
+    async getPartsBySession(sessionId) {
+      return [...parts.values()]
+        .filter(record => record.sessionId === sessionId)
+        .map(record => copy(record.part))
+        .sort(compareParts);
+    },
+    async updatePart(id, updates) {
+      const current = parts.get(id);
+      if (!current) return null;
+      current.part = copy({ ...current.part, ...updates }) as Part;
+      return copy(current.part);
+    },
+    async persistStreamingPartSnapshots(snapshots: StreamingPartSnapshot[]) {
+      let count = 0;
+      for (const snapshot of snapshots) {
+        const record = parts.get(snapshot.id);
+        if (!record
+          || record.part.messageId !== snapshot.messageId
+          || record.sessionId !== snapshot.sessionId
+          || record.part.type !== snapshot.type) continue;
+        record.part = copy({ ...record.part, text: snapshot.text }) as Part;
+        count += 1;
+      }
+      return count;
+    },
+    async transitionToolToRunningByCallId(sessionId, callId, childSessionId) {
+      const candidates = [...parts.values()]
+        .filter(record => record.sessionId === sessionId
+          && record.part.type === 'tool'
+          && record.part.callId === callId)
+        .sort((left, right) => {
+          const leftPart = left.part as ToolPart;
+          const rightPart = right.part as ToolPart;
+          return Number(rightPart.state.status === 'pending') - Number(leftPart.state.status === 'pending')
+            || rightPart.createdAt - leftPart.createdAt
+            || right.insertionOrder - left.insertionOrder;
+        });
+      const toolPart = candidates[0]?.part as ToolPart | undefined;
+      if (!toolPart || toolPart.state.status !== 'pending') return null;
+      return await store.updatePart(toolPart.id, {
+        state: {
+          status: 'running',
+          input: toolPart.state.input,
+          startedAt: Date.now(),
+          ...(childSessionId ? { childSessionId } : {}),
+        },
+      }) as ToolPart;
+    },
+    async transitionToolToInterrupted(partId, reason) {
+      const current = parts.get(partId)?.part;
+      if (!current || current.type !== 'tool') return null;
+      const now = Date.now();
+      return await store.updatePart(partId, {
+        state: {
+          status: 'interrupted',
+          input: current.state.input,
+          startedAt: current.state.status === 'running' ? current.state.startedAt : now,
+          interruptedAt: now,
+          reason,
+          ...('childSessionId' in current.state && current.state.childSessionId
+            ? { childSessionId: current.state.childSessionId }
+            : {}),
+        },
+      }) as ToolPart;
+    },
+  };
+
+  return store;
+}
+
+export function createInMemoryMessageQueueStore(options: { attachments?: AttachmentStore } = {}): MessageQueueStore {
+  const records = new Map<string, QueuedMessage>();
+  let id = 0;
+  return {
+    async addMessage(sessionId, content, attachments) {
+      const position = Math.max(-1, ...[...records.values()]
+        .filter(record => record.sessionId === sessionId)
+        .map(record => record.position)) + 1;
+      const enriched: Array<{ id: string; kind: string; filename?: string; mimeType?: string; accessKey?: string }> | undefined = attachments ? [] : undefined;
+      if (attachments && enriched) {
+        for (const attachment of attachments) {
+          const record = await options.attachments?.get(sessionId, attachment.id);
+          enriched.push(record ? {
+            ...attachment,
+            filename: record.filename,
+            mimeType: record.mimeType,
+            accessKey: record.accessKey,
+          } : attachment);
+        }
+      }
+      const message: QueuedMessage = {
+        id: `queue-${++id}`,
+        sessionId,
+        content,
+        position,
+        createdAt: Date.now(),
+        ...(enriched ? { attachments: enriched } : {}),
+      };
+      records.set(message.id, copy(message));
+      return copy(message);
+    },
+    async peek(sessionId) {
+      const message = [...records.values()]
+        .filter(record => record.sessionId === sessionId)
+        .sort((left, right) => left.position - right.position || left.id.localeCompare(right.id))[0];
+      return message ? copy(message) : null;
+    },
+    async delete(idToDelete) {
+      return records.delete(idToDelete);
+    },
+  };
+}
+
+export interface InMemoryAuxiliaryRecords {
+  attachments?: AttachmentRecord[];
+  workspaces?: Workspace[];
+  responseFormats?: ResponseFormat[];
+}
+
+export function createInMemoryStorageBundle(records: InMemoryAuxiliaryRecords = {}): StorageBundle {
+  const attachments = new Map(records.attachments?.map(record => [`${record.sessionId}:${record.id}`, copy(record)]));
+  const workspaces = new Map(records.workspaces?.map(record => [record.id, copy(record)]));
+  const responseFormats = new Map(records.responseFormats?.map(record => [record.id, copy(record)]));
+  const attachmentStore: AttachmentStore = {
+    get: async (sessionId, attachmentId) => copy(attachments.get(`${sessionId}:${attachmentId}`) ?? null),
+  };
+  const workspaceStore: WorkspaceStore = {
+    get: async id => copy(workspaces.get(id) ?? null),
+    getAutoApproveSeverity: async id => workspaces.get(id)?.settings.autoApproveSeverity ?? 'low',
+  };
+  const responseFormatStore: ResponseFormatStore = {
+    get: async id => copy(responseFormats.get(id) ?? null),
+  };
+  const index: ConversationIndex = { syncMessage: async () => {} };
+  return {
+    conversation: createInMemoryConversationStore(),
+    toolOutputArtifacts: createInMemoryToolOutputArtifactStore(),
+    queue: createInMemoryMessageQueueStore({ attachments: attachmentStore }),
+    attachments: attachmentStore,
+    workspaces: workspaceStore,
+    responseFormats: responseFormatStore,
+    index,
+  };
+}

package/src/storage/options.ts

@@ -0,0 +1,75 @@
+import type { ConversationStore, StorageBundle } from './contracts';
+import { createInMemoryStorageBundle } from './memory';
+
+export type AgentStorageOption =
+  | ConversationStore
+  | { type: 'memory' }
+  | { type: 'sqlite'; path: string };
+
+/** The storage bundle plus a close() for resources the chosen driver owns
+ * (e.g. sqlite handles). The bundle is spread directly: use the result as a
+ * StorageBundle anywhere, call close() when you are done with it. */
+export interface AgentStorage extends StorageBundle {
+  close(): void;
+}
+
+function composeConversationStore(conversation: ConversationStore): StorageBundle {
+  return {
+    ...createInMemoryStorageBundle(),
+    conversation,
+  };
+}
+
+function isStorageDescriptor(
+  option: AgentStorageOption,
+): option is { type: 'memory' } | { type: 'sqlite'; path: string } {
+  const record = option as Record<string, unknown>;
+  const keys = Object.keys(record).sort();
+  return (record.type === 'memory' && keys.length === 1)
+    || (record.type === 'sqlite'
+      && typeof record.path === 'string'
+      && keys.length === 2
+      && keys[0] === 'path'
+      && keys[1] === 'type');
+}
+
+function memoryComposition(): AgentStorage {
+  return {
+    ...createInMemoryStorageBundle(),
+    close: () => {},
+  };
+}
+
+/** The sqlite driver is imported dynamically: importing the package entry
+ * must not pull bun:sqlite into runtimes that only use memory or custom
+ * stores. The driver loads only when { type: 'sqlite' } is requested. */
+export async function createAgentStorage(option?: AgentStorageOption): Promise<AgentStorage> {
+  if (!option) {
+    return memoryComposition();
+  }
+
+  if (isStorageDescriptor(option)) {
+    if (option.type === 'memory') {
+      return memoryComposition();
+    }
+    const [{ createSqliteConversationStore }, { createSqliteToolOutputArtifactStore }] = await Promise.all([
+      import('./sqlite'),
+      import('./sqlite-tool-output-artifacts'),
+    ]);
+    const conversation = createSqliteConversationStore({ path: option.path });
+    const toolOutputArtifacts = createSqliteToolOutputArtifactStore({ path: option.path });
+    return {
+      ...composeConversationStore(conversation),
+      toolOutputArtifacts,
+      close: () => {
+        toolOutputArtifacts.close();
+        conversation.close();
+      },
+    };
+  }
+
+  return {
+    ...composeConversationStore(option),
+    close: () => {},
+  };
+}

package/src/storage/runtime.ts

@@ -0,0 +1,115 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { StorageBundle } from './contracts';
+import { createInMemoryStorageBundle } from './memory';
+
+let storage: StorageBundle = createInMemoryStorageBundle();
+const scopedStorage = new AsyncLocalStorage<StorageBundle>();
+
+function activeStorage(): StorageBundle {
+  return scopedStorage.getStore() ?? storage;
+}
+
+export function withStorage<T>(value: StorageBundle, callback: () => T): T {
+  return scopedStorage.run(value, callback);
+}
+
+export function configureStorage(value: StorageBundle): void {
+  storage = value;
+}
+
+export function getStorage(): StorageBundle {
+  return activeStorage();
+}
+
+export const createSession = async (...args: Parameters<StorageBundle['conversation']['createSession']>) =>
+  activeStorage().conversation.createSession(...args);
+export const getSession = async (...args: Parameters<StorageBundle['conversation']['getSession']>) =>
+  activeStorage().conversation.getSession(...args);
+export const updateSession = async (...args: Parameters<StorageBundle['conversation']['updateSession']>) =>
+  activeStorage().conversation.updateSession(...args);
+export const getChildSessions = async (...args: Parameters<StorageBundle['conversation']['getChildSessions']>) =>
+  activeStorage().conversation.getChildSessions(...args);
+export const createMessage = async (...args: Parameters<StorageBundle['conversation']['createMessage']>) =>
+  activeStorage().conversation.createMessage(...args);
+export const getMessage = async (...args: Parameters<StorageBundle['conversation']['getMessage']>) =>
+  activeStorage().conversation.getMessage(...args);
+export const getMessageWithParts = async (...args: Parameters<StorageBundle['conversation']['getMessageWithParts']>) =>
+  activeStorage().conversation.getMessageWithParts(...args);
+export async function updateMessage(
+  id: string,
+  updates: Parameters<StorageBundle['conversation']['updateMessage']>[1],
+  options?: { syncFts?: boolean },
+) {
+  const current = activeStorage();
+  const result = await current.conversation.updateMessage(id, updates);
+  if (result && options?.syncFts !== false) await current.index.syncMessage(id);
+  return result;
+}
+export const deleteMessage = async (...args: Parameters<StorageBundle['conversation']['deleteMessage']>) => {
+  const current = activeStorage();
+  await current.index.removeMessage?.(args[0]);
+  return current.conversation.deleteMessage(...args);
+};
+export const listMessagesWithParts = async (...args: Parameters<StorageBundle['conversation']['listMessagesWithParts']>) =>
+  activeStorage().conversation.listMessagesWithParts(...args);
+export const listLatestMessagesWithPartsPage = async (...args: Parameters<StorageBundle['conversation']['listLatestMessagesWithPartsPage']>) =>
+  activeStorage().conversation.listLatestMessagesWithPartsPage(...args);
+export const buildEffectiveContextHistory = async (...args: Parameters<StorageBundle['conversation']['buildEffectiveContextHistory']>) =>
+  activeStorage().conversation.buildEffectiveContextHistory(...args);
+export async function createPart(
+  part: Parameters<StorageBundle['conversation']['createPart']>[0],
+  sessionId: string,
+  options?: { syncFts?: boolean },
+) {
+  const current = activeStorage();
+  const result = await current.conversation.createPart(part, sessionId);
+  if (result && options?.syncFts !== false && (part.type === 'text' || part.type === 'tool')) {
+    await current.index.syncMessage(part.messageId);
+  }
+  return result;
+}
+export const getPart = async (...args: Parameters<StorageBundle['conversation']['getPart']>) =>
+  activeStorage().conversation.getPart(...args);
+export const getPartsByMessage = async (...args: Parameters<StorageBundle['conversation']['getPartsByMessage']>) =>
+  activeStorage().conversation.getPartsByMessage(...args);
+export const getPartsBySession = async (...args: Parameters<StorageBundle['conversation']['getPartsBySession']>) =>
+  activeStorage().conversation.getPartsBySession(...args);
+export async function updatePart(
+  id: string,
+  updates: Record<string, unknown>,
+  options?: { syncFts?: boolean },
+) {
+  const current = activeStorage();
+  const previous = await current.conversation.getPart(id);
+  const result = await current.conversation.updatePart(id, updates);
+  if (result && options?.syncFts !== false
+    && (previous?.type === 'text' || previous?.type === 'tool' || result.type === 'text' || result.type === 'tool')) {
+    await current.index.syncMessage(result.messageId);
+  }
+  return result;
+}
+export const persistStreamingPartSnapshots = async (...args: Parameters<StorageBundle['conversation']['persistStreamingPartSnapshots']>) =>
+  activeStorage().conversation.persistStreamingPartSnapshots(...args);
+export const transitionToolToRunningByCallId = async (...args: Parameters<StorageBundle['conversation']['transitionToolToRunningByCallId']>) =>
+  activeStorage().conversation.transitionToolToRunningByCallId(...args);
+export const transitionToolToInterrupted = async (...args: Parameters<StorageBundle['conversation']['transitionToolToInterrupted']>) =>
+  activeStorage().conversation.transitionToolToInterrupted(...args);
+export const syncMessageFts = async (messageId: string): Promise<void> => activeStorage().index.syncMessage(messageId);
+export const createToolOutputArtifact = (...args: Parameters<StorageBundle['toolOutputArtifacts']['create']>) =>
+  activeStorage().toolOutputArtifacts.create(...args);
+export const getToolOutputArtifactPage = (...args: Parameters<StorageBundle['toolOutputArtifacts']['getPage']>) =>
+  activeStorage().toolOutputArtifacts.getPage(...args);
+export const addMessageToQueue = (...args: Parameters<StorageBundle['queue']['addMessage']>) =>
+  activeStorage().queue.addMessage(...args);
+export const getNextQueuedMessage = (...args: Parameters<StorageBundle['queue']['peek']>) =>
+  activeStorage().queue.peek(...args);
+export const deleteQueuedMessage = (...args: Parameters<StorageBundle['queue']['delete']>) =>
+  activeStorage().queue.delete(...args);
+export const getAttachment = (...args: Parameters<StorageBundle['attachments']['get']>) =>
+  activeStorage().attachments.get(...args);
+export const getWorkspace = async (...args: Parameters<StorageBundle['workspaces']['get']>) =>
+  activeStorage().workspaces.get(...args);
+export const getWorkspaceAutoApproveSeverity = async (...args: Parameters<StorageBundle['workspaces']['getAutoApproveSeverity']>) =>
+  activeStorage().workspaces.getAutoApproveSeverity(...args);
+export const getResponseFormat = (...args: Parameters<StorageBundle['responseFormats']['get']>) =>
+  activeStorage().responseFormats.get(...args);