@velum-labs/routekit-daemon 1.3.2 → 1.5.0

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

@@ -0,0 +1,7 @@
+import { CodexBackendRelay } from "./relay.js";
+export { codex, codexProvider, codexSubscriptionProvider } from "./module-api.js";
+export { CodexBackendRelay, codexRelayAuth } from "./relay.js";
+export const codexRelayFactory = (accounts) => new CodexBackendRelay({
+    catalog: (_template, stock) => [...stock],
+    auth: { kind: "accounts", accounts }
+});

package/dist/internal-providers/provider-codex/module-api.d.ts

@@ -0,0 +1,25 @@
+import { SubscriptionAccountBackend } from "@velum-labs/routekit-accounts/provider";
+import { Effect } from "effect";
+export declare const codex: {
+    readonly id: "codex";
+    readonly protocol: "codex";
+    readonly accountClass: "subscription";
+    readonly billingMode: "subscription";
+    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<SubscriptionAccountBackend, never, never>;
+};
+export { codexProvider } from "./subscription.js";
+export declare const codexSubscriptionProvider: import("@velum-labs/routekit-accounts").SubscriptionProvider<"codex">;

package/dist/internal-providers/provider-codex/module-api.js

@@ -0,0 +1,31 @@
+import { SubscriptionAccountBackend } from "@velum-labs/routekit-accounts/provider";
+import { CodexResponsesBackend, defineProviderConnection, defineProvider } from "@velum-labs/routekit-provider-core";
+import { Effect } from "effect";
+import { codexProvider } from "./subscription.js";
+export const codex = defineProvider({
+    id: "codex",
+    protocol: "codex",
+    accountClass: "subscription",
+    billingMode: "subscription",
+    connection: defineProviderConnection({
+        subscriptionMode: "codex",
+        manifest: {
+            version: 1, id: "codex", displayName: "ChatGPT Codex", category: "subscription",
+            description: "Connect a ChatGPT subscription through the Codex OAuth flow.",
+            methods: [{ id: "oauth", kind: "oauth", label: "Sign in with ChatGPT", schemaRevision: 1, fields: [] }]
+        }
+    }),
+    createSource: (context) => Effect.sync(() => {
+        const accountSet = context.resources?.accountSet;
+        if (accountSet === undefined || accountSet.mode !== "codex") {
+            throw new Error('provider module "codex" requires its daemon-owned account set');
+        }
+        return new SubscriptionAccountBackend({
+            sourceId: context.sourceId,
+            accountSet,
+            backendFactory: (_mode, backendOptions) => new CodexResponsesBackend(backendOptions)
+        });
+    })
+});
+export { codexProvider } from "./subscription.js";
+export const codexSubscriptionProvider = codexProvider();

package/dist/internal-providers/provider-codex/relay.d.ts

@@ -0,0 +1,123 @@
+import type { IncomingHttpHeaders } from "node:http";
+import type { SubscriptionAccountSet, SubscriptionAccountSetSnapshot, SubscriptionRelay } from "@velum-labs/routekit-accounts";
+import { RouteKitFailure } from "@velum-labs/routekit-runtime/effect";
+import { Effect } from "effect";
+import { z } from "zod";
+/**
+ * The Codex backend relay: lets a Codex client keep its own stock models while
+ * pointed at a RouteKit gateway as its model provider.
+ *
+ * The relay supports two explicit credential trust models:
+ *
+ * - `client` forwards the ChatGPT login Codex attached to the request.
+ * - `accounts` selects from a server-owned {@link SubscriptionAccountSet}.
+ *
+ * In either mode:
+ *
+ * - `GET /v1/models`: forwarded to the ChatGPT Codex backend with the client's
+ *   relayed auth, and the live stock catalog is merged behind the configured
+ *   entries, so the picker is always the union of what the router adds and
+ *   what Codex would natively offer. When the upstream fetch is impossible
+ *   (no relayable auth, offline), the merge falls back to the locally cached
+ *   stock catalog snapshot.
+ * - `POST /v1/responses` for a model the gateway does not serve locally:
+ *   forwarded to the ChatGPT Codex backend with public string input normalized
+ *   to the backend's canonical item-list form. Native item-list requests and
+ *   auth remain untouched.
+ *
+ * Client mode never stores or mints credentials. Account-set mode strips
+ * ingress auth and injects the selected managed credential.
+ */
+/** One model catalog entry in Codex's own `ModelInfo` wire shape. */
+export type CodexCatalogEntry = Record<string, unknown>;
+export type ProviderRelayLogger = {
+    warn(message: string): void;
+    error(message: string): void;
+};
+declare const stockEntrySchema: z.ZodObject<{
+    slug: z.ZodString;
+}, z.core.$loose>;
+/** A validated upstream stock entry: a known `slug`, everything else opaque. */
+export type CodexStockEntry = z.infer<typeof stockEntrySchema>;
+export type CodexRelayOptions = {
+    /**
+     * ChatGPT Codex backend base URL (no trailing slash). Defaults to the
+     * provider registry's `codex` base; override for tests/self-hosted proxies.
+     */
+    backendUrl?: string;
+    /**
+     * Build the full picker catalog: configured entries first, then the given
+     * stock entries merged behind them (deduped by slug).
+     */
+    catalog: (template: CodexCatalogEntry, stock: readonly CodexCatalogEntry[]) => CodexCatalogEntry[];
+    /**
+     * Stock catalog snapshot used when the upstream fetch is impossible
+     * (typically the user's `~/.codex/models_cache.json`).
+     */
+    fallbackStock?: () => CodexCatalogEntry[];
+    /** Upstream fetch timeout (ms). Codex itself caps the whole refresh at 5s. */
+    timeoutMs?: number;
+    logger?: ProviderRelayLogger;
+    /** Credential trust model. Defaults to forwarding the Codex client's auth. */
+    auth?: CodexRelayAuthSource;
+};
+export type CodexRelayAuthSource = {
+    kind: "client";
+} | {
+    kind: "accounts";
+    accounts: SubscriptionAccountSet;
+};
+/** ChatGPT auth material relayed from the client's own request. */
+export type CodexRelayAuth = {
+    authorization: string;
+    accountId: string;
+};
+/**
+ * Extract relayable ChatGPT auth from a request. Codex's ChatGPT-login auth
+ * provider always sends the bearer token together with a `chatgpt-account-id`
+ * header; the pair is what distinguishes it from a plain API key or a gateway
+ * bearer token, so only that combination is ever relayed.
+ */
+export declare function codexRelayAuth(headers: IncomingHttpHeaders): CodexRelayAuth | undefined;
+export declare class CodexBackendRelay implements SubscriptionRelay {
+    #private;
+    readonly kind: "request";
+    readonly dialect: "codex";
+    readonly httpSubmission: SubscriptionRelay["httpSubmission"];
+    constructor(options: CodexRelayOptions);
+    /**
+     * The merged Codex picker catalog for a `GET /v1/models` request, plus the
+     * upstream ETag when the live list was used. With relayable auth the stock
+     * list comes from the live ChatGPT backend; otherwise (or on any upstream
+     * failure) from the local snapshot. Returns `undefined` when no catalog can
+     * be built at all (no stock entry to use as a schema template).
+     */
+    mergedCatalog(headers: IncomingHttpHeaders, search: string): Effect.Effect<{
+        etag?: string | undefined;
+        models: CodexCatalogEntry[];
+    } | undefined, never, any>;
+    /**
+     * Whether a `POST /v1/responses` request should be relayed: it names a model
+     * the gateway does not serve locally AND carries relayable ChatGPT auth.
+     */
+    shouldRelayResponses(headers: IncomingHttpHeaders, model: string | undefined, servesLocally: (model: string) => boolean): boolean;
+    shouldRelay(headers: IncomingHttpHeaders, model: string | undefined, servesLocally: (model: string) => boolean): boolean;
+    /**
+     * Forward a Responses request to the ChatGPT Codex backend. Public string
+     * input is normalized to the backend's required item-list representation;
+     * item-list input and every non-transport header (including the client's own
+     * auth) go through untouched, and the upstream response (typically SSE)
+     * streams back unchanged.
+     */
+    relayResponses(headers: IncomingHttpHeaders, body: unknown, signal?: AbortSignal, options?: Parameters<SubscriptionRelay["relay"]>[3]): Effect.Effect<Response, Error | import("effect/PlatformError").PlatformError, any>;
+    relay(headers: IncomingHttpHeaders, body: Parameters<SubscriptionRelay["relay"]>[1], signal?: AbortSignal, options?: Parameters<SubscriptionRelay["relay"]>[3]): Effect.Effect<Response, Error | import("effect/PlatformError").PlatformError, any>;
+    snapshot(): SubscriptionAccountSetSnapshot | undefined;
+    close(): Effect.Effect<void, RouteKitFailure, never>;
+    /** Merge relayed stock slugs into an OpenAI-shape `data` model list. */
+    mergeDataIds(data: Array<{
+        id: string;
+    } & Record<string, unknown>>, models: readonly CodexCatalogEntry[]): Array<{
+        id: string;
+    } & Record<string, unknown>>;
+}
+export {};

package/dist/internal-providers/provider-codex/relay.js

@@ -0,0 +1,261 @@
+import { randomUUID } from "node:crypto";
+import { codexModelsSearch, forwardRelayHeaders } from "@velum-labs/routekit-accounts";
+import { providerDefaultBaseUrl, subscriptionInfo } from "@velum-labs/routekit-registry";
+import { executeInferenceRequest, executeWebRequest, RouteKitFailure, routeKitError, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
+import { trimTrailingSlashes } from "@velum-labs/routekit-runtime/network";
+import { Effect } from "effect";
+import { z } from "zod";
+function withCodexAccountDefaults(body) {
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+        return body;
+    const defaults = subscriptionInfo("codex").requestDefaults;
+    const normalized = {
+        ...body,
+        ...(defaults?.stream !== undefined ? { stream: defaults.stream } : {}),
+        ...(defaults?.store !== undefined ? { store: defaults.store } : {})
+    };
+    if (defaults?.omitSampling === true) {
+        delete normalized.max_output_tokens;
+        delete normalized.temperature;
+        delete normalized.top_p;
+    }
+    return normalized;
+}
+function withCodexResponsesInput(body) {
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+        return body;
+    const record = body;
+    if (typeof record.input !== "string")
+        return body;
+    return {
+        ...record,
+        input: [
+            {
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text: record.input }]
+            }
+        ]
+    };
+}
+const defaultProviderRelayLogger = {
+    warn: (message) => process.stderr.write(`${message}\n`),
+    error: (message) => process.stderr.write(`${message}\n`)
+};
+/**
+ * The upstream `/models` wire contract, validated structurally. There is no
+ * official OpenAPI document or published SDK type for the private ChatGPT
+ * Codex backend: the authoritative schema is codex-rs's `ModelInfo`
+ * (`codex-rs/protocol/src/openai_models.rs`, serde + ts-rs bindings that are
+ * not published to npm — `@openai/codex-sdk` only ships the Threads API), and
+ * it deliberately drifts across Codex releases. So validation pins exactly
+ * what the relay relies on — the `{ models: [...] }` envelope and each
+ * entry's identity (`slug`) — while every other field passes through verbatim
+ * (`looseObject`), which is what keeps newer/unknown fields alive on the way
+ * to the Codex client that DOES validate the full schema for its own version.
+ */
+const upstreamModelsEnvelope = z.object({ models: z.array(z.unknown()) });
+const stockEntrySchema = z.looseObject({ slug: z.string().min(1) });
+/**
+ * Extract relayable ChatGPT auth from a request. Codex's ChatGPT-login auth
+ * provider always sends the bearer token together with a `chatgpt-account-id`
+ * header; the pair is what distinguishes it from a plain API key or a gateway
+ * bearer token, so only that combination is ever relayed.
+ */
+export function codexRelayAuth(headers) {
+    const authorization = headers.authorization;
+    const accountId = headers["chatgpt-account-id"];
+    if (typeof authorization !== "string" || !authorization.startsWith("Bearer "))
+        return undefined;
+    if (typeof accountId !== "string" || accountId.length === 0)
+        return undefined;
+    return { authorization, accountId };
+}
+function entrySlug(entry) {
+    return typeof entry.slug === "string" && entry.slug.length > 0 ? entry.slug : undefined;
+}
+const DEFAULT_RELAY_TIMEOUT_MS = 4500;
+export class CodexBackendRelay {
+    kind = "request";
+    dialect = "codex";
+    httpSubmission;
+    #backendUrl;
+    #catalog;
+    #fallbackStock;
+    #timeoutMs;
+    #logger;
+    #auth;
+    constructor(options) {
+        this.#backendUrl = trimTrailingSlashes(options.backendUrl ?? providerDefaultBaseUrl("codex") ?? "");
+        this.#catalog = options.catalog;
+        this.#fallbackStock = options.fallbackStock ?? (() => []);
+        this.#timeoutMs = options.timeoutMs ?? DEFAULT_RELAY_TIMEOUT_MS;
+        this.#logger = options.logger ?? defaultProviderRelayLogger;
+        this.#auth = options.auth ?? { kind: "client" };
+        if (this.#auth.kind === "accounts" && this.#auth.accounts.mode !== "codex") {
+            throw new Error("Codex relay requires a codex subscription account set");
+        }
+        this.httpSubmission =
+            this.#auth.kind === "accounts" &&
+                this.#backendUrl === trimTrailingSlashes(providerDefaultBaseUrl("codex") ?? "")
+                ? "credential-owner-http-v1"
+                : undefined;
+    }
+    /**
+     * The merged Codex picker catalog for a `GET /v1/models` request, plus the
+     * upstream ETag when the live list was used. With relayable auth the stock
+     * list comes from the live ChatGPT backend; otherwise (or on any upstream
+     * failure) from the local snapshot. Returns `undefined` when no catalog can
+     * be built at all (no stock entry to use as a schema template).
+     */
+    mergedCatalog(headers, search) {
+        const self = this;
+        return Effect.gen(function* () {
+            const auth = codexRelayAuth(headers);
+            if (auth !== undefined || self.#auth.kind === "accounts") {
+                const live = yield* self.#fetchUpstreamModels(headers, search).pipe(Effect.map((upstream) => {
+                    const template = upstream.models[0];
+                    if (template === undefined)
+                        return undefined;
+                    return {
+                        models: self.#catalog(template, upstream.models),
+                        ...(upstream.etag !== undefined ? { etag: upstream.etag } : {})
+                    };
+                }), Effect.catch((error) => {
+                    self.#logger.warn(`routekit: live Codex model catalog unavailable (${error instanceof Error ? error.message : String(error)}); using the local snapshot`);
+                    return Effect.void;
+                }));
+                if (live !== undefined)
+                    return live;
+            }
+            const stock = self.#fallbackStock();
+            const template = stock[0];
+            if (template === undefined)
+                return undefined;
+            return { models: self.#catalog(template, stock) };
+        });
+    }
+    #fetchUpstreamModels(headers, search) {
+        const self = this;
+        return Effect.gen(function* () {
+            const request = (injected) => {
+                const forwarded = forwardRelayHeaders(headers);
+                if (injected !== undefined) {
+                    delete forwarded.authorization;
+                    delete forwarded.Authorization;
+                    delete forwarded["chatgpt-account-id"];
+                    Object.assign(forwarded, injected);
+                }
+                return executeWebRequest(`${self.#backendUrl}/models${codexModelsSearch(search)}`, {
+                    method: "GET",
+                    headers: forwarded,
+                    signal: AbortSignal.timeout(self.#timeoutMs)
+                }).pipe(Effect.mapError((error) => routeKitError(error)));
+            };
+            const response = yield* self.#auth.kind === "client"
+                ? request()
+                : self.#auth.accounts.execute(undefined, (credential) => request(self.#auth.kind === "accounts"
+                    ? self.#auth.accounts.provider.authHeaders(credential)
+                    : {}));
+            if (!response.ok) {
+                return yield* new RouteKitFailure({
+                    message: `upstream /models returned ${response.status}`
+                });
+            }
+            const payload = yield* Effect.tryPromise({
+                try: () => response.json(),
+                catch: (cause) => toRouteKitFailure(cause)
+            });
+            const envelope = upstreamModelsEnvelope.safeParse(payload);
+            if (!envelope.success) {
+                return yield* new RouteKitFailure({
+                    message: "upstream /models returned an unexpected shape (no models array)"
+                });
+            }
+            const models = envelope.data.models.flatMap((entry) => {
+                const parsed = stockEntrySchema.safeParse(entry);
+                return parsed.success ? [parsed.data] : [];
+            });
+            const etag = response.headers.get("etag");
+            return { models, ...(etag !== null ? { etag } : {}) };
+        });
+    }
+    /**
+     * Whether a `POST /v1/responses` request should be relayed: it names a model
+     * the gateway does not serve locally AND carries relayable ChatGPT auth.
+     */
+    shouldRelayResponses(headers, model, servesLocally) {
+        if (model === undefined || model.length === 0)
+            return false;
+        if (servesLocally(model))
+            return false;
+        return this.#auth.kind === "accounts" || codexRelayAuth(headers) !== undefined;
+    }
+    shouldRelay(headers, model, servesLocally) {
+        return this.shouldRelayResponses(headers, model, servesLocally);
+    }
+    /**
+     * Forward a Responses request to the ChatGPT Codex backend. Public string
+     * input is normalized to the backend's required item-list representation;
+     * item-list input and every non-transport header (including the client's own
+     * auth) go through untouched, and the upstream response (typically SSE)
+     * streams back unchanged.
+     */
+    relayResponses(headers, body, signal, options) {
+        const normalizedBody = withCodexResponsesInput(body);
+        const upstreamBody = this.#auth.kind === "accounts" ? withCodexAccountDefaults(normalizedBody) : normalizedBody;
+        const request = (injected) => {
+            const forwarded = forwardRelayHeaders(headers);
+            if (injected !== undefined) {
+                delete forwarded.authorization;
+                delete forwarded.Authorization;
+                delete forwarded["chatgpt-account-id"];
+                Object.assign(forwarded, injected);
+            }
+            forwarded["content-type"] = "application/json";
+            return executeInferenceRequest(`${this.#backendUrl}/responses`, {
+                method: "POST",
+                headers: forwarded,
+                body: JSON.stringify(upstreamBody),
+                ...(signal !== undefined ? { signal } : {})
+            }).pipe(Effect.mapError((error) => routeKitError(error)));
+        };
+        if (this.#auth.kind === "client")
+            return request();
+        const model = typeof body === "object" && body !== null && "model" in body && typeof body.model === "string"
+            ? body.model
+            : undefined;
+        const operationId = randomUUID();
+        return this.#auth.accounts.execute(model, (credential) => request(this.#auth.kind === "accounts" ? this.#auth.accounts.provider.authHeaders(credential) : {}), signal, {
+            responseMode: options?.responseMode,
+            onAttempt: (account) => options?.onAttribution?.({
+                accountAttempt: { operationId, seat: account.seat }
+            }),
+            onRetriedAttempt: (attempt) => options?.onAttribution?.({
+                accountAttemptResult: { operationId, ...attempt }
+            })
+        });
+    }
+    relay(headers, body, signal, options) {
+        return this.relayResponses(headers, body, signal, options);
+    }
+    snapshot() {
+        return this.#auth.kind === "accounts" ? this.#auth.accounts.statusSnapshot() : undefined;
+    }
+    close() {
+        return this.#auth.kind === "accounts" ? this.#auth.accounts.close() : Effect.void;
+    }
+    /** Merge relayed stock slugs into an OpenAI-shape `data` model list. */
+    mergeDataIds(data, models) {
+        const seen = new Set(data.map((entry) => entry.id));
+        const merged = [...data];
+        for (const entry of models) {
+            const slug = entrySlug(entry);
+            if (slug === undefined || seen.has(slug))
+                continue;
+            seen.add(slug);
+            merged.push({ id: slug, object: "model", owned_by: "codex-relay" });
+        }
+        return merged;
+    }
+}

package/dist/internal-providers/provider-codex/subscription.d.ts

@@ -0,0 +1,2 @@
+import type { SubscriptionProvider } from "@velum-labs/routekit-accounts";
+export declare function codexProvider(): SubscriptionProvider<"codex">;