@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/chunks/account-limits-cache-hwehc67r.js

@@ -0,0 +1,509 @@
+import {
+  registerSessionResourceCleanup2
+} from "./account-limits-cache-gqsrbky9.js";
+import {
+  formatThrownValue2,
+  createAssistantMessageDiagnostic2,
+  appendAssistantMessageDiagnostic2
+} from "./account-limits-cache-9wqk28n5.js";
+import {
+  FifoQueue2
+} from "./account-limits-cache-nn9jebsj.js";
+import {
+  headersToRecord2
+} from "./account-limits-cache-ag5b8dja.js";
+import {
+  resolveHttpProxyUrlForTarget2
+} from "./account-limits-cache-0yd6bde8.js";
+import {
+  normalizeContext2
+} from "./account-limits-cache-6250ykn6.js";
+import {
+  CodexFrameJson2,
+  readText2,
+  readBoolean2,
+  readNumber2,
+  readRecord2,
+  TERMINAL_RESPONSE_TYPES2,
+  resolveCodexWebSocketUrl2
+} from "./account-limits-cache-fvadc36m.js";
+import {
+  convertResponsesMessages2
+} from "./account-limits-cache-n3yk6g5c.js";
+import {
+  CODEX_TOOL_CALL_PROVIDERS2,
+  codexStreamOptions2,
+  CodexApiError2,
+  CodexProtocolError2,
+  mapCodexEvents2
+} from "./account-limits-cache-vwgfz727.js";
+import {
+  ResponsesUsageError2,
+  processResponsesStream2
+} from "./account-limits-cache-53e64mhx.js";
+
+// src/api/openai-codex-websocket.ts
+import { Value } from "typebox/value";
+var DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS = 15000;
+var WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
+var WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
+var PREVIOUS_RESPONSE_NOT_FOUND_CODE = "previous_response_not_found";
+var SESSION_WEBSOCKET_CACHE_TTL_MS = 5 * 60 * 1000;
+var SESSION_WEBSOCKET_MAX_AGE_MS = 55 * 60 * 1000;
+var WEBSOCKET_OPEN = 1;
+var websocketSessionCache = new Map;
+var websocketSseFallbackSessions = new Set;
+function closeOpenAICodexWebSocketSessions2(sessionId) {
+  const closeEntry = (entry) => {
+    if (entry.idleTimer)
+      clearTimeout(entry.idleTimer);
+    closeWebSocketSilently(entry.socket, 1000, "debug_close");
+  };
+  if (sessionId) {
+    for (const entry of websocketSessionCache.get(sessionId)?.values() ?? [])
+      closeEntry(entry);
+    websocketSessionCache.delete(sessionId);
+    websocketSseFallbackSessions.delete(sessionId);
+    return;
+  }
+  for (const accountEntries of websocketSessionCache.values()) {
+    for (const entry of accountEntries.values())
+      closeEntry(entry);
+  }
+  websocketSessionCache.clear();
+  websocketSseFallbackSessions.clear();
+}
+registerSessionResourceCleanup2(closeOpenAICodexWebSocketSessions2);
+
+class WebSocketCloseError extends Error {
+  code;
+  reason;
+  wasClean;
+  constructor(message, options) {
+    super(message);
+    this.name = "WebSocketCloseError";
+    this.code = options?.code;
+    this.reason = options?.reason;
+    this.wasClean = options?.wasClean;
+  }
+}
+function codexErrorCode(cause) {
+  return cause instanceof CodexApiError2 ? cause.code : undefined;
+}
+function socketReusable(socket) {
+  return socket.readyState === undefined || socket.readyState === WEBSOCKET_OPEN;
+}
+function closeWebSocketSilently(socket, code = 1000, reason = "done") {
+  try {
+    socket.close(code, reason);
+  } catch {
+    return;
+  }
+}
+function forgetEntry(sessionId, accountId, entry) {
+  const accountEntries = websocketSessionCache.get(sessionId);
+  if (accountEntries?.get(accountId) === entry)
+    accountEntries.delete(accountId);
+  if (accountEntries?.size === 0)
+    websocketSessionCache.delete(sessionId);
+}
+function scheduleSessionWebSocketExpiry(sessionId, accountId, entry) {
+  if (entry.idleTimer) {
+    clearTimeout(entry.idleTimer);
+  }
+  entry.idleTimer = setTimeout(() => {
+    if (entry.busy)
+      return;
+    closeWebSocketSilently(entry.socket, 1000, "idle_timeout");
+    forgetEntry(sessionId, accountId, entry);
+  }, SESSION_WEBSOCKET_CACHE_TTL_MS);
+  entry.idleTimer.unref?.();
+}
+function openWebSocket(url, headers, env) {
+  const WebSocketClass = globalThis.WebSocket;
+  if (typeof WebSocketClass !== "function") {
+    throw new Error("WebSocket transport is not available in this runtime");
+  }
+  const init = { headers };
+  if (typeof process !== "undefined" && process.versions?.bun) {
+    const proxyUrl = resolveHttpProxyUrlForTarget2(url.replace(/^wss:/, "https:").replace(/^ws:/, "http:"), env);
+    if (proxyUrl)
+      init.proxy = proxyUrl.href;
+  }
+  const socket = Reflect.construct(WebSocketClass, [url, init]);
+  return socket;
+}
+async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS, env) {
+  const wsHeaders = headersToRecord2(headers);
+  delete wsHeaders["OpenAI-Beta"];
+  const socket = openWebSocket(url, wsHeaders, env);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeout;
+    const cleanup = () => {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = undefined;
+      }
+      socket.removeEventListener("open", onOpen);
+      socket.removeEventListener("error", onError);
+      socket.removeEventListener("close", onClose);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const fail = (error, closeReason) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      if (closeReason) {
+        closeWebSocketSilently(socket, 1000, closeReason);
+      }
+      reject(error);
+    };
+    const onOpen = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve(socket);
+    };
+    const onError = (event) => {
+      fail(extractWebSocketError(event));
+    };
+    const onClose = (event) => {
+      fail(extractWebSocketCloseError(event));
+    };
+    const onAbort = () => {
+      fail(new Error("Request was aborted"), "aborted");
+    };
+    socket.addEventListener("open", onOpen);
+    socket.addEventListener("error", onError);
+    socket.addEventListener("close", onClose);
+    signal?.addEventListener("abort", onAbort);
+    if (connectTimeoutMs > 0) {
+      timeout = setTimeout(() => {
+        fail(new Error(`WebSocket connect timeout after ${connectTimeoutMs}ms`), "connect_timeout");
+      }, connectTimeoutMs);
+    }
+    if (signal?.aborted) {
+      onAbort();
+    }
+  });
+}
+function cachedEntryRelease(sessionId, accountId, entry) {
+  return (keep) => {
+    if (!keep || !socketReusable(entry.socket)) {
+      closeWebSocketSilently(entry.socket);
+      if (entry.idleTimer)
+        clearTimeout(entry.idleTimer);
+      forgetEntry(sessionId, accountId, entry);
+      return;
+    }
+    entry.busy = false;
+    scheduleSessionWebSocketExpiry(sessionId, accountId, entry);
+  };
+}
+async function acquireWebSocket(url, headers, sessionId, accountId, signal, connectTimeoutMs, env) {
+  const connectSingleUse = async () => {
+    const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
+    return { socket, release: () => closeWebSocketSilently(socket) };
+  };
+  if (!sessionId)
+    return connectSingleUse();
+  const cached = websocketSessionCache.get(sessionId)?.get(accountId);
+  if (cached) {
+    if (cached.idleTimer) {
+      clearTimeout(cached.idleTimer);
+      cached.idleTimer = undefined;
+    }
+    if (cached.busy)
+      return connectSingleUse();
+    if (Date.now() - cached.createdAt >= SESSION_WEBSOCKET_MAX_AGE_MS) {
+      closeWebSocketSilently(cached.socket, 1000, "connection_age_limit");
+      forgetEntry(sessionId, accountId, cached);
+    } else if (socketReusable(cached.socket)) {
+      cached.busy = true;
+      return {
+        socket: cached.socket,
+        entry: cached,
+        release: cachedEntryRelease(sessionId, accountId, cached)
+      };
+    } else {
+      closeWebSocketSilently(cached.socket);
+      forgetEntry(sessionId, accountId, cached);
+    }
+  }
+  const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
+  const entry = { socket, busy: true, createdAt: Date.now() };
+  let accountEntries = websocketSessionCache.get(sessionId);
+  if (!accountEntries) {
+    accountEntries = new Map;
+    websocketSessionCache.set(sessionId, accountEntries);
+  }
+  accountEntries.set(accountId, entry);
+  return { socket, entry, release: cachedEntryRelease(sessionId, accountId, entry) };
+}
+function extractWebSocketError(event) {
+  const message = readText2(event.message);
+  if (message)
+    return new Error(message);
+  const nested = event.error;
+  if (nested instanceof Error && nested.message.length > 0)
+    return nested;
+  const nestedMessage = readText2(readRecord2(nested)?.message);
+  if (nestedMessage)
+    return new Error(nestedMessage);
+  return new Error("WebSocket error");
+}
+function extractWebSocketCloseError(event) {
+  const code = readNumber2(event.code);
+  const reason = readText2(event.reason);
+  const codeText = code !== undefined ? ` ${code}` : "";
+  const reasonText = reason && reason.length > 0 ? ` ${reason}` : code === WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE ? " message too big" : "";
+  return new WebSocketCloseError(`WebSocket closed${codeText}${reasonText}`.trim(), {
+    code,
+    reason,
+    wasClean: readBoolean2(event.wasClean)
+  });
+}
+async function decodeWebSocketData(data) {
+  const text = readText2(data);
+  if (text !== undefined)
+    return text;
+  if (data instanceof ArrayBuffer) {
+    return new TextDecoder().decode(new Uint8Array(data));
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new TextDecoder().decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+  }
+  const blobLike = readRecord2(data);
+  if (blobLike && blobLike.arrayBuffer instanceof Function) {
+    const arrayBuffer = await blobLike.arrayBuffer();
+    return new TextDecoder().decode(new Uint8Array(arrayBuffer));
+  }
+  return null;
+}
+async function* parseWebSocket(socket, signal, idleTimeoutMs) {
+  const queue = new FifoQueue2;
+  let pending = null;
+  const wake = () => {
+    if (!pending)
+      return;
+    const resolve = pending;
+    pending = null;
+    resolve();
+  };
+  const enqueue = (event) => {
+    queue.enqueue(event);
+    wake();
+  };
+  const onMessage = (event) => {
+    enqueue({ kind: "message", data: event.data });
+  };
+  const onError = (event) => {
+    enqueue({ kind: "failure", error: extractWebSocketError(event) });
+  };
+  const onClose = (event) => {
+    enqueue({ kind: "failure", error: extractWebSocketCloseError(event) });
+  };
+  const onAbort = () => {
+    enqueue({ kind: "failure", error: new Error("Request was aborted") });
+  };
+  socket.addEventListener("message", onMessage);
+  socket.addEventListener("error", onError);
+  socket.addEventListener("close", onClose);
+  signal?.addEventListener("abort", onAbort);
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      if (queue.length === 0) {
+        let timeout;
+        await new Promise((resolve, reject) => {
+          pending = resolve;
+          if (idleTimeoutMs !== undefined && idleTimeoutMs > 0) {
+            timeout = setTimeout(() => {
+              const error = new Error(`WebSocket idle timeout after ${idleTimeoutMs}ms`);
+              pending = null;
+              closeWebSocketSilently(socket, 1000, "idle_timeout");
+              reject(error);
+            }, idleTimeoutMs);
+          }
+        }).finally(() => {
+          if (timeout) {
+            clearTimeout(timeout);
+          }
+        });
+      }
+      const event = queue.dequeue();
+      if (!event)
+        continue;
+      if (event.kind === "failure") {
+        throw event.error;
+      }
+      let text = null;
+      let frame;
+      try {
+        text = await decodeWebSocketData(event.data);
+        const decoded = text ? JSON.parse(text) : undefined;
+        if (Value.Check(CodexFrameJson2, decoded))
+          frame = decoded;
+      } catch (cause) {
+        throw new CodexProtocolError2(`Invalid Codex WebSocket JSON: ${formatThrownValue2(cause)}`, {
+          cause,
+          payload: text
+        });
+      }
+      if (!frame)
+        continue;
+      const terminal = TERMINAL_RESPONSE_TYPES2.has(frame.type);
+      yield frame;
+      if (terminal)
+        return;
+    }
+  } finally {
+    socket.removeEventListener("message", onMessage);
+    socket.removeEventListener("error", onError);
+    socket.removeEventListener("close", onClose);
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+function requestBodyWithoutInput(body) {
+  const { input: _input, previous_response_id: _previousResponseId, ...rest } = body;
+  return rest;
+}
+function getCachedWebSocketInputDelta(body, continuation) {
+  if (JSON.stringify(requestBodyWithoutInput(body)) !== JSON.stringify(requestBodyWithoutInput(continuation.lastRequestBody))) {
+    return;
+  }
+  const currentInput = body.input ?? [];
+  const baseline = [
+    ...continuation.lastRequestBody.input ?? [],
+    ...continuation.lastResponseItems
+  ];
+  if (currentInput.length < baseline.length) {
+    return;
+  }
+  if (JSON.stringify(currentInput.slice(0, baseline.length)) !== JSON.stringify(baseline)) {
+    return;
+  }
+  return currentInput.slice(baseline.length);
+}
+function buildCachedWebSocketRequestBody(entry, body) {
+  const continuation = entry.continuation;
+  if (!continuation) {
+    return body;
+  }
+  const delta = getCachedWebSocketInputDelta(body, continuation);
+  if (!delta || !continuation.lastResponseId) {
+    entry.continuation = undefined;
+    return body;
+  }
+  return {
+    ...body,
+    previous_response_id: continuation.lastResponseId,
+    input: delta
+  };
+}
+var NON_STARTING_FRAMES = new Set([
+  "codex.rate_limits",
+  "error",
+  "response.failed"
+]);
+async function* startWebSocketOutputOnFirstEvent(frames, onStart) {
+  let started = false;
+  for await (const frame of frames) {
+    if (!started && !NON_STARTING_FRAMES.has(frame.type)) {
+      started = true;
+      onStart();
+    }
+    yield frame;
+  }
+}
+async function processWebSocketStream(request, headers, output, stream, onStart) {
+  const { model, options } = request;
+  const { socket, entry, release } = await acquireWebSocket(resolveCodexWebSocketUrl2(model.baseUrl), headers, request.cacheSessionId, request.accountId, options?.signal, request.connectTimeoutMs, options?.env);
+  let keepConnection = true;
+  const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
+  const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, request.body) : request.body;
+  try {
+    socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
+    await processResponsesStream2(mapCodexEvents2(startWebSocketOutputOnFirstEvent(parseWebSocket(socket, options?.signal, request.timeoutMs), onStart), output, options?.onAccountLimits === undefined ? undefined : (limits) => options.onAccountLimits?.(limits, model)), output, stream, model, codexStreamOptions2(request));
+    if (options?.signal?.aborted) {
+      keepConnection = false;
+    } else if (useCachedContext && entry && output.responseId) {
+      const responseItems = convertResponsesMessages2(model, normalizeContext2({ messages: [output] }), CODEX_TOOL_CALL_PROVIDERS2, {
+        includeSystemPrompt: false,
+        grammarToolInputProperties: request.grammarToolInputProperties
+      }).filter((item) => item.type !== "function_call_output" && item.type !== "custom_tool_call_output");
+      entry.continuation = {
+        lastRequestBody: request.body,
+        lastResponseId: output.responseId,
+        lastResponseItems: responseItems
+      };
+    }
+  } catch (error) {
+    if (entry) {
+      entry.continuation = undefined;
+    }
+    keepConnection = false;
+    throw error;
+  } finally {
+    release(keepConnection);
+  }
+}
+async function streamOverWebSocket2(request, headers, output, stream) {
+  const { options, cacheSessionId } = request;
+  const transport = options?.transport || "auto";
+  if (transport === "sse" || cacheSessionId !== undefined && websocketSseFallbackSessions.has(cacheSessionId)) {
+    return false;
+  }
+  let startEmitted = false;
+  let retriedWebSocketConnectionLimit = false;
+  let retriedMissingWebSocketContinuation = false;
+  for (;; ) {
+    let websocketStarted = false;
+    try {
+      await processWebSocketStream(request, headers, output, stream, () => {
+        websocketStarted = true;
+        if (!startEmitted) {
+          startEmitted = true;
+          stream.push({ type: "start", partial: output });
+        }
+      });
+      return true;
+    } catch (error) {
+      const aborted = options?.signal?.aborted;
+      const code = codexErrorCode(error);
+      const connectionLimitBeforeStart = !websocketStarted && code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
+      if (!aborted && code === PREVIOUS_RESPONSE_NOT_FOUND_CODE && !retriedMissingWebSocketContinuation) {
+        retriedMissingWebSocketContinuation = true;
+        continue;
+      }
+      if (!aborted && connectionLimitBeforeStart && !retriedWebSocketConnectionLimit) {
+        retriedWebSocketConnectionLimit = true;
+        continue;
+      }
+      const failedInProtocol = error instanceof CodexApiError2 || error instanceof CodexProtocolError2 || error instanceof ResponsesUsageError2;
+      if (aborted || failedInProtocol && !connectionLimitBeforeStart) {
+        throw error;
+      }
+      appendAssistantMessageDiagnostic2(output, createAssistantMessageDiagnostic2("provider_transport_failure", error, {
+        configuredTransport: transport,
+        fallbackTransport: websocketStarted ? undefined : "sse",
+        eventsEmitted: websocketStarted,
+        phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
+        requestBytes: new TextEncoder().encode(JSON.stringify(request.body)).byteLength
+      }));
+      if (cacheSessionId)
+        websocketSseFallbackSessions.add(cacheSessionId);
+      if (websocketStarted) {
+        throw error;
+      }
+      return false;
+    }
+  }
+}
+
+export { closeOpenAICodexWebSocketSessions2, streamOverWebSocket2 };

package/dist/chunks/account-limits-cache-hyzn1jmk.js

@@ -0,0 +1,46 @@
+import {
+  getProviderEnvValue2
+} from "./account-limits-cache-b23sbrke.js";
+
+// src/env-api-keys.ts
+var ANTHROPIC_AUTH_TOKEN_ENV2 = "ANTHROPIC_AUTH_TOKEN";
+var ANTHROPIC_OAUTH_TOKEN_ENV2 = "ANTHROPIC_OAUTH_TOKEN";
+var ANTHROPIC_API_KEY_ENV2 = "ANTHROPIC_API_KEY";
+var ANTHROPIC_FEDERATION_RULE_ID_ENV2 = "ANTHROPIC_FEDERATION_RULE_ID";
+var ANTHROPIC_ORGANIZATION_ID_ENV2 = "ANTHROPIC_ORGANIZATION_ID";
+var ANTHROPIC_SERVICE_ACCOUNT_ID_ENV2 = "ANTHROPIC_SERVICE_ACCOUNT_ID";
+var ANTHROPIC_IDENTITY_TOKEN_FILE_ENV2 = "ANTHROPIC_IDENTITY_TOKEN_FILE";
+var ANTHROPIC_WORKSPACE_ID_ENV2 = "ANTHROPIC_WORKSPACE_ID";
+var ANTHROPIC_ENV_KEYS2 = [
+  ANTHROPIC_AUTH_TOKEN_ENV2,
+  ANTHROPIC_OAUTH_TOKEN_ENV2,
+  ANTHROPIC_API_KEY_ENV2
+];
+function getApiKeyEnvVars(provider) {
+  if (provider === "anthropic") {
+    return ANTHROPIC_ENV_KEYS2;
+  }
+  if (provider === "opencode" || provider === "opencode-go")
+    return ["OPENCODE_API_KEY"];
+  if (provider === "openai")
+    return ["OPENAI_API_KEY"];
+  return;
+}
+function findEnvKeys2(provider, env) {
+  const envVars = getApiKeyEnvVars(provider);
+  if (!envVars)
+    return;
+  const found = envVars.filter((envVar) => !!getProviderEnvValue2(envVar, env));
+  return found.length > 0 ? found : undefined;
+}
+function getEnvApiKey2(provider, env) {
+  const envKeys = findEnvKeys2(provider, env);
+  if (envKeys?.[0]) {
+    const apiKeyEnv = provider === "anthropic" ? envKeys.find((key) => key !== ANTHROPIC_AUTH_TOKEN_ENV2) : envKeys[0];
+    if (apiKeyEnv)
+      return getProviderEnvValue2(apiKeyEnv, env);
+  }
+  return;
+}
+
+export { ANTHROPIC_AUTH_TOKEN_ENV2, ANTHROPIC_OAUTH_TOKEN_ENV2, ANTHROPIC_API_KEY_ENV2, ANTHROPIC_FEDERATION_RULE_ID_ENV2, ANTHROPIC_ORGANIZATION_ID_ENV2, ANTHROPIC_SERVICE_ACCOUNT_ID_ENV2, ANTHROPIC_IDENTITY_TOKEN_FILE_ENV2, ANTHROPIC_WORKSPACE_ID_ENV2, ANTHROPIC_ENV_KEYS2, findEnvKeys2, getEnvApiKey2 };

package/dist/chunks/account-limits-cache-j2bt392s.js

@@ -0,0 +1,63 @@
+// src/utils/abort.ts
+function abortReason(signal) {
+  if (signal.reason !== undefined)
+    return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function sleep2(ms, signal, abortError) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortError());
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timeout);
+      reject(abortError());
+    };
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, Math.max(0, ms));
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function operationSignal2(signal) {
+  return signal ?? new AbortController().signal;
+}
+function raceWithAbortSignal2(operation, signal) {
+  if (signal.aborted) {
+    operation.catch(() => {});
+    return Promise.reject(abortReason(signal));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(abortReason(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then((value) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(error);
+    });
+    if (signal.aborted)
+      onAbort();
+  });
+}
+
+export { sleep2, operationSignal2, raceWithAbortSignal2 };

package/dist/chunks/account-limits-cache-k0pkzhbx.js

@@ -0,0 +1,74 @@
+import {
+  clampThinkingLevel2
+} from "./account-limits-cache-zgzptd0z.js";
+import {
+  estimateContextTokens2
+} from "./account-limits-cache-dejeygdt.js";
+
+// src/api/simple-options.ts
+var CONTEXT_SAFETY_TOKENS = 4096;
+var MIN_MAX_TOKENS = 1;
+function clampMaxTokensToContext2(model, context, maxTokens) {
+  if (model.contextWindow <= 0)
+    return Math.max(MIN_MAX_TOKENS, maxTokens);
+  const available = model.contextWindow - estimateContextTokens2(context).tokens - CONTEXT_SAFETY_TOKENS;
+  return Math.min(maxTokens, Math.max(MIN_MAX_TOKENS, available));
+}
+function buildBaseOptions2(model, context, options) {
+  const samplingParams = model.samplingParams || options?.samplingParams ? { ...model.samplingParams, ...options?.samplingParams } : undefined;
+  return {
+    temperature: options?.temperature,
+    samplingParams,
+    maxTokens: clampMaxTokensToContext2(model, context, options?.maxTokens ?? model.maxTokens),
+    signal: options?.signal,
+    fast: options?.fast,
+    apiKey: options?.apiKey,
+    fetch: options?.fetch,
+    transport: options?.transport,
+    cacheRetention: options?.cacheRetention,
+    sessionId: options?.sessionId,
+    headers: options?.headers,
+    onPayload: options?.onPayload,
+    onResponse: options?.onResponse,
+    onAccountLimits: options?.onAccountLimits,
+    timeoutMs: options?.timeoutMs,
+    websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
+    maxRetries: options?.maxRetries,
+    maxRetryDelayMs: options?.maxRetryDelayMs,
+    metadata: options?.metadata,
+    env: options?.env,
+    toolChoice: options?.toolChoice
+  };
+}
+function simpleReasoningEffort2(model, reasoning) {
+  const clamped = reasoning ? clampThinkingLevel2(model, reasoning) : undefined;
+  return clamped === "off" ? undefined : clamped;
+}
+var MIN_ANSWER_TOKENS = 1024;
+var DEFAULT_THINKING_BUDGETS = {
+  minimal: 1024,
+  low: 2048,
+  medium: 8192,
+  high: 16384
+};
+function clampReasoning(effort) {
+  return effort === "xhigh" || effort === "max" ? "high" : effort;
+}
+function thinkingBudgetForLevel2(reasoningLevel, customBudgets) {
+  const budgets = { ...DEFAULT_THINKING_BUDGETS, ...customBudgets };
+  const level = clampReasoning(reasoningLevel);
+  return budgets[level];
+}
+function clampThinkingBudgetToAnswerRoom2(thinkingBudget, ceiling) {
+  return Math.min(thinkingBudget, Math.max(0, ceiling - MIN_ANSWER_TOKENS));
+}
+function adjustMaxTokensForThinking2(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+  let thinkingBudget = thinkingBudgetForLevel2(reasoningLevel, customBudgets);
+  const maxTokens = baseMaxTokens === undefined ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+  if (maxTokens <= thinkingBudget) {
+    thinkingBudget = clampThinkingBudgetToAnswerRoom2(thinkingBudget, maxTokens);
+  }
+  return { maxTokens, thinkingBudget };
+}
+
+export { clampMaxTokensToContext2, buildBaseOptions2, simpleReasoningEffort2, thinkingBudgetForLevel2, clampThinkingBudgetToAnswerRoom2, adjustMaxTokensForThinking2 };