@every-app/sdk 0.2.0 → 0.3.0-rc.10

package/dist/internal/aiDefault.js

@@ -0,0 +1,334 @@
+/**
+ * The Gateway's default model provider: what an app that says "I need a
+ * chat model" (manifest `ai: { chat: true }`, the SDK's `ai()`, the route
+ * `/api/ai/default/…`) is served (docs/design/2026-10-model-providers.md).
+ *
+ * The default is resolved, never assumed: the operator's choice when one
+ * is stored (`everyapp ai default <provider>[/<model>]`, Manage workspace
+ * → Usage → AI default), else the shipped order below, first provider
+ * whose Gateway settings are all set; with none set, the first of the
+ * order with the settings it needs, so "Needs setup" asks for one key.
+ * OpenRouter comes first because one key reaches many models; Workers AI
+ * second because it needs no provider account (the Gateway's own
+ * Cloudflare token), with weaker models; then the single-vendor keys.
+ * Cloudflare AI Gateway is never a default: it has no models of its own
+ * and fronts whichever provider the default resolves to when
+ * `AI_GATEWAY_ID` is set (./capabilities.ts, `aig`).
+ *
+ * The models resolve the same way: the operator's model setting for the
+ * provider (`everyapp ai model <provider> --chat … --embeddings …`,
+ * `org_settings.ai_models`), else the catalog entry's seed (`chat.seedModel`,
+ * `embeddings.seedModel`). Nothing reads a seed except through here.
+ *
+ * Everything here is pure: what is set is asked of the caller (`isSet`),
+ * which reads the Gateway's env, the Worker's secret names, or `.dev.vars`.
+ */
+import { CATALOG, } from "./capabilities.js";
+/** The reserved provider id apps call for the default: `/api/ai/default/…`. */
+export const AI_DEFAULT_PROVIDER = "default";
+/** The catalog id of Cloudflare AI Gateway, the proxy entry. */
+export const AI_GATEWAY_PROVIDER = "ai-gateway";
+/** The settings that make AI Gateway front the providers that have a slug. */
+export const AI_GATEWAY_SETTINGS = [
+    "AI_GATEWAY_ID",
+    "CLOUDFLARE_ACCOUNT_ID",
+];
+/**
+ * The shipped order: the provider the default resolves to when the
+ * operator chose none, the first of these whose settings are set.
+ */
+export const AI_DEFAULT_ORDER = [
+    "openrouter",
+    "workers-ai",
+    "openai",
+    "anthropic",
+    "groq",
+    "mistral",
+    "gemini",
+];
+/** The model name an app sends to mean "the default's model". */
+export const AI_DEFAULT_MODEL = "default";
+/** The paths an app calls under `/api/ai/default`, OpenAI-shaped. */
+export const AI_DEFAULT_ROUTES = {
+    chat: "/v1/chat/completions",
+    embeddings: "/v1/embeddings",
+};
+/** Whether `value` can be a model id: 1 to 200 characters, no surrounding or control whitespace. */
+export function isAiModelName(value) {
+    return (value.length >= 1 &&
+        value.length <= 200 &&
+        value.trim() === value &&
+        !/[\u0000-\u001f\u007f]/.test(value));
+}
+/**
+ * `org_settings.ai_models` as stored: a JSON object of provider id →
+ * `{ chat?, embeddings? }`. Anything else (null, malformed JSON, a field
+ * that isn't a model name) reads as no setting, so the seed serves.
+ */
+export function parseAiModelSettings(value) {
+    if (typeof value !== "string" || value.trim() === "")
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return {};
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return {};
+    const settings = {};
+    for (const [provider, entry] of Object.entries(parsed)) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const setting = {};
+        for (const kind of ["chat", "embeddings"]) {
+            const model = entry[kind];
+            if (typeof model === "string" && isAiModelName(model)) {
+                setting[kind] = model;
+            }
+        }
+        if (setting.chat !== undefined || setting.embeddings !== undefined) {
+            settings[provider] = setting;
+        }
+    }
+    return settings;
+}
+/** The stored text of the settings, providers sorted; null when nothing is set. */
+export function formatAiModelSettings(settings) {
+    const providers = Object.keys(settings)
+        .filter((id) => settings[id]?.chat !== undefined ||
+        settings[id]?.embeddings !== undefined)
+        .sort();
+    if (providers.length === 0)
+        return null;
+    return JSON.stringify(Object.fromEntries(providers.map((id) => {
+        const { chat, embeddings } = settings[id];
+        return [
+            id,
+            {
+                ...(chat === undefined ? {} : { chat }),
+                ...(embeddings === undefined ? {} : { embeddings }),
+            },
+        ];
+    })));
+}
+/** `settings` with one provider's models changed by `patch`. */
+export function withAiModelSetting(settings, provider, patch) {
+    const next = { ...settings[provider] };
+    for (const kind of ["chat", "embeddings"]) {
+        const value = patch[kind];
+        if (value === null)
+            delete next[kind];
+        else if (value !== undefined)
+            next[kind] = value;
+    }
+    const rest = Object.fromEntries(Object.entries(settings).filter(([id]) => id !== provider));
+    return next.chat === undefined && next.embeddings === undefined
+        ? rest
+        : { ...rest, [provider]: next };
+}
+/** A choice must name a provider id; the model is free text after the first slash. */
+const CHOICE = /^([a-z][a-z0-9-]{1,39})(?:\/(.{1,200}))?$/;
+/**
+ * `openrouter` or `openrouter/anthropic/claude-haiku-5.5` as typed:
+ * the provider id up to the first slash, the model after it (a model id
+ * may hold slashes of its own). Null for blank or malformed text.
+ */
+export function parseAiDefaultChoice(value) {
+    if (typeof value !== "string")
+        return null;
+    const match = CHOICE.exec(value.trim());
+    if (!match)
+        return null;
+    const model = match[2]?.trim();
+    return model ? { provider: match[1], model } : { provider: match[1] };
+}
+/** The text of a choice: `provider` or `provider/model`. */
+export function formatAiDefaultChoice(choice) {
+    return choice.model ? `${choice.provider}/${choice.model}` : choice.provider;
+}
+/**
+ * The provider id `org_settings.ai_default` holds, or null. The column
+ * holds the provider alone (its models are in `ai_models`); text after a
+ * first slash is not read.
+ */
+export function parseAiDefaultProvider(value) {
+    return parseAiDefaultChoice(value)?.provider ?? null;
+}
+export function canBeAiDefault(capability) {
+    return (capability?.mode === "ai" &&
+        capability.kind !== "proxy" &&
+        capability.chat !== undefined);
+}
+/**
+ * The Gateway settings an `ai` entry needs before it serves: its key
+ * (unless the entry works without one, `authOptional`) and what its URL
+ * needs besides (`alsoNeeds`).
+ */
+export function aiRequiredSettings(capability) {
+    return [
+        ...(capability.authOptional ? [] : [capability.auth.secret]),
+        ...(capability.alsoNeeds ?? []),
+    ];
+}
+/** Whether every setting the entry needs is set. */
+export function aiProviderConfigured(capability, isSet) {
+    return aiRequiredSettings(capability).every((name) => isSet(name));
+}
+/** Whether AI Gateway fronts calls: its id and the account are set. */
+export function aiGatewayConfigured(isSet) {
+    return AI_GATEWAY_SETTINGS.every((name) => isSet(name));
+}
+/** Whether a call to `capability` goes through AI Gateway: it is configured and the entry has a slug. */
+export function viaAiGateway(capability, isSet) {
+    return capability.aig !== undefined && aiGatewayConfigured(isSet);
+}
+/** The provider's models: the operator's setting, else the seed. */
+function modelsOf(id, capability, models) {
+    const setting = models[id];
+    const { chat, embeddings } = capability;
+    return {
+        model: setting?.chat ?? chat.seedModel,
+        ...(embeddings
+            ? { embeddingsModel: setting?.embeddings ?? embeddings.seedModel }
+            : {}),
+        seed: {
+            chat: chat.seedModel,
+            ...(embeddings ? { embeddings: embeddings.seedModel } : {}),
+        },
+    };
+}
+function candidateOf(id, capability, isSet, models) {
+    return {
+        id,
+        label: capability.label,
+        settings: aiRequiredSettings(capability),
+        configured: aiProviderConfigured(capability, isSet),
+        ...modelsOf(id, capability, models),
+        viaAiGateway: viaAiGateway(capability, isSet),
+        embeddings: capability.embeddings !== undefined,
+    };
+}
+/**
+ * Every provider the default may resolve to: the shipped order first,
+ * then any other `ai` entry of `lookup` with a chat route (a registered
+ * row, one day), each with its state.
+ */
+export function aiDefaultCandidates(isSet, lookup = CATALOG, models = {}) {
+    const ids = [
+        ...AI_DEFAULT_ORDER,
+        ...lookup.ids().filter((id) => !AI_DEFAULT_ORDER.includes(id)),
+    ];
+    return ids.flatMap((id) => {
+        const capability = lookup.get(id);
+        // A registered row whose key isn't bound to the hosts it has now reads
+        // as unset everywhere (`providers.value-bound-to-hosts`).
+        const set = lookup.bound && !lookup.bound(id) ? () => false : isSet;
+        return canBeAiDefault(capability)
+            ? [candidateOf(id, capability, set, models)]
+            : [];
+    });
+}
+/** Why `choice.provider` can't be the default, or null when it can. */
+export function aiDefaultChoiceProblem(choice, lookup = CATALOG) {
+    const capability = lookup.get(choice.provider);
+    if (!capability)
+        return `${choice.provider} isn't a provider this Gateway knows`;
+    if (capability.mode !== "ai") {
+        return `${choice.provider} is an API provider, not a model provider`;
+    }
+    if (capability.kind === "proxy") {
+        return `${capability.label} fronts the model providers and serves no models of its own; set a provider, and turn the gateway on with everyapp ai gateway on`;
+    }
+    if (!capability.chat) {
+        return `${capability.label} has no OpenAI-shaped chat route, so it can't serve the default; an app pins it by listing it under providers`;
+    }
+    return null;
+}
+/**
+ * Why `patch` can't be stored for `provider`, or null when it can: the
+ * provider must be one the default can be, a model name must be a model
+ * name, and an embeddings model needs the entry's embeddings route.
+ */
+export function aiModelPatchProblem(provider, patch, lookup = CATALOG) {
+    const why = aiDefaultChoiceProblem({ provider }, lookup);
+    if (why)
+        return why;
+    const capability = lookup.get(provider);
+    if (!canBeAiDefault(capability))
+        return `${provider} can't serve the default`;
+    for (const kind of ["chat", "embeddings"]) {
+        const value = patch[kind];
+        if (typeof value === "string" && !isAiModelName(value)) {
+            return `${JSON.stringify(value)} isn't a model id: 1 to 200 characters, no surrounding spaces`;
+        }
+    }
+    if (typeof patch.embeddings === "string" && !capability.embeddings) {
+        return `${capability.label} has no embeddings route, so it serves no embeddings model`;
+    }
+    return null;
+}
+/**
+ * The Gateway's effective default, from the stored choice (or none) and
+ * what is set. A choice that names a provider which isn't configured
+ * still wins (the operator chose it: `configured` is false and `settings`
+ * says what to set); a choice the default can't be is reported as
+ * `problem` and the order decides.
+ */
+export function resolveAiDefault(input) {
+    const lookup = input.lookup ?? CATALOG;
+    const models = input.models ?? {};
+    const { isSet } = input;
+    const candidates = aiDefaultCandidates(isSet, lookup, models);
+    const resolve = (id, capability, source, problem) => ({
+        provider: id,
+        label: capability.label,
+        ...modelsOf(id, capability, models),
+        source,
+        configured: aiProviderConfigured(capability, isSet),
+        settings: aiRequiredSettings(capability),
+        via: viaAiGateway(capability, isSet) ? "ai-gateway" : "direct",
+        chat: capability.chat,
+        ...(capability.embeddings ? { embeddings: capability.embeddings } : {}),
+        candidates: [
+            ...candidates.filter((candidate) => candidate.id === id),
+            ...candidates.filter((candidate) => candidate.id !== id),
+        ],
+        ...(problem ? { problem } : {}),
+    });
+    let problem;
+    if (input.provider) {
+        const capability = lookup.get(input.provider);
+        const why = aiDefaultChoiceProblem({ provider: input.provider }, lookup);
+        if (!why && canBeAiDefault(capability)) {
+            return resolve(input.provider, capability, "setting");
+        }
+        problem = why ?? undefined;
+    }
+    const configured = candidates.find((candidate) => candidate.configured);
+    const first = configured ?? candidates[0];
+    if (!first) {
+        throw new Error("the catalog has no AI provider with a chat route");
+    }
+    const capability = lookup.get(first.id);
+    if (!canBeAiDefault(capability))
+        throw new Error("unreachable");
+    return resolve(first.id, capability, configured ? "order" : "none", problem);
+}
+/**
+ * The sentence setup shows for an unconfigured default: the one key to
+ * set, and the alternatives in the order.
+ */
+export function aiDefaultSetupHint(resolution) {
+    const others = resolution.candidates
+        .filter((candidate) => candidate.id !== resolution.provider)
+        .slice(0, 3)
+        .map((candidate) => `${candidate.label} (${candidate.settings.join(" and ")})`);
+    const head = resolution.source === "setting"
+        ? `The Gateway's default model provider is ${resolution.label}; set ${resolution.settings.join(" and ")}.`
+        : `Any one model provider's key makes the app work; ${resolution.label} is first in the order: set ${resolution.settings.join(" and ")}.`;
+    return others.length > 0
+        ? `${head} Or another: ${others.join(", ")}; pick one with everyapp ai default <provider>.`
+        : head;
+}

package/dist/internal/aiProviders.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The gateway's AI providers as the SDK's local-dev fallback reaches them:
+ * with no gateway binding, a developer's own key, under the name of the
+ * gateway secret that holds it, goes to the provider directly. Deployed
+ * apps always go through the gateway, which holds the real keys. The
+ * providers themselves are the catalog's `ai` entries (./capabilities.ts);
+ * this derives the fallback's view of each, and holds the one response
+ * rewrite the gateway has (Workers AI's numeric tokens).
+ */
+import { type AiProviderCapability, type AiProviderId, type AiRoute, type ApiKeyAuth, type CapabilitySettings } from "./capabilities.js";
+export interface DevAiProviderSpec {
+    origin: string;
+    /** The routes the default maps onto in dev, with the model filled in (the entry's `chat` and `embeddings`). */
+    chat?: AiRoute;
+    embeddings?: AiRoute;
+    /** The gateway secret holding the provider key; in local dev, the `.dev.vars` name. */
+    keyEnv: string;
+    /** Where the key goes on a request (`authorizationOf`). */
+    auth: ApiKeyAuth;
+    /** Where an operator gets the key: the provider's API keys page. */
+    docs: string;
+    /** The everyapp skill's setup guide for it, relative to the skill (`setup/openai.md`). */
+    setup?: string;
+    /** Gateway settings the provider's URL needs besides the key, under the same names. */
+    alsoNeeds?: readonly string[];
+    /** The path every provider path is joined onto, from those settings. */
+    basePath?: (settings: Readonly<Record<string, string>>) => string;
+    /** Turns the provider's response at `path` into what OpenAI clients parse. */
+    normalizeResponse?: (path: string, response: Response) => Response;
+}
+export type DevAiProvider = AiProviderId;
+/** The fallback's view of one `ai` catalog entry. */
+export declare function devAiProviderSpec(capability: AiProviderCapability): DevAiProviderSpec;
+export declare const DEV_AI_PROVIDERS: Readonly<Record<DevAiProvider, DevAiProviderSpec>>;
+export declare function devAiProvider(name: string, 
+/** The dev Worker's bindings: a registered `ai` spec under `.everyapp/providers/<id>.json` resolves from them. */
+values?: Readonly<Record<string, unknown>>): DevAiProviderSpec | undefined;
+/** Every setting a provider needs, its key first: the names `.dev.vars` and the gateway use. */
+export declare function aiProviderSettings(spec: DevAiProviderSpec): string[];
+/**
+ * An `ai` entry's `basePath` with each `{SETTING}` filled from the
+ * settings, URL-encoded (`/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai`
+ * with `acc 1` makes `/client/v4/accounts/acc%201/ai`), or null while a
+ * named setting is unset or blank.
+ */
+export declare function fillBasePath(template: string, settings: CapabilitySettings): string | null;
+/**
+ * The base URL an `ai` entry's calls are joined onto, from the Gateway's
+ * settings: its origin and filled `basePath`, or null while a setting the
+ * path needs is unset.
+ */
+export declare function aiBaseUrl(capability: AiProviderCapability, settings: CapabilitySettings): string | null;
+/** The account-scoped base path of Workers AI's REST API. */
+export declare function workersAiBasePath(accountId: string): string;
+/**
+ * `base` with `path` joined onto its path (never replacing it) and
+ * `search` as its query: `https://api.cloudflare.com/client/v4/accounts/<id>/ai`
+ * and `/v1/chat/completions` make `…/ai/v1/chat/completions`. `path` starts
+ * with one slash; null when the result would leave `base`'s path.
+ */
+export declare function joinProviderUrl(base: string, path: string, search?: string): URL | null;
+/**
+ * Workers AI's OpenAI-compatible chat completions on the vLLM-backed models
+ * (Meta's Llama among them) send a token made only of digits as a JSON
+ * number (`"delta":{"content":18}`), which OpenAI clients refuse:
+ * `@ai-sdk/openai-compatible` drops the token and reports an error part.
+ * This turns such numbers back into strings, in `choices[].delta` (streams)
+ * and `choices[].message` (whole JSON bodies); every other event or body
+ * passes through byte for byte. Remove it once Cloudflare sends strings.
+ */
+export declare function normalizeWorkersAiResponse(path: string, response: Response): Response;
+//# sourceMappingURL=aiProviders.d.ts.map

package/dist/internal/aiProviders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiProviders.d.ts","sourceRoot":"","sources":["../../src/internal/aiProviders.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAC;AAG3B,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,+GAA+G;IAC/G,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,uFAAuF;IACvF,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,IAAI,EAAE,UAAU,CAAC;IACjB,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uFAAuF;IACvF,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,wEAAwE;IACxE,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAK,MAAM,CAAC;IAClE,8EAA8E;IAC9E,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,KAAK,QAAQ,CAAC;CACpE;AAED,MAAM,MAAM,aAAa,GAAG,YAAY,CAAC;AAEzC,qDAAqD;AACrD,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,oBAAoB,GAC/B,iBAAiB,CAoBnB;AAED,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CACrC,MAAM,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAUG,CAAC;AAE9C,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM;AACZ,kHAAkH;AAClH,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACzC,iBAAiB,GAAG,SAAS,CAS/B;AAED,gGAAgG;AAChG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,GAAG,IAAI,CAcf;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,GAAG,IAAI,CAIf;AAED,6DAA6D;AAC7D,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,SAAK,GACV,GAAG,GAAG,IAAI,CAOZ;AAWD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,GACjB,QAAQ,CAqBV"}

package/dist/internal/aiProviders.js

@@ -0,0 +1,233 @@
+/**
+ * The gateway's AI providers as the SDK's local-dev fallback reaches them:
+ * with no gateway binding, a developer's own key, under the name of the
+ * gateway secret that holds it, goes to the provider directly. Deployed
+ * apps always go through the gateway, which holds the real keys. The
+ * providers themselves are the catalog's `ai` entries (./capabilities.ts);
+ * this derives the fallback's view of each, and holds the one response
+ * rewrite the gateway has (Workers AI's numeric tokens).
+ */
+import { CAPABILITIES, CAPABILITY_IDS, } from "./capabilities.js";
+import { resolveDevProvider } from "./devProviders.js";
+/** The fallback's view of one `ai` catalog entry. */
+export function devAiProviderSpec(capability) {
+    const { basePath, normalize } = capability;
+    return {
+        origin: capability.origin,
+        ...(capability.chat ? { chat: capability.chat } : {}),
+        ...(capability.embeddings ? { embeddings: capability.embeddings } : {}),
+        keyEnv: capability.auth.secret,
+        auth: capability.auth,
+        docs: capability.docs,
+        ...(capability.setup === undefined ? {} : { setup: capability.setup }),
+        ...(capability.alsoNeeds === undefined
+            ? {}
+            : { alsoNeeds: capability.alsoNeeds }),
+        ...(basePath === undefined
+            ? {}
+            : { basePath: (settings) => fillBasePath(basePath, settings) ?? "" }),
+        ...(normalize === "workers-ai"
+            ? { normalizeResponse: normalizeWorkersAiResponse }
+            : {}),
+    };
+}
+export const DEV_AI_PROVIDERS = Object.fromEntries(CAPABILITY_IDS.flatMap((id) => {
+    const capability = CAPABILITIES[id];
+    // The proxy entry (AI Gateway) serves no models: never a dev target.
+    return capability.mode === "ai" &&
+        !("kind" in capability && capability.kind === "proxy")
+        ? [[id, devAiProviderSpec(capability)]]
+        : [];
+}));
+export function devAiProvider(name, 
+/** The dev Worker's bindings: a registered `ai` spec under `.everyapp/providers/<id>.json` resolves from them. */
+values) {
+    if (Object.hasOwn(DEV_AI_PROVIDERS, name)) {
+        return DEV_AI_PROVIDERS[name];
+    }
+    if (!values)
+        return undefined;
+    const resolved = resolveDevProvider(values, name);
+    return resolved.found && resolved.capability.mode === "ai"
+        ? devAiProviderSpec(resolved.capability)
+        : undefined;
+}
+/** Every setting a provider needs, its key first: the names `.dev.vars` and the gateway use. */
+export function aiProviderSettings(spec) {
+    return [spec.keyEnv, ...(spec.alsoNeeds ?? [])];
+}
+/**
+ * An `ai` entry's `basePath` with each `{SETTING}` filled from the
+ * settings, URL-encoded (`/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai`
+ * with `acc 1` makes `/client/v4/accounts/acc%201/ai`), or null while a
+ * named setting is unset or blank.
+ */
+export function fillBasePath(template, settings) {
+    let missing = false;
+    const filled = template.replace(/\{([A-Z][A-Z0-9_]*)\}/g, (_, name) => {
+        const value = settings[name];
+        if (typeof value !== "string" || !value.trim()) {
+            missing = true;
+            return "";
+        }
+        return encodeURIComponent(value.trim());
+    });
+    return missing ? null : filled;
+}
+/**
+ * The base URL an `ai` entry's calls are joined onto, from the Gateway's
+ * settings: its origin and filled `basePath`, or null while a setting the
+ * path needs is unset.
+ */
+export function aiBaseUrl(capability, settings) {
+    if (capability.basePath === undefined)
+        return capability.origin;
+    const path = fillBasePath(capability.basePath, settings);
+    return path === null ? null : `${capability.origin}${path}`;
+}
+/** The account-scoped base path of Workers AI's REST API. */
+export function workersAiBasePath(accountId) {
+    return `/client/v4/accounts/${encodeURIComponent(accountId.trim())}/ai`;
+}
+/**
+ * `base` with `path` joined onto its path (never replacing it) and
+ * `search` as its query: `https://api.cloudflare.com/client/v4/accounts/<id>/ai`
+ * and `/v1/chat/completions` make `…/ai/v1/chat/completions`. `path` starts
+ * with one slash; null when the result would leave `base`'s path.
+ */
+export function joinProviderUrl(base, path, search = "") {
+    const url = new URL(base);
+    const basePath = url.pathname.replace(/\/+$/, "");
+    url.pathname = `${basePath}${path}`;
+    url.search = search;
+    url.hash = "";
+    return url.pathname === `${basePath}${path}` ? url : null;
+}
+const WORKERS_AI_NORMALIZED_ROUTES = new Set([
+    "/v1/chat/completions",
+]);
+/** Text fields of a chat completion choice that OpenAI clients require as strings. */
+const TEXT_FIELDS = ["content", "reasoning_content", "reasoning"];
+const NUMERIC_TEXT_FIELD = /"(?:content|reasoning_content|reasoning)"\s*:\s*-?\d/;
+/**
+ * Workers AI's OpenAI-compatible chat completions on the vLLM-backed models
+ * (Meta's Llama among them) send a token made only of digits as a JSON
+ * number (`"delta":{"content":18}`), which OpenAI clients refuse:
+ * `@ai-sdk/openai-compatible` drops the token and reports an error part.
+ * This turns such numbers back into strings, in `choices[].delta` (streams)
+ * and `choices[].message` (whole JSON bodies); every other event or body
+ * passes through byte for byte. Remove it once Cloudflare sends strings.
+ */
+export function normalizeWorkersAiResponse(path, response) {
+    if (!response.body || !WORKERS_AI_NORMALIZED_ROUTES.has(path)) {
+        return response;
+    }
+    const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
+    const transform = contentType.startsWith("text/event-stream")
+        ? normalizeSseLines()
+        : contentType.startsWith("application/json")
+            ? normalizeJsonBody()
+            : null;
+    if (!transform)
+        return response;
+    const headers = new Headers(response.headers);
+    // The body may change length.
+    headers.delete("content-length");
+    return new Response(response.body.pipeThrough(transform), {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+/** Stringify numeric text fields of every choice in a chat completion (chunk). */
+function stringifyNumericText(payload) {
+    if (!isRecord(payload) || !Array.isArray(payload["choices"]))
+        return false;
+    let changed = false;
+    for (const choice of payload["choices"]) {
+        if (!isRecord(choice))
+            continue;
+        for (const part of [choice["delta"], choice["message"]]) {
+            if (!isRecord(part))
+                continue;
+            for (const field of TEXT_FIELDS) {
+                const value = part[field];
+                if (typeof value === "number") {
+                    part[field] = String(value);
+                    changed = true;
+                }
+            }
+        }
+    }
+    return changed;
+}
+/** `json` with its numeric text fields as strings, or null when it has none. */
+function normalizedJson(json) {
+    if (!NUMERIC_TEXT_FIELD.test(json))
+        return null;
+    let payload;
+    try {
+        payload = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    return stringifyNumericText(payload) ? JSON.stringify(payload) : null;
+}
+/**
+ * An SSE stream, line by line: a `data:` line whose JSON has a numeric text
+ * field is rewritten, every other line (and its line ending) is kept.
+ */
+function normalizeSseLines() {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let pending = "";
+    const normalizeLine = (line) => {
+        const match = /^(data:[ ]?)(.*?)(\r?)$/s.exec(line);
+        if (!match)
+            return line;
+        const rewritten = normalizedJson(match[2]);
+        return rewritten === null ? line : `${match[1]}${rewritten}${match[3]}`;
+    };
+    return new TransformStream({
+        transform(chunk, controller) {
+            pending += decoder.decode(chunk, { stream: true });
+            const end = pending.lastIndexOf("\n");
+            if (end === -1)
+                return;
+            const complete = pending.slice(0, end + 1);
+            pending = pending.slice(end + 1);
+            controller.enqueue(encoder.encode(complete.split("\n").map(normalizeLine).join("\n")));
+        },
+        flush(controller) {
+            pending += decoder.decode();
+            if (pending)
+                controller.enqueue(encoder.encode(normalizeLine(pending)));
+        },
+    });
+}
+/** A whole JSON body: rewritten when it has a numeric text field, else kept as sent. */
+function normalizeJsonBody() {
+    const chunks = [];
+    return new TransformStream({
+        transform(chunk) {
+            chunks.push(chunk);
+        },
+        flush(controller) {
+            const decoder = new TextDecoder();
+            const text = chunks
+                .map((chunk) => decoder.decode(chunk, { stream: true }))
+                .join("") + decoder.decode();
+            const rewritten = normalizedJson(text);
+            if (rewritten !== null) {
+                controller.enqueue(new TextEncoder().encode(rewritten));
+                return;
+            }
+            for (const chunk of chunks)
+                controller.enqueue(chunk);
+        },
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}