@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/foundry-billing.js

@@ -0,0 +1,107 @@
+import { errorOutcome, errorToken, GenesisError } from './errors.js';
+export const foundryBillingOperations = ['foundry_readBillingProfile', 'foundry_ensureBillingProfile', 'foundry_createNativeCreditCheckout', 'foundry_readNativeCreditBalance'];
+export const isFoundryBillingOperation = (id) => foundryBillingOperations.includes(id);
+const writes = new Set(['foundry_ensureBillingProfile', 'foundry_createNativeCreditCheckout']);
+const keyValid = (key) => typeof key === 'string' && /^[\x21-\x7e]{1,255}(?![\s\S])/.test(key) && !key.includes(',');
+/** One gateway dispatch, no redirect or automatic retry. Native billing always
+ * uses the caller's original human credential; customer/provider selectors are absent. */
+export async function foundryBillingTransport(options) {
+    const write = writes.has(options.operationId), key = options.headers?.['idempotency-key'];
+    const error = (status, type, body) => new GenesisError({ status, type, body, operationId: options.operationId,
+        message: 'Native Foundry billing was not confirmed. Preserve the operation key and reconcile an unknown result before retrying.' });
+    const body = options.input.body;
+    if (options.routing !== 'gateway' || !isFoundryBillingOperation(options.operationId) || Object.keys(options.input).some(k => k !== 'body')
+        || (write ? !keyValid(key) || !body || typeof body !== 'object' || Array.isArray(body) || Object.keys(body).length > 0 : Object.keys(options.input).length > 0))
+        throw error(0, 'invalid_request');
+    const controller = new AbortController(), cancel = () => controller.abort(options.signal?.reason);
+    if (options.signal?.aborted)
+        cancel();
+    else
+        options.signal?.addEventListener('abort', cancel, { once: true });
+    const timer = setTimeout(() => controller.abort(), 20_000);
+    async function bounded(work) {
+        controller.signal.throwIfAborted();
+        let abort = () => { };
+        try {
+            return await Promise.race([work, new Promise((_, reject) => { abort = () => reject(error(0, 'outcome_unknown', write ? { outcome: 'unknown' } : undefined)); controller.signal.addEventListener('abort', abort, { once: true }); })]);
+        }
+        finally {
+            controller.signal.removeEventListener('abort', abort);
+        }
+    }
+    try {
+        controller.signal.throwIfAborted();
+        const credential = await bounded(options.credential());
+        controller.signal.throwIfAborted();
+        if (!credential)
+            throw error(401, 'unauthenticated');
+        const response = await bounded(options.fetch(options.url, { method: write ? 'POST' : 'GET', headers: { authorization: `Bearer ${credential}`, accept: 'application/json', ...(write ? { 'content-type': 'application/json', 'idempotency-key': key } : {}) },
+            ...(write ? { body: '{}' } : {}), signal: controller.signal, redirect: 'error', cache: 'no-store' }).then(response => { if (controller.signal.aborted) {
+            void response.body?.cancel().catch(() => { });
+            throw error(0, 'outcome_unknown', write ? { outcome: 'unknown' } : undefined);
+        } return response; }));
+        if (!response.body || !/^application\/json(?:;|$)/i.test(response.headers.get('content-type') ?? ''))
+            throw error(response.status, 'invalid_response', write ? { outcome: 'unknown' } : undefined);
+        const reader = response.body.getReader(), parts = [];
+        let size = 0;
+        const stop = () => { void reader.cancel().catch(() => { }); };
+        controller.signal.addEventListener('abort', stop, { once: true });
+        try {
+            for (;;) {
+                const next = await bounded(reader.read());
+                if (next.done)
+                    break;
+                size += next.value.length;
+                if (size > 16384)
+                    throw error(response.status, 'invalid_response', write ? { outcome: 'unknown' } : undefined);
+                parts.push(next.value);
+            }
+        }
+        finally {
+            controller.signal.removeEventListener('abort', stop);
+            stop();
+            try {
+                reader.releaseLock();
+            }
+            catch { /* pending read was cancelled */ }
+        }
+        const bytes = new Uint8Array(size);
+        let at = 0;
+        for (const part of parts) {
+            bytes.set(part, at);
+            at += part.length;
+        }
+        let value;
+        try {
+            value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        }
+        catch {
+            throw error(response.status, 'invalid_response', write ? { outcome: 'unknown' } : undefined);
+        }
+        if (!response.ok) {
+            const fields = value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+            // Envelope (error.code / error.outcome) or legacy string form; only an explicit not_dispatched 400 is safe to fix and resend.
+            const outcome = response.status === 400 && errorToken(fields) === 'invalid_billing_request' && errorOutcome(fields) === 'not_dispatched' ? 'not_dispatched' : 'unknown';
+            throw error(response.status, 'billing_unconfirmed', write ? { ...fields, outcome } : value);
+        }
+        return Response.json(value, { status: response.status, headers: { 'cache-control': 'no-store' } });
+    }
+    catch (e) {
+        if (e instanceof GenesisError)
+            throw e;
+        throw error(0, 'outcome_unknown', write ? { outcome: 'unknown' } : undefined);
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        options.signal?.removeEventListener('abort', cancel);
+    }
+}
+export function foundryBilling(client) {
+    const read = (id, options = {}) => client.request(id, {}, options);
+    const write = (id, key, options = {}) => client.request(id, { body: {} }, { ...options, headers: { 'idempotency-key': key } });
+    return { profile: (options) => read('foundry_readBillingProfile', options),
+        ensureProfile: (operationKey, options) => write('foundry_ensureBillingProfile', operationKey, options),
+        checkoutCredits: (purchaseKey, options) => write('foundry_createNativeCreditCheckout', purchaseKey, options),
+        creditBalance: (options) => read('foundry_readNativeCreditBalance', options) };
+}

package/dist/foundry.d.ts

@@ -0,0 +1,424 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Foundry through the gateway (gateway/src/foundry-native.ts). Inference, receipts and key info are delegated for a
+ * login session; an org API key gets 403 FOUNDRY_HUMAN_SESSION_REQUIRED until Foundry admits key principals. A One app
+ * sign-in (`pf_one`) gets the prepaid child, which Foundry admits only for chat, responses, embeddings and messages;
+ * `universal`, `routing`, `tools`, `workloads`, `generation` and `keys.current` work today with a Console login (`pf_console`). Registry reads are public. Key writes are gateway-native and need an idempotency key.
+ * Canonical model ids are `vendor/name`: their `/` is sent as a path separator. */
+export declare function foundryModule(client: GenesisClient): {
+    /** Anthropic Messages (Foundry /api/v1/messages). */
+    messages: (body: In<"foundry_createMessage">["body"]) => Promise<{
+        id: string;
+        model?: string;
+        content: {
+            [key: string]: unknown;
+        }[];
+        usage?: import("./index.js").components["schemas"]["Foundry.Usage"];
+        foundry?: import("./index.js").components["schemas"]["Foundry.RequestMetadata"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    responses: (body: In<"foundry_createResponse">["body"]) => Promise<{
+        id: string;
+        object?: string;
+        model?: string;
+        output?: {
+            [key: string]: unknown;
+        }[];
+        usage?: import("./index.js").components["schemas"]["Foundry.Usage"];
+        foundry?: import("./index.js").components["schemas"]["Foundry.RequestMetadata"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    rerank: (body: In<"foundry_createRerank">["body"]) => Promise<unknown>;
+    images: {
+        create: (body: In<"foundry_createImage">["body"]) => Promise<unknown>;
+        models: () => Promise<{
+            data: {
+                [key: string]: unknown;
+            }[];
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    transcribe: (body: In<"foundry_createAudioTranscription">["body"]) => Promise<unknown>;
+    receipts: {
+        get: (receipt_id: string) => Promise<{
+            version?: string;
+            receipt_id: string;
+            request_id: string;
+            model_id?: string;
+            provider_id?: string;
+            lane?: "pay_as_you_go" | "subscription_entitled" | "byok";
+            usage?: import("./index.js").components["schemas"]["Foundry.Usage"];
+            signature?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        byRequest: (request_id: string) => Promise<{
+            version?: string;
+            receipt_id: string;
+            request_id: string;
+            model_id?: string;
+            provider_id?: string;
+            lane?: "pay_as_you_go" | "subscription_entitled" | "byok";
+            usage?: import("./index.js").components["schemas"]["Foundry.Usage"];
+            signature?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        verificationKey: () => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    keys: {
+        list: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        create: (body: In<"foundry_createApiKey">["body"], idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        delete: (key_id: string, idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        rotate: (key_id: string, idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        /** The Foundry credential the call carried (through the gateway: your login's delegated identity). */
+        current: () => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    reporting: {
+        requestLogs: (q?: In<"foundry_listRequestLogs">) => Promise<{
+            data: {
+                id: string;
+                timestamp: string;
+                model: string;
+                provider: string;
+                status: number;
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+                latency_ms: number;
+                estimated_cost_microdollars: number;
+            }[];
+            scope: import("./index.js").components["schemas"]["Foundry.ReportingScope"];
+            meta: {
+                limit: number;
+                offset: number;
+                total_count: number;
+                has_more: boolean;
+            };
+        }>;
+        providerCredentials: () => Promise<{
+            data: {
+                object: "provider_credential_summary";
+                source: string;
+                generated_at: string;
+                complete: boolean;
+                consistency: string;
+                configuration_only: boolean;
+                health_verified: boolean;
+                execution_verified: boolean;
+                default_credential_mode: string;
+                credential_count: number;
+                enabled_credential_count: number;
+                credentials: {
+                    provider_id: string;
+                    enabled?: boolean;
+                    created_at: string;
+                    updated_at: string;
+                    credential_mode: "platform" | "prefer_byok" | "require_byok";
+                }[];
+                policies: {
+                    provider_id: string;
+                    enabled?: boolean;
+                    created_at: string;
+                    updated_at: string;
+                    credential_mode: "platform" | "prefer_byok" | "require_byok";
+                }[];
+            };
+            scope: import("./index.js").components["schemas"]["Foundry.ReportingScope"];
+        }>;
+    };
+    /** Refused to every caller today: Foundry gates these on its `admin` scope (403 SCOPE_MISSING). */
+    activity: {
+        list: (q?: In<"foundry_getActivity">) => Promise<{
+            [key: string]: unknown;
+        }>;
+        export: (q?: In<"foundry_exportActivity">) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    analytics: {
+        meta: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        query: (body: In<"foundry_queryAnalytics">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    /** Foundry universal API (/foundry/v1/*): `infer` for any modality, or a task wrapper. Paid. */
+    universal: {
+        infer: (body: In<"foundry_createInference">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        /** Server-sent events: the raw Response. */
+        inferStream: (body: In<"foundry_streamInference">["body"]) => Promise<unknown>;
+        classify: (body: In<"foundry_classifyText">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        detect: (body: In<"foundry_detectObjects">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        segment: (body: In<"foundry_segmentImage">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        embed: (body: In<"foundry_embedTexts">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        transcribe: (body: In<"foundry_transcribeAudio">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        speak: (body: In<"foundry_synthesizeSpeech">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        generateImage: (body: In<"foundry_generateImage">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        predict: (body: In<"foundry_predictTabular">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        forecast: (body: In<"foundry_forecastSeries">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        recommend: (body: In<"foundry_recommendItems">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        annotate: (body: In<"foundry_annotateText">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        summarize: (body: In<"foundry_summarizeText">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    /** Routing preview, explanation and eval planning: compute only. */
+    routing: {
+        preview: (body: In<"foundry_previewRoute">["body"]) => Promise<{
+            candidates?: {
+                [key: string]: unknown;
+            }[];
+            selected?: {
+                [key: string]: unknown;
+            };
+            executable?: boolean;
+            billing_lane?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        explain: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        evals: {
+            plan: (body: In<"foundry_planRoutingEval">["body"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+            dispatchPlan: (body: In<"foundry_dispatchRoutingEvalPlan">["body"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+            aggregateDispatch: (body: In<"foundry_aggregateRoutingEvalDispatch">["body"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+            aggregatePlanned: (body: In<"foundry_aggregatePlannedRoutingEval">["body"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+            aggregate: (body: In<"foundry_aggregateRoutingEval">["body"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+            claimReadiness: (body: In<"foundry_checkRoutingEvalClaimReadiness">["body"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+    };
+    /** Cost and model comparison estimates: compute only, no provider call. */
+    tools: {
+        costEstimate: (body: In<"foundry_estimateCost">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        compare: (body: In<"foundry_compareModels">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        benchmark: (body: In<"foundry_benchmarkModels">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    workloads: {
+        status: (workload_id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        terminate: (workload_id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    /** OpenRouter-style generation lookup by request id; content and feedback need Foundry `admin` (refused today). */
+    generation: {
+        get: (id: string) => Promise<{
+            data: {
+                id?: string;
+                request_id?: string;
+                model?: string;
+                provider_name?: string;
+                is_byok?: boolean;
+                total_cost?: number;
+                foundry_receipt?: import("./index.js").components["schemas"]["Foundry.JsonObject"];
+            } & {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        }>;
+        content: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        feedback: (body: In<"foundry_submitGenerationFeedback">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    batches: {
+        create: (body: In<"foundry_createBatch">["body"]) => Promise<{
+            id: string;
+            status: string;
+            endpoint?: string;
+            input_file_id?: string;
+            output_file_id?: string | null;
+            request_counts?: {
+                [key: string]: unknown;
+            };
+            metadata?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        }>;
+        get: (batch_id: string) => Promise<{
+            id: string;
+            status: string;
+            endpoint?: string;
+            input_file_id?: string;
+            output_file_id?: string | null;
+            request_counts?: {
+                [key: string]: unknown;
+            };
+            metadata?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+};
+/** Public registry reads, V1 and paginated V2. */
+export declare function foundryRegistry(client: GenesisClient): {
+    models: (q?: In<"foundry_listRegistryModels">) => Promise<{
+        [key: string]: unknown;
+    }>;
+    model: (canonical_model_id: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    offers: (canonical_model_id: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    dossier: (canonical_model_id: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    benchmarks: (canonical_model_id: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    sources: (canonical_model_id: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    providers: () => Promise<{
+        [key: string]: unknown;
+    }>;
+    provider: (provider_id: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    providerDossier: (provider_id: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    facets: () => Promise<{
+        [key: string]: unknown;
+    }>;
+    modelBase: () => Promise<{
+        [key: string]: unknown;
+    }>;
+    modelBaseReleases: () => Promise<{
+        [key: string]: unknown;
+    }>;
+    labs: () => Promise<{
+        [key: string]: unknown;
+    }>;
+    lab: (lab_id: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    compare: (q?: In<"foundry_compareRegistryModels">) => Promise<{
+        [key: string]: unknown;
+    }>;
+    v2: {
+        models: (q?: In<"foundry_listRegistryModelsV2">) => Promise<{
+            [key: string]: unknown;
+        }>;
+        model: (canonical_model_id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        dossier: (canonical_model_id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        providers: (q?: In<"foundry_listRegistryProvidersV2">) => Promise<{
+            [key: string]: unknown;
+        }>;
+        provider: (provider_id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        facets: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        modelBase: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        modelBaseReleases: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        labs: (q?: In<"foundry_listRegistryLabsV2">) => Promise<{
+            [key: string]: unknown;
+        }>;
+        lab: (lab_id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        compare: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        benchmarks: (q?: In<"foundry_listRegistryBenchmarksV2">) => Promise<{
+            version: 2;
+            snapshot: {
+                [key: string]: unknown;
+            };
+            data: import("./index.js").components["schemas"]["Foundry.PublicBenchmarkV2"][];
+            count: number;
+            page: {
+                count: number;
+                total: number;
+                limit: number;
+                next_cursor?: string | null;
+                has_more: boolean;
+            };
+        }>;
+        sources: (q?: In<"foundry_listRegistrySourcesV2">) => Promise<{
+            [key: string]: unknown;
+        }>;
+        provenance: (q?: In<"foundry_listRegistryProvenanceV2">) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+};

package/dist/foundry.js

@@ -0,0 +1,133 @@
+import { idempotencyHeaders } from './idempotency.js';
+/** Foundry through the gateway (gateway/src/foundry-native.ts). Inference, receipts and key info are delegated for a
+ * login session; an org API key gets 403 FOUNDRY_HUMAN_SESSION_REQUIRED until Foundry admits key principals. A One app
+ * sign-in (`pf_one`) gets the prepaid child, which Foundry admits only for chat, responses, embeddings and messages;
+ * `universal`, `routing`, `tools`, `workloads`, `generation` and `keys.current` work today with a Console login (`pf_console`). Registry reads are public. Key writes are gateway-native and need an idempotency key.
+ * Canonical model ids are `vendor/name`: their `/` is sent as a path separator. */
+export function foundryModule(client) {
+    const key = (id, k) => ({ headers: idempotencyHeaders(id, k) });
+    return {
+        /** Anthropic Messages (Foundry /api/v1/messages). */
+        messages: (body) => client.request('foundry_createMessage', { body }),
+        responses: (body) => client.request('foundry_createResponse', { body }),
+        rerank: (body) => client.request('foundry_createRerank', { body }),
+        images: {
+            create: (body) => client.request('foundry_createImage', { body }),
+            models: () => client.request('foundry_listImageModels'),
+        },
+        transcribe: (body) => client.request('foundry_createAudioTranscription', { body }),
+        receipts: {
+            get: (receipt_id) => client.request('foundry_getGenerationReceipt', { receipt_id }),
+            byRequest: (request_id) => client.request('foundry_getGenerationReceiptByRequest', { request_id }),
+            verificationKey: () => client.request('foundry_getReceiptVerificationKey'),
+        },
+        keys: {
+            list: () => client.request('foundry_listApiKeys'),
+            create: async (body, idempotencyKey) => client.request('foundry_createApiKey', { body }, key('foundry_createApiKey', idempotencyKey)),
+            delete: async (key_id, idempotencyKey) => client.request('foundry_deleteApiKey', { key_id }, key('foundry_deleteApiKey', idempotencyKey)),
+            rotate: async (key_id, idempotencyKey) => client.request('foundry_rotateApiKey', { key_id }, key('foundry_rotateApiKey', idempotencyKey)),
+            /** The Foundry credential the call carried (through the gateway: your login's delegated identity). */
+            current: () => client.request('foundry_getCurrentApiKey'),
+        },
+        reporting: {
+            requestLogs: (q = {}) => client.request('foundry_listRequestLogs', q),
+            providerCredentials: () => client.request('foundry_getProviderCredentialSummary'),
+        },
+        /** Refused to every caller today: Foundry gates these on its `admin` scope (403 SCOPE_MISSING). */
+        activity: {
+            list: (q = {}) => client.request('foundry_getActivity', q),
+            export: (q = {}) => client.request('foundry_exportActivity', q),
+        },
+        analytics: {
+            meta: () => client.request('foundry_getAnalyticsMeta'),
+            query: (body) => client.request('foundry_queryAnalytics', { body }),
+        },
+        /** Foundry universal API (/foundry/v1/*): `infer` for any modality, or a task wrapper. Paid. */
+        universal: {
+            infer: (body) => client.request('foundry_createInference', { body }),
+            /** Server-sent events: the raw Response. */
+            inferStream: (body) => client.request('foundry_streamInference', { body }),
+            classify: (body) => client.request('foundry_classifyText', { body }),
+            detect: (body) => client.request('foundry_detectObjects', { body }),
+            segment: (body) => client.request('foundry_segmentImage', { body }),
+            embed: (body) => client.request('foundry_embedTexts', { body }),
+            transcribe: (body) => client.request('foundry_transcribeAudio', { body }),
+            speak: (body) => client.request('foundry_synthesizeSpeech', { body }),
+            generateImage: (body) => client.request('foundry_generateImage', { body }),
+            predict: (body) => client.request('foundry_predictTabular', { body }),
+            forecast: (body) => client.request('foundry_forecastSeries', { body }),
+            recommend: (body) => client.request('foundry_recommendItems', { body }),
+            annotate: (body) => client.request('foundry_annotateText', { body }),
+            summarize: (body) => client.request('foundry_summarizeText', { body }),
+        },
+        /** Routing preview, explanation and eval planning: compute only. */
+        routing: {
+            preview: (body) => client.request('foundry_previewRoute', { body }),
+            explain: (id) => client.request('foundry_explainRoutingInvocation', { id }),
+            evals: {
+                plan: (body) => client.request('foundry_planRoutingEval', { body }),
+                dispatchPlan: (body) => client.request('foundry_dispatchRoutingEvalPlan', { body }),
+                aggregateDispatch: (body) => client.request('foundry_aggregateRoutingEvalDispatch', { body }),
+                aggregatePlanned: (body) => client.request('foundry_aggregatePlannedRoutingEval', { body }),
+                aggregate: (body) => client.request('foundry_aggregateRoutingEval', { body }),
+                claimReadiness: (body) => client.request('foundry_checkRoutingEvalClaimReadiness', { body }),
+            },
+        },
+        /** Cost and model comparison estimates: compute only, no provider call. */
+        tools: {
+            costEstimate: (body) => client.request('foundry_estimateCost', { body }),
+            compare: (body) => client.request('foundry_compareModels', { body }),
+            benchmark: (body) => client.request('foundry_benchmarkModels', { body }),
+        },
+        workloads: {
+            status: (workload_id) => client.request('foundry_getWorkloadStatus', { workload_id }),
+            terminate: (workload_id) => client.request('foundry_terminateWorkload', { workload_id }),
+        },
+        /** OpenRouter-style generation lookup by request id; content and feedback need Foundry `admin` (refused today). */
+        generation: {
+            get: (id) => client.request('foundry_getGeneration', { id }),
+            content: (id) => client.request('foundry_getGenerationContent', { id }),
+            feedback: (body) => client.request('foundry_submitGenerationFeedback', { body }),
+        },
+        batches: {
+            create: (body) => client.request('foundry_createBatch', { body }),
+            get: (batch_id) => client.request('foundry_getBatch', { batch_id }),
+        },
+    };
+}
+/** Public registry reads, V1 and paginated V2. */
+export function foundryRegistry(client) {
+    return {
+        models: (q = {}) => client.request('foundry_listRegistryModels', q),
+        model: (canonical_model_id) => client.request('foundry_getRegistryModel', { canonical_model_id }),
+        offers: (canonical_model_id) => client.request('foundry_listModelOffers', { canonical_model_id }),
+        dossier: (canonical_model_id) => client.request('foundry_getModelDossier', { canonical_model_id }),
+        benchmarks: (canonical_model_id) => client.request('foundry_listModelBenchmarks', { canonical_model_id }),
+        sources: (canonical_model_id) => client.request('foundry_listModelSources', { canonical_model_id }),
+        providers: () => client.request('foundry_listRegistryProviders'),
+        provider: (provider_id) => client.request('foundry_getRegistryProvider', { provider_id }),
+        providerDossier: (provider_id) => client.request('foundry_getProviderDossier', { provider_id }),
+        facets: () => client.request('foundry_listRegistryFacets'),
+        modelBase: () => client.request('foundry_getCurrentModelBase'),
+        modelBaseReleases: () => client.request('foundry_listModelBaseReleases'),
+        labs: () => client.request('foundry_listRegistryLabs'),
+        lab: (lab_id) => client.request('foundry_getRegistryLab', { lab_id }),
+        compare: (q = {}) => client.request('foundry_compareRegistryModels', q),
+        v2: {
+            models: (q = {}) => client.request('foundry_listRegistryModelsV2', q),
+            model: (canonical_model_id) => client.request('foundry_getRegistryModelV2', { canonical_model_id }),
+            dossier: (canonical_model_id) => client.request('foundry_getModelDossierV2', { canonical_model_id }),
+            providers: (q = {}) => client.request('foundry_listRegistryProvidersV2', q),
+            provider: (provider_id) => client.request('foundry_getProviderDossierV2', { provider_id }),
+            facets: () => client.request('foundry_listRegistryFacetsV2'),
+            modelBase: () => client.request('foundry_getCurrentModelBaseV2'),
+            modelBaseReleases: () => client.request('foundry_listModelBaseReleasesV2'),
+            labs: (q = {}) => client.request('foundry_listRegistryLabsV2', q),
+            lab: (lab_id) => client.request('foundry_getRegistryLabV2', { lab_id }),
+            compare: () => client.request('foundry_compareRegistryModelsV2'),
+            benchmarks: (q = {}) => client.request('foundry_listRegistryBenchmarksV2', q),
+            sources: (q = {}) => client.request('foundry_listRegistrySourcesV2', q),
+            provenance: (q = {}) => client.request('foundry_listRegistryProvenanceV2', q),
+        },
+    };
+}