@codehz/ai 0.2.0 → 0.2.1

package/src/helpers/adapter-base.ts

@@ -25,10 +25,11 @@ import type {
   ToolCallItem,
 } from "../types/index.js";
 import { createEventFactory } from "../core/event-factory.js";
-import { AIMappingError, AIRequestError, AIStreamError } from "../core/errors.js";
+import { AIMappingError, AIProviderError, AIRequestError, AIStreamError } from "../core/errors.js";
 import type { EventFactory } from "../core/event-factory.js";
 import { extractText } from "./mapping.js";
 import { AdapterAuxiliaryState } from "./adapter-auxiliary.js";
+import { mergeAuxiliary } from "../core/merge-auxiliary.js";
 
 // ── Adapter 解析中间结果 ──────────────────────────────────────
 
@@ -55,7 +56,7 @@ export type StreamResult = {
 
 export abstract class AdapterBase implements BackendAdapter {
   abstract readonly kind: "chat-completions" | "messages" | "responses" | "ollama" | "mock";
-  abstract readonly nativeStreaming: boolean;
+  abstract readonly capabilities: import("../types/index.js").AdapterCapabilities;
 
   /**
    * stream 模板方法：
@@ -66,7 +67,7 @@ export abstract class AdapterBase implements BackendAdapter {
   async *stream(request: NormalizedRequest): AsyncIterable<AIStreamEvent> {
     const factory = createEventFactory({
       responseId: request.requestId,
-      backend: { kind: this.kind, isSynthetic: !this.nativeStreaming },
+      backend: { kind: this.kind, isSynthetic: this.capabilities.textStreaming === "synthetic" },
     });
 
     yield factory.responseStarted(request.model);
@@ -75,11 +76,26 @@ export abstract class AdapterBase implements BackendAdapter {
       const providerRequest = await this.buildRequest(request);
       yield* this.runStream(providerRequest, factory, request);
     } catch (err) {
-      if (err instanceof AIRequestError || err instanceof AIStreamError || err instanceof AIMappingError) {
+      if (err instanceof AIRequestError || err instanceof AIProviderError || err instanceof AIStreamError) {
         throw err;
       }
-      yield factory.responseWarning(err instanceof Error ? err.message : String(err), "PROVIDER_ERROR");
-      yield factory.responseCompleted(this.buildResponse(request, { output: [], replay: [] }, factory));
+
+      if (err instanceof AIMappingError) {
+        yield factory.responseWarning(err.message, "MAPPING_ERROR");
+        const errorResp = this.buildResponse(request, { output: [], replay: [] }, factory);
+        yield factory.responseCompleted({
+          replay: errorResp.replay,
+          stopReason: errorResp.stopReason,
+          trace: errorResp.backend,
+          usage: errorResp.usage,
+          billing: errorResp.billing,
+          auxiliary: errorResp.auxiliary,
+          warnings: errorResp.warnings,
+        });
+        return;
+      }
+
+      throw err;
     }
   }
 
@@ -132,7 +148,7 @@ export abstract class AdapterBase implements BackendAdapter {
         requestId: request.requestId,
         rawResponseId: result.rawResponseId,
         adapter: this.kind,
-        isSyntheticStream: !this.nativeStreaming,
+        isSyntheticStream: this.capabilities.textStreaming === "synthetic",
         metadataSources: result.metadataSources,
         warnings,
       },
@@ -149,24 +165,6 @@ export abstract class AdapterBase implements BackendAdapter {
   }
 }
 
-function mergeAuxiliary(base?: Partial<AuxiliaryInfo>, patch?: Partial<AuxiliaryInfo>): AuxiliaryInfo | undefined {
-  if (!base && !patch) return undefined;
-
-  const merged: AuxiliaryInfo = {
-    ...base,
-    ...patch,
-  };
-
-  if (base?.providerMetadata || patch?.providerMetadata) {
-    merged.providerMetadata = {
-      ...base?.providerMetadata,
-      ...patch?.providerMetadata,
-    };
-  }
-
-  return merged;
-}
-
 function mergeWarnings(...groups: Array<string[] | undefined>): string[] | undefined {
   const merged: string[] = [];
 

package/src/helpers/adapter-security.ts

@@ -0,0 +1,126 @@
+/**
+ * Adapter 边界安全辅助
+ *
+ * - opaque replay 入站 envelope（大小 / 深度）
+ * - provider HTTP 错误 body 出站脱敏
+ */
+
+import { AIProviderError, AIRequestError } from "../core/errors.js";
+
+export const MAX_OPAQUE_PAYLOAD_BYTES = 65536;
+export const MAX_OPAQUE_JSON_DEPTH = 8;
+export const PROVIDER_ERROR_MESSAGE_MAX_LEN = 500;
+export const PROVIDER_ERROR_RAW_BODY_THRESHOLD = 200;
+
+export type OpaqueEnvelopeResult = { ok: true } | { ok: false; reason: string };
+
+/** 测量 JSON 值嵌套深度（对象/数组）；循环引用按已访问节点深度计。 */
+export function measureJsonDepth(value: unknown, seen = new WeakSet<object>()): number {
+  if (value === null || typeof value !== "object") {
+    return 0;
+  }
+
+  if (seen.has(value)) {
+    return 0;
+  }
+  seen.add(value);
+
+  let maxChild = 0;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      maxChild = Math.max(maxChild, measureJsonDepth(item, seen));
+    }
+  } else {
+    for (const key of Object.keys(value as Record<string, unknown>)) {
+      maxChild = Math.max(maxChild, measureJsonDepth((value as Record<string, unknown>)[key], seen));
+    }
+  }
+
+  return 1 + maxChild;
+}
+
+/**
+ * Opaque replay 通用 envelope：必须是 object、体积 ≤ 64KB、深度 ≤ 8。
+ * 不校验 adapter 专用字段形状。
+ */
+export function validateOpaqueReplayEnvelope(payload: unknown): OpaqueEnvelopeResult {
+  if (typeof payload !== "object" || payload === null) {
+    return { ok: false, reason: "payload must be an object" };
+  }
+
+  let raw: string;
+  try {
+    raw = JSON.stringify(payload);
+  } catch {
+    return { ok: false, reason: "payload is not JSON-serializable" };
+  }
+
+  if (raw === undefined) {
+    return { ok: false, reason: "payload is not JSON-serializable" };
+  }
+
+  if (raw.length > MAX_OPAQUE_PAYLOAD_BYTES) {
+    return {
+      ok: false,
+      reason: `opaque payload exceeds max size (${raw.length} > ${MAX_OPAQUE_PAYLOAD_BYTES})`,
+    };
+  }
+
+  const depth = measureJsonDepth(payload);
+  if (depth > MAX_OPAQUE_JSON_DEPTH) {
+    return {
+      ok: false,
+      reason: `opaque payload nesting depth (${depth}) exceeds max (${MAX_OPAQUE_JSON_DEPTH})`,
+    };
+  }
+
+  return { ok: true };
+}
+
+/** envelope 失败时抛 AIRequestError。 */
+export function assertOpaqueReplayEnvelope(payload: unknown): void {
+  const result = validateOpaqueReplayEnvelope(payload);
+  if (!result.ok) {
+    throw new AIRequestError(`Invalid opaque replay payload: ${result.reason}`, "INVALID_OPAQUE_REPLAY");
+  }
+}
+
+/**
+ * 从 provider HTTP 错误 body 提取可对外暴露的短消息，避免泄漏 HTML / 内部路径等。
+ */
+export function extractProviderErrorMessage(body: string, status: number): string {
+  if (!body) return `HTTP ${status}`;
+
+  try {
+    const parsed: unknown = JSON.parse(body);
+    if (parsed && typeof parsed === "object") {
+      const record = parsed as Record<string, unknown>;
+      const errorField = record.error;
+      let msg: unknown;
+      if (errorField && typeof errorField === "object" && errorField !== null) {
+        msg = (errorField as Record<string, unknown>).message;
+      }
+      if (typeof msg !== "string") {
+        msg = typeof errorField === "string" ? errorField : record.message;
+      }
+      if (typeof msg === "string" && msg.length > 0) {
+        return msg.slice(0, PROVIDER_ERROR_MESSAGE_MAX_LEN);
+      }
+    }
+  } catch {
+    // not JSON
+  }
+
+  const trimmed = body.trimStart();
+  if (trimmed.startsWith("<!") || trimmed.startsWith("<html") || body.length > PROVIDER_ERROR_RAW_BODY_THRESHOLD) {
+    return `HTTP ${status}. Body omitted (${body.length} bytes)`;
+  }
+
+  return body.slice(0, PROVIDER_ERROR_MESSAGE_MAX_LEN);
+}
+
+/** 统一构造脱敏后的 AIProviderError。 */
+export function providerHttpError(status: number, body: string): AIProviderError {
+  const safe = extractProviderErrorMessage(body, status);
+  return new AIProviderError(`Provider returned ${status}: ${safe}`, "PROVIDER_ERROR", status, safe);
+}

package/src/helpers/incremental-stream-parser.ts

@@ -0,0 +1,84 @@
+export type StreamSplitResult = {
+  items: string[];
+  rest: string;
+};
+
+export type StreamParseResult<T> = { status: "parsed"; value: T } | { status: "ignored" } | { status: "malformed" };
+
+export class IncrementalStreamParser<T> {
+  private buffer = "";
+  private readonly decoder = new TextDecoder();
+
+  constructor(
+    private readonly split: (buffer: string, allowEOF: boolean) => StreamSplitResult,
+    private readonly parse: (item: string) => StreamParseResult<T>,
+  ) {}
+
+  feed(value: Uint8Array): { items: T[]; malformed: number } {
+    this.buffer += this.decoder.decode(value, { stream: true });
+    return this.consume(false);
+  }
+
+  flush(): { items: T[]; malformed: number } {
+    this.buffer += this.decoder.decode();
+    return this.consume(true);
+  }
+
+  getRemaining(): string {
+    return this.buffer;
+  }
+
+  private consume(allowEOF: boolean): { items: T[]; malformed: number } {
+    const split = this.split(this.buffer, allowEOF);
+    this.buffer = split.rest;
+    const items: T[] = [];
+    let malformed = 0;
+
+    for (const rawItem of split.items) {
+      const result = this.parse(rawItem);
+      if (result.status === "parsed") items.push(result.value);
+      else if (result.status === "malformed") malformed++;
+    }
+
+    return { items, malformed };
+  }
+}
+
+export function splitLines(buffer: string, allowEOF: boolean): StreamSplitResult {
+  const items: string[] = [];
+  let cursor = 0;
+
+  while (true) {
+    const lineEnd = buffer.indexOf("\n", cursor);
+    if (lineEnd === -1) break;
+    items.push(buffer.slice(cursor, lineEnd));
+    cursor = lineEnd + 1;
+  }
+
+  if (allowEOF && cursor < buffer.length) {
+    items.push(buffer.slice(cursor));
+    cursor = buffer.length;
+  }
+
+  return { items, rest: buffer.slice(cursor) };
+}
+
+export function splitSSEFrames(buffer: string, allowEOF: boolean): StreamSplitResult {
+  const normalized = buffer.replaceAll("\r\n", "\n");
+  const items: string[] = [];
+  let cursor = 0;
+
+  while (true) {
+    const frameEnd = normalized.indexOf("\n\n", cursor);
+    if (frameEnd === -1) break;
+    items.push(normalized.slice(cursor, frameEnd));
+    cursor = frameEnd + 2;
+  }
+
+  if (allowEOF && cursor < normalized.length) {
+    items.push(normalized.slice(cursor));
+    cursor = normalized.length;
+  }
+
+  return { items, rest: normalized.slice(cursor) };
+}

package/src/helpers/index.ts

@@ -40,3 +40,22 @@ export {
   usageFromOllama,
   usageFromOpenAIResponses,
 } from "./usage-mapping.js";
+
+export {
+  assertOpaqueReplayEnvelope,
+  extractProviderErrorMessage,
+  measureJsonDepth,
+  providerHttpError,
+  validateOpaqueReplayEnvelope,
+  MAX_OPAQUE_JSON_DEPTH,
+  MAX_OPAQUE_PAYLOAD_BYTES,
+  PROVIDER_ERROR_MESSAGE_MAX_LEN,
+  PROVIDER_ERROR_RAW_BODY_THRESHOLD,
+} from "./adapter-security.js";
+export type { OpaqueEnvelopeResult } from "./adapter-security.js";
+
+export { IncrementalStreamParser, splitLines, splitSSEFrames } from "./incremental-stream-parser.js";
+export type { StreamSplitResult, StreamParseResult } from "./incremental-stream-parser.js";
+
+export { NormalizedRequestMapper } from "./request-mapper.js";
+export type { ProviderProfile } from "./request-mapper.js";

package/src/helpers/request-mapper.ts

@@ -0,0 +1,72 @@
+import { AIRequestError } from "../core/errors.js";
+import { contentBlocksToText } from "./mapping.js";
+
+import type { AdapterCapabilities, ContentBlock, InstructionBlock, ToolResultItem } from "../types/index.js";
+
+export type ProviderProfile = {
+  readonly kind: string;
+  readonly instructionsMode: "system_message" | "instructions_field" | "none";
+  readonly supportedBlockTypes: ReadonlyArray<ContentBlock["type"]>;
+  readonly reasoningBlockTypes: ReadonlyArray<ContentBlock["type"]>;
+  readonly capabilities: AdapterCapabilities;
+};
+
+export class NormalizedRequestMapper {
+  constructor(readonly profile: ProviderProfile) {}
+
+  mapInstructions(instructions: string | InstructionBlock[]): string {
+    return typeof instructions === "string"
+      ? instructions
+      : contentBlocksToText(this.ensureTextBlocks(instructions, "instructions"));
+  }
+
+  ensureTextBlocks(blocks: ContentBlock[], field: string): ContentBlock[] {
+    return this.ensureBlocks(blocks, field, this.profile.supportedBlockTypes, "only text/json blocks are supported");
+  }
+
+  ensureReasoningBlocks(blocks: ContentBlock[], field: string): Array<Extract<ContentBlock, { type: "text" }>> {
+    return this.ensureBlocks(
+      blocks,
+      field,
+      this.profile.reasoningBlockTypes,
+      "reasoning only supports text blocks",
+    ) as Array<Extract<ContentBlock, { type: "text" }>>;
+  }
+
+  assertToolResultOutcome(outcome: ToolResultItem["outcome"]): void {
+    if (this.profile.capabilities.toolResultOutcomes.includes(outcome)) return;
+
+    const outcomes = this.profile.capabilities.toolResultOutcomes;
+    const supported = outcomes.map((value) => `"${value}"`).join(" and ");
+    const verb = outcomes.length > 1 ? "are" : "is";
+    throw new AIRequestError(
+      `${this.profile.kind} does not preserve tool_result outcome "${outcome}"; only ${supported} ${verb} supported`,
+      "UNSUPPORTED_TOOL_RESULT_OUTCOME",
+    );
+  }
+
+  rollbackTrailingAssistantMessages<T extends { role: string }>(messages: T[]): void {
+    while (messages.length > 0 && messages[messages.length - 1]?.role === "assistant") {
+      messages.pop();
+    }
+  }
+
+  private ensureBlocks(
+    blocks: ContentBlock[],
+    field: string,
+    supportedTypes: ReadonlyArray<ContentBlock["type"]>,
+    description: string,
+  ): ContentBlock[] {
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i];
+      if (block && !supportedTypes.includes(block.type)) {
+        throw new AIRequestError(
+          `${this.profile.kind} does not support ${field}[${i}] of type "${block.type}"; ${description}`,
+          "UNSUPPORTED_CONTENT_BLOCK",
+        );
+      }
+    }
+
+    return blocks;
+  }
+}

package/src/helpers/sse-parser.ts

@@ -27,6 +27,10 @@ export type SSEParseResult = {
   malformedEvents: number;
 };
 
+export type ParseSSEOptions = {
+  allowEOF?: boolean;
+};
+
 /**
  * 将 SSE 文本块解析为事件数组。
  * 累积事件行直到遇到空行，支持 [DONE] 标记。
@@ -37,7 +41,7 @@ export type SSEParseResult = {
  * - 未完成的行保留在 rest 中，等待下次 chunk 补全
  * - 支持跨 chunk 的 event 分片
  */
-export function parseSSEEvents(chunk: string): SSEParseResult {
+export function parseSSEEvents(chunk: string, options: ParseSSEOptions = {}): SSEParseResult {
   const events: SSEEvent[] = [];
   let eventType = "";
   let dataLines: string[] = [];
@@ -45,6 +49,39 @@ export function parseSSEEvents(chunk: string): SSEParseResult {
   let cursor = 0;
   let malformedEvents = 0;
 
+  const emitEvent = (consumedCursor: number): void => {
+    const dataStr = dataLines.join("\n");
+    if (dataStr === "[DONE]") {
+      eventType = "";
+      dataLines = [];
+      consumedUntil = consumedCursor;
+      return;
+    }
+
+    try {
+      const data = JSON.parse(dataStr);
+      events.push({ type: eventType, data });
+    } catch {
+      malformedEvents++;
+    }
+
+    eventType = "";
+    dataLines = [];
+    consumedUntil = consumedCursor;
+  };
+
+  const consumeLine = (line: string, consumedCursor: number): void => {
+    if (line.startsWith("event: ")) {
+      eventType = line.slice(7).trim();
+    } else if (line.startsWith("data: ")) {
+      dataLines.push(line.slice(6));
+    } else if (line === "" && eventType && dataLines.length > 0) {
+      emitEvent(consumedCursor);
+    } else if (line === "" && !eventType && dataLines.length === 0) {
+      consumedUntil = consumedCursor;
+    }
+  };
+
   while (cursor < chunk.length) {
     const lineEnd = chunk.indexOf("\n", cursor);
     if (lineEnd === -1) break;
@@ -56,31 +93,20 @@ export function parseSSEEvents(chunk: string): SSEParseResult {
       line = line.slice(0, -1);
     }
 
-    if (line.startsWith("event: ")) {
-      eventType = line.slice(7).trim();
-    } else if (line.startsWith("data: ")) {
-      dataLines.push(line.slice(6));
-    } else if (line === "" && eventType && dataLines.length > 0) {
-      // 完整的 event（以空行结尾）
-      const dataStr = dataLines.join("\n");
-      if (dataStr === "[DONE]") {
-        eventType = "";
-        dataLines = [];
-        consumedUntil = cursor;
-        continue;
-      }
-      try {
-        const data = JSON.parse(dataStr);
-        events.push({ type: eventType, data });
-      } catch {
-        malformedEvents++;
-      }
-      eventType = "";
-      dataLines = [];
-      consumedUntil = cursor;
-    } else if (line === "" && !eventType && dataLines.length === 0) {
-      consumedUntil = cursor;
+    consumeLine(line, cursor);
+  }
+
+  if (options.allowEOF && cursor < chunk.length) {
+    let line = chunk.slice(cursor);
+    if (line.endsWith("\r")) {
+      line = line.slice(0, -1);
     }
+    consumeLine(line, chunk.length);
+    cursor = chunk.length;
+  }
+
+  if (options.allowEOF && eventType && dataLines.length > 0) {
+    emitEvent(chunk.length);
   }
 
   return { events, rest: chunk.slice(consumedUntil), malformedEvents };

package/src/helpers/synthetic-stream.ts

@@ -14,7 +14,7 @@
  */
 
 import { createEventFactory } from "../core/event-factory.js";
-import { replayFromOutput, extractText } from "./mapping.js";
+import { replayFromOutput } from "./mapping.js";
 
 import type {
   OutputItem,
@@ -23,10 +23,10 @@ import type {
   Usage,
   BillingInfo,
   AIStreamEvent,
-  AIResponse,
   MessageItem,
   ReasoningItem,
   ToolCallItem,
+  OpaqueItem,
 } from "../types/index.js";
 
 // ── 输入参数 ──────────────────────────────────────────────────
@@ -99,7 +99,7 @@ export async function* syntheticStream(options: SyntheticStreamOptions): AsyncIt
     yield factory.responseAuxiliary({ usage, billing });
   }
 
-  // 4. 构建最终 response
+  // 4. 构建最终 completion 并发射
   const finalReplay = replay ?? replayFromOutput(output);
 
   // 收集警告
@@ -107,26 +107,22 @@ export async function* syntheticStream(options: SyntheticStreamOptions): AsyncIt
   allWarnings.push("Response is synthetically streamed; delta granularity may differ from native streaming");
   if (extraWarnings) allWarnings.push(...extraWarnings);
 
-  const response: AIResponse = {
-    id: responseId,
-    output,
+  yield factory.responseCompleted({
     replay: finalReplay,
-    text: extractText(output),
-    toolCalls: output.filter((item): item is ToolCallItem => item.type === "tool_call"),
     stopReason,
     usage,
     billing,
     auxiliary: providerMetadata ? { providerMetadata } : undefined,
+    opaqueOutput: output.filter((item): item is OpaqueItem => item.type === "opaque"),
     warnings: allWarnings.length > 0 ? allWarnings : undefined,
-    backend: {
+    trace: {
       requestId: responseId,
       rawResponseId,
       adapter: backend.kind,
       isSyntheticStream: true,
+      warnings: allWarnings.length > 0 ? allWarnings : undefined,
     },
-  };
-
-  yield factory.responseCompleted(response);
+  });
 }
 
 // ── Item 事件发射 ─────────────────────────────────────────────
@@ -156,12 +152,10 @@ function* emitMessageEvents(
   yield factory.messageStarted(id);
 
   for (const block of item.content) {
-    if (block.type === "text") {
-      yield factory.messageDelta(id, block.text);
-    }
+    yield factory.messageDelta(id, block);
   }
 
-  yield factory.messageCompleted(item);
+  yield factory.messageCompleted(id);
 }
 
 function* emitReasoningEvents(
@@ -172,12 +166,10 @@ function* emitReasoningEvents(
   yield factory.reasoningStarted(id, item.visibility);
 
   for (const block of item.content) {
-    if (block.type === "text") {
-      yield factory.reasoningDelta(id, block);
-    }
+    yield factory.reasoningDelta(id, block);
   }
 
-  yield factory.reasoningCompleted(item);
+  yield factory.reasoningCompleted(id);
 }
 
 function* emitToolCallEvents(
@@ -190,7 +182,7 @@ function* emitToolCallEvents(
     yield factory.toolCallDelta(item.id, { argumentsText: item.argumentsText });
   }
 
-  yield factory.toolCallCompleted(item);
+  yield factory.toolCallCompleted(item.id);
 }
 
 // ── Helper ────────────────────────────────────────────────────

package/src/helpers/usage-mapping.ts

@@ -88,8 +88,7 @@ export function usageFromAnthropicMessages(raw: {
     (n): n is number => n !== undefined,
   );
   const inputTokens = inputParts.length > 0 ? inputParts.reduce((sum, n) => sum + n, 0) : undefined;
-  const totalTokens =
-    inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined;
+  const totalTokens = inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined;
 
   return record({
     inputTokens,
@@ -101,18 +100,14 @@ export function usageFromAnthropicMessages(raw: {
 }
 
 /** Ollama 流式 chunk */
-export function usageFromOllama(raw: {
-  prompt_eval_count?: number;
-  eval_count?: number;
-}): Partial<Usage> {
+export function usageFromOllama(raw: { prompt_eval_count?: number; eval_count?: number }): Partial<Usage> {
   const inputTokens = num(raw.prompt_eval_count);
   const outputTokens = num(raw.eval_count);
-  const totalTokens =
-    inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined;
+  const totalTokens = inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined;
 
   return record({
     inputTokens,
     outputTokens,
     totalTokens,
   });
-}
+}

package/src/types/adapter.ts

@@ -21,9 +21,20 @@ export type NormalizedRequest = AIRequest & {
 
 // ── Adapter 接口 ──────────────────────────────────────────────
 
+export type StreamingCapability = "native" | "synthetic" | "none";
+
+export type AdapterCapabilities = {
+  readonly textStreaming: StreamingCapability;
+  readonly reasoningStreaming: StreamingCapability;
+  readonly toolCallStreaming: StreamingCapability;
+  readonly replay: "canonical" | "opaque" | "none";
+  readonly usage: "stream" | "final" | "none";
+  readonly toolResultOutcomes: ReadonlyArray<"success" | "error" | "rejected">;
+};
+
 export interface BackendAdapter {
   readonly kind: "chat-completions" | "messages" | "responses" | "ollama" | "mock";
-  readonly nativeStreaming: boolean;
+  readonly capabilities: AdapterCapabilities;
   stream(request: NormalizedRequest): AsyncIterable<AIStreamEvent>;
 }