@happyvertical/ai 0.78.2 → 0.79.0

package/dist/chunks/{index-BT4thAvS.js → index-DCXO0nZA.js}

@@ -469,7 +469,7 @@ function normalizeRateLimitConfig(options) {
     key: rateLimit?.key?.trim() || deriveBudgetKey(options),
     maxAttempts: Math.max(
       1,
-      normalizeNonNegativeInteger(rateLimit?.maxAttempts, 3)
+      normalizeNonNegativeInteger(rateLimit?.maxAttempts, 1)
     )
   };
 }
@@ -589,6 +589,357 @@ function createRateLimitedAI(client, options) {
     }
   });
 }
+const DEFAULT_AI_TIMEOUT_MS = 12e4;
+const DEFAULT_AI_MAX_RETRIES = 0;
+const DEFAULT_AI_GENERATION_LIMITS = Object.freeze({
+  maxOutputTokens: 4096,
+  maxReasoningTokens: 1024,
+  maxImagesPerRequest: 1,
+  onExceeded: "error"
+});
+function positiveInteger(value, fallback, field) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new AIError(
+      `${field} must be a positive finite number`,
+      "AI_LIMIT_INVALID"
+    );
+  }
+  return Math.trunc(value);
+}
+function normalizeBaseAIOptions(options) {
+  const configuredLimits = options.generationLimits || {};
+  const generationLimits = {
+    maxOutputTokens: positiveInteger(
+      configuredLimits.maxOutputTokens,
+      DEFAULT_AI_GENERATION_LIMITS.maxOutputTokens,
+      "generationLimits.maxOutputTokens"
+    ),
+    maxReasoningTokens: positiveInteger(
+      configuredLimits.maxReasoningTokens,
+      DEFAULT_AI_GENERATION_LIMITS.maxReasoningTokens,
+      "generationLimits.maxReasoningTokens"
+    ),
+    maxImagesPerRequest: positiveInteger(
+      configuredLimits.maxImagesPerRequest,
+      DEFAULT_AI_GENERATION_LIMITS.maxImagesPerRequest,
+      "generationLimits.maxImagesPerRequest"
+    ),
+    onExceeded: configuredLimits.onExceeded || DEFAULT_AI_GENERATION_LIMITS.onExceeded
+  };
+  if (!["error", "clamp"].includes(generationLimits.onExceeded)) {
+    throw new AIError(
+      'generationLimits.onExceeded must be "error" or "clamp"',
+      "AI_LIMIT_INVALID"
+    );
+  }
+  return {
+    ...options,
+    timeout: positiveInteger(options.timeout, DEFAULT_AI_TIMEOUT_MS, "timeout"),
+    maxRetries: (() => {
+      if (options.maxRetries === void 0) return DEFAULT_AI_MAX_RETRIES;
+      if (!Number.isFinite(options.maxRetries) || options.maxRetries < 0) {
+        throw new AIError(
+          "maxRetries must be a non-negative finite number",
+          "AI_LIMIT_INVALID"
+        );
+      }
+      return Math.trunc(options.maxRetries);
+    })(),
+    generationLimits
+  };
+}
+function reasoningTokensForEffort(effort) {
+  switch (effort) {
+    case false:
+    case "none":
+      return 0;
+    case "minimal":
+      return 1024;
+    case "low":
+      return 2048;
+    case "medium":
+      return 4096;
+    case "high":
+      return 8192;
+    default:
+      return void 0;
+  }
+}
+function enforceLimit(requested, limit, behavior, label, provider, model) {
+  if (!Number.isFinite(requested) || requested < 0) {
+    throw new AIError(
+      `${label} must be a non-negative finite number`,
+      "AI_LIMIT_INVALID",
+      provider,
+      model
+    );
+  }
+  const normalized = Math.trunc(requested);
+  if (normalized <= limit) return normalized;
+  if (behavior === "clamp") return limit;
+  throw new AIError(
+    `${label} ${normalized} exceeds configured ceiling ${limit}`,
+    "AI_LIMIT_EXCEEDED",
+    provider,
+    model
+  );
+}
+function normalizeChatOptions(providerOptions, options, provider, model) {
+  const normalizedProvider = normalizeBaseAIOptions(providerOptions);
+  const limits = normalizedProvider.generationLimits;
+  const requestedOutput = options.maxTokens ?? limits.maxOutputTokens;
+  const legacyEffort = options.thinkingLevel ?? providerOptions.thinkingLevel;
+  const reasoningWasRequested = options.reasoning !== void 0 || legacyEffort !== void 0 || options.includeThoughts === true;
+  const requestedReasoning = reasoningWasRequested ? options.reasoning?.maxTokens ?? reasoningTokensForEffort(options.reasoning?.effort ?? legacyEffort) ?? limits.maxReasoningTokens : 0;
+  return {
+    ...options,
+    maxTokens: enforceLimit(
+      requestedOutput,
+      limits.maxOutputTokens,
+      limits.onExceeded,
+      "maxTokens",
+      provider,
+      model
+    ),
+    reasoning: {
+      ...options.reasoning,
+      maxTokens: enforceLimit(
+        requestedReasoning,
+        limits.maxReasoningTokens,
+        limits.onExceeded,
+        "reasoning.maxTokens",
+        provider,
+        model
+      ),
+      includeThoughts: options.reasoning?.includeThoughts ?? options.includeThoughts
+    }
+  };
+}
+function normalizeImageGenerationOptions(providerOptions, options, provider, model) {
+  const normalizedProvider = normalizeBaseAIOptions(providerOptions);
+  const limits = normalizedProvider.generationLimits;
+  return {
+    ...options,
+    n: enforceLimit(
+      options.n ?? 1,
+      limits.maxImagesPerRequest,
+      limits.onExceeded,
+      "n",
+      provider,
+      model
+    )
+  };
+}
+function prepareRequestControls(providerOptions, requestOptions = {}) {
+  const normalized = normalizeBaseAIOptions(providerOptions);
+  const timeout = positiveInteger(
+    requestOptions.timeout,
+    normalized.timeout,
+    "timeout"
+  );
+  const controller = new AbortController();
+  let timedOut = false;
+  const abortFromCaller = () => controller.abort(requestOptions.signal?.reason);
+  if (requestOptions.signal?.aborted) {
+    abortFromCaller();
+  } else {
+    requestOptions.signal?.addEventListener("abort", abortFromCaller, {
+      once: true
+    });
+  }
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new Error(`AI request timed out after ${timeout}ms`));
+  }, timeout);
+  return {
+    signal: controller.signal,
+    timeout,
+    didTimeout: () => timedOut,
+    cleanup: () => {
+      clearTimeout(timer);
+      requestOptions.signal?.removeEventListener("abort", abortFromCaller);
+    }
+  };
+}
+function mergeTags(providerOptions, callTags) {
+  return providerOptions.usageTags || callTags ? { ...providerOptions.usageTags, ...callTags } : void 0;
+}
+function emitRequestEvent(providerOptions, event) {
+  if (!providerOptions.onRequest) return;
+  try {
+    providerOptions.onRequest({
+      ...event,
+      tags: mergeTags(providerOptions, event.tags)
+    });
+  } catch {
+  }
+}
+function classifyRequestFailure(error, didTimeout = false) {
+  const code = error instanceof AIError ? error.code : void 0;
+  if (code === "AI_LIMIT_EXCEEDED" || code === "AI_LIMIT_INVALID") {
+    return { status: "rejected", errorCode: code };
+  }
+  if (didTimeout || code === "AI_TIMEOUT" || code === "TIMEOUT") {
+    return { status: "timed_out", errorCode: code || "AI_TIMEOUT" };
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return { status: "aborted", errorCode: "ABORTED" };
+  }
+  if (code === "AI_ABORTED") {
+    return { status: "aborted", errorCode: code };
+  }
+  return {
+    status: "failed",
+    errorCode: code || (error instanceof Error ? error.name : void 0)
+  };
+}
+function requestEventBase(options) {
+  const normalized = normalizeBaseAIOptions(options.providerOptions);
+  return {
+    provider: options.provider,
+    model: options.model,
+    operation: options.operation,
+    attempts: normalized.maxRetries + 1,
+    requestedMaxOutputTokens: options.callOptions?.maxTokens,
+    effectiveMaxOutputTokens: options.operation === "generateImage" ? void 0 : options.effectiveMaxOutputTokens ?? normalized.generationLimits.maxOutputTokens,
+    tags: options.callOptions?.usageTags
+  };
+}
+const OBSERVED_OPERATIONS = /* @__PURE__ */ new Set([
+  "chat",
+  "complete",
+  "message",
+  "describeImage",
+  "generateImage",
+  "stream"
+]);
+function callOptionsFor(operation, args) {
+  const index = operation === "describeImage" ? 2 : 1;
+  const value = args[index];
+  return value && typeof value === "object" ? value : void 0;
+}
+function providerName(options) {
+  const configured = options.type;
+  return configured || "openai";
+}
+function effectiveOutputTokens(operation, providerOptions, callOptions) {
+  if (operation === "generateImage") {
+    normalizeImageGenerationOptions(
+      providerOptions,
+      callOptions || {},
+      providerName(providerOptions),
+      callOptions?.model
+    );
+    return void 0;
+  }
+  return normalizeChatOptions(
+    providerOptions,
+    callOptions || {},
+    providerName(providerOptions),
+    callOptions?.model || providerOptions.defaultModel
+  ).maxTokens;
+}
+function createObservedAI(client, providerOptions) {
+  if (!providerOptions.onRequest) return client;
+  return new Proxy(client, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof property !== "string" || typeof value !== "function" || !OBSERVED_OPERATIONS.has(property)) {
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+      const operation = property;
+      if (operation === "stream") {
+        return async function* (...args) {
+          const startedAt = Date.now();
+          const callOptions = callOptionsFor(operation, args);
+          let base;
+          try {
+            base = requestEventBase({
+              providerOptions,
+              provider: providerName(providerOptions),
+              model: callOptions?.model || providerOptions.defaultModel || "unknown",
+              operation,
+              callOptions,
+              effectiveMaxOutputTokens: effectiveOutputTokens(
+                operation,
+                providerOptions,
+                callOptions
+              )
+            });
+            const iterable = Reflect.apply(
+              value,
+              target,
+              args
+            );
+            for await (const chunk of iterable) yield chunk;
+            emitRequestEvent(providerOptions, {
+              ...base,
+              status: "succeeded",
+              duration: Date.now() - startedAt
+            });
+          } catch (error) {
+            const failure = classifyRequestFailure(error);
+            base ||= requestEventBase({
+              providerOptions,
+              provider: providerName(providerOptions),
+              model: callOptions?.model || providerOptions.defaultModel || "unknown",
+              operation,
+              callOptions
+            });
+            emitRequestEvent(providerOptions, {
+              ...base,
+              ...failure,
+              duration: Date.now() - startedAt
+            });
+            throw error;
+          }
+        };
+      }
+      return async (...args) => {
+        const startedAt = Date.now();
+        const callOptions = callOptionsFor(operation, args);
+        let base;
+        try {
+          base = requestEventBase({
+            providerOptions,
+            provider: providerName(providerOptions),
+            model: callOptions?.model || providerOptions.defaultModel || "unknown",
+            operation,
+            callOptions,
+            effectiveMaxOutputTokens: effectiveOutputTokens(
+              operation,
+              providerOptions,
+              callOptions
+            )
+          });
+          const result = await Reflect.apply(value, target, args);
+          emitRequestEvent(providerOptions, {
+            ...base,
+            status: "succeeded",
+            duration: Date.now() - startedAt
+          });
+          return result;
+        } catch (error) {
+          const failure = classifyRequestFailure(error);
+          base ||= requestEventBase({
+            providerOptions,
+            provider: providerName(providerOptions),
+            model: callOptions?.model || providerOptions.defaultModel || "unknown",
+            operation,
+            callOptions
+          });
+          emitRequestEvent(providerOptions, {
+            ...base,
+            ...failure,
+            duration: Date.now() - startedAt
+          });
+          throw error;
+        }
+      };
+    }
+  });
+}
 function isOpenAIOptions(options) {
   return !options.type || options.type === "openai";
 }
@@ -646,36 +997,37 @@ async function getAI(options = {}) {
   if ("model" in options && !options.defaultModel) {
     options.defaultModel = options.model;
   }
+  options = normalizeBaseAIOptions(options);
   let client;
   if (isOpenAIOptions(options)) {
-    const { OpenAIProvider } = await import("./openai-5snI2diE.js");
+    const { OpenAIProvider } = await import("./openai-CJEo69jb.js");
     client = new OpenAIProvider(options);
   } else if (isLiteLLMOptions(options)) {
-    const { LiteLLMProvider } = await import("./litellm-DhPKa_Jz.js");
+    const { LiteLLMProvider } = await import("./litellm-BMFTYbWc.js");
     client = new LiteLLMProvider(options);
   } else if (isBifrostOptions(options)) {
-    const { BifrostProvider } = await import("./bifrost-3mXtQsTj.js");
+    const { BifrostProvider } = await import("./bifrost-CEnCsciy.js");
     client = new BifrostProvider(options);
   } else if (isOllamaOptions(options)) {
-    const { OllamaProvider } = await import("./ollama-Di1ldur0.js");
+    const { OllamaProvider } = await import("./ollama-DsGDrA-c.js");
     client = new OllamaProvider(options);
   } else if (isGeminiOptions(options)) {
-    const { GeminiProvider } = await import("./gemini-BfpHXDIQ.js");
+    const { GeminiProvider } = await import("./gemini-CS56gY0D.js");
     client = new GeminiProvider(options);
   } else if (isAnthropicOptions(options)) {
-    const { AnthropicProvider } = await import("./anthropic-BRwbhwIl.js");
+    const { AnthropicProvider } = await import("./anthropic-2z-82zgr.js");
     client = new AnthropicProvider(options);
   } else if (isHuggingFaceOptions(options)) {
-    const { HuggingFaceProvider } = await import("./huggingface-280qv9iv.js");
+    const { HuggingFaceProvider } = await import("./huggingface-wQSfO5xA.js");
     client = new HuggingFaceProvider(options);
   } else if (isBedrockOptions(options)) {
-    const { BedrockProvider } = await import("./bedrock-Cf1xUerN.js");
+    const { BedrockProvider } = await import("./bedrock-Dc2eVPUD.js");
     client = new BedrockProvider(options);
   } else if (isClaudeCliOptions(options)) {
-    const { ClaudeCliProvider } = await import("./claude-cli-BrHRfkry.js");
+    const { ClaudeCliProvider } = await import("./claude-cli-X1ONjE8K.js");
     client = new ClaudeCliProvider(options);
   } else if (isQwen3TTSOptions(options)) {
-    const { Qwen3TTSProvider } = await import("./qwen-tts-DgPgdXxG.js");
+    const { Qwen3TTSProvider } = await import("./qwen-tts-BLYZ6d9s.js");
     client = new Qwen3TTSProvider(options);
   } else {
     throw new ValidationError("Unsupported AI provider type", {
@@ -683,7 +1035,7 @@ async function getAI(options = {}) {
       providedType: options.type
     });
   }
-  return createRateLimitedAI(client, options);
+  return createObservedAI(createRateLimitedAI(client, options), options);
 }
 async function getAIAuto(options) {
   const baseUrl = String(options.baseUrl || "");
@@ -914,21 +1266,28 @@ const PACKAGE_VERSION_INITIALIZED = true;
 export {
   AIError as A,
   ContentFilterError as C,
+  DEFAULT_AI_GENERATION_LIMITS as D,
   ModelNotFoundError as M,
   OpenAIClient as O,
   PACKAGE_VERSION_INITIALIZED as P,
   RateLimitError as R,
-  ContextLengthError as a,
-  AuthenticationError as b,
-  extractTextContent as c,
-  AIClient as d,
+  normalizeImageGenerationOptions as a,
+  normalizeBaseAIOptions as b,
+  ContextLengthError as c,
+  AuthenticationError as d,
   extractRetryAfterSeconds as e,
-  AIMessage as f,
-  AIThread as g,
-  AI_PROVIDER_TYPES as h,
-  getAI as i,
-  getAIAuto as j,
-  getAIClient as k,
-  getOpenAI as l
+  extractTextContent as f,
+  AIClient as g,
+  AIMessage as h,
+  AIThread as i,
+  AI_PROVIDER_TYPES as j,
+  DEFAULT_AI_MAX_RETRIES as k,
+  DEFAULT_AI_TIMEOUT_MS as l,
+  getAI as m,
+  normalizeChatOptions as n,
+  getAIAuto as o,
+  prepareRequestControls as p,
+  getAIClient as q,
+  getOpenAI as r
 };
-//# sourceMappingURL=index-BT4thAvS.js.map
+//# sourceMappingURL=index-DCXO0nZA.js.map