@oh-my-pi/pi-ai 18.2.7 → 18.2.8

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [18.2.8] - 2026-09-21
+
+### Added
+
+- Added support for text embeddings, document reranking, video generation, image generation across multiple providers, audio speech synthesis, and audio transcription services.
+- Added support for the System One judgment API, including configurable request headers for proxy routing and custom authentication.
+
+### Changed
+
+- Updated API response cost reporting to use aggregate usage totals.
+- Model list responses now optionally include a model kind.
+
+### Fixed
+
+- Fixed detection of Claude usage-limit errors.
+
 ## [18.2.7] - 2026-09-21
 
 ### Breaking Changes

package/dist/types/auth-gateway/dispatch.d.ts

@@ -0,0 +1,80 @@
+import type { ApiKeyResolver } from "../auth-retry.js";
+import type { AuthStorage } from "../auth-storage.js";
+import { type GatewayErrorClassification } from "../error/gateway.js";
+import type { Api, FetchImpl, Model, Usage } from "../types.js";
+import type { ClientUsageIdentity } from "../usage.js";
+import type { AuthGatewayServerOptions } from "./types.js";
+export type ModelResolver = (modelId: string) => Model<Api> | undefined;
+export interface AuthGatewayBootOptions extends AuthGatewayServerOptions {
+    /** Source of credentials. Caller wires this to a broker-backed AuthStorage. */
+    storage: AuthStorage;
+    /**
+     * Resolve a client-requested model id to a pi-ai Model. Caller supplies
+     * this from a ModelRegistry (lives in `coding-agent` to avoid an inverse
+     * dependency in `pi-ai`).
+     */
+    resolveModel: ModelResolver;
+    /** Optional supplier for `/v1/models` listing. Returns the full model array. */
+    listModels?: () => Iterable<Model<Api>>;
+    /** Upstream transport for every provider call; defaults to global `fetch`. Test seam. */
+    fetch?: FetchImpl;
+}
+/**
+ * The client's own session key, or `undefined` when it sent none. A blank key
+ * counts as none: honouring it would collapse every caller that sends an empty
+ * key into one shared credential-sticky, prefix-cache and provider-session
+ * bucket.
+ */
+export declare function normalizeClientSessionKey(clientKey: string | undefined): string | undefined;
+/**
+ * Stable identity of the account a request's credential belongs to.
+ *
+ * `markUsageLimitReached` and the auth-retry resolver switch a session to a
+ * sibling credential, so the provider state retained for that session can
+ * outlive the account that taught it. OAuth rows expose an account id / email
+ * that survives token refresh — fingerprinting the bearer instead would look
+ * like a rotation every time a token refreshes and discard the retained
+ * lessons for nothing. Key-based rows fall back to a hash of the key, never
+ * the key itself: this value is held for the lifetime of the entry.
+ */
+export declare function resolveGatewayAccount(storage: AuthStorage, provider: string, sessionId: string, apiKey: string): string;
+/**
+ * Resolve the credential for one request from broker-backed storage.
+ *
+ * pi-ai clients never consult `AuthStorage`; the gateway resolves the bearer
+ * (an OAuth access token refreshed through the broker when needed) and hands
+ * it to the client. Returns the key, or the error classification the route
+ * should encode in its own envelope: storage failures map through
+ * {@link classifyGatewayError}, a provider without any credential is a 401.
+ */
+export declare function resolveGatewayApiKey(storage: AuthStorage, model: Model<Api>, sessionId: string, signal: AbortSignal, peer: string): Promise<string | GatewayErrorClassification>;
+/**
+ * Build the {@link ApiKeyResolver} handed to a pi-ai client for a gateway
+ * request. Drives the central a/b/c auth-retry policy server-side:
+ *
+ * - initial resolve → the credential already resolved for this request.
+ * - step (b) `!lastChance` → force-refresh the SAME session-sticky credential
+ *   (a peer/broker may have rotated its token out from under our cached copy).
+ * - step (c) `lastChance` → {@link refreshGatewayApiKeyAfterAuthError} switches
+ *   to a sibling (usage-limit block vs credential invalidation by error class).
+ *
+ * `lastKey` tracks the most recent bearer so the switch step invalidates the
+ * credential that actually failed. `onResolvedKey` observes every rotation;
+ * routes that retain provider session state use it to re-key the account
+ * lease, one-shot routes pass `undefined`.
+ */
+export declare function buildGatewayApiKeyResolver(storage: AuthStorage, model: Model<Api>, sessionId: string, initialKey: string, requestSignal: AbortSignal, format: string, peer: string, onResolvedKey?: (apiKey: string) => void): ApiKeyResolver;
+/**
+ * Attribute one settled upstream request to the originating client via the
+ * broker's observed-usage channel (`AuthStorage.recordObservedUsage`, batched
+ * by the remote store). Error/aborted turns still record — the provider
+ * billed whatever tokens the partial turn consumed; zero-usage results
+ * (pre-flight failures) are skipped. `at` defaults to now.
+ */
+export declare function recordGatewayUsage(storage: AuthStorage, model: Model<Api>, client: ClientUsageIdentity, usage: Usage, at?: number): void;
+/**
+ * An `AbortController` that follows the inbound request's abort signal. Routes
+ * abort it themselves when the response body is cancelled mid-stream, which
+ * `req.signal` alone does not observe.
+ */
+export declare function mirrorRequestAbort(req: Request): AbortController;

package/dist/types/auth-gateway/http.d.ts

@@ -1,4 +1,4 @@
-import type { Api, AssistantMessage, Model } from "../types.js";
+import type { Api, Model } from "../types.js";
 import type { ClientUsageIdentity } from "../usage.js";
 export declare function json(status: number, body: unknown, headers?: Record<string, string>): Response;
 /**
@@ -7,14 +7,13 @@ export declare function json(status: number, body: unknown, headers?: Record<str
  * `request-id` (surfaced as `_request_id` by the OpenAI and Anthropic SDKs,
  * matches the gateway log line), LiteLLM's model-resolution and cost headers,
  * and OpenAI's `openai-processing-ms`. Model/request-id headers are always
- * present; `message` — the final assistant message, available only on
- * non-streaming responses — adds the computed cost, and `startedAt` the wall
- * time. Streaming responses send headers before usage exists, so they carry
- * only the identity headers.
+ * present; `costUsd` — known only once a non-streaming response has settled —
+ * adds the computed cost, and `startedAt` the wall time. Streaming responses
+ * send headers before usage exists, so they carry only the identity headers.
  */
 export declare function gatewayResponseHeaders(model: Model<Api>, info: {
     requestId: string;
-    message?: AssistantMessage;
+    costUsd?: number;
     startedAt?: number;
 }): Record<string, string>;
 export declare function resolvePeer(req: Request): string;

package/dist/types/auth-gateway/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./dispatch.js";
 export * from "./http.js";
 export * from "./session-state.js";
 export * from "./server.js";

package/dist/types/auth-gateway/routes/embeddings.d.ts

@@ -0,0 +1,3 @@
+import { type AuthGatewayBootOptions } from "../dispatch.js";
+/** OpenAI-compatible `POST /v1/embeddings` gateway handler. */
+export declare function handleEmbeddings(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/images.d.ts

@@ -0,0 +1,3 @@
+import { type AuthGatewayBootOptions } from "../dispatch.js";
+export declare function handleImageGenerations(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
+export declare function handleImageEdits(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/rerank.d.ts

@@ -0,0 +1,3 @@
+import { type AuthGatewayBootOptions } from "../dispatch.js";
+/** OpenRouter-compatible `POST /v1/rerank` gateway handler. */
+export declare function handleRerank(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/speech.d.ts

@@ -0,0 +1,2 @@
+import { type AuthGatewayBootOptions } from "../dispatch.js";
+export declare function handleSpeech(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/systemone.d.ts

@@ -0,0 +1,2 @@
+import { type AuthGatewayBootOptions } from "../dispatch.js";
+export declare function handleSystemOne(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/transcriptions.d.ts

@@ -0,0 +1,3 @@
+import { type AuthGatewayBootOptions } from "../dispatch.js";
+/** OpenAI-compatible `POST /v1/audio/transcriptions` gateway handler. */
+export declare function handleTranscriptions(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;

package/dist/types/auth-gateway/routes/video.d.ts

@@ -0,0 +1,7 @@
+import { type AuthGatewayBootOptions } from "../dispatch.js";
+/** OpenRouter-compatible `POST /v1/videos` asynchronous video submit handler. */
+export declare function handleVideoSubmit(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response>;
+/** OpenRouter-compatible `GET /v1/videos/:id` asynchronous video poll handler. */
+export declare function handleVideoPoll(bootOpts: AuthGatewayBootOptions, req: Request, peer: string, gatewayId: string): Promise<Response>;
+/** OpenRouter-compatible `GET /v1/videos/:id/content` streaming video content handler. */
+export declare function handleVideoContent(bootOpts: AuthGatewayBootOptions, req: Request, peer: string, gatewayId: string): Promise<Response>;

package/dist/types/auth-gateway/server.d.ts

@@ -16,21 +16,15 @@
  *   POST /v1/chat/completions              → OpenAI chat-completions in/out
  *   POST /v1/messages                      → Anthropic messages in/out
  *   POST /v1/responses                     → OpenAI Responses in/out
+ *   POST /v1/pi/stream                     → native pi-ai stream in/out
+ *   POST /v1/systemone | /alpha/decisions  → TypeSafe System One judgments (routes/systemone)
+ *   POST /v1/images[/generations|/edits]   → image generation, OpenAI/OpenRouter wire (routes/images)
+ *   POST /v1/audio/speech                  → text-to-speech, raw audio out (routes/speech)
+ *   POST /v1/audio/transcriptions          → speech-to-text, multipart or JSON base64 in (routes/transcriptions)
+ *
+ * Chat routes live in this file; every other modality is a `routes/*` module
+ * built on the shared plumbing in `dispatch.ts`.
  */
-import type { AuthStorage } from "../auth-storage.js";
-import type { Api, Model } from "../types.js";
-import type { AuthGatewayServerHandle, AuthGatewayServerOptions } from "./types.js";
-export type ModelResolver = (modelId: string) => Model<Api> | undefined;
-export interface AuthGatewayBootOptions extends AuthGatewayServerOptions {
-    /** Source of credentials. Caller wires this to a broker-backed AuthStorage. */
-    storage: AuthStorage;
-    /**
-     * Resolve a client-requested model id to a pi-ai Model. Caller supplies
-     * this from a ModelRegistry (lives in `coding-agent` to avoid an inverse
-     * dependency in `pi-ai`).
-     */
-    resolveModel: ModelResolver;
-    /** Optional supplier for `/v1/models` listing. Returns the full model array. */
-    listModels?: () => Iterable<Model<Api>>;
-}
+import { type AuthGatewayBootOptions } from "./dispatch.js";
+import type { AuthGatewayServerHandle } from "./types.js";
 export declare function startAuthGateway(opts: AuthGatewayBootOptions): AuthGatewayServerHandle;

package/dist/types/embeddings/index.d.ts

@@ -0,0 +1,7 @@
+import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import { type EmbeddingOptions } from "./openai-embeddings.js";
+import type { EmbeddingRequest, EmbeddingResult } from "./types.js";
+export * from "./openai-embeddings.js";
+export * from "./types.js";
+/** Dispatch an embedding request through the transport selected by the catalog model. */
+export declare function embed(model: Model<Api>, request: EmbeddingRequest, options: EmbeddingOptions): Promise<EmbeddingResult>;

package/dist/types/embeddings/openai-embeddings.d.ts

@@ -0,0 +1,15 @@
+import type { Api, FetchImpl, Model } from "@oh-my-pi/pi-catalog/types";
+import { type ApiKey } from "../auth-retry.js";
+import * as AIError from "../error/index.js";
+import type { EmbeddingRequest, EmbeddingResult } from "./types.js";
+export interface EmbeddingOptions {
+    apiKey: ApiKey;
+    fetch?: FetchImpl;
+    signal?: AbortSignal;
+}
+/** Non-2xx response from an OpenAI-compatible embeddings endpoint. */
+export declare class EmbeddingApiError extends AIError.ProviderHttpError {
+    readonly name = "EmbeddingApiError";
+}
+/** Call an OpenAI/OpenRouter-compatible embeddings endpoint. */
+export declare function embedOpenAI(model: Model<Api>, request: EmbeddingRequest, options: EmbeddingOptions): Promise<EmbeddingResult>;

package/dist/types/embeddings/types.d.ts

@@ -0,0 +1,15 @@
+import type { Usage } from "@oh-my-pi/pi-catalog/types";
+export interface EmbeddingRequest {
+    input: string | string[] | number[] | number[][];
+    dimensions?: number;
+    encodingFormat: "float" | "base64";
+    user?: string;
+}
+export interface EmbeddingResult {
+    embeddings: Array<{
+        index: number;
+        embedding: number[] | string;
+    }>;
+    model: string;
+    usage: Usage;
+}

package/dist/types/images/google-antigravity.d.ts

@@ -0,0 +1,9 @@
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
+interface AntigravityCredentials {
+    accessToken: string;
+    projectId: string;
+}
+export declare function parseAntigravityCredentials(raw: string): AntigravityCredentials | undefined;
+export declare function generateAntigravityImage(model: Model, request: ImageGenerationRequest, options: ImageGenerationOptions): Promise<ImageGenerationResult>;
+export {};

package/dist/types/images/google-generative-ai.d.ts

@@ -0,0 +1,3 @@
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
+export declare function generateGoogleImage(model: Model, request: ImageGenerationRequest, options: ImageGenerationOptions): Promise<ImageGenerationResult>;

package/dist/types/images/index.d.ts

@@ -0,0 +1,14 @@
+import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
+export * from "./google-antigravity.js";
+export * from "./google-generative-ai.js";
+export * from "./openai-hosted.js";
+export * from "./openai-images.js";
+export * from "./openrouter-images.js";
+export * from "./types.js";
+/** Catalog APIs {@link generateImage} serves; the hosted Responses pair needs an explicit carrier model. */
+export type ImageGenerationApi = "openai-images" | "openrouter-images" | "google-generative-ai" | "google-gemini-cli" | "openai-responses" | "openai-codex-responses";
+/** Whether a catalog API generates images through one of the pi-ai image clients. */
+export declare function isImageGenerationApi(api: Api): api is ImageGenerationApi;
+/** Generate (or edit, when `request.inputImages` is set) images through the transport selected by the model's `api`. */
+export declare function generateImage(model: Model<Api>, request: ImageGenerationRequest, options: ImageGenerationOptions): Promise<ImageGenerationResult>;

package/dist/types/images/openai-hosted.d.ts

@@ -0,0 +1,3 @@
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
+export declare function generateHostedImage(model: Model, request: ImageGenerationRequest, options: ImageGenerationOptions): Promise<ImageGenerationResult>;

package/dist/types/images/openai-images.d.ts

@@ -0,0 +1,5 @@
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
+export declare const XAI_MAX_EDIT_IMAGES = 3;
+export declare function resolveXAIResolution(imageSize?: string): "1k" | "2k";
+export declare function generateOpenAIImage(model: Model, request: ImageGenerationRequest, options: ImageGenerationOptions): Promise<ImageGenerationResult>;

package/dist/types/images/openrouter-images.d.ts

@@ -0,0 +1,3 @@
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
+export declare function generateOpenRouterImage(model: Model, request: ImageGenerationRequest, options: ImageGenerationOptions): Promise<ImageGenerationResult>;

package/dist/types/images/shared.d.ts

@@ -0,0 +1,34 @@
+import type { FetchImpl, Model, Usage } from "@oh-my-pi/pi-catalog/types";
+import type { ApiKey } from "../auth-retry.js";
+import * as AIError from "../error/index.js";
+import type { GeneratedImage } from "./types.js";
+export declare class ImageApiError extends AIError.ProviderHttpError {
+    readonly name = "ImageApiError";
+}
+export declare function emptyUsage(input?: number, output?: number, cost?: number): Usage;
+export declare function usageFromWire(value: unknown): Usage;
+export declare function imageBaseUrl(model: Model): string;
+export declare function modelHeaders(model: Model, signal?: AbortSignal): Promise<Record<string, string>>;
+export declare function errorMessage(rawText: string): string;
+export declare function postJson(options: {
+    model: Model;
+    url: string;
+    body: unknown;
+    apiKey: ApiKey;
+    fetch: FetchImpl;
+    signal?: AbortSignal;
+}): Promise<unknown>;
+export declare function postMultipart(options: {
+    model: Model;
+    url: string;
+    body: FormData;
+    apiKey: ApiKey;
+    fetch: FetchImpl;
+    signal?: AbortSignal;
+}): Promise<unknown>;
+export declare function decodeImageResponse(value: unknown, fetch: FetchImpl, signal?: AbortSignal): Promise<{
+    images: GeneratedImage[];
+    usage: Usage;
+}>;
+export declare function toDataUrl(image: GeneratedImage): string;
+export declare function resolveOpenAIImageSize(aspectRatio?: string, imageSize?: string): string | undefined;

package/dist/types/images/types.d.ts

@@ -0,0 +1,31 @@
+import type { Api, FetchImpl, Model, Usage } from "@oh-my-pi/pi-catalog/types";
+import type { ApiKey } from "../auth-retry.js";
+export interface ImageInput {
+    data: string;
+    mimeType: string;
+}
+export interface ImageGenerationRequest {
+    prompt: string;
+    inputImages?: ImageInput[];
+    aspectRatio?: string;
+    imageSize?: string;
+    count?: number;
+}
+export interface GeneratedImage {
+    data: string;
+    mimeType: string;
+}
+export interface ImageGenerationResult {
+    images: GeneratedImage[];
+    text?: string;
+    usage: Usage;
+}
+export interface ImageGenerationOptions {
+    apiKey: ApiKey;
+    fetch?: FetchImpl;
+    signal?: AbortSignal;
+    /** Chat model that carries a Responses `image_generation` tool call. */
+    carrier?: Model<Api>;
+    /** Stable provider session id, used by the Codex Responses carrier. */
+    sessionId?: string;
+}

package/dist/types/index.d.ts

@@ -1,12 +1,18 @@
 export { type Type, type } from "@oh-my-pi/omptype";
 export * from "./api-registry.js";
 export type * from "./auth-broker/index.js";
-export type { AuthGatewayBootOptions, ModelResolver } from "./auth-gateway/server.js";
+export type { AuthGatewayBootOptions, ModelResolver } from "./auth-gateway/dispatch.js";
 export * from "./auth-gateway/types.js";
 export * from "./auth-retry.js";
 export * from "./auth-storage.js";
 export * from "./error/rate-limit.js";
+export * from "./embeddings/index.js";
+export * from "./images/index.js";
 export * from "./judgment/index.js";
+export * from "./rerank/index.js";
+export * from "./speech/index.js";
+export * from "./transcription/index.js";
+export * from "./video/index.js";
 export * from "./oneshot-retry.js";
 export * from "./provider-details.js";
 export * from "./provider-session-state.js";

package/dist/types/judgment/typesafe.d.ts

@@ -27,6 +27,8 @@ export interface TypeSafeJudgeOptions {
     baseUrl?: string;
     /** Defaults to {@link typesafeModel}. */
     model?: string;
+    /** Static headers attached to judgment requests (e.g. proxy routing, gateway auth). */
+    headers?: Record<string, string>;
     fetch?: FetchImpl;
     /** Per-attempt timeout; defaults to {@link DEFAULT_TIMEOUT_MS}. */
     timeoutMs?: number;

package/dist/types/providers/embeddings-server.d.ts

@@ -0,0 +1,32 @@
+import * as AIError from "../error/index.js";
+import type { EmbeddingRequest, EmbeddingResult } from "../embeddings/types.js";
+export declare const MAX_EMBEDDINGS_BODY_BYTES: number;
+export declare class EmbeddingsWireError extends AIError.ValidationError {
+    readonly status: number;
+    constructor(status: number, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface EmbeddingsParsedRequest {
+    modelId: string;
+    request: EmbeddingRequest;
+}
+/** Parse an OpenAI-compatible embeddings request with a bounded JSON body. */
+export declare function parseRequest(req: Request): Promise<EmbeddingsParsedRequest>;
+export interface EmbeddingsResponseBody {
+    object: "list";
+    data: Array<{
+        object: "embedding";
+        index: number;
+        embedding: number[] | string;
+    }>;
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+        cost?: number;
+    };
+}
+/** Encode a canonical result as an OpenAI/OpenRouter embeddings response. */
+export declare function encodeResponse(result: EmbeddingResult, requestedModelId: string): EmbeddingsResponseBody;
+export declare function formatError(status: number, errorType: string, message: string): Response;

package/dist/types/providers/images-server.d.ts

@@ -0,0 +1,22 @@
+import type { ImageGenerationRequest, ImageGenerationResult } from "../images/types.js";
+export type ImageRequestKind = "generations" | "edits";
+export interface ImagesParsedRequest {
+    modelId: string;
+    request: ImageGenerationRequest;
+}
+export interface ImagesResponseBody {
+    created: number;
+    data: Array<{
+        b64_json: string;
+        revised_prompt?: string;
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+        cost: number;
+    };
+}
+export declare function parseRequest(body: unknown | FormData, kind: ImageRequestKind): Promise<ImagesParsedRequest>;
+export declare function encodeResponse(result: ImageGenerationResult, _requestedModelId: string): ImagesResponseBody;
+export declare function formatError(status: number, errorType: string, message: string): Response;

package/dist/types/providers/rerank-server.d.ts

@@ -0,0 +1,35 @@
+import * as AIError from "../error/index.js";
+import type { RerankRequest, RerankResult } from "../rerank/types.js";
+export declare const MAX_RERANK_BODY_BYTES: number;
+export interface RerankObjectDocument {
+    text: string;
+}
+export type RerankWireDocument = string | RerankObjectDocument;
+export interface RerankParsedRequest {
+    modelId: string;
+    request: RerankRequest;
+    originalDocuments: RerankWireDocument[];
+}
+export declare class RerankWireError extends AIError.ValidationError {
+    readonly status: number;
+    constructor(status: number, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Parse an OpenRouter-compatible JSON rerank request. */
+export declare function parseRequest(req: Request): Promise<RerankParsedRequest>;
+export interface RerankResponseBody {
+    model: string;
+    results: Array<{
+        index: number;
+        relevance_score: number;
+        document?: RerankObjectDocument;
+    }>;
+    usage: {
+        total_tokens: number;
+        cost: number;
+    };
+}
+/** Encode a canonical result as the OpenRouter rerank response shape. */
+export declare function encodeResponse(result: RerankResult, requestedModelId: string, originalDocuments: readonly RerankWireDocument[], returnDocuments: boolean): RerankResponseBody;
+export declare function formatError(status: number, errorType: string, message: string): Response;

package/dist/types/providers/speech-server.d.ts

@@ -0,0 +1,8 @@
+import type { SpeechRequest, SpeechResult } from "../speech/types.js";
+export interface SpeechParsedRequest {
+    modelId: string;
+    request: SpeechRequest;
+}
+export declare function parseRequest(body: unknown, _headers?: Headers): SpeechParsedRequest;
+export declare function encodeResponse(result: SpeechResult, _requestedModelId: string): Response;
+export declare function formatError(status: number, errorType: string, message: string): Response;

package/dist/types/providers/systemone-server.d.ts

@@ -0,0 +1,26 @@
+import type { JudgmentRequest, JudgmentResult } from "../judgment/types.js";
+export interface SystemOneParsedRequest {
+    modelId: string;
+    request: JudgmentRequest;
+}
+/** `POST /v1/systemone` response body; `cost` (USD) appears only when the route billed one. */
+export interface SystemOneResponseBody {
+    model: string;
+    answers: JudgmentResult["answers"];
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cost?: number;
+    };
+}
+/**
+ * Validate the routing-relevant parts of a System One request body.
+ *
+ * @throws {AIError.ValidationError} naming the offending field when `model`,
+ * `state`, or `questions` is missing or malformed.
+ */
+export declare function parseRequest(body: unknown): SystemOneParsedRequest;
+/** Re-encode a judgment result in TypeSafe's response shape. */
+export declare function encodeResponse(result: JudgmentResult): SystemOneResponseBody;
+/** TypeSafe answers errors with a status code and a JSON body; the envelope mirrors the other gateway routes. */
+export declare function formatError(status: number, type: string, message: string): Response;

package/dist/types/providers/transcriptions-server.d.ts

@@ -0,0 +1,32 @@
+import * as AIError from "../error/index.js";
+import type { TranscriptionRequest, TranscriptionResult } from "../transcription/types.js";
+export declare const MAX_TRANSCRIPTION_BODY_BYTES: number;
+export declare class TranscriptionWireError extends AIError.ValidationError {
+    readonly status: number;
+    constructor(status: number, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface TranscriptionParsedRequest {
+    modelId: string;
+    request: TranscriptionRequest;
+}
+/** Parse either OpenAI multipart uploads or OpenRouter base64 JSON requests. */
+export declare function parseRequest(req: Request): Promise<TranscriptionParsedRequest>;
+export interface TranscriptionResponseBody {
+    text: string;
+    language?: string;
+    duration?: number;
+    segments?: TranscriptionResult["segments"];
+    words?: TranscriptionResult["words"];
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+        cost: number;
+        seconds?: number;
+    };
+}
+/** Encode a canonical result as the shared OpenAI/OpenRouter transcription response. */
+export declare function encodeResponse(result: TranscriptionResult): TranscriptionResponseBody;
+export declare function formatError(status: number, errorType: string, message: string): Response;

package/dist/types/providers/video-server.d.ts

@@ -0,0 +1,39 @@
+import * as AIError from "../error/index.js";
+import type { VideoGenerationRequest, VideoJob } from "../video/types.js";
+export declare class VideoWireError extends AIError.ValidationError {
+    readonly status: number;
+    constructor(status: number, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface VideoParsedRequest {
+    modelId: string;
+    request: VideoGenerationRequest;
+}
+export interface GatewayJobIdentity {
+    provider: string;
+    modelId: string;
+    upstreamId: string;
+}
+/** Parse and validate an OpenRouter-compatible video submit body. */
+export declare function parseRequest(body: unknown): VideoParsedRequest;
+/** Encode all provider/model routing needed to resolve a future poll without gateway state. */
+export declare function encodeGatewayJobId(identity: GatewayJobIdentity): string;
+/** Decode a stateless gateway job id, rejecting malformed or incomplete identities. */
+export declare function decodeGatewayJobId(id: string): GatewayJobIdentity;
+export interface VideoResponseBody {
+    id: string;
+    status: VideoJob["status"];
+    polling_url: string;
+    generation_id?: string;
+    unsigned_urls?: string[];
+    error?: string;
+    usage?: {
+        cost: number;
+    };
+}
+/** Rewrite a provider submit response so every future operation returns through this gateway. */
+export declare function encodeSubmitResponse(job: VideoJob, req: Request, gatewayId: string): VideoResponseBody;
+/** Rewrite a provider poll response so content URLs and polling stay on this gateway. */
+export declare function encodePollResponse(job: VideoJob, req: Request, gatewayId: string): VideoResponseBody;
+export declare function formatError(status: number, errorType: string, message: string): Response;

package/dist/types/rerank/index.d.ts

@@ -0,0 +1,7 @@
+import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import { type RerankOptions } from "./openrouter-rerank.js";
+import type { RerankRequest, RerankResult } from "./types.js";
+export * from "./openrouter-rerank.js";
+export * from "./types.js";
+/** Dispatch reranking through the transport selected by the catalog model. */
+export declare function rerank(model: Model<Api>, request: RerankRequest, options: RerankOptions): Promise<RerankResult>;

package/dist/types/rerank/openrouter-rerank.d.ts

@@ -0,0 +1,15 @@
+import type { Api, FetchImpl, Model } from "@oh-my-pi/pi-catalog/types";
+import { type ApiKey } from "../auth-retry.js";
+import * as AIError from "../error/index.js";
+import type { RerankRequest, RerankResult } from "./types.js";
+export interface RerankOptions {
+    apiKey: ApiKey;
+    fetch?: FetchImpl;
+    signal?: AbortSignal;
+}
+/** Non-2xx response from an OpenRouter-compatible rerank endpoint. */
+export declare class RerankApiError extends AIError.ProviderHttpError {
+    readonly name = "RerankApiError";
+}
+/** Call an OpenRouter-compatible rerank endpoint. */
+export declare function rerankOpenRouter(model: Model<Api>, request: RerankRequest, options: RerankOptions): Promise<RerankResult>;