@aryee337/aery-ai 0.1.148 → 0.2.10

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

@@ -0,0 +1,16 @@
+/**
+ * Parsed inbound OpenAI chat-completions request, ready to feed into aery-ai
+ * `stream(model, context, options)`.
+ */
+import type { 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 encodeResponse(message: AssistantMessage, requestedModelId: string): Record<string, unknown>;
+export declare function encodeStream(events: AssistantMessageEventStream, requestedModelId: string, options?: ParsedRequest["options"]): ReadableStream<Uint8Array>;
+/**
+ * OpenAI chat-completions error envelope:
+ *   `{ error: { message, type } }`
+ * Matches the shape the official SDK auto-parses into `APIError`.
+ */
+export declare function formatError(status: number, type: string, message: string): Response;

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

@@ -0,0 +1,26 @@
+/**
+ * Constants for OpenAI Codex (ChatGPT OAuth) backend
+ */
+export declare const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+export declare const OPENAI_HEADERS: {
+    readonly BETA: "OpenAI-Beta";
+    readonly ACCOUNT_ID: "chatgpt-account-id";
+    readonly ORIGINATOR: "originator";
+    readonly SESSION_ID: "session_id";
+    readonly CONVERSATION_ID: "conversation_id";
+};
+export declare const OPENAI_HEADER_VALUES: {
+    readonly BETA_RESPONSES: "responses=experimental";
+    readonly BETA_RESPONSES_WEBSOCKETS_V2: "responses_websockets=2026-02-06";
+    readonly ORIGINATOR_CODEX: "aery";
+};
+export declare const URL_PATHS: {
+    readonly RESPONSES: "/responses";
+    readonly CODEX_RESPONSES: "/codex/responses";
+};
+export declare const JWT_CLAIM_PATH: "https://api.openai.com/auth";
+/**
+ * Extract account ID from a Codex JWT access token.
+ * Returns undefined if the token is not a valid Codex JWT.
+ */
+export declare function getCodexAccountId(accessToken: string): string | undefined;

package/dist/types/providers/openai-codex/request-transformer.d.ts

@@ -0,0 +1,49 @@
+import type { Api, Model } from "../../types";
+export interface ReasoningConfig {
+    effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    summary?: "auto" | "concise" | "detailed";
+}
+export interface CodexRequestOptions {
+    reasoningEffort?: ReasoningConfig["effort"];
+    reasoningSummary?: ReasoningConfig["summary"] | null;
+    textVerbosity?: "low" | "medium" | "high";
+    include?: string[];
+}
+export interface InputItem {
+    id?: string | null;
+    type?: string | null;
+    role?: string;
+    content?: unknown;
+    call_id?: string | null;
+    name?: string;
+    output?: unknown;
+    arguments?: unknown;
+}
+export interface RequestBody {
+    model: string;
+    store?: boolean;
+    stream?: boolean;
+    instructions?: string;
+    input?: InputItem[];
+    tools?: unknown;
+    tool_choice?: unknown;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    min_p?: number;
+    presence_penalty?: number;
+    repetition_penalty?: number;
+    reasoning?: Partial<ReasoningConfig>;
+    text?: {
+        verbosity?: "low" | "medium" | "high";
+    };
+    include?: string[];
+    prompt_cache_key?: string;
+    prompt_cache_retention?: "in_memory" | "24h";
+    max_output_tokens?: number;
+    max_completion_tokens?: number;
+    [key: string]: unknown;
+}
+export declare function transformRequestBody(body: RequestBody, model: Model<Api>, options?: CodexRequestOptions, prompt?: {
+    developerMessages: string[];
+}): Promise<RequestBody>;

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

@@ -0,0 +1,17 @@
+export type CodexRateLimit = {
+    used_percent?: number;
+    window_minutes?: number;
+    resets_at?: number;
+};
+export type CodexRateLimits = {
+    primary?: CodexRateLimit;
+    secondary?: CodexRateLimit;
+};
+export type CodexErrorInfo = {
+    message: string;
+    status: number;
+    friendlyMessage?: string;
+    rateLimits?: CodexRateLimits;
+    raw?: string;
+};
+export declare function parseCodexError(response: Response): Promise<CodexErrorInfo>;

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

@@ -0,0 +1,67 @@
+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";
+export interface OpenAICodexResponsesOptions extends StreamOptions {
+    reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoningSummary?: "auto" | "concise" | "detailed" | null;
+    textVerbosity?: "low" | "medium" | "high";
+    include?: string[];
+    codexMode?: boolean;
+    toolChoice?: ToolChoice;
+    preferWebsockets?: boolean;
+    serviceTier?: ServiceTier;
+}
+type CodexTransport = "sse" | "websocket";
+export interface OpenAICodexWebSocketDebugStats {
+    fullContextRequests: number;
+    deltaRequests: number;
+    lastInputItems: number;
+    lastDeltaInputItems?: number;
+    lastPreviousResponseId?: string;
+}
+/** @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 interface OpenAICodexTransportDetails {
+    websocketPreferred: boolean;
+    lastTransport?: CodexTransport;
+    websocketDisabled: boolean;
+    websocketConnected: boolean;
+    fallbackCount: number;
+    canAppend: boolean;
+    prewarmed: boolean;
+    hasSessionState: boolean;
+    lastFallbackAt?: number;
+}
+export declare function getOpenAICodexWebSocketDebugStats(model: Model<"openai-codex-responses">, options?: {
+    sessionId?: string;
+    baseUrl?: string;
+    providerSessionState?: Map<string, ProviderSessionState>;
+}): OpenAICodexWebSocketDebugStats | undefined;
+export declare function getOpenAICodexTransportDetails(model: Model<"openai-codex-responses">, options?: {
+    sessionId?: string;
+    baseUrl?: string;
+    preferWebsockets?: boolean;
+    providerSessionState?: Map<string, ProviderSessionState>;
+}): OpenAICodexTransportDetails;
+declare function convertMessages(model: Model<"openai-codex-responses">, context: Context): ResponseInput;
+/** @internal Exported for tests. */
+export { convertMessages as convertCodexResponsesMessages };
+type CodexToolPayload = {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    strict?: boolean;
+} | {
+    type: "custom";
+    name: string;
+    description: string;
+    format: {
+        type: "grammar";
+        syntax: "lark" | "regex";
+        definition: string;
+    };
+};
+/** @internal Exported for tests. */
+export declare function convertOpenAICodexResponsesTools(tools: Tool[], model: Model<"openai-codex-responses">): CodexToolPayload[];

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

@@ -0,0 +1,25 @@
+import type { Model, OpenAICompat } from "../types";
+type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
+export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode">> & {
+    openRouterRouting?: OpenAICompat["openRouterRouting"];
+    vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
+    extraBody?: OpenAICompat["extraBody"];
+    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.
+ */
+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

@@ -0,0 +1,54 @@
+import type { ChatCompletionMessageParam } from "openai/resources/chat/completions";
+import { type AssistantMessage, type Context, type Model, type ServiceTier, type StreamFunction, type StreamOptions, type ToolChoice } from "../types";
+import { type ResolvedOpenAICompat } from "./openai-completions-compat";
+/**
+ * Identify "real progress" stream chunks vs. keepalives, role-only preambles,
+ * and empty `{choices:[]}` no-ops emitted by some OpenAI-compatible endpoints.
+ * Without this filter, every keepalive resets `iterateWithIdleTimeout`'s
+ * deadline, so a provider that streams nothing but pings keeps the watchdog
+ * asleep indefinitely — observed against z.ai/GLM via OpenRouter where a
+ * subagent stalled for hours with no error surfaced.
+ *
+ * A chunk counts as progress when it carries terminal usage, a finish reason,
+ * or any model-produced delta (content / tool calls / reasoning / refusal).
+ * Role-only `delta: { role: "assistant" }` preambles do NOT count; we want the
+ * (longer) first-event timeout to keep governing until real output appears.
+ */
+export declare function isOpenAICompletionsProgressChunk(chunk: unknown): boolean;
+export interface OpenAICompletionsOptions extends StreamOptions {
+    toolChoice?: ToolChoice;
+    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    /** Force-disable reasoning where supported, or request the lowest effort on generic effort endpoints. */
+    disableReasoning?: boolean;
+    serviceTier?: ServiceTier;
+    /**
+     * Routing-variant suffix appended to OpenRouter model IDs when none is
+     * already present (`anthropic/claude-haiku-latest` → `…:nitro`). Common
+     * values: `"nitro"`, `"floor"`, `"online"`, `"exacto"`. Ignored when the
+     * resolved `model.id` already contains a colon-suffix after the last
+     * provider segment (explicit `:nitro` in the selector or a catalog entry
+     * with the variant baked in).
+     */
+    openrouterVariant?: string;
+}
+/**
+ * Append an OpenRouter routing-variant suffix (e.g. `:nitro`, `:floor`, `:online`, `:exacto`)
+ * to a model id when no explicit variant is already present. A variant is considered
+ * "already present" when `modelId` contains a colon after the last `/` separator —
+ * which covers both user-typed selectors (`anthropic/claude-haiku:nitro`) and catalog
+ * entries that bake the variant in (`deepseek/deepseek-v3.1-terminus:exacto`).
+ *
+ * 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

@@ -0,0 +1,392 @@
+/**
+ * Zod schemas for the OpenAI Responses API request shape we accept on the
+ * gateway. Mirrors https://platform.openai.com/docs/api-reference/responses.
+ *
+ * Unsupported / opaque controls (background/include/metadata/prompt/…) are
+ * accepted as `z.unknown().optional()` so we silently ignore rather than 400.
+ * 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";
+declare const inputImageBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"input_image">;
+    detail: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        high: "high";
+        low: "low";
+    }>>;
+    image_url: z.ZodOptional<z.ZodString>;
+    file_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const inputFileBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"input_file">;
+    file_id: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    file_data: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const outputRefusalSchema: z.ZodObject<{
+    type: z.ZodLiteral<"refusal">;
+    refusal: z.ZodString;
+}, z.core.$strip>;
+declare const customToolCallItemSchema: z.ZodObject<{
+    type: z.ZodLiteral<"custom_tool_call">;
+    id: z.ZodOptional<z.ZodString>;
+    call_id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodString;
+}, z.core.$strip>;
+declare const customToolCallOutputItemSchema: z.ZodObject<{
+    type: z.ZodLiteral<"custom_tool_call_output">;
+    call_id: z.ZodString;
+    output: z.ZodString;
+}, z.core.$strip>;
+/**
+ * An input item is one of the union members below. The convenience shape
+ * `{role, content}` (no `type`) is mapped to "message" before validation in
+ * the walker — schemas here only handle the canonical {type, ...} forms.
+ */
+export declare const inputItemSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<"message">>;
+    role: z.ZodUnion<readonly [z.ZodLiteral<"user">, z.ZodLiteral<"developer">]>;
+    content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"input_text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"input_image">;
+        detail: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            high: "high";
+            low: "low";
+        }>>;
+        image_url: z.ZodOptional<z.ZodString>;
+        file_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"input_file">;
+        file_id: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+        file_data: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<"message">>;
+    role: z.ZodLiteral<"system">;
+    content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"input_text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"input_image">;
+        detail: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            high: "high";
+            low: "low";
+        }>>;
+        image_url: z.ZodOptional<z.ZodString>;
+        file_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"input_file">;
+        file_id: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+        file_data: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<"message">>;
+    role: z.ZodLiteral<"assistant">;
+    content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"output_text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"refusal">;
+        refusal: z.ZodString;
+    }, z.core.$strip>]>>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reasoning">;
+    id: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"summary_text">;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+    content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"reasoning_text">;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"function_call">;
+    id: z.ZodOptional<z.ZodString>;
+    call_id: z.ZodString;
+    name: z.ZodString;
+    arguments: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"function_call_output">;
+    call_id: z.ZodString;
+    output: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"output_text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"refusal">;
+        refusal: z.ZodString;
+    }, z.core.$strip>]>>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"custom_tool_call">;
+    id: z.ZodOptional<z.ZodString>;
+    call_id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"custom_tool_call_output">;
+    call_id: z.ZodString;
+    output: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodString;
+}, z.core.$loose>]>;
+export type OpenAIResponsesUserItem = EasyInputMessage | ResponseInputItem.Message;
+export type OpenAIResponsesSystemItem = EasyInputMessage | ResponseInputItem.Message;
+export type OpenAIResponsesAssistantItem = EasyInputMessage | ResponseOutputMessage;
+export type OpenAIResponsesReasoningItem = ResponseReasoningItem;
+export type OpenAIResponsesFunctionCallItem = ResponseFunctionToolCall;
+export type OpenAIResponsesFunctionCallOutputItem = ResponseInputItem.FunctionCallOutput;
+/** Inferred shape of the custom tool call input item (no canonical SDK alias). */
+export type OpenAIResponsesCustomToolCallItem = z.infer<typeof customToolCallItemSchema>;
+export type OpenAIResponsesCustomToolCallOutputItem = z.infer<typeof customToolCallOutputItemSchema>;
+export type OpenAIResponsesInputImageBlock = z.infer<typeof inputImageBlockSchema>;
+export type OpenAIResponsesInputFileBlock = z.infer<typeof inputFileBlockSchema>;
+export type OpenAIResponsesOutputRefusalBlock = z.infer<typeof outputRefusalSchema>;
+export declare const toolSchema: z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const toolChoiceSchema: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"custom">;
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodEnum<{
+        code_interpreter: "code_interpreter";
+        computer_use_preview: "computer_use_preview";
+        file_search: "file_search";
+        image_generation: "image_generation";
+        mcp: "mcp";
+        web_search_preview: "web_search_preview";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"allowed_tools">;
+    mode: z.ZodEnum<{
+        auto: "auto";
+        required: "required";
+    }>;
+    tools: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>]>;
+export declare const reasoningConfigSchema: z.ZodObject<{
+    effort: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        concise: "concise";
+        detailed: "detailed";
+        none: "none";
+    }>>;
+}, z.core.$strip>;
+export declare const stopSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodNull]>;
+export declare const openaiResponsesRequestSchema: z.ZodObject<{
+    model: z.ZodString;
+    input: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodOptional<z.ZodLiteral<"message">>;
+        role: z.ZodUnion<readonly [z.ZodLiteral<"user">, z.ZodLiteral<"developer">]>;
+        content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"input_text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"input_image">;
+            detail: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                high: "high";
+                low: "low";
+            }>>;
+            image_url: z.ZodOptional<z.ZodString>;
+            file_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"input_file">;
+            file_id: z.ZodOptional<z.ZodString>;
+            filename: z.ZodOptional<z.ZodString>;
+            file_data: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodOptional<z.ZodLiteral<"message">>;
+        role: z.ZodLiteral<"system">;
+        content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"input_text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"input_image">;
+            detail: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                high: "high";
+                low: "low";
+            }>>;
+            image_url: z.ZodOptional<z.ZodString>;
+            file_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"input_file">;
+            file_id: z.ZodOptional<z.ZodString>;
+            filename: z.ZodOptional<z.ZodString>;
+            file_data: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodOptional<z.ZodLiteral<"message">>;
+        role: z.ZodLiteral<"assistant">;
+        content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"output_text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"refusal">;
+            refusal: z.ZodString;
+        }, z.core.$strip>]>>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"reasoning">;
+        id: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"summary_text">;
+            text: z.ZodString;
+        }, z.core.$strip>>>;
+        content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"reasoning_text">;
+            text: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"function_call">;
+        id: z.ZodOptional<z.ZodString>;
+        call_id: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"function_call_output">;
+        call_id: z.ZodString;
+        output: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"output_text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"refusal">;
+            refusal: z.ZodString;
+        }, z.core.$strip>]>>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"custom_tool_call">;
+        id: z.ZodOptional<z.ZodString>;
+        call_id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"custom_tool_call_output">;
+        call_id: z.ZodString;
+        output: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$loose>]>>]>>;
+    instructions: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        strict: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$loose>]>>>;
+    tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            code_interpreter: "code_interpreter";
+            computer_use_preview: "computer_use_preview";
+            file_search: "file_search";
+            image_generation: "image_generation";
+            mcp: "mcp";
+            web_search_preview: "web_search_preview";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"allowed_tools">;
+        mode: z.ZodEnum<{
+            auto: "auto";
+            required: "required";
+        }>;
+        tools: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>>;
+    max_output_tokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    stop: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodNull]>>;
+    stream: z.ZodOptional<z.ZodBoolean>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        effort: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            concise: "concise";
+            detailed: "detailed";
+            none: "none";
+        }>>;
+    }, z.core.$strip>>;
+    store: z.ZodOptional<z.ZodBoolean>;
+    previous_response_id: z.ZodOptional<z.ZodString>;
+    parallel_tool_calls: z.ZodOptional<z.ZodBoolean>;
+    prompt_cache_key: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodUnknown>;
+    user: z.ZodOptional<z.ZodString>;
+    service_tier: z.ZodOptional<z.ZodString>;
+    presence_penalty: z.ZodOptional<z.ZodNumber>;
+    frequency_penalty: z.ZodOptional<z.ZodNumber>;
+    background: z.ZodOptional<z.ZodUnknown>;
+    include: z.ZodOptional<z.ZodUnknown>;
+    prompt: z.ZodOptional<z.ZodUnknown>;
+    safety_identifier: z.ZodOptional<z.ZodUnknown>;
+    text: z.ZodOptional<z.ZodUnknown>;
+    top_logprobs: z.ZodOptional<z.ZodUnknown>;
+    truncation: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Public types are sourced from the OpenAI SDK so the gateway stays in
+ * lock-step with the canonical API surface; the schemas above are runtime
+ * validators for the subset we actually accept.
+ */
+export type OpenAIResponsesRequest = ResponseCreateParams;
+export type OpenAIResponsesInputItem = ResponseInputItem;
+export type OpenAIResponsesTool = ResponsesTool;
+export type OpenAIResponsesToolChoice = NonNullable<ResponseCreateParams["tool_choice"]>;
+export type OpenAIResponsesInputContent = ResponseInputContent;
+export type OpenAIResponsesOutputContent = ResponseOutputMessage["content"][number];
+export {};

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

@@ -0,0 +1,17 @@
+/**
+ * OpenAI Responses HTTP wire-format ↔ aery Context bridge for the auth-gateway.
+ *
+ * Inbound: parses `POST /v1/responses` request bodies into a {@link ParsedRequest}.
+ * Outbound: encodes aery's {@link AssistantMessage} (and event stream) back into
+ * the documented `response.*` SSE taxonomy or the non-streaming JSON shape.
+ *
+ * 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 { 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>;