@tanstack/ai-bedrock 0.1.4 → 0.1.6

package/dist/esm/adapters/converse-text.js

@@ -1,430 +1,414 @@
-import { EventType, convertSchemaToJsonSchema } from "@tanstack/ai";
-import { BaseTextAdapter } from "@tanstack/ai/adapters";
-import { toRunErrorPayload } from "@tanstack/ai/adapter-internals";
 import { resolveBedrockAuth } from "../utils/auth.js";
 import { toConverseMessages } from "../converse/message-converter.js";
 import { toToolConfig } from "../converse/tool-converter.js";
 import { processConverseStream, throwIfConverseStreamError } from "../converse/stream-processor.js";
-import { buildStructuredToolConfig, STRUCTURED_TOOL_NAME } from "../converse/structured-output.js";
-class BedrockConverseTextAdapter extends BaseTextAdapter {
-  kind = "text";
-  name = "bedrock-converse";
-  clientPromise;
-  clientConfig;
-  constructor(config, model) {
-    super({}, model);
-    this.clientConfig = config;
-  }
-  /**
-   * Dynamically import `@aws-sdk/client-bedrock-runtime`. The specifier is held
-   * in a variable (not a string literal) so bundler dep scanners (e.g. Vite/
-   * esbuild optimizeDeps) cannot statically discover the AWS SDK and try to
-   * pre-bundle it for the browser — it would fail on the SDK's Node-only
-   * `fromTokenFile` export chain. The SDK is Node/server-only and is only
-   * reached on a real request. `typeof import(...)` is a type-only reference
-   * (erased at emit) so the imported members keep full typing.
-   */
-  importBedrockRuntime() {
-    const mod = "@aws-sdk/client-bedrock-runtime";
-    return import(
-      /* @vite-ignore */
-      mod
-    );
-  }
-  /**
-   * Lazily construct the `BedrockRuntimeClient`. The dynamic import keeps
-   * `@aws-sdk/client-bedrock-runtime` out of the static/browser graph and
-   * defers `resolveBedrockAuth` until a real request is made.
-   */
-  async getClient() {
-    if (!this.clientPromise) {
-      this.clientPromise = (async () => {
-        const { BedrockRuntimeClient } = await this.importBedrockRuntime();
-        const region = this.clientConfig.region ?? "us-east-1";
-        const resolved = resolveBedrockAuth(
-          {
-            apiKey: this.clientConfig.apiKey,
-            region,
-            auth: this.clientConfig.auth
-          },
-          "runtime"
-        );
-        return new BedrockRuntimeClient(
-          this.buildClientConfig(resolved, region, this.clientConfig.baseURL)
-        );
-      })().catch((error) => {
-        this.clientPromise = void 0;
-        throw error;
-      });
-    }
-    return this.clientPromise;
-  }
-  /**
-   * Map resolved auth + endpoint to a `BedrockRuntimeClientConfig`.
-   *
-   * Recent `@aws-sdk/client-bedrock-runtime` exposes a first-class `token`
-   * config field for Bedrock API-key bearer auth. But the client's default
-   * auth-scheme order is SigV4 first, then bearer — so passing `token` alone is
-   * not enough: the SDK still resolves SigV4 and throws "Could not load
-   * credentials from any providers". Pinning `authSchemePreference` to the
-   * bearer scheme makes the API key actually get used. SigV4 uses the AWS
-   * credential provider chain and the default scheme order.
-   */
-  buildClientConfig(resolved, region, endpoint) {
-    if (resolved.kind === "bearer") {
-      return {
-        region,
-        token: { token: resolved.token },
-        authSchemePreference: ["httpBearerAuth"],
-        ...endpoint ? { endpoint } : {}
-      };
-    }
-    return {
-      region: resolved.region,
-      credentials: resolved.credentials,
-      ...endpoint ? { endpoint } : {}
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // SDK seams (overridden in tests so no real AWS call happens)
-  // ---------------------------------------------------------------------------
-  async sendStream(input) {
-    const { ConverseStreamCommand } = await this.importBedrockRuntime();
-    const client = await this.getClient();
-    const res = await client.send(new ConverseStreamCommand(input));
-    if (!res.stream) {
-      throw new Error("Bedrock Converse: empty stream response");
-    }
-    return res.stream;
-  }
-  async send(input) {
-    const { ConverseCommand } = await this.importBedrockRuntime();
-    const client = await this.getClient();
-    return client.send(new ConverseCommand(input));
-  }
-  // ---------------------------------------------------------------------------
-  // Public adapter surface
-  // ---------------------------------------------------------------------------
-  async *chatStream(options) {
-    try {
-      options.logger.request(
-        `activity=chat provider=${this.name} model=${this.model} messages=${options.messages.length} tools=${options.tools?.length ?? 0} stream=true`,
-        { provider: this.name, model: this.model }
-      );
-      const input = this.buildInput(options);
-      const stream = await this.sendStream(input);
-      yield* processConverseStream(stream, () => this.generateId(), {
-        threadId: options.threadId,
-        parentRunId: options.parentRunId,
-        model: options.model
-      });
-    } catch (error) {
-      const errorPayload = toRunErrorPayload(
-        error,
-        `${this.name}.chatStream failed`
-      );
-      options.logger.errors(`${this.name}.chatStream fatal`, {
-        error: errorPayload,
-        source: `${this.name}.chatStream`
-      });
-      yield {
-        type: EventType.RUN_ERROR,
-        model: options.model,
-        timestamp: Date.now(),
-        message: errorPayload.message,
-        ...errorPayload.code !== void 0 && { code: errorPayload.code },
-        error: {
-          message: errorPayload.message,
-          ...errorPayload.code !== void 0 && { code: errorPayload.code }
-        }
-      };
-    }
-  }
-  /**
-   * Structured output via the forced-tool strategy. Converse has no native
-   * json_schema response_format, so we force a single tool whose input schema
-   * is the requested output schema and read the model's `toolUse.input` back as
-   * the structured result.
-   */
-  async structuredOutput(options) {
-    const { chatOptions, outputSchema } = options;
-    try {
-      chatOptions.logger.request(
-        `activity=structuredOutput provider=${this.name} model=${this.model} messages=${chatOptions.messages.length}`,
-        { provider: this.name, model: this.model }
-      );
-      const input = {
-        ...this.buildInput(chatOptions),
-        toolConfig: buildStructuredToolConfig(outputSchema)
-      };
-      const res = await this.send(input);
-      const structured = extractStructuredToolInput(res);
-      if (structured === void 0) {
-        throw new Error(
-          `${this.name}.structuredOutput: response contained no forced-tool output`
-        );
-      }
-      return {
-        data: structured,
-        rawText: JSON.stringify(structured)
-      };
-    } catch (error) {
-      chatOptions.logger.errors(`${this.name}.structuredOutput fatal`, {
-        error: toRunErrorPayload(error, `${this.name}.structuredOutput failed`),
-        source: `${this.name}.structuredOutput`
-      });
-      throw error;
-    }
-  }
-  /**
-   * Streaming structured output. Same forced-tool strategy as
-   * `structuredOutput`, but streamed: the forced tool's `toolUse.input` JSON
-   * fragments are accumulated from the Converse stream and a terminal
-   * `CUSTOM 'structured-output.complete'` event carries `{ object, raw }`,
-   * mirroring openai-base's `structuredOutputStream` contract exactly.
-   */
-  async *structuredOutputStream(options) {
-    const { chatOptions, outputSchema } = options;
-    const timestamp = Date.now();
-    const runId = this.generateId();
-    const threadId = chatOptions.threadId ?? this.generateId();
-    const messageId = this.generateId();
-    let hasEmittedRunStarted = false;
-    let hasEmittedTextMessageStart = false;
-    let accumulatedRaw = "";
-    let finishReason = "stop";
-    try {
-      chatOptions.logger.request(
-        `activity=structuredOutputStream provider=${this.name} model=${this.model} messages=${chatOptions.messages.length}`,
-        { provider: this.name, model: this.model }
-      );
-      const input = {
-        ...this.buildInput(chatOptions),
-        toolConfig: buildStructuredToolConfig(outputSchema)
-      };
-      const stream = await this.sendStream(input);
-      for await (const ev of stream) {
-        if (!hasEmittedRunStarted) {
-          hasEmittedRunStarted = true;
-          yield {
-            type: EventType.RUN_STARTED,
-            runId,
-            threadId,
-            model: chatOptions.model,
-            timestamp,
-            parentRunId: chatOptions.parentRunId
-          };
-        }
-        throwIfConverseStreamError(ev);
-        if ("contentBlockDelta" in ev) {
-          const delta = ev.contentBlockDelta?.delta;
-          const fragment = delta && "toolUse" in delta ? delta.toolUse?.input : void 0;
-          if (fragment !== void 0) {
-            if (!hasEmittedTextMessageStart) {
-              hasEmittedTextMessageStart = true;
-              yield {
-                type: EventType.TEXT_MESSAGE_START,
-                messageId,
-                role: "assistant",
-                model: chatOptions.model,
-                timestamp
-              };
-            }
-            accumulatedRaw += fragment;
-            yield {
-              type: EventType.TEXT_MESSAGE_CONTENT,
-              messageId,
-              delta: fragment,
-              content: accumulatedRaw,
-              model: chatOptions.model,
-              timestamp
-            };
-          }
-          continue;
-        }
-        if ("messageStop" in ev) {
-          const stopReason = ev.messageStop?.stopReason;
-          finishReason = stopReason === "max_tokens" ? "length" : stopReason === "content_filtered" ? "content_filter" : "stop";
-          continue;
-        }
-      }
-      if (!hasEmittedRunStarted) {
-        hasEmittedRunStarted = true;
-        yield {
-          type: EventType.RUN_STARTED,
-          runId,
-          threadId,
-          model: chatOptions.model,
-          timestamp,
-          parentRunId: chatOptions.parentRunId
-        };
-      }
-      if (hasEmittedTextMessageStart) {
-        yield {
-          type: EventType.TEXT_MESSAGE_END,
-          messageId,
-          model: chatOptions.model,
-          timestamp
-        };
-      }
-      if (accumulatedRaw.length === 0) {
-        yield {
-          type: EventType.RUN_ERROR,
-          runId,
-          model: chatOptions.model,
-          timestamp,
-          message: `${this.name}.structuredOutputStream: response contained no content`,
-          code: "empty-response",
-          error: {
-            message: `${this.name}.structuredOutputStream: response contained no content`,
-            code: "empty-response"
-          }
-        };
-        return;
-      }
-      let parsed;
-      try {
-        parsed = JSON.parse(accumulatedRaw);
-      } catch {
-        yield {
-          type: EventType.RUN_ERROR,
-          runId,
-          model: chatOptions.model,
-          timestamp,
-          message: `Failed to parse structured output as JSON. Content: ${accumulatedRaw.slice(0, 200)}${accumulatedRaw.length > 200 ? "..." : ""}`,
-          code: "parse-error",
-          error: {
-            message: "Failed to parse structured output as JSON",
-            code: "parse-error"
-          }
-        };
-        return;
-      }
-      yield {
-        type: EventType.CUSTOM,
-        name: "structured-output.complete",
-        value: {
-          object: parsed,
-          raw: accumulatedRaw
-        },
-        model: chatOptions.model,
-        timestamp
-      };
-      yield {
-        type: EventType.RUN_FINISHED,
-        runId,
-        threadId,
-        model: chatOptions.model,
-        timestamp,
-        finishReason
-      };
-    } catch (error) {
-      if (!hasEmittedRunStarted) {
-        hasEmittedRunStarted = true;
-        yield {
-          type: EventType.RUN_STARTED,
-          runId,
-          threadId,
-          model: chatOptions.model,
-          timestamp,
-          parentRunId: chatOptions.parentRunId
-        };
-      }
-      const errorPayload = toRunErrorPayload(
-        error,
-        `${this.name}.structuredOutputStream failed`
-      );
-      chatOptions.logger.errors(`${this.name}.structuredOutputStream fatal`, {
-        error: errorPayload,
-        source: `${this.name}.structuredOutputStream`
-      });
-      yield {
-        type: EventType.RUN_ERROR,
-        runId,
-        model: chatOptions.model,
-        timestamp,
-        message: errorPayload.message,
-        ...errorPayload.code !== void 0 && { code: errorPayload.code },
-        error: {
-          message: errorPayload.message,
-          ...errorPayload.code !== void 0 && { code: errorPayload.code }
-        }
-      };
-    }
-  }
-  /**
-   * Converse sends `tools` and a forced structured-output tool via two separate
-   * mechanisms, never together. Declaring `false` makes the engine run the
-   * agent loop without `outputSchema` and finalize via `structuredOutput` /
-   * `structuredOutputStream`.
-   */
-  supportsCombinedToolsAndSchema() {
-    return false;
-  }
-  // ---------------------------------------------------------------------------
-  // Request construction
-  // ---------------------------------------------------------------------------
-  /**
-   * Translate `TextOptions` into a `ConverseCommandInput`. Shared by chatStream,
-   * structuredOutput, and structuredOutputStream (the latter two override
-   * `toolConfig` with the forced structured tool afterwards).
-   */
-  buildInput(options) {
-    const { system, messages } = toConverseMessages(
-      options.messages,
-      options.systemPrompts
-    );
-    const toolConfig = options.tools ? toToolConfig(convertTools(options.tools)) : void 0;
-    const modelOptions = options.modelOptions;
-    const temperature = modelOptions?.temperature;
-    const topP = modelOptions?.top_p;
-    const maxTokens = modelOptions?.max_completion_tokens;
-    const stop = modelOptions?.stop;
-    const stopSequences = stop == null ? void 0 : Array.isArray(stop) ? stop : [stop];
-    const inferenceConfig = temperature != null || topP != null || maxTokens != null || stopSequences != null ? {
-      ...temperature != null && { temperature },
-      ...topP != null && { topP },
-      ...maxTokens != null && { maxTokens },
-      ...stopSequences != null && { stopSequences }
-    } : void 0;
-    return {
-      modelId: this.model,
-      messages,
-      ...system.length > 0 && { system },
-      ...toolConfig && { toolConfig },
-      ...inferenceConfig && { inferenceConfig }
-    };
-  }
-}
+import { buildStructuredToolConfig } from "../converse/structured-output.js";
+import { EventType, convertSchemaToJsonSchema } from "@tanstack/ai";
+import { BaseTextAdapter } from "@tanstack/ai/adapters";
+import { toRunErrorPayload } from "@tanstack/ai/adapter-internals";
+//#region src/adapters/converse-text.ts
+/**
+* Bedrock Converse text adapter. Wires the Converse translation modules (message
+* converter, tool converter, stream processor, structured-output forced-tool
+* builder) onto `@tanstack/ai`'s `BaseTextAdapter` and the
+* `@aws-sdk/client-bedrock-runtime` `BedrockRuntimeClient`.
+*
+* The success-path AG-UI lifecycle (`RUN_STARTED`..`RUN_FINISHED`) is owned by
+* `processConverseStream`; this adapter only owns the catch/`RUN_ERROR` path,
+* mirroring openai-base's `chatStream`.
+*
+* The actual SDK calls live behind two protected seams (`sendStream` / `send`)
+* so tests can subclass and inject canned Converse SDK shapes without a real
+* AWS request.
+*/
+var BedrockConverseTextAdapter = class extends BaseTextAdapter {
+	kind = "text";
+	name = "bedrock-converse";
+	clientPromise;
+	clientConfig;
+	constructor(config, model) {
+		super({}, model);
+		this.clientConfig = config;
+	}
+	/**
+	* Dynamically import `@aws-sdk/client-bedrock-runtime`. The specifier is held
+	* in a variable (not a string literal) so bundler dep scanners (e.g. Vite/
+	* esbuild optimizeDeps) cannot statically discover the AWS SDK and try to
+	* pre-bundle it for the browser — it would fail on the SDK's Node-only
+	* `fromTokenFile` export chain. The SDK is Node/server-only and is only
+	* reached on a real request. `typeof import(...)` is a type-only reference
+	* (erased at emit) so the imported members keep full typing.
+	*/
+	importBedrockRuntime() {
+		return import(
+			/* @vite-ignore */
+			"@aws-sdk/client-bedrock-runtime"
+);
+	}
+	/**
+	* Lazily construct the `BedrockRuntimeClient`. The dynamic import keeps
+	* `@aws-sdk/client-bedrock-runtime` out of the static/browser graph and
+	* defers `resolveBedrockAuth` until a real request is made.
+	*/
+	async getClient() {
+		if (!this.clientPromise) this.clientPromise = (async () => {
+			const { BedrockRuntimeClient } = await this.importBedrockRuntime();
+			const region = this.clientConfig.region ?? "us-east-1";
+			const resolved = resolveBedrockAuth({
+				apiKey: this.clientConfig.apiKey,
+				region,
+				auth: this.clientConfig.auth
+			}, "runtime");
+			return new BedrockRuntimeClient(this.buildClientConfig(resolved, region, this.clientConfig.baseURL));
+		})().catch((error) => {
+			this.clientPromise = void 0;
+			throw error;
+		});
+		return this.clientPromise;
+	}
+	/**
+	* Map resolved auth + endpoint to a `BedrockRuntimeClientConfig`.
+	*
+	* Recent `@aws-sdk/client-bedrock-runtime` exposes a first-class `token`
+	* config field for Bedrock API-key bearer auth. But the client's default
+	* auth-scheme order is SigV4 first, then bearer — so passing `token` alone is
+	* not enough: the SDK still resolves SigV4 and throws "Could not load
+	* credentials from any providers". Pinning `authSchemePreference` to the
+	* bearer scheme makes the API key actually get used. SigV4 uses the AWS
+	* credential provider chain and the default scheme order.
+	*/
+	buildClientConfig(resolved, region, endpoint) {
+		if (resolved.kind === "bearer") return {
+			region,
+			token: { token: resolved.token },
+			authSchemePreference: ["httpBearerAuth"],
+			...endpoint ? { endpoint } : {}
+		};
+		return {
+			region: resolved.region,
+			credentials: resolved.credentials,
+			...endpoint ? { endpoint } : {}
+		};
+	}
+	async sendStream(input) {
+		const { ConverseStreamCommand } = await this.importBedrockRuntime();
+		const res = await (await this.getClient()).send(new ConverseStreamCommand(input));
+		if (!res.stream) throw new Error("Bedrock Converse: empty stream response");
+		return res.stream;
+	}
+	async send(input) {
+		const { ConverseCommand } = await this.importBedrockRuntime();
+		return (await this.getClient()).send(new ConverseCommand(input));
+	}
+	async *chatStream(options) {
+		try {
+			options.logger.request(`activity=chat provider=${this.name} model=${this.model} messages=${options.messages.length} tools=${options.tools?.length ?? 0} stream=true`, {
+				provider: this.name,
+				model: this.model
+			});
+			const input = this.buildInput(options);
+			yield* processConverseStream(await this.sendStream(input), () => this.generateId(), {
+				threadId: options.threadId,
+				parentRunId: options.parentRunId,
+				model: options.model
+			});
+		} catch (error) {
+			const errorPayload = toRunErrorPayload(error, `${this.name}.chatStream failed`);
+			options.logger.errors(`${this.name}.chatStream fatal`, {
+				error: errorPayload,
+				source: `${this.name}.chatStream`
+			});
+			yield {
+				type: EventType.RUN_ERROR,
+				model: options.model,
+				timestamp: Date.now(),
+				message: errorPayload.message,
+				...errorPayload.code !== void 0 && { code: errorPayload.code },
+				error: {
+					message: errorPayload.message,
+					...errorPayload.code !== void 0 && { code: errorPayload.code }
+				}
+			};
+		}
+	}
+	/**
+	* Structured output via the forced-tool strategy. Converse has no native
+	* json_schema response_format, so we force a single tool whose input schema
+	* is the requested output schema and read the model's `toolUse.input` back as
+	* the structured result.
+	*/
+	async structuredOutput(options) {
+		const { chatOptions, outputSchema } = options;
+		try {
+			chatOptions.logger.request(`activity=structuredOutput provider=${this.name} model=${this.model} messages=${chatOptions.messages.length}`, {
+				provider: this.name,
+				model: this.model
+			});
+			const input = {
+				...this.buildInput(chatOptions),
+				toolConfig: buildStructuredToolConfig(outputSchema)
+			};
+			const structured = extractStructuredToolInput(await this.send(input));
+			if (structured === void 0) throw new Error(`${this.name}.structuredOutput: response contained no forced-tool output`);
+			return {
+				data: structured,
+				rawText: JSON.stringify(structured)
+			};
+		} catch (error) {
+			chatOptions.logger.errors(`${this.name}.structuredOutput fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.structuredOutput failed`),
+				source: `${this.name}.structuredOutput`
+			});
+			throw error;
+		}
+	}
+	/**
+	* Streaming structured output. Same forced-tool strategy as
+	* `structuredOutput`, but streamed: the forced tool's `toolUse.input` JSON
+	* fragments are accumulated from the Converse stream and a terminal
+	* `CUSTOM 'structured-output.complete'` event carries `{ object, raw }`,
+	* mirroring openai-base's `structuredOutputStream` contract exactly.
+	*/
+	async *structuredOutputStream(options) {
+		const { chatOptions, outputSchema } = options;
+		const timestamp = Date.now();
+		const runId = this.generateId();
+		const threadId = chatOptions.threadId ?? this.generateId();
+		const messageId = this.generateId();
+		let hasEmittedRunStarted = false;
+		let hasEmittedTextMessageStart = false;
+		let accumulatedRaw = "";
+		let finishReason = "stop";
+		try {
+			chatOptions.logger.request(`activity=structuredOutputStream provider=${this.name} model=${this.model} messages=${chatOptions.messages.length}`, {
+				provider: this.name,
+				model: this.model
+			});
+			const input = {
+				...this.buildInput(chatOptions),
+				toolConfig: buildStructuredToolConfig(outputSchema)
+			};
+			const stream = await this.sendStream(input);
+			for await (const ev of stream) {
+				if (!hasEmittedRunStarted) {
+					hasEmittedRunStarted = true;
+					yield {
+						type: EventType.RUN_STARTED,
+						runId,
+						threadId,
+						model: chatOptions.model,
+						timestamp,
+						parentRunId: chatOptions.parentRunId
+					};
+				}
+				throwIfConverseStreamError(ev);
+				if ("contentBlockDelta" in ev) {
+					const delta = ev.contentBlockDelta?.delta;
+					const fragment = delta && "toolUse" in delta ? delta.toolUse?.input : void 0;
+					if (fragment !== void 0) {
+						if (!hasEmittedTextMessageStart) {
+							hasEmittedTextMessageStart = true;
+							yield {
+								type: EventType.TEXT_MESSAGE_START,
+								messageId,
+								role: "assistant",
+								model: chatOptions.model,
+								timestamp
+							};
+						}
+						accumulatedRaw += fragment;
+						yield {
+							type: EventType.TEXT_MESSAGE_CONTENT,
+							messageId,
+							delta: fragment,
+							content: accumulatedRaw,
+							model: chatOptions.model,
+							timestamp
+						};
+					}
+					continue;
+				}
+				if ("messageStop" in ev) {
+					const stopReason = ev.messageStop?.stopReason;
+					finishReason = stopReason === "max_tokens" ? "length" : stopReason === "content_filtered" ? "content_filter" : "stop";
+					continue;
+				}
+			}
+			if (!hasEmittedRunStarted) {
+				hasEmittedRunStarted = true;
+				yield {
+					type: EventType.RUN_STARTED,
+					runId,
+					threadId,
+					model: chatOptions.model,
+					timestamp,
+					parentRunId: chatOptions.parentRunId
+				};
+			}
+			if (hasEmittedTextMessageStart) yield {
+				type: EventType.TEXT_MESSAGE_END,
+				messageId,
+				model: chatOptions.model,
+				timestamp
+			};
+			if (accumulatedRaw.length === 0) {
+				yield {
+					type: EventType.RUN_ERROR,
+					runId,
+					model: chatOptions.model,
+					timestamp,
+					message: `${this.name}.structuredOutputStream: response contained no content`,
+					code: "empty-response",
+					error: {
+						message: `${this.name}.structuredOutputStream: response contained no content`,
+						code: "empty-response"
+					}
+				};
+				return;
+			}
+			let parsed;
+			try {
+				parsed = JSON.parse(accumulatedRaw);
+			} catch {
+				yield {
+					type: EventType.RUN_ERROR,
+					runId,
+					model: chatOptions.model,
+					timestamp,
+					message: `Failed to parse structured output as JSON. Content: ${accumulatedRaw.slice(0, 200)}${accumulatedRaw.length > 200 ? "..." : ""}`,
+					code: "parse-error",
+					error: {
+						message: "Failed to parse structured output as JSON",
+						code: "parse-error"
+					}
+				};
+				return;
+			}
+			yield {
+				type: EventType.CUSTOM,
+				name: "structured-output.complete",
+				value: {
+					object: parsed,
+					raw: accumulatedRaw
+				},
+				model: chatOptions.model,
+				timestamp
+			};
+			yield {
+				type: EventType.RUN_FINISHED,
+				runId,
+				threadId,
+				model: chatOptions.model,
+				timestamp,
+				finishReason
+			};
+		} catch (error) {
+			if (!hasEmittedRunStarted) {
+				hasEmittedRunStarted = true;
+				yield {
+					type: EventType.RUN_STARTED,
+					runId,
+					threadId,
+					model: chatOptions.model,
+					timestamp,
+					parentRunId: chatOptions.parentRunId
+				};
+			}
+			const errorPayload = toRunErrorPayload(error, `${this.name}.structuredOutputStream failed`);
+			chatOptions.logger.errors(`${this.name}.structuredOutputStream fatal`, {
+				error: errorPayload,
+				source: `${this.name}.structuredOutputStream`
+			});
+			yield {
+				type: EventType.RUN_ERROR,
+				runId,
+				model: chatOptions.model,
+				timestamp,
+				message: errorPayload.message,
+				...errorPayload.code !== void 0 && { code: errorPayload.code },
+				error: {
+					message: errorPayload.message,
+					...errorPayload.code !== void 0 && { code: errorPayload.code }
+				}
+			};
+		}
+	}
+	/**
+	* Converse sends `tools` and a forced structured-output tool via two separate
+	* mechanisms, never together. Declaring `false` makes the engine run the
+	* agent loop without `outputSchema` and finalize via `structuredOutput` /
+	* `structuredOutputStream`.
+	*/
+	supportsCombinedToolsAndSchema() {
+		return false;
+	}
+	/**
+	* Translate `TextOptions` into a `ConverseCommandInput`. Shared by chatStream,
+	* structuredOutput, and structuredOutputStream (the latter two override
+	* `toolConfig` with the forced structured tool afterwards).
+	*/
+	buildInput(options) {
+		const { system, messages } = toConverseMessages(options.messages, options.systemPrompts);
+		const toolConfig = options.tools ? toToolConfig(convertTools(options.tools), "auto") : void 0;
+		const modelOptions = options.modelOptions;
+		const temperature = modelOptions?.temperature;
+		const topP = modelOptions?.top_p;
+		const maxTokens = modelOptions?.max_completion_tokens;
+		const stop = modelOptions?.stop;
+		const stopSequences = stop == null ? void 0 : Array.isArray(stop) ? stop : [stop];
+		const inferenceConfig = temperature != null || topP != null || maxTokens != null || stopSequences != null ? {
+			...temperature != null && { temperature },
+			...topP != null && { topP },
+			...maxTokens != null && { maxTokens },
+			...stopSequences != null && { stopSequences }
+		} : void 0;
+		return {
+			modelId: this.model,
+			messages,
+			...system.length > 0 && { system },
+			...toolConfig && { toolConfig },
+			...inferenceConfig && { inferenceConfig }
+		};
+	}
+};
+/**
+* Convert TanStack `Tool[]` to the Converse tool-converter input shape. Reuses
+* the SAME `convertSchemaToJsonSchema` the other adapters use so the Converse
+* tool input schemas match what every other provider sends.
+*/
 function convertTools(tools) {
-  return tools.map((tool) => {
-    const inputSchema = convertSchemaToJsonSchema(
-      tool.inputSchema
-    ) ?? { type: "object", properties: {}, required: [] };
-    return {
-      name: tool.name,
-      description: tool.description,
-      inputSchema
-    };
-  });
+	return tools.map((tool) => {
+		const inputSchema = convertSchemaToJsonSchema(tool.inputSchema) ?? {
+			type: "object",
+			properties: {},
+			required: []
+		};
+		return {
+			name: tool.name,
+			description: tool.description,
+			inputSchema
+		};
+	});
 }
+/**
+* Find the forced structured-output tool's `input` in a non-streaming Converse
+* response. SDK-boundary narrowing only — `ConverseOutput` is a tagged union
+* (`{ message }`) and a tool-use block is `{ toolUse: { input } }`.
+*/
 function extractStructuredToolInput(res) {
-  const message = res.output && "message" in res.output ? res.output.message : void 0;
-  const content = message?.content ?? [];
-  for (const block of content) {
-    if ("toolUse" in block && block.toolUse) {
-      if (block.toolUse.name === STRUCTURED_TOOL_NAME || block.toolUse.name === void 0) {
-        return block.toolUse.input;
-      }
-    }
-  }
-  return void 0;
+	const content = (res.output && "message" in res.output ? res.output.message : void 0)?.content ?? [];
+	for (const block of content) if ("toolUse" in block && block.toolUse) {
+		if (block.toolUse.name === "structured_output" || block.toolUse.name === void 0) return block.toolUse.input;
+	}
 }
+/** Converse adapter with an explicit API key (low-level; mirrors createBedrockChat). */
 function createBedrockConverse(model, apiKey, config) {
-  return new BedrockConverseTextAdapter({ ...config, apiKey }, model);
+	return new BedrockConverseTextAdapter({
+		...config,
+		apiKey
+	}, model);
 }
-export {
-  BedrockConverseTextAdapter,
-  createBedrockConverse
-};
-//# sourceMappingURL=converse-text.js.map
+//#endregion
+export { BedrockConverseTextAdapter, createBedrockConverse };
+
+//# sourceMappingURL=converse-text.js.map