@oxy.so/contracts 1.0.0

package/dist/types/inference/errors.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Inference errors and retryability.
+ *
+ * One closed set of codes, shared by the Oxy public edge, the data plane and
+ * every SDK.
+ * Closed because the alternative — a free-form `code` string — makes a client's
+ * error handling a guess about the producer's spelling, and makes "is this
+ * worth retrying" a decision every consumer re-derives from prose.
+ *
+ * Retryability is carried explicitly and is CONSTRAINED by the code: a code
+ * that can never succeed on a bare retry (an invalid request, a denied
+ * permission, an insufficient balance) cannot claim `retryable: true`. Without
+ * that constraint the field is advisory, and one producer setting it optimistically
+ * turns every client into a retry storm against a request that will never pass.
+ *
+ * The provider passthrough exists so a customer can see what the upstream said
+ * without Oxy having to interpret every provider's error vocabulary — but it is
+ * the single most likely place for an upstream credential to escape, because
+ * provider errors routinely echo the request that caused them. It is therefore
+ * a `.strict()` object of four fields with no room for headers or a request
+ * body, and its free text is refused if it looks like it contains a credential.
+ *
+ * Decided in: docs/adr/0010-public-api-compatibility.md.
+ */
+import { z } from 'zod';
+/**
+ * The closed set of inference error codes.
+ *
+ * Grouped by who must act: the caller (`invalid_request` … `idempotency_conflict`),
+ * the account owner (`insufficient_balance`, `spending_limit_exceeded`,
+ * `quota_exceeded`, `byok_credential_invalid`), routing/permission policy
+ * (`policy_violation`, `commercial_permission_denied`, `no_route_available`),
+ * and the platform or its upstreams (everything from `deployment_unavailable`).
+ *
+ * The platform group is NOT uniformly retryable, and that is the point of
+ * `provider_credential_invalid` sitting in it: an upstream that refuses the
+ * PLATFORM's own credential fails every identical retry until an operator
+ * rotates a key, so classifying it as `provider_error` would send every client
+ * into a retry loop against a request that cannot succeed.
+ *
+ * `provider_billing_refused` is in that group for the same reason and was found
+ * the same way — an upstream declining to bill OXY (Anthropic answers 402) has
+ * to be distinguishable from the customer's own balance running out, or the
+ * error tells them to go and top up an account that is not the one at fault.
+ */
+export declare const INFERENCE_ERROR_CODES: readonly ["invalid_request", "authentication_failed", "permission_denied", "insufficient_scope", "model_not_found", "unsupported_modality", "context_length_exceeded", "request_too_large", "output_limit_exceeded", "idempotency_conflict", "insufficient_balance", "spending_limit_exceeded", "quota_exceeded", "byok_credential_invalid", "policy_violation", "commercial_permission_denied", "no_route_available", "upstream_content_filtered", "cancelled", "rate_limited", "deployment_unavailable", "provider_error", "provider_timeout", "provider_overloaded", "provider_credential_invalid", "provider_billing_refused", "service_unavailable", "internal_error"];
+export declare const inferenceErrorCodeSchema: z.ZodEnum<["invalid_request", "authentication_failed", "permission_denied", "insufficient_scope", "model_not_found", "unsupported_modality", "context_length_exceeded", "request_too_large", "output_limit_exceeded", "idempotency_conflict", "insufficient_balance", "spending_limit_exceeded", "quota_exceeded", "byok_credential_invalid", "policy_violation", "commercial_permission_denied", "no_route_available", "upstream_content_filtered", "cancelled", "rate_limited", "deployment_unavailable", "provider_error", "provider_timeout", "provider_overloaded", "provider_credential_invalid", "provider_billing_refused", "service_unavailable", "internal_error"]>;
+/**
+ * Codes for which an identical retried request cannot succeed.
+ *
+ * `rate_limited` and `quota_exceeded` sit on opposite sides of this line
+ * deliberately: a rate limit clears on its own within the window the response
+ * names, while a quota is an account-level ceiling that only a human raises.
+ * `cancelled` is here because the caller already withdrew the request; a client
+ * that retries it is contradicting its own cancellation.
+ *
+ * `byok_credential_invalid` and `provider_credential_invalid` are the same
+ * failure seen from the two sides of the BYOK boundary — the customer's own
+ * upstream credential and the platform's — and they are two codes rather than
+ * one because only the first names an action the customer can take. Both are
+ * non-retryable for the same reason: a credential an upstream has refused keeps
+ * being refused until somebody replaces it.
+ *
+ * `quota_exceeded` and `provider_billing_refused` divide along the same line:
+ * both are money, but one is the CUSTOMER's ceiling and the other is Oxy's
+ * account with an upstream. Reporting the second as the first is retryability-
+ * correct and diagnostically wrong, which is the worst combination — it reads
+ * as actionable and the action does nothing.
+ */
+export declare const NON_RETRYABLE_INFERENCE_ERROR_CODES: readonly ["invalid_request", "authentication_failed", "permission_denied", "insufficient_scope", "model_not_found", "unsupported_modality", "context_length_exceeded", "request_too_large", "output_limit_exceeded", "idempotency_conflict", "insufficient_balance", "spending_limit_exceeded", "quota_exceeded", "byok_credential_invalid", "policy_violation", "commercial_permission_denied", "no_route_available", "upstream_content_filtered", "cancelled", "provider_credential_invalid", "provider_billing_refused"];
+/**
+ * Free text that is safe to hand a customer: bounded, and refused if it still
+ * looks like it carries a credential. Applied to BOTH the Oxy message and the
+ * upstream one — a leak is no less a leak for having been written by a provider.
+ *
+ * ## This is a last-resort REFUSAL, not protection
+ *
+ * A pattern over the OUTPUT cannot be the control that keeps a credential out of
+ * an error, and a producer that treats it as one has the hole #1027 reported.
+ * The only reliable control is redacting the KNOWN SECRET VALUE at the point
+ * where the producer still holds the bytes it sent — which is an adapter's job
+ * and is available to nobody else. This refinement exists to catch what that
+ * control missed, and nothing here is a licence to skip it.
+ *
+ * Two rules follow, and they are the whole reason this text is longer than the
+ * pattern it describes:
+ *
+ *  - **Never redact by replacing the span this pattern matched.** The span is
+ *    the MARKER; the secret is what follows it. OxyHQ/Kaana#3 measured the
+ *    result: `{x-api-key: <key>}` is refused, `{x-[redacted] <key>}` was
+ *    accepted, and both carry the key. Redaction made the leak worse by
+ *    converting "this string is dangerous" into "this string is fine".
+ *  - **This package deliberately ships no redaction helper.** One keyed on these
+ *    patterns would rebuild the same defect one layer up, and one that took the
+ *    secret as an argument would only restate what the producer already has.
+ *
+ * What it still cannot see, stated so nobody relies on it: a credential with no
+ * marker, no issued-token prefix and no placeholder beside it is bytes that look
+ * like a request id, and refusing those means refusing request ids.
+ */
+export declare const safeErrorTextSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * A coarse classification of an upstream failure (ADR 0010's `upstreamCategory`).
+ *
+ * Distinct from {@link providerErrorPassthroughSchema}, which carries the
+ * upstream's OWN code and text: this is Oxy's reading of what kind of failure it
+ * was, in a vocabulary that is the same across every provider, so a client can
+ * branch on it without knowing who served the request.
+ */
+export declare const upstreamErrorCategorySchema: z.ZodEnum<["rate_limit", "quota", "timeout", "overloaded", "server_error", "content_filter", "invalid_request", "authentication", "unknown"]>;
+/**
+ * What the upstream provider said, reduced to the four fields a customer can
+ * act on.
+ *
+ * `.strict()` is the security control here, not a tidiness preference: it means
+ * a producer cannot widen this by attaching `requestHeaders`, `curl`, `body` or
+ * `raw` and have it silently pass. Adding a field is a contract change with a
+ * version bump and a review, which is the point.
+ */
+export declare const providerErrorPassthroughSchema: z.ZodObject<{
+    provider: z.ZodString;
+    /** The upstream HTTP status, when the upstream spoke HTTP. */
+    status: z.ZodOptional<z.ZodNumber>;
+    /** The upstream's own error code, verbatim and uninterpreted. */
+    code: z.ZodOptional<z.ZodString>;
+    /** The upstream's message, subject to the same credential refusal. */
+    message: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strict", z.ZodTypeAny, {
+    provider: string;
+    code?: string | undefined;
+    message?: string | undefined;
+    status?: number | undefined;
+}, {
+    provider: string;
+    code?: string | undefined;
+    message?: string | undefined;
+    status?: number | undefined;
+}>;
+/**
+ * The error body every inference surface returns and every stream error event
+ * carries.
+ *
+ * `requestId` is always present — an error a customer cannot correlate with a
+ * log line is an error they have to reproduce to report.
+ */
+export declare const inferenceErrorSchema: z.ZodEffects<z.ZodObject<{
+    /** See `version.ts`: this shape appears alone on the wire, so it is versioned. */
+    schemaVersion: z.ZodLiteral<1>;
+    code: z.ZodEnum<["invalid_request", "authentication_failed", "permission_denied", "insufficient_scope", "model_not_found", "unsupported_modality", "context_length_exceeded", "request_too_large", "output_limit_exceeded", "idempotency_conflict", "insufficient_balance", "spending_limit_exceeded", "quota_exceeded", "byok_credential_invalid", "policy_violation", "commercial_permission_denied", "no_route_available", "upstream_content_filtered", "cancelled", "rate_limited", "deployment_unavailable", "provider_error", "provider_timeout", "provider_overloaded", "provider_credential_invalid", "provider_billing_refused", "service_unavailable", "internal_error"]>;
+    message: z.ZodEffects<z.ZodString, string, string>;
+    retryable: z.ZodBoolean;
+    requestId: z.ZodString;
+    /** How long to wait before retrying. Only meaningful when `retryable`. */
+    retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    /** The request field at fault, for `invalid_request`. */
+    param: z.ZodOptional<z.ZodString>;
+    /** Present only when an upstream provider was reached and failed. */
+    upstreamCategory: z.ZodOptional<z.ZodEnum<["rate_limit", "quota", "timeout", "overloaded", "server_error", "content_filter", "invalid_request", "authentication", "unknown"]>>;
+    providerError: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        /** The upstream HTTP status, when the upstream spoke HTTP. */
+        status: z.ZodOptional<z.ZodNumber>;
+        /** The upstream's own error code, verbatim and uninterpreted. */
+        code: z.ZodOptional<z.ZodString>;
+        /** The upstream's message, subject to the same credential refusal. */
+        message: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    }, "strict", z.ZodTypeAny, {
+        provider: string;
+        code?: string | undefined;
+        message?: string | undefined;
+        status?: number | undefined;
+    }, {
+        provider: string;
+        code?: string | undefined;
+        message?: string | undefined;
+        status?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    code: "invalid_request" | "authentication_failed" | "permission_denied" | "insufficient_scope" | "model_not_found" | "unsupported_modality" | "context_length_exceeded" | "request_too_large" | "output_limit_exceeded" | "idempotency_conflict" | "insufficient_balance" | "spending_limit_exceeded" | "quota_exceeded" | "byok_credential_invalid" | "policy_violation" | "commercial_permission_denied" | "no_route_available" | "upstream_content_filtered" | "cancelled" | "rate_limited" | "deployment_unavailable" | "provider_error" | "provider_timeout" | "provider_overloaded" | "provider_credential_invalid" | "provider_billing_refused" | "service_unavailable" | "internal_error";
+    message: string;
+    schemaVersion: 1;
+    requestId: string;
+    retryable: boolean;
+    retryAfterMs?: number | undefined;
+    param?: string | undefined;
+    upstreamCategory?: "unknown" | "authentication" | "invalid_request" | "rate_limit" | "quota" | "timeout" | "overloaded" | "server_error" | "content_filter" | undefined;
+    providerError?: {
+        provider: string;
+        code?: string | undefined;
+        message?: string | undefined;
+        status?: number | undefined;
+    } | undefined;
+}, {
+    code: "invalid_request" | "authentication_failed" | "permission_denied" | "insufficient_scope" | "model_not_found" | "unsupported_modality" | "context_length_exceeded" | "request_too_large" | "output_limit_exceeded" | "idempotency_conflict" | "insufficient_balance" | "spending_limit_exceeded" | "quota_exceeded" | "byok_credential_invalid" | "policy_violation" | "commercial_permission_denied" | "no_route_available" | "upstream_content_filtered" | "cancelled" | "rate_limited" | "deployment_unavailable" | "provider_error" | "provider_timeout" | "provider_overloaded" | "provider_credential_invalid" | "provider_billing_refused" | "service_unavailable" | "internal_error";
+    message: string;
+    schemaVersion: 1;
+    requestId: string;
+    retryable: boolean;
+    retryAfterMs?: number | undefined;
+    param?: string | undefined;
+    upstreamCategory?: "unknown" | "authentication" | "invalid_request" | "rate_limit" | "quota" | "timeout" | "overloaded" | "server_error" | "content_filter" | undefined;
+    providerError?: {
+        provider: string;
+        code?: string | undefined;
+        message?: string | undefined;
+        status?: number | undefined;
+    } | undefined;
+}>, {
+    code: "invalid_request" | "authentication_failed" | "permission_denied" | "insufficient_scope" | "model_not_found" | "unsupported_modality" | "context_length_exceeded" | "request_too_large" | "output_limit_exceeded" | "idempotency_conflict" | "insufficient_balance" | "spending_limit_exceeded" | "quota_exceeded" | "byok_credential_invalid" | "policy_violation" | "commercial_permission_denied" | "no_route_available" | "upstream_content_filtered" | "cancelled" | "rate_limited" | "deployment_unavailable" | "provider_error" | "provider_timeout" | "provider_overloaded" | "provider_credential_invalid" | "provider_billing_refused" | "service_unavailable" | "internal_error";
+    message: string;
+    schemaVersion: 1;
+    requestId: string;
+    retryable: boolean;
+    retryAfterMs?: number | undefined;
+    param?: string | undefined;
+    upstreamCategory?: "unknown" | "authentication" | "invalid_request" | "rate_limit" | "quota" | "timeout" | "overloaded" | "server_error" | "content_filter" | undefined;
+    providerError?: {
+        provider: string;
+        code?: string | undefined;
+        message?: string | undefined;
+        status?: number | undefined;
+    } | undefined;
+}, {
+    code: "invalid_request" | "authentication_failed" | "permission_denied" | "insufficient_scope" | "model_not_found" | "unsupported_modality" | "context_length_exceeded" | "request_too_large" | "output_limit_exceeded" | "idempotency_conflict" | "insufficient_balance" | "spending_limit_exceeded" | "quota_exceeded" | "byok_credential_invalid" | "policy_violation" | "commercial_permission_denied" | "no_route_available" | "upstream_content_filtered" | "cancelled" | "rate_limited" | "deployment_unavailable" | "provider_error" | "provider_timeout" | "provider_overloaded" | "provider_credential_invalid" | "provider_billing_refused" | "service_unavailable" | "internal_error";
+    message: string;
+    schemaVersion: 1;
+    requestId: string;
+    retryable: boolean;
+    retryAfterMs?: number | undefined;
+    param?: string | undefined;
+    upstreamCategory?: "unknown" | "authentication" | "invalid_request" | "rate_limit" | "quota" | "timeout" | "overloaded" | "server_error" | "content_filter" | undefined;
+    providerError?: {
+        provider: string;
+        code?: string | undefined;
+        message?: string | undefined;
+        status?: number | undefined;
+    } | undefined;
+}>;
+export type InferenceErrorCode = z.infer<typeof inferenceErrorCodeSchema>;
+export type UpstreamErrorCategory = z.infer<typeof upstreamErrorCategorySchema>;
+export type ProviderErrorPassthrough = z.infer<typeof providerErrorPassthroughSchema>;
+export type InferenceError = z.infer<typeof inferenceErrorSchema>;

package/dist/types/inference/identifiers.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Identifiers, references and wire primitives shared by every Oxy↔data-plane
+ * inference contract.
+ *
+ * Two kinds of identifier live here, and the difference matters:
+ *
+ *  - **Principal identifiers** owned by Oxy (`accountId`, `applicationId`,
+ *    `credentialId`, the optional delegated `userId`). The data plane may store
+ *    them as immutable references; it never owns, mints or mutates them.
+ *  - **Catalogue references** (`<publisher>/<model>`, `<publisher>/<model>@<revision>`,
+ *    a routing-profile slug). These are the strings a customer types, so their
+ *    grammar is part of the public contract, not an implementation detail.
+ *
+ * Platform-agnostic — zod only. Every regex here is plain ASCII: this package
+ * is imported by React Native apps running on Hermes, which rejects Unicode
+ * property escapes (`\p{…}`) at runtime.
+ *
+ * Decided in: docs/adr/0007-canonical-request-attribution.md, docs/adr/0008-catalogue-concept-separation.md.
+ */
+import { z } from 'zod';
+/**
+ * An Oxy account id — the account that owns the workload and is financially
+ * responsible for it.
+ *
+ * Branded, and that brand is load-bearing rather than decorative: it is the
+ * type-level half of the rule that a delegated end-user identity can never
+ * become the billing identity (see {@link delegatedUserIdSchema} and
+ * `billingPrincipalSchema`). A plain `string` — and therefore any id read out
+ * of a header, a JWT claim or a request body — is not assignable to it; the
+ * only way to obtain one is to parse a value through this schema.
+ */
+export declare const oxyAccountIdSchema: z.ZodBranded<z.ZodString, "OxyAccountId">;
+/**
+ * A delegated end-user identity (Alia's `X-Oxy-User-Id`), branded with a
+ * DIFFERENT brand from {@link oxyAccountIdSchema} so the two cannot be
+ * substituted for one another in either direction, in any consumer, without a
+ * cast that review would catch.
+ *
+ * It exists for attribution and product-side personalisation only. It is never
+ * a billing principal, never an access-control principal, and its presence
+ * never changes which account is charged.
+ */
+export declare const delegatedUserIdSchema: z.ZodBranded<z.ZodString, "DelegatedUserId">;
+/**
+ * An Oxy `Application._id`. Not branded: no invariant in this contract turns on
+ * confusing it with another id, and brand inflation costs every producer a
+ * parse call for no safety. The two ids above are branded because ADR 0007's
+ * rule is exactly that they must not be interchangeable.
+ */
+export declare const oxyApplicationIdSchema: z.ZodString;
+/** An Oxy `ApplicationCredential._id` — the credential used for this request. */
+export declare const oxyCredentialIdSchema: z.ZodString;
+/**
+ * A request id allocated by the Oxy EDGE, at admission and BEFORE
+ * authentication, so that a request rejected for a bad credential is as
+ * traceable as one that was served (ADR 0007, and step 1 of ADR 0010's edge
+ * order). It is required on the inbound envelope, which is what makes the data
+ * plane a consumer of this id rather than its source: the data plane echoes it
+ * on every stream event, on the usage report, in its response header and on
+ * anything it can be asked about later. It never mints one for a request it
+ * received.
+ *
+ * The one case that is NOT an exception to that: an envelope the data plane
+ * cannot read or authenticate carries no id to echo, so its rejection is
+ * labelled with an id of the data plane's own — visibly local, and never
+ * correlated with an Oxy request, because there is no Oxy request it belongs to.
+ * Saying so is what stops "consumer, not source" from being read as forbidding
+ * the only id such a rejection could have.
+ *
+ * Correlates the Oxy edge, the data plane, the financial ledger and the
+ * customer-visible receipt, so it appears on every stream event and every
+ * ledger record.
+ */
+export declare const requestIdSchema: z.ZodString;
+/**
+ * A generation id generated by the data plane, present when a request produced
+ * a generation that can be looked up later (`GET /v1/generations/:id`).
+ */
+export declare const generationIdSchema: z.ZodString;
+/**
+ * A caller-supplied idempotency key. Every reserve/settle/refund call is keyed
+ * on one so a retry, a redelivered event or a duplicated webhook can never
+ * charge twice.
+ */
+export declare const idempotencyKeySchema: z.ZodString;
+/** Credential environments. A credential is issued into exactly one of them. */
+export declare const inferenceEnvironmentSchema: z.ZodEnum<["development", "staging", "production"]>;
+/**
+ * An instant, as an ISO 8601 string in UTC (`2026-08-15T09:41:00.000Z`).
+ *
+ * Validated rather than left free-form — unlike the session contracts, which
+ * carry legacy expiry strings no consumer interprets, every instant here is
+ * read: a reservation expires, a price version starts applying, a receipt is
+ * settled. One canonical spelling (UTC, `Z`) so two records that describe the
+ * same moment compare and sort as equal, which a mix of offsets would not.
+ */
+export declare const inferenceTimestampSchema: z.ZodString;
+/**
+ * A calendar DATE with no instant attached (`2026-05-01`) — a knowledge cutoff
+ * or a release date, which are published as days and become wrong when a
+ * timezone is invented for them.
+ */
+export declare const inferenceDateSchema: z.ZodString;
+/** An absolute https URL, for model cards, licenses and provider documentation. */
+export declare const inferenceHttpsUrlSchema: z.ZodString;
+/**
+ * A content digest, `sha256:<64 lowercase hex>`.
+ *
+ * ONE spelling, because a digest is compared for equality and nothing else: an
+ * uppercase or unprefixed variant of the same hash is a different string, so two
+ * records describing the same bytes would not match. Lowercase hex with the
+ * algorithm prefix is what the `inference_model_revisions` CHECK stores and what
+ * every artifact registry emits.
+ */
+export declare const sha256DigestSchema: z.ZodString;
+/** A publisher slug, e.g. `openai`, `anthropic`, `meta`, `alia`. */
+export declare const publisherSlugSchema: z.ZodString;
+/** A model slug within its publisher's namespace, e.g. `gpt-5`, `llama-3.1-70b`. */
+export declare const modelSlugSchema: z.ZodString;
+/**
+ * A canonical model id, `<publisher>/<model>`. This names a MODEL — a
+ * long-lived product identity whose behaviour changes as revisions ship. It
+ * does not name a revision, a deployment or a provider.
+ */
+export declare const modelIdSchema: z.ZodString;
+/** An immutable revision label, unique within its model, e.g. `2026-05-01`. */
+export declare const modelRevisionLabelSchema: z.ZodString;
+/**
+ * A model reference as a customer writes it: `<publisher>/<model>` (the model's
+ * current revision, chosen by Oxy) or `<publisher>/<model>@<revision>` (an
+ * immutable revision the customer pinned).
+ *
+ * Both forms name a CONCRETE MODEL. Neither can name a routing profile — see
+ * {@link routingProfileSlugSchema} — which is what makes "a request for a
+ * concrete model is never silently replaced with a different model" a
+ * distinction the type system can carry rather than a convention.
+ */
+export declare const modelReferenceSchema: z.ZodString;
+/**
+ * A routing-profile slug, e.g. `auto`, `fast`, `quality`.
+ *
+ * Deliberately refuses a `/`, so a profile can never be written in the shape of
+ * a model id and no caller can be confused about whether they asked for a
+ * concrete model or for Oxy to choose one. Modes like `auto`/`fast`/`quality`
+ * are profiles or product presets; they are never model objects.
+ */
+export declare const routingProfileSlugSchema: z.ZodString;
+/**
+ * The opaque PostgreSQL identity of one routing profile.
+ *
+ * No trim, case-folding or format heuristic: callers selecting by id must name
+ * the exact stored bytes. The database lookup is the authority for existence.
+ */
+export declare const routingProfileIdSchema: z.ZodString;
+/** An inference provider slug, e.g. `openai`, `bedrock`, `oxy-hosted`. */
+export declare const inferenceProviderSlugSchema: z.ZodString;
+/**
+ * A deployment/endpoint id. Opaque to customers: which concrete endpoint served
+ * a request is the data plane's operational detail, and only the customer-safe
+ * subset of it is ever attributed back (see the catalogue's serving-boundary
+ * rules).
+ */
+export declare const deploymentIdSchema: z.ZodString;
+/**
+ * A region identifier, e.g. `us-west-2`, `eu-central-1`. Free-form rather than
+ * a closed enum because the set is provider-defined and grows without any
+ * contract change; residency policies match on exact strings.
+ */
+export declare const inferenceRegionSchema: z.ZodString;
+/**
+ * The publisher namespace reserved for models Alia actually owns or derives.
+ *
+ * `alia/*` is never a re-badged third-party route and never a prompt preset —
+ * enforcing that is the job of `modelSchema`'s provenance refinement, which
+ * this constant exists to be checked against.
+ */
+export declare const RESERVED_ALIA_PUBLISHER = "alia";
+export type OxyAccountId = z.infer<typeof oxyAccountIdSchema>;
+export type DelegatedUserId = z.infer<typeof delegatedUserIdSchema>;
+export type InferenceEnvironment = z.infer<typeof inferenceEnvironmentSchema>;
+export type ModelReference = z.infer<typeof modelReferenceSchema>;
+export type ModelId = z.infer<typeof modelIdSchema>;