@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/src/api/google-generative-ai.js

@@ -0,0 +1,583 @@
+import {
+  calculateCost2,
+  clampThinkingLevel2
+} from "../../chunks/account-limits-cache-zgzptd0z.js";
+import {
+  providerHeadersToRecord2
+} from "../../chunks/account-limits-cache-ag5b8dja.js";
+import {
+  getNyteUserAgent2
+} from "../../chunks/account-limits-cache-gknnm1kv.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+import {
+  retryProviderRequest2
+} from "../../chunks/account-limits-cache-nbhht7xz.js";
+import {
+  sanitizeSurrogates2
+} from "../../chunks/account-limits-cache-eqwweapz.js";
+import {
+  getSystemMessageText2
+} from "../../chunks/account-limits-cache-b4edaybk.js";
+import {
+  collapseSystemMessages2,
+  getCurrentTools2,
+  getInitialSystemMessage2,
+  withoutInitialSystemMessage2
+} 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,
+  runAssistantStream2
+} from "../../chunks/account-limits-cache-fsktnetm.js";
+import {
+  getJsonSchemaToolParameters2,
+  resolveJsonSchemaStrictSampling2
+} from "../../chunks/account-limits-cache-h92bzz1j.js";
+import"../../chunks/account-limits-cache-dejeygdt.js";
+import {
+  buildBaseOptions2
+} from "../../chunks/account-limits-cache-k0pkzhbx.js";
+import {
+  transformMessages2
+} from "../../chunks/account-limits-cache-8qzk56vj.js";
+
+// src/api/google-generative-ai.ts
+import {
+  FinishReason,
+  FunctionCallingConfigMode,
+  GoogleGenAI,
+  ThinkingLevel as GoogleThinkingLevel
+} from "@google/genai";
+var toolCallCounter = 0;
+var stream = (model, context, options) => {
+  const normalizedContext = collapseSystemMessages2(context);
+  return runAssistantStream2(model, options?.signal, "Google", async (output, stream) => {
+    if (options?.fetch && options.fetch !== globalThis.fetch) {
+      throw new Error("Custom fetch is not supported by the Google Generative AI adapter");
+    }
+    const apiKey = options?.apiKey;
+    if (!apiKey) {
+      throw new Error(`No API key for provider: ${model.provider}`);
+    }
+    const client = createClient(model, apiKey, options?.headers);
+    const params = buildParams(model, normalizedContext, options);
+    await options?.onPayload?.(params, model);
+    const googleStream = await retryGoogleRequest(() => client.models.generateContentStream(params), options);
+    stream.push({ type: "start", partial: output });
+    let currentBlock = null;
+    const blocks = output.content;
+    const blockIndex = () => blocks.length - 1;
+    for await (const chunk of googleStream) {
+      output.responseId ||= chunk.responseId;
+      const candidate = chunk.candidates?.[0];
+      if (candidate?.content?.parts) {
+        for (const part of candidate.content.parts) {
+          if (part.text !== undefined) {
+            const isThinking = part.thought === true;
+            if (!currentBlock || isThinking && currentBlock.type !== "thinking" || !isThinking && currentBlock.type !== "text") {
+              if (currentBlock) {
+                if (currentBlock.type === "text") {
+                  stream.push({
+                    type: "text_end",
+                    contentIndex: blocks.length - 1,
+                    content: currentBlock.text,
+                    partial: output
+                  });
+                } else {
+                  stream.push({
+                    type: "thinking_end",
+                    contentIndex: blockIndex(),
+                    content: currentBlock.thinking,
+                    partial: output
+                  });
+                }
+              }
+              if (isThinking) {
+                currentBlock = { type: "thinking", thinking: "", thinkingSignature: undefined };
+                output.content.push(currentBlock);
+                stream.push({
+                  type: "thinking_start",
+                  contentIndex: blockIndex(),
+                  partial: output
+                });
+              } else {
+                currentBlock = { type: "text", text: "" };
+                output.content.push(currentBlock);
+                stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+              }
+            }
+            if (currentBlock.type === "thinking") {
+              currentBlock.thinking += part.text;
+              currentBlock.thinkingSignature = retainThoughtSignature(currentBlock.thinkingSignature, part.thoughtSignature);
+              stream.push({
+                type: "thinking_delta",
+                contentIndex: blockIndex(),
+                delta: part.text,
+                partial: output
+              });
+            } else {
+              currentBlock.text += part.text;
+              currentBlock.textSignature = retainThoughtSignature(currentBlock.textSignature, part.thoughtSignature);
+              stream.push({
+                type: "text_delta",
+                contentIndex: blockIndex(),
+                delta: part.text,
+                partial: output
+              });
+            }
+          }
+          if (part.functionCall) {
+            if (currentBlock) {
+              if (currentBlock.type === "text") {
+                stream.push({
+                  type: "text_end",
+                  contentIndex: blockIndex(),
+                  content: currentBlock.text,
+                  partial: output
+                });
+              } else {
+                stream.push({
+                  type: "thinking_end",
+                  contentIndex: blockIndex(),
+                  content: currentBlock.thinking,
+                  partial: output
+                });
+              }
+              currentBlock = null;
+            }
+            const providedId = part.functionCall.id;
+            const needsNewId = !providedId || output.content.some((b) => b.type === "toolCall" && b.id === providedId);
+            const toolCallId = needsNewId ? `${part.functionCall.name}_${Date.now()}_${++toolCallCounter}` : providedId;
+            const toolCall = {
+              type: "toolCall",
+              id: toolCallId,
+              name: part.functionCall.name || "",
+              arguments: part.functionCall.args ?? {},
+              ...part.thoughtSignature && { thoughtSignature: part.thoughtSignature }
+            };
+            output.content.push(toolCall);
+            stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+            stream.push({
+              type: "toolcall_delta",
+              contentIndex: blockIndex(),
+              delta: JSON.stringify(toolCall.arguments),
+              partial: output
+            });
+            stream.push({
+              type: "toolcall_end",
+              contentIndex: blockIndex(),
+              toolCall,
+              partial: output
+            });
+          }
+        }
+      }
+      if (candidate?.finishReason) {
+        output.rawStopReason = candidate.finishReason;
+        output.stopReason = mapStopReason(candidate.finishReason);
+        if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
+          output.stopReason = "toolUse";
+        }
+      }
+      if (chunk.usageMetadata) {
+        output.usage = {
+          input: (chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
+          output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
+          cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
+          cacheWrite: 0,
+          reasoning: chunk.usageMetadata.thoughtsTokenCount || 0,
+          totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+          cost: emptyCost2()
+        };
+        calculateCost2(model, output.usage);
+      }
+    }
+    if (currentBlock) {
+      if (currentBlock.type === "text") {
+        stream.push({
+          type: "text_end",
+          contentIndex: blockIndex(),
+          content: currentBlock.text,
+          partial: output
+        });
+      } else {
+        stream.push({
+          type: "thinking_end",
+          contentIndex: blockIndex(),
+          content: currentBlock.thinking,
+          partial: output
+        });
+      }
+    }
+    if (output.stopReason === "error" && output.rawStopReason) {
+      output.errorMessage = `Provider stopped with: ${output.rawStopReason}`;
+    }
+  });
+};
+var streamSimple = (model, context, options) => {
+  const apiKey = options?.apiKey;
+  if (!apiKey) {
+    throw new Error(`No API key for provider: ${model.provider}`);
+  }
+  const base = buildBaseOptions2(model, context, options);
+  if (!options?.reasoning) {
+    return stream(model, context, {
+      ...base,
+      thinking: { enabled: false }
+    });
+  }
+  const clampedReasoning = clampThinkingLevel2(model, options.reasoning);
+  if (clampedReasoning === "off") {
+    return stream(model, context, {
+      ...base,
+      thinking: { enabled: false }
+    });
+  }
+  const resolvedLevel = resolveGoogleThinkingLevel(model, clampedReasoning);
+  if (usesGoogleThinkingLevel(model)) {
+    return stream(model, context, {
+      ...base,
+      thinking: {
+        enabled: true,
+        level: toGoogleThinkingLevel(resolvedLevel)
+      }
+    });
+  }
+  return stream(model, context, {
+    ...base,
+    thinking: {
+      enabled: true,
+      budgetTokens: getGoogleBudget(model, resolvedLevel, options.thinkingBudgets)
+    }
+  });
+};
+function createClient(model, apiKey, optionsHeaders) {
+  const httpOptions = {};
+  if (model.baseUrl) {
+    httpOptions.baseUrl = model.baseUrl;
+    httpOptions.apiVersion = "";
+  }
+  const headers = providerHeadersToRecord2({ "User-Agent": getNyteUserAgent2() }, model.headers, optionsHeaders);
+  if (headers) {
+    httpOptions.headers = headers;
+  }
+  return new GoogleGenAI({
+    apiKey,
+    httpOptions: Object.keys(httpOptions).length > 0 ? httpOptions : undefined
+  });
+}
+function buildParams(model, context, options = {}) {
+  const contents = convertMessages(model, context);
+  const initialSystemMessage = getInitialSystemMessage2(context.messages);
+  const currentTools = getCurrentTools2(context.messages);
+  const generationConfig = {};
+  if (options.temperature !== undefined) {
+    generationConfig.temperature = options.temperature;
+  }
+  if (options.maxTokens !== undefined) {
+    generationConfig.maxOutputTokens = options.maxTokens;
+  }
+  const supportsStrictMode = atLeastGemini3(model.id);
+  const functionCallingMode = currentTools.length > 0 ? resolveGoogleFunctionCallingMode(currentTools, options.toolChoice, supportsStrictMode) : undefined;
+  const systemInstruction = initialSystemMessage ? getSystemMessageText2(initialSystemMessage) : "";
+  const config = {
+    ...Object.keys(generationConfig).length > 0 && generationConfig,
+    ...systemInstruction && { systemInstruction: sanitizeSurrogates2(systemInstruction) },
+    ...currentTools.length > 0 && {
+      tools: convertTools(currentTools, supportsStrictMode)
+    },
+    ...functionCallingMode !== undefined && {
+      toolConfig: { functionCallingConfig: { mode: functionCallingMode } }
+    }
+  };
+  if (options.thinking?.enabled && model.reasoning) {
+    const thinkingConfig = { includeThoughts: true };
+    if (options.thinking.level !== undefined) {
+      thinkingConfig.thinkingLevel = options.thinking.level;
+    } else if (options.thinking.budgetTokens !== undefined) {
+      thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
+    }
+    config.thinkingConfig = thinkingConfig;
+  } else if (model.reasoning && options.thinking && !options.thinking.enabled) {
+    config.thinkingConfig = getDisabledThinkingConfig(model);
+  }
+  if (options.signal) {
+    if (options.signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    config.abortSignal = options.signal;
+  }
+  const params = {
+    model: model.id,
+    contents,
+    config
+  };
+  return params;
+}
+function usesGoogleThinkingLevel(model) {
+  const id = model.id.toLowerCase();
+  return /gemini-3(?:\.\d+)?-(?:pro|flash)/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest" || /gemma-?4/.test(id);
+}
+function getDisabledThinkingConfig(model) {
+  if (!usesGoogleThinkingLevel(model))
+    return { thinkingBudget: 0 };
+  const fallback = clampThinkingLevel2(model, "off");
+  if (fallback === "off")
+    return { thinkingBudget: 0 };
+  return { thinkingLevel: toGoogleThinkingLevel(resolveGoogleThinkingLevel(model, fallback)) };
+}
+function toGoogleThinkingLevel(level) {
+  switch (level) {
+    case "minimal":
+      return GoogleThinkingLevel.MINIMAL;
+    case "low":
+      return GoogleThinkingLevel.LOW;
+    case "medium":
+      return GoogleThinkingLevel.MEDIUM;
+    case "high":
+      return GoogleThinkingLevel.HIGH;
+  }
+}
+function getGoogleBudget(model, level, customBudgets) {
+  if (customBudgets?.[level] !== undefined) {
+    return customBudgets[level];
+  }
+  if (model.id.includes("2.5-pro")) {
+    const budgets = {
+      minimal: 128,
+      low: 2048,
+      medium: 8192,
+      high: 32768
+    };
+    return budgets[level];
+  }
+  if (model.id.includes("2.5-flash-lite")) {
+    const budgets = {
+      minimal: 512,
+      low: 2048,
+      medium: 8192,
+      high: 24576
+    };
+    return budgets[level];
+  }
+  if (model.id.includes("2.5-flash")) {
+    const budgets = {
+      minimal: 128,
+      low: 2048,
+      medium: 8192,
+      high: 24576
+    };
+    return budgets[level];
+  }
+  return -1;
+}
+function resolveGoogleThinkingLevel(model, level) {
+  const mapped = model.thinkingLevelMap?.[level];
+  const resolvedLevel = mapped?.toLowerCase() ?? level;
+  switch (resolvedLevel) {
+    case "minimal":
+    case "low":
+    case "medium":
+    case "high":
+      return resolvedLevel;
+    default:
+      throw new Error(`Unsupported Google thinking level mapping for ${model.provider}/${model.id}: ${level} -> ${String(mapped)}`);
+  }
+}
+function retainThoughtSignature(existing, incoming) {
+  return incoming || existing;
+}
+var base64SignaturePattern = /^[A-Za-z0-9+/]+={0,2}$/;
+function resolveThoughtSignature(isSameProviderAndModel, signature) {
+  return isSameProviderAndModel && signature !== undefined && signature.length > 0 && signature.length % 4 === 0 && base64SignaturePattern.test(signature) ? signature : undefined;
+}
+function getGeminiMajorVersion(modelId) {
+  const match = modelId.toLowerCase().match(/^gemini(?:-live)?-(\d+)/);
+  return match ? Number.parseInt(match[1], 10) : undefined;
+}
+function atLeastGemini3(modelId) {
+  const majorVersion = getGeminiMajorVersion(modelId);
+  return majorVersion !== undefined && majorVersion >= 3;
+}
+function supportsMultimodalFunctionResponse(modelId) {
+  const majorVersion = getGeminiMajorVersion(modelId);
+  return majorVersion === undefined || majorVersion >= 3;
+}
+function convertMessages(model, context) {
+  const conversation = withoutInitialSystemMessage2(collapseSystemMessages2(context).messages);
+  const contents = [];
+  const normalizeToolCallId = (id) => {
+    if (!atLeastGemini3(model.id))
+      return id;
+    return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+  };
+  const transformedMessages = transformMessages2(conversation, model, normalizeToolCallId);
+  for (const message of transformedMessages) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "user") {
+      if (!Array.isArray(message.content)) {
+        contents.push({
+          role: "user",
+          parts: [{ text: sanitizeSurrogates2(message.content) }]
+        });
+      } else {
+        const parts = message.content.map((item) => item.type === "text" ? { text: sanitizeSurrogates2(item.text) } : { inlineData: { mimeType: item.mimeType, data: item.data } });
+        if (parts.length > 0) {
+          contents.push({ role: "user", parts });
+        }
+      }
+      continue;
+    }
+    if (message.role === "assistant") {
+      const parts = [];
+      const isSameProviderAndModel = message.provider === model.provider && message.model === model.id;
+      for (const block of message.content) {
+        if (block.type === "text") {
+          const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.textSignature);
+          if (block.text.trim() === "" && !thoughtSignature)
+            continue;
+          parts.push({
+            text: sanitizeSurrogates2(block.text),
+            ...thoughtSignature && { thoughtSignature }
+          });
+          continue;
+        }
+        if (block.type === "thinking") {
+          if (isSameProviderAndModel) {
+            const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thinkingSignature);
+            if (block.thinking.trim() === "" && !thoughtSignature)
+              continue;
+            parts.push({
+              thought: true,
+              text: sanitizeSurrogates2(block.thinking),
+              ...thoughtSignature && { thoughtSignature }
+            });
+          } else if (block.thinking.trim() !== "") {
+            parts.push({ text: sanitizeSurrogates2(block.thinking) });
+          }
+          continue;
+        }
+        const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
+        parts.push({
+          functionCall: {
+            name: block.name,
+            args: block.arguments ?? {},
+            ...atLeastGemini3(model.id) && { id: block.id }
+          },
+          ...thoughtSignature && { thoughtSignature }
+        });
+      }
+      if (parts.length > 0) {
+        contents.push({ role: "model", parts });
+      }
+      continue;
+    }
+    const textResult = message.content.filter((content) => content.type === "text").map((content) => content.text).join(`
+`);
+    const imageContent = model.input.includes("image") ? message.content.filter((content) => content.type === "image") : [];
+    const hasImages = imageContent.length > 0;
+    const supportsMultimodalResponse = supportsMultimodalFunctionResponse(model.id);
+    const responseValue = textResult.length > 0 ? sanitizeSurrogates2(textResult) : hasImages ? "(see attached image)" : "";
+    const imageParts = imageContent.map((image) => ({
+      inlineData: { mimeType: image.mimeType, data: image.data }
+    }));
+    const functionResponsePart = {
+      functionResponse: {
+        name: message.toolName,
+        response: message.isError ? { error: responseValue } : { output: responseValue },
+        ...hasImages && supportsMultimodalResponse && { parts: imageParts },
+        ...atLeastGemini3(model.id) && { id: message.toolCallId }
+      }
+    };
+    const lastContent = contents[contents.length - 1];
+    if (lastContent?.role === "user" && lastContent.parts?.some((part) => part.functionResponse)) {
+      lastContent.parts.push(functionResponsePart);
+    } else {
+      contents.push({ role: "user", parts: [functionResponsePart] });
+    }
+    if (hasImages && !supportsMultimodalResponse) {
+      contents.push({
+        role: "user",
+        parts: [{ text: "Tool result image:" }, ...imageParts]
+      });
+    }
+  }
+  return contents;
+}
+function convertTools(tools, supportsStrictMode) {
+  if (tools.length === 0)
+    return;
+  return [
+    {
+      functionDeclarations: tools.map((tool) => {
+        const strict = resolveJsonSchemaStrictSampling2(tool, supportsStrictMode);
+        return {
+          name: tool.name,
+          description: tool.description,
+          parametersJsonSchema: getJsonSchemaToolParameters2(tool, strict)
+        };
+      })
+    }
+  ];
+}
+function resolveGoogleFunctionCallingMode(tools, toolChoice, supportsStrictMode) {
+  if (toolChoice === "none")
+    return FunctionCallingConfigMode.NONE;
+  if (toolChoice === "any")
+    return FunctionCallingConfigMode.ANY;
+  if (tools.some((tool) => resolveJsonSchemaStrictSampling2(tool, supportsStrictMode))) {
+    return FunctionCallingConfigMode.VALIDATED;
+  }
+  return toolChoice === "auto" ? FunctionCallingConfigMode.AUTO : undefined;
+}
+function mapStopReason(reason) {
+  switch (reason) {
+    case FinishReason.STOP:
+      return "stop";
+    case FinishReason.MAX_TOKENS:
+      return "length";
+    case FinishReason.BLOCKLIST:
+    case FinishReason.PROHIBITED_CONTENT:
+    case FinishReason.SPII:
+    case FinishReason.SAFETY:
+    case FinishReason.IMAGE_SAFETY:
+    case FinishReason.IMAGE_PROHIBITED_CONTENT:
+    case FinishReason.IMAGE_RECITATION:
+    case FinishReason.IMAGE_OTHER:
+    case FinishReason.RECITATION:
+    case FinishReason.FINISH_REASON_UNSPECIFIED:
+    case FinishReason.OTHER:
+    case FinishReason.LANGUAGE:
+    case FinishReason.MALFORMED_FUNCTION_CALL:
+    case FinishReason.UNEXPECTED_TOOL_CALL:
+    case FinishReason.NO_IMAGE:
+      return "error";
+    default: {
+      const exhaustive = reason;
+      throw new Error(`Unhandled stop reason: ${exhaustive}`);
+    }
+  }
+}
+function retryGoogleRequest(request, options) {
+  return retryProviderRequest2(async () => {
+    try {
+      return await request();
+    } catch (error) {
+      if (error instanceof Error && "status" in error && !("headers" in error)) {
+        Object.assign(error, { headers: undefined });
+      }
+      throw error;
+    }
+  }, {
+    maxRetries: options?.maxRetries,
+    maxRetryDelayMs: options?.maxRetryDelayMs,
+    signal: options?.signal
+  });
+}
+export {
+  stream,
+  streamSimple
+};

package/dist/src/api/google-generative-ai.lazy.d.ts

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

package/dist/src/api/google-generative-ai.lazy.js

@@ -0,0 +1,11 @@
+import {
+  googleGenerativeAIApi2
+} from "../../chunks/account-limits-cache-x9fvb3s5.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 {
+  googleGenerativeAIApi2 as googleGenerativeAIApi
+};

package/dist/src/api/lazy.d.ts

@@ -0,0 +1,18 @@
+import type { Api, Model, ProviderStreams } from "../types.ts";
+import { AssistantMessageEventStream } from "../utils/event-stream.ts";
+/**
+ * Returns a stream synchronously while running async setup (auth resolution,
+ * lazy module loading) behind it. Setup failures terminate the stream with an
+ * error event.
+ */
+export declare function lazyStream(model: Model<Api>, setup: () => Promise<AssistantMessageEventStream>): AssistantMessageEventStream;
+/**
+ * Wraps a dynamically imported API implementation module as `ProviderStreams`.
+ * The module loads on first stream call; the host's import cache deduplicates
+ * loads. Load failures terminate the returned stream with an error event.
+ */
+export interface LazyApiCapabilities {
+    fetchDeferred?: boolean;
+    cancelDeferred?: boolean;
+}
+export declare function lazyApi(load: () => Promise<ProviderStreams>, capabilities?: LazyApiCapabilities): ProviderStreams;

package/dist/src/api/lazy.js

@@ -0,0 +1,12 @@
+import {
+  lazyStream2,
+  lazyApi2
+} from "../../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 {
+  lazyApi2 as lazyApi,
+  lazyStream2 as lazyStream
+};

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

@@ -0,0 +1,14 @@
+import type { Context, Model } from "../types.ts";
+import { type OpenAICodexResponsesOptions } from "./openai-codex-protocol.ts";
+import type { OpenAICompactResult } from "./openai-compact.ts";
+export type OpenAICodexCompactResult = OpenAICompactResult;
+/**
+ * Codex V2 uses the ordinary Responses stream, not /responses/compact.
+ * History retention follows openai/codex@121f91fd5d9dc66017866ce9bdc49f1e182721df,
+ * core/src/compact_remote_v2.rs and compact_remote_v2_images.rs.
+ * timeoutMs bounds header wait and stream idleness, not total duration.
+ * It defaults to five minutes; zero disables it. A failure throws an
+ * {@link OpenAICodexCompactionError} without a cause, response body, or raw SSE payload,
+ * since those may echo prompts or credentials.
+ */
+export declare function compactOpenAICodexContext(model: Model<"openai-codex-responses">, context: Context, requested?: OpenAICodexResponsesOptions): Promise<OpenAICodexCompactResult>;