jeopi-ai 16.2.13

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

@@ -0,0 +1,54 @@
+import type { Api, Model } from "../../types";
+/** Reasoning replay scope for the Codex Responses API (`reasoning.context`). */
+export type CodexReasoningContext = "auto" | "current_turn" | "all_turns";
+export interface ReasoningConfig {
+    effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    summary?: "auto" | "concise" | "detailed";
+    context?: CodexReasoningContext;
+}
+export interface CodexRequestOptions {
+    reasoningEffort?: ReasoningConfig["effort"];
+    reasoningSummary?: ReasoningConfig["summary"] | null;
+    /** Explicit `reasoning.context` override; defaults to `all_turns` when unset. The `all_turns` value is gated to gpt-5.4+ Codex models — older ids reject it, so it is suppressed and `context` omitted. */
+    reasoningContext?: CodexReasoningContext;
+    textVerbosity?: "low" | "medium" | "high";
+    include?: string[];
+    /** Responses Lite transport contract: strips image detail and disables parallel tool calling, mirroring codex-rs. */
+    responsesLite?: boolean;
+}
+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;
+    reasoning?: Partial<ReasoningConfig>;
+    text?: {
+        verbosity?: "low" | "medium" | "high";
+    };
+    include?: string[];
+    prompt_cache_key?: string;
+    prompt_cache_retention?: "in_memory" | "24h";
+    client_metadata?: Record<string, string>;
+    max_output_tokens?: number;
+    max_completion_tokens?: number;
+    service_tier?: "auto" | "default" | "flex" | "scale" | "priority" | null;
+    [key: string]: unknown;
+}
+/** Returns whether a Codex request can use the text-only Responses Lite transport. */
+export declare function shouldUseCodexResponsesLite(body: RequestBody, requested: boolean | undefined): boolean;
+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,26 @@
+import { ProviderHttpError } from "../../error";
+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;
+    /** 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

@@ -0,0 +1,108 @@
+import type { Context, Model, ProviderSessionState, ServiceTier, StreamFunction, StreamOptions, Tool, ToolChoice } from "../types";
+import { type CodexReasoningContext, type RequestBody } 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` when unset. The `all_turns` value is gated to gpt-5.4+ Codex models — older ids reject it, so it is suppressed and `context` omitted. */
+    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 disables parallel tool calling — 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;
+    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;
+/** @internal Exported for tests. */
+export declare function buildTransformedCodexRequestBody(model: Model<"openai-codex-responses">, context: Context, options: OpenAICodexResponsesOptions | undefined, promptCacheKey?: string | undefined): Promise<RequestBody>;
+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" | "responsesLite">): 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[];
+export declare class CodexWebSocketTransportError extends Error {
+    constructor(detail: string);
+}
+declare class CodexProviderStreamError extends Error {
+    readonly retryable: boolean;
+    readonly code?: string;
+    constructor(message: string, retryable: boolean, code?: string);
+}
+export declare function isRetryableCodexFailureEvent(rawEvent: Record<string, unknown>): boolean;
+export declare function createCodexProviderStreamError(rawEvent: Record<string, unknown>): CodexProviderStreamError;

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

@@ -0,0 +1,45 @@
+import type { ResolvedOpenAICompat } from "jeopi-catalog/types";
+import type { AssistantMessage, Context, Model, ServiceTier, StreamFunction, StreamOptions, ToolChoice } from "../types";
+import type { ChatCompletionMessageParam } from "./openai-chat-wire";
+export { applyOpenRouterRoutingVariant } from "./openai-shared";
+/**
+ * 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 a 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;
+    /** @internal True when maxTokens came from the caller, not the model default. */
+    maxTokensExplicit?: boolean;
+    /**
+     * 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;
+}
+/**
+ * Public entry: wrap the single-attempt streamer with bounded empty-completion
+ * retries — flaky gateways occasionally 200 with `delta: {}` + `finish_reason:
+ * "stop"` and no usage, which would otherwise stall the agent loop. Shared with
+ * the Anthropic provider via `withEmptyCompletionRetry`.
+ */
+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[];

package/dist/types/providers/openai-reasoning-fallback.d.ts

@@ -0,0 +1,25 @@
+import type { CapturedHttpErrorResponse } from "../utils/http-inspector";
+/** @internal */
+export type OpenAIReasoningEffortFallback = string | null;
+/** @internal */
+export interface OpenAIReasoningEffortFallbackState {
+    reasoningEffortFallbacks: Map<string, OpenAIReasoningEffortFallback>;
+}
+/** @internal */
+export declare function createOpenAIReasoningEffortFallbackState(): OpenAIReasoningEffortFallbackState;
+/** @internal */
+export declare function clearOpenAIReasoningEffortFallbackState(state: OpenAIReasoningEffortFallbackState): void;
+/** @internal */
+export declare function getOpenAIReasoningEffortFallback(state: OpenAIReasoningEffortFallbackState | undefined, key: string): OpenAIReasoningEffortFallback | undefined;
+/** @internal */
+export declare function rememberOpenAIReasoningEffortFallback(state: OpenAIReasoningEffortFallbackState | undefined, key: string, fallback: OpenAIReasoningEffortFallback): void;
+/** @internal */
+export declare function createOpenAIReasoningEffortFallbackKey(endpoint: "chat-completions" | "responses" | "azure-responses", baseUrl: string | undefined, wireModelId: string | undefined): string;
+/** @internal */
+export declare function readOpenAIReasoningEffort(params: unknown): string | undefined;
+/** @internal */
+export declare function applyOpenAIReasoningEffortFallback(params: unknown, fallback: OpenAIReasoningEffortFallback): boolean;
+/** @internal */
+export declare function resolveOpenAIReasoningEffortFallback(error: unknown, captured: CapturedHttpErrorResponse | undefined, params: unknown, options?: {
+    explicitDisable?: boolean;
+}): OpenAIReasoningEffortFallback | undefined;

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

@@ -0,0 +1,349 @@
+/**
+ * ArkType 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 `"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-responses-wire";
+declare const inputImageBlockSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "input_image";
+    detail?: "auto" | "high" | "low" | undefined;
+    image_url?: string | undefined;
+    file_id?: string | undefined;
+}, {}>;
+declare const inputFileBlockSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "input_file";
+    file_id?: string | undefined;
+    filename?: string | undefined;
+    file_data?: string | undefined;
+}, {}>;
+declare const outputRefusalSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "refusal";
+    refusal: string;
+}, {}>;
+declare const customToolCallItemSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "custom_tool_call";
+    id?: string | undefined;
+    call_id: string;
+    name: string;
+    input: string;
+}, {}>;
+declare const customToolCallOutputItemSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "custom_tool_call_output";
+    call_id: string;
+    output: string;
+}, {}>;
+/**
+ * Direct mapping to standard types.
+ */
+export declare const inputItemSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type?: "message" | undefined;
+    role: "developer" | "user";
+    content?: string | ({
+        type: "input_text";
+        text: string;
+    } | {
+        type: "text";
+        text: string;
+    } | {
+        type: "input_image";
+        detail?: "auto" | "high" | "low" | undefined;
+        image_url?: string | undefined;
+        file_id?: string | undefined;
+    } | {
+        type: "input_file";
+        file_id?: string | undefined;
+        filename?: string | undefined;
+        file_data?: string | undefined;
+    })[] | undefined;
+} | {
+    type?: "message" | undefined;
+    role: "system";
+    content?: string | ({
+        type: "input_text";
+        text: string;
+    } | {
+        type: "text";
+        text: string;
+    } | {
+        type: "input_image";
+        detail?: "auto" | "high" | "low" | undefined;
+        image_url?: string | undefined;
+        file_id?: string | undefined;
+    } | {
+        type: "input_file";
+        file_id?: string | undefined;
+        filename?: string | undefined;
+        file_data?: string | undefined;
+    })[] | undefined;
+} | {
+    type?: "message" | undefined;
+    id?: string | undefined;
+    role: "assistant";
+    content?: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "output_text";
+        text: string;
+    } | {
+        type: "refusal";
+        refusal: string;
+    })[] | undefined;
+    status?: "completed" | "in_progress" | "incomplete" | undefined;
+    phase?: "commentary" | "final_answer" | null | undefined;
+} | {
+    type: "reasoning";
+    id?: string | undefined;
+    summary?: {
+        type: "summary_text";
+        text: string;
+    }[] | undefined;
+    content?: {
+        type: "reasoning_text";
+        text: string;
+    }[] | undefined;
+} | {
+    type: "function_call";
+    id?: string | undefined;
+    call_id: string;
+    name: string;
+    arguments?: string | undefined;
+} | {
+    type: "function_call_output";
+    call_id: string;
+    output?: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "output_text";
+        text: string;
+    } | {
+        type: "refusal";
+        refusal: string;
+    })[] | undefined;
+} | {
+    type: "custom_tool_call";
+    id?: string | undefined;
+    call_id: string;
+    name: string;
+    input: string;
+} | {
+    type: "custom_tool_call_output";
+    call_id: string;
+    output: string;
+} | {
+    type: string;
+}, {}>;
+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 = typeof customToolCallItemSchema.infer;
+export type OpenAIResponsesCustomToolCallOutputItem = typeof customToolCallOutputItemSchema.infer;
+export type OpenAIResponsesInputImageBlock = typeof inputImageBlockSchema.infer;
+export type OpenAIResponsesInputFileBlock = typeof inputFileBlockSchema.infer;
+export type OpenAIResponsesOutputRefusalBlock = typeof outputRefusalSchema.infer;
+export declare const toolSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "function";
+    name: string;
+    description?: string | undefined;
+    parameters?: {
+        [x: string]: unknown;
+    } | undefined;
+    strict?: boolean | undefined;
+}, {}>;
+export declare const toolChoiceSchema: import("arktype").BaseType<"auto" | "none" | "required" | {
+    type: "function";
+    name: string;
+} | {
+    type: "custom";
+    name: string;
+} | {
+    type: "code_interpreter" | "computer_use_preview" | "file_search" | "image_generation" | "mcp" | "web_search_preview";
+} | {
+    type: "allowed_tools";
+    mode: "auto" | "required";
+    tools: {
+        type: string;
+        name?: string | undefined;
+    }[];
+}, {}>;
+export declare const reasoningConfigSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    effort?: string | undefined;
+    summary?: "auto" | "concise" | "detailed" | "none" | undefined;
+}, {}>;
+export declare const stopSchema: import("arktype").BaseType<string | string[] | null, {}>;
+export declare const openaiResponsesRequestSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    model: string;
+    input?: string | ({
+        type?: "message" | undefined;
+        role: "developer" | "user";
+        content?: string | ({
+            type: "input_text";
+            text: string;
+        } | {
+            type: "text";
+            text: string;
+        } | {
+            type: "input_image";
+            detail?: "auto" | "high" | "low" | undefined;
+            image_url?: string | undefined;
+            file_id?: string | undefined;
+        } | {
+            type: "input_file";
+            file_id?: string | undefined;
+            filename?: string | undefined;
+            file_data?: string | undefined;
+        })[] | undefined;
+    } | {
+        type?: "message" | undefined;
+        role: "system";
+        content?: string | ({
+            type: "input_text";
+            text: string;
+        } | {
+            type: "text";
+            text: string;
+        } | {
+            type: "input_image";
+            detail?: "auto" | "high" | "low" | undefined;
+            image_url?: string | undefined;
+            file_id?: string | undefined;
+        } | {
+            type: "input_file";
+            file_id?: string | undefined;
+            filename?: string | undefined;
+            file_data?: string | undefined;
+        })[] | undefined;
+    } | {
+        type?: "message" | undefined;
+        id?: string | undefined;
+        role: "assistant";
+        content?: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "output_text";
+            text: string;
+        } | {
+            type: "refusal";
+            refusal: string;
+        })[] | undefined;
+        status?: "completed" | "in_progress" | "incomplete" | undefined;
+        phase?: "commentary" | "final_answer" | null | undefined;
+    } | {
+        type: "reasoning";
+        id?: string | undefined;
+        summary?: {
+            type: "summary_text";
+            text: string;
+        }[] | undefined;
+        content?: {
+            type: "reasoning_text";
+            text: string;
+        }[] | undefined;
+    } | {
+        type: "function_call";
+        id?: string | undefined;
+        call_id: string;
+        name: string;
+        arguments?: string | undefined;
+    } | {
+        type: "function_call_output";
+        call_id: string;
+        output?: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "output_text";
+            text: string;
+        } | {
+            type: "refusal";
+            refusal: string;
+        })[] | undefined;
+    } | {
+        type: "custom_tool_call";
+        id?: string | undefined;
+        call_id: string;
+        name: string;
+        input: string;
+    } | {
+        type: "custom_tool_call_output";
+        call_id: string;
+        output: string;
+    } | {
+        type: string;
+    })[] | undefined;
+    instructions?: string | null | undefined;
+    tools?: ({
+        type: "function";
+        name: string;
+        description?: string | undefined;
+        parameters?: {
+            [x: string]: unknown;
+        } | undefined;
+        strict?: boolean | undefined;
+    } | {
+        type: string;
+    })[] | undefined;
+    tool_choice?: "auto" | "none" | "required" | {
+        type: "function";
+        name: string;
+    } | {
+        type: "custom";
+        name: string;
+    } | {
+        type: "code_interpreter" | "computer_use_preview" | "file_search" | "image_generation" | "mcp" | "web_search_preview";
+    } | {
+        type: "allowed_tools";
+        mode: "auto" | "required";
+        tools: {
+            type: string;
+            name?: string | undefined;
+        }[];
+    } | undefined;
+    max_output_tokens?: number | undefined;
+    temperature?: number | undefined;
+    top_p?: number | undefined;
+    stop?: string | string[] | null | undefined;
+    stream?: boolean | undefined;
+    reasoning?: {
+        effort?: string | undefined;
+        summary?: "auto" | "concise" | "detailed" | "none" | undefined;
+    } | undefined;
+    store?: boolean | undefined;
+    previous_response_id?: string | undefined;
+    parallel_tool_calls?: boolean | undefined;
+    prompt_cache_key?: string | undefined;
+    metadata?: unknown;
+    user?: string | undefined;
+    service_tier?: string | undefined;
+    presence_penalty?: number | undefined;
+    frequency_penalty?: number | undefined;
+    background?: unknown;
+    include?: unknown;
+    prompt?: unknown;
+    safety_identifier?: unknown;
+    text?: unknown;
+    top_logprobs?: unknown;
+    truncation?: unknown;
+}, {}>;
+/**
+ * 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 ↔ omp Context bridge for the auth-gateway.
+ *
+ * Inbound: parses `POST /v1/responses` request bodies into a {@link ParsedRequest}.
+ * Outbound: encodes omp'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 { 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, _options?: ParsedRequest["options"], control?: AuthGatewayStreamControl): ReadableStream<Uint8Array>;