llm-strings 1.2.0 → 1.4.0

package/README.md

@@ -213,12 +213,10 @@ The AI SDK adapter is available as a separate subpath so you can load it only
 where you need it:
 
 ```ts
-import { parse } from "llm-strings";
-
 const { createAiSdkProviderOptions } = await import("llm-strings/ai-sdk");
 
 const { providerOptions } = createAiSdkProviderOptions(
-  parse("llm://api.anthropic.com/claude-sonnet-4-5?cache=1h&effort=max"),
+  "llm://api.anthropic.com/claude-sonnet-4-5?cache=1h&effort=max",
 );
 
 // {
@@ -468,7 +466,6 @@ Returns `true` if the Bedrock model supports prompt caching (Claude and Nova mod
 | `PARAM_SPECS`                 | Validation rules (type, min/max, enum) per provider, keyed by provider-specific param name |
 | `REASONING_MODEL_UNSUPPORTED` | Set of canonical params unsupported by reasoning models                                    |
 | `PROVIDER_META`               | Array of provider metadata (id, name, host, brand color) for UI integrations               |
-| `MODELS`                      | Suggested model IDs per provider                                                           |
 | `CANONICAL_PARAM_SPECS`       | Canonical param specs per provider with descriptions — useful for building UIs             |
 
 ## TypeScript
@@ -498,14 +495,10 @@ import type {
 
 ## Provider Metadata (for UI integrations)
 
-The library exports metadata useful for building UIs — provider names, brand colors, suggested models, and canonical parameter specs:
+The library exports metadata useful for building UIs — provider names, brand colors, and canonical parameter specs:
 
 ```ts
-import {
-  PROVIDER_META,
-  MODELS,
-  CANONICAL_PARAM_SPECS,
-} from "llm-strings/providers";
+import { PROVIDER_META, CANONICAL_PARAM_SPECS } from "llm-strings/providers";
 
 // Provider display info
 PROVIDER_META.forEach((p) => console.log(`${p.name}: ${p.host} (${p.color})`));
@@ -513,10 +506,6 @@ PROVIDER_META.forEach((p) => console.log(`${p.name}: ${p.host} (${p.color})`));
 // Anthropic: api.anthropic.com (#e8956a)
 // ...
 
-// Suggested models per provider
-MODELS.openai; // → ["gpt-5.2", "gpt-5.2-pro", "gpt-4.1", "gpt-4.1-mini", ...]
-MODELS.anthropic; // → ["claude-opus-4-6", "claude-sonnet-4-6", "claude-sonnet-4-5", ...]
-
 // Canonical param specs — useful for building config forms
 CANONICAL_PARAM_SPECS.openai.temperature;
 // → { type: "number", min: 0, max: 2, default: 0.7, description: "Controls randomness" }

package/dist/ai-sdk.cjs

@@ -28,11 +28,115 @@ module.exports = __toCommonJS(ai_sdk_exports);
 function hasOwn(object, key) {
   return Object.prototype.hasOwnProperty.call(object, key);
 }
+var HOST_ALIASES = {
+  openai: "api.openai.com",
+  azure: "models.inference.ai.azure.com",
+  anthropic: "api.anthropic.com",
+  google: "generativelanguage.googleapis.com",
+  "google-vertex": "aiplatform.googleapis.com",
+  aistudio: "generativelanguage.googleapis.com",
+  mistral: "api.mistral.ai",
+  cohere: "api.cohere.com",
+  bedrock: "bedrock-runtime.us-east-1.amazonaws.com",
+  openrouter: "openrouter.ai",
+  vercel: "gateway.ai.vercel.app",
+  alibaba: "dashscope-intl.aliyuncs.com",
+  alibabacloud: "dashscope-intl.aliyuncs.com",
+  dashscope: "dashscope-intl.aliyuncs.com",
+  groq: "api.groq.com",
+  fal: "fal.run",
+  fireworks: "api.fireworks.ai",
+  fireworksai: "api.fireworks.ai",
+  "black-forest-labs": "api.bfl.ai",
+  bfl: "api.bfl.ai",
+  deepseek: "api.deepseek.com",
+  moonshotai: "api.moonshot.ai",
+  moonshot: "api.moonshot.ai",
+  perplexity: "api.perplexity.ai",
+  venice: "api.venice.ai",
+  parasail: "api.parasail.io",
+  deepinfra: "api.deepinfra.com",
+  atlascloud: "api.atlascloud.ai",
+  novita: "api.novita.ai",
+  novitaai: "api.novita.ai",
+  grok: "api.x.ai",
+  xai: "api.x.ai",
+  together: "api.together.xyz",
+  togetherai: "api.together.xyz",
+  cerebras: "api.cerebras.ai",
+  replicate: "api.replicate.com",
+  prodia: "api.prodia.com",
+  luma: "api.lumalabs.ai",
+  bytedance: "ark.cn-beijing.volces.com",
+  kling: "api.klingai.com",
+  elevenlabs: "api.elevenlabs.io",
+  assemblyai: "api.assemblyai.com",
+  deepgram: "api.deepgram.com",
+  gladia: "api.gladia.io",
+  lmnt: "api.lmnt.com",
+  hume: "api.hume.ai",
+  revai: "api.rev.ai",
+  baseten: "api.baseten.co",
+  huggingface: "api-inference.huggingface.co",
+  wandb: "api.inference.wandb.ai",
+  weightsandbiases: "api.inference.wandb.ai",
+  baidu: "qianfan.baidubce.com",
+  qianfan: "qianfan.baidubce.com",
+  vertex: "aiplatform.googleapis.com",
+  xiaomi: "api.xiaomimimo.com",
+  minimax: "api.minimax.io"
+};
+var HOST_ALIAS_PROVIDERS = {
+  aistudio: "google",
+  vertex: "google-vertex",
+  grok: "xai",
+  bfl: "black-forest-labs",
+  moonshot: "moonshotai",
+  alibaba: "alibaba",
+  alibabacloud: "alibaba",
+  dashscope: "alibaba",
+  togetherai: "together",
+  fireworksai: "fireworks"
+};
+function readProcessEnv() {
+  return typeof process !== "undefined" && process.env ? process.env : {};
+}
+function normalizeHostValue(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return trimmed;
+  try {
+    if (trimmed.includes("://")) {
+      return new URL(trimmed).host;
+    }
+  } catch {
+  }
+  return trimmed.replace(/^\/\//, "").split("/")[0] ?? trimmed;
+}
+function envHostOverride(alias, env) {
+  const upper = alias.toUpperCase();
+  const override = env[`LLM_STRINGS_${upper}_HOST`] ?? env[`LLM_STRINGS_HOST_${upper}`];
+  return override?.trim() ? override : void 0;
+}
+function resolveHostAlias(host, env = readProcessEnv()) {
+  const normalizedHost = host.toLowerCase();
+  if (!hasOwn(HOST_ALIASES, normalizedHost)) {
+    return { host };
+  }
+  const alias = normalizedHost;
+  const override = envHostOverride(alias, env);
+  return {
+    host: normalizeHostValue(override ?? HOST_ALIASES[alias]),
+    alias
+  };
+}
 function providerFromHostAlias(alias) {
   const normalizedAlias = alias.toLowerCase();
   if (hasOwn(PROVIDER_PARAMS, normalizedAlias)) {
     return normalizedAlias;
   }
+  if (hasOwn(HOST_ALIAS_PROVIDERS, normalizedAlias)) {
+    return HOST_ALIAS_PROVIDERS[normalizedAlias];
+  }
   return void 0;
 }
 function detectProvider(host) {
@@ -40,6 +144,34 @@ function detectProvider(host) {
   if (host.includes("openrouter")) return "openrouter";
   if (host.includes("gateway.ai.vercel")) return "vercel";
   if (host.includes("amazonaws") || host.includes("bedrock")) return "bedrock";
+  if (host.includes("aiplatform.googleapis")) return "google-vertex";
+  if (host.includes("api.x.ai")) return "xai";
+  if (host.includes("groq")) return "groq";
+  if (host.includes("fal.run") || host.includes("fal.ai")) return "fal";
+  if (host.includes("deepinfra")) return "deepinfra";
+  if (host.includes("bfl.ai")) return "black-forest-labs";
+  if (host.includes("together")) return "together";
+  if (host.includes("fireworks")) return "fireworks";
+  if (host.includes("deepseek")) return "deepseek";
+  if (host.includes("moonshot")) return "moonshotai";
+  if (host.includes("perplexity")) return "perplexity";
+  if (host.includes("dashscope") || host.includes("aliyuncs")) return "alibaba";
+  if (host.includes("cerebras")) return "cerebras";
+  if (host.includes("replicate")) return "replicate";
+  if (host.includes("prodia")) return "prodia";
+  if (host.includes("lumalabs") || host.includes("luma")) return "luma";
+  if (host.includes("volces") || host.includes("bytedance")) return "bytedance";
+  if (host.includes("kling")) return "kling";
+  if (host.includes("elevenlabs")) return "elevenlabs";
+  if (host.includes("assemblyai")) return "assemblyai";
+  if (host.includes("deepgram")) return "deepgram";
+  if (host.includes("gladia")) return "gladia";
+  if (host.includes("lmnt")) return "lmnt";
+  if (host.includes("hume")) return "hume";
+  if (host.includes("rev.ai")) return "revai";
+  if (host.includes("baseten")) return "baseten";
+  if (host.includes("huggingface")) return "huggingface";
+  if (host.includes("azure")) return "azure";
   if (host.includes("openai")) return "openai";
   if (host.includes("anthropic") || host.includes("claude")) return "anthropic";
   if (host.includes("googleapis") || host.includes("google")) return "google";
@@ -94,6 +226,33 @@ var ALIASES = {
   cachePoint: "cache",
   cache_point: "cache"
 };
+var OPENAI_COMPATIBLE_PARAMS = {
+  temperature: "temperature",
+  max_tokens: "max_tokens",
+  top_p: "top_p",
+  top_k: "top_k",
+  frequency_penalty: "frequency_penalty",
+  presence_penalty: "presence_penalty",
+  stop: "stop",
+  n: "n",
+  seed: "seed",
+  stream: "stream",
+  effort: "reasoning_effort"
+};
+var GOOGLE_COMPATIBLE_PARAMS = {
+  temperature: "temperature",
+  max_tokens: "maxOutputTokens",
+  top_p: "topP",
+  top_k: "topK",
+  frequency_penalty: "frequencyPenalty",
+  presence_penalty: "presencePenalty",
+  stop: "stopSequences",
+  n: "candidateCount",
+  stream: "stream",
+  seed: "seed",
+  responseMimeType: "responseMimeType",
+  responseSchema: "responseSchema"
+};
 var PROVIDER_PARAMS = {
   openai: {
     temperature: "temperature",
@@ -107,6 +266,7 @@ var PROVIDER_PARAMS = {
     stream: "stream",
     effort: "reasoning_effort"
   },
+  azure: OPENAI_COMPATIBLE_PARAMS,
   anthropic: {
     temperature: "temperature",
     max_tokens: "max_tokens",
@@ -132,6 +292,7 @@ var PROVIDER_PARAMS = {
     responseMimeType: "responseMimeType",
     responseSchema: "responseSchema"
   },
+  "google-vertex": GOOGLE_COMPATIBLE_PARAMS,
   mistral: {
     temperature: "temperature",
     max_tokens: "max_tokens",
@@ -195,7 +356,33 @@ var PROVIDER_PARAMS = {
     seed: "seed",
     stream: "stream",
     effort: "reasoning_effort"
-  }
+  },
+  xai: OPENAI_COMPATIBLE_PARAMS,
+  groq: OPENAI_COMPATIBLE_PARAMS,
+  fal: {},
+  deepinfra: OPENAI_COMPATIBLE_PARAMS,
+  "black-forest-labs": {},
+  together: OPENAI_COMPATIBLE_PARAMS,
+  fireworks: OPENAI_COMPATIBLE_PARAMS,
+  deepseek: OPENAI_COMPATIBLE_PARAMS,
+  moonshotai: OPENAI_COMPATIBLE_PARAMS,
+  perplexity: OPENAI_COMPATIBLE_PARAMS,
+  alibaba: OPENAI_COMPATIBLE_PARAMS,
+  cerebras: OPENAI_COMPATIBLE_PARAMS,
+  replicate: {},
+  prodia: {},
+  luma: {},
+  bytedance: {},
+  kling: {},
+  elevenlabs: {},
+  assemblyai: {},
+  deepgram: {},
+  gladia: {},
+  lmnt: {},
+  hume: {},
+  revai: {},
+  baseten: OPENAI_COMPATIBLE_PARAMS,
+  huggingface: OPENAI_COMPATIBLE_PARAMS
 };
 function isReasoningModel(model) {
   const name = model.includes("/") ? model.split("/").pop() : model;
@@ -245,28 +432,84 @@ function bedrockSupportsCaching(model) {
 var CACHE_VALUES = {
   openai: void 0,
   // OpenAI auto-caches; no explicit param
+  azure: void 0,
   anthropic: "ephemeral",
   google: void 0,
   // Google uses explicit caching API, not a param
+  "google-vertex": void 0,
   mistral: void 0,
   cohere: void 0,
   bedrock: "ephemeral",
   // Supported for Claude models on Bedrock
   openrouter: void 0,
   // Depends on underlying provider
-  vercel: void 0
+  vercel: void 0,
   // Depends on underlying provider
+  xai: void 0,
+  groq: void 0,
+  fal: void 0,
+  deepinfra: void 0,
+  "black-forest-labs": void 0,
+  together: void 0,
+  fireworks: void 0,
+  deepseek: void 0,
+  moonshotai: void 0,
+  perplexity: void 0,
+  alibaba: void 0,
+  cerebras: void 0,
+  replicate: void 0,
+  prodia: void 0,
+  luma: void 0,
+  bytedance: void 0,
+  kling: void 0,
+  elevenlabs: void 0,
+  assemblyai: void 0,
+  deepgram: void 0,
+  gladia: void 0,
+  lmnt: void 0,
+  hume: void 0,
+  revai: void 0,
+  baseten: void 0,
+  huggingface: void 0
 };
 var CACHE_TTLS = {
   openai: void 0,
+  azure: void 0,
   anthropic: ["5m", "1h"],
   google: void 0,
+  "google-vertex": void 0,
   mistral: void 0,
   cohere: void 0,
   bedrock: ["5m", "1h"],
   // Claude on Bedrock uses same TTLs as direct Anthropic
   openrouter: void 0,
-  vercel: void 0
+  vercel: void 0,
+  xai: void 0,
+  groq: void 0,
+  fal: void 0,
+  deepinfra: void 0,
+  "black-forest-labs": void 0,
+  together: void 0,
+  fireworks: void 0,
+  deepseek: void 0,
+  moonshotai: void 0,
+  perplexity: void 0,
+  alibaba: void 0,
+  cerebras: void 0,
+  replicate: void 0,
+  prodia: void 0,
+  luma: void 0,
+  bytedance: void 0,
+  kling: void 0,
+  elevenlabs: void 0,
+  assemblyai: void 0,
+  deepgram: void 0,
+  gladia: void 0,
+  lmnt: void 0,
+  hume: void 0,
+  revai: void 0,
+  baseten: void 0,
+  huggingface: void 0
 };
 var DURATION_RE = /^\d+[mh]$/;
 
@@ -368,16 +611,71 @@ function normalize(config, options = {}) {
   };
 }
 
+// src/parse.ts
+function parse(connectionString) {
+  const url = new URL(connectionString);
+  if (url.protocol !== "llm:") {
+    throw new Error(
+      `Invalid scheme: expected "llm://", got "${url.protocol}//"`
+    );
+  }
+  const { host, alias: hostAlias } = resolveHostAlias(url.host);
+  const model = url.pathname.replace(/^\//, "");
+  const label = url.username || void 0;
+  const apiKey = url.password || void 0;
+  const params = {};
+  for (const [key, value] of url.searchParams) {
+    params[key] = value;
+  }
+  return {
+    raw: connectionString,
+    host,
+    hostAlias,
+    model,
+    label,
+    apiKey,
+    params
+  };
+}
+
 // src/ai-sdk.ts
 var PROVIDER_OPTION_KEYS = {
   openai: "openai",
+  azure: "azure",
   anthropic: "anthropic",
   google: "google",
+  "google-vertex": "vertex",
   mistral: "mistral",
   cohere: "cohere",
   bedrock: "bedrock",
   openrouter: "openrouter",
-  vercel: "gateway"
+  vercel: "gateway",
+  xai: "xai",
+  groq: "groq",
+  fal: "fal",
+  deepinfra: "deepinfra",
+  "black-forest-labs": "blackForestLabs",
+  together: "together",
+  fireworks: "fireworks",
+  deepseek: "deepseek",
+  moonshotai: "moonshotai",
+  perplexity: "perplexity",
+  alibaba: "alibaba",
+  cerebras: "cerebras",
+  replicate: "replicate",
+  prodia: "prodia",
+  luma: "luma",
+  bytedance: "bytedance",
+  kling: "kling",
+  elevenlabs: "elevenlabs",
+  assemblyai: "assemblyai",
+  deepgram: "deepgram",
+  gladia: "gladia",
+  lmnt: "lmnt",
+  hume: "hume",
+  revai: "revai",
+  baseten: "baseten",
+  huggingface: "huggingface"
 };
 var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
 var FALSE_VALUES = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
@@ -428,8 +726,7 @@ function mergeObjectOption(options, provider, key, value) {
     setProviderOption(options, provider, key, parsed);
   }
 }
-function addOpenAiOption(options, key, value) {
-  const target = "openai";
+function addOpenAiOption(options, key, value, target = "openai") {
   const mappings = {
     reasoning_effort: "reasoningEffort",
     max_completion_tokens: "maxCompletionTokens",
@@ -541,8 +838,7 @@ function addAnthropicOption(options, key, value) {
   }
   setProviderOption(options, target, optionKey, typedValue(value));
 }
-function addGoogleOption(options, key, value) {
-  const target = "google";
+function addGoogleOption(options, key, value, target = "google") {
   if (key === "thinking_budget" || key === "thinking_level" || key === "include_thoughts") {
     const current = options[target]?.thinkingConfig;
     const thinkingConfig = current && typeof current === "object" && !Array.isArray(current) ? { ...current } : {};
@@ -778,21 +1074,71 @@ function addOpenRouterOption(options, key, value) {
     setProviderOption(options, target, "user", value);
   }
 }
+function addFlexibleProviderOption(options, target, key, value) {
+  setProviderOption(options, target, key, typedValue(value));
+}
 function addProviderSpecificOption(options, provider, key, value, includeGatewayOptions) {
   if (provider === "vercel") {
     if (includeGatewayOptions) addGatewayOption(options, key, value);
     return;
   }
   if (provider === "openai") addOpenAiOption(options, key, value);
+  if (provider === "azure") addOpenAiOption(options, key, value, "azure");
   if (provider === "anthropic") addAnthropicOption(options, key, value);
   if (provider === "google") addGoogleOption(options, key, value);
+  if (provider === "google-vertex")
+    addGoogleOption(options, key, value, "vertex");
   if (provider === "mistral") addMistralOption(options, key, value);
   if (provider === "cohere") addCohereOption(options, key, value);
   if (provider === "bedrock") addBedrockOption(options, key, value);
   if (provider === "openrouter") addOpenRouterOption(options, key, value);
+  if (provider === "xai") addOpenAiOption(options, key, value, "xai");
+  if (provider === "groq") addOpenAiOption(options, key, value, "groq");
+  if (provider === "fal") addFlexibleProviderOption(options, "fal", key, value);
+  if (provider === "deepinfra")
+    addOpenAiOption(options, key, value, "deepinfra");
+  if (provider === "black-forest-labs")
+    addFlexibleProviderOption(options, "blackForestLabs", key, value);
+  if (provider === "together") addOpenAiOption(options, key, value, "together");
+  if (provider === "fireworks")
+    addOpenAiOption(options, key, value, "fireworks");
+  if (provider === "deepseek") addOpenAiOption(options, key, value, "deepseek");
+  if (provider === "moonshotai")
+    addOpenAiOption(options, key, value, "moonshotai");
+  if (provider === "perplexity")
+    addOpenAiOption(options, key, value, "perplexity");
+  if (provider === "alibaba") addOpenAiOption(options, key, value, "alibaba");
+  if (provider === "cerebras") addOpenAiOption(options, key, value, "cerebras");
+  if (provider === "replicate")
+    addFlexibleProviderOption(options, "replicate", key, value);
+  if (provider === "prodia")
+    addFlexibleProviderOption(options, "prodia", key, value);
+  if (provider === "luma")
+    addFlexibleProviderOption(options, "luma", key, value);
+  if (provider === "bytedance")
+    addFlexibleProviderOption(options, "bytedance", key, value);
+  if (provider === "kling")
+    addFlexibleProviderOption(options, "kling", key, value);
+  if (provider === "elevenlabs")
+    addFlexibleProviderOption(options, "elevenlabs", key, value);
+  if (provider === "assemblyai")
+    addFlexibleProviderOption(options, "assemblyai", key, value);
+  if (provider === "deepgram")
+    addFlexibleProviderOption(options, "deepgram", key, value);
+  if (provider === "gladia")
+    addFlexibleProviderOption(options, "gladia", key, value);
+  if (provider === "lmnt")
+    addFlexibleProviderOption(options, "lmnt", key, value);
+  if (provider === "hume")
+    addFlexibleProviderOption(options, "hume", key, value);
+  if (provider === "revai")
+    addFlexibleProviderOption(options, "revai", key, value);
+  if (provider === "baseten") addOpenAiOption(options, key, value, "baseten");
+  if (provider === "huggingface")
+    addOpenAiOption(options, key, value, "huggingface");
 }
 function createAiSdkProviderOptions(configOrResult, options = {}) {
-  const normalized = "changes" in configOrResult && "subProvider" in configOrResult ? configOrResult : normalize(configOrResult, options);
+  const normalized = typeof configOrResult === "string" ? normalize(parse(configOrResult), options) : "changes" in configOrResult && "subProvider" in configOrResult ? configOrResult : normalize(configOrResult, options);
   const providerOptions = {};
   if (!normalized.provider) {
     return {
@@ -828,4 +1174,3 @@ function createAiSdkProviderOptions(configOrResult, options = {}) {
 0 && (module.exports = {
   createAiSdkProviderOptions
 });
-//# sourceMappingURL=ai-sdk.cjs.map

package/dist/ai-sdk.d.cts

@@ -1,6 +1,6 @@
-import { NormalizeOptions, NormalizeResult } from './normalize.cjs';
+import { NormalizeResult, NormalizeOptions } from './normalize.cjs';
 import { LlmConnectionConfig } from './parse.cjs';
-import { P as Provider } from './provider-core-BiAl8MCV.cjs';
+import { P as Provider } from './provider-core-B934MuhJ.cjs';
 
 type AiSdkProviderOptions = Record<string, Record<string, unknown>>;
 interface AiSdkProviderOptionsResult {
@@ -15,6 +15,7 @@ interface AiSdkProviderOptionsOptions extends NormalizeOptions {
      */
     includeGatewayOptions?: boolean;
 }
+type AiSdkProviderOptionsInput = string | LlmConnectionConfig | NormalizeResult;
 /**
  * Build AI SDK `providerOptions` from an LLM connection config.
  *
@@ -22,6 +23,6 @@ interface AiSdkProviderOptionsOptions extends NormalizeOptions {
  * `maxOutputTokens` are intentionally not emitted here. This helper only emits
  * provider-specific AI SDK options under the correct provider key.
  */
-declare function createAiSdkProviderOptions(configOrResult: LlmConnectionConfig | NormalizeResult, options?: AiSdkProviderOptionsOptions): AiSdkProviderOptionsResult;
+declare function createAiSdkProviderOptions(configOrResult: AiSdkProviderOptionsInput, options?: AiSdkProviderOptionsOptions): AiSdkProviderOptionsResult;
 
-export { type AiSdkProviderOptions, type AiSdkProviderOptionsOptions, type AiSdkProviderOptionsResult, createAiSdkProviderOptions };
+export { type AiSdkProviderOptions, type AiSdkProviderOptionsInput, type AiSdkProviderOptionsOptions, type AiSdkProviderOptionsResult, createAiSdkProviderOptions };

package/dist/ai-sdk.d.ts

@@ -1,6 +1,6 @@
-import { NormalizeOptions, NormalizeResult } from './normalize.js';
+import { NormalizeResult, NormalizeOptions } from './normalize.js';
 import { LlmConnectionConfig } from './parse.js';
-import { P as Provider } from './provider-core-BiAl8MCV.js';
+import { P as Provider } from './provider-core-B934MuhJ.js';
 
 type AiSdkProviderOptions = Record<string, Record<string, unknown>>;
 interface AiSdkProviderOptionsResult {
@@ -15,6 +15,7 @@ interface AiSdkProviderOptionsOptions extends NormalizeOptions {
      */
     includeGatewayOptions?: boolean;
 }
+type AiSdkProviderOptionsInput = string | LlmConnectionConfig | NormalizeResult;
 /**
  * Build AI SDK `providerOptions` from an LLM connection config.
  *
@@ -22,6 +23,6 @@ interface AiSdkProviderOptionsOptions extends NormalizeOptions {
  * `maxOutputTokens` are intentionally not emitted here. This helper only emits
  * provider-specific AI SDK options under the correct provider key.
  */
-declare function createAiSdkProviderOptions(configOrResult: LlmConnectionConfig | NormalizeResult, options?: AiSdkProviderOptionsOptions): AiSdkProviderOptionsResult;
+declare function createAiSdkProviderOptions(configOrResult: AiSdkProviderOptionsInput, options?: AiSdkProviderOptionsOptions): AiSdkProviderOptionsResult;
 
-export { type AiSdkProviderOptions, type AiSdkProviderOptionsOptions, type AiSdkProviderOptionsResult, createAiSdkProviderOptions };
+export { type AiSdkProviderOptions, type AiSdkProviderOptionsInput, type AiSdkProviderOptionsOptions, type AiSdkProviderOptionsResult, createAiSdkProviderOptions };