@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/src/api/openai-codex-compact.js

@@ -0,0 +1,389 @@
+import {
+  applyServiceTierPricing2
+} from "../../chunks/account-limits-cache-f9z00x8c.js";
+import {
+  calculateCost2
+} from "../../chunks/account-limits-cache-zgzptd0z.js";
+import {
+  reportsQuotaExhaustion2
+} from "../../chunks/account-limits-cache-xds88kxd.js";
+import {
+  headersToRecord2
+} from "../../chunks/account-limits-cache-ag5b8dja.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+import {
+  RetryDelayExceededError2,
+  retryProviderRequest2
+} from "../../chunks/account-limits-cache-nbhht7xz.js";
+import {
+  normalizeContext2,
+  resolveTranscript2
+} from "../../chunks/account-limits-cache-6250ykn6.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import {
+  emptyCost2
+} from "../../chunks/account-limits-cache-fsktnetm.js";
+import {
+  OpenAICodexCompactionError2
+} from "../../chunks/account-limits-cache-eejm0vth.js";
+import"../../chunks/account-limits-cache-gknnm1kv.js";
+import {
+  CodexFrameJson2,
+  readRecord2,
+  TERMINAL_RESPONSE_TYPES2,
+  normalizeTimeoutMs2,
+  resolveCodexUrl2,
+  extractAccountId2,
+  buildSSEHeaders2
+} from "../../chunks/account-limits-cache-fvadc36m.js";
+import"../../chunks/account-limits-cache-ehy0ze2b.js";
+import"../../chunks/account-limits-cache-hj3ek3ty.js";
+import"../../chunks/account-limits-cache-8s8bz4dr.js";
+import"../../chunks/account-limits-cache-9wqk28n5.js";
+import"../../chunks/account-limits-cache-me1x57bs.js";
+import"../../chunks/account-limits-cache-b4edaybk.js";
+import"../../chunks/account-limits-cache-h92bzz1j.js";
+import"../../chunks/account-limits-cache-0af5gqeg.js";
+import"../../chunks/account-limits-cache-eqwweapz.js";
+import"../../chunks/account-limits-cache-8qzk56vj.js";
+import"../../chunks/account-limits-cache-n3yk6g5c.js";
+import {
+  DEFAULT_MAX_RETRIES2,
+  compressRequestBodyZstd2,
+  buildRequestBody2,
+  resolveCodexServiceTier2,
+  CodexRequestError2,
+  retryableCodexRequest2,
+  CodexProtocolError2,
+  extractCodexEventError2,
+  parseSSE2
+} from "../../chunks/account-limits-cache-vwgfz727.js";
+import {
+  clampOpenAIPromptCacheKey2
+} from "../../chunks/account-limits-cache-csbxvam7.js";
+import"../../chunks/account-limits-cache-fbkaq46e.js";
+import"../../chunks/account-limits-cache-736tdyme.js";
+import"../../chunks/account-limits-cache-a558rjbg.js";
+import {
+  withPriorityTier2
+} from "../../chunks/account-limits-cache-53e64mhx.js";
+
+// src/api/openai-codex-compact.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var DEFAULT_COMPACT_IDLE_TIMEOUT_MS = 300000;
+var RETRYABLE_COMPACTION_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+var RETRYABLE_COMPACTION_CODES = new Set([
+  "server_error",
+  "rate_limit_exceeded",
+  "overloaded"
+]);
+var compactTokenCount = Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+var codexCompactionItem = Type.Object({
+  type: Type.Literal("compaction"),
+  id: Type.Optional(Type.Union([Type.String({ minLength: 1 }), Type.Null()])),
+  encrypted_content: Type.String({ minLength: 1 })
+});
+var compactUsage = Type.Union([
+  Type.Null(),
+  Type.Object({
+    input_tokens: compactTokenCount,
+    output_tokens: compactTokenCount,
+    total_tokens: compactTokenCount,
+    input_tokens_details: Type.Optional(Type.Union([
+      Type.Null(),
+      Type.Object({
+        cached_tokens: Type.Optional(compactTokenCount),
+        cache_write_tokens: Type.Optional(compactTokenCount)
+      })
+    ])),
+    output_tokens_details: Type.Optional(Type.Union([
+      Type.Null(),
+      Type.Object({
+        reasoning_tokens: Type.Optional(compactTokenCount)
+      })
+    ]))
+  })
+]);
+var compactServiceTier = Type.Union([
+  Type.Null(),
+  Type.Literal("auto"),
+  Type.Literal("default"),
+  Type.Literal("flex"),
+  Type.Literal("scale"),
+  Type.Literal("priority")
+]);
+var codexCompactCompleted = Type.Object({
+  id: Type.String({ minLength: 1 }),
+  status: Type.Optional(Type.Literal("completed")),
+  error: Type.Optional(Type.Null()),
+  incomplete_details: Type.Optional(Type.Null()),
+  usage: Type.Optional(compactUsage),
+  service_tier: Type.Optional(compactServiceTier)
+});
+var codexRetainedMessages = Type.Array(Type.Object({
+  role: Type.Literal("user"),
+  content: Type.Union([
+    Type.String(),
+    Type.Array(Type.Union([
+      Type.Object({ type: Type.Literal("input_text"), text: Type.String() }),
+      Type.Object({
+        type: Type.Literal("input_image"),
+        image_url: Type.String(),
+        detail: Type.Literal("auto")
+      })
+    ]))
+  ])
+}));
+
+class CompactionStepError extends Error {
+  retryable;
+  constructor(reason, retryable) {
+    super(reason);
+    this.retryable = retryable;
+  }
+}
+function addUsage(total, next) {
+  if (total === undefined)
+    return next;
+  return {
+    input: total.input + next.input,
+    output: total.output + next.output,
+    cacheRead: total.cacheRead + next.cacheRead,
+    cacheWrite: total.cacheWrite + next.cacheWrite,
+    reasoning: (total.reasoning ?? 0) + (next.reasoning ?? 0),
+    totalTokens: total.totalTokens + next.totalTokens,
+    cost: {
+      input: total.cost.input + next.cost.input,
+      output: total.cost.output + next.cost.output,
+      cacheRead: total.cost.cacheRead + next.cost.cacheRead,
+      cacheWrite: total.cost.cacheWrite + next.cost.cacheWrite,
+      total: total.cost.total + next.cost.total
+    }
+  };
+}
+function terminalUsage(terminal, model, options) {
+  const tokens = terminal?.usage;
+  if (tokens !== undefined && !Value.Check(compactUsage, tokens)) {
+    throw new CompactionStepError("Invalid terminal usage", false);
+  }
+  if (!tokens)
+    return;
+  const cached = tokens.input_tokens_details?.cached_tokens ?? 0;
+  const written = tokens.input_tokens_details?.cache_write_tokens ?? 0;
+  const usage = {
+    input: Math.max(0, tokens.input_tokens - cached - written),
+    output: tokens.output_tokens,
+    cacheRead: cached,
+    cacheWrite: written,
+    reasoning: tokens.output_tokens_details?.reasoning_tokens ?? 0,
+    totalTokens: tokens.total_tokens,
+    cost: emptyCost2()
+  };
+  const serviceTier = terminal?.service_tier;
+  calculateCost2(model, usage);
+  applyServiceTierPricing2(usage, resolveCodexServiceTier2(Value.Check(compactServiceTier, serviceTier) ? serviceTier : undefined, options?.serviceTier), model);
+  return usage;
+}
+function readOutputItem(item, output) {
+  if (!Value.Check(CodexFrameJson2, item))
+    return { kind: "invalid", reason: "Invalid output item" };
+  if (item.type !== "compaction" || output.kind === "invalid")
+    return output;
+  if (!Value.Check(codexCompactionItem, item)) {
+    return { kind: "invalid", reason: "Invalid compaction item" };
+  }
+  if (output.kind === "checkpoint") {
+    return { kind: "invalid", reason: "Expected exactly one compaction item" };
+  }
+  const checkpoint = {
+    type: item.type,
+    encrypted_content: item.encrypted_content
+  };
+  if (item.id !== undefined)
+    checkpoint.id = item.id;
+  return { kind: "checkpoint", item: checkpoint };
+}
+async function compactOpenAICodexContext(model, context, requested) {
+  const options = withPriorityTier2(requested);
+  const apiKey = options?.apiKey;
+  if (!apiKey)
+    throw new Error(`No API key for provider: ${model.provider}`);
+  const accountId = extractAccountId2(apiKey);
+  const cacheSessionId = options?.cacheRetention === "none" ? undefined : clampOpenAIPromptCacheKey2(options?.sessionId);
+  const request = buildRequestBody2(model, resolveTranscript2(normalizeContext2(context), model.compat?.supportsMidConvoSystemMessages), options, cacheSessionId);
+  const input = [
+    ...request.input ?? [],
+    { type: "compaction_trigger" }
+  ];
+  request.input = input;
+  await options?.onPayload?.(request, model);
+  const userInputs = input.filter((item) => ("role" in item) && item.role === "user");
+  if (!Value.Check(codexRetainedMessages, userInputs)) {
+    throw new Error("Invalid Codex compaction user input");
+  }
+  const headers = buildSSEHeaders2(model.headers, options?.headers, accountId, apiKey, cacheSessionId);
+  const betaFeatures = new Set((headers.get("x-codex-beta-features") ?? "").split(",").filter(Boolean));
+  betaFeatures.add("remote_compaction_v2");
+  headers.set("x-codex-beta-features", [...betaFeatures].join(","));
+  const encodedBody = JSON.stringify(request);
+  const compressedBody = compressRequestBodyZstd2(encodedBody);
+  if (compressedBody)
+    headers.set("content-encoding", "zstd");
+  const url = new URL(resolveCodexUrl2(model.baseUrl));
+  const timeoutMs = normalizeTimeoutMs2(options?.timeoutMs) ?? DEFAULT_COMPACT_IDLE_TIMEOUT_MS;
+  const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES2;
+  if (!Number.isSafeInteger(maxRetries) || maxRetries < 0) {
+    throw new Error("Invalid Codex compaction maxRetries");
+  }
+  let response;
+  let usage;
+  const attempt = async () => {
+    response = undefined;
+    const headerTimeout = new AbortController;
+    const signal = options?.signal ? AbortSignal.any([options.signal, headerTimeout.signal]) : headerTimeout.signal;
+    const timer = timeoutMs > 0 ? setTimeout(() => headerTimeout.abort(), timeoutMs) : undefined;
+    let retryable = true;
+    let output = { kind: "missing" };
+    try {
+      response = await (options?.fetch ?? globalThis.fetch)(url, {
+        method: "POST",
+        headers,
+        body: compressedBody ?? encodedBody,
+        signal
+      });
+      clearTimeout(timer);
+      retryable = false;
+      await options?.onResponse?.({ status: response.status, headers: headersToRecord2(response.headers) }, model);
+      if (!response.ok) {
+        retryable = RETRYABLE_COMPACTION_STATUSES.has(response.status);
+        if (response.status === 429) {
+          const bodyTimer = timeoutMs > 0 ? setTimeout(() => headerTimeout.abort(), timeoutMs) : undefined;
+          try {
+            retryable = !reportsQuotaExhaustion2(await response.text());
+          } finally {
+            clearTimeout(bodyTimer);
+          }
+        }
+        throw new CompactionStepError("HTTP request failed", retryable);
+      }
+      retryable = true;
+      for await (const event of parseSSE2(response, signal, timeoutMs)) {
+        if (event.type === "response.output_item.done") {
+          output = readOutputItem(event.item, output);
+        } else if (TERMINAL_RESPONSE_TYPES2.has(event.type) || event.type === "response.cancelled") {
+          retryable = false;
+          const terminal = readRecord2(event.response);
+          const reported = terminalUsage(terminal, model, options);
+          if (reported)
+            usage = addUsage(usage, reported);
+          if (event.type !== "response.completed") {
+            throw new CompactionStepError(output.kind === "invalid" ? output.reason : "Compaction did not complete", event.type === "response.failed" && RETRYABLE_COMPACTION_CODES.has(readRecord2(terminal?.error)?.code));
+          }
+          if (!Value.Check(codexCompactCompleted, event.response)) {
+            throw new CompactionStepError("Invalid completed response or usage", false);
+          }
+          if (output.kind !== "checkpoint") {
+            throw new CompactionStepError(output.kind === "invalid" ? output.reason : "Expected exactly one compaction item", false);
+          }
+          const data = [...retainCodexUserInputs(userInputs), output.item];
+          return usage === undefined ? { data } : { data, usage };
+        } else if (event.type === "error") {
+          throw new CompactionStepError("Compaction did not complete", RETRYABLE_COMPACTION_CODES.has(extractCodexEventError2(event).code));
+        }
+      }
+      throw new CompactionStepError(output.kind === "invalid" ? output.reason : "Stream ended before response.completed", retryable);
+    } catch (error) {
+      if (options?.signal?.aborted)
+        throw error;
+      const failure = headerTimeout.signal.aborted ? response ? "HTTP error body timed out" : "Response headers timed out" : error instanceof DOMException && error.name === "TimeoutError" ? "Stream idle timeout" : error instanceof CodexProtocolError2 ? "Invalid SSE stream" : error instanceof CompactionStepError ? error.message : "Request failed";
+      const stepRetryable = error instanceof CompactionStepError ? error.retryable : retryable && !(error instanceof CodexProtocolError2);
+      throw new CodexRequestError2(failure, response?.ok === false ? response.status : undefined, response?.headers, stepRetryable && output.kind !== "invalid");
+    } finally {
+      clearTimeout(timer);
+      await response?.body?.cancel().catch(() => {
+        return;
+      });
+    }
+  };
+  try {
+    return await retryProviderRequest2(attempt, {
+      maxRetries,
+      maxRetryDelayMs: options?.maxRetryDelayMs,
+      signal: options?.signal,
+      retryable: retryableCodexRequest2
+    });
+  } catch (error) {
+    const failure = options?.signal?.aborted ? "Request was aborted" : error instanceof RetryDelayExceededError2 || error instanceof CodexRequestError2 ? error.message : "Request failed";
+    const requestId = response?.headers.get("x-request-id") ?? response?.headers.get("x-openai-request-id");
+    const safeRequestId = requestId && /^[a-zA-Z0-9_-]{1,200}$/.test(requestId) ? requestId : undefined;
+    throw new OpenAICodexCompactionError2(`Codex compaction: ${failure}; ${url.origin}${url.pathname}${response ? `; HTTP ${response.status}` : ""}${safeRequestId ? `; request ID ${safeRequestId}` : ""}`, usage);
+  }
+}
+var IMAGE_TOKENS = 1844;
+function truncateMiddle(text, remaining, encoder) {
+  const bytes = encoder.encode(text);
+  const budget = remaining * 4;
+  let left = budget / 2;
+  let right = bytes.length - budget / 2;
+  while (left > 0 && (bytes[left] & 192) === 128)
+    left--;
+  while (right < bytes.length && (bytes[right] & 192) === 128)
+    right++;
+  const decoder = new TextDecoder;
+  return {
+    type: "input_text",
+    text: `${decoder.decode(bytes.subarray(0, left))}…${Math.ceil((bytes.length - budget) / 4)} tokens truncated…${decoder.decode(bytes.subarray(right))}`
+  };
+}
+function retainCodexUserInputs(messages) {
+  let remaining = 64000;
+  const retained = [];
+  const encoder = new TextEncoder;
+  for (const message of messages.toReversed()) {
+    if (remaining === 0)
+      break;
+    const content = Array.isArray(message.content) ? message.content : [{ type: "input_text", text: message.content }];
+    const budgeted = content.map((part) => ({
+      part,
+      tokens: part.type === "input_image" ? IMAGE_TOKENS : Math.ceil(encoder.encode(part.text).length / 4)
+    }));
+    const cost = Math.max(1, budgeted.reduce((sum, item) => sum + item.tokens, 0));
+    if (cost <= remaining) {
+      retained.push({ type: "message", role: "user", content });
+      remaining -= cost;
+      continue;
+    }
+    const hasImages = content.some((part) => part.type === "input_image");
+    const parts = [];
+    for (const { part, tokens } of hasImages ? budgeted.toReversed() : budgeted) {
+      if (part.type === "input_image") {
+        if (tokens <= remaining) {
+          parts.push(part);
+          remaining -= tokens;
+        } else
+          remaining = 0;
+      } else if (remaining > 0) {
+        if (tokens <= remaining) {
+          if (part.text)
+            parts.push(part);
+          remaining -= tokens;
+        } else {
+          parts.push(truncateMiddle(part.text, remaining, encoder));
+          remaining = 0;
+        }
+      }
+    }
+    if (hasImages)
+      parts.reverse();
+    if (parts.length > 0)
+      retained.push({ type: "message", role: "user", content: parts });
+    remaining = 0;
+  }
+  return retained.reverse();
+}
+export {
+  compactOpenAICodexContext
+};

package/dist/src/api/openai-codex-compaction-error.d.ts

@@ -0,0 +1,7 @@
+import type { Usage } from "../types.ts";
+/** Sanitized failure, kept out of the client module so `instanceof` checks stay cheap to import. */
+export declare class OpenAICodexCompactionError extends Error {
+    /** Sum of valid terminal usage across attempts; undefined means none was reported. */
+    readonly usage: Usage | undefined;
+    constructor(message: string, usage?: Usage);
+}

package/dist/src/api/openai-codex-compaction-error.js

@@ -0,0 +1,6 @@
+import {
+  OpenAICodexCompactionError2
+} from "../../chunks/account-limits-cache-eejm0vth.js";
+export {
+  OpenAICodexCompactionError2 as OpenAICodexCompactionError
+};

package/dist/src/api/openai-codex-protocol.d.ts

@@ -0,0 +1,125 @@
+/**
+ * The Codex Responses protocol both transports and compaction share: request options and body,
+ * error types, frame decoding and the mapping of Codex frames onto Responses stream events.
+ */
+import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+import type { AccountLimits, AssistantMessage, Model, StreamOptions, TranscriptContext } from "../types.ts";
+import { type CodexFrame } from "./openai-codex-wire.ts";
+import { type ResponsesInput, type ResponsesTool } from "./openai-responses-convert.ts";
+import type { ResponsesServiceTier } from "./openai-responses-events.ts";
+import type { OpenAIResponsesStreamOptions } from "./openai-responses-stream.ts";
+export interface OpenAICodexResponsesOptions extends StreamOptions {
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    reasoningSummary?: "auto" | "concise" | "detailed" | "off" | "on" | null;
+    serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+    textVerbosity?: "low" | "medium" | "high";
+    toolChoice?: "auto" | "none" | "required";
+}
+export interface RequestBody {
+    model: string;
+    store?: boolean;
+    stream?: boolean;
+    instructions?: string;
+    previous_response_id?: string;
+    input?: ResponsesInput;
+    tools?: ResponsesTool[];
+    tool_choice?: OpenAICodexResponsesOptions["toolChoice"];
+    parallel_tool_calls?: boolean;
+    temperature?: number;
+    reasoning?: {
+        effort?: string;
+        summary?: string;
+    };
+    service_tier?: ResponseCreateParamsStreaming["service_tier"];
+    text?: {
+        verbosity?: string;
+    };
+    include?: string[];
+    prompt_cache_key?: string;
+}
+/** One Codex request as both transports send it. */
+export interface CodexRequest {
+    readonly model: Model<"openai-codex-responses">;
+    readonly body: RequestBody;
+    readonly accountId: string;
+    /** The caller's session id, unless prompt caching is off; it keys the WebSocket cache. */
+    readonly cacheSessionId: string | undefined;
+    readonly grammarToolInputProperties: ReadonlyMap<string, string>;
+    /** Bounds the SSE header wait and WebSocket idleness, from `options.timeoutMs`. */
+    readonly timeoutMs: number | undefined;
+    /** Bounds the WebSocket open handshake, from `options.websocketConnectTimeoutMs`. */
+    readonly connectTimeoutMs: number | undefined;
+    readonly options: OpenAICodexResponsesOptions | undefined;
+}
+interface CodexEventError {
+    code?: string;
+    message?: string;
+}
+export declare const DEFAULT_MAX_RETRIES = 0;
+export declare const CODEX_TOOL_CALL_PROVIDERS: ReadonlySet<string>;
+/** `bodyJson` as zstd, or null outside Node and Bun, where `node:zlib` is unavailable. */
+export declare function compressRequestBodyZstd(bodyJson: string): Uint8Array<ArrayBuffer> | null;
+/**
+ * The Codex request body. Later system messages anchor their own tool additions, and
+ * `addedToolNames` on a tool result only loads request-list tools the transcript did not anchor,
+ * so nothing is declared twice.
+ */
+export declare function buildRequestBody(model: Model<"openai-codex-responses">, context: TranscriptContext, options: OpenAICodexResponsesOptions | undefined, cacheSessionId: string | undefined, grammarToolInputProperties?: ReadonlyMap<string, string>): RequestBody;
+/** Codex answers `default` for a flex or priority request it served at that tier. */
+export declare function resolveCodexServiceTier(responseServiceTier: ResponsesServiceTier | undefined, requestServiceTier: ResponseCreateParamsStreaming["service_tier"] | undefined): ResponsesServiceTier | undefined;
+/** How the shared Responses stream processor reads a Codex response. */
+export declare function codexStreamOptions(request: CodexRequest): OpenAIResponsesStreamOptions;
+/**
+ * A failed Codex request attempt, carrying `status` and `headers` so the shared provider retry
+ * policy applies; `retryable` vetoes a retry the policy would allow, such as a 429 that is quota
+ * exhaustion, which waiting does not lift.
+ */
+export declare class CodexRequestError extends Error {
+    readonly status: number | undefined;
+    readonly headers: Headers | undefined;
+    readonly retryable: boolean;
+    constructor(message: string, status: number | undefined, headers: Headers | undefined, retryable: boolean, options?: {
+        cause?: unknown;
+    });
+}
+/** The retry veto for Codex attempts: only a {@link CodexRequestError} marked retryable runs again. */
+export declare function retryableCodexRequest(error: unknown): boolean;
+/** An error the Codex API reported in a frame, with its machine-readable code. */
+export declare class CodexApiError extends Error {
+    readonly code?: string;
+    readonly payload?: unknown;
+    constructor(message: string, options?: {
+        code?: string;
+        payload?: unknown;
+        cause?: unknown;
+    });
+}
+/** A frame that is not valid Codex protocol JSON. */
+export declare class CodexProtocolError extends Error {
+    readonly payload?: unknown;
+    constructor(message: string, options?: {
+        payload?: unknown;
+        cause?: unknown;
+    });
+}
+/** The code and message of an `error` frame, flat or nested under `error`. */
+export declare function extractCodexEventError(event: CodexFrame): CodexEventError;
+/**
+ * Maps Codex frames onto Responses stream events. `codex.rate_limits` frames go to
+ * `onAccountLimits`, whose failures never fail the assistant stream. Every terminal frame
+ * becomes `response.completed` carrying its status, so the shared finalizer accounts for usage
+ * before a `response.failed` frame throws a {@link CodexApiError} that keeps the Codex error
+ * code, which tells API failures from retryable transport failures.
+ */
+export declare function mapCodexEvents(events: AsyncIterable<CodexFrame>, output: AssistantMessage, onAccountLimits?: (limits: AccountLimits) => void | Promise<void>): AsyncGenerator<unknown>;
+/** Codex frames from an SSE response body; `[DONE]` and empty data are skipped. */
+export declare function parseSSE(response: Response, signal?: AbortSignal, idleTimeoutMs?: number): AsyncGenerator<CodexFrame>;
+/**
+ * The message of a failed Codex HTTP response, and a usage-limit explanation for a 429 or a
+ * usage-limit error code, with the plan and reset time when the body gives them.
+ */
+export declare function parseErrorResponse(raw: string, response: Response): {
+    message: string;
+    friendlyMessage?: string;
+};
+export {};

package/dist/src/api/openai-codex-protocol.js

@@ -0,0 +1,48 @@
+import {
+  DEFAULT_MAX_RETRIES2,
+  CODEX_TOOL_CALL_PROVIDERS2,
+  compressRequestBodyZstd2,
+  buildRequestBody2,
+  resolveCodexServiceTier2,
+  codexStreamOptions2,
+  CodexRequestError2,
+  retryableCodexRequest2,
+  CodexApiError2,
+  CodexProtocolError2,
+  extractCodexEventError2,
+  mapCodexEvents2,
+  parseSSE2,
+  parseErrorResponse2
+} from "../../chunks/account-limits-cache-vwgfz727.js";
+import"../../chunks/account-limits-cache-n3yk6g5c.js";
+import"../../chunks/account-limits-cache-8qzk56vj.js";
+import"../../chunks/account-limits-cache-h92bzz1j.js";
+import"../../chunks/account-limits-cache-eqwweapz.js";
+import"../../chunks/account-limits-cache-me1x57bs.js";
+import"../../chunks/account-limits-cache-0af5gqeg.js";
+import"../../chunks/account-limits-cache-8s8bz4dr.js";
+import"../../chunks/account-limits-cache-hj3ek3ty.js";
+import"../../chunks/account-limits-cache-fvadc36m.js";
+import"../../chunks/account-limits-cache-ehy0ze2b.js";
+import"../../chunks/account-limits-cache-b4edaybk.js";
+import"../../chunks/account-limits-cache-6250ykn6.js";
+import"../../chunks/account-limits-cache-gknnm1kv.js";
+import"../../chunks/account-limits-cache-ag5b8dja.js";
+import"../../chunks/account-limits-cache-9wqk28n5.js";
+import"../../chunks/account-limits-cache-f9z00x8c.js";
+export {
+  CODEX_TOOL_CALL_PROVIDERS2 as CODEX_TOOL_CALL_PROVIDERS,
+  CodexApiError2 as CodexApiError,
+  CodexProtocolError2 as CodexProtocolError,
+  CodexRequestError2 as CodexRequestError,
+  DEFAULT_MAX_RETRIES2 as DEFAULT_MAX_RETRIES,
+  buildRequestBody2 as buildRequestBody,
+  codexStreamOptions2 as codexStreamOptions,
+  compressRequestBodyZstd2 as compressRequestBodyZstd,
+  extractCodexEventError2 as extractCodexEventError,
+  mapCodexEvents2 as mapCodexEvents,
+  parseErrorResponse2 as parseErrorResponse,
+  parseSSE2 as parseSSE,
+  resolveCodexServiceTier2 as resolveCodexServiceTier,
+  retryableCodexRequest2 as retryableCodexRequest
+};

package/dist/src/api/openai-codex-responses.d.ts

@@ -0,0 +1,4 @@
+import type { SimpleStreamOptions, StreamFunction } from "../types.ts";
+import { type OpenAICodexResponsesOptions } from "./openai-codex-protocol.ts";
+export declare const stream: StreamFunction<"openai-codex-responses", OpenAICodexResponsesOptions>;
+export declare const streamSimple: StreamFunction<"openai-codex-responses", SimpleStreamOptions>;