@tanstack/ai-bedrock 0.0.1

package/README.md

@@ -0,0 +1,95 @@
+# @tanstack/ai-bedrock
+
+Amazon Bedrock adapter for TanStack AI — the native Converse API (default) plus the OpenAI-compatible Chat Completions and Responses APIs, with streaming, tool calling, and reasoning.
+
+## Installation
+
+```bash
+pnpm add @tanstack/ai-bedrock
+# or
+npm install @tanstack/ai-bedrock
+# or
+yarn add @tanstack/ai-bedrock
+```
+
+## Setup
+
+Get a Bedrock API key from the [Amazon Bedrock console](https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys.html) and set it as an environment variable:
+
+```bash
+BEDROCK_API_KEY=your-bedrock-api-key
+```
+
+Alternatively, configure AWS credentials for SigV4 auth (see below).
+
+## Usage
+
+```typescript
+import { bedrockText } from '@tanstack/ai-bedrock'
+import { chat } from '@tanstack/ai'
+
+const adapter = bedrockText('us.anthropic.claude-haiku-4-5-20251001-v1:0', {
+  region: 'us-east-1',
+})
+
+for await (const chunk of chat({
+  adapter,
+  messages: [{ role: 'user', content: 'Hello from Bedrock!' }],
+})) {
+  if (chunk.type === 'TEXT_MESSAGE_CONTENT')
+    process.stdout.write(chunk.delta ?? '')
+}
+```
+
+### Responses API
+
+```typescript
+import { bedrockText } from '@tanstack/ai-bedrock'
+
+const adapter = bedrockText('openai.gpt-oss-120b-1:0', {
+  region: 'us-east-1',
+  api: 'responses',
+})
+```
+
+### With Explicit API Key
+
+```typescript
+import { createBedrockText } from '@tanstack/ai-bedrock'
+
+const adapter = createBedrockText(
+  'us.amazon.nova-pro-v1:0',
+  'your-bedrock-api-key',
+  { region: 'us-west-2' },
+)
+```
+
+## Authentication
+
+Auth is resolved in this order:
+
+1. Explicit `apiKey` passed to the factory
+2. `BEDROCK_API_KEY` environment variable
+3. `AWS_BEARER_TOKEN_BEDROCK` environment variable
+4. SigV4 via the AWS credential chain
+
+SigV4 signing is built in — no additional packages required. On the Converse
+(default) path the `@aws-sdk/client-bedrock-runtime` client signs requests
+itself; the OpenAI-compatible chat/responses paths sign via the bundled
+`@smithy/signature-v4`. Set `auth: 'sigv4'` and provide AWS credentials through
+the standard credential chain (env vars, shared config, instance role):
+
+```typescript
+const adapter = bedrockText('us.anthropic.claude-haiku-4-5-20251001-v1:0', {
+  auth: 'sigv4',
+  region: 'us-east-1',
+})
+```
+
+## Documentation
+
+Full documentation: [TanStack AI — Amazon Bedrock adapter](https://tanstack.com/ai/latest/docs/adapters/bedrock)
+
+## License
+
+MIT

package/dist/esm/adapters/converse-text.d.ts

@@ -0,0 +1,93 @@
+import { BaseTextAdapter, StructuredOutputOptions, StructuredOutputResult } from '@tanstack/ai/adapters';
+import { ResolvedBedrockAuth } from '../utils/auth.js';
+import { BedrockRuntimeClient, BedrockRuntimeClientConfig, ConverseCommandInput, ConverseCommandOutput, ConverseStreamCommandInput, ConverseStreamOutput } from '@aws-sdk/client-bedrock-runtime';
+import { Modality, StreamChunk, TextOptions } from '@tanstack/ai';
+import { BedrockClientConfig } from '../utils/client.js';
+import { BedrockMessageMetadataByModality } from '../message-types.js';
+import { BedrockConverseModels, ResolveConverseProviderOptions, ResolveInputModalities } from '../model-meta.js';
+import type * as BedrockRuntime from '@aws-sdk/client-bedrock-runtime';
+/** Config for the Converse adapter — same client config as the chat adapter. */
+export interface BedrockConverseConfig extends BedrockClientConfig {
+}
+/**
+ * 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.
+ */
+export declare class BedrockConverseTextAdapter<TModel extends BedrockConverseModels, TProviderOptions extends Record<string, any> = ResolveConverseProviderOptions<TModel>, TInputModalities extends ReadonlyArray<Modality> = ResolveInputModalities<TModel>> extends BaseTextAdapter<TModel, TProviderOptions, TInputModalities, BedrockMessageMetadataByModality> {
+    readonly kind: "text";
+    readonly name: "bedrock-converse";
+    private clientPromise?;
+    private readonly clientConfig;
+    constructor(config: BedrockConverseConfig, model: TModel);
+    /**
+     * 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.
+     */
+    protected importBedrockRuntime(): Promise<typeof BedrockRuntime>;
+    /**
+     * 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.
+     */
+    protected getClient(): Promise<BedrockRuntimeClient>;
+    /**
+     * 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.
+     */
+    protected buildClientConfig(resolved: ResolvedBedrockAuth, region: string, endpoint: string | undefined): BedrockRuntimeClientConfig;
+    protected sendStream(input: ConverseStreamCommandInput): Promise<AsyncIterable<ConverseStreamOutput>>;
+    protected send(input: ConverseCommandInput): Promise<ConverseCommandOutput>;
+    chatStream(options: TextOptions<TProviderOptions>): AsyncIterable<StreamChunk>;
+    /**
+     * 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.
+     */
+    structuredOutput(options: StructuredOutputOptions<TProviderOptions>): Promise<StructuredOutputResult<unknown>>;
+    /**
+     * 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.
+     */
+    structuredOutputStream(options: StructuredOutputOptions<TProviderOptions>): AsyncIterable<StreamChunk>;
+    /**
+     * 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(): boolean;
+    /**
+     * Translate `TextOptions` into a `ConverseCommandInput`. Shared by chatStream,
+     * structuredOutput, and structuredOutputStream (the latter two override
+     * `toolConfig` with the forced structured tool afterwards).
+     */
+    protected buildInput(options: TextOptions<TProviderOptions>): ConverseCommandInput;
+}
+/** Converse adapter with an explicit API key (low-level; mirrors createBedrockChat). */
+export declare function createBedrockConverse<TModel extends BedrockConverseModels>(model: TModel, apiKey: string, config?: Omit<BedrockConverseConfig, 'apiKey'>): BedrockConverseTextAdapter<TModel>;

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

@@ -0,0 +1,430 @@
+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 }
+    };
+  }
+}
+function convertTools(tools) {
+  return tools.map((tool) => {
+    const inputSchema = convertSchemaToJsonSchema(
+      tool.inputSchema
+    ) ?? { type: "object", properties: {}, required: [] };
+    return {
+      name: tool.name,
+      description: tool.description,
+      inputSchema
+    };
+  });
+}
+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;
+}
+function createBedrockConverse(model, apiKey, config) {
+  return new BedrockConverseTextAdapter({ ...config, apiKey }, model);
+}
+export {
+  BedrockConverseTextAdapter,
+  createBedrockConverse
+};
+//# sourceMappingURL=converse-text.js.map