@codehz/ai 0.1.2 → 0.1.3

package/package.json

@@ -27,5 +27,5 @@
     "tsdown": "^0.22.3",
     "typescript": "^6"
   },
-  "version": "0.1.2"
+  "version": "0.1.3"
 }

package/src/adapters/chat-completions.ts

@@ -22,7 +22,7 @@ import {
 } from "../helpers/mapping.js";
 import { emitMalformedStreamWarning } from "../helpers/adapter-auxiliary.js";
 
-import type { AdapterCapabilities, NormalizedRequest, AIStreamEvent, EventFactory, OutputItem, FetchFn } from "../index.js";
+import type { NormalizedRequest, AIStreamEvent, EventFactory, OutputItem, FetchFn } from "../index.js";
 
 // ── 类型 ──────────────────────────────────────────────────────
 
@@ -249,29 +249,12 @@ function buildAssistantReplayMessage(params: {
 
 export class ChatCompletionsAdapter extends AdapterBase {
   readonly kind = "chat-completions" as const;
-  readonly capabilities: AdapterCapabilities = {
-    nativeStreaming: true,
-    messageStreaming: true,
-    reasoningStreaming: false,
-    toolCallStreaming: false,
-    hiddenReasoningReplay: "none" as const,
-    replayFidelity: "low" as const,
-    tools: true,
-    usage: "full" as const,
-    billing: "derived" as const,
-    providerMetadata: false,
-  };
+  readonly nativeStreaming = true;
 
   private apiKey: string;
   private baseUrl: string;
   private fetchFn: FetchFn;
 
-  private markReasoningCompatibility(): void {
-    this.capabilities.reasoningStreaming = true;
-    this.capabilities.hiddenReasoningReplay = "partial";
-    this.capabilities.replayFidelity = "medium";
-  }
-
   constructor(options: ChatCompletionsAdapterOptions) {
     super();
     this.apiKey = options.apiKey;
@@ -439,7 +422,6 @@ export class ChatCompletionsAdapter extends AdapterBase {
     let currentReasoningId = "";
     let hasMessageStarted = false;
     let hasReasoningStarted = false;
-    let hasStreamedReasoning = false;
 
     // tool_calls 累积: tool call index → { id, name, args }
     const pendingToolCalls = new Map<number, PendingToolCall>();
@@ -540,7 +522,6 @@ export class ChatCompletionsAdapter extends AdapterBase {
               if (!hasReasoningStarted) {
                 currentReasoningId = `reason-${chunk.id}`;
                 hasReasoningStarted = true;
-                hasStreamedReasoning = true;
                 accumulatedReasoning = "";
                 yield factory.reasoningStarted(currentReasoningId, "full");
               }
@@ -609,8 +590,6 @@ export class ChatCompletionsAdapter extends AdapterBase {
                 yield event;
               }
 
-              if (hasStreamedReasoning) this.markReasoningCompatibility();
-
               // 构建 stop reason
               const stopReason = mapStopReason(finishReason);
 
@@ -665,8 +644,6 @@ export class ChatCompletionsAdapter extends AdapterBase {
     if (hasMessageStarted || hasReasoningStarted || pendingToolCalls.size > 0) {
       yield factory.responseWarning("Stream ended without a finish_reason", "INCOMPLETE_STREAM");
 
-      if (hasStreamedReasoning) this.markReasoningCompatibility();
-
       const { events, assistantReplayMessage } = finalizePendingTurn();
       for (const event of events) {
         yield event;

package/src/adapters/index.ts

@@ -22,6 +22,7 @@ export type { OllamaAdapterOptions } from "./ollama.js";
 export { MockAdapter } from "./mock.js";
 export type {
   MockAdapterOptions,
+  MockTextStreamOptions,
   MockInputExpectation,
   MockRequestExpectation,
   MockTurnContext,

package/src/adapters/messages.ts

@@ -27,7 +27,6 @@ import { emitMalformedStreamWarning } from "../helpers/adapter-auxiliary.js";
 
 import { parseSSEEvents } from "../helpers/sse-parser.js";
 
-import { CAPABILITY_MATRIX } from "../index.js";
 import type { NormalizedRequest, AIStreamEvent, EventFactory, OutputItem, FetchFn } from "../index.js";
 
 // ── 类型 ──────────────────────────────────────────────────────
@@ -237,7 +236,7 @@ function buildStreamMetadata(options: {
 
 export class MessagesAdapter extends AdapterBase {
   readonly kind = "messages" as const;
-  readonly capabilities = CAPABILITY_MATRIX.messages;
+  readonly nativeStreaming = true;
 
   private apiKey: string;
   private apiVersion: string;

package/src/adapters/mock.ts

@@ -12,7 +12,6 @@
 import { AIRequestError } from "../core/errors.js";
 import { AdapterBase } from "../helpers/adapter-base.js";
 import { messageItem, reasoningItem, replayFromOutput, textBlock } from "../helpers/mapping.js";
-import { CAPABILITY_MATRIX } from "../types/adapter.js";
 
 import type {
   AIStreamEvent,
@@ -81,10 +80,26 @@ export type MockAuxiliaryStep = {
   auxiliary?: Partial<AuxiliaryInfo>;
 };
 
+export type MockTextStreamOptions = {
+  /**
+   * 每秒吐出的字符数。未设置时仍会按 chunk 拆分，但不会额外等待。
+   */
+  charsPerSecond?: number;
+  /**
+   * 每个 delta 最多包含多少个字符，默认 1。
+   */
+  chunkSize?: number;
+  /**
+   * 首个 delta 发出前的延迟。
+   */
+  initialDelayMs?: number;
+};
+
 export type MockMessageStep = {
   type: "message";
   id?: string;
   content: string | ContentBlock[];
+  stream?: MockTextStreamOptions | false;
 };
 
 export type MockReasoningStep = {
@@ -92,6 +107,7 @@ export type MockReasoningStep = {
   id?: string;
   visibility?: Extract<OutputItem, { type: "reasoning" }>["visibility"];
   content: string | ContentBlock[];
+  stream?: MockTextStreamOptions | false;
 };
 
 export type MockToolCallStep = {
@@ -101,11 +117,13 @@ export type MockToolCallStep = {
   argumentsText: string;
   argumentsJson?: unknown;
   streamArguments?: boolean;
+  stream?: MockTextStreamOptions | false;
 };
 
 export type MockOutputStep = {
   type: "output";
   item: Extract<OutputItem, { type: "message" | "reasoning" | "tool_call" }>;
+  stream?: MockTextStreamOptions | false;
 };
 
 export type MockCompleteStep = {
@@ -159,6 +177,7 @@ export type MockAdapterOptions = {
   turns: MockTurn[];
   onExhausted?: "throw" | "repeat-last" | "complete-empty";
   providerMetadata?: Record<string, unknown>;
+  stream?: MockTextStreamOptions;
 };
 
 type MockTurnRecord = {
@@ -177,13 +196,20 @@ type MockProviderRequest = {
   remainingPendingToolCalls: ToolCallItem[];
 };
 
+type ResolvedMockTextStreamOptions = {
+  charsPerSecond?: number;
+  chunkSize: number;
+  initialDelayMs: number;
+};
+
 export class MockAdapter extends AdapterBase {
   readonly kind = "mock" as const;
-  readonly capabilities = CAPABILITY_MATRIX.mock;
+  readonly nativeStreaming = false;
 
   private readonly turns: MockTurn[];
   private readonly onExhausted: NonNullable<MockAdapterOptions["onExhausted"]>;
   private readonly providerMetadata?: Record<string, unknown>;
+  private readonly defaultStream?: ResolvedMockTextStreamOptions;
 
   private cursor = 0;
   private previousReplay: ReplayItem[] = [];
@@ -196,6 +222,7 @@ export class MockAdapter extends AdapterBase {
     this.turns = options.turns;
     this.onExhausted = options.onExhausted ?? "throw";
     this.providerMetadata = options.providerMetadata;
+    this.defaultStream = resolveMockTextStreamOptions(options.stream, "adapter stream");
   }
 
   protected async buildRequest(request: NormalizedRequest): Promise<MockProviderRequest> {
@@ -254,26 +281,31 @@ export class MockAdapter extends AdapterBase {
             break;
           case "message": {
             const item = createMessageFromStep(step, request, mockRequest.turnIndex, stepIndex);
-            yield* emitMessage(factory, item);
+            yield* emitMessage(factory, item, resolveStepStreamOptions(this.defaultStream, step.stream, "message"));
             output.push(item);
             break;
           }
           case "reasoning": {
             const item = createReasoningFromStep(step, request, mockRequest.turnIndex, stepIndex);
-            yield* emitReasoning(factory, item);
+            yield* emitReasoning(factory, item, resolveStepStreamOptions(this.defaultStream, step.stream, "reasoning"));
             output.push(item);
             break;
           }
           case "tool_call": {
             const item = createToolCallFromStep(step);
-            yield* emitToolCall(factory, item, step.streamArguments ?? true);
+            yield* emitToolCall(
+              factory,
+              item,
+              step.streamArguments ?? true,
+              resolveStepStreamOptions(this.defaultStream, step.stream, "tool_call"),
+            );
             output.push(item);
             break;
           }
           case "output": {
             assertSupportedOutputItem(step.item);
             const item = attachSyntheticId(step.item, request, mockRequest.turnIndex, stepIndex);
-            yield* emitOutputItem(factory, item);
+            yield* emitOutputItem(factory, item, resolveStepStreamOptions(this.defaultStream, step.stream, "output"));
             output.push(item);
             break;
           }
@@ -464,30 +496,40 @@ function attachSyntheticId(
 async function* emitOutputItem(
   factory: EventFactory,
   item: Extract<OutputItem, { type: "message" | "reasoning" | "tool_call" }>,
+  stream?: ResolvedMockTextStreamOptions,
 ): AsyncIterable<AIStreamEvent> {
   if (item.type === "message") {
-    yield* emitMessage(factory, item);
+    yield* emitMessage(factory, item, stream);
     return;
   }
 
   if (item.type === "reasoning") {
-    yield* emitReasoning(factory, item);
+    yield* emitReasoning(factory, item, stream);
     return;
   }
 
-  yield* emitToolCall(factory, item, true);
+  yield* emitToolCall(factory, item, true, stream);
 }
 
-async function* emitMessage(factory: EventFactory, item: MessageItem): AsyncIterable<AIStreamEvent> {
+async function* emitMessage(
+  factory: EventFactory,
+  item: MessageItem,
+  stream?: ResolvedMockTextStreamOptions,
+): AsyncIterable<AIStreamEvent> {
   if (!item.id) {
     throw new AIRequestError("Mock message output requires an id after normalization", "MOCK_MESSAGE_ID_MISSING");
   }
 
   yield factory.messageStarted(item.id);
 
+  let chunkIndex = 0;
   for (const block of item.content) {
     if (block.type === "text") {
-      yield factory.messageDelta(item.id, block.text);
+      for (const chunk of chunkText(block.text, stream)) {
+        await delayForChunk(stream, chunkIndex, chunk.length);
+        yield factory.messageDelta(item.id, chunk);
+        chunkIndex += 1;
+      }
     }
   }
 
@@ -497,6 +539,7 @@ async function* emitMessage(factory: EventFactory, item: MessageItem): AsyncIter
 async function* emitReasoning(
   factory: EventFactory,
   item: Extract<OutputItem, { type: "reasoning" }>,
+  stream?: ResolvedMockTextStreamOptions,
 ): AsyncIterable<AIStreamEvent> {
   if (!item.id) {
     throw new AIRequestError("Mock reasoning output requires an id after normalization", "MOCK_REASONING_ID_MISSING");
@@ -504,8 +547,18 @@ async function* emitReasoning(
 
   yield factory.reasoningStarted(item.id, item.visibility);
 
+  let chunkIndex = 0;
   for (const block of item.content) {
-    yield factory.reasoningDelta(item.id, block);
+    if (block.type !== "text") {
+      yield factory.reasoningDelta(item.id, block);
+      continue;
+    }
+
+    for (const chunk of chunkText(block.text, stream)) {
+      await delayForChunk(stream, chunkIndex, chunk.length);
+      yield factory.reasoningDelta(item.id, textBlock(chunk));
+      chunkIndex += 1;
+    }
   }
 
   yield factory.reasoningCompleted(item);
@@ -515,16 +568,112 @@ async function* emitToolCall(
   factory: EventFactory,
   item: ToolCallItem,
   streamArguments: boolean,
+  stream?: ResolvedMockTextStreamOptions,
 ): AsyncIterable<AIStreamEvent> {
   yield factory.toolCallStarted(item.id, item.name);
 
   if (streamArguments && item.argumentsText) {
-    yield factory.toolCallDelta(item.id, { argumentsText: item.argumentsText });
+    let chunkIndex = 0;
+    for (const chunk of chunkText(item.argumentsText, stream)) {
+      await delayForChunk(stream, chunkIndex, chunk.length);
+      yield factory.toolCallDelta(item.id, { argumentsText: chunk });
+      chunkIndex += 1;
+    }
   }
 
   yield factory.toolCallCompleted(item);
 }
 
+function resolveStepStreamOptions(
+  defaults: ResolvedMockTextStreamOptions | undefined,
+  override: MockTextStreamOptions | false | undefined,
+  label: string,
+): ResolvedMockTextStreamOptions | undefined {
+  if (override === false) {
+    return undefined;
+  }
+
+  return resolveMockTextStreamOptions(override, `${label} stream`, defaults);
+}
+
+function resolveMockTextStreamOptions(
+  options: MockTextStreamOptions | undefined,
+  label: string,
+  defaults?: ResolvedMockTextStreamOptions,
+): ResolvedMockTextStreamOptions | undefined {
+  if (options === undefined) {
+    return defaults;
+  }
+
+  const chunkSize = options.chunkSize ?? defaults?.chunkSize ?? 1;
+  const initialDelayMs = options.initialDelayMs ?? defaults?.initialDelayMs ?? 0;
+  const charsPerSecond = options.charsPerSecond ?? defaults?.charsPerSecond;
+
+  if (!Number.isInteger(chunkSize) || chunkSize < 1) {
+    throw new AIRequestError(`${label}: chunkSize must be a positive integer`, "MOCK_STREAM_CONFIG_INVALID");
+  }
+
+  if (!Number.isFinite(initialDelayMs) || initialDelayMs < 0) {
+    throw new AIRequestError(`${label}: initialDelayMs must be a non-negative number`, "MOCK_STREAM_CONFIG_INVALID");
+  }
+
+  if (charsPerSecond !== undefined && (!Number.isFinite(charsPerSecond) || charsPerSecond <= 0)) {
+    throw new AIRequestError(`${label}: charsPerSecond must be a positive number`, "MOCK_STREAM_CONFIG_INVALID");
+  }
+
+  return {
+    chunkSize,
+    initialDelayMs,
+    charsPerSecond,
+  };
+}
+
+function chunkText(text: string, stream?: ResolvedMockTextStreamOptions): string[] {
+  if (!text) {
+    return [];
+  }
+
+  if (!stream) {
+    return [text];
+  }
+
+  const chars = Array.from(text);
+  const chunks: string[] = [];
+
+  for (let index = 0; index < chars.length; index += stream.chunkSize) {
+    chunks.push(chars.slice(index, index + stream.chunkSize).join(""));
+  }
+
+  return chunks;
+}
+
+async function delayForChunk(
+  stream: ResolvedMockTextStreamOptions | undefined,
+  chunkIndex: number,
+  chunkLength: number,
+): Promise<void> {
+  if (!stream) {
+    return;
+  }
+
+  if (chunkIndex === 0 && stream.initialDelayMs > 0) {
+    await sleep(stream.initialDelayMs);
+    return;
+  }
+
+  if (chunkIndex > 0 && stream.charsPerSecond !== undefined) {
+    await sleep((chunkLength / stream.charsPerSecond) * 1000);
+  }
+}
+
+async function sleep(ms: number): Promise<void> {
+  if (ms <= 0) {
+    return;
+  }
+
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 function resolveStopReason(output: OutputItem[]): StopReason {
   return output.some((item) => item.type === "tool_call") ? "tool_call" : "end_turn";
 }

package/src/adapters/ollama.ts

@@ -28,7 +28,7 @@ import {
 } from "../helpers/mapping.js";
 import { emitMalformedStreamWarning } from "../helpers/adapter-auxiliary.js";
 
-import type { AdapterCapabilities, NormalizedRequest, AIStreamEvent, EventFactory, OutputItem, FetchFn } from "../index.js";
+import type { NormalizedRequest, AIStreamEvent, EventFactory, OutputItem, FetchFn } from "../index.js";
 
 // ── 选项类型 ──────────────────────────────────────────────────
 
@@ -226,18 +226,7 @@ function isOllamaToolCalls(value: unknown): value is OllamaToolCall[] {
 
 export class OllamaAdapter extends AdapterBase {
   readonly kind = "ollama" as const;
-  readonly capabilities: AdapterCapabilities = {
-    nativeStreaming: true,
-    messageStreaming: true,
-    reasoningStreaming: false,
-    toolCallStreaming: false,
-    hiddenReasoningReplay: "none" as const,
-    replayFidelity: "low" as const,
-    tools: true,
-    usage: "partial" as const,
-    billing: "none" as const,
-    providerMetadata: false,
-  };
+  readonly nativeStreaming = true;
 
   private baseUrl: string;
   private apiKey: string | undefined;
@@ -406,7 +395,6 @@ export class OllamaAdapter extends AdapterBase {
 
     try {
       while (true) {
-        // oxlint-disable-next-line no-await-in-loop
         const { done, value } = await reader.read();
         if (done) break;
 
@@ -520,7 +508,6 @@ export class OllamaAdapter extends AdapterBase {
               );
             }
 
-            // oxlint-disable-next-line no-await-in-loop
             const auxiliaryResult = await auxiliary.finalize(factory);
             for (const event of auxiliaryResult.events) {
               yield event;

package/src/adapters/responses.ts

@@ -25,7 +25,6 @@ import { emitMalformedStreamWarning } from "../helpers/adapter-auxiliary.js";
 
 import { parseSSEEvents } from "../helpers/sse-parser.js";
 
-import { CAPABILITY_MATRIX } from "../index.js";
 import type { NormalizedRequest, AIStreamEvent, EventFactory, OutputItem, FetchFn } from "../index.js";
 
 // ── 类型 ──────────────────────────────────────────────────────
@@ -194,7 +193,7 @@ function canonicalToResponsesBlock(b: import("../index.js").ContentBlock): Respo
 
 export class ResponsesAdapter extends AdapterBase {
   readonly kind = "responses" as const;
-  readonly capabilities = CAPABILITY_MATRIX.responses;
+  readonly nativeStreaming = true;
 
   private apiKey: string;
   private baseUrl: string;

package/src/helpers/adapter-auxiliary.ts

@@ -1,7 +1,6 @@
 import { WarningCode } from "../core/errors.js";
 import type { EventFactory } from "../core/event-factory.js";
 import type {
-  AdapterCapabilities,
   AIStreamEvent,
   BillingInfo,
   NormalizedRequest,
@@ -18,7 +17,6 @@ export type BillingPostprocessHook = (context: {
   usage?: Usage;
   billing?: BillingInfo;
   auxiliary?: AuxiliaryInfo;
-  capabilities: AdapterCapabilities;
 }) => MaybePromise<Partial<BillingInfo> | undefined>;
 
 export type AuxiliaryFinalizeOptions = {
@@ -41,10 +39,7 @@ export class AdapterAuxiliaryState {
   private readonly collector = new AuxiliaryCollector();
   private readonly metadataSources = new Set<string>();
 
-  constructor(
-    private readonly request: NormalizedRequest,
-    private readonly capabilities: AdapterCapabilities,
-  ) {}
+  constructor(private readonly request: NormalizedRequest) {}
 
   recordUsage(usage: Partial<Usage>, source: UsageSource, raw?: unknown): void {
     if (this.request.include?.usage === "off" || isEmptyRecord(usage)) return;
@@ -75,7 +70,6 @@ export class AdapterAuxiliaryState {
           usage: snapshot.usage,
           billing: snapshot.billing,
           auxiliary: snapshot.auxiliary,
-          capabilities: this.capabilities,
         });
         if (derived && !isEmptyRecord(derived)) {
           this.collector.recordBilling(

package/src/helpers/adapter-base.ts

@@ -14,7 +14,6 @@
 import type {
   NormalizedRequest,
   BackendAdapter,
-  AdapterCapabilities,
   AIStreamEvent,
   AIResponse,
   AuxiliaryInfo,
@@ -56,7 +55,7 @@ export type StreamResult = {
 
 export abstract class AdapterBase implements BackendAdapter {
   abstract readonly kind: "chat-completions" | "messages" | "responses" | "ollama" | "mock";
-  abstract readonly capabilities: AdapterCapabilities;
+  abstract readonly nativeStreaming: boolean;
 
   /**
    * stream 模板方法：
@@ -67,7 +66,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.capabilities.nativeStreaming },
+      backend: { kind: this.kind, isSynthetic: !this.nativeStreaming },
     });
 
     yield factory.responseStarted(request.model);
@@ -130,7 +129,7 @@ export abstract class AdapterBase implements BackendAdapter {
         requestId: request.requestId,
         rawResponseId: result.rawResponseId,
         adapter: this.kind,
-        isSyntheticStream: !this.capabilities.nativeStreaming,
+        isSyntheticStream: !this.nativeStreaming,
         metadataSources: result.metadataSources,
         warnings,
       },
@@ -143,7 +142,7 @@ export abstract class AdapterBase implements BackendAdapter {
   }
 
   protected createAuxiliaryState(request: NormalizedRequest): AdapterAuxiliaryState {
-    return new AdapterAuxiliaryState(request, this.capabilities);
+    return new AdapterAuxiliaryState(request);
   }
 }
 

package/src/types/adapter.ts

@@ -2,7 +2,6 @@
  * BackendAdapter — adapter 内部协议和 client 公开类型
  *
  * adapter 对前台只暴露一个统一适配点。
- * 能力矩阵在此落成代码而非仅存在于文档。
  */
 
 import type { AIRequest } from "./request.js";
@@ -20,91 +19,11 @@ export type NormalizedRequest = AIRequest & {
   requestId: string;
 };
 
-// ── 能力矩阵 ──────────────────────────────────────────────────
-
-export type AdapterCapabilities = {
-  nativeStreaming: boolean;
-  messageStreaming: boolean;
-  reasoningStreaming: boolean;
-  toolCallStreaming: boolean;
-  hiddenReasoningReplay: "full" | "partial" | "none";
-  replayFidelity: "high" | "medium" | "low";
-  tools: boolean;
-  usage: "full" | "partial" | "none";
-  billing: "direct" | "lookup" | "derived" | "none";
-  providerMetadata: boolean;
-};
-
-// ── 能力矩阵常量（文档中的能力表在此落代码） ────────────────
-
-export const CAPABILITY_MATRIX = {
-  responses: {
-    nativeStreaming: true,
-    messageStreaming: true,
-    reasoningStreaming: true,
-    toolCallStreaming: true,
-    hiddenReasoningReplay: "full" as const,
-    replayFidelity: "high" as const,
-    tools: true,
-    usage: "full" as const,
-    billing: "lookup" as const,
-    providerMetadata: true,
-  },
-  messages: {
-    nativeStreaming: true,
-    messageStreaming: true,
-    reasoningStreaming: false, // 条件支持，默认 false
-    toolCallStreaming: true,
-    hiddenReasoningReplay: "partial" as const,
-    replayFidelity: "medium" as const,
-    tools: true,
-    usage: "full" as const,
-    billing: "lookup" as const,
-    providerMetadata: true,
-  },
-  "chat.completions": {
-    nativeStreaming: true,
-    messageStreaming: true,
-    reasoningStreaming: false,
-    toolCallStreaming: false, // 中，默认 false
-    hiddenReasoningReplay: "none" as const,
-    replayFidelity: "low" as const,
-    tools: true,
-    usage: "full" as const,
-    billing: "derived" as const,
-    providerMetadata: false,
-  },
-  ollama: {
-    nativeStreaming: true,
-    messageStreaming: true,
-    reasoningStreaming: false,
-    toolCallStreaming: false,
-    hiddenReasoningReplay: "none" as const,
-    replayFidelity: "low" as const,
-    tools: true,
-    usage: "partial" as const,
-    billing: "none" as const,
-    providerMetadata: false,
-  },
-  mock: {
-    nativeStreaming: false,
-    messageStreaming: true,
-    reasoningStreaming: false,
-    toolCallStreaming: true,
-    hiddenReasoningReplay: "none" as const,
-    replayFidelity: "high" as const,
-    tools: true,
-    usage: "none" as const,
-    billing: "none" as const,
-    providerMetadata: true,
-  },
-} as const satisfies Record<string, AdapterCapabilities>;
-
 // ── Adapter 接口 ──────────────────────────────────────────────
 
 export interface BackendAdapter {
   readonly kind: "chat-completions" | "messages" | "responses" | "ollama" | "mock";
-  readonly capabilities: AdapterCapabilities;
+  readonly nativeStreaming: boolean;
   stream(request: NormalizedRequest): AsyncIterable<AIStreamEvent>;
 }
 

package/src/types/index.ts

@@ -48,12 +48,8 @@ export type {
 // Adapter 协议和 client 类型
 export type {
   BackendAdapter,
-  AdapterCapabilities,
   FetchFn,
   NormalizedRequest,
   CreateAIClientOptions,
   AIClient,
 } from "./adapter.js";
-
-// 能力矩阵常量
-export { CAPABILITY_MATRIX } from "./adapter.js";