@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/internal-providers/provider-codex/test/translated-content.test.js

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { SubscriptionAccountSet } from "@velum-labs/routekit-accounts";
+import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
+import { codex, codexProvider } from "../module-api.js";
+for (const stream of [false, true]) {
+    test(`managed Codex source preserves images and account attribution (stream=${stream})`, async (t) => {
+        const directory = await mkdtemp(join(tmpdir(), "codex-content-"));
+        await writeFile(join(directory, "account.json"), JSON.stringify({ tokens: { access_token: "offline-token", account_id: "offline-account" } }));
+        const accounts = await runRouteKitEffect(SubscriptionAccountSet.open(codexProvider(), {
+            source: { kind: "directory", path: directory },
+            publishedModels: ["codex-test"],
+            probeIntervalMs: 0
+        }));
+        t.after(async () => {
+            await runRouteKitEffect(accounts.close());
+            await rm(directory, { recursive: true, force: true });
+        });
+        const source = await runRouteKitEffect(codex.createSource({
+            sourceId: "codex",
+            config: { use: "codex" },
+            env: {},
+            resources: { accountSet: accounts }
+        }));
+        assert.equal(source.responses.kind, "unsupported");
+        const requests = [];
+        t.mock.method(globalThis, "fetch", async (input, init) => {
+            const request = new Request(input, init);
+            requests.push(request);
+            assert.equal(request.url, "https://chatgpt.com/backend-api/codex/responses");
+            const response = {
+                id: "resp_offline",
+                output: [
+                    {
+                        type: "message",
+                        role: "assistant",
+                        content: [{ type: "output_text", text: "image received" }]
+                    }
+                ],
+                usage: { input_tokens: 4, output_tokens: 3, total_tokens: 7 }
+            };
+            return new Response(`event: response.output_text.delta\ndata: {"delta":"image received"}\n\nevent: response.completed\ndata: ${JSON.stringify({ response })}\n\n`, { headers: { "content-type": "text/event-stream" } });
+        });
+        const attempts = [];
+        const response = await runRouteKitEffect(source.requests.chat({
+            model: "codex-test",
+            stream,
+            messages: [
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "image_url",
+                            image_url: { url: "data:image/png;base64,b2ZmbGluZQ==", detail: "low" }
+                        }
+                    ]
+                }
+            ],
+            max_tokens: 1
+        }, undefined, {
+            responseMode: stream ? "streaming" : "buffered",
+            onAttribution: (update) => attempts.push(update)
+        }));
+        assert.equal(response.status, 200);
+        const text = await response.text();
+        assert.match(text, /image received/);
+        assert.match(text, /prompt_tokens":4/);
+        assert.equal(requests.length, 1);
+        assert.equal(requests[0].headers.get("authorization"), "Bearer offline-token");
+        assert.equal(requests[0].headers.get("chatgpt-account-id"), "offline-account");
+        const body = (await requests[0].json());
+        assert.deepEqual(body.input.at(-1), {
+            role: "user",
+            content: [
+                { type: "input_image", image_url: "data:image/png;base64,b2ZmbGluZQ==", detail: "low" }
+            ]
+        });
+        assert.equal(body.stream, true);
+        assert.equal(Object.hasOwn(body, "max_output_tokens"), false);
+        assert.ok(attempts.some((attempt) => Object.hasOwn(attempt, "accountAttempt")));
+        const rejected = await runRouteKitEffect(source.requests.chat({
+            model: "codex-test",
+            messages: [{ role: "user", content: [{ type: "file", file: { file_data: "private" } }] }]
+        }));
+        assert.equal(rejected.status, 400);
+        assert.equal(requests.length, 1, "rejected content never enters the account transport");
+    });
+}

package/dist/internal-providers/provider-custom/index.d.ts

@@ -0,0 +1,9 @@
+import { ApiProviderSource } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+export declare const custom: {
+    readonly id: "custom";
+    readonly protocol: "openai";
+    readonly accountClass: "api-key";
+    readonly billingMode: "metered-api";
+    readonly createSource: (context: import("@velum-labs/routekit-provider-core").ProviderModuleContext) => Effect.Effect<ApiProviderSource, never, never>;
+};

package/dist/internal-providers/provider-custom/index.js

@@ -0,0 +1,15 @@
+import { ApiProviderSource } from "@velum-labs/routekit-provider-core";
+import { defineProvider } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+export const custom = defineProvider({
+    id: "custom",
+    protocol: "openai",
+    accountClass: "api-key",
+    billingMode: "metered-api",
+    createSource: (context) => Effect.sync(() => new ApiProviderSource({
+        provider: "custom",
+        sourceId: context.sourceId,
+        config: context.config,
+        env: context.env
+    }))
+});

package/dist/internal-providers/provider-google/index.d.ts

@@ -0,0 +1,23 @@
+import { ApiProviderSource } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+export declare const google: {
+    readonly id: "google";
+    readonly protocol: "google";
+    readonly accountClass: "api-key";
+    readonly billingMode: "metered-api";
+    readonly connection: Readonly<{
+        validate?: (context: Readonly<{
+            sourceId: string;
+            config: import("@velum-labs/routekit-config-core").SourceConfig;
+            env: Readonly<Record<string, string | undefined>>;
+            resources?: Readonly<Record<string, unknown>>;
+        }>) => Effect.Effect<void, Error, import("@velum-labs/routekit-runtime/effect").RouteKitPlatform>;
+        credentialValidation?: "registry-key-probe" | "registry-key-probe-if-configured-models";
+        manifest: import("@velum-labs/routekit-provider-core").ProviderConnectionManifest;
+        prepare?: (input: import("@velum-labs/routekit-provider-core").PrepareProviderConnectionInput) => import("@velum-labs/routekit-provider-core").PreparedProviderConnection;
+        enrollment?: Readonly<Record<string, import("@velum-labs/routekit-provider-core").ProviderEnrollmentAdapter>>;
+        credentials?: import("@velum-labs/routekit-provider-core").ProviderCredentialAdapter;
+        subscriptionMode?: import("@velum-labs/routekit-registry").SubscriptionMode;
+    }>;
+    readonly createSource: (context: import("@velum-labs/routekit-provider-core").ProviderModuleContext) => Effect.Effect<ApiProviderSource, never, never>;
+};

package/dist/internal-providers/provider-google/index.js

@@ -0,0 +1,43 @@
+import { ApiProviderSource, connectionString, connectionStringList, defineProviderConnection, defineProvider, optionalConnectionString, preparedProviderConnection, providerSourceTransportFromContext, routeTextToolModelMetadata } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+function configuredGoogleModelMetadata(model) {
+    const nativeModel = model.replace(/^models\//u, "");
+    return /^gemini(?:[-.]|$)/iu.test(nativeModel)
+        ? routeTextToolModelMetadata({ inputModalities: ["text", "image"] })
+        : undefined;
+}
+export const google = defineProvider({
+    id: "google",
+    protocol: "google",
+    accountClass: "api-key",
+    billingMode: "metered-api",
+    connection: defineProviderConnection({
+        manifest: {
+            version: 1, id: "google", displayName: "Google Gemini API", category: "api",
+            description: "Connect a Google AI Studio API key.",
+            methods: [{ id: "api-key", kind: "form", label: "API key", schemaRevision: 1, fields: [
+                        { id: "api-key", label: "API key", control: "secret", required: true },
+                        { id: "base-url", label: "Base URL", control: "url", required: false, advanced: true, description: "With explicit models, custom endpoints must support authenticated GET /v1beta/models for key validation." },
+                        { id: "models", label: "Models", control: "string-list", required: false, advanced: true, description: "Optional comma- or line-separated IDs. Explicit models require read-only model-list access to validate the key." }
+                    ] }]
+        },
+        prepare: ({ values }) => {
+            const env = "ROUTEKIT_CLOUD_GRANT_GOOGLE_KEY";
+            const baseUrl = optionalConnectionString(values, "base-url");
+            const models = connectionStringList(values, "models");
+            return preparedProviderConnection({
+                config: { use: "google", auth: { kind: "env-header", env, header: "x-goog-api-key" }, ...(baseUrl === undefined ? {} : { baseUrl }), ...(models === undefined ? {} : { options: { models } }) },
+                environment: { [env]: connectionString(values, "api-key") }
+            });
+        },
+        credentialValidation: "registry-key-probe-if-configured-models"
+    }),
+    createSource: (context) => Effect.sync(() => new ApiProviderSource({
+        provider: "google",
+        sourceId: context.sourceId,
+        config: context.config,
+        env: context.env,
+        transport: providerSourceTransportFromContext(context),
+        metadataForConfiguredModel: configuredGoogleModelMetadata
+    }))
+});

package/dist/internal-providers/provider-google/test/provider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal-providers/provider-google/test/provider.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { Effect } from "effect";
+import { google } from "../index.js";
+test("configured Google catalogs qualify known Gemini routes and fail closed otherwise", async () => {
+    const prepared = google.connection.prepare({
+        sourceId: "google-production",
+        methodId: "api-key",
+        values: { "api-key": "google-secret" }
+    });
+    const source = await Effect.runPromise(google.createSource({
+        sourceId: "google-production",
+        config: {
+            ...prepared.config,
+            options: {
+                models: ["gemini-2.5-pro", "text-embedding-004", "future-google-model"]
+            }
+        },
+        env: prepared.environment
+    }));
+    const models = await Effect.runPromise(source.discovery.discoverModels());
+    const [gemini, embedding, unknown] = models;
+    assert.deepEqual(gemini?.metadata, {
+        architecture: {
+            modality: "text+image->text",
+            inputModalities: ["text", "image"],
+            outputModalities: ["text"]
+        },
+        supportedParameters: ["tools", "tool_choice"],
+        provenance: "route"
+    });
+    assert.equal(embedding?.metadata, undefined);
+    assert.equal(unknown?.metadata, undefined);
+});

package/dist/internal-providers/provider-google-vertex/index.d.ts

@@ -0,0 +1,28 @@
+import type { SourceConfig } from "@velum-labs/routekit-config-core";
+import type { ProviderSource } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+export type VertexAuthHeaders = (url: string) => Promise<{
+    entries(): IterableIterator<[string, string]>;
+}>;
+export declare function createVertexSource(sourceId: string, config: SourceConfig, authorization?: VertexAuthHeaders | Readonly<Record<string, string | undefined>>): ProviderSource;
+export declare const googleVertex: {
+    readonly id: "google-vertex";
+    readonly protocol: "google";
+    readonly accountClass: "iam";
+    readonly billingMode: "metered-api";
+    readonly connection: Readonly<{
+        validate?: (context: Readonly<{
+            sourceId: string;
+            config: SourceConfig;
+            env: Readonly<Record<string, string | undefined>>;
+            resources?: Readonly<Record<string, unknown>>;
+        }>) => Effect.Effect<void, Error, import("@velum-labs/routekit-runtime/effect").RouteKitPlatform>;
+        credentialValidation?: "registry-key-probe" | "registry-key-probe-if-configured-models";
+        manifest: import("@velum-labs/routekit-provider-core").ProviderConnectionManifest;
+        prepare?: (input: import("@velum-labs/routekit-provider-core").PrepareProviderConnectionInput) => import("@velum-labs/routekit-provider-core").PreparedProviderConnection;
+        enrollment?: Readonly<Record<string, import("@velum-labs/routekit-provider-core").ProviderEnrollmentAdapter>>;
+        credentials?: import("@velum-labs/routekit-provider-core").ProviderCredentialAdapter;
+        subscriptionMode?: import("@velum-labs/routekit-registry").SubscriptionMode;
+    }>;
+    readonly createSource: (context: import("@velum-labs/routekit-provider-core").ProviderModuleContext) => Effect.Effect<ProviderSource, never, never>;
+};

package/dist/internal-providers/provider-google-vertex/index.js

@@ -0,0 +1,137 @@
+import { connectionString, connectionStringList, defineProviderConnection, GoogleGenAiBackend, optionalConnectionString, preparedProviderConnection, ProviderConnectionInputError, routeTextToolModelMetadata } from "@velum-labs/routekit-provider-core";
+import { defineProvider } from "@velum-labs/routekit-provider-core";
+import { executeWebRequest, RouteKitFailure, routeKitError } from "@velum-labs/routekit-runtime/effect";
+import { Effect } from "effect";
+import { GoogleAuth } from "google-auth-library";
+function configuredVertexModelMetadata(model) {
+    return /(?:^|\/)gemini(?:[-.]|$)/iu.test(model)
+        ? routeTextToolModelMetadata({ inputModalities: ["text", "image"] })
+        : undefined;
+}
+function option(config, key) {
+    const value = config.options?.[key];
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`google-vertex requires options.${key}`);
+    return value;
+}
+function configuredModels(config) {
+    const value = config.options?.models;
+    if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string" && entry.length > 0)) {
+        throw new Error("google-vertex requires options.models");
+    }
+    return value.map((id) => {
+        const metadata = configuredVertexModelMetadata(id);
+        return { id, ...(metadata === undefined ? {} : { metadata }) };
+    });
+}
+function adcHeaders(env) {
+    const serialized = env.GOOGLE_APPLICATION_CREDENTIALS_JSON;
+    const credentials = serialized === undefined
+        ? undefined
+        : JSON.parse(serialized);
+    const auth = new GoogleAuth({
+        scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+        ...(credentials === undefined ? {} : { credentials })
+    });
+    return async (url) => {
+        const client = await auth.getClient();
+        return client.getRequestHeaders(url);
+    };
+}
+export function createVertexSource(sourceId, config, authorization = process.env) {
+    const getAuthHeaders = typeof authorization === "function"
+        ? authorization
+        : adcHeaders(authorization);
+    if (config.auth?.kind !== "adc")
+        throw new Error("google-vertex requires auth.kind adc");
+    const project = option(config, "project");
+    const location = option(config, "location");
+    const publisher = typeof config.options?.publisher === "string" ? config.options.publisher : "google";
+    const transport = (url, init) => Effect.tryPromise({
+        try: async () => {
+            const headers = new Headers(init.headers);
+            const authHeaders = await getAuthHeaders(url);
+            for (const [name, value] of authHeaders.entries())
+                headers.set(name, value);
+            return { url, init: { ...init, headers } };
+        },
+        catch: (cause) => new RouteKitFailure({ message: "could not acquire Vertex ADC", cause })
+    }).pipe(Effect.flatMap(({ url, init }) => executeWebRequest(url, init)), Effect.mapError(routeKitError));
+    const backend = new GoogleGenAiBackend({
+        baseUrl: `https://${location}-aiplatform.googleapis.com/v1/projects/${encodeURIComponent(project)}/locations/${encodeURIComponent(location)}/publishers/${encodeURIComponent(publisher)}`,
+        apiKey: "",
+        apiKeyHeader: false,
+        transport,
+        modelPath: (model, method, streaming) => `/models/${encodeURIComponent(model)}:${method}${streaming ? "?alt=sse" : ""}`
+    });
+    return {
+        sourceId,
+        discovery: { discoverModels: () => Effect.succeed(configuredModels(config)) },
+        requests: {
+            chat: (body, signal, options) => backend.chat(body, signal, options),
+            embeddings: (_body, _signal, _options) => Effect.succeed(Response.json({ error: { message: "Vertex embeddings are not supported by this source" } }, { status: 501 }))
+        },
+        responses: { kind: "unsupported" },
+        capabilities: {
+            forModel: () => ({}),
+            metadataForModel: configuredVertexModelMetadata,
+            reasoningForModel: () => undefined
+        },
+        resource: { kind: "borrowed" }
+    };
+}
+export const googleVertex = defineProvider({
+    id: "google-vertex",
+    protocol: "google",
+    accountClass: "iam",
+    billingMode: "metered-api",
+    connection: defineProviderConnection({
+        manifest: {
+            version: 1, id: "google-vertex", displayName: "Google Vertex AI", category: "cloud",
+            description: "Connect a Google Cloud service account to Vertex AI.",
+            methods: [{ id: "service-account", kind: "form", label: "Service account", schemaRevision: 1, fields: [
+                        { id: "service-account-json", label: "Service account JSON", control: "secret-json", required: true },
+                        { id: "project", label: "Google Cloud project", control: "text", required: true },
+                        { id: "location", label: "Location", control: "text", required: true, placeholder: "us-central1" },
+                        { id: "publisher", label: "Publisher", control: "text", required: false, advanced: true, defaultValue: "google" },
+                        { id: "models", label: "Models", control: "string-list", required: true, description: "Comma- or line-separated Vertex model IDs." }
+                    ] }]
+        },
+        prepare: ({ values }) => {
+            const serialized = connectionString(values, "service-account-json");
+            let credentials;
+            try {
+                credentials = JSON.parse(serialized);
+            }
+            catch {
+                throw new ProviderConnectionInputError("The service account JSON is invalid.", {
+                    "service-account-json": "Enter valid JSON."
+                });
+            }
+            if (typeof credentials !== "object" || credentials === null ||
+                typeof credentials.client_email !== "string" || credentials.client_email.length === 0 ||
+                typeof credentials.private_key !== "string" || credentials.private_key.length === 0) {
+                throw new ProviderConnectionInputError("The service account JSON is invalid.", {
+                    "service-account-json": "The JSON must contain client_email and private_key."
+                });
+            }
+            const models = connectionStringList(values, "models");
+            if (models === undefined) {
+                throw new ProviderConnectionInputError("Vertex model IDs are required.", { models: "This field is required." });
+            }
+            return preparedProviderConnection({
+                config: {
+                    use: "google-vertex", auth: { kind: "adc" },
+                    options: {
+                        project: connectionString(values, "project"),
+                        location: connectionString(values, "location"),
+                        publisher: optionalConnectionString(values, "publisher") ?? "google",
+                        models
+                    }
+                },
+                environment: { GOOGLE_APPLICATION_CREDENTIALS_JSON: JSON.stringify(credentials) }
+            });
+        }
+    }),
+    createSource: (context) => Effect.sync(() => createVertexSource(context.sourceId, context.config, context.env))
+});

package/dist/internal-providers/provider-google-vertex/test/provider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal-providers/provider-google-vertex/test/provider.test.js

@@ -0,0 +1,85 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
+import { createVertexSource } from "../index.js";
+test("Vertex sources use ADC and the regional publisher model path", async () => {
+    const originalFetch = globalThis.fetch;
+    let request;
+    let authUrl;
+    globalThis.fetch = async (input, init) => {
+        request = new Request(input, init);
+        return Response.json({
+            candidates: [{ content: { parts: [{ text: "vertex" }] } }],
+            usageMetadata: { promptTokenCount: 1, candidatesTokenCount: 1, totalTokenCount: 2 }
+        });
+    };
+    try {
+        const config = {
+            use: "google-vertex",
+            auth: { kind: "adc" },
+            options: {
+                project: "routekit-project",
+                location: "us-central1",
+                publisher: "google",
+                models: ["gemini-2.5-pro"]
+            }
+        };
+        const source = createVertexSource("vertex-prod", config, async (url) => {
+            authUrl = url;
+            return new Headers({ authorization: "Bearer adc-token" });
+        });
+        const response = await runRouteKitEffect(source.requests.chat({
+            model: "gemini-2.5-pro",
+            messages: [{ role: "user", content: "hello" }]
+        }));
+        const expectedUrl = "https://us-central1-aiplatform.googleapis.com/v1/projects/routekit-project/locations/us-central1/publishers/google/models/gemini-2.5-pro:generateContent";
+        assert.equal(source.sourceId, "vertex-prod");
+        assert.equal(response.status, 200);
+        assert.equal(authUrl, expectedUrl);
+        assert.equal(request?.url, expectedUrl);
+        assert.equal(request?.headers.get("authorization"), "Bearer adc-token");
+        assert.equal(request?.headers.get("x-goog-api-key"), null);
+        assert.deepEqual(await runRouteKitEffect(source.discovery.discoverModels()), [
+            {
+                id: "gemini-2.5-pro",
+                metadata: {
+                    architecture: {
+                        modality: "text+image->text",
+                        inputModalities: ["text", "image"],
+                        outputModalities: ["text"]
+                    },
+                    supportedParameters: ["tools", "tool_choice"],
+                    provenance: "route"
+                }
+            }
+        ]);
+        const body = (await response.json());
+        assert.equal(body.choices[0]?.message.content, "vertex");
+        const embeddings = await runRouteKitEffect(source.requests.embeddings({ model: "text-embedding-005", input: ["hello"] }));
+        assert.equal(embeddings.status, 501);
+        assert.deepEqual(await embeddings.json(), {
+            error: { message: "Vertex embeddings are not supported by this source" }
+        });
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+test("Vertex configured catalogs qualify Gemini and fail closed for embedding or unknown IDs", async () => {
+    const source = createVertexSource("vertex-prod", {
+        use: "google-vertex",
+        auth: { kind: "adc" },
+        options: {
+            project: "routekit-project",
+            location: "us-central1",
+            publisher: "google",
+            models: ["gemini-2.5-pro", "text-embedding-005", "future-vertex-model"]
+        }
+    }, async () => new Headers({ authorization: "Bearer adc-token" }));
+    const models = await runRouteKitEffect(source.discovery.discoverModels());
+    assert.notEqual(models[0]?.metadata, undefined);
+    assert.equal(models[1]?.metadata, undefined);
+    assert.equal(models[2]?.metadata, undefined);
+    assert.equal(source.capabilities.metadataForModel?.("text-embedding-005"), undefined);
+    assert.equal(source.capabilities.metadataForModel?.("future-vertex-model"), undefined);
+});

package/dist/internal-providers/provider-openai/documented-reasoning.d.ts

@@ -0,0 +1,9 @@
+export declare function documentedOpenAiReasoning(model: string): {
+    status: "supported";
+    efforts: {
+        id: string;
+    }[];
+    defaultEffort: string;
+    wireShape: string;
+    provenance: "builtin";
+} | undefined;

package/dist/internal-providers/provider-openai/documented-reasoning.js

@@ -0,0 +1,26 @@
+/**
+ * Exact model-specific capabilities from OpenAI's published model pages.
+ * The global Responses schema's effort enum is not evidence for any model.
+ * Keep this list narrow; unknown and custom model IDs remain unconstrained.
+ *
+ * https://developers.openai.com/api/docs/models/gpt-6-luna
+ * https://developers.openai.com/api/docs/models/gpt-6-sol
+ * https://developers.openai.com/api/docs/models/gpt-6-astra
+ */
+const documentedEfforts = new Map([
+    ["gpt-6-luna", ["none", "low", "medium", "high", "xhigh", "max"]],
+    ["gpt-6-sol", ["none", "low", "medium", "high", "xhigh", "max"]],
+    ["gpt-6-astra", ["low", "medium", "high", "xhigh", "max"]]
+]);
+export function documentedOpenAiReasoning(model) {
+    const efforts = documentedEfforts.get(model);
+    if (efforts === undefined)
+        return undefined;
+    return {
+        status: "supported",
+        efforts: efforts.map((id) => ({ id })),
+        defaultEffort: "medium",
+        wireShape: "openai-responses",
+        provenance: "builtin"
+    };
+}

package/dist/internal-providers/provider-openai/index.d.ts

@@ -0,0 +1,23 @@
+import { ApiProviderSource, type ProviderModuleContext } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+export declare const openai: {
+    readonly id: "openai";
+    readonly protocol: "openai";
+    readonly accountClass: "api-key";
+    readonly billingMode: "metered-api";
+    readonly connection: Readonly<{
+        validate?: (context: Readonly<{
+            sourceId: string;
+            config: import("@velum-labs/routekit-config-core").SourceConfig;
+            env: Readonly<Record<string, string | undefined>>;
+            resources?: Readonly<Record<string, unknown>>;
+        }>) => Effect.Effect<void, Error, import("@velum-labs/routekit-runtime/effect").RouteKitPlatform>;
+        credentialValidation?: "registry-key-probe" | "registry-key-probe-if-configured-models";
+        manifest: import("@velum-labs/routekit-provider-core").ProviderConnectionManifest;
+        prepare?: (input: import("@velum-labs/routekit-provider-core").PrepareProviderConnectionInput) => import("@velum-labs/routekit-provider-core").PreparedProviderConnection;
+        enrollment?: Readonly<Record<string, import("@velum-labs/routekit-provider-core").ProviderEnrollmentAdapter>>;
+        credentials?: import("@velum-labs/routekit-provider-core").ProviderCredentialAdapter;
+        subscriptionMode?: import("@velum-labs/routekit-registry").SubscriptionMode;
+    }>;
+    readonly createSource: (context: ProviderModuleContext) => Effect.Effect<ApiProviderSource, never, never>;
+};

package/dist/internal-providers/provider-openai/index.js

@@ -0,0 +1,74 @@
+import { ApiProviderSource, connectionString, connectionStringList, defineProviderConnection, defineProvider, OpenAiApiSpecificationClient, optionalProviderModuleResource, optionalConnectionString, preparedProviderConnection, providerSourceTransportFromContext, sharedOpenAiApiSpecificationClient } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+import { documentedOpenAiReasoning } from "./documented-reasoning.js";
+function usesOfficialOpenAiApi(context) {
+    const baseUrl = context.config.baseUrl ?? context.env.OPENAI_BASE_URL;
+    if (baseUrl === undefined)
+        return true;
+    try {
+        const url = new URL(baseUrl);
+        return url.origin === "https://api.openai.com";
+    }
+    catch {
+        return false;
+    }
+}
+function apiSpecificationClient(context) {
+    const injected = optionalProviderModuleResource(context, "openaiApiSpecification", (value) => value instanceof OpenAiApiSpecificationClient);
+    return injected ?? sharedOpenAiApiSpecificationClient();
+}
+export const openai = defineProvider({
+    id: "openai",
+    protocol: "openai",
+    accountClass: "api-key",
+    billingMode: "metered-api",
+    connection: defineProviderConnection({
+        manifest: {
+            version: 1,
+            id: "openai",
+            displayName: "OpenAI API",
+            category: "api",
+            description: "Connect an OpenAI project API key.",
+            methods: [{
+                    id: "api-key", kind: "form", label: "API key", schemaRevision: 1,
+                    fields: [
+                        { id: "api-key", label: "API key", control: "secret", required: true, placeholder: "sk-…" },
+                        { id: "base-url", label: "Base URL", control: "url", required: false, advanced: true, placeholder: "https://api.openai.com", description: "With explicit models, custom endpoints must support authenticated GET /v1/models for key validation." },
+                        { id: "models", label: "Models", control: "string-list", required: false, advanced: true, description: "Optional comma- or line-separated IDs. Explicit models require read-only model-list access to validate the key." }
+                    ]
+                }]
+        },
+        prepare: ({ values }) => {
+            const env = "ROUTEKIT_CLOUD_GRANT_OPENAI_KEY";
+            const baseUrl = optionalConnectionString(values, "base-url");
+            const models = connectionStringList(values, "models");
+            return preparedProviderConnection({
+                config: { use: "openai", auth: { kind: "env-bearer", env }, ...(baseUrl === undefined ? {} : { baseUrl }), ...(models === undefined ? {} : { options: { models } }) },
+                environment: { [env]: connectionString(values, "api-key") }
+            });
+        },
+        credentialValidation: "registry-key-probe-if-configured-models"
+    }),
+    createSource: (context) => Effect.sync(() => {
+        const official = usesOfficialOpenAiApi(context);
+        let enrichDiscoveredModels;
+        if (official) {
+            const specification = apiSpecificationClient(context);
+            enrichDiscoveredModels = (models, signal) => specification.enrich(models, signal).pipe(Effect.catch((error) => Effect.logWarning("OpenAI API specification is unavailable; retaining sparse model discovery").pipe(Effect.annotateLogs({
+                sourceId: context.sourceId,
+                stage: "openai_api_specification",
+                error: error.message
+            }), Effect.as(models))));
+        }
+        return new ApiProviderSource({
+            provider: "openai",
+            sourceId: context.sourceId,
+            config: context.config,
+            env: context.env,
+            transport: providerSourceTransportFromContext(context),
+            nativeResponses: true,
+            ...(official ? { reasoningForModel: documentedOpenAiReasoning } : {}),
+            enrichDiscoveredModels
+        });
+    })
+});

package/dist/internal-providers/provider-openai/test/provider.test.d.ts

@@ -0,0 +1 @@
+export {};