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

package/dist/types/providers/claude-code-fingerprint.d.ts

@@ -7,12 +7,31 @@
  * `registry` → `registry/oauth/anthropic` → back into the still-initializing
  * provider module.
  */
-/** Current Claude Code CLI version represented on the Anthropic wire. */
-export declare const claudeCodeVersion = "2.1.257";
+/**
+ * Pinned Claude Code CLI version: the offline fallback for {@link getClaudeCodeVersion}.
+ * Bumped to the latest npm release by `bun run check-spoofed-versions --update`.
+ */
+export declare const DEFAULT_CLAUDE_CODE_VERSION = "2.1.280";
 /** `@anthropic-ai/sdk` version bundled by the current Claude Code release. */
 export declare const claudeCodeSdkVersion = "0.112.1";
+/**
+ * Claude Code CLI version represented on the Anthropic wire (User-Agent, billing
+ * header): `PI_AI_CLAUDE_CODE_VERSION` → version adopted from a server rejection
+ * (see {@link adoptRequiredClaudeCodeVersion}) → {@link DEFAULT_CLAUDE_CODE_VERSION}.
+ */
+export declare function getClaudeCodeVersion(): string;
 /** User-Agent emitted by Claude Code's CLI inference entrypoint. */
-export declare const claudeCodeUserAgent = "claude-cli/2.1.257 (external, cli)";
+export declare function getClaudeCodeUserAgent(): string;
+/**
+ * Adopts the minimum version named by an Anthropic `claude_code_version_too_old`
+ * rejection for the rest of the process, so the pinned fallback going stale costs
+ * one rejected request instead of a hard failure.
+ *
+ * Returns true only when the wire version actually increased — callers retry on
+ * true, so a repeated rejection at the same version cannot loop. Always false
+ * while `PI_AI_CLAUDE_CODE_VERSION` pins the version explicitly.
+ */
+export declare function adoptRequiredClaudeCodeVersion(error: unknown): boolean;
 /** Prefix used to isolate custom Anthropic OAuth tools from built-in tools. */
 export declare const claudeToolPrefix: string;
 /** Identity block prepended by Claude Code's CLI runtime. */

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/google-gemini-cli.d.ts

@@ -95,9 +95,7 @@ interface CloudCodeAssistRequest {
             temperature?: number;
             topP?: number;
             topK?: number;
-            minP?: number;
             presencePenalty?: number;
-            repetitionPenalty?: number;
             thinkingConfig?: ThinkingConfig;
         };
         tools?: {

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/openai-chat-server-schema.d.ts

@@ -1048,7 +1048,7 @@ export declare const openaiChatRequestSchema: import("@oh-my-pi/omptype").Fluent
     prediction?: unknown;
     presence_penalty?: number | undefined;
     prompt_cache_key?: unknown;
-    reasoning_effort?: "high" | "low" | "max" | "medium" | "minimal" | "xhigh" | undefined;
+    reasoning_effort?: "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | undefined;
     response_format?: unknown;
     safety_identifier?: unknown;
     seed?: number | undefined;
@@ -1263,7 +1263,7 @@ export declare const openaiChatRequestSchema: import("@oh-my-pi/omptype").Fluent
     prediction?: unknown;
     presence_penalty?: number | undefined;
     prompt_cache_key?: unknown;
-    reasoning_effort?: "high" | "low" | "max" | "medium" | "minimal" | "xhigh" | undefined;
+    reasoning_effort?: "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | undefined;
     response_format?: unknown;
     safety_identifier?: unknown;
     seed?: number | undefined;

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>;

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

@@ -0,0 +1,17 @@
+import type { Usage } from "@oh-my-pi/pi-catalog/types";
+export interface RerankRequest {
+    query: string;
+    documents: string[];
+    topN?: number;
+    returnDocuments?: boolean;
+}
+export interface RerankResultItem {
+    index: number;
+    relevanceScore: number;
+    document?: string;
+}
+export interface RerankResult {
+    results: RerankResultItem[];
+    model: string;
+    usage: Usage;
+}

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

@@ -0,0 +1,13 @@
+import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import type { SpeechOptions, SpeechRequest, SpeechResult } from "./types.js";
+export * from "./openai-speech.js";
+export * from "./transport.js";
+export * from "./types.js";
+export * from "./xai-tts.js";
+/** Catalog APIs {@link synthesizeSpeech} serves; the `tts` tool and the gateway gate on these. */
+export declare const SPEECH_APIS: readonly ["xai-tts", "openai-speech"];
+export type SpeechApi = (typeof SPEECH_APIS)[number];
+/** Whether a catalog API synthesizes speech through a cloud transport (local inference is tool-only). */
+export declare function isSpeechApi(api: Api): api is SpeechApi;
+/** Synthesize speech through the transport selected by the catalog model's `api`. */
+export declare function synthesizeSpeech(model: Model<Api>, request: SpeechRequest, options: SpeechOptions): Promise<SpeechResult>;

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

@@ -0,0 +1,3 @@
+import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import type { SpeechOptions, SpeechRequest, SpeechResult } from "./types.js";
+export declare function synthesizeOpenAiSpeech(model: Model<Api>, request: SpeechRequest, options: SpeechOptions): Promise<SpeechResult>;

package/dist/types/speech/transport.d.ts

@@ -0,0 +1,7 @@
+import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import * as AIError from "../error/index.js";
+import { type SpeechFormat, type SpeechOptions, type SpeechResult } from "./types.js";
+export declare class SpeechApiError extends AIError.ProviderHttpError {
+    readonly name = "SpeechApiError";
+}
+export declare function postSpeechRequest(model: Model<Api>, path: string, payload: Record<string, unknown>, format: SpeechFormat, options: SpeechOptions): Promise<SpeechResult>;

package/dist/types/speech/types.d.ts

@@ -0,0 +1,24 @@
+import type { FetchImpl, Usage } from "@oh-my-pi/pi-catalog/types";
+import type { ApiKey } from "../auth-retry.js";
+export declare const SPEECH_FORMATS: readonly ["mp3", "wav", "pcm", "opus", "aac", "flac"];
+export type SpeechFormat = (typeof SPEECH_FORMATS)[number];
+export declare const SPEECH_FORMAT_MIME_TYPES: Record<SpeechFormat, string>;
+export interface SpeechRequest {
+    text: string;
+    voice?: string;
+    format: SpeechFormat;
+    speed?: number;
+    sampleRate?: number;
+    bitRate?: number;
+    instructions?: string;
+}
+export interface SpeechResult {
+    audio: Uint8Array;
+    mimeType: string;
+    usage: Usage;
+}
+export interface SpeechOptions {
+    apiKey: ApiKey;
+    fetch?: FetchImpl;
+    signal?: AbortSignal;
+}

package/dist/types/speech/xai-tts.d.ts

@@ -0,0 +1,7 @@
+import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import type { SpeechOptions, SpeechRequest, SpeechResult } from "./types.js";
+export declare const DEFAULT_XAI_VOICE_ID = "eve";
+export declare const DEFAULT_XAI_SAMPLE_RATE = 24000;
+export declare const DEFAULT_XAI_BIT_RATE = 128000;
+export declare const XAI_MAX_TEXT_LENGTH = 15000;
+export declare function synthesizeXaiSpeech(model: Model<Api>, request: SpeechRequest, options: SpeechOptions): Promise<SpeechResult>;

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

@@ -0,0 +1,7 @@
+import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import { type TranscriptionOptions } from "./openai-transcriptions.js";
+import type { TranscriptionRequest, TranscriptionResult } from "./types.js";
+export * from "./openai-transcriptions.js";
+export * from "./types.js";
+/** Dispatch an audio transcription through the transport selected by the catalog model. */
+export declare function transcribeAudio(model: Model<Api>, request: TranscriptionRequest, options: TranscriptionOptions): Promise<TranscriptionResult>;

package/dist/types/transcription/openai-transcriptions.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 { TranscriptionRequest, TranscriptionResult } from "./types.js";
+export interface TranscriptionOptions {
+    apiKey: ApiKey;
+    fetch?: FetchImpl;
+    signal?: AbortSignal;
+}
+/** Non-2xx response from an OpenAI-compatible transcription endpoint. */
+export declare class TranscriptionApiError extends AIError.ProviderHttpError {
+    readonly name = "TranscriptionApiError";
+}
+/** Call an OpenAI/OpenRouter-compatible multipart transcription endpoint. */
+export declare function transcribeOpenAI(model: Model<Api>, request: TranscriptionRequest, options: TranscriptionOptions): Promise<TranscriptionResult>;

package/dist/types/transcription/types.d.ts

@@ -0,0 +1,41 @@
+import type { Usage } from "@oh-my-pi/pi-catalog/types";
+export type TranscriptionResponseFormat = "json" | "verbose_json";
+export type TranscriptionTimestampGranularity = "word" | "segment";
+export interface TranscriptionRequest {
+    audio: Uint8Array;
+    mimeType: string;
+    fileName?: string;
+    language?: string;
+    prompt?: string;
+    temperature?: number;
+    responseFormat: TranscriptionResponseFormat;
+    timestampGranularities?: TranscriptionTimestampGranularity[];
+}
+/** Provider-specific segment fields are preserved alongside the normalized timestamps and text. */
+export interface TranscriptionSegment {
+    id?: number | string;
+    start: number;
+    end: number;
+    text: string;
+    speaker?: number | string;
+    [key: string]: unknown;
+}
+/** Provider-specific word fields are preserved alongside the normalized timestamps and spelling. */
+export interface TranscriptionWord {
+    word: string;
+    start: number;
+    end: number;
+    speaker?: number | string;
+    confidence?: number;
+    [key: string]: unknown;
+}
+export interface TranscriptionResult {
+    text: string;
+    language?: string;
+    duration?: number;
+    segments?: TranscriptionSegment[];
+    words?: TranscriptionWord[];
+    /** Provider-billed audio duration, which may be present without verbose output. */
+    seconds?: number;
+    usage: Usage;
+}

package/dist/types/usage/claude-api.d.ts

@@ -0,0 +1,22 @@
+/** Canonical host for Claude's first-party account API. */
+export declare const DEFAULT_CLAUDE_API_BASE_URL = "https://api.anthropic.com";
+/** Canonical subscription usage and profile endpoint. */
+export declare const DEFAULT_CLAUDE_OAUTH_BASE_URL = "https://api.anthropic.com/api/oauth";
+/** OAuth protocol beta required by Claude's account routes. */
+export declare const CLAUDE_OAUTH_BETA = "oauth-2025-04-20";
+/**
+ * Normalize Messages (`/v1`) and OAuth (`/api/oauth`) endpoints to the common
+ * API root used by both usage and reset routes. Custom path prefixes survive.
+ */
+export declare function normalizeClaudeApiBaseUrl(baseUrl?: string): string;
+/** Resolve the OAuth API base while retaining a configured proxy path prefix. */
+export declare function claudeOAuthBaseUrl(baseUrl?: string): string;
+/** Configured OAuth endpoint followed by canonical fallback, without duplicates. */
+export declare function claudeOAuthBaseUrls(baseUrl?: string): readonly string[];
+/** Resolve a first-party account route against the configured Claude API root. */
+export declare function claudeApiUrl(baseUrl: string | undefined, path: string): string;
+/** Shared OAuth and CLI identity headers for Claude usage, profile, and resets. */
+export declare function buildClaudeOAuthHeaders(accessToken: string, options?: {
+    beta?: string;
+    json?: boolean;
+}): Record<string, string>;

package/dist/types/usage/claude-reset.d.ts

@@ -0,0 +1,44 @@
+import type { UsageResetCredit, UsageResetCredits } from "../usage.js";
+import type { FetchImpl } from "../types.js";
+/** OAuth credential and transport used for an account's Claude reset operations. */
+export interface ClaudeResetAuth {
+    accessToken: string;
+    orgId?: string;
+    baseUrl?: string;
+    fetch: FetchImpl;
+    signal?: AbortSignal;
+}
+/** Live reset eligibility plus the exact organization and host used for redemption. */
+export interface ClaudeResetCreditList extends UsageResetCredits {
+    credits: UsageResetCredit[];
+    orgId?: string;
+    /** OAuth API base that answered discovery; pass back as consume `baseUrl`. */
+    baseUrl?: string;
+}
+/** Confirmed reset outcome; transport uncertainty never reports a successful spend. */
+export interface ClaudeResetConsumeResult {
+    ok: boolean;
+    code: string;
+    status: number;
+    cleared?: string[];
+    reason?: string;
+    raw?: unknown;
+}
+/**
+ * Reuse program blocks when a normal usage response actually includes them.
+ * A lone non-redeemable Cedar block is inconclusive because Juniper requires
+ * the separate at-wall read, so callers must still perform discovery.
+ *
+ * @internal
+ */
+export declare function parseClaudeResetCreditsFromUsagePayload(payload: unknown, orgId?: string, baseUrl?: string): ClaudeResetCreditList | null;
+/**
+ * Discover Claude's saved Cedar grant first, then its Juniper session reset.
+ * `null` means discovery failed; a zero-count object is an authoritative answer.
+ */
+export declare function listClaudeResetCredits(auth: ClaudeResetAuth): Promise<ClaudeResetCreditList | null>;
+/** Spend exactly the server-selected Claude reset. Mutation requests are never retried. */
+export declare function consumeClaudeResetCredit(auth: ClaudeResetAuth & {
+    credit: UsageResetCredit;
+    redeemRequestId?: string;
+}): Promise<ClaudeResetConsumeResult>;