@raybase/core 0.0.1 → 0.3.3

package/dist/ai.js

@@ -0,0 +1,1858 @@
+import { dataStub } from "./db.js";
+import { sha256Hex, stableJson } from "./internal.js";
+import { jsonSchemaFor, parseWithSchema, restoreStrictModelValue, strictModelSchema } from "./json-schema.js";
+import { id, integer, longText, raybaseSystemTable, text } from "./schema.js";
+import { nowIso, randomId } from "./sql.js";
+import { createInferenceTape, tapeChatStream, withoutInferenceTapeEnv } from "./inference-tape.js";
+export const raybaseRecommendedModelsManifestUrl = "https://raybase.dev/models/recommended.json";
+export const defaultAiModel = "";
+export const defaultEmbeddingModel = "@cf/baai/bge-base-en-v1.5";
+export const defaultAiLimits = {
+    // perUserDailyRequests, perUserDailyOutputTokens, and perAppDailyRequests are
+    // deliberately absent: unset means unlimited. Public (unauthenticated) traffic
+    // keeps a default cap because that surface is an abuse question, not a spend one.
+    perPublicDailyRequests: 200,
+    perPublicDailyOutputTokens: 60_000,
+    maxToolCallsPerTurn: 6,
+    maxLoopStepsPerTurn: 8,
+    maxConversationMessages: 40
+};
+/**
+ * Deadline for a single model call. A provider request that hangs otherwise
+ * parks the whole agent turn: the turn's abort signal is only consulted
+ * between loop steps, so neither a member's cancel nor the runtime can cut a
+ * request already in flight. Measured healthy agent calls finish far inside
+ * this (drafts up to ~21s, delivery gates and chapter closes ~9s), so the
+ * bound never touches honest traffic.
+ */
+export const defaultModelCallTimeoutMs = 120_000;
+export const defaultAiDefaults = {
+    model: defaultAiModel,
+    embeddingModel: defaultEmbeddingModel,
+    maxInputChars: 20_000,
+    maxOutputTokens: 1_200,
+    modelCallTimeoutMs: defaultModelCallTimeoutMs,
+    modelParams: {}
+};
+export class RaybaseAiModelNotConfiguredError extends Error {
+    constructor(source = "AI model") {
+        super(`${source} is not configured. Set the defaultAiModel setting in Raybase admin or provide appConfig.ai.defaults.model.`);
+        this.name = "RaybaseAiModelNotConfiguredError";
+    }
+}
+export function chatMessageText(message) {
+    if (typeof message.content === "string")
+        return message.content;
+    return message.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+}
+/**
+ * Tool definitions in the form a strict provider accepts.
+ *
+ * Every object closed with every property required, optionality spelled as a
+ * null union, open records carried as JSON in a string. `restoreStrictToolCalls`
+ * is the other half and is not optional: the arguments that come back carry the
+ * padding, and an action's own validator refuses it.
+ *
+ * Core applies both around every `ai.chat` and `ai.chatStream` call, so declared
+ * Zod and JSON-Schema inputs work on a strict lane without an app doing
+ * anything. A custom inference provider that builds its own request — an app
+ * registering `appConfig.ai.provider` — uses this pair rather than rebuilding it.
+ */
+export function strictChatTools(tools) {
+    if (!tools?.length)
+        return tools;
+    return tools.map((tool) => {
+        const parameters = tool.parameters === undefined
+            ? { type: "object", properties: {} }
+            : tool.parameters;
+        if (!parameters || typeof parameters !== "object" || Array.isArray(parameters))
+            return tool;
+        return { ...tool, parameters: strictModelSchema(parameters) };
+    });
+}
+/**
+ * Tool-call arguments with the strict padding undone, restored against the tool
+ * schemas *as they were declared* — before `strictChatTools` saw them.
+ */
+export function restoreStrictToolCalls(calls, tools) {
+    if (!calls?.length)
+        return calls ?? [];
+    if (!tools?.length)
+        return calls;
+    const schemas = new Map(tools.map((tool) => [tool.name, tool.parameters]));
+    return calls.map((call) => {
+        const schema = schemas.get(call.name);
+        if (!schema || typeof schema !== "object" || Array.isArray(schema))
+            return call;
+        return { ...call, arguments: restoreStrictModelValue(call.arguments, schema) };
+    });
+}
+/**
+ * The first complete JSON object in a reply.
+ *
+ * Models put prose before the JSON and, less often, after it. Scanning from the
+ * first `{` to the last `}` swallows both into one unparseable span; this walks
+ * brace depth with string and escape handling, mirroring the boundary a
+ * streaming JSON decoder would find, and returns the first object that parses.
+ */
+export function firstJsonObject(text) {
+    for (let start = text.indexOf("{"); start >= 0; start = text.indexOf("{", start + 1)) {
+        let depth = 0;
+        let quoted = false;
+        let escaped = false;
+        for (let index = start; index < text.length; index += 1) {
+            const character = text[index];
+            if (quoted) {
+                if (escaped)
+                    escaped = false;
+                else if (character === "\\")
+                    escaped = true;
+                else if (character === '"')
+                    quoted = false;
+                continue;
+            }
+            if (character === '"')
+                quoted = true;
+            else if (character === "{")
+                depth += 1;
+            else if (character === "}" && --depth === 0) {
+                try {
+                    const value = JSON.parse(text.slice(start, index + 1));
+                    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * The one input-size measure. Every budget check — the agent turn pre-flight,
+ * the in-loop re-measure, and the AI layer's own guard — must count the same
+ * request the same way, or a turn passes one check and fails the next on the
+ * same bytes. Callers that measure ahead of a call pass exactly what they will
+ * send.
+ *
+ * Image and attachment content parts still count as zero: chatMessageText
+ * keeps text parts only, and a provider bills their bytes as tokens on a
+ * different scale than characters.
+ */
+export function chatRequestInputChars(input) {
+    return jsonCharLength({
+        messages: input.messages.map((message) => ({ ...message, content: chatMessageText(message) })),
+        tools: input.tools,
+        metadata: input.metadata,
+        responseFormat: input.responseFormat
+    });
+}
+export class RaybaseInferenceProviderError extends Error {
+    code;
+    health;
+    retryAt;
+    actionHref;
+    constructor(input) {
+        super(input.message ?? "The selected AI provider is unavailable.");
+        this.name = "RaybaseInferenceProviderError";
+        this.code = input.code;
+        this.health = input.health;
+        this.retryAt = input.retryAt;
+        this.actionHref = input.actionHref;
+    }
+}
+export function safeInferenceProviderError(error) {
+    if (error instanceof RaybaseInferenceProviderError) {
+        const code = /^[a-z0-9][a-z0-9_.:-]{0,79}$/.test(error.code) ? error.code : "provider_error";
+        const retryAt = error.retryAt && Number.isFinite(new Date(error.retryAt).getTime())
+            ? new Date(error.retryAt).toISOString()
+            : undefined;
+        const actionHref = error.actionHref?.startsWith("/") && error.actionHref.length <= 256
+            ? error.actionHref
+            : undefined;
+        return {
+            code,
+            ...(error.health ? { health: error.health } : {}),
+            ...(retryAt ? { retryAt } : {}),
+            ...(actionHref ? { actionHref } : {}),
+            message: "The selected AI provider is unavailable."
+        };
+    }
+    return {
+        code: "provider_error",
+        message: "The selected AI provider failed."
+    };
+}
+export function safeInferenceProviderErrorMessage(error) {
+    return JSON.stringify(safeInferenceProviderError(error));
+}
+/**
+ * A structured call that produced nothing usable: no JSON in the reply, or JSON
+ * the caller's own schema refused. It carries the raw text and the validation
+ * issues, because a caller who cannot see what the model actually said has no
+ * way to tell a prompt problem from a schema problem.
+ */
+export class RaybaseAIObjectError extends Error {
+    raw;
+    issues;
+    constructor(message, input) {
+        super(message, input.cause === undefined ? undefined : { cause: input.cause });
+        this.name = "RaybaseAIObjectError";
+        this.raw = input.raw;
+        this.issues = input.issues ?? [];
+    }
+}
+/**
+ * `ai.object` for any client that can `chat`: the request-scoped `RaybaseAI`,
+ * the commit-scoped variant, and anything wrapping either of them with its own
+ * accounting. Kept as a free function so a wrapper delegates in one line rather
+ * than reimplementing the parse-and-validate half.
+ */
+export function raybaseObjectCall(chat) {
+    return async (input, options) => {
+        const messages = objectRequestMessages(input);
+        const declared = jsonSchemaFor(input.schema);
+        const responseFormat = {
+            type: "json_schema",
+            name: objectSchemaName(input.schemaName),
+            schema: strictModelSchema(declared),
+            strict: true,
+            ...(input.schemaDescription ? { description: input.schemaDescription } : {})
+        };
+        const attempts = input.retry === false ? 1 : 2;
+        let raw = "";
+        let issues = [];
+        let failure;
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
+            const result = await chat({
+                model: input.model ?? "",
+                messages: attempt === 0 ? messages : [...messages, ...objectRetryMessages(raw, issues)],
+                responseFormat,
+                ...(input.maxOutputTokens !== undefined ? { maxOutputTokens: input.maxOutputTokens } : {}),
+                ...(input.modelParams ? { modelParams: input.modelParams } : {}),
+                ...(input.providerParams ? { providerParams: input.providerParams } : {}),
+                ...(input.metadata ? { metadata: input.metadata } : {})
+            }, options);
+            raw = result.text;
+            const parsed = firstJsonObject(raw);
+            if (!parsed) {
+                issues = [{ message: "The reply contained no complete JSON object." }];
+                failure = undefined;
+                continue;
+            }
+            try {
+                // The wire form travels back too: nulls where the caller wrote an
+                // optional, JSON in a string where it wrote a record.
+                return parseWithSchema(input.schema, restoreStrictModelValue(parsed, declared), "ai.object");
+            }
+            catch (error) {
+                failure = error;
+                issues = objectValidationIssues(error);
+            }
+        }
+        throw new RaybaseAIObjectError(issues.length === 1 && typeof issues[0]?.message === "string"
+            ? `Structured AI reply was rejected: ${issues[0].message}`
+            : "Structured AI reply did not validate against its schema", { raw, issues, cause: failure });
+    };
+}
+function objectRequestMessages(input) {
+    const messages = input.messages?.length
+        ? input.messages
+        : input.prompt
+            ? [{ role: "user", content: input.prompt }]
+            : [];
+    if (!messages.length)
+        throw new Error("ai.object requires messages or a prompt");
+    return messages;
+}
+function objectSchemaName(name) {
+    const trimmed = name?.trim();
+    if (!trimmed)
+        return "response";
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(trimmed))
+        throw new Error(`ai.object schemaName ${trimmed} must be 1-64 characters of letters, digits, underscores or dashes`);
+    return trimmed;
+}
+function objectRetryMessages(raw, issues) {
+    return [
+        { role: "assistant", content: raw },
+        {
+            role: "user",
+            content: `That reply did not validate against the required schema: ${objectIssueText(issues)}. Reply again with only the JSON object, corrected.`
+        }
+    ];
+}
+function objectIssueText(issues) {
+    const described = issues.map((issue) => {
+        const record = issue;
+        const path = Array.isArray(record?.path) && record.path.length ? `${record.path.join(".")}: ` : "";
+        return `${path}${typeof record?.message === "string" ? record.message : String(issue)}`;
+    });
+    return described.join("; ").slice(0, 800) || "no details";
+}
+function objectValidationIssues(error) {
+    const issues = error?.issues;
+    if (Array.isArray(issues) && issues.length)
+        return issues;
+    return [{ message: error instanceof Error ? error.message : String(error) }];
+}
+export const raybaseAiSystemTables = [
+    raybaseSystemTable("_ai_usage_events", {
+        id: id(),
+        userId: text(),
+        principalKind: text(),
+        publicScopeHash: text(),
+        serviceName: text(),
+        agent: text(),
+        conversationId: text(),
+        model: text({ required: true }),
+        requestKind: text({ required: true }),
+        role: text(),
+        gatewayId: text(),
+        gatewayLogId: text(),
+        inputChars: integer({ required: true }),
+        floorChars: integer(),
+        tailChars: integer(),
+        outputChars: integer({ required: true }),
+        estimatedInputTokens: integer({ required: true }),
+        estimatedOutputTokens: integer({ required: true }),
+        estimatedNeurons: integer(),
+        modelParams: longText(),
+        metadata: longText(),
+        status: text({ required: true }),
+        error: longText(),
+        durationMs: integer({ required: true }),
+        createdAt: text({ required: true })
+    }, { indexes: [["userId", "createdAt"], ["serviceName", "createdAt"], ["agent", "createdAt"], ["conversationId"]] }),
+    raybaseSystemTable("_ai_budget_windows", {
+        id: id(),
+        scope: text({ required: true }),
+        scopeId: text({ required: true }),
+        windowStart: text({ required: true }),
+        windowEnd: text({ required: true }),
+        requestCount: integer({ required: true }),
+        estimatedOutputTokens: integer({ required: true }),
+        estimatedNeurons: integer(),
+        updatedAt: text({ required: true })
+    }, { indexes: [["scope", "scopeId", "windowStart"], ["windowEnd"]] }),
+    raybaseSystemTable("_ai_action_events", {
+        id: id(),
+        userId: text({ required: true }),
+        agent: text({ required: true }),
+        conversationId: text(),
+        actionName: text({ required: true }),
+        inputHash: text(),
+        status: text({ required: true }),
+        error: longText(),
+        createdAt: text({ required: true })
+    }, { indexes: [["userId", "createdAt"], ["agent", "createdAt"], ["conversationId"], ["actionName"]] }),
+    raybaseSystemTable("_ai_embedding_chunks", {
+        id: id(),
+        indexName: text({ required: true }),
+        backend: text({ required: true }),
+        physicalIndex: text(),
+        namespace: text(),
+        vectorId: text({ required: true }),
+        sourceType: text({ required: true }),
+        sourceTable: text(),
+        sourceId: text({ required: true }),
+        sourceVersion: text(),
+        chunkKey: text({ required: true }),
+        chunkOrdinal: integer({ required: true }),
+        embeddingModel: text({ required: true }),
+        dimensions: integer({ required: true }),
+        metric: text(),
+        textHash: text({ required: true }),
+        title: text(),
+        url: text(),
+        metadata: longText(),
+        vectorBase64: longText(),
+        status: text({ required: true }),
+        mutationId: text(),
+        lastError: longText(),
+        indexedAt: text(),
+        updatedAt: text({ required: true })
+    }, {
+        indexes: [
+            ["indexName", "backend", "sourceType", "sourceTable", "sourceId"],
+            ["backend", "physicalIndex", "namespace", "vectorId"],
+            ["status", "updatedAt"],
+            ["textHash"],
+            ["sourceType", "sourceTable", "sourceId", "chunkKey"]
+        ]
+    }),
+    raybaseSystemTable("_ai_retrieval_reindex_runs", {
+        id: id(),
+        indexName: text({ required: true }),
+        backend: text({ required: true }),
+        status: text({ required: true }),
+        actorId: text(),
+        actorKind: text(),
+        namespace: text(),
+        totalSources: integer({ required: true }),
+        totalChunks: integer({ required: true }),
+        upsertedChunks: integer({ required: true }),
+        deletedChunks: integer({ required: true }),
+        skippedChunks: integer({ required: true }),
+        errorCount: integer({ required: true }),
+        startedAt: text({ required: true }),
+        completedAt: text(),
+        summaryJson: longText()
+    }, { indexes: [["indexName", "startedAt"], ["backend", "status"], ["namespace", "startedAt"]] })
+];
+export function aiEndpoint(config) {
+    const endpoint = config.ai?.endpoint || "/api/ai";
+    return endpoint.startsWith("/") ? endpoint.replace(/\/$/, "") || "/api/ai" : `/${endpoint.replace(/\/$/, "")}`;
+}
+export function normalizeAiLimits(config) {
+    return { ...defaultAiLimits, ...(config.ai?.limits ?? {}) };
+}
+export function normalizeAiDefaults(config) {
+    return {
+        ...defaultAiDefaults,
+        ...(config.ai?.defaults ?? {}),
+        modelParams: normalizeModelParams(config.ai?.defaults?.modelParams ?? {})
+    };
+}
+export async function fetchRecommendedAiModelsManifest(url = raybaseRecommendedModelsManifestUrl) {
+    const response = await fetch(url, {
+        headers: { accept: "application/json" }
+    });
+    if (!response.ok)
+        return null;
+    const value = await response.json();
+    if (!value || typeof value !== "object")
+        return null;
+    const manifest = value;
+    if (manifest.schemaVersion !== 1)
+        return null;
+    return manifest;
+}
+export function recommendedDefaultAiModel(manifest) {
+    const model = manifest?.defaults?.guide?.model ?? manifest?.defaults?.chat?.model;
+    return typeof model === "string" && model.trim() ? model.trim() : null;
+}
+export function requireConfiguredAiModel(model, source = "AI model") {
+    const resolved = typeof model === "string" ? model.trim() : "";
+    if (resolved)
+        return resolved;
+    throw new RaybaseAiModelNotConfiguredError(source);
+}
+export function aiGatewayId(config) {
+    return config.ai?.gateway?.id ?? null;
+}
+export function buildAiGatewayOptions(input) {
+    const gatewayId = effectiveAiGatewayId(input.config, input.env);
+    if (!gatewayId)
+        return {};
+    const gateway = {
+        id: gatewayId,
+        cache: input.env?.RAYBASE_ENV === "local" && input.env.RAYBASE_AI_GATEWAY_CACHE !== undefined
+            ? parseAiGatewayCache(input.env.RAYBASE_AI_GATEWAY_CACHE)
+            : input.config.ai?.gateway?.cache,
+        metadata: {
+            raybaseApp: input.config.appName,
+            raybaseAgent: input.agent ?? null,
+            raybasePrincipalKind: input.principalKind ?? (input.publicId ? "public" : "user"),
+            raybaseUser: input.userId ?? null,
+            raybasePublicPrincipal: input.publicId ?? null,
+            raybaseService: input.serviceName ?? null,
+            raybaseRequest: input.requestId ?? null,
+            raybaseSurface: input.surface ?? null,
+            raybaseEnv: input.env?.RAYBASE_ENV === "local" ? "local" : "production",
+            ...(input.metadata ?? {})
+        }
+    };
+    return { gateway };
+}
+function effectiveAiGatewayProviderAuthorization(config, env) {
+    const secretName = config.ai?.gateway?.authorizationSecretName?.trim();
+    if (!secretName || !env)
+        return null;
+    const value = env[secretName];
+    return typeof value === "string" && value.trim() ? `Bearer ${value.trim()}` : null;
+}
+function effectiveAiGatewayRequestAuthorization(env) {
+    const value = env?.RAYBASE_AI_GATEWAY_AUTH?.trim();
+    if (!value)
+        return null;
+    return /^Bearer\s+/i.test(value) ? value : `Bearer ${value}`;
+}
+export function aiGatewayAuthorizationConfig(config) {
+    return {
+        authorizationSecretName: config.ai?.gateway?.authorizationSecretName?.trim() || undefined,
+        storeKeyName: config.ai?.gateway?.storeKeyName?.trim() || undefined
+    };
+}
+function parseAiGatewayCache(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (["true", "1", "yes", "on"].includes(normalized))
+        return true;
+    if (["false", "0", "no", "off"].includes(normalized))
+        return false;
+    return undefined;
+}
+function effectiveAiGatewayId(config, env) {
+    if (env?.RAYBASE_ENV === "local" && env.RAYBASE_AI_GATEWAY_ID !== undefined) {
+        return env.RAYBASE_AI_GATEWAY_ID.trim() || null;
+    }
+    return aiGatewayId(config);
+}
+function normalizeAiPrincipal(options) {
+    if (options.principal)
+        return options.principal;
+    if (options.user)
+        return { kind: "user", user: options.user };
+    throw new Error("createRaybaseAI requires a signed-in user or explicit principal");
+}
+function usagePrincipalFields(principal) {
+    switch (principal.kind) {
+        case "user":
+            return { principalKind: "user", userId: principal.user.id, publicScopeHash: null, serviceName: null };
+        case "public":
+            return { principalKind: "public", userId: null, publicScopeHash: principal.id, serviceName: null };
+        case "service":
+            return { principalKind: "service", userId: null, publicScopeHash: null, serviceName: principal.service };
+    }
+}
+function usagePromptSplitFields(split) {
+    if (!split)
+        return { floorChars: null, tailChars: null };
+    return {
+        floorChars: Math.max(0, Math.round(split.floorChars)),
+        tailChars: Math.max(0, Math.round(split.tailChars))
+    };
+}
+export function createRaybaseAI(options) {
+    const workersProvider = options.env.AI ? createCloudflareWorkersAIInferenceProvider() : undefined;
+    const cloudflareProvider = options.env.AI ? createCloudflareInferenceProvider() : undefined;
+    const principal = normalizeAiPrincipal(options);
+    const defaults = normalizeAiDefaults(options.config);
+    const limits = normalizeAiLimits(options.config);
+    const requestId = options.requestId ?? options.request?.headers.get("cf-ray") ?? randomId("ai_req");
+    const baseSignal = options.signal ?? options.request?.signal;
+    const inferenceTape = createInferenceTape(options.env);
+    const providerEnv = withoutInferenceTapeEnv(options.env);
+    let providerPromise;
+    const resolveProvider = () => {
+        providerPromise ??= Promise.resolve(options.providerFactory
+            ? options.providerFactory({
+                env: providerEnv,
+                request: options.request,
+                config: options.config,
+                control: options.control,
+                principal,
+                organizationId: options.organizationId,
+                requestId,
+                surface: options.surface ?? "http",
+                signal: baseSignal,
+                moduleOptions: options.config.modules
+            })
+            : options.provider ?? cloudflareProvider).then((provider) => localAiProvider(options.env, options.config, provider));
+        return providerPromise;
+    };
+    const resolveEmbeddingProvider = async () => {
+        const selected = await resolveProvider();
+        if (selected?.embed)
+            return selected;
+        return localAiProvider(options.env, options.config, workersProvider);
+    };
+    const claimBudget = options.claimBudget ??
+        ((input) => {
+            return dataStub(options.env).claimAiBudget(input);
+        });
+    async function beforeCall(input) {
+        const maxInputChars = input.maxInputChars ?? defaults.maxInputChars;
+        if (input.inputChars > maxInputChars) {
+            throw new Error(`AI input is ${input.inputChars} characters, exceeding maxInputChars ${maxInputChars}`);
+        }
+        if (input.budgetMode === "system-exempt")
+            return;
+        const overhead = input.budgetMode === "system-overhead" || principal.kind === "service";
+        const claim = await claimBudget({
+            now: nowIso(),
+            principalKind: overhead ? undefined : principal.kind,
+            userId: overhead ? null : principal.kind === "user" ? principal.user.id : null,
+            publicScopeId: overhead ? null : principal.kind === "public" ? principal.id : null,
+            appScopeId: "app",
+            requestCount: 1,
+            estimatedOutputTokens: Math.max(0, input.estimatedOutputTokens),
+            estimatedNeurons: null,
+            perUserDailyRequests: overhead ? null : limits.perUserDailyRequests ?? null,
+            perUserDailyOutputTokens: overhead ? null : limits.perUserDailyOutputTokens ?? null,
+            perAppDailyRequests: limits.perAppDailyRequests ?? null,
+            perPublicDailyRequests: overhead ? null : limits.perPublicDailyRequests,
+            perPublicDailyOutputTokens: overhead ? null : limits.perPublicDailyOutputTokens
+        });
+        if (!claim.ok) {
+            throw new Error(`AI budget exhausted for ${claim.scope}: ${claim.reason}`);
+        }
+    }
+    async function record(event) {
+        await recordAiUsageEvent(options.control, {
+            ...event,
+            metadata: options.usageMetadata ?? null
+        });
+    }
+    function providerContext(input) {
+        const gateway = buildAiGatewayOptions({
+            config: options.config,
+            env: providerEnv,
+            agent: input.agent ?? options.agent,
+            userId: principal.kind === "user" ? principal.user.id : undefined,
+            principalKind: principal.kind,
+            publicId: principal.kind === "public" ? principal.id : undefined,
+            serviceName: principal.kind === "service" ? principal.service : undefined,
+            requestId,
+            surface: options.surface ?? "http",
+            metadata: input.metadata
+        });
+        return {
+            env: providerEnv,
+            request: options.request,
+            config: options.config,
+            principal,
+            organizationId: options.organizationId,
+            surface: options.surface ?? "http",
+            agent: input.agent ?? options.agent,
+            conversationId: input.conversationId ?? options.conversationId,
+            requestId,
+            gatewayOptions: { ...gateway, ...(input.gateway ?? {}) },
+            metadata: input.metadata,
+            signal: input.signal ?? baseSignal
+        };
+    }
+    function tapeCorrelation(input) {
+        return {
+            ...(input.agent ?? options.agent ? { agent: input.agent ?? options.agent } : {}),
+            ...(input.conversationId ?? options.conversationId
+                ? { conversationId: input.conversationId ?? options.conversationId }
+                : {}),
+            requestId,
+            ...(options.turnKey ? { turnKey: options.turnKey } : {}),
+            surface: options.surface ?? "http",
+            ...(options.organizationId ? { organizationId: options.organizationId } : {}),
+            ...(effectiveAiGatewayId(options.config, options.env)
+                ? { gatewayId: effectiveAiGatewayId(options.config, options.env) }
+                : {})
+        };
+    }
+    const client = {
+        async chat(input, chatOptions = {}) {
+            const provider = await resolveProvider();
+            if (!provider)
+                throw new Error("Raybase AI is enabled in appConfig but no AI provider is available");
+            const model = requireConfiguredAiModel(input.model || options.defaultModel || defaults.model);
+            const inputChars = chatRequestInputChars(input);
+            const promptSplit = usagePromptSplitFields(chatOptions.promptSplit);
+            const maxOutputTokens = input.maxOutputTokens ?? chatOptions.maxOutputTokens ?? defaults.maxOutputTokens;
+            const requestKind = chatOptions.requestKind ?? "chat";
+            const role = aiUsageRole(chatOptions.metadata ?? input.metadata);
+            const modelParams = effectiveModelParams(defaults.modelParams, {
+                modelParams: { ...(chatOptions.modelParams ?? {}), ...(input.modelParams ?? {}) }
+            });
+            await beforeCall({
+                agent: chatOptions.agent,
+                requestKind,
+                budgetMode: chatOptions.budgetMode,
+                inputChars,
+                estimatedOutputTokens: maxOutputTokens,
+                maxInputChars: chatOptions.maxInputChars
+            });
+            const request = {
+                ...input,
+                model,
+                maxOutputTokens,
+                modelParams,
+                ...(input.tools ? { tools: strictChatTools(input.tools) } : {})
+            };
+            const tapeCall = await inferenceTape.begin({
+                operation: "chat",
+                provider: provider.id ?? "unknown",
+                requestKind,
+                roleOrLane: role ?? requestKind,
+                request,
+                ...(chatOptions.promptBandDiagnostics
+                    ? { diagnostics: { promptBands: chatOptions.promptBandDiagnostics } }
+                    : {}),
+                correlation: tapeCorrelation({ agent: chatOptions.agent, conversationId: chatOptions.conversationId })
+            });
+            const started = Date.now();
+            try {
+                const result = await provider.chat(request, providerContext({
+                    agent: chatOptions.agent,
+                    conversationId: chatOptions.conversationId,
+                    gateway: chatOptions.gateway,
+                    metadata: chatOptions.metadata ?? input.metadata,
+                    signal: chatOptions.signal
+                }));
+                await tapeCall.completed(result);
+                await record({
+                    ...usagePrincipalFields(principal),
+                    agent: chatOptions.agent ?? options.agent ?? null,
+                    conversationId: chatOptions.conversationId ?? options.conversationId ?? null,
+                    model,
+                    requestKind,
+                    role,
+                    gatewayId: effectiveAiGatewayId(options.config, options.env),
+                    gatewayLogId: result.provider?.requestId ?? null,
+                    inputChars,
+                    ...promptSplit,
+                    outputChars: result.text.length,
+                    estimatedInputTokens: result.usage?.inputTokens ?? estimateTokensFromChars(inputChars),
+                    estimatedOutputTokens: result.usage?.outputTokens ?? estimateTokensFromChars(result.text.length),
+                    estimatedNeurons: null,
+                    modelParams,
+                    status: "ok",
+                    durationMs: Date.now() - started
+                });
+                return {
+                    ...result,
+                    // The padding the strict form required, undone against the tools as
+                    // the caller declared them, before anything parses these arguments.
+                    toolCalls: restoreStrictToolCalls(result.toolCalls, input.tools),
+                    provider: { id: result.provider?.id ?? provider.id, requestId: result.provider?.requestId, raw: result.provider?.raw }
+                };
+            }
+            catch (error) {
+                await tapeCall.error(error);
+                await record({
+                    ...usagePrincipalFields(principal),
+                    agent: chatOptions.agent ?? options.agent ?? null,
+                    conversationId: chatOptions.conversationId ?? options.conversationId ?? null,
+                    model,
+                    requestKind,
+                    role,
+                    gatewayId: effectiveAiGatewayId(options.config, options.env),
+                    inputChars,
+                    ...promptSplit,
+                    outputChars: 0,
+                    estimatedInputTokens: estimateTokensFromChars(inputChars),
+                    estimatedOutputTokens: 0,
+                    modelParams,
+                    status: "error",
+                    error: safeInferenceProviderErrorMessage(error),
+                    durationMs: Date.now() - started
+                });
+                throw error;
+            }
+        },
+        async chatStream(input, streamOptions = {}) {
+            const provider = await resolveProvider();
+            if (!provider)
+                throw new Error("Raybase AI is enabled in appConfig but no AI provider is available");
+            const model = requireConfiguredAiModel(input.model || options.defaultModel || defaults.model);
+            const inputChars = chatRequestInputChars(input);
+            const promptSplit = usagePromptSplitFields(streamOptions.promptSplit);
+            const maxOutputTokens = input.maxOutputTokens ?? streamOptions.maxOutputTokens ?? defaults.maxOutputTokens;
+            const requestKind = streamOptions.requestKind ?? "chat";
+            const role = aiUsageRole(streamOptions.metadata ?? input.metadata);
+            const modelParams = effectiveModelParams(defaults.modelParams, {
+                modelParams: { ...(streamOptions.modelParams ?? {}), ...(input.modelParams ?? {}) }
+            });
+            await beforeCall({
+                agent: streamOptions.agent,
+                requestKind,
+                budgetMode: streamOptions.budgetMode,
+                inputChars,
+                estimatedOutputTokens: maxOutputTokens,
+                maxInputChars: streamOptions.maxInputChars
+            });
+            const request = {
+                ...input,
+                model,
+                maxOutputTokens,
+                modelParams,
+                ...(input.tools ? { tools: strictChatTools(input.tools) } : {})
+            };
+            const tapeCall = await inferenceTape.begin({
+                operation: "chatStream",
+                provider: provider.id ?? "unknown",
+                requestKind,
+                roleOrLane: role ?? requestKind,
+                request,
+                ...(streamOptions.promptBandDiagnostics
+                    ? { diagnostics: { promptBands: streamOptions.promptBandDiagnostics } }
+                    : {}),
+                correlation: tapeCorrelation({ agent: streamOptions.agent, conversationId: streamOptions.conversationId })
+            });
+            const started = Date.now();
+            try {
+                const source = provider.chatStream
+                    ? await provider.chatStream(request, providerContext({
+                        agent: streamOptions.agent,
+                        conversationId: streamOptions.conversationId,
+                        gateway: streamOptions.gateway,
+                        metadata: streamOptions.metadata ?? input.metadata,
+                        signal: streamOptions.signal
+                    }))
+                    : chatResultToStream(await provider.chat(request, providerContext({
+                        agent: streamOptions.agent,
+                        conversationId: streamOptions.conversationId,
+                        gateway: streamOptions.gateway,
+                        metadata: streamOptions.metadata ?? input.metadata,
+                        signal: streamOptions.signal
+                    })));
+                return recordChatStreamUsage(restoreStrictToolCallStream(tapeChatStream(source, tapeCall), input.tools), {
+                    record,
+                    principal,
+                    agent: streamOptions.agent ?? options.agent ?? null,
+                    conversationId: streamOptions.conversationId ?? options.conversationId ?? null,
+                    model,
+                    requestKind,
+                    role,
+                    gatewayId: effectiveAiGatewayId(options.config, options.env),
+                    inputChars,
+                    promptSplit,
+                    modelParams,
+                    started,
+                    maxOutputTokens
+                });
+            }
+            catch (error) {
+                await tapeCall.error(error);
+                await record({
+                    ...usagePrincipalFields(principal),
+                    agent: streamOptions.agent ?? options.agent ?? null,
+                    conversationId: streamOptions.conversationId ?? options.conversationId ?? null,
+                    model,
+                    requestKind,
+                    role,
+                    gatewayId: effectiveAiGatewayId(options.config, options.env),
+                    inputChars,
+                    ...promptSplit,
+                    outputChars: 0,
+                    estimatedInputTokens: estimateTokensFromChars(inputChars),
+                    estimatedOutputTokens: 0,
+                    modelParams,
+                    status: "error",
+                    error: safeInferenceProviderErrorMessage(error),
+                    durationMs: Date.now() - started
+                });
+                throw error;
+            }
+        },
+        async embed(input, embedOptions = {}) {
+            const embeddingProvider = await resolveEmbeddingProvider();
+            if (!embeddingProvider?.embed)
+                throw new Error("Raybase AI embedding provider is unavailable");
+            const model = requireConfiguredAiModel(embedOptions.model ?? defaults.embeddingModel, "AI embedding model");
+            const inputChars = Array.isArray(input) ? input.join("\n").length : input.length;
+            const role = aiUsageRole(embedOptions.metadata);
+            const maxInputChars = embedOptions.maxInputChars ?? defaults.maxInputChars;
+            if (inputChars > maxInputChars)
+                throw new Error(`AI embedding input exceeds maxInputChars ${maxInputChars}`);
+            await beforeCall({
+                agent: embedOptions.agent,
+                requestKind: "embedding",
+                budgetMode: embedOptions.budgetMode,
+                inputChars,
+                estimatedOutputTokens: 0,
+                maxInputChars
+            });
+            const request = { model, input, metadata: embedOptions.metadata };
+            const tapeCall = await inferenceTape.begin({
+                operation: "embed",
+                provider: embeddingProvider.id ?? "unknown",
+                requestKind: "embedding",
+                roleOrLane: role ?? "embedding",
+                request,
+                correlation: tapeCorrelation({ agent: embedOptions.agent, conversationId: embedOptions.conversationId })
+            });
+            const started = Date.now();
+            try {
+                const result = await embeddingProvider.embed(request, providerContext({
+                    agent: embedOptions.agent,
+                    conversationId: embedOptions.conversationId,
+                    gateway: embedOptions.gateway,
+                    metadata: embedOptions.metadata,
+                    signal: embedOptions.signal
+                }));
+                await tapeCall.completed(result);
+                await recordAiEmbeddingUsage({
+                    record,
+                    principal,
+                    agent: embedOptions.agent ?? options.agent ?? null,
+                    conversationId: embedOptions.conversationId ?? options.conversationId ?? null,
+                    model,
+                    gatewayId: effectiveAiGatewayId(options.config, options.env),
+                    raw: result.provider?.raw,
+                    inputChars,
+                    role,
+                    started
+                });
+                return result.embeddings;
+            }
+            catch (error) {
+                await tapeCall.error(error);
+                await record({
+                    ...usagePrincipalFields(principal),
+                    agent: embedOptions.agent ?? options.agent ?? null,
+                    conversationId: embedOptions.conversationId ?? options.conversationId ?? null,
+                    model,
+                    requestKind: "embedding",
+                    role,
+                    gatewayId: effectiveAiGatewayId(options.config, options.env),
+                    inputChars,
+                    outputChars: 0,
+                    estimatedInputTokens: estimateTokensFromChars(inputChars),
+                    estimatedOutputTokens: 0,
+                    status: "error",
+                    error: safeInferenceProviderErrorMessage(error),
+                    durationMs: Date.now() - started
+                });
+                throw error;
+            }
+        },
+        object: (input, objectOptions) => raybaseObjectCall((request, callOptions) => client.chat(request, callOptions))(input, objectOptions)
+    };
+    return client;
+}
+/** Tool calls in a stream, restored the same way `chat` restores its own. */
+async function* restoreStrictToolCallStream(source, tools) {
+    if (!tools?.length) {
+        yield* source;
+        return;
+    }
+    for await (const event of source) {
+        if (event.type === "tool-call") {
+            yield { ...event, toolCall: restoreStrictToolCalls([event.toolCall], tools)[0] };
+            continue;
+        }
+        if (event.type === "done" && event.result?.toolCalls?.length) {
+            yield { ...event, result: { ...event.result, toolCalls: restoreStrictToolCalls(event.result.toolCalls, tools) } };
+            continue;
+        }
+        yield event;
+    }
+}
+export const disabledRaybaseAI = {
+    async chat() {
+        throw new Error("Raybase AI is not available in this context");
+    },
+    async chatStream() {
+        throw new Error("Raybase AI is not available in this context");
+    },
+    async object() {
+        throw new Error("Raybase AI is not available in this context");
+    },
+    async embed() {
+        throw new Error("Raybase AI is not available in this context");
+    }
+};
+async function recordAiEmbeddingUsage(input) {
+    await input.record({
+        ...usagePrincipalFields(input.principal),
+        agent: input.agent,
+        conversationId: input.conversationId,
+        model: input.model,
+        requestKind: "embedding",
+        role: input.role,
+        gatewayId: input.gatewayId,
+        gatewayLogId: gatewayLogId(input.raw),
+        inputChars: input.inputChars,
+        outputChars: 0,
+        estimatedInputTokens: estimateTokensFromChars(input.inputChars),
+        estimatedOutputTokens: 0,
+        estimatedNeurons: null,
+        status: "ok",
+        durationMs: Date.now() - input.started
+    });
+}
+function recordChatStreamUsage(source, input) {
+    return (async function* streamWithUsage() {
+        let outputText = "";
+        let doneResult;
+        try {
+            for await (const event of source) {
+                if (event.type === "text-delta")
+                    outputText += event.text;
+                if (event.type === "done")
+                    doneResult = event.result;
+                yield event;
+            }
+            const recordedText = typeof doneResult?.text === "string" ? doneResult.text : outputText;
+            await input.record({
+                ...usagePrincipalFields(input.principal),
+                agent: input.agent,
+                conversationId: input.conversationId,
+                model: input.model,
+                requestKind: input.requestKind,
+                role: input.role,
+                gatewayId: input.gatewayId,
+                gatewayLogId: doneResult?.provider?.requestId ?? null,
+                inputChars: input.inputChars,
+                ...input.promptSplit,
+                outputChars: recordedText.length,
+                estimatedInputTokens: doneResult?.usage?.inputTokens ?? estimateTokensFromChars(input.inputChars),
+                estimatedOutputTokens: doneResult?.usage?.outputTokens ?? estimateTokensFromChars(recordedText.length || input.maxOutputTokens),
+                estimatedNeurons: null,
+                modelParams: input.modelParams,
+                status: "ok",
+                durationMs: Date.now() - input.started
+            });
+        }
+        catch (error) {
+            await input.record({
+                ...usagePrincipalFields(input.principal),
+                agent: input.agent,
+                conversationId: input.conversationId,
+                model: input.model,
+                requestKind: input.requestKind,
+                role: input.role,
+                gatewayId: input.gatewayId,
+                inputChars: input.inputChars,
+                ...input.promptSplit,
+                outputChars: 0,
+                estimatedInputTokens: estimateTokensFromChars(input.inputChars),
+                estimatedOutputTokens: 0,
+                modelParams: input.modelParams,
+                status: "error",
+                error: safeInferenceProviderErrorMessage(error),
+                durationMs: Date.now() - input.started
+            });
+            throw error;
+        }
+    })();
+}
+async function* chatResultToStream(result) {
+    if (result.text)
+        yield { type: "text-delta", text: result.text };
+    for (const toolCall of result.toolCalls)
+        yield { type: "tool-call", toolCall };
+    yield { type: "done", result };
+}
+export function createCloudflareInferenceProvider() {
+    const workers = createCloudflareWorkersAIInferenceProvider();
+    const gateway = createCloudflareAiGatewayInferenceProvider();
+    return {
+        id: "cloudflare",
+        async chat(input, context) {
+            return shouldUseProviderNativeAiGateway(input.model, context) ? gateway.chat(input, context) : workers.chat(input, context);
+        },
+        async chatStream(input, context) {
+            return shouldUseProviderNativeAiGateway(input.model, context) ? gateway.chatStream(input, context) : workers.chatStream(input, context);
+        },
+        async embed(input, context) {
+            return workers.embed(input, context);
+        }
+    };
+}
+export function createCloudflareAiGatewayInferenceProvider() {
+    return {
+        id: "cloudflare-ai-gateway",
+        async chat(input, context) {
+            const response = await fetch(await aiGatewayChatCompletionsUrl(input.model, context), {
+                method: "POST",
+                headers: aiGatewayProviderHeaders(input.model, context, false),
+                body: stableJson(aiGatewayChatPayload(input)),
+                signal: context.signal
+            });
+            const raw = await parseAiGatewayJsonResponse(response);
+            const result = normalizeWorkersAiChatResult(raw, "cloudflare-ai-gateway");
+            return {
+                ...result,
+                provider: {
+                    id: "cloudflare-ai-gateway",
+                    requestId: gatewayLogIdFromHeaders(response.headers) ?? result.provider?.requestId,
+                    raw
+                }
+            };
+        },
+        async chatStream(input, context) {
+            const response = await fetch(await aiGatewayChatCompletionsUrl(input.model, context), {
+                method: "POST",
+                headers: aiGatewayProviderHeaders(input.model, context, true),
+                body: stableJson(aiGatewayChatPayload(input, true)),
+                signal: context.signal
+            });
+            if (!response.ok)
+                await throwAiGatewayResponseError(response);
+            return aiGatewayRawStreamEvents(response);
+        }
+    };
+}
+export function createCloudflareWorkersAIInferenceProvider() {
+    return {
+        id: "workers-ai",
+        async chat(input, context) {
+            const raw = await requireWorkersAI(context.env).run(input.model, workersAiChatPayload(input), context.gatewayOptions);
+            return normalizeWorkersAiChatResult(raw, "workers-ai");
+        },
+        async chatStream(input, context) {
+            const raw = await requireWorkersAI(context.env).run(input.model, workersAiChatPayload(input, true), context.gatewayOptions);
+            return workersAiRawStreamEvents(raw);
+        },
+        async embed(input, context) {
+            const raw = await requireWorkersAI(context.env).run(input.model, { text: input.input }, context.gatewayOptions);
+            return {
+                embeddings: parseEmbeddingResult(raw),
+                provider: { id: "workers-ai", requestId: gatewayLogId(raw) ?? undefined, raw }
+            };
+        }
+    };
+}
+export const raybaseTranscriptionModel = "@cf/openai/whisper-large-v3-turbo";
+export async function transcribeAudioWithWorkersAI(env, input) {
+    const result = await requireWorkersAI(env).run(raybaseTranscriptionModel, {
+        audio: input.audioBase64
+    });
+    const transcript = result && typeof result === "object" && typeof result.text === "string"
+        ? result.text.trim()
+        : "";
+    return { transcript };
+}
+function requireWorkersAI(env) {
+    if (!env.AI)
+        throw new Error("Workers AI binding is unavailable");
+    return env.AI;
+}
+function workersAiChatPayload(input, stream = false) {
+    const payload = {
+        messages: input.messages.map(workersAiChatMessage),
+        ...(input.maxOutputTokens !== undefined ? { max_tokens: input.maxOutputTokens } : {}),
+        ...(input.modelParams ?? {}),
+        ...chatProviderParams(input.providerParams)
+    };
+    if (input.tools?.length)
+        payload.tools = input.tools.map(workersAiTool);
+    if (input.responseFormat)
+        payload.response_format = chatResponseFormatPayload(input.responseFormat);
+    if (stream)
+        payload.stream = true;
+    return payload;
+}
+function chatProviderParams(params) {
+    if (!params?.verbosity)
+        return {};
+    return { verbosity: params.verbosity };
+}
+function chatResponseFormatPayload(format) {
+    if (format.type === "json_object")
+        return { type: "json_object" };
+    return {
+        type: "json_schema",
+        json_schema: {
+            name: format.name,
+            schema: format.schema,
+            ...(format.description ? { description: format.description } : {}),
+            ...(format.strict !== undefined ? { strict: format.strict } : {})
+        }
+    };
+}
+function workersAiChatMessage(message) {
+    if (message.role === "tool")
+        return { role: "tool", tool_call_id: message.toolCallId, content: message.content };
+    const content = message.role === "user" && Array.isArray(message.content)
+        ? message.content.map(workersAiChatContentPart)
+        : message.content;
+    const output = { role: message.role, content };
+    if (message.role === "assistant" && message.toolCalls?.length) {
+        output.tool_calls = message.toolCalls.map((call) => ({
+            id: call.id,
+            type: "function",
+            function: { name: call.name, arguments: stableJson(call.arguments ?? {}) }
+        }));
+    }
+    return output;
+}
+function workersAiChatContentPart(part) {
+    if (part.type === "text")
+        return { type: "text", text: part.text };
+    const url = part.type === "image"
+        ? `data:${part.mediaType};base64,${part.data}`
+        : part.url;
+    return { type: "image_url", image_url: { url } };
+}
+function workersAiTool(tool) {
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description ?? "",
+            parameters: tool.parameters ?? { type: "object", properties: {} }
+        }
+    };
+}
+function shouldUseProviderNativeAiGateway(model, context) {
+    if (model.startsWith("@cf/"))
+        return false;
+    if (!effectiveAiGatewayId(context.config, context.env))
+        return false;
+    return Boolean(context.config.ai?.gateway?.authorizationSecretName?.trim() ||
+        context.config.ai?.gateway?.storeKeyName?.trim() ||
+        context.env.RAYBASE_AI_GATEWAY_AUTH?.trim());
+}
+async function aiGatewayChatCompletionsUrl(model, context) {
+    const gatewayId = effectiveAiGatewayId(context.config, context.env);
+    if (!gatewayId)
+        throw new Error("AI Gateway id is required for provider-native AI Gateway requests");
+    const provider = aiGatewayProviderSlug(model);
+    const gateway = context.env.AI?.gateway?.(gatewayId);
+    if (!gateway?.getUrl)
+        throw new Error("AI Gateway provider-native requests require env.AI.gateway().getUrl()");
+    const baseUrl = (await gateway.getUrl(provider)).replace(/\/+$/, "");
+    return `${baseUrl}${aiGatewayChatCompletionsPath(provider)}`;
+}
+/**
+ * The OpenAI-compatible chat path under a provider's AI Gateway base. The
+ * gateway appends what follows the provider slug to the provider's own API
+ * root, so the path depends on where each provider mounts its compatible
+ * endpoint: OpenAI-shaped APIs serve `/chat/completions` at their `/v1`
+ * root, while Anthropic's compatibility layer lives at `/v1/chat/completions`
+ * under `api.anthropic.com`.
+ */
+export function aiGatewayChatCompletionsPath(provider) {
+    return provider === "anthropic" ? "/v1/chat/completions" : "/chat/completions";
+}
+function aiGatewayProviderSlug(model) {
+    const slash = model.indexOf("/");
+    const provider = slash === -1 ? "" : model.slice(0, slash);
+    if (!provider || provider.startsWith("@"))
+        throw new Error(`AI Gateway provider-native model must be provider/model, received ${model}`);
+    return provider;
+}
+function aiGatewayProviderModel(model) {
+    const slash = model.indexOf("/");
+    return slash === -1 ? model : model.slice(slash + 1);
+}
+function aiGatewayProviderHeaders(model, context, stream) {
+    const headers = new Headers({ "Content-Type": "application/json" });
+    if (stream)
+        headers.set("Accept", "text/event-stream");
+    const gatewayAuthorization = effectiveAiGatewayRequestAuthorization(context.env);
+    if (gatewayAuthorization)
+        headers.set("cf-aig-authorization", gatewayAuthorization);
+    const providerAuthorization = effectiveAiGatewayProviderAuthorization(context.config, context.env);
+    if (providerAuthorization) {
+        headers.set("Authorization", providerAuthorization);
+        // Anthropic reads its key from x-api-key; the gateway only recognises a
+        // request-supplied Anthropic credential there, and the compatibility
+        // endpoint accepts either header.
+        if (aiGatewayProviderSlug(model) === "anthropic")
+            headers.set("x-api-key", providerAuthorization.replace(/^Bearer\s+/i, ""));
+    }
+    const storeKeyName = context.config.ai?.gateway?.storeKeyName?.trim();
+    if (storeKeyName && storeKeyName !== "default")
+        headers.set("cf-aig-byok-alias", storeKeyName);
+    headers.set("cf-aig-metadata", stableJson(aiGatewayMetadata(context)));
+    headers.set("x-raybase-model-provider", aiGatewayProviderSlug(model));
+    return headers;
+}
+function aiGatewayMetadata(context) {
+    const gateway = asRecord(asRecord(context.gatewayOptions).gateway);
+    return {
+        ...asRecord(gateway.metadata),
+        ...(context.metadata ?? {})
+    };
+}
+function aiGatewayChatPayload(input, stream = false) {
+    const providerModel = aiGatewayProviderModel(input.model);
+    return {
+        ...workersAiChatPayload(input, stream),
+        model: providerModel
+    };
+}
+async function parseAiGatewayJsonResponse(response) {
+    const text = await response.text();
+    let parsed = text;
+    if (text.trim()) {
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = text;
+        }
+    }
+    if (!response.ok) {
+        const message = typeof parsed === "string" ? parsed : stableJson(parsed);
+        throw new Error(`AI Gateway request failed with ${response.status}: ${message}`);
+    }
+    return parsed;
+}
+async function throwAiGatewayResponseError(response) {
+    const body = await response.text();
+    throw new Error(`AI Gateway request failed with ${response.status}: ${body}`);
+}
+/**
+ * Tool calls in an OpenAI-shaped chat stream arrive as fragments: the first
+ * delta for an index carries the id and name with empty arguments, later
+ * deltas append argument text, and the finish chunk closes them. Fragments
+ * are gathered here per index and released as one call each at the finish;
+ * a delta that already carries parsed (non-string) arguments is complete and
+ * released at once, which is how Workers AI streams them.
+ */
+export class AiStreamToolCallAssembler {
+    pending = new Map();
+    /** Returns the calls completed by this chunk; fragments stay pending. */
+    collect(raw) {
+        const record = asRecord(raw);
+        const choices = Array.isArray(record.choices) ? record.choices : [];
+        const first = asRecord(choices[0]);
+        const delta = asRecord(first.delta);
+        const fragments = Array.isArray(delta.tool_calls) ? delta.tool_calls : Array.isArray(delta.toolCalls) ? delta.toolCalls : null;
+        const finished = typeof first.finish_reason === "string" || typeof first.finishReason === "string";
+        if (!fragments) {
+            const complete = extractProviderToolCalls(raw);
+            return finished ? [...complete, ...this.flush()] : complete;
+        }
+        const complete = [];
+        fragments.forEach((entry, position) => {
+            const call = asRecord(entry);
+            const fn = asRecord(call.function);
+            const args = call.arguments ?? fn.arguments ?? call.args ?? call.input;
+            if (args !== undefined && typeof args !== "string") {
+                complete.push(...extractProviderToolCalls({ tool_calls: [entry] }));
+                return;
+            }
+            const index = typeof call.index === "number" ? call.index : position;
+            const current = this.pending.get(index) ?? { id: "", name: "", arguments: "" };
+            if (typeof call.id === "string" && call.id)
+                current.id = call.id;
+            const name = String(call.name ?? fn.name ?? "");
+            if (name)
+                current.name = name;
+            if (typeof args === "string")
+                current.arguments += args;
+            this.pending.set(index, current);
+        });
+        return finished ? [...complete, ...this.flush()] : complete;
+    }
+    /** Releases every pending call, for the finish chunk and the end of the stream. */
+    flush() {
+        const calls = [...this.pending.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([index, call]) => {
+            if (!call.name)
+                throw new Error(`Malformed streamed tool call at index ${index}: missing name`);
+            return {
+                id: call.id || `tool_call_${index + 1}_${randomId("call")}`,
+                name: call.name,
+                arguments: parseProviderToolArguments(call.arguments.trim() || "{}")
+            };
+        });
+        this.pending.clear();
+        return calls;
+    }
+}
+async function* aiGatewayRawStreamEvents(response) {
+    const stream = coerceReadableStream(response);
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    const requestId = gatewayLogIdFromHeaders(response.headers) ?? undefined;
+    const assembler = new AiStreamToolCallAssembler();
+    let buffered = "";
+    let outputText = "";
+    let sawDone = false;
+    const done = () => ({ type: "done", result: { text: outputText, provider: { id: "cloudflare-ai-gateway", requestId } } });
+    try {
+        while (true) {
+            const { value, done: finished } = await reader.read();
+            if (finished)
+                break;
+            buffered += decoder.decode(value, { stream: true });
+            const splitAt = buffered.lastIndexOf("\n\n");
+            if (splitAt === -1)
+                continue;
+            const ready = buffered.slice(0, splitAt + 2);
+            buffered = buffered.slice(splitAt + 2);
+            for (const event of parseWorkersAiSseText(ready)) {
+                if (event.text) {
+                    outputText += event.text;
+                    yield { type: "text-delta", text: event.text };
+                }
+                if (event.done) {
+                    for (const toolCall of assembler.flush())
+                        yield { type: "tool-call", toolCall };
+                    sawDone = true;
+                    yield done();
+                    continue;
+                }
+                for (const toolCall of assembler.collect(event.raw))
+                    yield { type: "tool-call", toolCall };
+            }
+        }
+        buffered += decoder.decode();
+        if (buffered.trim()) {
+            for (const event of parseWorkersAiSseText(buffered)) {
+                if (event.text) {
+                    outputText += event.text;
+                    yield { type: "text-delta", text: event.text };
+                }
+                if (event.done) {
+                    for (const toolCall of assembler.flush())
+                        yield { type: "tool-call", toolCall };
+                    sawDone = true;
+                    yield done();
+                    continue;
+                }
+                for (const toolCall of assembler.collect(event.raw))
+                    yield { type: "tool-call", toolCall };
+            }
+        }
+        if (!sawDone) {
+            for (const toolCall of assembler.flush())
+                yield { type: "tool-call", toolCall };
+            yield done();
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function normalizeWorkersAiChatResult(raw, providerId) {
+    const text = modelResultText(raw);
+    const toolCalls = extractProviderToolCalls(raw);
+    return {
+        text,
+        toolCalls,
+        finishReason: normalizeFinishReason(raw, toolCalls),
+        usage: normalizeProviderUsage(raw),
+        provider: { id: providerId, requestId: gatewayLogId(raw) ?? undefined, raw }
+    };
+}
+async function* workersAiRawStreamEvents(raw) {
+    if (!(raw instanceof ReadableStream) && !(raw instanceof Response) && typeof raw !== "string") {
+        yield* chatResultToStream(normalizeWorkersAiChatResult(raw, "workers-ai"));
+        return;
+    }
+    const stream = coerceReadableStream(raw);
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffered = "";
+    let sawDone = false;
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffered += decoder.decode(value, { stream: true });
+            const splitAt = buffered.lastIndexOf("\n\n");
+            if (splitAt === -1)
+                continue;
+            const ready = buffered.slice(0, splitAt + 2);
+            buffered = buffered.slice(splitAt + 2);
+            for (const event of parseWorkersAiSseText(ready)) {
+                if (event.text)
+                    yield { type: "text-delta", text: event.text };
+                for (const toolCall of extractProviderToolCalls(event.raw))
+                    yield { type: "tool-call", toolCall };
+                if (event.done) {
+                    sawDone = true;
+                    yield { type: "done" };
+                }
+            }
+        }
+        buffered += decoder.decode();
+        if (buffered.trim()) {
+            const events = parseWorkersAiSseText(buffered);
+            if (events.length) {
+                for (const event of events) {
+                    if (event.text)
+                        yield { type: "text-delta", text: event.text };
+                    for (const toolCall of extractProviderToolCalls(event.raw))
+                        yield { type: "tool-call", toolCall };
+                    if (event.done) {
+                        sawDone = true;
+                        yield { type: "done" };
+                    }
+                }
+            }
+            else {
+                let parsed = buffered;
+                try {
+                    parsed = JSON.parse(buffered);
+                }
+                catch {
+                    parsed = buffered;
+                }
+                const result = normalizeWorkersAiChatResult(parsed, "workers-ai");
+                if (result.text)
+                    yield { type: "text-delta", text: result.text };
+                for (const toolCall of result.toolCalls)
+                    yield { type: "tool-call", toolCall };
+                sawDone = true;
+                yield { type: "done", result };
+            }
+        }
+        if (!sawDone)
+            yield { type: "done" };
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function extractProviderToolCalls(result) {
+    const record = asRecord(result);
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    const firstMessage = asRecord(asRecord(choices[0]).message);
+    const firstDelta = asRecord(asRecord(choices[0]).delta);
+    const candidates = [record.tool_calls, record.toolCalls, firstMessage.tool_calls, firstMessage.toolCalls, firstDelta.tool_calls, firstDelta.toolCalls]
+        .find(Array.isArray);
+    return (candidates ?? []).map((raw, index) => {
+        const call = asRecord(raw);
+        const fn = asRecord(call.function);
+        const name = String(call.name ?? fn.name ?? "");
+        if (!name)
+            throw new Error(`Malformed tool call at index ${index}: missing name`);
+        return {
+            id: String(call.id ?? `tool_call_${index + 1}_${randomId("call")}`),
+            name,
+            arguments: parseProviderToolArguments(call.arguments ?? fn.arguments ?? call.args ?? call.input ?? {})
+        };
+    });
+}
+function parseProviderToolArguments(value) {
+    if (typeof value !== "string")
+        return value ?? {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error("Malformed tool call arguments JSON");
+    }
+}
+function normalizeFinishReason(raw, toolCalls) {
+    const record = asRecord(raw);
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    const first = asRecord(choices[0]);
+    const reason = String(record.finish_reason ?? record.finishReason ?? first.finish_reason ?? first.finishReason ?? "").toLowerCase();
+    if (toolCalls.length || reason === "tool_calls" || reason === "tool-calls")
+        return "tool-calls";
+    if (reason === "stop")
+        return "stop";
+    if (reason === "length" || reason === "max_tokens")
+        return "length";
+    if (reason === "error")
+        return "error";
+    return "unknown";
+}
+function normalizeProviderUsage(raw) {
+    const usage = asRecord(asRecord(raw).usage);
+    const inputTokens = numericUsage(usage.prompt_tokens ?? usage.input_tokens ?? usage.inputTokens);
+    const outputTokens = numericUsage(usage.completion_tokens ?? usage.output_tokens ?? usage.outputTokens);
+    return inputTokens === undefined && outputTokens === undefined ? undefined : { inputTokens, outputTokens };
+}
+function numericUsage(value) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) && numeric >= 0 ? numeric : undefined;
+}
+function localAiProvider(env, config, liveProvider) {
+    if (env.RAYBASE_ENV !== "local")
+        return liveProvider;
+    const mode = normalizeLocalAiMode(env.RAYBASE_AI_MODE);
+    if (mode === "mock")
+        return mockRaybaseAIProvider(config, env.RAYBASE_AI_MOCK_RESPONSE);
+    if (mode === "disabled")
+        return localDisabledRaybaseAIProvider;
+    return liveProvider;
+}
+function normalizeLocalAiMode(value) {
+    const mode = value?.trim().toLowerCase();
+    if (mode === "live" || mode === "mock" || mode === "disabled")
+        return mode;
+    return null;
+}
+export function mockRaybaseAIProvider(config, responseOverride) {
+    const defaults = normalizeAiDefaults(config);
+    return {
+        id: "raybase-local-mock",
+        async chat(input) {
+            const text = responseOverride?.trim() || "Raybase local mock AI response.";
+            return {
+                text,
+                toolCalls: [],
+                finishReason: "stop",
+                provider: { id: "raybase-local-mock", raw: { input } }
+            };
+        },
+        async chatStream(input) {
+            const text = responseOverride?.trim() || "Raybase local mock AI response.";
+            return chatResultToStream({
+                text,
+                toolCalls: [],
+                finishReason: "stop",
+                provider: { id: "raybase-local-mock", raw: { input } }
+            });
+        },
+        async embed(input) {
+            const dimensions = embeddingDimensionsForModelName(defaults.embeddingModel);
+            const values = Array.isArray(input.input) ? input.input : [input.input];
+            return {
+                embeddings: values.map((value) => deterministicUnitVector(String(value), dimensions)),
+                provider: { id: "raybase-local-mock" }
+            };
+        }
+    };
+}
+const localDisabledRaybaseAIProvider = {
+    id: "raybase-local-disabled",
+    async chat() {
+        throw new Error("Raybase AI is disabled for local development. Set RAYBASE_AI_MODE=mock or run `raybase dev --ai live` to use Workers AI.");
+    },
+    async chatStream() {
+        throw new Error("Raybase AI is disabled for local development. Set RAYBASE_AI_MODE=mock or run `raybase dev --ai live` to use Workers AI.");
+    },
+    async embed() {
+        throw new Error("Raybase AI is disabled for local development. Set RAYBASE_AI_MODE=mock or run `raybase dev --ai live` to use Workers AI.");
+    }
+};
+function deterministicUnitVector(input, dimensions) {
+    const vector = [];
+    let state = deterministicHash(input || "raybase-local-mock");
+    let sumSquares = 0;
+    for (let index = 0; index < dimensions; index += 1) {
+        state = (1664525 * state + 1013904223) >>> 0;
+        const value = ((state / 0xffffffff) * 2) - 1;
+        vector.push(value);
+        sumSquares += value * value;
+    }
+    const norm = Math.sqrt(sumSquares) || 1;
+    return vector.map((value) => value / norm);
+}
+function deterministicHash(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0 || 1;
+}
+function embeddingDimensionsForModelName(model) {
+    if (model === "@cf/baai/bge-small-en-v1.5")
+        return 384;
+    if (model === "@cf/baai/bge-large-en-v1.5")
+        return 1024;
+    return 768;
+}
+function effectiveModelParams(defaults, options) {
+    return normalizeModelParams({
+        ...defaults,
+        ...(options.modelParams ?? {})
+    });
+}
+function normalizeModelParams(params) {
+    const output = {};
+    const temperature = boundedModelParam(params.temperature, "temperature");
+    const topP = boundedModelParam(params.top_p, "top_p");
+    if (temperature !== undefined)
+        output.temperature = temperature;
+    if (topP !== undefined)
+        output.top_p = topP;
+    return output;
+}
+function boundedModelParam(value, name) {
+    if (value === undefined || value === null)
+        return undefined;
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric < 0 || numeric > 2) {
+        throw new Error(`AI model parameter ${name} must be a number between 0 and 2`);
+    }
+    return numeric;
+}
+export async function recordAiUsageEvent(db, event) {
+    await db.run(`INSERT INTO "_ai_usage_events"
+     ("id", "userId", "principalKind", "publicScopeHash", "serviceName", "agent", "conversationId", "model", "requestKind", "role", "gatewayId", "gatewayLogId",
+      "inputChars", "floorChars", "tailChars", "outputChars", "estimatedInputTokens", "estimatedOutputTokens", "estimatedNeurons", "modelParams", "metadata",
+      "status", "error", "durationMs", "createdAt")
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        randomId("ai_usage"),
+        event.userId ?? null,
+        event.principalKind ?? "user",
+        event.publicScopeHash ?? null,
+        event.serviceName ?? null,
+        event.agent ?? null,
+        event.conversationId ?? null,
+        event.model,
+        event.requestKind,
+        event.role ?? null,
+        event.gatewayId ?? null,
+        event.gatewayLogId ?? null,
+        event.inputChars,
+        event.floorChars ?? null,
+        event.tailChars ?? null,
+        event.outputChars,
+        event.estimatedInputTokens,
+        event.estimatedOutputTokens,
+        event.estimatedNeurons ?? null,
+        event.modelParams && Object.keys(event.modelParams).length ? stableJson(event.modelParams) : null,
+        event.metadata && Object.keys(event.metadata).length ? stableJson(event.metadata) : null,
+        event.status,
+        event.error ?? null,
+        event.durationMs,
+        nowIso()
+    ]);
+}
+export async function recordAiActionEvent(db, input) {
+    await db.run(`INSERT INTO "_ai_action_events" ("id", "userId", "agent", "conversationId", "actionName", "inputHash", "status", "error", "createdAt")
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        randomId("ai_action"),
+        input.userId,
+        input.agent,
+        input.conversationId ?? null,
+        input.actionName,
+        input.actionInput === undefined ? null : await sha256Hex(stableJson(input.actionInput)),
+        input.status,
+        input.error ?? null,
+        nowIso()
+    ]);
+}
+export function formatSseEvent(event, data) {
+    return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+export function parseWorkersAiSseText(text) {
+    const events = [];
+    let current = [];
+    const flush = () => {
+        if (!current.length)
+            return;
+        const data = current.join("\n").trim();
+        current = [];
+        if (!data)
+            return;
+        if (data === "[DONE]") {
+            events.push({ raw: "[DONE]", done: true });
+            return;
+        }
+        try {
+            const parsed = JSON.parse(data);
+            events.push({ raw: parsed, text: modelResultText(parsed) || undefined });
+        }
+        catch {
+            events.push({ raw: data, text: data });
+        }
+    };
+    for (const line of text.split(/\r?\n/)) {
+        if (!line.trim()) {
+            flush();
+            continue;
+        }
+        if (line.startsWith("data:"))
+            current.push(line.slice(5).trimStart());
+    }
+    flush();
+    return events;
+}
+export function modelResultText(value) {
+    if (typeof value === "string")
+        return value;
+    const record = asRecord(value);
+    if (typeof record.response === "string")
+        return record.response;
+    if (typeof record.text === "string")
+        return record.text;
+    if (typeof record.content === "string")
+        return record.content;
+    const output = record.output;
+    if (typeof output === "string")
+        return output;
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    const first = asRecord(choices[0]);
+    const message = asRecord(first.message);
+    const delta = asRecord(first.delta);
+    if (typeof message.content === "string")
+        return message.content;
+    if (typeof delta.content === "string")
+        return delta.content;
+    if (typeof first.text === "string")
+        return first.text;
+    return "";
+}
+export function jsonCharLength(value) {
+    if (typeof value === "string")
+        return value.length;
+    return stableJson(value).length;
+}
+export function estimateTokensFromChars(chars) {
+    return Math.max(0, Math.ceil(chars / 4));
+}
+export function encodeFloatVector(vector) {
+    const floats = new Float32Array(vector);
+    const bytes = new Uint8Array(floats.buffer);
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    if (typeof btoa === "function")
+        return btoa(binary);
+    throw new Error("Base64 encoding is unavailable in this runtime");
+}
+export function decodeFloatVector(base64) {
+    if (typeof atob !== "function")
+        throw new Error("Base64 decoding is unavailable in this runtime");
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1)
+        bytes[index] = binary.charCodeAt(index);
+    return Array.from(new Float32Array(bytes.buffer));
+}
+export function cosineSimilarity(left, right) {
+    const length = Math.min(left.length, right.length);
+    let dot = 0;
+    let leftNorm = 0;
+    let rightNorm = 0;
+    for (let index = 0; index < length; index += 1) {
+        const a = left[index] ?? 0;
+        const b = right[index] ?? 0;
+        dot += a * b;
+        leftNorm += a * a;
+        rightNorm += b * b;
+    }
+    if (!leftNorm || !rightNorm)
+        return 0;
+    return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+function parseEmbeddingResult(raw) {
+    if (Array.isArray(raw) && Array.isArray(raw[0]))
+        return raw;
+    const record = asRecord(raw);
+    const data = record.data;
+    if (Array.isArray(data)) {
+        if (Array.isArray(data[0]))
+            return data;
+        if (data.every((item) => asRecord(item).embedding))
+            return data.map((item) => asRecord(item).embedding);
+    }
+    if (Array.isArray(record.embeddings))
+        return record.embeddings;
+    if (Array.isArray(record.embedding))
+        return [record.embedding];
+    throw new Error("Workers AI embedding response did not include vectors");
+}
+function coerceReadableStream(raw) {
+    if (raw instanceof ReadableStream)
+        return raw;
+    if (raw instanceof Response && raw.body)
+        return raw.body;
+    const text = typeof raw === "string" ? raw : stableJson(raw);
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(new TextEncoder().encode(text));
+            controller.close();
+        }
+    });
+}
+function gatewayLogId(raw) {
+    const record = asRecord(raw);
+    return typeof record.gatewayLogId === "string" ? record.gatewayLogId : typeof record.logId === "string" ? record.logId : null;
+}
+function gatewayLogIdFromHeaders(headers) {
+    return headers.get("cf-aig-log-id") ?? headers.get("cf-ai-gateway-log-id") ?? headers.get("x-ai-gateway-log-id");
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function aiUsageRole(metadata) {
+    const record = asRecord(metadata);
+    for (const key of ["role", "raybaseComposingSurface"]) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return null;
+}
+//# sourceMappingURL=ai.js.map