@velum-labs/routekit-daemon 1.3.2 → 1.5.0

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

@@ -0,0 +1,268 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createConnectedProviderSource, OpenAiApiSpecificationClient } from "@velum-labs/routekit-provider-core";
+import { Data, Effect } from "effect";
+import { openai } from "../index.js";
+class TestFailure extends Data.TaggedError("TestFailure") {
+}
+function context() {
+    const prepared = openai.connection.prepare({
+        sourceId: "openai-production",
+        methodId: "api-key",
+        values: { "api-key": "offline-openai-secret" }
+    });
+    return {
+        sourceId: "openai-production",
+        config: prepared.config,
+        env: prepared.environment
+    };
+}
+function specification(modelIds) {
+    return {
+        openapi: "3.1.0",
+        paths: {
+            "/responses": {
+                post: {
+                    requestBody: {
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: "#/components/schemas/CreateResponse"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        components: {
+            schemas: {
+                CreateResponse: {
+                    allOf: [
+                        {
+                            $ref: "#/components/schemas/ResponseProperties"
+                        }
+                    ]
+                },
+                ResponseProperties: {
+                    type: "object",
+                    properties: {
+                        model: {
+                            type: "string",
+                            enum: modelIds
+                        },
+                        tools: {
+                            type: "array"
+                        },
+                        tool_choice: {
+                            type: "string"
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+function specificationClient(modelIds, requests = []) {
+    const transport = (_url, init) => {
+        requests.push(init);
+        return Effect.succeed(Response.json(specification(modelIds)));
+    };
+    return new OpenAiApiSpecificationClient({ transport });
+}
+function discover(source) {
+    return Effect.runPromise(source.discovery.discoverModels());
+}
+test("a configured OpenAI inventory does not enroll an invalid key", async () => {
+    const ctx = context();
+    let calls = 0;
+    const transport = (url, init) => {
+        calls++;
+        assert.equal(url, "https://api.openai.com/v1/models");
+        assert.equal(init.redirect, "error");
+        return Effect.succeed(Response.json({ error: "invalid key" }, { status: 401 }));
+    };
+    await assert.rejects(Effect.runPromise(createConnectedProviderSource(openai, {
+        ...ctx,
+        config: { ...ctx.config, options: { models: ["configured-model"] } },
+        resources: { transport }
+    }, undefined, { validate: true })), /provider credential validation returned HTTP 401/);
+    assert.equal(calls, 1);
+});
+test("a valid configured OpenAI source probes once and retains its explicit inventory", async () => {
+    const ctx = context();
+    let calls = 0;
+    const transport = (_url, init) => {
+        calls++;
+        assert.equal(init.redirect, "error");
+        return Effect.succeed(Response.json({ data: [] }));
+    };
+    const source = await Effect.runPromise(createConnectedProviderSource(openai, {
+        ...ctx,
+        config: { ...ctx.config, options: { models: ["configured-model"] } },
+        resources: { transport, openaiApiSpecification: specificationClient(["configured-model"]) }
+    }, undefined, { validate: true }));
+    assert.deepEqual((await discover(source)).map((model) => model.id), ["configured-model"]);
+    assert.equal(calls, 1);
+});
+test("OpenAI discovery joins authenticated inventory with the official API specification", async () => {
+    const providerRequests = [];
+    const specificationRequests = [];
+    const transport = (url) => {
+        providerRequests.push(url);
+        return Effect.succeed(Response.json({
+            data: [
+                { id: "gpt-6-sol", created: 1_789_405_937 },
+                { id: "gpt-4o-mini-2024-07-18" },
+                { id: "private-fine-tune" }
+            ]
+        }));
+    };
+    const source = await Effect.runPromise(openai.createSource({
+        ...context(),
+        resources: {
+            transport,
+            openaiApiSpecification: specificationClient(["gpt-6-astra", "gpt-6-sol"], specificationRequests)
+        }
+    }));
+    assert.deepEqual(await discover(source), [
+        {
+            id: "gpt-6-sol",
+            createdAt: 1_789_405_937,
+            capabilities: {
+                responses: "supported"
+            },
+            reasoning: {
+                status: "supported",
+                efforts: ["none", "low", "medium", "high", "xhigh", "max"].map((id) => ({ id })),
+                defaultEffort: "medium",
+                wireShape: "openai-responses",
+                provenance: "builtin"
+            }
+        },
+        {
+            id: "gpt-4o-mini-2024-07-18"
+        },
+        {
+            id: "private-fine-tune"
+        }
+    ]);
+    assert.deepEqual(providerRequests, ["https://api.openai.com/v1/models"]);
+    assert.equal(specificationRequests.length, 1);
+});
+test("configured OpenAI inventory is intersected without provider discovery", async () => {
+    const ctx = context();
+    const providerTransport = () => {
+        assert.fail("Configured model inventory must not call provider discovery.");
+    };
+    const source = await Effect.runPromise(openai.createSource({
+        ...ctx,
+        config: {
+            ...ctx.config,
+            options: {
+                models: ["gpt-6-sol", "private-model"]
+            }
+        },
+        resources: {
+            transport: providerTransport,
+            openaiApiSpecification: specificationClient(["gpt-6-sol"])
+        }
+    }));
+    assert.deepEqual(await discover(source), [
+        {
+            id: "gpt-6-sol",
+            capabilities: {
+                responses: "supported"
+            },
+            reasoning: {
+                status: "supported",
+                efforts: ["none", "low", "medium", "high", "xhigh", "max"].map((id) => ({ id })),
+                defaultEffort: "medium",
+                wireShape: "openai-responses",
+                provenance: "builtin"
+            }
+        },
+        {
+            id: "private-model"
+        }
+    ]);
+});
+test("the OpenAPI specification cannot add an undiscovered model", async () => {
+    const transport = () => Effect.succeed(Response.json({ data: [{ id: "private-model" }] }));
+    const source = await Effect.runPromise(openai.createSource({
+        ...context(),
+        resources: {
+            transport,
+            openaiApiSpecification: specificationClient(["gpt-6-sol"])
+        }
+    }));
+    assert.deepEqual(await discover(source), [{ id: "private-model" }]);
+});
+test("official OpenAI models expose only their documented reasoning efforts", async () => {
+    const source = await Effect.runPromise(openai.createSource({
+        ...context(),
+        config: {
+            ...context().config,
+            options: { models: ["gpt-6-luna", "gpt-6-sol", "gpt-6-astra", "private-model"] }
+        },
+        resources: {
+            openaiApiSpecification: specificationClient([
+                "gpt-6-luna", "gpt-6-sol", "gpt-6-astra"
+            ])
+        }
+    }));
+    const models = await discover(source);
+    for (const id of ["gpt-6-luna", "gpt-6-sol"]) {
+        assert.deepEqual(models.find((model) => model.id === id)?.reasoning?.efforts?.map((effort) => effort.id), ["none", "low", "medium", "high", "xhigh", "max"]);
+        assert.equal(source.capabilities.reasoningForModel(id)?.defaultEffort, "medium");
+    }
+    assert.deepEqual(models.find((model) => model.id === "gpt-6-astra")?.reasoning?.efforts?.map((effort) => effort.id), ["low", "medium", "high", "xhigh", "max"]);
+    assert.equal(source.capabilities.reasoningForModel("private-model"), undefined);
+    assert.equal(models.find((model) => model.id === "private-model")?.reasoning, undefined);
+});
+test("OpenAPI failure retains the sparse authenticated inventory", async () => {
+    const transport = () => Effect.succeed(Response.json({ data: [{ id: "gpt-6-sol" }] }));
+    const specificationTransport = () => Effect.fail(new TestFailure({ message: "offline" }));
+    const source = await Effect.runPromise(openai.createSource({
+        ...context(),
+        resources: {
+            transport,
+            openaiApiSpecification: new OpenAiApiSpecificationClient({
+                transport: specificationTransport
+            })
+        }
+    }));
+    assert.deepEqual(await discover(source), [{
+            id: "gpt-6-sol",
+            reasoning: {
+                status: "supported",
+                efforts: ["none", "low", "medium", "high", "xhigh", "max"].map((id) => ({ id })),
+                defaultEffort: "medium",
+                wireShape: "openai-responses",
+                provenance: "builtin"
+            }
+        }]);
+});
+test("custom OpenAI-compatible origins do not inherit the official OpenAI specification", async () => {
+    const ctx = context();
+    const specificationRequests = [];
+    const custom = await Effect.runPromise(openai.createSource({
+        ...ctx,
+        env: {
+            ...ctx.env,
+            OPENAI_BASE_URL: "https://openai-compatible.example"
+        },
+        config: {
+            ...ctx.config,
+            options: {
+                models: ["gpt-6-sol"]
+            }
+        },
+        resources: {
+            openaiApiSpecification: specificationClient(["gpt-6-sol"], specificationRequests)
+        }
+    }));
+    assert.deepEqual(await discover(custom), [{ id: "gpt-6-sol" }]);
+    assert.equal(specificationRequests.length, 0);
+    assert.equal(custom.httpSubmission, undefined);
+});

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

@@ -0,0 +1,9 @@
+import { ApiProviderSource } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+export declare const openaiCompatible: {
+    readonly id: "openai-compatible";
+    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-openai-compatible/index.js

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

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

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

package/dist/internal-providers/provider-openai-compatible/test/provider.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
+import { openaiCompatible } from "../index.js";
+test("OpenAI-compatible modules expose native Responses without inventing reasoning", async () => {
+    let requestUrl;
+    const config = {
+        use: "openai-compatible",
+        baseUrl: "https://compatible.example",
+        auth: { kind: "env-bearer", env: "COMPATIBLE_API_KEY" },
+        options: { models: ["gpt-5.6-sol"] }
+    };
+    const source = await runRouteKitEffect(openaiCompatible.createSource({
+        sourceId: "compatible",
+        config,
+        env: { COMPATIBLE_API_KEY: "compatible-secret" }
+    }));
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input) => {
+        requestUrl = String(input);
+        return Response.json({
+            id: "resp_compatible",
+            object: "response",
+            output: [],
+            status: "completed"
+        });
+    };
+    try {
+        assert.equal(source.responses.kind, "responses");
+        if (source.responses.kind !== "responses")
+            return;
+        const response = await runRouteKitEffect(source.responses.execute({ model: "gpt-5.6-sol", input: "hello" }));
+        assert.equal(response.status, 200);
+        assert.equal(requestUrl, "https://compatible.example/v1/responses");
+        assert.equal(source.capabilities.reasoningForModel("gpt-5.6-sol"), undefined);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});

package/dist/internal-providers/provider-openrouter/connection.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import { ProviderEnrollmentError, type ProviderCredentialAdapter, type ProviderEnrollmentAdapter, type ProviderModuleContext } from "@velum-labs/routekit-provider-core";
+export declare const validateOpenRouterConnection: (context: ProviderModuleContext) => Effect.Effect<void, ProviderEnrollmentError, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
+export declare const openRouterEnrollment: ProviderEnrollmentAdapter;
+export declare const openRouterCredentials: ProviderCredentialAdapter;

package/dist/internal-providers/provider-openrouter/connection.js

@@ -0,0 +1,143 @@
+import { OpenRouterCore } from "@openrouter/sdk/core.js";
+import { oAuthCreateAuthorizationUrl } from "@openrouter/sdk/funcs/oAuthCreateAuthorizationUrl.js";
+import { oAuthExchangeAuthCodeForAPIKey } from "@openrouter/sdk/funcs/oAuthExchangeAuthCodeForAPIKey.js";
+import { HTTPClient } from "@openrouter/sdk/lib/http.js";
+import { calculatePKCECodeChallenge, generateRandomCodeVerifier } from "oauth4webapi";
+import { Effect } from "effect";
+import { z } from "zod";
+import { ProviderEnrollmentError, authHeaders, defaultProviderTransport, preparedProviderConnection, providerCredential, providerMetadata, providerSourceTransportFromContext, providerUrl } from "@velum-labs/routekit-provider-core";
+const keyEnvironment = "ROUTEKIT_CLOUD_GRANT_OPENROUTER_KEY";
+const stateSchema = z.object({ verifier: z.string().min(43) }).strict();
+const keySchema = z.object({ key: z.string().min(1) }).strict();
+const currentKeySchema = z.object({ data: z.object({ label: z.string() }) });
+const keyResponseMaxBytes = 64 * 1024;
+export const validateOpenRouterConnection = Effect.fn("OpenRouter.validateConnection")(function* (context) {
+    const { url, headers, transport } = yield* Effect.try({
+        try: () => {
+            const info = providerMetadata("openrouter", context.config);
+            const probe = info.keyProbe;
+            const auth = context.config.auth;
+            const credential = auth?.kind === "env-bearer" || auth?.kind === "env-header"
+                ? context.env[auth.env]
+                : providerCredential("openrouter", info, context.env);
+            if (!credential)
+                throw new Error("Missing credential");
+            return {
+                // Match discovery/inference resolution, including custom proxy path prefixes.
+                url: providerUrl(context.config.baseUrl ?? info.baseUrl, probe.path),
+                headers: {
+                    accept: "application/json",
+                    ...info.attributionHeaders,
+                    ...probe.extraHeaders,
+                    ...(auth?.kind === "env-header"
+                        ? { [auth.header]: credential }
+                        : authHeaders(probe.auth, credential))
+                },
+                transport: providerSourceTransportFromContext(context) ?? defaultProviderTransport
+            };
+        },
+        catch: () => new ProviderEnrollmentError("setup_incomplete", "OpenRouter connection settings are invalid.")
+    });
+    const invalidResponse = () => new ProviderEnrollmentError("setup_incomplete", "OpenRouter returned an invalid current-key response.");
+    yield* Effect.acquireUseRelease(transport(url, { method: "GET", headers, redirect: "error" }).pipe(Effect.mapError(() => new ProviderEnrollmentError("setup_incomplete", "OpenRouter current-key request failed.")), Effect.interruptible), (response) => Effect.gen(function* () {
+        if (!response.ok) {
+            // Preserve the host's safe HTTP classification; never include an upstream body.
+            return yield* Effect.fail(new ProviderEnrollmentError("setup_incomplete", `provider credential validation returned HTTP ${response.status} at /v1/key`));
+        }
+        if (response.body === null)
+            return yield* Effect.fail(invalidResponse());
+        yield* Effect.acquireUseRelease(Effect.try({ try: () => response.body.getReader(), catch: invalidResponse }), (reader) => Effect.gen(function* () {
+            const decoder = new TextDecoder();
+            let bytes = 0;
+            let text = "";
+            while (true) {
+                const chunk = yield* Effect.tryPromise({
+                    try: () => reader.read(),
+                    catch: invalidResponse
+                });
+                if (chunk.done)
+                    break;
+                bytes += chunk.value.byteLength;
+                if (bytes > keyResponseMaxBytes)
+                    return yield* Effect.fail(invalidResponse());
+                text += decoder.decode(chunk.value, { stream: true });
+            }
+            return yield* Effect.try({
+                try: () => currentKeySchema.parse(JSON.parse(text + decoder.decode())),
+                catch: invalidResponse
+            });
+        }), (reader) => Effect.sync(() => reader.releaseLock()));
+        // Key identity is not inference admission. Zero/exhausted/unlimited allowance is valid.
+    }), (response) => Effect.tryPromise({
+        try: () => response.body?.cancel() ?? Promise.resolve(),
+        catch: invalidResponse
+    }).pipe(Effect.timeout(250), Effect.ignore));
+}, 
+// A host's shorter discovery deadline still wins, including during body consumption.
+Effect.timeoutOrElse({
+    duration: 10_000,
+    orElse: () => Effect.fail(new ProviderEnrollmentError("setup_incomplete", "OpenRouter current-key request exceeded its deadline."))
+}), 
+// Hosts acquire the connected source in an uninterruptible resource acquisition.
+// The credential check owns no source yet and must honor cancellation through EOF.
+Effect.interruptible);
+export const openRouterEnrollment = {
+    start: (context) => Effect.tryPromise({
+        try: async () => {
+            const verifier = generateRandomCodeVerifier();
+            const result = oAuthCreateAuthorizationUrl(new OpenRouterCore(), {
+                callbackUrl: context.callbackUrl,
+                codeChallengeMethod: "S256",
+                codeChallenge: await calculatePKCECodeChallenge(verifier)
+            });
+            if (!result.ok)
+                throw new ProviderEnrollmentError("invalid_state", "Could not start OpenRouter authorization.");
+            return {
+                kind: "action",
+                action: { kind: "external", stepId: "authorize", title: "Authorize OpenRouter", url: result.value, completion: "callback" },
+                state: { version: 1, data: { verifier } }
+            };
+        },
+        catch: () => new ProviderEnrollmentError("invalid_state", "Could not start OpenRouter authorization.")
+    }),
+    resume: (context, state, event) => Effect.tryPromise({
+        try: async () => {
+            if (state.version !== 1 || event.kind !== "callback")
+                throw new ProviderEnrollmentError("invalid_state", "Restart this connection.");
+            const { verifier } = stateSchema.parse(state.data);
+            if (event.parameters.error !== undefined)
+                throw new ProviderEnrollmentError("provider_denied", "OpenRouter authorization was declined.");
+            const code = event.parameters.code;
+            if (!code)
+                throw new ProviderEnrollmentError("invalid_state", "OpenRouter did not return an authorization code.");
+            const client = new OpenRouterCore({ httpClient: new HTTPClient({ fetcher: context.fetch }), appTitle: "RouteKit Cloud" });
+            // A code may have been consumed even when the exchange response is lost.
+            const result = await oAuthExchangeAuthCodeForAPIKey(client, {
+                requestBody: { code, codeVerifier: verifier, codeChallengeMethod: "S256" }
+            }, { retries: { strategy: "none" }, timeoutMs: 20_000 });
+            if (!result.ok)
+                throw new ProviderEnrollmentError("exchange_failed", "OpenRouter authorization could not be completed. Reconnect to try again.");
+            const { key } = keySchema.parse({ key: result.value.key });
+            return {
+                kind: "complete",
+                connection: preparedProviderConnection({
+                    config: { use: "openrouter", auth: { kind: "env-bearer", env: keyEnvironment } },
+                    environment: {},
+                    credential: { version: 1, kind: "api-key", payload: { key } }
+                })
+            };
+        },
+        catch: (cause) => cause instanceof ProviderEnrollmentError ? cause :
+            new ProviderEnrollmentError("exchange_failed", "OpenRouter authorization could not be completed. Reconnect to try again.")
+    })
+};
+export const openRouterCredentials = {
+    resolve: (binding) => Effect.try({
+        try: () => {
+            if (binding.version !== 1 || binding.kind !== "api-key")
+                throw new Error("Unsupported OpenRouter credential.");
+            return { environment: { [keyEnvironment]: keySchema.parse(binding.payload).key } };
+        },
+        catch: () => new ProviderEnrollmentError("invalid_state", "The stored OpenRouter credential is invalid.")
+    })
+};

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

@@ -0,0 +1,28 @@
+import { ApiProviderSource } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+export { decodeOpenRouterPricing, openRouterPricingAdapter } from "./pricing.js";
+export declare const openrouter: {
+    readonly id: "openrouter";
+    readonly protocol: "openai";
+    readonly accountClass: "api-key";
+    readonly billingMode: "metered-api";
+    readonly pricing: Readonly<{
+        source: string;
+        discover(input: import("@velum-labs/routekit-provider-core").ProviderPricingDiscoveryInput): Effect.Effect<readonly import("@velum-labs/routekit-contracts").PricingQuote[], Error, import("@velum-labs/routekit-runtime/effect").RouteKitPlatform>;
+    }>;
+    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-openrouter/index.js

@@ -0,0 +1,42 @@
+import { ApiProviderSource, connectionString, connectionStringList, defineProviderConnection, defineProvider, optionalConnectionString, preparedProviderConnection, providerSourceTransportFromContext } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+import { openRouterCredentials, openRouterEnrollment, validateOpenRouterConnection } from "./connection.js";
+import { openRouterPricingAdapter } from "./pricing.js";
+export { decodeOpenRouterPricing, openRouterPricingAdapter } from "./pricing.js";
+export const openrouter = defineProvider({
+    id: "openrouter",
+    protocol: "openai",
+    accountClass: "api-key",
+    billingMode: "metered-api",
+    pricing: openRouterPricingAdapter,
+    connection: defineProviderConnection({
+        enrollment: { "browser": openRouterEnrollment },
+        credentials: openRouterCredentials,
+        manifest: {
+            version: 1, id: "openrouter", displayName: "OpenRouter", category: "api",
+            description: "Connect your OpenRouter account or 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-or-…" },
+                        { id: "base-url", label: "Base URL", control: "url", required: false, advanced: true, placeholder: "https://openrouter.ai/api", description: "Custom endpoints must support authenticated GET /v1/key for key validation." },
+                        { id: "models", label: "Models", control: "string-list", required: false, advanced: true, description: "Optional comma- or line-separated model IDs. Leave empty to discover them." }
+                    ] }, { id: "browser", kind: "flow", label: "Connect OpenRouter", schemaRevision: 1, fields: [] }]
+        },
+        prepare: ({ values }) => {
+            const env = "ROUTEKIT_CLOUD_GRANT_OPENROUTER_KEY";
+            const baseUrl = optionalConnectionString(values, "base-url");
+            const models = connectionStringList(values, "models");
+            return preparedProviderConnection({
+                config: { use: "openrouter", auth: { kind: "env-bearer", env }, ...(baseUrl === undefined ? {} : { baseUrl }), ...(models === undefined ? {} : { options: { models } }) },
+                environment: { [env]: connectionString(values, "api-key") }
+            });
+        },
+        validate: validateOpenRouterConnection
+    }),
+    createSource: (context) => Effect.sync(() => new ApiProviderSource({
+        provider: "openrouter",
+        sourceId: context.sourceId,
+        config: context.config,
+        env: context.env,
+        transport: providerSourceTransportFromContext(context)
+    }))
+});

package/dist/internal-providers/provider-openrouter/pricing.d.ts

@@ -0,0 +1,4 @@
+import type { PricingQuote } from "@velum-labs/routekit-contracts";
+import type { ProviderPricingAdapter } from "@velum-labs/routekit-provider-core";
+export declare function decodeOpenRouterPricing(value: unknown, retrievedAt: string): readonly PricingQuote[];
+export declare const openRouterPricingAdapter: ProviderPricingAdapter;