@truefoundry/trueforge-assistant-ui-runtime 0.0.0 → 0.2.0-rc.0

package/src/toolResponse.ts

@@ -0,0 +1,346 @@
+import type {
+  MessageStatus,
+  ThreadAssistantMessage,
+  ThreadAssistantMessagePart,
+  ThreadMessage,
+} from '@assistant-ui/core';
+import type { ToolResponseRequiredEvent, Turn, TurnInputItem, UserToolResponseEvent } from './server/index.js';
+
+import { ROOT_THREAD_ID } from './constants.js';
+import { recordToolApprovalInFold, recordToolResponseInFold, type PeerThreadFoldState } from './foldPeerThreads.js';
+import type { ToolResponseMessageCustomMetadata } from './messageCustomMetadata.js';
+import type { TurnStreamUpdate } from './turnStreamUpdate.js';
+
+export { ROOT_THREAD_ID } from './constants.js';
+
+export const TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY = 'toolResponseThreadId';
+
+export interface AskUserQuestionInterruptPayload {
+  question?: string;
+  options?: string[];
+}
+
+export type StoredToolResponse = Pick<UserToolResponseEvent, 'content'>;
+
+export type RespondToToolResponseOptions = Pick<UserToolResponseEvent, 'toolCallId' | 'content'>;
+
+type ToolCallPart = Extract<ThreadMessage['content'][number], { type: 'tool-call' }>;
+
+type AssistantToolCallPart = Extract<ThreadAssistantMessagePart, { type: 'tool-call' }>;
+
+export function hasPendingToolResponse(part: Pick<ToolCallPart, 'interrupt' | 'result'>): boolean {
+  return part.interrupt != null && part.result === undefined;
+}
+
+function isStagedResponseAwaitingSdk(part: ToolCallPart): boolean {
+  return part.interrupt != null && part.result !== undefined;
+}
+
+export function toolResponseStatus(): MessageStatus {
+  return { type: 'requires-action', reason: 'tool-calls' };
+}
+
+export function toolResponseMessageCustom(threadId: string): ToolResponseMessageCustomMetadata {
+  return {
+    [TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY]: threadId === ROOT_THREAD_ID ? ROOT_THREAD_ID : threadId,
+  };
+}
+
+export function getToolResponseThreadId(message: ThreadMessage | undefined): string | undefined {
+  if (message?.role !== 'assistant') {
+    return undefined;
+  }
+  const threadId = message.metadata.custom[TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY];
+  return typeof threadId === 'string' ? threadId : undefined;
+}
+
+export function findResponseRequiredInTurn(turn: Pick<Turn, 'state'>): ToolResponseRequiredEvent | undefined {
+  if (turn.state.status !== 'done') {
+    return undefined;
+  }
+  const found = turn.state.requiredActions?.find(action => action.type === 'tool.response_required');
+  return found?.type === 'tool.response_required' ? found : undefined;
+}
+
+function applyToolResponseToToolCall(part: AssistantToolCallPart, content: string): AssistantToolCallPart {
+  return { ...part, result: content };
+}
+
+function updateToolResponseInContent(
+  content: readonly ThreadAssistantMessagePart[],
+  options: RespondToToolResponseOptions,
+): { content: readonly ThreadAssistantMessagePart[]; found: boolean } {
+  let found = false;
+  const newContent = content.map(part => {
+    if (part.type !== 'tool-call') {
+      return part;
+    }
+
+    if (part.toolCallId === options.toolCallId && hasPendingToolResponse(part)) {
+      found = true;
+      return applyToolResponseToToolCall(part, options.content);
+    }
+
+    if (part.messages == null) {
+      return part;
+    }
+
+    const messages = part.messages.map(message => {
+      if (message.role !== 'assistant') {
+        return message;
+      }
+      const nested = updateToolResponseInContent(message.content, options);
+      if (!nested.found) {
+        return message;
+      }
+      found = true;
+      return { ...message, content: nested.content };
+    });
+    return { ...part, messages };
+  });
+
+  return { content: newContent, found };
+}
+
+export function applyToolResponseToMessage(
+  message: ThreadAssistantMessage,
+  options: RespondToToolResponseOptions,
+): ThreadAssistantMessage {
+  const { content } = updateToolResponseInContent(message.content, options);
+  return { ...message, content: [...content] };
+}
+
+function nestedMessagesHavePendingResponses(messages: readonly ThreadMessage[]): boolean {
+  for (const message of messages) {
+    if (messageHasPendingResponses(message)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function messageHasPendingResponses(message: ThreadMessage | undefined): boolean {
+  if (message?.role !== 'assistant') {
+    return false;
+  }
+  for (const part of message.content) {
+    if (part.type !== 'tool-call') {
+      continue;
+    }
+    if (hasPendingToolResponse(part)) {
+      return true;
+    }
+    if (part.messages != null && nestedMessagesHavePendingResponses(part.messages)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function collectResponseInputsFromMessages(
+  messages: readonly ThreadMessage[],
+  defaultThreadId: string,
+): UserToolResponseEvent[] {
+  const events: UserToolResponseEvent[] = [];
+  for (const message of messages) {
+    events.push(...collectResponseInputs(message, defaultThreadId));
+  }
+  return events;
+}
+
+export function collectResponseInputs(message: ThreadMessage, threadId: string): UserToolResponseEvent[] {
+  if (message.role !== 'assistant' || !threadId) {
+    return [];
+  }
+  if (messageHasPendingResponses(message)) {
+    return [];
+  }
+
+  const scopedThreadId = getToolResponseThreadId(message) ?? threadId;
+  const events: UserToolResponseEvent[] = [];
+
+  for (const part of message.content) {
+    if (part.type !== 'tool-call') {
+      continue;
+    }
+    if (isStagedResponseAwaitingSdk(part)) {
+      events.push({
+        type: 'user.tool_response',
+        threadId: scopedThreadId,
+        toolCallId: part.toolCallId,
+        content: String(part.result),
+      });
+    }
+    if (part.messages != null) {
+      events.push(...collectResponseInputsFromMessages(part.messages, scopedThreadId));
+    }
+  }
+  return events;
+}
+
+function contentHasPendingResponses(content: readonly ThreadAssistantMessagePart[]): boolean {
+  return messageHasPendingResponses({
+    id: 'pending-check',
+    role: 'assistant',
+    content,
+    status: { type: 'complete', reason: 'stop' },
+    createdAt: new Date(),
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {},
+    },
+  });
+}
+
+export function resolveToolResponseUpdate(update: TurnStreamUpdate): TurnStreamUpdate {
+  if (
+    contentHasPendingResponses(update.content) ||
+    update.status?.type !== 'requires-action' ||
+    update.status.reason !== 'tool-calls'
+  ) {
+    return update;
+  }
+
+  return { content: update.content };
+}
+
+function walkAssistantToolCallParts(
+  content: readonly ThreadAssistantMessagePart[],
+  visit: (part: AssistantToolCallPart) => void,
+): void {
+  for (const part of content) {
+    if (part.type !== 'tool-call') {
+      continue;
+    }
+    visit(part);
+    if (part.messages == null) {
+      continue;
+    }
+    for (const message of part.messages) {
+      if (message.role === 'assistant') {
+        walkAssistantToolCallParts(message.content, visit);
+      }
+    }
+  }
+}
+
+function collectStagedResponsesFromContent(content: readonly ThreadAssistantMessagePart[]): Map<string, string> {
+  const staged = new Map<string, string>();
+  walkAssistantToolCallParts(content, part => {
+    if (isStagedResponseAwaitingSdk(part)) {
+      staged.set(part.toolCallId, String(part.result));
+    }
+  });
+  return staged;
+}
+
+function applyStagedResponsesToContentMap(
+  content: readonly ThreadAssistantMessagePart[],
+  staged: ReadonlyMap<string, string>,
+): ThreadAssistantMessagePart[] {
+  return content.map(part => {
+    if (part.type !== 'tool-call') {
+      return part;
+    }
+
+    const contentValue = staged.get(part.toolCallId);
+    let nextPart: AssistantToolCallPart = part;
+    if (contentValue != null && hasPendingToolResponse(part)) {
+      nextPart = applyToolResponseToToolCall(part, contentValue);
+    }
+
+    if (nextPart.messages == null) {
+      return nextPart;
+    }
+
+    return {
+      ...nextPart,
+      messages: nextPart.messages.map(message => {
+        if (message.role !== 'assistant') {
+          return message;
+        }
+        return {
+          ...message,
+          content: applyStagedResponsesToContentMap(message.content, staged),
+        };
+      }),
+    };
+  });
+}
+
+export function mergeStagedResponsesIntoContent(
+  incoming: readonly ThreadAssistantMessagePart[],
+  existing: readonly ThreadAssistantMessagePart[],
+): ThreadAssistantMessagePart[] {
+  const staged = collectStagedResponsesFromContent(existing);
+  if (staged.size === 0) {
+    return [...incoming];
+  }
+  return applyStagedResponsesToContentMap(incoming, staged);
+}
+
+export function extractToolResponsesFromTurnInput(input: Turn['input'] | undefined): UserToolResponseEvent[] {
+  const events: UserToolResponseEvent[] = [];
+  for (const item of input ?? []) {
+    if (item.type === 'user.tool_response') {
+      events.push(item);
+    }
+  }
+  return events;
+}
+
+export function applyUserToolResponsesToFold(fold: PeerThreadFoldState, inputs: readonly TurnInputItem[]): void {
+  for (const item of inputs) {
+    if (item.type === 'user.tool_response') {
+      recordToolResponseInFold(fold, {
+        toolCallId: item.toolCallId,
+        content: item.content,
+      });
+    } else if (item.type === 'user.tool_approval') {
+      recordToolApprovalInFold(fold, {
+        toolCallId: item.toolCallId,
+        approved: item.approval.status === 'allow',
+        ...(item.approval.status === 'deny' && item.approval.reason != null ? { reason: item.approval.reason } : {}),
+      });
+    }
+  }
+}
+
+export function collectSubsequentToolResponses(
+  turns: readonly Pick<Turn, 'input'>[],
+  fromIndex: number,
+): Map<string, StoredToolResponse> {
+  const responses = new Map<string, StoredToolResponse>();
+
+  for (let index = fromIndex + 1; index < turns.length; index++) {
+    const input = turns[index]?.input ?? [];
+    if (input.some(item => item.type === 'user.message')) {
+      break;
+    }
+
+    for (const event of extractToolResponsesFromTurnInput(input)) {
+      responses.set(event.toolCallId, { content: event.content });
+    }
+  }
+
+  return responses;
+}
+
+export function collectToolResponsesFromTurnInput(input: Turn['input'] | undefined): Map<string, StoredToolResponse> {
+  const responses = new Map<string, StoredToolResponse>();
+  for (const event of extractToolResponsesFromTurnInput(input)) {
+    responses.set(event.toolCallId, { content: event.content });
+  }
+  return responses;
+}
+
+export function applyStagedResponsesToContent(
+  content: readonly ThreadAssistantMessagePart[],
+  responses: ReadonlyMap<string, StoredToolResponse>,
+): ThreadAssistantMessagePart[] {
+  const staged = new Map([...responses.entries()].map(([toolCallId, value]) => [toolCallId, value.content]));
+  return applyStagedResponsesToContentMap(content, staged);
+}

package/src/trueforgeExtras.ts

@@ -0,0 +1,223 @@
+'use client';
+
+import type { AssistantClient } from '@assistant-ui/store';
+import { useAui } from '@assistant-ui/store';
+import { useCallback, useSyncExternalStore } from 'react';
+import type { McpAuthRequiredEvent } from './server/index.js';
+
+import type { PendingApproval, PendingToolResponse } from './collectPending.js';
+import type { AgentSpecUpdate } from './draft/agentSpec.js';
+import type { AgentSpec } from './server/types.js';
+import type { RespondToToolApprovalOptions } from './toolApproval.js';
+import type { RespondToToolResponseOptions } from './toolResponse.js';
+
+export type { PendingApproval, PendingToolResponse };
+
+export interface TrueForgeDraftRuntimeExtras {
+  agentSpec: AgentSpec | null;
+  draftSessionId: string | undefined;
+  isSpecLoading: boolean;
+  isSpecSyncing: boolean;
+  specError: unknown;
+  updateAgentSpec: (update: AgentSpecUpdate) => void;
+  flushAgentSpec: () => Promise<void>;
+  adoptAgentSpec: (request: { agentSpec: AgentSpec; updatedAt?: string }) => void;
+}
+
+export interface TrueForgeRuntimeExtras {
+  pendingApprovals: PendingApproval[];
+  pendingToolResponses: PendingToolResponse[];
+  pendingMcpAuth: { mcpServers: McpAuthRequiredEvent['mcpServers'] } | null;
+  resumeUnavailable: boolean;
+  sandboxId: string | undefined;
+  respondToToolApproval: (response: RespondToToolApprovalOptions) => void;
+  respondToToolResponse: (response: RespondToToolResponseOptions) => void;
+  resumeMcpAuth: () => Promise<void>;
+  downloadSandboxFile: (req: { turnId: string; path: string }) => Promise<Blob>;
+  cancel: () => Promise<void>;
+  resetFromTurn: (turnId: string) => Promise<void>;
+  reload: () => void;
+  hasOlderHistory: boolean;
+  isLoadingOlderHistory: boolean;
+  loadOlderHistory: () => Promise<void>;
+  draft: TrueForgeDraftRuntimeExtras | null;
+}
+
+const extrasBrandSymbol = Symbol('useTrueForgeAgentRuntime extras');
+
+const isTrueForgeExtras = (extras: unknown): extras is TrueForgeRuntimeExtras =>
+  typeof extras === 'object' && extras !== null && extrasBrandSymbol in extras;
+
+const extrasBrand = {
+  provide: (value: TrueForgeRuntimeExtras): TrueForgeRuntimeExtras => {
+    Object.defineProperty(value, extrasBrandSymbol, {
+      value: true,
+      enumerable: false,
+      configurable: true,
+    });
+    return value;
+  },
+  is: isTrueForgeExtras,
+  tryGet: (extras: unknown): TrueForgeRuntimeExtras | undefined => (isTrueForgeExtras(extras) ? extras : undefined),
+};
+
+export const EMPTY_DRAFT_EXTRAS: TrueForgeDraftRuntimeExtras = {
+  agentSpec: null,
+  draftSessionId: undefined,
+  isSpecLoading: false,
+  isSpecSyncing: false,
+  specError: null,
+  updateAgentSpec: () => {
+    throw new Error('Draft agent extras are only available in draft mode.');
+  },
+  flushAgentSpec: () => Promise.reject(new Error('Draft agent extras are only available in draft mode.')),
+  adoptAgentSpec: () => {
+    throw new Error('Draft agent extras are only available in draft mode.');
+  },
+};
+
+type SubscribeFn = (onStoreChange: () => void) => () => void;
+
+function isThreadAccessor(value: unknown): value is (this: object) => unknown {
+  return typeof value === 'function';
+}
+
+function isGetState(value: unknown): value is (this: object) => unknown {
+  return typeof value === 'function';
+}
+
+function isSubscribe(value: unknown): value is (this: object, onStoreChange: () => void) => unknown {
+  return typeof value === 'function';
+}
+
+/**
+ * Walk `Object.create(parent)` AUI clients. Stops before leaving the chain.
+ * Callers must try/catch RootAssistantClient proxy gets (it throws on any
+ * missing accessor such as `subscribe` / `thread`).
+ */
+function walkAssistantClientAncestors(client: AssistantClient, visit: (current: object) => 'continue' | 'stop'): void {
+  let current: object | null = client;
+  const seen = new Set<object>();
+  while (!seen.has(current)) {
+    seen.add(current);
+    if (visit(current) === 'stop') {
+      return;
+    }
+    const parent = Reflect.getPrototypeOf(current);
+    if (parent == null || parent === Object.prototype) {
+      return;
+    }
+    current = parent;
+  }
+}
+
+/**
+ * `PartPrimitive.Messages` wraps sub-agent threads in `ReadonlyThreadProvider`,
+ * which shadows `thread` (and therefore `thread.extras`) with a readonly client
+ * that has no TrueForge extras. Nested AUI clients are `Object.create(parent)`,
+ * so walk the prototype chain to reach the root runtime extras.
+ */
+export function tryGetTrueForgeExtras(client: AssistantClient): TrueForgeRuntimeExtras | undefined {
+  let found: TrueForgeRuntimeExtras | undefined;
+  walkAssistantClientAncestors(client, current => {
+    try {
+      const thread: unknown = Reflect.get(current, 'thread');
+      if (isThreadAccessor(thread)) {
+        const threadClient: unknown = Reflect.apply(thread, current, []);
+        if (threadClient == null || typeof threadClient !== 'object') {
+          return 'continue';
+        }
+        const getState: unknown = Reflect.get(threadClient, 'getState');
+        if (!isGetState(getState)) {
+          return 'continue';
+        }
+        const state: unknown = Reflect.apply(getState, threadClient, []);
+        const extras = extrasBrand.tryGet(
+          state != null && typeof state === 'object' ? Reflect.get(state, 'extras') : undefined,
+        );
+        if (extras != null) {
+          found = extras;
+          return 'stop';
+        }
+      }
+    } catch {
+      // Nested/readonly clients may lack thread; RootAssistantClient proxy
+      // throws on missing scope accessors ("thread" / "subscribe").
+    }
+    return 'continue';
+  });
+  return found;
+}
+
+export function getTrueForgeExtras(client: AssistantClient): TrueForgeRuntimeExtras {
+  const extras = tryGetTrueForgeExtras(client);
+  if (extras == null) {
+    throw new Error('The current thread is not backed by the useTrueForgeAgentRuntime runtime.');
+  }
+  return extras;
+}
+
+function subscribeClientChain(client: AssistantClient): SubscribeFn {
+  return onStoreChange => {
+    const unsubs: (() => void)[] = [];
+    walkAssistantClientAncestors(client, current => {
+      try {
+        const subscribe: unknown = Reflect.get(current, 'subscribe');
+        if (isSubscribe(subscribe)) {
+          const unsubscribe: unknown = Reflect.apply(subscribe, current, [onStoreChange]);
+          if (typeof unsubscribe === 'function') {
+            unsubs.push(() => {
+              Reflect.apply(unsubscribe, undefined, []);
+            });
+          }
+        }
+        return 'continue';
+      } catch {
+        // RootAssistantClient proxy — no further usable ancestors.
+        return 'stop';
+      }
+    });
+    return () => {
+      for (const unsub of unsubs) {
+        unsub();
+      }
+    };
+  };
+}
+
+/**
+ * Resolves TrueForge extras from the nearest ancestor runtime, including
+ * inside nested readonly sub-agent renderers (`PartPrimitive.Messages`).
+ */
+export function useTrueForgeRuntimeExtras(): TrueForgeRuntimeExtras | undefined {
+  const aui = useAui();
+  const subscribe = useCallback(subscribeClientChain(aui), [aui]);
+  const getSnapshot = useCallback(() => tryGetTrueForgeExtras(aui), [aui]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
+function useTrueForgeExtrasApi(): TrueForgeRuntimeExtras;
+function useTrueForgeExtrasApi<S>(select: (extras: TrueForgeRuntimeExtras) => S, fallback?: S): S;
+function useTrueForgeExtrasApi<S>(select?: (extras: TrueForgeRuntimeExtras) => S, fallback?: S): unknown {
+  const extras = useTrueForgeRuntimeExtras();
+  const hasFallback = arguments.length >= 2;
+  if (extras == null) {
+    if (hasFallback) {
+      return fallback;
+    }
+    throw new Error('The current thread is not backed by the useTrueForgeAgentRuntime runtime.');
+  }
+  return select != null ? select(extras) : extras;
+}
+
+/**
+ * Brand + provide/tryGet from assistant-ui; get/use walk ancestor AUI clients so
+ * nested readonly sub-agent threads still resolve root TrueForge extras.
+ */
+export const trueForgeExtras = {
+  provide: extrasBrand.provide,
+  is: extrasBrand.is,
+  tryGet: extrasBrand.tryGet,
+  get: getTrueForgeExtras,
+  use: useTrueForgeExtrasApi,
+};

package/src/trueforgeOwnedSessionsThreadListAdapter.ts

@@ -0,0 +1,71 @@
+import type { RemoteThreadListAdapter } from '@assistant-ui/core';
+
+import type { AgentChatServer } from './server/types.js';
+import { sessionListStartTimestamp } from './sessionListStartTimestamp.js';
+import { sessionDisplayTitle, sessionToThreadMetadata } from './sessionThreadMetadata.js';
+
+const THREAD_LIST_PAGE_SIZE = 20;
+
+/**
+ * Read-only thread-list adapter backed by `AgentChatServer.listSessions`.
+ */
+export function createTrueForgeOwnedSessionsThreadListAdapter(options: {
+  server: AgentChatServer;
+  /** When set, filters `listSessions` by this agent id. Omit for all chats. */
+  listSessionsAgentId?: string;
+  /** Restrict history to sessions created by the authenticated subject. */
+  listSessionsCreatedByMe?: boolean;
+}): RemoteThreadListAdapter {
+  const { server, listSessionsAgentId, listSessionsCreatedByMe = false } = options;
+
+  return {
+    async list({ after } = {}) {
+      const page = await server.listSessions({
+        ...(listSessionsAgentId != null ? { agentId: listSessionsAgentId } : {}),
+        createdByMe: listSessionsCreatedByMe,
+        limit: THREAD_LIST_PAGE_SIZE,
+        ...(after == null ? {} : { pageToken: after }),
+        startTimestamp: sessionListStartTimestamp(),
+      });
+      const threads = page.data.map(session => sessionToThreadMetadata(session, sessionDisplayTitle(session)));
+      return {
+        threads,
+        nextCursor: page.nextPageToken ?? undefined,
+      };
+    },
+
+    initialize() {
+      return Promise.reject(
+        new Error('Owned sessions history adapter is read-only; create sessions via a named or draft runtime.'),
+      );
+    },
+
+    async fetch(remoteId) {
+      const session = await server.getSession({ sessionId: remoteId });
+      return sessionToThreadMetadata(session, sessionDisplayTitle(session));
+    },
+
+    async rename(remoteId, newTitle) {
+      if (typeof server.renameSession !== 'function') {
+        return;
+      }
+      await server.renameSession({ sessionId: remoteId, title: newTitle });
+    },
+    archive() {
+      return Promise.resolve();
+    },
+    unarchive() {
+      return Promise.resolve();
+    },
+    async delete(remoteId) {
+      if (typeof server.deleteSession !== 'function') {
+        return;
+      }
+      await server.deleteSession({ sessionId: remoteId });
+    },
+
+    generateTitle() {
+      return Promise.resolve(new ReadableStream());
+    },
+  };
+}

package/src/trueforgeThreadListAdapter.ts

@@ -0,0 +1,69 @@
+import type { RemoteThreadListAdapter } from '@assistant-ui/core';
+
+import type { AgentChatServer } from './server/types.js';
+import { sessionListStartTimestamp } from './sessionListStartTimestamp.js';
+import { getSession } from './sessions.js';
+import { sessionToThreadMetadata } from './sessionThreadMetadata.js';
+
+const THREAD_LIST_PAGE_SIZE = 20;
+
+export function createTrueForgeThreadListAdapter(options: {
+  server: AgentChatServer;
+  agentName: string;
+  /** When set, filters `listSessions` by this agent id. Omit for all chats. */
+  listSessionsAgentId?: string;
+  /** Restrict history to sessions created by the authenticated subject. */
+  listSessionsCreatedByMe?: boolean;
+}): RemoteThreadListAdapter {
+  const { server, agentName, listSessionsAgentId, listSessionsCreatedByMe = false } = options;
+
+  return {
+    async list({ after } = {}) {
+      const page = await server.listSessions({
+        ...(listSessionsAgentId != null ? { agentId: listSessionsAgentId } : {}),
+        createdByMe: listSessionsCreatedByMe,
+        limit: THREAD_LIST_PAGE_SIZE,
+        ...(after == null ? {} : { pageToken: after }),
+        startTimestamp: sessionListStartTimestamp(),
+      });
+      const threads = page.data.map(session => sessionToThreadMetadata(session, session.title ?? undefined));
+      return {
+        threads,
+        nextCursor: page.nextPageToken ?? undefined,
+      };
+    },
+
+    async initialize() {
+      const session = await server.createSession({ agentName });
+      return { remoteId: session.id, externalId: undefined };
+    },
+
+    async fetch(remoteId) {
+      const session = await getSession(server, remoteId);
+      return sessionToThreadMetadata(session, session.title ?? undefined);
+    },
+
+    async rename(remoteId, newTitle) {
+      if (typeof server.renameSession !== 'function') {
+        return;
+      }
+      await server.renameSession({ sessionId: remoteId, title: newTitle });
+    },
+    archive() {
+      return Promise.resolve();
+    },
+    unarchive() {
+      return Promise.resolve();
+    },
+    async delete(remoteId) {
+      if (typeof server.deleteSession !== 'function') {
+        return;
+      }
+      await server.deleteSession({ sessionId: remoteId });
+    },
+
+    generateTitle() {
+      return Promise.resolve(new ReadableStream());
+    },
+  };
+}