@absolutejs/ai 0.0.56 → 0.0.57

package/dist/ai/providers/openaiResponses.js

@@ -1,6 +1,286 @@
 // @bun
 var __require = import.meta.require;
 
+// src/ai/inputCapacity.ts
+class AIInputError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AIInputError";
+  }
+}
+var positiveTokenLimit = (value) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+    throw new AIInputError("capacity_unavailable", "The provider did not supply a valid model limit.");
+  return value;
+};
+var inputTokenCount = (value) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+    throw new AIInputError("capacity_unavailable", "The provider did not supply a valid token count.");
+  return value;
+};
+var inspectAIInput = async (provider, params) => {
+  params.signal?.throwIfAborted();
+  if (!provider.inputCapacity)
+    throw new AIInputError("capacity_unavailable", "This provider does not expose model capacity and token counting.");
+  const [limits, tokens] = await Promise.all([
+    provider.inputCapacity.getLimits(params),
+    provider.inputCapacity.countTokens(params)
+  ]);
+  const inputTokens = inputTokenCount(tokens);
+  const outputTokens = positiveTokenLimit(provider.inputCapacity.outputTokens?.(params) ?? params.maxTokens ?? limits.maxOutputTokens);
+  const maxInputTokens = positiveTokenLimit(limits.maxInputTokens);
+  const maxOutputTokens = positiveTokenLimit(limits.maxOutputTokens);
+  const availableInputTokens = Math.max(0, Math.min(maxInputTokens, limits.contextWindowTokens === undefined ? maxInputTokens : positiveTokenLimit(limits.contextWindowTokens) - outputTokens));
+  return {
+    limits,
+    inputTokens,
+    outputTokens,
+    availableInputTokens,
+    fits: outputTokens <= maxOutputTokens && inputTokens <= availableInputTokens
+  };
+};
+var cacheModelLimits = (load, ttlMs = 300000) => {
+  const cache = new Map;
+  return async (params) => {
+    const entry = cache.get(params.model);
+    if (entry && Date.now() - entry.at < ttlMs)
+      return entry.limits;
+    const limits = await load(params);
+    positiveTokenLimit(limits.maxInputTokens);
+    positiveTokenLimit(limits.maxOutputTokens);
+    if (cache.size >= 100)
+      cache.clear();
+    cache.set(params.model, { at: Date.now(), limits });
+    return limits;
+  };
+};
+var capacityJson = async (response) => {
+  if (!response.ok)
+    throw new AIInputError("capacity_unavailable", `Model capacity request failed (${response.status}).`);
+  const value = await response.json();
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new AIInputError("capacity_unavailable", "Model capacity response was invalid.");
+  return value;
+};
+
+// src/ai/providers/openaiCapacity.ts
+var LIMITS = {
+  "gpt-4.1": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-2025-04-14": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-mini": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-mini-2025-04-14": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-nano": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-nano-2025-04-14": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4o": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-4o-mini": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-4o-mini-2024-07-18": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-5": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5-mini": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5-mini-2025-08-07": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5-nano": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5-nano-2025-08-07": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.4-mini": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.4-nano": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.1": {
+    maxInputTokens: 400000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.1-2025-11-13": {
+    maxInputTokens: 400000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.2": {
+    maxInputTokens: 400000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.2-2025-12-11": {
+    maxInputTokens: 400000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.4": {
+    maxInputTokens: 1050000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.4-2026-03-05": {
+    maxInputTokens: 1050000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.5": {
+    maxInputTokens: 1050000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-6-astra": {
+    maxInputTokens: 922000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.6-sol": {
+    maxInputTokens: 922000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.6-terra": {
+    maxInputTokens: 922000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.6-luna": {
+    maxInputTokens: 922000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  o3: {
+    maxInputTokens: 200000,
+    contextWindowTokens: 200000,
+    maxOutputTokens: 1e5
+  },
+  "o3-2025-04-16": {
+    maxInputTokens: 200000,
+    contextWindowTokens: 200000,
+    maxOutputTokens: 1e5
+  },
+  "o4-mini": {
+    maxInputTokens: 200000,
+    contextWindowTokens: 200000,
+    maxOutputTokens: 1e5
+  },
+  "o4-mini-2025-04-16": {
+    maxInputTokens: 200000,
+    contextWindowTokens: 200000,
+    maxOutputTokens: 1e5
+  },
+  "gpt-5-chat-latest": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-5.1-chat-latest": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-5.2-chat-latest": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  }
+};
+var openaiInputCapacity = (config) => ({
+  outputTokens: (params) => {
+    const value = config.body(params).max_output_tokens;
+    return value === undefined ? undefined : positiveTokenLimit(value);
+  },
+  getLimits: async (params) => {
+    if (config.modelLimits)
+      return config.modelLimits(params);
+    if (new URL(config.baseUrl).origin !== "https://api.openai.com")
+      throw new AIInputError("capacity_unavailable", "This compatible endpoint must expose its own model capacity.");
+    const limits = LIMITS[params.model];
+    if (!limits)
+      throw new AIInputError("capacity_unavailable", `Model limits are unavailable for ${params.model}; no character limit has been substituted.`);
+    return { ...limits };
+  },
+  countTokens: async (params) => {
+    const headers = new Headers(await config.headers(params));
+    headers.set("Authorization", `Bearer ${await config.key()}`);
+    headers.set("Content-Type", "application/json");
+    const body = config.body(params);
+    const counted = {};
+    for (const key of [
+      "model",
+      "input",
+      "instructions",
+      "tools",
+      "tool_choice",
+      "reasoning",
+      "text",
+      "parallel_tool_calls"
+    ])
+      if (body[key] !== undefined)
+        counted[key] = body[key];
+    const response = await config.fetch(`${config.baseUrl}/v1/responses/input_tokens`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(counted),
+      signal: params.signal ? AbortSignal.any([params.signal, AbortSignal.timeout(15000)]) : AbortSignal.timeout(15000)
+    });
+    return inputTokenCount((await capacityJson(response)).input_tokens);
+  }
+});
+
 // src/ai/errors/providerError.ts
 var PROVIDER_STATUS_PAGES = {
   anthropic: "https://status.claude.com",
@@ -231,6 +511,7 @@ var withResilience = (provider, providerName = "unknown") => {
     }
   };
   return {
+    ...provider,
     stream: (params) => {
       const tripped = circuitOpen(providerName);
       if (tripped) {
@@ -247,6 +528,7 @@ var withResilience = (provider, providerName = "unknown") => {
 var instrumentAIProvider = (provider, providerName) => {
   const resilient = withResilience(provider, providerName);
   return {
+    ...provider,
     stream: (params) => {
       if (!params.onUsage && !params.onSpan) {
         return resilient.stream(params);
@@ -496,7 +778,7 @@ var buildTools = (tools, isImageModel) => {
   }
   return result.length > 0 ? result : undefined;
 };
-var buildRequestBody = (params, isImageModel, capabilityModel = params.model) => {
+var buildResponsesRequestBody = (params, isImageModel, capabilityModel = params.model) => {
   const body = {
     input: buildInput(params.messages),
     model: params.model,
@@ -906,9 +1188,20 @@ var openaiResponses = (config2) => {
   const resolveKey = async () => config2.tokenSource ? await Promise.resolve(config2.tokenSource()) : config2.apiKey;
   const resolveHeaders = async (params) => typeof config2.headers === "function" ? await config2.headers(params) : config2.headers ?? {};
   return instrumentAIProvider({
+    inputCapacity: openaiInputCapacity({
+      baseUrl,
+      fetch: fetchImpl,
+      key: resolveKey,
+      headers: resolveHeaders,
+      modelLimits: config2.modelLimits,
+      body: (params) => {
+        const built = buildResponsesRequestBody(params, imageModels.has(params.model), config2.modelForCapabilities?.(params.model) ?? params.model);
+        return config2.transformRequestBody ? config2.transformRequestBody(built, params) : built;
+      }
+    }),
     stream: (params) => {
       const isImageModel = imageModels.has(params.model);
-      const builtBody = buildRequestBody(params, isImageModel, config2.modelForCapabilities?.(params.model) ?? params.model);
+      const builtBody = buildResponsesRequestBody(params, isImageModel, config2.modelForCapabilities?.(params.model) ?? params.model);
       const body = config2.transformRequestBody ? config2.transformRequestBody(builtBody, params) : builtBody;
       return async function* () {
         const [apiKey, headers] = await Promise.all([
@@ -921,8 +1214,9 @@ var openaiResponses = (config2) => {
   }, providerName);
 };
 export {
+  buildResponsesRequestBody,
   openaiResponses
 };
 
-//# debugId=6C012FE2A677780E64756E2164756E21
+//# debugId=CDF72AC7A40CBC7664756E2164756E21
 //# sourceMappingURL=openaiResponses.js.map