@shop-os/modelkit 0.2.10 → 0.2.12

package/dist/index.cjs

@@ -63,6 +63,7 @@ __export(index_exports, {
   generateVideo: () => generateVideo,
   googleGenaiAdapter: () => googleGenaiAdapter,
   googleImageAdapter: () => googleImageAdapter,
+  hasAwsCredentials: () => hasAwsCredentials,
   higgsfieldAdapter: () => higgsfieldAdapter,
   isListed: () => isListed,
   isListedOn: () => isListedOn,
@@ -100,6 +101,14 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 __reExport(index_exports, require("ai"), module.exports);
 
+// src/types.ts
+function hasAwsCredentials(aws) {
+  if (!aws || !aws.region) return false;
+  if (aws.apiKey) return true;
+  if (aws.credentialProvider) return true;
+  return Boolean(aws.accessKeyId && aws.secretAccessKey);
+}
+
 // src/errors.ts
 var ModelKitError = class extends Error {
   code;
@@ -2136,7 +2145,18 @@ var CatalogModelSchemaBase = import_zod.z.looseObject({
     });
   }
 });
-var CatalogModelSchema = CatalogModelSchemaBase;
+var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
+  (row, ctx) => {
+    const transport = row.providerOptions?.["modelkit"]?.["transport"];
+    if (transport !== void 0 && transport !== "direct" && transport !== "bedrock") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["providerOptions", "modelkit", "transport"],
+        message: 'transport must be "direct" or "bedrock"'
+      });
+    }
+  }
+);
 var CatalogSchema = import_zod.z.array(CatalogModelSchemaBase).superRefine((rows, ctx) => {
   const seenIds = /* @__PURE__ */ new Map();
   rows.forEach((row, index) => {
@@ -2741,9 +2761,12 @@ var ADAPTER_KEYS = {
 function hasAll(keys, names) {
   if (!keys) return false;
   return names.every(
-    (n) => Boolean(keys[n]) && (n !== "higgsfield" || Boolean(keys.higgsfieldSecret))
+    (n) => n === "aws" ? hasAwsCredentials(keys.aws) : Boolean(keys[n]) && (n !== "higgsfield" || Boolean(keys.higgsfieldSecret))
   );
 }
+function hasKey(keys, name) {
+  return hasAll(keys, [name]);
+}
 function missingEnterpriseKeys(config, names) {
   return names.filter((name) => !hasAll(config.keys.enterprise, [name]));
 }
@@ -2780,6 +2803,22 @@ function keysFromEnv(env, prefix = "") {
   set("higgsfield", pick("HIGGSFIELD_API_KEY"));
   set("higgsfieldSecret", pick("HIGGSFIELD_API_SECRET"));
   set("cloudflare", pick("CLOUDFLARE_AI_GATEWAY_TOKEN", "CF_AIG_TOKEN"));
+  const bearer = pick("AWS_BEARER_TOKEN_BEDROCK");
+  const accessKeyId = pick("AWS_ACCESS_KEY_ID");
+  const secretAccessKey = pick("AWS_SECRET_ACCESS_KEY");
+  if (bearer || accessKeyId && secretAccessKey) {
+    const aws = {
+      region: env[`${prefix}BEDROCK_REGION`] || "us-east-1"
+    };
+    if (accessKeyId && secretAccessKey) {
+      aws.accessKeyId = accessKeyId;
+      aws.secretAccessKey = secretAccessKey;
+    }
+    const sessionToken = pick("AWS_SESSION_TOKEN");
+    if (sessionToken) aws.sessionToken = sessionToken;
+    if (bearer) aws.apiKey = bearer;
+    keys.aws = aws;
+  }
   return keys;
 }
 
@@ -3108,7 +3147,8 @@ function toGeneratedImage(image) {
 }
 
 // src/adapters/ai-sdk-text.ts
-var import_anthropic = require("@ai-sdk/anthropic");
+var import_anthropic = require("@ai-sdk/amazon-bedrock/anthropic");
+var import_anthropic2 = require("@ai-sdk/anthropic");
 var import_google = require("@ai-sdk/google");
 var import_openai = require("@ai-sdk/openai");
 var import_openai_compatible = require("@ai-sdk/openai-compatible");
@@ -3159,16 +3199,47 @@ function detectTextProvider(modelId) {
     message: `ai-sdk-text cannot detect a provider for "${modelId}". Set providerOptions.provider to one of ${TEXT_PROVIDERS.join(", ")}.`
   });
 }
-function textKeyName(model, _routing) {
-  return textProviderOf(model);
+function textKeyName(model, transport) {
+  const provider = textProviderOf(model);
+  return provider === "anthropic" && transport === "bedrock" ? "aws" : provider;
 }
 function textProviderOf(model) {
   const explicit = model.providerOptions?.["modelkit"]?.["provider"];
   return isTextProvider(explicit) ? explicit : detectTextProvider(model.providerModelId);
 }
-function textUsesCloudflareGateway(model, routing) {
+function textUsesCloudflareGateway(model, routing, transport) {
   if (routing.text !== "cloudflare") return false;
-  return GATEWAY_SLUGS[textProviderOf(model)] !== void 0;
+  const provider = textProviderOf(model);
+  if (provider === "anthropic" && transport === "bedrock") return false;
+  return GATEWAY_SLUGS[provider] !== void 0;
+}
+var BEDROCK_DATED_MODEL_IDS = {
+  "claude-haiku-4-5": "anthropic.claude-haiku-4-5-20251001-v1:0",
+  "claude-haiku-4-5-20251001": "anthropic.claude-haiku-4-5-20251001-v1:0",
+  "claude-sonnet-4-5": "anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "claude-sonnet-4-5-20250929": "anthropic.claude-sonnet-4-5-20250929-v1:0"
+};
+var BEDROCK_PROFILE_PREFIXES = ["us.", "global.", "eu.", "jp.", "au.", "apac."];
+function toBedrockModelId(model, routing) {
+  const profile = routing.bedrockProfile ?? "us";
+  const override = model.providerOptions?.["modelkit"]?.["bedrockModelId"];
+  if (typeof override === "string" && override.length > 0) {
+    if (BEDROCK_PROFILE_PREFIXES.some((prefix) => override.startsWith(prefix))) return override;
+    if (override.startsWith("anthropic.")) return `${profile}.${override}`;
+    return override;
+  }
+  const id = model.providerModelId;
+  if (BEDROCK_PROFILE_PREFIXES.some((prefix) => id.startsWith(prefix))) return id;
+  const dated = BEDROCK_DATED_MODEL_IDS[id];
+  if (dated) return `${profile}.${dated}`;
+  if (id.startsWith("claude-")) return `${profile}.anthropic.${id}`;
+  throw new ModelKitError({
+    code: "unsupported_option",
+    message: `No Bedrock model id for "${id}". Set providerOptions.modelkit.bedrockModelId on the catalog row.`,
+    provider: "ai-sdk-text",
+    model: model.id,
+    retryable: false
+  });
 }
 function nativeClientFor(provider) {
   switch (provider) {
@@ -3193,14 +3264,14 @@ function nativeClientFor(provider) {
 function resolveTextRoute(ctx) {
   const provider = textProviderOf(ctx.model);
   const mode = ctx.routing.text ?? "direct";
-  if (provider === "anthropic" && ctx.routing.anthropic === "bedrock") {
-    throw new ModelKitError({
-      code: "unsupported_option",
-      message: "ai-sdk-text has no Bedrock transport (@ai-sdk/amazon-bedrock is not installed). Pass the Bedrock model through catalogOverride with providerOptions.bedrockModel and resolve it outside the SDK.",
-      provider: "ai-sdk-text",
-      model: ctx.model.id,
-      retryable: false
-    });
+  if (provider === "anthropic" && ctx.anthropicTransport === "bedrock") {
+    return {
+      provider,
+      client: "bedrock-anthropic",
+      modelId: toBedrockModelId(ctx.model, ctx.routing),
+      keyName: "aws",
+      canonicalModelId: ctx.model.id
+    };
   }
   const compatBase = OPENAI_COMPATIBLE_BASE_URLS[provider];
   const route2 = {
@@ -3244,6 +3315,70 @@ function missingKey(ctx, name) {
     retryable: false
   });
 }
+function bedrockMiddleware(ctx, canonicalModelId) {
+  let warned = false;
+  return {
+    specificationVersion: "v3",
+    transformParams: async ({ params }) => {
+      const anthropic = params.providerOptions?.["anthropic"];
+      if (typeof anthropic !== "object" || anthropic === null || !("cacheControl" in anthropic))
+        return params;
+      if (!warned) {
+        warned = true;
+        ctx.logger.warn(
+          `[modelkit] ${canonicalModelId} drops call-level providerOptions.anthropic.cacheControl: not supported on Bedrock, use message-level cacheControl`
+        );
+      }
+      const { cacheControl: _dropped, ...rest } = anthropic;
+      return {
+        ...params,
+        providerOptions: { ...params.providerOptions, anthropic: rest }
+      };
+    },
+    // Bedrock echoes its own id for dated models (anthropic.claude-haiku-4-5-20251001-v1:0),
+    // and consumers bill on response.modelId.
+    wrapGenerate: async ({ doGenerate }) => {
+      const result = await doGenerate();
+      if (!result.response) return result;
+      return { ...result, response: { ...result.response, modelId: canonicalModelId } };
+    },
+    wrapStream: async ({ doStream }) => {
+      const result = await doStream();
+      return {
+        ...result,
+        stream: result.stream.pipeThrough(
+          new TransformStream({
+            transform(part, controller) {
+              controller.enqueue(
+                part.type === "response-metadata" && part.modelId !== void 0 ? { ...part, modelId: canonicalModelId } : part
+              );
+            }
+          })
+        )
+      };
+    }
+  };
+}
+function bedrockLanguageModel(ctx, route2) {
+  const aws = ctx.keys.aws;
+  if (!hasAwsCredentials(aws)) throw missingKey(ctx, "aws");
+  const canonical = route2.canonicalModelId ?? ctx.model.id;
+  const inner = (0, import_anthropic.createBedrockAnthropic)({
+    region: aws.region,
+    fetch: ctx.fetch,
+    ...aws.apiKey ? { apiKey: aws.apiKey } : aws.credentialProvider ? { credentialProvider: aws.credentialProvider } : aws.accessKeyId !== void 0 && aws.secretAccessKey !== void 0 ? {
+      accessKeyId: aws.accessKeyId,
+      secretAccessKey: aws.secretAccessKey,
+      ...aws.sessionToken !== void 0 ? { sessionToken: aws.sessionToken } : {}
+    } : {}
+  })(route2.modelId);
+  return (0, import_ai2.wrapLanguageModel)({
+    model: inner,
+    middleware: bedrockMiddleware(ctx, canonical),
+    modelId: canonical,
+    providerId: "anthropic.messages"
+  });
+}
 function minimaxDefaults(params) {
   return params.responseFormat?.type === "json" ? { reasoning_split: true, thinking: { type: "disabled" } } : { reasoning_split: true };
 }
@@ -3282,14 +3417,17 @@ var aiSdkTextAdapter = {
   id: "ai-sdk-text",
   languageModel(ctx) {
     const route2 = resolveTextRoute(ctx);
-    const apiKey = ctx.keys[route2.keyName];
-    if (!apiKey) throw missingKey(ctx, route2.keyName);
+    if (route2.client === "bedrock-anthropic") return bedrockLanguageModel(ctx, route2);
+    const { keyName } = route2;
+    if (keyName === "aws") throw missingKey(ctx, keyName);
+    const apiKey = ctx.keys[keyName];
+    if (!apiKey) throw missingKey(ctx, keyName);
     const settings = { apiKey, fetch: ctx.fetch };
     if (route2.baseURL !== void 0) settings.baseURL = route2.baseURL;
     if (route2.headers !== void 0) settings.headers = route2.headers;
     switch (route2.client) {
       case "anthropic":
-        return (0, import_anthropic.createAnthropic)(settings)(route2.modelId);
+        return (0, import_anthropic2.createAnthropic)(settings)(route2.modelId);
       case "google":
         return (0, import_google.createGoogleGenerativeAI)(settings)(route2.modelId);
       case "xai":
@@ -3322,14 +3460,47 @@ var aiSdkTextAdapter = {
   }
 };
 
+// src/anthropic-transport.ts
+var ANTHROPIC_TRANSPORTS = ["direct", "bedrock"];
+function isAnthropicTransport(value) {
+  return ANTHROPIC_TRANSPORTS.some((transport) => transport === value);
+}
+function preferredAnthropicTransport(model, routing) {
+  const row = model.providerOptions?.["modelkit"]?.["transport"];
+  if (isAnthropicTransport(row)) return row;
+  return routing.anthropic ?? "direct";
+}
+function resolveAnthropicTransport(model, config, tier, warn) {
+  if (model.adapter !== "ai-sdk-text" || textProviderOf(model) !== "anthropic") return void 0;
+  const rowValue = model.providerOptions?.["modelkit"]?.["transport"];
+  if (rowValue !== void 0 && !isAnthropicTransport(rowValue))
+    warn(
+      `[modelkit] ${model.id} has an unknown providerOptions.modelkit.transport "${String(rowValue)}"; ignoring it`
+    );
+  const preferred = preferredAnthropicTransport(model, config.routing ?? {});
+  const usable = (transport) => {
+    const name = transport === "bedrock" ? "aws" : "anthropic";
+    return hasKey(config.keys.pro, name) || tier === "enterprise" && hasKey(config.keys.enterprise, name);
+  };
+  if (usable(preferred)) return preferred;
+  const other = preferred === "bedrock" ? "direct" : "bedrock";
+  if (!usable(other)) return preferred;
+  warn(`[modelkit] ${model.id}: no credentials for the ${preferred} transport; using ${other}`);
+  return other;
+}
+var BEDROCK_USAGE_PROVIDER = "bedrock";
+function textUsageProvider(model, transport) {
+  return transport === "bedrock" ? BEDROCK_USAGE_PROVIDER : textProviderOf(model);
+}
+
 // src/client.ts
-function requiredKeys(model, config) {
+function requiredKeys(model, config, transport) {
   if (model.adapter === "fal" && config.routing?.fal === "cloudflare-passthrough")
     return ["cloudflare"];
   if (model.adapter === "ai-sdk-text") {
     const routing = config.routing ?? {};
-    const names = [textKeyName(model, routing)];
-    if (textUsesCloudflareGateway(model, routing)) names.push("cloudflare");
+    const names = [textKeyName(model, transport)];
+    if (textUsesCloudflareGateway(model, routing, transport)) names.push("cloudflare");
     return names;
   }
   return ADAPTER_KEYS[model.adapter];
@@ -3416,6 +3587,12 @@ function createModelKit(config, adapters) {
   const catalog = config.catalogOverride ? liveCatalog.withOverrides(config.catalogOverride) : liveCatalog;
   const logger = config.logger ?? console;
   const fetchImpl = config.fetch ?? globalThis.fetch;
+  const transportWarnings = /* @__PURE__ */ new Set();
+  function warnOnce(message) {
+    if (transportWarnings.has(message)) return;
+    transportWarnings.add(message);
+    logger.warn(message);
+  }
   function context(model, call, warnings) {
     const adapter = adapters[model.adapter];
     if (!adapter)
@@ -3424,7 +3601,8 @@ function createModelKit(config, adapters) {
         message: `No adapter registered for ${model.adapter}`,
         model: model.id
       });
-    const names = requiredKeys(model, config);
+    const transport = resolveAnthropicTransport(model, config, call.tier, warnOnce);
+    const names = requiredKeys(model, config, transport);
     if (call.tier === "enterprise") {
       const missing = missingEnterpriseKeys(config, names);
       if (missing.length > 0)
@@ -3443,6 +3621,7 @@ function createModelKit(config, adapters) {
       call,
       warnings
     };
+    if (transport) ctx.anthropicTransport = transport;
     if (config.endpoints) ctx.endpoints = config.endpoints;
     if (call.signal) ctx.signal = call.signal;
     return { adapter, ctx };
@@ -3483,7 +3662,7 @@ function createModelKit(config, adapters) {
     return {
       entry,
       languageModel: adapter.languageModel(ctx),
-      provider: textProviderOf(entry)
+      provider: textUsageProvider(entry, ctx.anthropicTransport)
     };
   }
   async function passthroughImage(req, call) {
@@ -3777,12 +3956,12 @@ function createModelKit(config, adapters) {
     async prepareMediaPart(modelId, ref, mediaType, call = {}) {
       const model = catalog.require(modelId);
       const { adapter, ctx } = context(model, call, []);
-      const fileStore = model.adapter === "ai-sdk-text" && textKeyName(model, config.routing ?? {}) === "google" ? adapters["google-genai"] : adapter;
+      const fileStore = model.adapter === "ai-sdk-text" && textKeyName(model) === "google" ? adapters["google-genai"] : adapter;
       if (fileStore?.prepareMediaPart) return fileStore.prepareMediaPart(ref, mediaType, ctx);
       return "url" in ref ? { type: "file", data: ref.url, mediaType } : { type: "file", data: ref.bytes, mediaType };
     },
     languageModel(modelId, call = {}) {
-      const { entry, languageModel: model } = textTarget(modelId, call);
+      const { entry, languageModel: model, provider } = textTarget(modelId, call);
       if (model.specificationVersion !== "v3")
         throw new ModelKitError({
           code: "unsupported_option",
@@ -3792,9 +3971,18 @@ function createModelKit(config, adapters) {
       return {
         model,
         providerOptions: withoutModelkit(entry.providerOptions),
-        catalog: entry
+        catalog: entry,
+        usageProvider: provider
       };
     },
+    usageProvider(modelId, call = {}) {
+      const entry = catalog.require(modelId);
+      if (entry.type !== "text") return entry.adapter;
+      return textUsageProvider(
+        entry,
+        resolveAnthropicTransport(entry, config, call.tier, warnOnce)
+      );
+    },
     async generateText(options, call = {}) {
       const target = textTarget(options.model, call);
       const steps = createTextSteps(
@@ -7569,6 +7757,7 @@ var describe = (modelId) => createDefaultModelKit().describe(modelId);
   generateVideo,
   googleGenaiAdapter,
   googleImageAdapter,
+  hasAwsCredentials,
   higgsfieldAdapter,
   isListed,
   isListedOn,