@nyte-ai/ai 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,175 @@
+import {
+  headersToRecord2
+} from "../../chunks/account-limits-cache-ag5b8dja.js";
+import"../../chunks/account-limits-cache-gknnm1kv.js";
+import {
+  normalizeTimeoutMs2,
+  resolveCodexUrl2,
+  extractAccountId2,
+  buildSSEHeaders2,
+  buildWebSocketHeaders2
+} from "../../chunks/account-limits-cache-fvadc36m.js";
+import"../../chunks/account-limits-cache-ehy0ze2b.js";
+import {
+  codexHeaderLimits2
+} from "../../chunks/account-limits-cache-hj3ek3ty.js";
+import {
+  formatThrownValue2
+} from "../../chunks/account-limits-cache-9wqk28n5.js";
+import {
+  reportsQuotaExhaustion2
+} from "../../chunks/account-limits-cache-xds88kxd.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+import {
+  retryProviderRequest2
+} from "../../chunks/account-limits-cache-nbhht7xz.js";
+import {
+  getDeclaredTools2,
+  resolveTranscript2
+} from "../../chunks/account-limits-cache-6250ykn6.js";
+import {
+  uuidv72
+} from "../../chunks/account-limits-cache-8137j3zp.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import {
+  runAssistantStream2
+} from "../../chunks/account-limits-cache-fsktnetm.js";
+import {
+  createGrammarToolInputProperties2
+} from "../../chunks/account-limits-cache-h92bzz1j.js";
+import"../../chunks/account-limits-cache-f9z00x8c.js";
+import"../../chunks/account-limits-cache-8s8bz4dr.js";
+import"../../chunks/account-limits-cache-me1x57bs.js";
+import"../../chunks/account-limits-cache-b4edaybk.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 {
+  compressRequestBodyZstd2,
+  buildRequestBody2,
+  codexStreamOptions2,
+  CodexRequestError2,
+  retryableCodexRequest2,
+  mapCodexEvents2,
+  parseSSE2,
+  parseErrorResponse2
+} from "../../chunks/account-limits-cache-vwgfz727.js";
+import"../../chunks/account-limits-cache-gqsrbky9.js";
+import"../../chunks/account-limits-cache-b23sbrke.js";
+import"../../chunks/account-limits-cache-0yd6bde8.js";
+import"../../chunks/account-limits-cache-zgzptd0z.js";
+import"../../chunks/account-limits-cache-fbkaq46e.js";
+import"../../chunks/account-limits-cache-736tdyme.js";
+import"../../chunks/account-limits-cache-a558rjbg.js";
+import {
+  withPriorityTier2,
+  processResponsesStream2
+} from "../../chunks/account-limits-cache-53e64mhx.js";
+import {
+  streamOverWebSocket2
+} from "../../chunks/account-limits-cache-hwehc67r.js";
+import {
+  clampOpenAIPromptCacheKey2
+} from "../../chunks/account-limits-cache-csbxvam7.js";
+import"../../chunks/account-limits-cache-dejeygdt.js";
+import {
+  buildBaseOptions2,
+  simpleReasoningEffort2
+} from "../../chunks/account-limits-cache-k0pkzhbx.js";
+
+// src/api/openai-codex-responses.ts
+async function openCodexSse(model, headers, body, timeoutMs, options) {
+  const headerTimeout = new AbortController;
+  const timer = timeoutMs !== undefined && timeoutMs > 0 ? setTimeout(() => headerTimeout.abort(), timeoutMs) : undefined;
+  const signal = options?.signal ? AbortSignal.any([options.signal, headerTimeout.signal]) : headerTimeout.signal;
+  let response;
+  try {
+    response = await (options?.fetch ?? globalThis.fetch)(resolveCodexUrl2(model.baseUrl), {
+      method: "POST",
+      headers,
+      body,
+      signal
+    });
+  } catch (cause) {
+    if (options?.signal?.aborted)
+      throw cause;
+    throw new CodexRequestError2(headerTimeout.signal.aborted ? `Codex SSE response headers timed out after ${String(timeoutMs)}ms` : formatThrownValue2(cause), undefined, undefined, true, { cause });
+  } finally {
+    clearTimeout(timer);
+  }
+  const responseHeaders = headersToRecord2(response.headers);
+  await options?.onResponse?.({ status: response.status, headers: responseHeaders }, model);
+  if (response.ok) {
+    if (options?.onAccountLimits !== undefined) {
+      const limits = codexHeaderLimits2(responseHeaders, model.provider);
+      if (limits !== undefined)
+        await options.onAccountLimits(limits, model);
+    }
+    return response;
+  }
+  const errorText = await response.text();
+  const info = parseErrorResponse2(errorText, response);
+  throw new CodexRequestError2(info.friendlyMessage || info.message, response.status, response.headers, !(response.status === 429 && reportsQuotaExhaustion2(errorText)));
+}
+async function streamOverSse(request, headers, output, stream) {
+  const { model, options } = request;
+  const bodyJson = JSON.stringify(request.body);
+  const compressedBody = compressRequestBodyZstd2(bodyJson);
+  if (compressedBody)
+    headers.set("content-encoding", "zstd");
+  const response = await retryProviderRequest2(() => openCodexSse(model, headers, compressedBody ?? bodyJson, request.timeoutMs, options), {
+    maxRetries: options?.maxRetries,
+    maxRetryDelayMs: options?.maxRetryDelayMs,
+    signal: options?.signal,
+    retryable: retryableCodexRequest2
+  });
+  if (!response.body)
+    throw new Error("No response body");
+  stream.push({ type: "start", partial: output });
+  await processResponsesStream2(mapCodexEvents2(parseSSE2(response, options?.signal), output), output, stream, model, codexStreamOptions2(request));
+}
+var stream = (model, context, requested) => {
+  const options = withPriorityTier2(requested);
+  const normalizedContext = resolveTranscript2(context, model.compat?.supportsMidConvoSystemMessages);
+  return runAssistantStream2(model, options?.signal, "Codex", async (output, stream) => {
+    const apiKey = options?.apiKey;
+    if (!apiKey) {
+      throw new Error(`No API key for provider: ${model.provider}`);
+    }
+    const accountId = extractAccountId2(apiKey);
+    const grammarToolInputProperties = createGrammarToolInputProperties2(getDeclaredTools2(normalizedContext.messages), model.compat?.supportsOpenAIGrammarTools ?? false);
+    const cacheSessionId = options?.cacheRetention === "none" ? undefined : options?.sessionId;
+    const codexSessionId = clampOpenAIPromptCacheKey2(cacheSessionId);
+    const body = buildRequestBody2(model, normalizedContext, options, codexSessionId, grammarToolInputProperties);
+    await options?.onPayload?.(body, model);
+    const request = {
+      model,
+      body,
+      accountId,
+      cacheSessionId,
+      grammarToolInputProperties,
+      timeoutMs: normalizeTimeoutMs2(options?.timeoutMs),
+      connectTimeoutMs: normalizeTimeoutMs2(options?.websocketConnectTimeoutMs),
+      options
+    };
+    const websocketHeaders = buildWebSocketHeaders2(model.headers, options?.headers, accountId, apiKey, codexSessionId || uuidv72());
+    if (await streamOverWebSocket2(request, websocketHeaders, output, stream))
+      return;
+    await streamOverSse(request, buildSSEHeaders2(model.headers, options?.headers, accountId, apiKey, codexSessionId), output, stream);
+  });
+};
+var streamSimple = (model, context, options) => {
+  if (!options?.apiKey)
+    throw new Error(`No API key for provider: ${model.provider}`);
+  return stream(model, context, {
+    ...buildBaseOptions2(model, context, options),
+    reasoningEffort: simpleReasoningEffort2(model, options.reasoning)
+  });
+};
+export {
+  stream,
+  streamSimple
+};

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

@@ -0,0 +1,2 @@
+import type { ProviderStreams } from "../types.ts";
+export declare const openAICodexResponsesApi: () => ProviderStreams;

package/dist/src/api/openai-codex-responses.lazy.js

@@ -0,0 +1,11 @@
+import {
+  openAICodexResponsesApi2
+} from "../../chunks/account-limits-cache-5rx2pfm5.js";
+import"../../chunks/account-limits-cache-90c9c2eb.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+export {
+  openAICodexResponsesApi2 as openAICodexResponsesApi
+};

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

@@ -0,0 +1,13 @@
+import type { AssistantMessage } from "../types.ts";
+import type { AssistantMessageEventStream } from "../utils/event-stream.ts";
+import { type CodexRequest } from "./openai-codex-protocol.ts";
+/** Closes the cached sockets of `sessionId`, or of every session, and forgets their SSE fallback. */
+export declare function closeOpenAICodexWebSocketSessions(sessionId?: string): void;
+/**
+ * Streams `request` over a Codex WebSocket into `output`, pushing `start` on the first event.
+ * One retry each covers a missing continuation and a connection limit hit before any event.
+ * A transport failure before any event records a diagnostic, moves the session onto SSE and
+ * returns false so the caller sends the request over SSE; protocol and API failures, and any
+ * failure after the first event, throw.
+ */
+export declare function streamOverWebSocket(request: CodexRequest, headers: Headers, output: AssistantMessage, stream: AssistantMessageEventStream): Promise<boolean>;

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

@@ -0,0 +1,37 @@
+import {
+  closeOpenAICodexWebSocketSessions2,
+  streamOverWebSocket2
+} from "../../chunks/account-limits-cache-hwehc67r.js";
+import"../../chunks/account-limits-cache-53e64mhx.js";
+import"../../chunks/account-limits-cache-a558rjbg.js";
+import"../../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-736tdyme.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-0yd6bde8.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-fbkaq46e.js";
+import"../../chunks/account-limits-cache-gknnm1kv.js";
+import"../../chunks/account-limits-cache-ag5b8dja.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-9wqk28n5.js";
+import"../../chunks/account-limits-cache-gqsrbky9.js";
+import"../../chunks/account-limits-cache-b23sbrke.js";
+import"../../chunks/account-limits-cache-zgzptd0z.js";
+import"../../chunks/account-limits-cache-f9z00x8c.js";
+export {
+  closeOpenAICodexWebSocketSessions2 as closeOpenAICodexWebSocketSessions,
+  streamOverWebSocket2 as streamOverWebSocket
+};

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

@@ -0,0 +1,44 @@
+/**
+ * The ChatGPT Codex backend's wire basics: endpoint URLs, the account id inside the OAuth
+ * token, request headers, and the raw frame both transports decode.
+ */
+import { Type } from "typebox";
+import type { ProviderHeaders } from "../types.ts";
+/**
+ * The fields this adapter acts on in a raw Codex SSE/WebSocket frame. Frames
+ * carry more fields; unlisted ones pass through untouched. Decoding happens once
+ * at the two ingress points (`parseSSE`, `parseWebSocket`) so downstream code
+ * branches on decoded values instead of re-narrowing raw JSON.
+ */
+export interface CodexFrame {
+    readonly type: string;
+    readonly code?: unknown;
+    readonly message?: unknown;
+    readonly error?: unknown;
+    readonly response?: unknown;
+    readonly item?: unknown;
+}
+export declare const CodexFrameJson: Type.TObject<{
+    type: Type.TString;
+}>;
+/** `value` when it is a string. */
+export declare function readText(value: unknown): string | undefined;
+/** `value` when it is a boolean. */
+export declare function readBoolean(value: unknown): boolean | undefined;
+/** `value` when it is a number. */
+export declare function readNumber(value: unknown): number | undefined;
+/** `value` when it is a JSON object. */
+export declare function readRecord(value: unknown): Record<string, unknown> | undefined;
+/** Frame types that end a Codex response. */
+export declare const TERMINAL_RESPONSE_TYPES: ReadonlySet<string>;
+export declare const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+/** A caller timeout floored to whole milliseconds; a negative or non-finite one is rejected. */
+export declare function normalizeTimeoutMs(value: number | undefined): number | undefined;
+export declare function resolveCodexUrl(baseUrl?: string): string;
+export declare function resolveCodexWebSocketUrl(baseUrl?: string): string;
+/** The ChatGPT account id from the OAuth access token's JWT payload. */
+export declare function extractAccountId(token: string): string;
+/** Model and caller headers plus the Codex identity every request carries. */
+export declare function buildBaseCodexHeaders(initHeaders: Record<string, string> | undefined, additionalHeaders: ProviderHeaders | undefined, accountId: string, token: string): Headers;
+export declare function buildSSEHeaders(initHeaders: Record<string, string> | undefined, additionalHeaders: ProviderHeaders | undefined, accountId: string, token: string, sessionId?: string): Headers;
+export declare function buildWebSocketHeaders(initHeaders: Record<string, string> | undefined, additionalHeaders: ProviderHeaders | undefined, accountId: string, token: string, requestId: string): Headers;

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

@@ -0,0 +1,34 @@
+import {
+  CodexFrameJson2,
+  readText2,
+  readBoolean2,
+  readNumber2,
+  readRecord2,
+  TERMINAL_RESPONSE_TYPES2,
+  DEFAULT_CODEX_BASE_URL2,
+  normalizeTimeoutMs2,
+  resolveCodexUrl2,
+  resolveCodexWebSocketUrl2,
+  extractAccountId2,
+  buildBaseCodexHeaders2,
+  buildSSEHeaders2,
+  buildWebSocketHeaders2
+} from "../../chunks/account-limits-cache-fvadc36m.js";
+import"../../chunks/account-limits-cache-gknnm1kv.js";
+import"../../chunks/account-limits-cache-ag5b8dja.js";
+export {
+  CodexFrameJson2 as CodexFrameJson,
+  DEFAULT_CODEX_BASE_URL2 as DEFAULT_CODEX_BASE_URL,
+  TERMINAL_RESPONSE_TYPES2 as TERMINAL_RESPONSE_TYPES,
+  buildBaseCodexHeaders2 as buildBaseCodexHeaders,
+  buildSSEHeaders2 as buildSSEHeaders,
+  buildWebSocketHeaders2 as buildWebSocketHeaders,
+  extractAccountId2 as extractAccountId,
+  normalizeTimeoutMs2 as normalizeTimeoutMs,
+  readBoolean2 as readBoolean,
+  readNumber2 as readNumber,
+  readRecord2 as readRecord,
+  readText2 as readText,
+  resolveCodexUrl2 as resolveCodexUrl,
+  resolveCodexWebSocketUrl2 as resolveCodexWebSocketUrl
+};

package/dist/src/api/openai-compact.d.ts

@@ -0,0 +1,9 @@
+import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+import type { Api, JsonValue, Model, Usage } from "../types.ts";
+export interface OpenAICompactResult {
+    /** The complete opaque window, replayed unchanged to the matching provider. */
+    readonly data: JsonValue;
+    readonly usage?: Usage;
+}
+/** Decode the JSON envelope; provider-owned item contents remain opaque. */
+export declare function readOpenAICompactResponse(response: Response, model: Model<Api>, requestedServiceTier?: ResponseCreateParamsStreaming["service_tier"]): Promise<OpenAICompactResult>;

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

@@ -0,0 +1,12 @@
+import {
+  readOpenAICompactResponse2
+} from "../../chunks/account-limits-cache-pfr14mcn.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-zgzptd0z.js";
+import"../../chunks/account-limits-cache-f9z00x8c.js";
+export {
+  readOpenAICompactResponse2 as readOpenAICompactResponse
+};

package/dist/src/api/openai-completions-convert.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Conversion of the neutral transcript and tools into Chat Completions
+ * messages, the catalog compat they follow, and Anthropic-style cache control.
+ */
+import OpenAI from "openai";
+import type { ChatCompletionMessageParam } from "openai/resources/chat/completions.js";
+import type { CacheRetention, Model, OpenAICompletionsCompat, Tool, TranscriptContext } from "../types.ts";
+interface ConvertCompletionsMessagesOptions {
+    grammarToolInputProperties?: ReadonlyMap<string, string>;
+}
+export type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "cacheControlFormat" | "deferredToolsMode" | "supportsThinkingTokenBudget" | "thinkingTokenBudgetField" | "supportsMidConvoSystemMessages" | "supportsMidConvoToolAdditions"> & {
+    cacheControlFormat?: OpenAICompletionsCompat["cacheControlFormat"];
+    deferredToolsMode?: OpenAICompletionsCompat["deferredToolsMode"];
+    supportsThinkingTokenBudget?: OpenAICompletionsCompat["supportsThinkingTokenBudget"];
+    thinkingTokenBudgetField?: OpenAICompletionsCompat["thinkingTokenBudgetField"];
+    supportsMidConvoSystemMessages?: OpenAICompletionsCompat["supportsMidConvoSystemMessages"];
+    supportsMidConvoToolAdditions?: OpenAICompletionsCompat["supportsMidConvoToolAdditions"];
+};
+/**
+ * The model's compat over the defaults. The catalog generator stamps every provider quirk onto
+ * `model.compat`, so nothing here sniffs the provider name or base URL.
+ */
+export declare function resolveCompat(model: Model<"openai-completions">): ResolvedOpenAICompletionsCompat;
+type KimiToolSystemMessageParam = {
+    role: "system";
+    content?: never;
+    tools?: OpenAI.Chat.Completions.ChatCompletionTool[];
+};
+export type CompletionsMessage = ChatCompletionMessageParam | KimiToolSystemMessageParam;
+interface OpenAICompatCacheControl {
+    type: "ephemeral";
+    ttl?: string;
+}
+export declare function getCompatCacheControl(compat: ResolvedOpenAICompletionsCompat, cacheRetention: CacheRetention): OpenAICompatCacheControl | undefined;
+export declare function applyAnthropicCacheControl(messages: CompletionsMessage[], tools: OpenAI.Chat.Completions.ChatCompletionTool[] | undefined, cacheControl: OpenAICompatCacheControl): void;
+/**
+ * The transcript as Chat Completions messages, shaped by the model's compat.
+ *
+ * - Tool results load request-list tools through `addedToolNames` only in Kimi mode; anchored
+ *   additions are not in the request list, so neither path declares a tool twice.
+ * - Some providers reject a user message right after tool results, so a synthetic assistant
+ *   message bridges the gap; some reject null assistant content, so it is an empty string.
+ * - Copilot accepts reasoning text only alongside its opaque state; text without the state is
+ *   dropped rather than replayed as a bare field.
+ * - Thinking replayed as text carries no tags, so the model does not mimic them.
+ * - `reasoning_details` is the structured alternative to a raw reasoning field; without it the
+ *   first thinking block's signature names the field (llama.cpp server with gpt-oss).
+ * - Assistant messages with neither content nor tool calls are skipped: providers require one
+ *   of them, and aborted responses can have neither.
+ * - Every tool result carries text, a placeholder when it has only images, and its tool name
+ *   for providers that require it.
+ */
+export declare function convertMessages(model: Model<"openai-completions">, context: TranscriptContext, compat: ResolvedOpenAICompletionsCompat, options?: ConvertCompletionsMessagesOptions): CompletionsMessage[];
+/**
+ * Only include strict if provider supports it. Some reject unknown fields.
+ */
+export declare function convertTools(tools: Tool[], compat: ResolvedOpenAICompletionsCompat): OpenAI.Chat.Completions.ChatCompletionTool[];
+export {};

package/dist/src/api/openai-completions-convert.js

@@ -0,0 +1,21 @@
+import {
+  resolveCompat2,
+  getCompatCacheControl2,
+  applyAnthropicCacheControl2,
+  convertMessages2,
+  convertTools2
+} from "../../chunks/account-limits-cache-fdwad56n.js";
+import"../../chunks/account-limits-cache-hj1h48sc.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-0af5gqeg.js";
+import"../../chunks/account-limits-cache-b4edaybk.js";
+import"../../chunks/account-limits-cache-6250ykn6.js";
+export {
+  applyAnthropicCacheControl2 as applyAnthropicCacheControl,
+  convertMessages2 as convertMessages,
+  convertTools2 as convertTools,
+  getCompatCacheControl2 as getCompatCacheControl,
+  resolveCompat2 as resolveCompat
+};

package/dist/src/api/openai-completions-params.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The Chat Completions request body: options, token limits, tools, and each
+ * server family's reasoning parameters.
+ */
+import OpenAI from "openai";
+import type { CacheRetention, Model, StreamOptions, ThinkingBudgets, TranscriptContext } from "../types.ts";
+import { type ResolvedOpenAICompletionsCompat, type CompletionsMessage } from "./openai-completions-convert.ts";
+export interface OpenAICompletionsOptions extends StreamOptions {
+    toolChoice?: OpenAI.Chat.Completions.ChatCompletionToolChoiceOption;
+    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    /** Token budgets per thinking level. Used when `compat.thinkingTokenBudgetField` or `compat.supportsThinkingTokenBudget` is set, or by `{ "$var": "thinking.budget" }`. */
+    thinkingBudgets?: ThinkingBudgets;
+}
+type CompletionsRequest = Omit<OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming, "messages"> & {
+    messages: CompletionsMessage[];
+};
+/**
+ * The Chat Completions request body.
+ *
+ * - A transcript with tool history always sends `tools`, empty if need be: Anthropic behind
+ *   LiteLLM-style proxies requires it whenever messages carry tool calls or results.
+ * - OpenRouter normalizes reasoning across providers through a nested `reasoning` object.
+ * - A top-level thinking budget field caps reasoning independently of `thinkingFormat`, since one
+ *   server can serve zai, qwen or chat-template models. Reasoning and the answer share
+ *   `max_tokens` there, so uncapped reasoning can consume the whole response.
+ * - `samplingParams` merge last, so custom keys override the named request fields.
+ */
+export declare function buildParams(model: Model<"openai-completions">, context: TranscriptContext, options?: OpenAICompletionsOptions, compat?: ResolvedOpenAICompletionsCompat, cacheRetention?: CacheRetention, grammarToolInputProperties?: ReadonlyMap<string, string>): CompletionsRequest;
+export {};

package/dist/src/api/openai-completions-params.js

@@ -0,0 +1,20 @@
+import {
+  buildParams2
+} from "../../chunks/account-limits-cache-zn01kscn.js";
+import"../../chunks/account-limits-cache-fdwad56n.js";
+import"../../chunks/account-limits-cache-hj1h48sc.js";
+import"../../chunks/account-limits-cache-csbxvam7.js";
+import"../../chunks/account-limits-cache-k0pkzhbx.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-0af5gqeg.js";
+import"../../chunks/account-limits-cache-b4edaybk.js";
+import"../../chunks/account-limits-cache-6250ykn6.js";
+import"../../chunks/account-limits-cache-dejeygdt.js";
+import"../../chunks/account-limits-cache-d2a51dka.js";
+import"../../chunks/account-limits-cache-b23sbrke.js";
+import"../../chunks/account-limits-cache-zgzptd0z.js";
+export {
+  buildParams2 as buildParams
+};

package/dist/src/api/openai-completions-reasoning.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Reasoning replay data on OpenAI-compatible Chat Completions: OpenRouter
+ * `reasoning_details`, the raw reasoning fields servers stream, and Copilot's
+ * `reasoning_opaque` state.
+ */
+import { Type, type Static } from "typebox";
+export declare const OpenAIReasoningDetailSchema: Type.TUnion<[Type.TObject<{
+    type: Type.TLiteral<"reasoning.summary">;
+    summary: Type.TString;
+    id: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    format: Type.TOptional<Type.TString>;
+    index: Type.TOptional<Type.TNumber>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"reasoning.encrypted">;
+    data: Type.TString;
+    id: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    format: Type.TOptional<Type.TString>;
+    index: Type.TOptional<Type.TNumber>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"reasoning.text">;
+    text: Type.TString;
+    signature: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    id: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    format: Type.TOptional<Type.TString>;
+    index: Type.TOptional<Type.TNumber>;
+}>]>;
+export type OpenAIReasoningDetail = Static<typeof OpenAIReasoningDetailSchema>;
+type OpenAIEncryptedReasoningDetail = Extract<OpenAIReasoningDetail, {
+    type: "reasoning.encrypted";
+}>;
+export declare function parseOpenAIReasoningDetails(signature: string | undefined): OpenAIReasoningDetail[] | undefined;
+export declare function parseLegacyEncryptedReasoningDetail(signature: string | undefined): OpenAIEncryptedReasoningDetail | undefined;
+export declare function appendOpenAIReasoningDetail(details: OpenAIReasoningDetail[], detail: OpenAIReasoningDetail): void;
+declare const OPENAI_COMPLETIONS_REASONING_FIELDS: readonly ["reasoning", "reasoning_content", "reasoning_text"];
+export type OpenAICompletionsReasoningField = (typeof OPENAI_COMPLETIONS_REASONING_FIELDS)[number];
+export declare const OpenAICompletionsReasoningFieldSchema: Type.TEnum<["reasoning", "reasoning_content", "reasoning_text"]>;
+/**
+ * Copilot continues a model's reasoning across turns only when the assistant
+ * message replays `reasoning_opaque`; it rides in the thinking signature.
+ */
+export declare const CopilotReasoningOpaqueSchema: Type.TObject<{
+    reasoning_opaque: Type.TString;
+}>;
+export declare const REASONING_DELTA_SCHEMAS: {
+    field: "reasoning" | "reasoning_content" | "reasoning_text";
+    schema: Type.TObject<{
+        [x: string]: Type.TString;
+    }>;
+}[];
+export declare const ReasoningDetailsDeltaSchema: Type.TObject<{
+    reasoning_details: Type.TArray<Type.TUnknown>;
+}>;
+export declare function parseCopilotReasoningOpaque(signature: string | undefined): string | undefined;
+export {};

package/dist/src/api/openai-completions-reasoning.js

@@ -0,0 +1,22 @@
+import {
+  OpenAIReasoningDetailSchema2,
+  parseOpenAIReasoningDetails2,
+  parseLegacyEncryptedReasoningDetail2,
+  appendOpenAIReasoningDetail2,
+  OpenAICompletionsReasoningFieldSchema2,
+  CopilotReasoningOpaqueSchema2,
+  REASONING_DELTA_SCHEMAS2,
+  ReasoningDetailsDeltaSchema2,
+  parseCopilotReasoningOpaque2
+} from "../../chunks/account-limits-cache-hj1h48sc.js";
+export {
+  CopilotReasoningOpaqueSchema2 as CopilotReasoningOpaqueSchema,
+  OpenAICompletionsReasoningFieldSchema2 as OpenAICompletionsReasoningFieldSchema,
+  OpenAIReasoningDetailSchema2 as OpenAIReasoningDetailSchema,
+  REASONING_DELTA_SCHEMAS2 as REASONING_DELTA_SCHEMAS,
+  ReasoningDetailsDeltaSchema2 as ReasoningDetailsDeltaSchema,
+  appendOpenAIReasoningDetail2 as appendOpenAIReasoningDetail,
+  parseCopilotReasoningOpaque2 as parseCopilotReasoningOpaque,
+  parseLegacyEncryptedReasoningDetail2 as parseLegacyEncryptedReasoningDetail,
+  parseOpenAIReasoningDetails2 as parseOpenAIReasoningDetails
+};

package/dist/src/api/openai-completions.d.ts

@@ -0,0 +1,22 @@
+import type { SimpleStreamOptions, StreamFunction } from "../types.ts";
+import { type OpenAICompletionsOptions } from "./openai-completions-params.ts";
+/**
+ * Streams a Chat Completions response.
+ *
+ * - The chunk id is the completion id: OpenAI documents it as unique per completion and every
+ *   chunk of a stream carries the same one.
+ * - Usage comes from `chunk.usage`, or from `choice.usage` where providers such as Moonshot put it.
+ * - Reasoning text arrives in `reasoning_content` (llama.cpp), `reasoning`, or `reasoning_text`;
+ *   only the first non-empty field counts, since some servers (chutes.ai) send the same text twice.
+ * - `reasoning_details` are replay metadata, not display deltas. OpenRouter streams them as
+ *   deltas: consecutive text and summary entries merge, encrypted entries stay opaque and
+ *   discrete. They stay in memory and serialize into the thinking signature once at the end.
+ * - Copilot's `reasoning_opaque` arrives with the first text delta or after all reasoning text and
+ *   is never a display delta. It lives in the thinking signature, which later reasoning text
+ *   never rewrites; one response carries one state, as in OpenCode's Copilot adapter.
+ * - Finished tool calls drop their scratch buffers, so replay carries only parsed arguments.
+ * - The SDK rejects a present-but-undefined timeout instead of using its default, so it is set
+ *   only when given.
+ */
+export declare const stream: StreamFunction<"openai-completions", OpenAICompletionsOptions>;
+export declare const streamSimple: StreamFunction<"openai-completions", SimpleStreamOptions>;