@codehz/ai 0.1.3 → 0.1.4

package/README.md

@@ -1,6 +1,6 @@
 # nano-ai
 
-统一流式 AI 客户端，提供一套 canonical API，对接真实模型后端与面向测试的脚本化 `MockAdapter`（`responses` / `messages` / `chat.completions` / `ollama` / `mock`）。
+统一流式 AI 客户端，提供一套 canonical API，对接真实模型后端与面向测试的回调驱动 `MockAdapter`（`responses` / `messages` / `chat.completions` / `ollama` / `mock`）。
 
 ## 安装
 
@@ -109,16 +109,23 @@ console.log(response.replay); // 续接材料
 
 ## 后端 Adapter
 
-| Adapter                 | 类                       | 说明                     |
-| ----------------------- | ------------------------ | ------------------------ |
-| OpenAI Responses API    | `ResponsesAdapter`       | OpenAI Responses 端点    |
-| Anthropic Messages API  | `MessagesAdapter`        | Anthropic Messages 端点  |
-| OpenAI Chat Completions | `ChatCompletionsAdapter` | Chat Completions 端点    |
-| Ollama Chat API         | `OllamaAdapter`          | 本地或自托管 Ollama      |
-| Scripted Test Backend   | `MockAdapter`            | 脚本化测试夹具           |
+| Adapter                 | 类                       | 说明                    |
+| ----------------------- | ------------------------ | ----------------------- |
+| OpenAI Responses API    | `ResponsesAdapter`       | OpenAI Responses 端点   |
+| Anthropic Messages API  | `MessagesAdapter`        | Anthropic Messages 端点 |
+| OpenAI Chat Completions | `ChatCompletionsAdapter` | Chat Completions 端点   |
+| Ollama Chat API         | `OllamaAdapter`          | 本地或自托管 Ollama     |
+| Scripted Test Backend   | `MockAdapter`            | 脚本化测试夹具          |
 
 ```ts
-import { ResponsesAdapter, MessagesAdapter, ChatCompletionsAdapter, OllamaAdapter, MockAdapter } from "nano-ai";
+import {
+  ResponsesAdapter,
+  MessagesAdapter,
+  ChatCompletionsAdapter,
+  OllamaAdapter,
+  MockAdapter,
+  withMockStreaming,
+} from "nano-ai";
 
 // OpenAI Responses API
 const responses = new ResponsesAdapter({ apiKey: "sk-..." });
@@ -132,25 +139,23 @@ const chat = new ChatCompletionsAdapter({ apiKey: "sk-..." });
 // Ollama
 const ollama = new OllamaAdapter({ baseUrl: "http://localhost:11434" });
 
-// 面向测试的脚本化 mock backend
+// 面向测试的回调驱动 mock backend
 const mock = new MockAdapter({
-  stream: {
-    charsPerSecond: 24,
-    chunkSize: 1,
-  },
-  turns: [
+  handler: withMockStreaming(
+    async function* () {
+      yield { type: "message", content: "我先调用天气工具。" };
+      yield {
+        type: "tool_call",
+        id: "mock-call-weather",
+        name: "get_weather",
+        argumentsText: '{"city":"Hangzhou"}',
+      };
+    },
     {
-      steps: [
-        { type: "message", content: "我先调用天气工具。" },
-        {
-          type: "tool_call",
-          id: "mock-call-weather",
-          name: "get_weather",
-          argumentsText: '{"city":"Hangzhou"}',
-        },
-      ],
+      charsPerSecond: 24,
+      chunkSize: 1,
     },
-  ],
+  ),
 });
 ```
 
@@ -165,66 +170,71 @@ adapter.nativeStreaming; // 是否为 provider 原生流，而不是本地模拟
 
 ## Mock 后端
 
-`MockAdapter` 是一个面向测试的脚本化 adapter，用来验证长流程工具调用、`replay` 续接和异常路径。
+`MockAdapter` 是一个面向测试的回调驱动 adapter，用来验证长流程工具调用、`replay` 续接和异常路径。
 
-如果你要调试前端逐字渲染效果，可以给 `MockAdapter` 打开分片流：
+如果你要调试前端逐字渲染效果，可以用 `withMockStreaming()` 给非流式 handler 包一层分片输出：
 
 ```ts
-const mock = new MockAdapter({
-  stream: {
+const handler = withMockStreaming(
+  async function* () {
+    yield { type: "message", content: "Streaming preview for the frontend." };
+  },
+  {
     charsPerSecond: 20, // 每秒约 20 个字符
     chunkSize: 1, // 默认 1，即逐字输出
     initialDelayMs: 150, // 可选：首字前停顿
   },
-  turns: [
-    {
-      steps: [{ type: "message", content: "Streaming preview for the frontend." }],
-    },
-  ],
-});
+);
 ```
 
-默认会发出单个完整 `message.delta`。只有显式配置 `stream` 时，`message` / `reasoning` / `tool_call` 参数才会被拆成多个 delta。单个 step 也可用 `stream: false` 关闭全局流速配置。
+默认会发出单个完整 `message.delta`。只有经 `withMockStreaming()` 注入默认流速后，`message` / `reasoning` / `tool_call` 参数才会被拆成多个 delta。单个 step 也可用 `stream: false` 关闭包装器的默认流速配置。
 
-核心思路是按 turn 写脚本：
+核心思路是每轮请求执行一次 handler：
 
-- 每一轮可声明对请求格式的期望
-- 每一轮可脚本化发出 `message` / `reasoning` / `tool_call`
+- handler 会拿到 `request` 和 `context`
+- `context` 内建 `previousReplay`、`pendingToolCalls`、`history`
+- handler 可脚本化发出 `message` / `reasoning` / `tool_call`
 - 可注入 `warning`、`content_filter`、transport interruption、provider-style error
-- 可验证调用方是否把上一轮 `replay` 和当前 `tool_result` 正确带回
+- 可用 `assertMockRequest()` 验证调用方是否把上一轮 `replay` 和当前 `tool_result` 正确带回
 
 ```ts
-import { createAIClient, MockAdapter } from "nano-ai";
+import { assertMockRequest, createAIClient, MockAdapter } from "nano-ai";
 
 const client = createAIClient({
   adapter: new MockAdapter({
-    turns: [
-      {
-        name: "request-tool",
-        expect: {
-          items: [{ type: "message", role: "user", textIncludes: "weather" }],
-          tools: "present",
-          toolChoice: "present",
-        },
-        steps: [
-          { type: "message", content: "Checking weather now." },
+    handler: async function* (request, context) {
+      if (context.turnIndex === 0) {
+        assertMockRequest(
+          request,
           {
-            type: "tool_call",
-            id: "mock-call-weather",
-            name: "get_weather",
-            argumentsText: '{"city":"Hangzhou"}',
+            items: [{ type: "message", role: "user", textIncludes: "weather" }],
+            tools: "present",
+            toolChoice: "present",
           },
-        ],
-      },
-      {
-        name: "consume-tool-result",
-        expect: {
+          context,
+        );
+
+        yield { type: "message", content: "Checking weather now." };
+        yield {
+          type: "tool_call",
+          id: "mock-call-weather",
+          name: "get_weather",
+          argumentsText: '{"city":"Hangzhou"}',
+        };
+        return;
+      }
+
+      assertMockRequest(
+        request,
+        {
           requireReplayFromPreviousTurn: true,
           requireToolResultsForPendingCalls: true,
         },
-        steps: [{ type: "message", content: "Hangzhou is 28C and sunny." }],
-      },
-    ],
+        context,
+      );
+
+      yield { type: "message", content: "Hangzhou is 28C and sunny." };
+    },
   }),
   model: "mock-model",
 });
@@ -233,10 +243,13 @@ const client = createAIClient({
 核心类型：
 
 ```ts
-type MockTurn = {
-  name?: string;
-  expect?: MockRequestExpectation | MockTurnValidator;
-  steps: MockStep[];
+type MockHandler = (request: NormalizedRequest, context: MockHandlerContext) => AsyncIterable<MockStep>;
+
+type MockHandlerContext = {
+  turnIndex: number;
+  previousReplay: ReplayItem[];
+  pendingToolCalls: readonly ToolCallItem[];
+  history: readonly MockHistoryRecord[];
 };
 ```
 
@@ -248,21 +261,13 @@ type MockTurn = {
 畸形路径示例：
 
 ```ts
-{
-  steps: [
-    { type: "message", content: "partial answer" },
-    { type: "interrupt" }, // 不发 response.completed，collectStream() 应失败
-  ],
-}
+yield { type: "message", content: "partial answer" };
+yield { type: "interrupt" }; // 不发 response.completed，collectStream() 应失败
 ```
 
 ```ts
-{
-  steps: [
-    { type: "warning", message: "content filtered by policy", code: "CONTENT_FILTERED" },
-    { type: "complete", stopReason: "content_filter" },
-  ],
-}
+yield { type: "warning", message: "content filtered by policy", code: "CONTENT_FILTERED" };
+yield { type: "complete", stopReason: "content_filter" };
 ```
 
 ## 多轮对话

package/dist/index.d.mts

@@ -797,13 +797,18 @@ type MockRequestExpectation = {
   toolChoice?: "ignore" | "present" | "absent";
   items?: MockInputExpectation[];
 };
-type MockTurnContext = {
+type MockHistoryRecord = {
+  turnIndex: number;
+  requestId: string;
+  replay: ReplayItem[];
+  toolCalls: ToolCallItem[];
+};
+type MockHandlerContext = {
   turnIndex: number;
   previousReplay: ReplayItem[];
   pendingToolCalls: readonly ToolCallItem[];
-  history: readonly MockTurnRecord[];
+  history: readonly MockHistoryRecord[];
 };
-type MockTurnValidator = (request: NormalizedRequest, context: MockTurnContext) => void | Promise<void>;
 type MockWarningStep = {
   type: "warning";
   message: string;
@@ -886,38 +891,25 @@ type MockThrowStep = {
   error: string | Error;
 };
 type MockStep = MockWarningStep | MockAuxiliaryStep | MockMessageStep | MockReasoningStep | MockToolCallStep | MockOutputStep | MockCompleteStep | MockErrorStep | MockInterruptStep | MockThrowStep;
-type MockTurn = {
-  name?: string;
-  expect?: MockRequestExpectation | MockTurnValidator;
-  steps: MockStep[];
-};
+type MockHandler = (request: NormalizedRequest, context: MockHandlerContext) => AsyncIterable<MockStep>;
+type MockHandlerSource = Iterable<MockStep> | AsyncIterable<MockStep>;
+type MockStaticHandler = (request: NormalizedRequest, context: MockHandlerContext) => MockHandlerSource | Promise<MockHandlerSource>;
 type MockAdapterOptions = {
-  turns: MockTurn[];
-  onExhausted?: "throw" | "repeat-last" | "complete-empty";
+  handler: MockHandler;
   providerMetadata?: Record<string, unknown>;
-  stream?: MockTextStreamOptions;
-};
-type MockTurnRecord = {
-  turnIndex: number;
-  turnName?: string;
-  requestId: string;
-  replay: ReplayItem[];
-  toolCalls: ToolCallItem[];
 };
 type MockProviderRequest = {
   request: NormalizedRequest;
-  turn: MockTurn;
+  handlerResult: AsyncIterable<MockStep>;
   turnIndex: number;
-  turnName?: string;
   remainingPendingToolCalls: ToolCallItem[];
 };
+declare function assertMockRequest(request: NormalizedRequest, expectation: MockRequestExpectation, context: MockHandlerContext): void;
 declare class MockAdapter extends AdapterBase {
   readonly kind: "mock";
   readonly nativeStreaming = false;
-  private readonly turns;
-  private readonly onExhausted;
+  private readonly handler;
   private readonly providerMetadata?;
-  private readonly defaultStream?;
   private cursor;
   private previousReplay;
   private pendingToolCalls;
@@ -927,9 +919,9 @@ declare class MockAdapter extends AdapterBase {
   protected buildRequest(request: NormalizedRequest): Promise<MockProviderRequest>;
   protected runStream(providerRequest: unknown, factory: EventFactory, request: NormalizedRequest): AsyncIterable<AIStreamEvent>;
   private finalizeTurn;
-  private resolveTurn;
-  private buildTurnContext;
+  private buildHandlerContext;
 }
+declare function withMockStreaming(handler: MockStaticHandler, options: MockTextStreamOptions): MockHandler;
 //#endregion
 //#region src/helpers/mapping.d.ts
 declare function mapStopReason(providerReason: string): StopReason;
@@ -1051,5 +1043,5 @@ type SyntheticStreamOptions = {
  */
 declare function syntheticStream(options: SyntheticStreamOptions): AsyncIterable<AIStreamEvent>;
 //#endregion
-export { type AIClient, AIError, AIMappingError, AIProviderError, type AIRequest, AIRequestError, type AIResponse, AIStreamError, type AIStreamEvent, AdapterAuxiliaryState, AdapterBase, AuxiliaryCollector, type AuxiliaryFinalizeOptions, type AuxiliaryFinalizeResult, type AuxiliaryInfo, type BackendAdapter, type BackendTrace, type BillingInfo, type BillingPostprocessHook, type BillingSource, ChatCompletionsAdapter, type ChatCompletionsAdapterOptions, type ContentBlock, type CreateAIClientOptions, type EventFactory, type EventFactoryBackend, type EventFactoryState, type FetchFn, type IncludeSettings, type InputItem, type LookupResult, type MessageCompletedEvent, type MessageDeltaEvent, type MessageItem, type MessageStartedEvent, MessagesAdapter, type MessagesAdapterOptions, MockAdapter, type MockAdapterOptions, type MockAuxiliaryStep, type MockCompleteStep, type MockErrorStep, type MockInputExpectation, type MockInterruptStep, type MockMessageStep, type MockOutputStep, type MockReasoningStep, type MockRequestExpectation, type MockStep, type MockTextStreamOptions, type MockThrowStep, type MockToolCallStep, type MockTurn, type MockTurnContext, type MockTurnValidator, type MockWarningStep, type NormalizeOptions, type NormalizedRequest, OllamaAdapter, type OllamaAdapterOptions, type OpaqueItem, type OutputItem, type ReasoningCompletedEvent, type ReasoningDeltaEvent, type ReasoningItem, type ReasoningStartedEvent, type ReplayItem, type ResponseAuxiliaryEvent, type ResponseCompletedEvent, type ResponseStartedEvent, type ResponseWarningEvent, ResponsesAdapter, type ResponsesAdapterOptions, type SSEEvent, type StopReason, type StreamEventBase, type StreamResult, type SyntheticStreamOptions, type ToolCallCompletedEvent, type ToolCallDeltaEvent, type ToolCallItem, type ToolCallStartedEvent, type ToolChoice, type ToolDefinition, type ToolResultItem, type Usage, type UsageSource, type ValidationIssue, WarningCode, aggregateEvents, assertValidRequest, blockToText, collectStream, contentBlocksToText, createAIClient, createEventFactory, emitMalformedStreamWarning, extractText, imageBlock, instructionsToText, jsonBlock, mapReasoningVisibility, mapStopReason, messageItem, metadataSourceList, normalizeRequest, opaqueBlock, opaqueItem, parseSSEEvents, reasoningItem, replayFromOutput, syntheticStream, textBlock, toolCallItem, toolResultItem, validateRequest };
+export { type AIClient, AIError, AIMappingError, AIProviderError, type AIRequest, AIRequestError, type AIResponse, AIStreamError, type AIStreamEvent, AdapterAuxiliaryState, AdapterBase, AuxiliaryCollector, type AuxiliaryFinalizeOptions, type AuxiliaryFinalizeResult, type AuxiliaryInfo, type BackendAdapter, type BackendTrace, type BillingInfo, type BillingPostprocessHook, type BillingSource, ChatCompletionsAdapter, type ChatCompletionsAdapterOptions, type ContentBlock, type CreateAIClientOptions, type EventFactory, type EventFactoryBackend, type EventFactoryState, type FetchFn, type IncludeSettings, type InputItem, type LookupResult, type MessageCompletedEvent, type MessageDeltaEvent, type MessageItem, type MessageStartedEvent, MessagesAdapter, type MessagesAdapterOptions, MockAdapter, type MockAdapterOptions, type MockAuxiliaryStep, type MockCompleteStep, type MockErrorStep, type MockHandler, type MockHandlerContext, type MockHistoryRecord, type MockInputExpectation, type MockInterruptStep, type MockMessageStep, type MockOutputStep, type MockReasoningStep, type MockRequestExpectation, type MockStaticHandler, type MockStep, type MockTextStreamOptions, type MockThrowStep, type MockToolCallStep, type MockWarningStep, type NormalizeOptions, type NormalizedRequest, OllamaAdapter, type OllamaAdapterOptions, type OpaqueItem, type OutputItem, type ReasoningCompletedEvent, type ReasoningDeltaEvent, type ReasoningItem, type ReasoningStartedEvent, type ReplayItem, type ResponseAuxiliaryEvent, type ResponseCompletedEvent, type ResponseStartedEvent, type ResponseWarningEvent, ResponsesAdapter, type ResponsesAdapterOptions, type SSEEvent, type StopReason, type StreamEventBase, type StreamResult, type SyntheticStreamOptions, type ToolCallCompletedEvent, type ToolCallDeltaEvent, type ToolCallItem, type ToolCallStartedEvent, type ToolChoice, type ToolDefinition, type ToolResultItem, type Usage, type UsageSource, type ValidationIssue, WarningCode, aggregateEvents, assertMockRequest, assertValidRequest, blockToText, collectStream, contentBlocksToText, createAIClient, createEventFactory, emitMalformedStreamWarning, extractText, imageBlock, instructionsToText, jsonBlock, mapReasoningVisibility, mapStopReason, messageItem, metadataSourceList, normalizeRequest, opaqueBlock, opaqueItem, parseSSEEvents, reasoningItem, replayFromOutput, syntheticStream, textBlock, toolCallItem, toolResultItem, validateRequest, withMockStreaming };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -2511,20 +2511,35 @@ var OllamaAdapter = class extends AdapterBase {
 /**
 * Mock Adapter
 *
-* 面向测试的脚本化 adapter：
-* - 按 turn 顺序消费请求，验证调用方是否正确续接 replay / tool_result
+* 面向测试的回调驱动 adapter：
+* - 每次请求执行用户提供的 handler
+* - 验证调用方是否正确续接 replay / tool_result
 * - 发出可控的 message / reasoning / tool_call 流
 * - 注入 warning / auxiliary / content_filter / 中断 / provider error
 *
 * 这不是通用“假模型”，而是测试工具调用编排与错误路径的测试夹具。
 */
+function assertMockRequest(request, expectation, context) {
+	const prefix = `MockAdapter turn ${context.turnIndex + 1} expectation failed`;
+	if (expectation.minItems !== void 0 && request.input.length < expectation.minItems) throw new AIRequestError(`${prefix}: expected at least ${expectation.minItems} input item(s)`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.maxItems !== void 0 && request.input.length > expectation.maxItems) throw new AIRequestError(`${prefix}: expected at most ${expectation.maxItems} input item(s)`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.tools === "present" && (!request.tools || request.tools.length === 0)) throw new AIRequestError(`${prefix}: expected tools to be present`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.tools === "absent" && request.tools && request.tools.length > 0) throw new AIRequestError(`${prefix}: expected tools to be absent`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.toolChoice === "present" && request.toolChoice === void 0) throw new AIRequestError(`${prefix}: expected toolChoice to be present`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.toolChoice === "absent" && request.toolChoice !== void 0) throw new AIRequestError(`${prefix}: expected toolChoice to be absent`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.requireReplayFromPreviousTurn && context.previousReplay.length > 0) assertReplayIncluded(request.input, context.previousReplay, prefix);
+	if (expectation.requireToolResultsForPendingCalls && context.pendingToolCalls.length > 0) {
+		const toolResultIds = new Set(request.input.filter((item) => item.type === "tool_result").map((item) => item.callId));
+		for (const call of context.pendingToolCalls) if (!toolResultIds.has(call.id)) throw new AIRequestError(`${prefix}: expected tool_result for pending tool call "${call.id}"`, "MOCK_EXPECTATION_FAILED");
+	}
+	if (expectation.items && expectation.items.length > 0) if (expectation.ordered) assertOrderedItems(request.input, expectation.items, prefix);
+	else assertUnorderedItems(request.input, expectation.items, prefix);
+}
 var MockAdapter = class extends AdapterBase {
 	kind = "mock";
 	nativeStreaming = false;
-	turns;
-	onExhausted;
+	handler;
 	providerMetadata;
-	defaultStream;
 	cursor = 0;
 	previousReplay = [];
 	pendingToolCalls = [];
@@ -2532,25 +2547,19 @@ var MockAdapter = class extends AdapterBase {
 	activeStream = false;
 	constructor(options) {
 		super();
-		this.turns = options.turns;
-		this.onExhausted = options.onExhausted ?? "throw";
+		this.handler = options.handler;
 		this.providerMetadata = options.providerMetadata;
-		this.defaultStream = resolveMockTextStreamOptions(options.stream, "adapter stream");
 	}
 	async buildRequest(request) {
 		const turnIndex = this.cursor;
-		const turn = this.resolveTurn(turnIndex);
-		const turnName = turn.name;
-		const context = this.buildTurnContext(turnIndex);
-		if (turn.expect) if (typeof turn.expect === "function") await turn.expect(request, context);
-		else assertRequestMatchesExpectation(request, turn.expect, context);
+		const context = this.buildHandlerContext(turnIndex);
 		const remainingPendingToolCalls = consumePendingToolCalls(this.pendingToolCalls, request.input);
+		const handlerResult = this.handler(request, context);
 		this.cursor += 1;
 		return {
 			request,
-			turn,
+			handlerResult,
 			turnIndex,
-			turnName,
 			remainingPendingToolCalls
 		};
 	}
@@ -2560,76 +2569,79 @@ var MockAdapter = class extends AdapterBase {
 		try {
 			const mockRequest = providerRequest;
 			const output = [];
-			for (const [stepIndex, step] of mockRequest.turn.steps.entries()) switch (step.type) {
-				case "warning":
-					yield factory.responseWarning(step.message, step.code);
-					break;
-				case "auxiliary":
-					yield factory.responseAuxiliary({
-						usage: step.usage,
-						billing: step.billing,
-						auxiliary: step.auxiliary
-					});
-					break;
-				case "message": {
-					const item = createMessageFromStep(step, request, mockRequest.turnIndex, stepIndex);
-					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, resolveStepStreamOptions(this.defaultStream, step.stream, "reasoning"));
-					output.push(item);
-					break;
-				}
-				case "tool_call": {
-					const item = createToolCallFromStep(step);
-					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, resolveStepStreamOptions(this.defaultStream, step.stream, "output"));
-					output.push(item);
-					break;
-				}
-				case "complete": {
-					const response = this.finalizeTurn(request, factory, mockRequest, output, step);
-					yield factory.responseCompleted(response);
-					return;
-				}
-				case "error": {
-					yield factory.responseWarning(step.message, step.code);
-					const response = this.finalizeTurn(request, factory, mockRequest, output, {
-						type: "complete",
-						stopReason: step.stopReason ?? "error",
-						providerMetadata: step.providerMetadata
-					});
-					yield factory.responseCompleted(response);
-					return;
+			let stepCount = 0;
+			for await (const step of mockRequest.handlerResult) {
+				stepCount += 1;
+				switch (step.type) {
+					case "warning":
+						yield factory.responseWarning(step.message, step.code);
+						break;
+					case "auxiliary":
+						yield factory.responseAuxiliary({
+							usage: step.usage,
+							billing: step.billing,
+							auxiliary: step.auxiliary
+						});
+						break;
+					case "message": {
+						const item = createMessageFromStep(step, request, mockRequest.turnIndex, stepCount - 1);
+						yield* emitMessage(factory, item, resolveStepStreamOptions(void 0, step.stream, "message"));
+						output.push(item);
+						break;
+					}
+					case "reasoning": {
+						const item = createReasoningFromStep(step, request, mockRequest.turnIndex, stepCount - 1);
+						yield* emitReasoning(factory, item, resolveStepStreamOptions(void 0, step.stream, "reasoning"));
+						output.push(item);
+						break;
+					}
+					case "tool_call": {
+						const item = createToolCallFromStep(step);
+						yield* emitToolCall(factory, item, step.streamArguments ?? true, resolveStepStreamOptions(void 0, step.stream, "tool_call"));
+						output.push(item);
+						break;
+					}
+					case "output": {
+						assertSupportedOutputItem(step.item);
+						const item = attachSyntheticId(step.item, request, mockRequest.turnIndex, stepCount - 1);
+						yield* emitOutputItem(factory, item, resolveStepStreamOptions(void 0, step.stream, "output"));
+						output.push(item);
+						break;
+					}
+					case "complete": {
+						const response = this.finalizeTurn(request, factory, mockRequest, output, step, stepCount);
+						yield factory.responseCompleted(response);
+						return;
+					}
+					case "error": {
+						yield factory.responseWarning(step.message, step.code);
+						const response = this.finalizeTurn(request, factory, mockRequest, output, {
+							type: "complete",
+							stopReason: step.stopReason ?? "error",
+							providerMetadata: step.providerMetadata
+						}, stepCount);
+						yield factory.responseCompleted(response);
+						return;
+					}
+					case "interrupt":
+						this.pendingToolCalls = mockRequest.remainingPendingToolCalls;
+						return;
+					case "throw": throw typeof step.error === "string" ? new Error(step.error) : step.error;
 				}
-				case "interrupt":
-					this.pendingToolCalls = mockRequest.remainingPendingToolCalls;
-					return;
-				case "throw": throw typeof step.error === "string" ? new Error(step.error) : step.error;
 			}
-			const response = this.finalizeTurn(request, factory, mockRequest, output, { type: "complete" });
+			const response = this.finalizeTurn(request, factory, mockRequest, output, { type: "complete" }, stepCount);
 			yield factory.responseCompleted(response);
 		} finally {
 			this.activeStream = false;
 		}
 	}
-	finalizeTurn(request, factory, mockRequest, output, completion) {
+	finalizeTurn(request, factory, mockRequest, output, completion, stepCount) {
 		const replay = completion.replay ?? replayFromOutput(output);
 		const toolCalls = output.filter((item) => item.type === "tool_call");
 		this.previousReplay = replay;
 		this.pendingToolCalls = [...mockRequest.remainingPendingToolCalls, ...toolCalls];
 		this.history.push({
 			turnIndex: mockRequest.turnIndex,
-			turnName: mockRequest.turnName,
 			requestId: request.requestId,
 			replay,
 			toolCalls
@@ -2643,8 +2655,7 @@ var MockAdapter = class extends AdapterBase {
 			auxiliary: completion.auxiliary,
 			providerMetadata: {
 				turnIndex: mockRequest.turnIndex,
-				turnName: mockRequest.turnName,
-				scriptedSteps: mockRequest.turn.steps.length,
+				stepCount,
 				pendingToolCallIds: this.pendingToolCalls.map((item) => item.id),
 				historyLength: this.history.length,
 				...this.providerMetadata,
@@ -2655,18 +2666,7 @@ var MockAdapter = class extends AdapterBase {
 			rawResponseId: completion.rawResponseId
 		}, factory);
 	}
-	resolveTurn(turnIndex) {
-		const turn = this.turns[turnIndex];
-		if (turn !== void 0) return turn;
-		const lastTurn = this.turns.at(-1);
-		if (this.onExhausted === "repeat-last" && lastTurn !== void 0) return lastTurn;
-		if (this.onExhausted === "complete-empty") return {
-			name: "exhausted",
-			steps: []
-		};
-		throw new AIRequestError(`MockAdapter turn ${turnIndex + 1} requested, but only ${this.turns.length} turn(s) were scripted`, "MOCK_TURN_EXHAUSTED");
-	}
-	buildTurnContext(turnIndex) {
+	buildHandlerContext(turnIndex) {
 		return {
 			turnIndex,
 			previousReplay: this.previousReplay.map(cloneItem),
@@ -2679,6 +2679,32 @@ var MockAdapter = class extends AdapterBase {
 		};
 	}
 };
+function withMockStreaming(handler, options) {
+	const defaults = resolveMockTextStreamOptions(options, "mock stream wrapper");
+	if (!defaults) throw new AIRequestError("mock stream wrapper requires streaming options", "MOCK_STREAM_CONFIG_INVALID");
+	return async function* streamWrappedHandler(request, context) {
+		const source = await handler(request, context);
+		for await (const step of source) yield applyDefaultStreaming(step, defaults);
+	};
+}
+function applyDefaultStreaming(step, defaults) {
+	switch (step.type) {
+		case "message":
+		case "reasoning":
+		case "tool_call":
+		case "output":
+			if (step.stream !== void 0) return step;
+			return {
+				...step,
+				stream: {
+					charsPerSecond: defaults.charsPerSecond,
+					chunkSize: defaults.chunkSize,
+					initialDelayMs: defaults.initialDelayMs
+				}
+			};
+		default: return step;
+	}
+}
 function createMessageFromStep(step, request, turnIndex, stepIndex) {
 	return {
 		...messageItem(normalizeBlocks(step.content), { id: step.id ?? `mock-msg-${request.requestId}-${turnIndex}-${stepIndex}` }),
@@ -2811,22 +2837,6 @@ function consumePendingToolCalls(pending, input) {
 	const fulfilledIds = new Set(input.filter((item) => item.type === "tool_result").map((item) => item.callId));
 	return pending.filter((item) => !fulfilledIds.has(item.id)).map(cloneItem);
 }
-function assertRequestMatchesExpectation(request, expectation, context) {
-	const prefix = `MockAdapter turn ${context.turnIndex + 1} expectation failed`;
-	if (expectation.minItems !== void 0 && request.input.length < expectation.minItems) throw new AIRequestError(`${prefix}: expected at least ${expectation.minItems} input item(s)`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.maxItems !== void 0 && request.input.length > expectation.maxItems) throw new AIRequestError(`${prefix}: expected at most ${expectation.maxItems} input item(s)`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.tools === "present" && (!request.tools || request.tools.length === 0)) throw new AIRequestError(`${prefix}: expected tools to be present`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.tools === "absent" && request.tools && request.tools.length > 0) throw new AIRequestError(`${prefix}: expected tools to be absent`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.toolChoice === "present" && request.toolChoice === void 0) throw new AIRequestError(`${prefix}: expected toolChoice to be present`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.toolChoice === "absent" && request.toolChoice !== void 0) throw new AIRequestError(`${prefix}: expected toolChoice to be absent`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.requireReplayFromPreviousTurn && context.previousReplay.length > 0) assertReplayIncluded(request.input, context.previousReplay, prefix);
-	if (expectation.requireToolResultsForPendingCalls && context.pendingToolCalls.length > 0) {
-		const toolResultIds = new Set(request.input.filter((item) => item.type === "tool_result").map((item) => item.callId));
-		for (const call of context.pendingToolCalls) if (!toolResultIds.has(call.id)) throw new AIRequestError(`${prefix}: expected tool_result for pending tool call "${call.id}"`, "MOCK_EXPECTATION_FAILED");
-	}
-	if (expectation.items && expectation.items.length > 0) if (expectation.ordered) assertOrderedItems(request.input, expectation.items, prefix);
-	else assertUnorderedItems(request.input, expectation.items, prefix);
-}
 function assertReplayIncluded(input, replay, prefix) {
 	const fingerprints = input.map(fingerprintItem);
 	let cursor = 0;
@@ -2993,6 +3003,6 @@ function* emitToolCallEvents(item, factory) {
 	yield factory.toolCallCompleted(item);
 }
 //#endregion
-export { AIError, AIMappingError, AIProviderError, AIRequestError, AIStreamError, AdapterAuxiliaryState, AdapterBase, AuxiliaryCollector, ChatCompletionsAdapter, MessagesAdapter, MockAdapter, OllamaAdapter, ResponsesAdapter, WarningCode, aggregateEvents, assertValidRequest, blockToText, collectStream, contentBlocksToText, createAIClient, createEventFactory, emitMalformedStreamWarning, extractText, imageBlock, instructionsToText, jsonBlock, mapReasoningVisibility, mapStopReason, messageItem, metadataSourceList, normalizeRequest, opaqueBlock, opaqueItem, parseSSEEvents, reasoningItem, replayFromOutput, syntheticStream, textBlock, toolCallItem, toolResultItem, validateRequest };
+export { AIError, AIMappingError, AIProviderError, AIRequestError, AIStreamError, AdapterAuxiliaryState, AdapterBase, AuxiliaryCollector, ChatCompletionsAdapter, MessagesAdapter, MockAdapter, OllamaAdapter, ResponsesAdapter, WarningCode, aggregateEvents, assertMockRequest, assertValidRequest, blockToText, collectStream, contentBlocksToText, createAIClient, createEventFactory, emitMalformedStreamWarning, extractText, imageBlock, instructionsToText, jsonBlock, mapReasoningVisibility, mapStopReason, messageItem, metadataSourceList, normalizeRequest, opaqueBlock, opaqueItem, parseSSEEvents, reasoningItem, replayFromOutput, syntheticStream, textBlock, toolCallItem, toolResultItem, validateRequest, withMockStreaming };
 
 //# sourceMappingURL=index.mjs.map