@kitn.ai/ui 0.20.0 → 0.21.0

package/src/wire/formats/anthropic.ts

@@ -0,0 +1,267 @@
+// Anthropic Messages SSE.
+//
+// This format is STATEFUL. `content_block_delta` names the delta kind
+// (`thinking_delta`, `input_json_delta`, ...) but not which block kind the
+// fragment belongs to, so the block map is populated at `content_block_start`
+// and read on every later event for that index.
+//
+// It is also the only format in the kit carrying a VERBATIM requirement:
+// Anthropic returns 400 if a `thinking` block is modified, reordered or
+// reconstructed on the way back in. The block emitted at `content_block_stop`
+// is ASSEMBLED, not invented: `thinking` is the concatenation of the provider's
+// own thinking_delta payloads and `signature` is the provider's signature_delta,
+// so every byte came off the wire. Nothing is derived from the reasoning PART's
+// text, which a consumer can edit.
+//
+// Three of the chunks below carry NO reasoning text (the block start, every
+// signature_delta, the block stop). They depend on consume.ts gating reasoning
+// on `reasoning !== undefined || reasoningRaw || reasoningSignature` rather than
+// on truthiness. Under the old guard all three vanish.
+import type { MessageSource } from '../../elements/chat-types';
+import type { ModelStreamChunk, ModelUsage, WireFormat, WireFormatReader } from '../chunk';
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+function str(v: unknown): string | undefined {
+  return typeof v === 'string' ? v : undefined;
+}
+
+function num(v: unknown): number | undefined {
+  return typeof v === 'number' ? v : undefined;
+}
+
+type BlockKind = 'text' | 'thinking' | 'redacted_thinking' | 'tool_use' | 'other';
+
+interface BlockState {
+  kind: BlockKind;
+  /** Accumulated thinking_delta payloads, for the verbatim block at stop. */
+  thinking: string;
+  /** Accumulated signature_delta payloads. */
+  signature?: string;
+}
+
+function usageOf(raw: unknown): ModelUsage | undefined {
+  if (!isRecord(raw)) return undefined;
+  const out: ModelUsage = {};
+  const input = num(raw.input_tokens);
+  if (input !== undefined) out.inputTokens = input;
+  const output = num(raw.output_tokens);
+  if (output !== undefined) out.outputTokens = output;
+  const cached = num(raw.cache_read_input_tokens);
+  if (cached !== undefined) out.cachedInputTokens = cached;
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function blockStart(
+  frame: Record<string, unknown>,
+  blocks: Map<number, BlockState>,
+  toolIndexById: Map<string, number>,
+): ModelStreamChunk[] {
+  const index = num(frame.index) ?? 0;
+  const block = frame.content_block;
+  if (!isRecord(block)) return [];
+
+  switch (str(block.type)) {
+    case 'text': {
+      blocks.set(index, { kind: 'text', thinking: '' });
+      const text = str(block.text);
+      return text ? [{ text }] : [];
+    }
+    case 'thinking': {
+      const seed = str(block.thinking) ?? '';
+      blocks.set(index, { kind: 'thinking', thinking: seed });
+      // An EMPTY reasoning delta on purpose: it opens the reasoning part at the
+      // point in the stream where the block started, so block order in `parts`
+      // matches block order on the wire. The encoder round-trips that order.
+      return [{ reasoning: seed, reasoningIndex: index }];
+    }
+    case 'redacted_thinking': {
+      blocks.set(index, { kind: 'redacted_thinking', thinking: '' });
+      // The WHOLE block arrives here; there are no deltas and there is no
+      // readable text. It must still round-trip: the docs require sending back
+      // every block "including any blocks with empty thinking fields".
+      return [
+        {
+          reasoning: '',
+          reasoningIndex: index,
+          reasoningRaw: { source: 'anthropic.content_block', payload: block },
+        },
+      ];
+    }
+    case 'tool_use':
+    case 'server_tool_use': {
+      const id = str(block.id);
+      const name = str(block.name);
+      blocks.set(index, { kind: 'tool_use', thinking: '' });
+      if (id) toolIndexById.set(id, index);
+      return [{ toolCalls: [{ index, ...(id ? { id } : {}), ...(name ? { name } : {}) }] }];
+    }
+    case 'web_search_tool_result': {
+      // A result the PROVIDER executed. It correlates by `tool_use_id`, NOT by
+      // its own block index, so it is routed back to the index of the
+      // server_tool_use block that opened the call. With no such block the
+      // result has nothing to complete and is dropped rather than inventing a
+      // panel.
+      blocks.set(index, { kind: 'other', thinking: '' });
+      const toolUseId = str(block.tool_use_id);
+      const target = toolUseId !== undefined ? toolIndexById.get(toolUseId) : undefined;
+      if (target === undefined) return [];
+      const content = block.content;
+      if (isRecord(content) && (str(content.type) ?? '').endsWith('_error')) {
+        return [
+          {
+            toolCalls: [
+              {
+                index: target,
+                ...(toolUseId ? { id: toolUseId } : {}),
+                outputError: str(content.error_code) ?? 'web_search_tool_result_error',
+              },
+            ],
+          },
+        ];
+      }
+      return [
+        {
+          toolCalls: [
+            { index: target, ...(toolUseId ? { id: toolUseId } : {}), output: { content } },
+          ],
+        },
+      ];
+    }
+    default:
+      blocks.set(index, { kind: 'other', thinking: '' });
+      return [];
+  }
+}
+
+function blockDelta(
+  frame: Record<string, unknown>,
+  blocks: Map<number, BlockState>,
+): ModelStreamChunk[] {
+  const index = num(frame.index) ?? 0;
+  const delta = frame.delta;
+  if (!isRecord(delta)) return [];
+
+  switch (str(delta.type)) {
+    case 'text_delta': {
+      const text = str(delta.text);
+      return text ? [{ text }] : [];
+    }
+    case 'thinking_delta': {
+      const text = str(delta.thinking) ?? '';
+      const state = blocks.get(index);
+      if (state) state.thinking += text;
+      return [{ reasoning: text, reasoningIndex: index }];
+    }
+    case 'signature_delta': {
+      const signature = str(delta.signature) ?? '';
+      const state = blocks.get(index);
+      // Concatenated rather than assigned: a split signature must reassemble.
+      if (state) state.signature = (state.signature ?? '') + signature;
+      // No text. Carried so the part's informational `signature` is populated;
+      // the round-trip payload lands at content_block_stop.
+      return [{ reasoning: '', reasoningIndex: index, reasoningSignature: signature }];
+    }
+    case 'input_json_delta': {
+      return [{ toolCalls: [{ index, arguments: str(delta.partial_json) ?? '' }] }];
+    }
+    case 'citations_delta': {
+      const citation = delta.citation;
+      if (!isRecord(citation)) return [];
+      const source: MessageSource = {};
+      const url = str(citation.url);
+      if (url) source.url = url;
+      const title = str(citation.title);
+      if (title) source.title = title;
+      const snippet = str(citation.cited_text);
+      if (snippet) source.snippet = snippet;
+      return Object.keys(source).length > 0 ? [{ sources: [source] }] : [];
+    }
+    default:
+      return [];
+  }
+}
+
+function blockStop(
+  frame: Record<string, unknown>,
+  blocks: Map<number, BlockState>,
+): ModelStreamChunk[] {
+  const index = num(frame.index) ?? 0;
+  const state = blocks.get(index);
+  // Only a streamed `thinking` block needs assembling. `redacted_thinking`
+  // already emitted its whole payload at start, and text and tool blocks have
+  // no verbatim requirement.
+  if (!state || state.kind !== 'thinking') return [];
+  const payload: Record<string, unknown> = { type: 'thinking', thinking: state.thinking };
+  if (state.signature !== undefined) payload.signature = state.signature;
+  return [
+    {
+      reasoning: '',
+      reasoningIndex: index,
+      reasoningRaw: { source: 'anthropic.content_block', payload },
+    },
+  ];
+}
+
+function messageDelta(frame: Record<string, unknown>): ModelStreamChunk[] {
+  const out: ModelStreamChunk = {};
+  const delta = frame.delta;
+  if (isRecord(delta)) {
+    const stop = str(delta.stop_reason);
+    if (stop) out.finishReason = stop;
+  }
+  const usage = usageOf(frame.usage);
+  if (usage) out.usage = usage;
+  return Object.keys(out).length > 0 ? [out] : [];
+}
+
+function errorFrame(frame: Record<string, unknown>): ModelStreamChunk[] {
+  const err = frame.error;
+  const message = isRecord(err) ? str(err.message) : undefined;
+  const code = isRecord(err) ? str(err.type) : undefined;
+  return [
+    {
+      error: {
+        message: message ?? 'The provider sent an error frame with no message.',
+        ...(code ? { code } : {}),
+      },
+    },
+  ];
+}
+
+export const anthropicMessagesFormat: WireFormat = {
+  id: 'anthropic.messages',
+  open(): WireFormatReader {
+    // Per-stream state, created HERE so two open() calls share nothing.
+    const blocks = new Map<number, BlockState>();
+    const toolIndexById = new Map<string, number>();
+    return {
+      push(frame: unknown): ModelStreamChunk[] {
+        if (!isRecord(frame)) return [];
+        switch (str(frame.type)) {
+          case 'message_start': {
+            const message = frame.message;
+            if (!isRecord(message)) return [];
+            const usage = usageOf(message.usage);
+            return usage ? [{ usage }] : [];
+          }
+          case 'content_block_start':
+            return blockStart(frame, blocks, toolIndexById);
+          case 'content_block_delta':
+            return blockDelta(frame, blocks);
+          case 'content_block_stop':
+            return blockStop(frame, blocks);
+          case 'message_delta':
+            return messageDelta(frame);
+          case 'error':
+            return errorFrame(frame);
+          default:
+            // ping, message_stop, and anything Anthropic adds later.
+            return [];
+        }
+      },
+    };
+  },
+};

package/src/wire/formats/openai.ts

@@ -0,0 +1,187 @@
+// OpenAI chat-completions SSE. Also the shape every non-mock integration in the
+// kit's catalog re-frames to server-side, so this one decoder covers all nine.
+//
+// Input is an ALREADY DECODED JSON frame typed `unknown`. Nothing here imports a
+// provider SDK, and nothing here throws: a frame this format does not recognise
+// yields [] so a provider adding a field cannot take a turn down.
+import type { MessageSource } from '../../elements/chat-types';
+import type {
+  ModelStreamChunk,
+  ModelToolCallDelta,
+  ModelUsage,
+  WireFormat,
+  WireFormatReader,
+} from '../chunk';
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+function str(v: unknown): string | undefined {
+  return typeof v === 'string' ? v : undefined;
+}
+
+function num(v: unknown): number | undefined {
+  return typeof v === 'number' ? v : undefined;
+}
+
+function usageOf(raw: unknown): ModelUsage | undefined {
+  if (!isRecord(raw)) return undefined;
+  const out: ModelUsage = {};
+  const input = num(raw.prompt_tokens);
+  if (input !== undefined) out.inputTokens = input;
+  const output = num(raw.completion_tokens);
+  if (output !== undefined) out.outputTokens = output;
+  const total = num(raw.total_tokens);
+  if (total !== undefined) out.totalTokens = total;
+  const details = raw.completion_tokens_details;
+  if (isRecord(details)) {
+    // The one number that proves reasoning happened even when no reasoning text
+    // was streamed back.
+    const reasoning = num(details.reasoning_tokens);
+    if (reasoning !== undefined) out.reasoningTokens = reasoning;
+  }
+  const promptDetails = raw.prompt_tokens_details;
+  if (isRecord(promptDetails)) {
+    const cached = num(promptDetails.cached_tokens);
+    if (cached !== undefined) out.cachedInputTokens = cached;
+  }
+  const cost = num(raw.cost);
+  if (cost !== undefined) out.costUsd = cost;
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function toolCallDelta(raw: unknown, position: number): ModelToolCallDelta | undefined {
+  if (!isRecord(raw)) return undefined;
+  const fn = isRecord(raw.function) ? raw.function : undefined;
+  const out: ModelToolCallDelta = { index: num(raw.index) ?? position };
+  const id = str(raw.id);
+  if (id) out.id = id;
+  const name = str(fn?.name);
+  if (name) out.name = name;
+  const args = str(fn?.arguments);
+  if (args !== undefined) out.arguments = args;
+  return out;
+}
+
+/** Sum the READABLE text across reasoning_details entries. Entries with no
+ *  readable text (`reasoning.encrypted`, opaque signed blobs) contribute nothing
+ *  here; they still ride along whole in `reasoningRaw`. */
+function detailText(details: unknown[]): string {
+  let out = '';
+  for (const d of details) {
+    if (!isRecord(d)) continue;
+    const text = str(d.text) ?? str(d.summary);
+    if (text) out += text;
+  }
+  return out;
+}
+
+function detailField(details: unknown[], key: 'index' | 'signature'): unknown {
+  for (const d of details) {
+    if (isRecord(d) && d[key] !== undefined) return d[key];
+  }
+  return undefined;
+}
+
+/**
+ * FINDINGS: OpenRouter frequently puts the SAME text in `reasoning` AND in
+ * `reasoning_details` on the same delta. Concatenating both doubles every
+ * reasoning token, so `reasoning` wins and details are only a text FALLBACK.
+ *
+ * `reasoning_details` is still read in BOTH cases, for `reasoningRaw`, the block
+ * index and the signature. It is the provider's own block list, and dropping it
+ * is exactly the Anthropic 400 this entry exists to avoid.
+ */
+function applyReasoning(delta: Record<string, unknown>, out: ModelStreamChunk): void {
+  const details = Array.isArray(delta.reasoning_details) ? delta.reasoning_details : undefined;
+  const primaryRaw = str(delta.reasoning);
+  const primary = primaryRaw !== undefined && primaryRaw !== '' ? primaryRaw : undefined;
+  const fallback = details ? detailText(details) : undefined;
+  const hasDetails = details !== undefined && details.length > 0;
+  const text = primary ?? fallback;
+  if (text === undefined && !hasDetails) return;
+
+  // '' is deliberate and meaningful: an encrypted-only detail entry has no
+  // readable text but must still produce a reasoning part carrying its payload.
+  out.reasoning = text ?? '';
+  if (!hasDetails) return;
+
+  out.reasoningRaw = { source: 'openai.reasoning_details', payload: details };
+  const index = num(detailField(details, 'index'));
+  if (index !== undefined) out.reasoningIndex = index;
+  const signature = str(detailField(details, 'signature'));
+  if (signature !== undefined) out.reasoningSignature = signature;
+}
+
+function sourcesOf(delta: Record<string, unknown>): MessageSource[] {
+  if (!Array.isArray(delta.annotations)) return [];
+  const out: MessageSource[] = [];
+  for (const a of delta.annotations) {
+    if (!isRecord(a)) continue;
+    const citation = isRecord(a.url_citation) ? a.url_citation : undefined;
+    const url = str(citation?.url);
+    if (!url) continue;
+    const source: MessageSource = { url };
+    const title = str(citation?.title);
+    if (title) source.title = title;
+    const snippet = str(citation?.content);
+    if (snippet) source.snippet = snippet;
+    out.push(source);
+  }
+  return out;
+}
+
+function pushOpenAI(frame: unknown): ModelStreamChunk[] {
+  if (!isRecord(frame)) return [];
+  const out: ModelStreamChunk = {};
+
+  const err = frame.error;
+  if (isRecord(err)) {
+    const message = str(err.message);
+    if (message) {
+      out.error = { message };
+      const code = err.code;
+      if (typeof code === 'string' || typeof code === 'number') out.error.code = code;
+    }
+  }
+
+  const usage = usageOf(frame.usage);
+  if (usage) out.usage = usage;
+
+  const choices = Array.isArray(frame.choices) ? frame.choices : [];
+  const choice = isRecord(choices[0]) ? choices[0] : undefined;
+  if (choice) {
+    const delta = isRecord(choice.delta) ? choice.delta : undefined;
+    if (delta) {
+      const content = str(delta.content);
+      if (content) out.text = content;
+
+      applyReasoning(delta, out);
+
+      if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
+        const calls = delta.tool_calls
+          .map((raw, i) => toolCallDelta(raw, i))
+          .filter((c): c is ModelToolCallDelta => c !== undefined);
+        if (calls.length > 0) out.toolCalls = calls;
+      }
+
+      const sources = sourcesOf(delta);
+      if (sources.length > 0) out.sources = sources;
+    }
+    const finish = str(choice.finish_reason);
+    if (finish) out.finishReason = finish;
+  }
+
+  return Object.keys(out).length > 0 ? [out] : [];
+}
+
+/** Stateless: every frame is self-describing, so `open()` returns a reader with
+ *  no closure state. The interface still calls it per stream, which is what lets
+ *  the stateful Anthropic format use the same seam. */
+export const openaiChatFormat: WireFormat = {
+  id: 'openai.chat-completions',
+  open(): WireFormatReader {
+    return { push: pushOpenAI };
+  },
+};

package/src/wire/index.ts

@@ -0,0 +1,52 @@
+// @kitn.ai/ui/wire: the model-stream adapter.
+//
+// Separate from ./state on purpose. `state` is I/O-free pure functions over
+// ChatMessage[]; `wire` touches Response, TextDecoder and byte streams. Keeping
+// them apart leaves the bring-your-own-transport consumer at zero cost, and
+// gives a future AG-UI format an obvious home. The cost is that importing both
+// entries ships state/parts.ts twice, about 2 KB.
+//
+// The kit PARSES. The consumer FETCHES. There is no client, no key handling and
+// no provider SDK anywhere below this file.
+
+export { readModelStream, readOpenAIStream, readAnthropicStream, WireError } from './read';
+export type { StreamSource, ReadOptions } from './read';
+
+export { consumeModelStream, createToolCallAccumulator } from './consume';
+export { applyToolOutput, applyToolFailure, bufferText } from './sink-helpers';
+
+export { toOpenAIMessages, toAnthropicMessages, WireEncodeError } from './encode';
+export type {
+  AnthropicContentBlock,
+  AnthropicWireMessage,
+  OpenAIEncodeOptions,
+  OpenAIReasoningDetail,
+  OpenAIToolCall,
+  OpenAIWireMessage,
+} from './encode';
+
+export { openaiChatFormat } from './formats/openai';
+export { anthropicMessagesFormat } from './formats/anthropic';
+
+export { sseDataFrames, sseJson, readableToAsyncIterable } from './sse';
+export type { ByteSource } from './sse';
+
+export { normalizeStopReason } from './chunk';
+export type {
+  AssistantStreamSink,
+  ConsumeOptions,
+  ModelStreamChunk,
+  ModelToolCall,
+  ModelToolCallDelta,
+  ModelTurn,
+  ModelUsage,
+  StopReason,
+  WireFormat,
+  WireFormatReader,
+} from './chunk';
+
+// The content-model types every signature above mentions, re-exported so a
+// consumer importing only from '@kitn.ai/ui/wire' can annotate the values these
+// functions take and return without a second import.
+export type { ChatMessage, MessagePart, MessageSource, RawOrigin } from '../elements/chat-types';
+export type { ToolPart } from '../components/tool-types';

package/src/wire/read.ts

@@ -0,0 +1,152 @@
+// The transport seam. The kit PARSES the stream; the consumer OWNS the
+// transport. Auth, proxies, retries, aborts and rate limits are app decisions,
+// so `StreamSource` is the entire surface: hand over a Response, a
+// ReadableStream, or any async iterable of bytes or strings.
+//
+// Deliberately absent: retries, reconnect, Last-Event-ID, backoff, an
+// AbortSignal parameter (abort the fetch), a URL-taking client, and key
+// handling. Untested retry logic is worse than none.
+//
+// SSR: nothing here references Response or ReadableStream at module scope. A
+// Response is detected by duck-typing, not `instanceof`, so this module imports
+// cleanly in a runtime where the global does not exist.
+import { sseJson, type ByteSource } from './sse';
+import { consumeModelStream } from './consume';
+import type {
+  AssistantStreamSink,
+  ConsumeOptions,
+  ModelStreamChunk,
+  ModelTurn,
+  WireFormat,
+} from './chunk';
+import { openaiChatFormat } from './formats/openai';
+import { anthropicMessagesFormat } from './formats/anthropic';
+
+export type StreamSource =
+  | Response
+  | ReadableStream<Uint8Array>
+  | AsyncIterable<Uint8Array | string>;
+
+export interface ReadOptions extends ConsumeOptions {
+  format: WireFormat;
+}
+
+/** A non-ok HTTP response from the model endpoint, with the provider's own error
+ *  body attached when there is one. Thrown before a single chunk is read, so a
+ *  caller can distinguish "the request failed" from "the stream carried an
+ *  error", which is `ModelTurn.error`. */
+export class WireError extends Error {
+  readonly status: number;
+  readonly statusText: string;
+  /** The response body parsed as JSON, or undefined when it was not JSON (an
+   *  HTML error page from a proxy, most often). */
+  readonly body: unknown;
+  /** The raw response body, always. */
+  readonly bodyText: string;
+
+  constructor(status: number, statusText: string, bodyText: string, body: unknown) {
+    super(buildMessage(status, statusText, bodyText, body));
+    // Restores the prototype chain when this class is DOWNLEVELLED to ES5 by a
+    // consumer's build. Without it `err instanceof WireError` is false there,
+    // and the documented way to tell a transport failure from an in-band error
+    // stops working. A no-op in the shipped ES2020+ output.
+    Object.setPrototypeOf(this, WireError.prototype);
+    this.name = 'WireError';
+    this.status = status;
+    this.statusText = statusText;
+    this.bodyText = bodyText;
+    this.body = body;
+  }
+}
+
+function providerMessage(body: unknown): string | undefined {
+  if (typeof body !== 'object' || body === null) return undefined;
+  const error = (body as { error?: unknown }).error;
+  if (typeof error === 'string') return error;
+  if (typeof error === 'object' && error !== null) {
+    const message = (error as { message?: unknown }).message;
+    if (typeof message === 'string') return message;
+  }
+  const top = (body as { message?: unknown }).message;
+  return typeof top === 'string' ? top : undefined;
+}
+
+function buildMessage(status: number, statusText: string, bodyText: string, body: unknown): string {
+  const head = `Model request failed: HTTP ${status}${statusText ? ` ${statusText}` : ''}`;
+  const provider = providerMessage(body);
+  if (provider) return `${head}: ${provider}`;
+  const snippet = bodyText.trim().slice(0, 200);
+  return snippet ? `${head}: ${snippet}` : head;
+}
+
+/** Duck-typed, because `Response` may not be a global in every runtime the kit
+ *  is imported into. A ReadableStream has no `ok`, and an async iterable that
+ *  happens to have all three of these is not a shape any transport produces. */
+function isResponse(source: StreamSource): source is Response {
+  return (
+    typeof source === 'object' &&
+    source !== null &&
+    'ok' in source &&
+    'status' in source &&
+    'body' in source
+  );
+}
+
+async function wireErrorFrom(res: Response): Promise<WireError> {
+  const bodyText = await res.text().catch(() => '');
+  let body: unknown;
+  try {
+    body = bodyText ? JSON.parse(bodyText) : undefined;
+  } catch {
+    body = undefined; // an HTML error page, or anything else non-JSON
+  }
+  return new WireError(res.status, res.statusText, bodyText, body);
+}
+
+async function toByteSource(source: StreamSource): Promise<ByteSource> {
+  if (!isResponse(source)) return source;
+  if (!source.ok) throw await wireErrorFrom(source);
+  if (!source.body) {
+    throw new Error(
+      'The model response has no body to stream. Check that the request set stream: true and that nothing between you and the provider buffered it.',
+    );
+  }
+  return source.body;
+}
+
+/** Read one turn off the wire in `opts.format` and drive `sink` with it. */
+export async function readModelStream(
+  source: StreamSource,
+  sink: AssistantStreamSink,
+  opts: ReadOptions,
+): Promise<ModelTurn> {
+  const bytes = await toByteSource(source);
+  // Opened ONCE per stream, which is the whole point of the open()/push() shape:
+  // a stateful format (Anthropic) gets a fresh block map per call.
+  const reader = opts.format.open();
+  async function* chunks(): AsyncGenerator<ModelStreamChunk> {
+    for await (const frame of sseJson<unknown>(bytes)) {
+      for (const chunk of reader.push(frame)) yield chunk;
+    }
+  }
+  return consumeModelStream(chunks(), sink, opts);
+}
+
+/** OpenAI chat-completions SSE. Also what all nine catalog integrations except
+ *  `mock` re-frame to server-side, so this is the common path. */
+export function readOpenAIStream(
+  source: StreamSource,
+  sink: AssistantStreamSink,
+  opts: ConsumeOptions = {},
+): Promise<ModelTurn> {
+  return readModelStream(source, sink, { ...opts, format: openaiChatFormat });
+}
+
+/** Anthropic Messages SSE. */
+export function readAnthropicStream(
+  source: StreamSource,
+  sink: AssistantStreamSink,
+  opts: ConsumeOptions = {},
+): Promise<ModelTurn> {
+  return readModelStream(source, sink, { ...opts, format: anthropicMessagesFormat });
+}