@tanstack/ai-bedrock 0.1.6 → 0.2.0

package/dist/esm/model-meta.d.ts

@@ -1,6 +1,7 @@
 import { GENERATED_BEDROCK_MODELS } from './model-catalog.generated.js';
 import { BedrockTextProviderOptions } from './text/text-provider-options.js';
 import { BedrockConverseProviderOptions } from './converse/provider-options.js';
+import { BedrockCohereEmbeddingProviderOptions, BedrockEmbeddingProviderOptions, BedrockTitanImageEmbeddingProviderOptions, BedrockTitanTextEmbeddingProviderOptions } from './embedding/embedding-provider-options.js';
 type Entry = (typeof GENERATED_BEDROCK_MODELS)[number];
 /**
  * Type-level per-API filter over the generated catalog. Because the catalog is
@@ -35,4 +36,34 @@ export type BedrockChatModelToolCapabilitiesByName = {
 export type ResolveProviderOptions<TModel extends string> = TModel extends keyof BedrockChatModelProviderOptionsByName ? BedrockChatModelProviderOptionsByName[TModel] : BedrockTextProviderOptions;
 export type ResolveConverseProviderOptions<TModel extends string> = TModel extends keyof BedrockConverseModelProviderOptionsByName ? BedrockConverseModelProviderOptionsByName[TModel] : BedrockConverseProviderOptions;
 export type ResolveInputModalities<TModel extends string> = TModel extends keyof BedrockModelInputModalitiesByName ? BedrockModelInputModalitiesByName[TModel] : readonly ['text'];
+/**
+ * Embedding models reachable through Bedrock's `InvokeModel` API. These are
+ * not part of the generated Converse catalog (embedding models have no
+ * conversational surface), so they're maintained by hand here.
+ */
+export declare const BEDROCK_EMBEDDING_MODELS: readonly ["amazon.titan-embed-text-v2:0", "amazon.titan-embed-image-v1", "cohere.embed-english-v3", "cohere.embed-multilingual-v3"];
+export type BedrockEmbeddingModel = (typeof BEDROCK_EMBEDDING_MODELS)[number];
+/**
+ * Type-only map from embedding model name to its provider options type.
+ * The Cohere models make `modelOptions` REQUIRED at the `embed()` call site
+ * because `inputType` is a required field.
+ */
+export type BedrockEmbeddingModelProviderOptionsByName = {
+    'amazon.titan-embed-text-v2:0': BedrockTitanTextEmbeddingProviderOptions;
+    'amazon.titan-embed-image-v1': BedrockTitanImageEmbeddingProviderOptions;
+    'cohere.embed-english-v3': BedrockCohereEmbeddingProviderOptions;
+    'cohere.embed-multilingual-v3': BedrockCohereEmbeddingProviderOptions;
+};
+/**
+ * Per-model input modalities for embedding models. Titan Multimodal accepts
+ * text and/or images (including fused text+image items embedded into one
+ * vector); the rest are text-only, so image inputs fail at compile time.
+ */
+export type BedrockEmbeddingModelInputModalitiesByName = {
+    'amazon.titan-embed-text-v2:0': readonly ['text'];
+    'amazon.titan-embed-image-v1': readonly ['text', 'image'];
+    'cohere.embed-english-v3': readonly ['text'];
+    'cohere.embed-multilingual-v3': readonly ['text'];
+};
+export type ResolveEmbeddingProviderOptions<TModel extends string> = TModel extends keyof BedrockEmbeddingModelProviderOptionsByName ? BedrockEmbeddingModelProviderOptionsByName[TModel] : BedrockEmbeddingProviderOptions;
 export {};

package/dist/esm/model-meta.js

@@ -4,7 +4,18 @@ import { GENERATED_BEDROCK_MODELS } from "./model-catalog.generated.js";
 var BEDROCK_CONVERSE_MODELS = GENERATED_BEDROCK_MODELS.map((m) => m.id);
 var BEDROCK_CHAT_MODELS = GENERATED_BEDROCK_MODELS.filter((m) => m.apis.chat).map((m) => m.id);
 var BEDROCK_RESPONSES_MODELS = GENERATED_BEDROCK_MODELS.filter((m) => m.apis.responses).map((m) => m.id);
+/**
+* Embedding models reachable through Bedrock's `InvokeModel` API. These are
+* not part of the generated Converse catalog (embedding models have no
+* conversational surface), so they're maintained by hand here.
+*/
+var BEDROCK_EMBEDDING_MODELS = [
+	"amazon.titan-embed-text-v2:0",
+	"amazon.titan-embed-image-v1",
+	"cohere.embed-english-v3",
+	"cohere.embed-multilingual-v3"
+];
 //#endregion
-export { BEDROCK_CHAT_MODELS, BEDROCK_CONVERSE_MODELS, BEDROCK_RESPONSES_MODELS };
+export { BEDROCK_CHAT_MODELS, BEDROCK_CONVERSE_MODELS, BEDROCK_EMBEDDING_MODELS, BEDROCK_RESPONSES_MODELS };
 
 //# sourceMappingURL=model-meta.js.map

package/dist/esm/model-meta.js.map

@@ -1 +1 @@
-{"version":3,"file":"model-meta.js","names":[],"sources":["../../src/model-meta.ts"],"sourcesContent":["import { GENERATED_BEDROCK_MODELS } from './model-catalog.generated.js'\nimport type { BedrockTextProviderOptions } from './text/text-provider-options'\nimport type { BedrockConverseProviderOptions } from './converse/provider-options'\n\ntype Entry = (typeof GENERATED_BEDROCK_MODELS)[number]\n\n/**\n * Type-level per-API filter over the generated catalog. Because the catalog is\n * `as const`, `Extract` preserves literal `id` unions (no widening to `string`).\n */\ntype IdsWhere<TApi extends 'converse' | 'chat' | 'responses'> = Extract<\n  Entry,\n  { apis: Record<TApi, true> }\n>['id']\n\nexport type BedrockConverseModels = IdsWhere<'converse'>\nexport type BedrockChatModels = IdsWhere<'chat'>\nexport type BedrockResponsesModels = IdsWhere<'responses'>\n\n/** Runtime catalogs. Cast-free narrowing via a type predicate (the ai-bedrock pattern). */\n// Every catalog entry advertises `converse: true` (Converse is the universal\n// Bedrock surface), so the id list is the full catalog — no runtime filter needed.\nexport const BEDROCK_CONVERSE_MODELS: ReadonlyArray<BedrockConverseModels> =\n  GENERATED_BEDROCK_MODELS.map((m) => m.id)\n\nexport const BEDROCK_CHAT_MODELS: ReadonlyArray<BedrockChatModels> =\n  GENERATED_BEDROCK_MODELS.filter(\n    (m): m is Extract<Entry, { apis: { chat: true } }> => m.apis.chat,\n  ).map((m) => m.id)\n\nexport const BEDROCK_RESPONSES_MODELS: ReadonlyArray<BedrockResponsesModels> =\n  GENERATED_BEDROCK_MODELS.filter(\n    (m): m is Extract<Entry, { apis: { responses: true } }> => m.apis.responses,\n  ).map((m) => m.id)\n\n/** Per-model input modalities (drives type-safe multimodal content). Covers ALL models. */\nexport type BedrockModelInputModalitiesByName = {\n  [E in Entry as E['id']]: E['input']\n}\n\n/** Provider options per model. Same options for every model; keyed over the full catalog. */\nexport type BedrockChatModelProviderOptionsByName = {\n  [E in Entry as E['id']]: BedrockTextProviderOptions\n}\n\n/** Converse provider options per model (narrower than the Chat Completions set). */\nexport type BedrockConverseModelProviderOptionsByName = {\n  [E in Entry as E['id']]: BedrockConverseProviderOptions\n}\n\n/** No provider-specific tools — empty tuple makes cross-provider ProviderTool a compile error. */\nexport type BedrockChatModelToolCapabilitiesByName = {\n  [E in Entry as E['id']]: readonly []\n}\n\nexport type ResolveProviderOptions<TModel extends string> =\n  TModel extends keyof BedrockChatModelProviderOptionsByName\n    ? BedrockChatModelProviderOptionsByName[TModel]\n    : BedrockTextProviderOptions\n\nexport type ResolveConverseProviderOptions<TModel extends string> =\n  TModel extends keyof BedrockConverseModelProviderOptionsByName\n    ? BedrockConverseModelProviderOptionsByName[TModel]\n    : BedrockConverseProviderOptions\n\nexport type ResolveInputModalities<TModel extends string> =\n  TModel extends keyof BedrockModelInputModalitiesByName\n    ? BedrockModelInputModalitiesByName[TModel]\n    : readonly ['text']\n"],"mappings":";;;AAsBA,IAAa,0BACX,yBAAyB,KAAK,MAAM,EAAE,EAAE;AAE1C,IAAa,sBACX,yBAAyB,QACtB,MAAqD,EAAE,KAAK,IAC/D,CAAC,CAAC,KAAK,MAAM,EAAE,EAAE;AAEnB,IAAa,2BACX,yBAAyB,QACtB,MAA0D,EAAE,KAAK,SACpE,CAAC,CAAC,KAAK,MAAM,EAAE,EAAE"}
+{"version":3,"file":"model-meta.js","names":[],"sources":["../../src/model-meta.ts"],"sourcesContent":["import { GENERATED_BEDROCK_MODELS } from './model-catalog.generated.js'\nimport type { BedrockTextProviderOptions } from './text/text-provider-options'\nimport type { BedrockConverseProviderOptions } from './converse/provider-options'\nimport type {\n  BedrockCohereEmbeddingProviderOptions,\n  BedrockEmbeddingProviderOptions,\n  BedrockTitanImageEmbeddingProviderOptions,\n  BedrockTitanTextEmbeddingProviderOptions,\n} from './embedding/embedding-provider-options'\n\ntype Entry = (typeof GENERATED_BEDROCK_MODELS)[number]\n\n/**\n * Type-level per-API filter over the generated catalog. Because the catalog is\n * `as const`, `Extract` preserves literal `id` unions (no widening to `string`).\n */\ntype IdsWhere<TApi extends 'converse' | 'chat' | 'responses'> = Extract<\n  Entry,\n  { apis: Record<TApi, true> }\n>['id']\n\nexport type BedrockConverseModels = IdsWhere<'converse'>\nexport type BedrockChatModels = IdsWhere<'chat'>\nexport type BedrockResponsesModels = IdsWhere<'responses'>\n\n/** Runtime catalogs. Cast-free narrowing via a type predicate (the ai-bedrock pattern). */\n// Every catalog entry advertises `converse: true` (Converse is the universal\n// Bedrock surface), so the id list is the full catalog — no runtime filter needed.\nexport const BEDROCK_CONVERSE_MODELS: ReadonlyArray<BedrockConverseModels> =\n  GENERATED_BEDROCK_MODELS.map((m) => m.id)\n\nexport const BEDROCK_CHAT_MODELS: ReadonlyArray<BedrockChatModels> =\n  GENERATED_BEDROCK_MODELS.filter(\n    (m): m is Extract<Entry, { apis: { chat: true } }> => m.apis.chat,\n  ).map((m) => m.id)\n\nexport const BEDROCK_RESPONSES_MODELS: ReadonlyArray<BedrockResponsesModels> =\n  GENERATED_BEDROCK_MODELS.filter(\n    (m): m is Extract<Entry, { apis: { responses: true } }> => m.apis.responses,\n  ).map((m) => m.id)\n\n/** Per-model input modalities (drives type-safe multimodal content). Covers ALL models. */\nexport type BedrockModelInputModalitiesByName = {\n  [E in Entry as E['id']]: E['input']\n}\n\n/** Provider options per model. Same options for every model; keyed over the full catalog. */\nexport type BedrockChatModelProviderOptionsByName = {\n  [E in Entry as E['id']]: BedrockTextProviderOptions\n}\n\n/** Converse provider options per model (narrower than the Chat Completions set). */\nexport type BedrockConverseModelProviderOptionsByName = {\n  [E in Entry as E['id']]: BedrockConverseProviderOptions\n}\n\n/** No provider-specific tools — empty tuple makes cross-provider ProviderTool a compile error. */\nexport type BedrockChatModelToolCapabilitiesByName = {\n  [E in Entry as E['id']]: readonly []\n}\n\nexport type ResolveProviderOptions<TModel extends string> =\n  TModel extends keyof BedrockChatModelProviderOptionsByName\n    ? BedrockChatModelProviderOptionsByName[TModel]\n    : BedrockTextProviderOptions\n\nexport type ResolveConverseProviderOptions<TModel extends string> =\n  TModel extends keyof BedrockConverseModelProviderOptionsByName\n    ? BedrockConverseModelProviderOptionsByName[TModel]\n    : BedrockConverseProviderOptions\n\nexport type ResolveInputModalities<TModel extends string> =\n  TModel extends keyof BedrockModelInputModalitiesByName\n    ? BedrockModelInputModalitiesByName[TModel]\n    : readonly ['text']\n\n// ============================================================================\n// Embedding models\n// ============================================================================\n\n/**\n * Embedding models reachable through Bedrock's `InvokeModel` API. These are\n * not part of the generated Converse catalog (embedding models have no\n * conversational surface), so they're maintained by hand here.\n */\nexport const BEDROCK_EMBEDDING_MODELS = [\n  'amazon.titan-embed-text-v2:0',\n  'amazon.titan-embed-image-v1',\n  'cohere.embed-english-v3',\n  'cohere.embed-multilingual-v3',\n] as const\n\nexport type BedrockEmbeddingModel = (typeof BEDROCK_EMBEDDING_MODELS)[number]\n\n/**\n * Type-only map from embedding model name to its provider options type.\n * The Cohere models make `modelOptions` REQUIRED at the `embed()` call site\n * because `inputType` is a required field.\n */\nexport type BedrockEmbeddingModelProviderOptionsByName = {\n  'amazon.titan-embed-text-v2:0': BedrockTitanTextEmbeddingProviderOptions\n  'amazon.titan-embed-image-v1': BedrockTitanImageEmbeddingProviderOptions\n  'cohere.embed-english-v3': BedrockCohereEmbeddingProviderOptions\n  'cohere.embed-multilingual-v3': BedrockCohereEmbeddingProviderOptions\n}\n\n/**\n * Per-model input modalities for embedding models. Titan Multimodal accepts\n * text and/or images (including fused text+image items embedded into one\n * vector); the rest are text-only, so image inputs fail at compile time.\n */\nexport type BedrockEmbeddingModelInputModalitiesByName = {\n  'amazon.titan-embed-text-v2:0': readonly ['text']\n  'amazon.titan-embed-image-v1': readonly ['text', 'image']\n  'cohere.embed-english-v3': readonly ['text']\n  'cohere.embed-multilingual-v3': readonly ['text']\n}\n\nexport type ResolveEmbeddingProviderOptions<TModel extends string> =\n  TModel extends keyof BedrockEmbeddingModelProviderOptionsByName\n    ? BedrockEmbeddingModelProviderOptionsByName[TModel]\n    : BedrockEmbeddingProviderOptions\n"],"mappings":";;;AA4BA,IAAa,0BACX,yBAAyB,KAAK,MAAM,EAAE,EAAE;AAE1C,IAAa,sBACX,yBAAyB,QACtB,MAAqD,EAAE,KAAK,IAC/D,CAAC,CAAC,KAAK,MAAM,EAAE,EAAE;AAEnB,IAAa,2BACX,yBAAyB,QACtB,MAA0D,EAAE,KAAK,SACpE,CAAC,CAAC,KAAK,MAAM,EAAE,EAAE;;;;;;AA8CnB,IAAa,2BAA2B;CACtC;CACA;CACA;CACA;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai-bedrock",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "type": "module",
   "description": "Amazon Bedrock adapter for TanStack AI — OpenAI-compatible chat, responses, tools, and reasoning.",
   "author": "",
@@ -40,7 +40,7 @@
   },
   "peerDependencies": {
     "zod": "^4.0.0",
-    "@tanstack/ai": "0.43.1"
+    "@tanstack/ai": "^0.44.0"
   },
   "dependencies": {
     "@aws-crypto/sha256-js": "^5.2.0",
@@ -49,7 +49,7 @@
     "@smithy/signature-v4": "^5.4.5",
     "@smithy/types": "^4.14.2",
     "openai": "^6.41.0",
-    "@tanstack/openai-base": "0.9.10"
+    "@tanstack/openai-base": "^0.9.11"
   },
   "scripts": {
     "build": "vite build",

package/src/adapters/embedding.ts

@@ -0,0 +1,547 @@
+import { BaseEmbeddingAdapter } from '@tanstack/ai/adapters'
+import { toRunErrorPayload } from '@tanstack/ai/adapter-internals'
+import {
+  requireTextOnlyEmbeddingInput,
+  resolveEmbeddingInput,
+} from '@tanstack/ai'
+import { resolveBedrockAuth } from '../utils/auth'
+import { BEDROCK_EMBEDDING_MODELS } from '../model-meta'
+import type * as BedrockRuntime from '@aws-sdk/client-bedrock-runtime'
+import type {
+  BedrockRuntimeClient,
+  BedrockRuntimeClientConfig,
+} from '@aws-sdk/client-bedrock-runtime'
+import type {
+  EmbeddingOptions,
+  EmbeddingResult,
+  ImagePart,
+  TokenUsage,
+} from '@tanstack/ai'
+import type { ResolvedBedrockAuth } from '../utils/auth'
+import type { BedrockClientConfig } from '../utils/client'
+import type {
+  BedrockEmbeddingModel,
+  BedrockEmbeddingModelInputModalitiesByName,
+  BedrockEmbeddingModelProviderOptionsByName,
+  ResolveEmbeddingProviderOptions,
+} from '../model-meta'
+
+/**
+ * Config for the Bedrock embedding adapter — the same auth surface as the
+ * other Bedrock adapters (apiKey → env → SigV4 via `resolveBedrockAuth`),
+ * minus the OpenAI-compat client options that don't apply to `InvokeModel`.
+ */
+export interface BedrockEmbeddingConfig extends Pick<
+  BedrockClientConfig,
+  'apiKey' | 'region' | 'auth' | 'baseURL'
+> {}
+
+/** InvokeModel calls issued concurrently during a per-item fan-out. */
+const MAX_CONCURRENT_INVOCATIONS = 5
+
+/** Valid `dimensions` for `amazon.titan-embed-text-v2:0`. */
+const TITAN_TEXT_DIMENSIONS: ReadonlyArray<number> = [256, 512, 1024]
+
+/** Valid `dimensions` (outputEmbeddingLength) for `amazon.titan-embed-image-v1`. */
+const TITAN_IMAGE_DIMENSIONS: ReadonlyArray<number> = [256, 384, 1024]
+const TITAN_IMAGE_DEFAULT_DIMENSIONS = 1024
+
+/** Cohere embed accepts at most 96 texts per InvokeModel call. */
+const COHERE_MAX_BATCH_SIZE = 96
+
+/**
+ * Bedrock Embedding Adapter
+ *
+ * Tree-shakeable adapter for embeddings served through Bedrock's native
+ * `InvokeModel` API (embedding models have no Converse surface). Each model
+ * family has its own JSON body dialect:
+ *
+ * - `amazon.titan-embed-text-v2:0` — text-only, ONE text per call; the batch
+ *   is fanned out with a small concurrency cap and per-call
+ *   `inputTextTokenCount`s are summed into usage.
+ * - `amazon.titan-embed-image-v1` — MULTIMODAL: text, image, or a fused
+ *   text+image item embedded into a single vector; one item per call.
+ * - `cohere.embed-english-v3` / `cohere.embed-multilingual-v3` — text-only,
+ *   batched natively (chunked at 96 texts per call). `inputType` is required.
+ *
+ * The SDK call lives behind a protected `invokeModel` seam so tests can
+ * subclass and inject canned response bodies without a real AWS request, and
+ * the AWS SDK itself is imported lazily (it's Node/server-only).
+ */
+export class BedrockEmbeddingAdapter<
+  TModel extends BedrockEmbeddingModel,
+  // Same rationale as the text adapters: the base parameterises
+  // `TProviderOptions extends object`, and the per-model options interfaces
+  // lack implicit index signatures — `Record<string, any>` (not `unknown`)
+  // accepts them. Confined to the generic constraint; no value cast.
+  TProviderOptions extends Record<string, any> =
+    ResolveEmbeddingProviderOptions<TModel>,
+> extends BaseEmbeddingAdapter<
+  TModel,
+  TProviderOptions,
+  BedrockEmbeddingModelProviderOptionsByName,
+  BedrockEmbeddingModelInputModalitiesByName
+> {
+  readonly name = 'bedrock' as const
+  private clientPromise?: Promise<BedrockRuntimeClient>
+  private readonly clientConfig: BedrockEmbeddingConfig
+
+  constructor(config: BedrockEmbeddingConfig, model: TModel) {
+    super(model, {})
+    // Defer client construction and auth resolution: the AWS SDK is Node/
+    // server-only, so we must not pull it into the static graph here. The
+    // client (and its dynamic import) is built lazily on first SDK call.
+    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 cannot
+   * statically discover the AWS SDK and try to pre-bundle it for the browser.
+   * Same pattern as the Converse text adapter.
+   */
+  protected importBedrockRuntime(): Promise<typeof BedrockRuntime> {
+    const mod = '@aws-sdk/client-bedrock-runtime'
+    return import(/* @vite-ignore */ mod) as Promise<typeof BedrockRuntime>
+  }
+
+  /**
+   * Lazily construct the `BedrockRuntimeClient`, deferring
+   * `resolveBedrockAuth` until a real request is made.
+   */
+  protected async getClient(): Promise<BedrockRuntimeClient> {
+    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: unknown) => {
+        // Don't cache a rejected promise — clear it so a later call can retry
+        // (e.g. after a transient import failure or fixed auth config).
+        this.clientPromise = undefined
+        throw error
+      })
+    }
+    return this.clientPromise
+  }
+
+  /**
+   * Map resolved auth + endpoint to a `BedrockRuntimeClientConfig`. Bearer
+   * auth needs `authSchemePreference` pinned or the SDK still tries SigV4
+   * first — same reasoning as the Converse text adapter.
+   */
+  protected buildClientConfig(
+    resolved: ResolvedBedrockAuth,
+    region: string,
+    endpoint: string | undefined,
+  ): BedrockRuntimeClientConfig {
+    if (resolved.kind === 'bearer') {
+      return {
+        region,
+        token: { token: resolved.token },
+        authSchemePreference: ['httpBearerAuth'],
+        ...(endpoint ? { endpoint } : {}),
+      }
+    }
+    return {
+      region: resolved.region,
+      credentials: resolved.credentials,
+      ...(endpoint ? { endpoint } : {}),
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // SDK seam (overridden in tests so no real AWS call happens)
+  // ---------------------------------------------------------------------------
+
+  /** Send one InvokeModel call and parse its JSON response body. */
+  protected async invokeModel(
+    modelId: string,
+    body: Record<string, unknown>,
+  ): Promise<unknown> {
+    const { InvokeModelCommand } = await this.importBedrockRuntime()
+    const client = await this.getClient()
+    const response = await client.send(
+      new InvokeModelCommand({
+        modelId,
+        contentType: 'application/json',
+        accept: 'application/json',
+        body: JSON.stringify(body),
+      }),
+    )
+    return JSON.parse(new TextDecoder().decode(response.body))
+  }
+
+  // ---------------------------------------------------------------------------
+  // Public adapter surface
+  // ---------------------------------------------------------------------------
+
+  async createEmbeddings(
+    options: EmbeddingOptions<TProviderOptions>,
+  ): Promise<EmbeddingResult> {
+    const { model, logger } = options
+    try {
+      logger.request(
+        `activity=embed provider=${this.name} model=${model} inputs=${options.input.length}`,
+        { provider: this.name, model },
+      )
+      switch (model) {
+        case 'amazon.titan-embed-text-v2:0':
+          return await this.embedTitanText(options)
+        case 'amazon.titan-embed-image-v1':
+          return await this.embedTitanImage(options)
+        case 'cohere.embed-english-v3':
+        case 'cohere.embed-multilingual-v3':
+          return await this.embedCohere(options)
+        default:
+          throw new Error(
+            `Unknown Bedrock embedding model "${model}". Supported models: ` +
+              `${BEDROCK_EMBEDDING_MODELS.join(', ')}.`,
+          )
+      }
+    } catch (error: unknown) {
+      logger.errors(`${this.name}.createEmbeddings fatal`, {
+        error: toRunErrorPayload(error, `${this.name}.createEmbeddings failed`),
+        source: `${this.name}.createEmbeddings`,
+      })
+      throw error
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Per-model request mapping
+  // ---------------------------------------------------------------------------
+
+  /**
+   * `amazon.titan-embed-text-v2:0` — one text per InvokeModel call, fanned
+   * out with a concurrency cap; result order matches input order and per-call
+   * `inputTextTokenCount`s are summed into usage.
+   */
+  private async embedTitanText(
+    options: EmbeddingOptions<TProviderOptions>,
+  ): Promise<EmbeddingResult> {
+    const { model, dimensions } = options
+    if (
+      dimensions !== undefined &&
+      !TITAN_TEXT_DIMENSIONS.includes(dimensions)
+    ) {
+      throw new Error(
+        `${model} supports dimensions 256, 512, or 1024; got ${dimensions}`,
+      )
+    }
+    const normalize: boolean | undefined = options.modelOptions?.normalize
+    const texts = requireTextOnlyEmbeddingInput(options.input, this.name, model)
+
+    const responses = await mapWithConcurrency(
+      texts,
+      MAX_CONCURRENT_INVOCATIONS,
+      async (text) => {
+        // Built incrementally: exactOptionalPropertyTypes is on, and Titan
+        // rejects explicit nulls/undefined for absent optional fields.
+        const body: Record<string, unknown> = { inputText: text }
+        if (dimensions !== undefined) body.dimensions = dimensions
+        if (normalize !== undefined) body.normalize = normalize
+        return readTitanEmbeddingBody(
+          await this.invokeModel(model, body),
+          `${this.name} ${model}`,
+        )
+      },
+    )
+
+    return this.toTitanResult(model, responses)
+  }
+
+  /**
+   * `amazon.titan-embed-image-v1` (Titan Multimodal) — one item per
+   * InvokeModel call. An item may carry text, an image, or both (a fused
+   * item embedded into a single vector). Titan accepts at most one image per
+   * request and never fetches remote URLs.
+   */
+  private async embedTitanImage(
+    options: EmbeddingOptions<TProviderOptions>,
+  ): Promise<EmbeddingResult> {
+    const { model, dimensions } = options
+    const outputEmbeddingLength = dimensions ?? TITAN_IMAGE_DEFAULT_DIMENSIONS
+    if (!TITAN_IMAGE_DIMENSIONS.includes(outputEmbeddingLength)) {
+      throw new Error(
+        `${model} supports dimensions 256, 384, or 1024; got ${outputEmbeddingLength}`,
+      )
+    }
+    const items = resolveEmbeddingInput(options.input)
+
+    const responses = await mapWithConcurrency(
+      items,
+      MAX_CONCURRENT_INVOCATIONS,
+      async (item, index) => {
+        if (item.images.length > 1) {
+          throw new Error(
+            `${model} accepts at most one image per input item; input item ` +
+              `at index ${index} contains ${item.images.length} images. ` +
+              `Pass them as separate input items (one vector each).`,
+          )
+        }
+        const body: Record<string, unknown> = {
+          embeddingConfig: { outputEmbeddingLength },
+        }
+        if (item.texts.length > 0) body.inputText = item.texts.join('\n')
+        const image = item.images[0]
+        if (image) body.inputImage = toTitanInputImage(image, model)
+        return readTitanEmbeddingBody(
+          await this.invokeModel(model, body),
+          `${this.name} ${model}`,
+        )
+      },
+    )
+
+    return this.toTitanResult(model, responses)
+  }
+
+  /**
+   * `cohere.embed-*-v3` — natively batched (chunked at 96 texts per call,
+   * order preserved across chunks). `inputType` is required by the Cohere
+   * API; output dimensionality is fixed, so `dimensions` is rejected.
+   */
+  private async embedCohere(
+    options: EmbeddingOptions<TProviderOptions>,
+  ): Promise<EmbeddingResult> {
+    const { model, dimensions } = options
+    if (dimensions !== undefined) {
+      throw new Error(
+        `${model} does not support the dimensions option; its output size is fixed`,
+      )
+    }
+    const inputType: string | undefined = options.modelOptions?.inputType
+    if (inputType === undefined) {
+      throw new Error(
+        `${model} requires modelOptions.inputType ('search_document' | ` +
+          `'search_query' | 'classification' | 'clustering')`,
+      )
+    }
+    const truncate: string | undefined = options.modelOptions?.truncate
+    const texts = requireTextOnlyEmbeddingInput(options.input, this.name, model)
+    const batches = chunk(texts, COHERE_MAX_BATCH_SIZE)
+
+    const responses = await mapWithConcurrency(
+      batches,
+      MAX_CONCURRENT_INVOCATIONS,
+      async (batch) => {
+        const body: Record<string, unknown> = {
+          texts: batch,
+          input_type: inputType,
+        }
+        if (truncate !== undefined) body.truncate = truncate
+        return readCohereEmbeddingBody(
+          await this.invokeModel(model, body),
+          `${this.name} ${model}`,
+        )
+      },
+    )
+
+    return {
+      id: this.generateId(),
+      model,
+      embeddings: responses.flat().map((vector, index) => ({ vector, index })),
+    }
+  }
+
+  /** Assemble an EmbeddingResult from per-item Titan responses. */
+  private toTitanResult(
+    model: string,
+    responses: Array<TitanEmbeddingBody>,
+  ): EmbeddingResult {
+    let promptTokens = 0
+    const embeddings = responses.map((response, index) => {
+      promptTokens += response.inputTextTokenCount
+      return { vector: response.embedding, index }
+    })
+    const usage: TokenUsage = {
+      promptTokens,
+      completionTokens: 0,
+      totalTokens: promptTokens,
+    }
+    return { id: this.generateId(), model, embeddings, usage }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Response-body narrowing (SDK JSON boundary)
+// ---------------------------------------------------------------------------
+
+interface TitanEmbeddingBody {
+  embedding: Array<number>
+  /** 0 when the response omits it (e.g. image-only Titan Multimodal calls). */
+  inputTextTokenCount: number
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+/** Narrow a Titan InvokeModel JSON body: `{ embedding, inputTextTokenCount? }`. */
+function readTitanEmbeddingBody(
+  raw: unknown,
+  context: string,
+): TitanEmbeddingBody {
+  const embedding =
+    isRecord(raw) && Array.isArray(raw.embedding) ? raw.embedding : undefined
+  if (!embedding) {
+    throw new Error(
+      `${context}: response body is missing the "embedding" array`,
+    )
+  }
+  const inputTextTokenCount =
+    isRecord(raw) && typeof raw.inputTextTokenCount === 'number'
+      ? raw.inputTextTokenCount
+      : 0
+  return { embedding, inputTextTokenCount }
+}
+
+/** Narrow a Cohere InvokeModel JSON body: `{ embeddings: number[][] }` (float). */
+function readCohereEmbeddingBody(
+  raw: unknown,
+  context: string,
+): Array<Array<number>> {
+  const embeddings =
+    isRecord(raw) && Array.isArray(raw.embeddings) ? raw.embeddings : undefined
+  if (!embeddings) {
+    throw new Error(
+      `${context}: response body is missing the "embeddings" array`,
+    )
+  }
+  return embeddings
+}
+
+// ---------------------------------------------------------------------------
+// Input mapping helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Map an ImagePart to Titan's `inputImage` (RAW base64, no data: prefix).
+ * Accepts `data` sources as-is and `url` sources ONLY when the value is a
+ * `data:` URI; Titan cannot fetch remote http(s) URLs.
+ */
+function toTitanInputImage(image: ImagePart, model: string): string {
+  const source = image.source
+  if (source.type === 'data') {
+    return source.value
+  }
+  if (source.value.startsWith('data:')) {
+    const comma = source.value.indexOf(',')
+    if (comma !== -1) {
+      return source.value.slice(comma + 1)
+    }
+  }
+  throw new Error(
+    `Bedrock Titan does not fetch remote image URLs; pass base64 data ` +
+      `(a { type: 'data' } source or a data: URI) for ${model}.`,
+  )
+}
+
+/** Split into runs of at most `size`, preserving order. */
+function chunk<T>(items: Array<T>, size: number): Array<Array<T>> {
+  const chunks: Array<Array<T>> = []
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size))
+  }
+  return chunks
+}
+
+/**
+ * Map `fn` over `items` with at most `limit` calls in flight, returning
+ * results in input order (result[i] corresponds to items[i] regardless of
+ * completion order). Rejects with the first error.
+ */
+async function mapWithConcurrency<T, TResult>(
+  items: ReadonlyArray<T>,
+  limit: number,
+  fn: (item: T, index: number) => Promise<TResult>,
+): Promise<Array<TResult>> {
+  const results = new Array<TResult>(items.length)
+  let next = 0
+  const worker = async (): Promise<void> => {
+    while (next < items.length) {
+      const index = next++
+      const item = items[index]
+      if (item === undefined) continue // unreachable: index < length
+      results[index] = await fn(item, index)
+    }
+  }
+  const workerCount = Math.max(1, Math.min(limit, items.length))
+  await Promise.all(Array.from({ length: workerCount }, () => worker()))
+  return results
+}
+
+// ---------------------------------------------------------------------------
+// Factories
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a Bedrock embedding adapter with an explicit API key (bearer).
+ * Type resolution happens here at the call site.
+ *
+ * @param model - The model name (e.g., 'amazon.titan-embed-text-v2:0')
+ * @param apiKey - Your Bedrock API key
+ * @param config - Optional additional configuration (region, baseURL, ...)
+ * @returns Configured Bedrock embedding adapter instance with resolved types
+ *
+ * @example
+ * ```typescript
+ * const adapter = createBedrockEmbedding(
+ *   'amazon.titan-embed-text-v2:0',
+ *   'bedrock-api-key',
+ * );
+ *
+ * const result = await embed({
+ *   adapter,
+ *   input: 'a red guitar',
+ * });
+ * ```
+ */
+export function createBedrockEmbedding<TModel extends BedrockEmbeddingModel>(
+  model: TModel,
+  apiKey: string,
+  config?: Omit<BedrockEmbeddingConfig, 'apiKey'>,
+): BedrockEmbeddingAdapter<TModel> {
+  // Explicit apiKey is authoritative — spread config first so it can't override.
+  return new BedrockEmbeddingAdapter({ ...config, apiKey }, model)
+}
+
+/**
+ * Creates a Bedrock embedding adapter using the ambient auth cascade:
+ * `config.apiKey` → `BEDROCK_API_KEY` → `AWS_BEARER_TOKEN_BEDROCK` → SigV4
+ * (AWS credential provider chain). Auth resolves lazily on the first
+ * request, so `auth: 'sigv4'` never requires an API key.
+ *
+ * @param model - The model name (e.g., 'cohere.embed-english-v3')
+ * @param config - Optional configuration (region, auth, baseURL, ...)
+ * @returns Configured Bedrock embedding adapter instance with resolved types
+ *
+ * @example
+ * ```typescript
+ * const adapter = bedrockEmbedding('cohere.embed-english-v3');
+ *
+ * const result = await embed({
+ *   adapter,
+ *   input: ['a red guitar', 'a blue drum kit'],
+ *   modelOptions: { inputType: 'search_document' },
+ * });
+ *
+ * console.log(result.embeddings[0].vector)
+ * ```
+ */
+export function bedrockEmbedding<TModel extends BedrockEmbeddingModel>(
+  model: TModel,
+  config?: BedrockEmbeddingConfig,
+): BedrockEmbeddingAdapter<TModel> {
+  return new BedrockEmbeddingAdapter(config ?? {}, model)
+}