@prometheus-ai/ai 0.5.4 → 0.5.8

package/dist/types/providers/openai-codex/response-handler.d.ts

@@ -1,3 +1,4 @@
+import { ProviderHttpError } from "../../errors";
 export type CodexRateLimit = {
     used_percent?: number;
     window_minutes?: number;
@@ -10,8 +11,16 @@ export type CodexRateLimits = {
 export type CodexErrorInfo = {
     message: string;
     status: number;
+    /** Machine-readable error code (`error.code` or `error.type` from the response body), when present. */
+    code?: string;
     friendlyMessage?: string;
     rateLimits?: CodexRateLimits;
     raw?: string;
 };
+/** Non-2xx response from the Codex backend, with the parsed body retained. */
+export declare class CodexApiError extends ProviderHttpError {
+    readonly info: CodexErrorInfo;
+    constructor(info: CodexErrorInfo, headers?: Headers);
+    static fromResponse(response: Response): Promise<CodexApiError>;
+}
 export declare function parseCodexError(response: Response): Promise<CodexErrorInfo>;

package/dist/types/providers/openai-codex-responses.d.ts

@@ -1,16 +1,45 @@
-import type { ResponseInput } from "openai/resources/responses/responses";
 import { type Context, type Model, type ProviderSessionState, type ServiceTier, type StreamFunction, type StreamOptions, type Tool, type ToolChoice } from "../types";
+import { type CodexReasoningContext } from "./openai-codex/request-transformer";
+import type { ResponseInput } from "./openai-responses-wire";
 export interface OpenAICodexResponsesOptions extends StreamOptions {
     reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
     reasoningSummary?: "auto" | "concise" | "detailed" | null;
+    /** `reasoning.context` replay scope. Defaults to `all_turns` under {@link OpenAICodexResponsesOptions.responsesLite}, otherwise omitted (server default is `current_turn`). */
+    reasoningContext?: CodexReasoningContext;
     textVerbosity?: "low" | "medium" | "high";
     include?: string[];
     codexMode?: boolean;
     toolChoice?: ToolChoice;
     preferWebsockets?: boolean;
     serviceTier?: ServiceTier;
+    /**
+     * Opt into the Responses Lite transport contract. Sends
+     * `x-openai-internal-codex-responses-lite: true` on HTTP requests and on the
+     * WebSocket upgrade (the marker is connection-scoped there, so lite and
+     * non-lite turns never share a pooled socket), strips image detail from
+     * input, and defaults `reasoning.context` to `all_turns` — mirroring codex-rs.
+     */
+    responsesLite?: boolean;
+    /**
+     * Extra `client_metadata` to include in the request body on both transports.
+     * The canonical Codex envelope is `client_metadata["x-codex-turn-metadata"]`
+     * (JSON string of thread/turn identifiers); flat keys are also accepted.
+     */
+    clientMetadata?: Record<string, string>;
+    /**
+     * Invoked when the server streams a `response.metadata` event carrying
+     * ChatGPT moderation metadata (`metadata.openai_chatgpt_moderation_metadata`)
+     * for first-party presentation parity. Diagnostic observer: failures are
+     * swallowed and must not alter the stream.
+     */
+    onModerationMetadata?: (metadata: unknown) => void;
 }
 type CodexTransport = "sse" | "websocket";
+/**
+ * Per-session request-shape counters. Despite the name, these cover both
+ * transports: once stateful SSE chaining is enabled, SSE requests are counted
+ * too (the shared chained-request builder records every request it shapes).
+ */
 export interface OpenAICodexWebSocketDebugStats {
     fullContextRequests: number;
     deltaRequests: number;
@@ -21,7 +50,7 @@ export interface OpenAICodexWebSocketDebugStats {
 /** @internal Exported for tests. */
 export declare function normalizeCodexToolChoice(choice: ToolChoice | undefined, tools?: Tool[], model?: Model<"openai-codex-responses">): string | Record<string, unknown> | undefined;
 export declare const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses">;
-export declare function prewarmOpenAICodexResponses(model: Model<"openai-codex-responses">, options?: Pick<OpenAICodexResponsesOptions, "apiKey" | "headers" | "sessionId" | "signal" | "preferWebsockets" | "providerSessionState">): Promise<void>;
+export declare function prewarmOpenAICodexResponses(model: Model<"openai-codex-responses">, options?: Pick<OpenAICodexResponsesOptions, "apiKey" | "headers" | "sessionId" | "signal" | "preferWebsockets" | "providerSessionState" | "responsesLite">): Promise<void>;
 export interface OpenAICodexTransportDetails {
     websocketPreferred: boolean;
     lastTransport?: CodexTransport;

package/dist/types/providers/openai-completions-compat.d.ts

@@ -1,27 +1,4 @@
-import type { Model, OpenAICompat } from "../types";
-type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
-export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "cacheControlFormat" | "thinkingKeep">> & {
-    openRouterRouting?: OpenAICompat["openRouterRouting"];
-    vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
-    extraBody?: OpenAICompat["extraBody"];
-    cacheControlFormat?: OpenAICompat["cacheControlFormat"];
-    thinkingKeep?: OpenAICompat["thinkingKeep"];
-    toolStrictMode: ResolvedToolStrictMode;
-};
-/**
- * Detect compatibility settings from provider and baseUrl for known providers.
- * Provider takes precedence over URL-based detection since it's explicitly configured.
- * @param model - The model configuration
- * @param resolvedBaseUrl - Optional resolved base URL (e.g., after GitHub Copilot proxy-ep resolution).
- *                           If provided, this takes precedence over model.baseUrl for URL-based checks.
- */
+import type { Model, ResolvedOpenAICompat } from "../types";
+export type { ResolvedOpenAICompat };
 export declare function detectOpenAICompat(model: Model<"openai-completions">, resolvedBaseUrl?: string): ResolvedOpenAICompat;
-/**
- * Resolve compatibility settings by layering explicit model.compat overrides onto
- * the detected defaults. This is the canonical compat view for both metadata and transport.
- * @param model - The model configuration
- * @param resolvedBaseUrl - Optional resolved base URL (e.g., after GitHub Copilot proxy-ep resolution).
- *                           If provided, this takes precedence over model.baseUrl for URL-based checks.
- */
 export declare function resolveOpenAICompat(model: Model<"openai-completions">, resolvedBaseUrl?: string): ResolvedOpenAICompat;
-export {};

package/dist/types/providers/openai-completions.d.ts

@@ -1,6 +1,6 @@
-import type { ChatCompletionMessageParam } from "openai/resources/chat/completions";
+import type { ResolvedOpenAICompat } from "@prometheus-ai/catalog/types";
 import { type AssistantMessage, type Context, type Model, type ServiceTier, type StreamFunction, type StreamOptions, type ToolChoice } from "../types";
-import { type ResolvedOpenAICompat } from "./openai-completions-compat";
+import type { ChatCompletionMessageParam } from "./openai-chat-wire";
 /**
  * Identify "real progress" stream chunks vs. keepalives, role-only preambles,
  * and empty `{choices:[]}` no-ops emitted by some OpenAI-compatible endpoints.
@@ -41,14 +41,6 @@ export interface OpenAICompletionsOptions extends StreamOptions {
  * Exported for unit testing.
  */
 export declare function applyOpenRouterRoutingVariant(modelId: string, variant: string | undefined): string;
-/** Returns the widened OpenAI stream watchdog floor for slow GLM coding-plan reasoning models. */
-export declare function getOpenAICompletionsStreamIdleTimeoutFallbackMs(model: Model<"openai-completions">): number | undefined;
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
 export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined): AssistantMessage["usage"];
 export declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompat): ChatCompletionMessageParam[];
-/**
- * Detect compatibility settings from provider and baseUrl for known providers.
- * Provider takes precedence over URL-based detection since it's explicitly configured.
- * Returns a fully resolved OpenAICompat object with all fields set.
- */
-export declare function detectCompat(model: Model<"openai-completions">): ResolvedOpenAICompat;

package/dist/types/providers/openai-responses-server-schema.d.ts

@@ -7,8 +7,8 @@
  * Real clients (codex, openai-python, llm-git) routinely send these and a 400
  * is a worse outcome than dropping them on the floor.
  */
-import type { EasyInputMessage, ResponseCreateParams, ResponseFunctionToolCall, ResponseInputContent, ResponseInputItem, ResponseOutputMessage, ResponseReasoningItem, Tool as ResponsesTool } from "openai/resources/responses/responses";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
+import type { EasyInputMessage, ResponseCreateParams, ResponseFunctionToolCall, ResponseInputContent, ResponseInputItem, ResponseOutputMessage, ResponseReasoningItem, Tool as ResponsesTool } from "./openai-responses-wire";
 declare const inputImageBlockSchema: z.ZodObject<{
     type: z.ZodLiteral<"input_image">;
     detail: z.ZodOptional<z.ZodEnum<{
@@ -118,7 +118,7 @@ export declare const inputItemSchema: z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"reasoning_text">;
         text: z.ZodString;
     }, z.core.$strip>>>;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$loose>, z.ZodObject<{
     type: z.ZodLiteral<"function_call">;
     id: z.ZodOptional<z.ZodString>;
     call_id: z.ZodString;
@@ -279,7 +279,7 @@ export declare const openaiResponsesRequestSchema: z.ZodObject<{
             type: z.ZodLiteral<"reasoning_text">;
             text: z.ZodString;
         }, z.core.$strip>>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$loose>, z.ZodObject<{
         type: z.ZodLiteral<"function_call">;
         id: z.ZodOptional<z.ZodString>;
         call_id: z.ZodString;

package/dist/types/providers/openai-responses-server.d.ts

@@ -8,10 +8,10 @@
  * Spec: https://platform.openai.com/docs/api-reference/responses
  * Inverse direction (source-of-truth for item shapes): ../../providers/openai-responses.ts
  */
-import type { AuthGatewayParsedRequest as ParsedRequest } from "../auth-gateway/types";
+import type { AuthGatewayStreamControl, AuthGatewayParsedRequest as ParsedRequest } from "../auth-gateway/types";
 import type { AssistantMessage, AssistantMessageEventStream } from "../types";
 export type { ParsedRequest };
 export declare function parseRequest(body: unknown, headers?: Headers): ParsedRequest;
 export declare function formatError(status: number, type: string, message: string): Response;
 export declare function encodeResponse(message: AssistantMessage, requestedModelId: string): Record<string, unknown>;
-export declare function encodeStream(events: AssistantMessageEventStream, requestedModelId: string): ReadableStream<Uint8Array>;
+export declare function encodeStream(events: AssistantMessageEventStream, requestedModelId: string, _options?: ParsedRequest["options"], control?: AuthGatewayStreamControl): ReadableStream<Uint8Array>;

package/dist/types/providers/openai-responses-shared.d.ts

@@ -1,7 +1,6 @@
-import type OpenAI from "openai";
-import type { ResponseInput, ResponseInputContent, ResponseOutputItem } from "openai/resources/responses/responses";
 import { type Api, type AssistantMessage, type ImageContent, type Model, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ToolResultMessage } from "../types";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
+import type { ResponseCreateParamsStreaming, ResponseInput, ResponseInputContent, ResponseOutputItem, ResponseStatus, ResponseStreamEvent } from "./openai-responses-wire";
 export declare const OPENAI_RESPONSES_PROGRESS_EVENT_TYPES: ReadonlySet<string>;
 export declare function isOpenAIResponsesProgressEvent(event: unknown): boolean;
 export declare function encodeTextSignatureV1(id: string, phase?: TextSignatureV1["phase"]): string;
@@ -38,15 +37,38 @@ export declare function collectCustomCallIds(messages: ResponseInput): Set<strin
  * codex provider — issue #1351 / regression of #472.
  */
 export declare function repairOrphanResponsesToolOutputs(input: ResponseInput): ResponseInput;
+/**
+ * Synthesize a placeholder `function_call_output` / `custom_tool_call_output`
+ * for every `function_call` / `custom_tool_call` whose `call_id` has no matching
+ * output later in the same input. The Responses API rejects an unpaired call
+ * with `400 No tool output found for function call …`.
+ *
+ * Orphan calls surface when the user branches/navigates the session tree to a
+ * node that ends on a tool call (the tool-result child is excluded from the
+ * reconstructed history) or when a turn is aborted/crashes after the call
+ * streamed but before its result persisted. Dropping the call would erase the
+ * assistant's action; a placeholder output keeps the call visible so the model
+ * can recover (e.g. re-issue the call). Symmetric to
+ * {@link repairOrphanResponsesToolOutputs}.
+ */
+export declare function repairOrphanResponsesToolCalls(input: ResponseInput): ResponseInput;
 export declare function convertResponsesInputContent(content: string | Array<TextContent | ImageContent>, supportsImages: boolean): ResponseInputContent[] | undefined;
 export declare function convertResponsesAssistantMessage<TApi extends Api>(assistantMsg: AssistantMessage, model: Model<TApi>, msgIndex: number, knownCallIds: Set<string>, includeThinkingSignatures?: boolean, customCallIds?: Set<string>): ResponseInput;
 export declare function appendResponsesToolResultMessages<TApi extends Api>(messages: ResponseInput, toolResult: ToolResultMessage, model: Model<TApi>, strictResponsesPairing: boolean, knownCallIds: ReadonlySet<string>, customCallIds?: ReadonlySet<string>): void;
 export interface ProcessResponsesStreamOptions {
     onFirstToken?: () => void;
     onOutputItemDone?: (item: ResponseOutputItem) => void;
+    /**
+     * Called when a terminal `response.completed` or `response.incomplete` event
+     * is successfully processed. Only invoked on the successful-completion path;
+     * thrown failure (`response.failed`) and cancellation paths never call this.
+     * Used by callers to detect premature stream closure (i.e. the stream ended
+     * without a recognized terminal event).
+     */
+    onCompleted?: () => void;
 }
-export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<void>;
-export declare function mapOpenAIResponsesStopReason(status: OpenAI.Responses.ResponseStatus | undefined): StopReason;
+export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<void>;
+export declare function mapOpenAIResponsesStopReason(status: ResponseStatus | undefined): StopReason;
 /** Initial empty `AssistantMessage` that streaming providers accumulate into. */
 export declare function createInitialResponsesAssistantMessage(api: Api, provider: string, modelId: string): AssistantMessage;
 /** Extension fields we add on top of `ResponseCreateParamsStreaming` across the Responses-family providers. */
@@ -57,7 +79,7 @@ export type ResponsesSamplingParamsExtras = {
     presence_penalty?: number;
     repetition_penalty?: number;
 };
-type CommonResponsesParams = OpenAI.Responses.ResponseCreateParamsStreaming & ResponsesSamplingParamsExtras;
+type CommonResponsesParams = ResponseCreateParamsStreaming & ResponsesSamplingParamsExtras;
 type CommonSamplingOptions = Pick<StreamOptions, "temperature" | "topP" | "topK" | "minP" | "presencePenalty" | "repetitionPenalty" | "maxTokens"> & {
     serviceTier?: ServiceTier;
 };
@@ -70,15 +92,19 @@ type CommonSamplingOptions = Pick<StreamOptions, "temperature" | "topP" | "topK"
  * can let the upstream apply its own default instead of 400-ing on `maxTokens` values that
  * reflect the model's context window rather than the upstream output limit.
  */
-export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, model: Pick<Model, "provider" | "omitMaxOutputTokens">): void;
+export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, model: Pick<Model, "provider" | "omitMaxOutputTokens" | "maxTokens">): void;
 type ReasoningOptions = {
     reasoning?: string;
     reasoningSummary?: "auto" | "detailed" | "concise" | null;
 };
 /**
  * Apply reasoning-related Responses parameters: enable encrypted reasoning content for replay,
- * set effort/summary when requested, and otherwise inject the GPT-5 "Juice: 0" no-reasoning hack.
- * Mutates `params` and may push a developer message into `messages`.
+ * set effort/summary when requested, and otherwise inject the "Juice: 0" no-reasoning hack
+ * when `model.compat.requiresJuiceZeroHack` is set (GPT-5 family by default).
+ * Mutates `params` and may push a developer message into `messages`. Returns
+ * the number of per-turn trailing scaffolding items appended to `messages`
+ * (the "Juice: 0" developer item), so callers doing stateful
+ * `previous_response_id` chaining can exclude them from append-baseline math.
  *
  * @param omitReasoningEffort - When `true`, suppresses `params.reasoning.effort` from the wire
  *   body. Set by `xai-responses.ts` via {@link OpenAIResponsesOptions.omitReasoningEffort} for
@@ -89,7 +115,7 @@ type ReasoningOptions = {
  *   without needing explicit activation. Callers that pass `options.reasoning` for such models
  *   should expect this documented downgrade: the model will reason, but at its default effort.
  */
-export declare function applyResponsesReasoningParams<P extends OpenAI.Responses.ResponseCreateParamsStreaming>(params: P, model: Model<Api>, options: ReasoningOptions | undefined, messages: ResponseInput, mapEffort?: (effort: string) => string, includeEncryptedReasoning?: boolean, omitReasoningEffort?: boolean): void;
+export declare function applyResponsesReasoningParams<P extends ResponseCreateParamsStreaming>(params: P, model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">, options: ReasoningOptions | undefined, messages: ResponseInput, mapEffort?: (effort: string) => string, includeEncryptedReasoning?: boolean, omitReasoningEffort?: boolean): number;
 /** Populate `output.usage` from a Responses-API `response.usage` payload. Does not invoke `calculateCost`. */
 export declare function populateResponsesUsageFromResponse(output: AssistantMessage, usage: {
     input_tokens?: number | null;
@@ -102,4 +128,18 @@ export declare function populateResponsesUsageFromResponse(output: AssistantMess
         reasoning_tokens?: number | null;
     } | null;
 } | null | undefined): void;
+/**
+ * Strict-prefix delta for stateful `previous_response_id` chaining (used by the
+ * platform Responses provider and the Codex provider on both transports):
+ * returns the input items the current request appends beyond the previous
+ * request's input plus the previous response's output items, or null when the
+ * request options differ or history mutated (the chain must break). Per-turn
+ * `client_metadata` (e.g. rotating turn ids) is excluded from the option
+ * comparison; codex-rs excludes it from the same check.
+ */
+export declare function buildResponsesDeltaInput<TItem>(previous: {
+    input?: unknown;
+} | undefined, previousResponseItems: readonly TItem[] | undefined, current: {
+    input?: unknown;
+}): TItem[] | null;
 export {};