@juspay/neurolink 9.6.0 → 9.7.0

package/dist/lib/providers/mistral.js

@@ -6,7 +6,7 @@ import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { logger } from "../utils/logger.js";
 import { createMistralConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 // Configuration helpers - now using consolidated utility
 const getMistralApiKey = () => {
     return validateApiKey(createMistralConfig());
@@ -63,7 +63,8 @@ export class MistralProvider extends BaseProvider {
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[MistralProvider] Failed to store tool executions", {

package/dist/lib/providers/openAI.js

@@ -9,7 +9,7 @@ import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, Ra
 import { logger } from "../utils/logger.js";
 import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 // Configuration helpers - now using consolidated utility
 const getOpenAIApiKey = () => {
     return validateApiKey(createOpenAIConfig());
@@ -282,7 +282,7 @@ export class OpenAIProvider extends BaseProvider {
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     logger.info("Tool execution completed", { toolResults, toolCalls });

package/dist/lib/providers/openRouter.js

@@ -1,13 +1,14 @@
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-import { Output, streamText } from "ai";
+import { Output, streamText, } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { getProviderModel } from "../utils/providerConfig.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 // Constants
 const MODELS_DISCOVERY_TIMEOUT_MS = 5000; // 5 seconds for model discovery
 // Configuration helpers
@@ -206,8 +207,7 @@ export class OpenRouterProvider extends BaseProvider {
             // BaseProvider.stream() pre-merges base tools + external tools into options.tools
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools
-                ? options.tools ||
-                    (await this.getAllTools())
+                ? options.tools || (await this.getAllTools())
                 : {};
             logger.debug(`OpenRouter: Tools for streaming`, {
                 shouldUseTools,
@@ -229,7 +229,8 @@ export class OpenRouterProvider extends BaseProvider {
                     toolChoice: "auto",
                     maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 }),
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -276,7 +277,7 @@ export class OpenRouterProvider extends BaseProvider {
                 }
             }
             const result = await streamText(streamOptions);
-            timeoutController?.cleanup();
+            result.text.finally(() => timeoutController?.cleanup());
             // Transform stream to content object stream using fullStream (handles both text and tool calls)
             const transformedStream = (async function* () {
                 // Try fullStream first (handles both text and tool calls), fallback to textStream
@@ -439,7 +440,7 @@ export class OpenRouterProvider extends BaseProvider {
         }
         catch (error) {
             clearTimeout(timeoutId);
-            if (error instanceof Error && error.name === "AbortError") {
+            if (isAbortError(error)) {
                 throw new Error(`Request timed out after ${MODELS_DISCOVERY_TIMEOUT_MS / 1000} seconds`);
             }
             throw error;

package/dist/lib/providers/openaiCompatible.js

@@ -3,7 +3,7 @@ import { streamText } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
@@ -159,6 +159,11 @@ export class OpenAICompatibleProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Get tools - options.tools is pre-merged by BaseProvider.stream()
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
@@ -173,9 +178,10 @@ export class OpenAICompatibleProvider extends BaseProvider {
                     ? { temperature: options.temperature }
                     : {}),
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                tools: options.tools,
-                toolChoice: "auto",
-                abortSignal: timeoutController?.controller.signal,
+                tools,
+                toolChoice: shouldUseTools ? "auto" : "none",
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {

package/dist/lib/rag/resilience/RetryHandler.js

@@ -6,6 +6,7 @@
  * vector queries, and LLM-based extraction.
  */
 import { withRetry, } from "../../core/infrastructure/index.js";
+import { isAbortError } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
 import { EmbeddingError, isRetryableRAGError, MetadataExtractionError, RAGError, RAGErrorCodes, VectorQueryError, } from "../errors/RAGError.js";
 /**
@@ -50,6 +51,10 @@ function sleep(ms) {
  * Check if an error is retryable based on configuration
  */
 export function isRetryable(error, config = DEFAULT_RAG_RETRY_CONFIG) {
+    // Never retry abort errors - the operation was intentionally cancelled
+    if (isAbortError(error)) {
+        return false;
+    }
     // Use custom shouldRetry if provided
     if (config.shouldRetry) {
         return config.shouldRetry(error);
@@ -70,8 +75,7 @@ export function isRetryable(error, config = DEFAULT_RAG_RETRY_CONFIG) {
         // Timeout errors
         if (errorObj.name === "TimeoutError" ||
             errorObj.code === "TIMEOUT" ||
-            errorObj.code === "ETIMEDOUT" ||
-            errorObj.name === "AbortError") {
+            errorObj.code === "ETIMEDOUT") {
             return true;
         }
         // Network errors

package/dist/lib/services/server/ai/observability/instrumentation.d.ts

@@ -15,7 +15,7 @@ import type { LangfuseConfig } from "../../../../types/observability.js";
  * Extended context for Langfuse spans
  * Supports all Langfuse trace attributes for rich observability
  */
-type LangfuseContext = {
+export type LangfuseContext = {
     userId?: string | null;
     sessionId?: string | null;
     /** Conversation/thread identifier for grouping related traces */
@@ -51,6 +51,27 @@ type LangfuseContext = {
      * @default undefined (uses global setting, which defaults to true)
      */
     autoDetectOperationName?: boolean;
+    /**
+     * Custom attributes to set on all spans within this context.
+     *
+     * These attributes are propagated to every span created within the
+     * AsyncLocalStorage context, enabling application-level context
+     * (e.g., Slack channel name, feature flag, tenant ID) to appear
+     * on all SDK-internal spans.
+     *
+     * @example
+     * await setLangfuseContext({
+     *   userId: "user@email.com",
+     *   customAttributes: {
+     *     "app.slack.channel": "engineering",
+     *     "app.tenant.id": "tenant-123",
+     *     "app.feature.flag": true,
+     *   }
+     * }, async () => {
+     *   // All spans created here will have these attributes
+     * });
+     */
+    customAttributes?: Record<string, string | number | boolean>;
 };
 /**
  * Initialize OpenTelemetry with Langfuse span processor
@@ -140,6 +161,8 @@ export declare function setLangfuseContext<T = void>(context: {
     operationName?: string | null;
     /** Override global autoDetectOperationName for this context */
     autoDetectOperationName?: boolean;
+    /** Custom attributes to set on all spans within this context */
+    customAttributes?: Record<string, string | number | boolean>;
 }, callback?: () => T | Promise<T>): Promise<T | void>;
 /**
  * Get the current Langfuse context from AsyncLocalStorage
@@ -194,4 +217,3 @@ export declare function getSpanProcessors(): SpanProcessor[];
  * @returns true if operating in external TracerProvider mode
  */
 export declare function isUsingExternalTracerProvider(): boolean;
-export {};

package/dist/lib/services/server/ai/observability/instrumentation.js

@@ -119,7 +119,14 @@ class ContextEnricher {
         // 2. Formatted name with userId + operationName
         // 3. userId only (legacy fallback)
         const traceName = this.buildTraceName(context?.traceName, userId, operationName);
-        // Set user and session attributes
+        // Apply custom attributes FIRST so internal attributes always take precedence
+        // and cannot be accidentally overwritten by user-provided values
+        if (context?.customAttributes) {
+            for (const [key, value] of Object.entries(context.customAttributes)) {
+                span.setAttribute(key, value);
+            }
+        }
+        // Set user and session attributes (internal - always override custom)
         if (userId && userId !== "guest") {
             span.setAttribute("user.id", userId);
         }
@@ -657,6 +664,10 @@ export async function setLangfuseContext(context, callback) {
         autoDetectOperationName: context.autoDetectOperationName !== undefined
             ? context.autoDetectOperationName
             : currentContext.autoDetectOperationName,
+        // Custom attributes support
+        customAttributes: context.customAttributes !== undefined
+            ? context.customAttributes
+            : currentContext.customAttributes,
     };
     if (callback) {
         return await contextStorage.run(newContext, callback);

package/dist/lib/types/generateTypes.d.ts

@@ -217,6 +217,8 @@ export type GenerateOptions = {
     schema?: ValidationSchema;
     tools?: Record<string, Tool>;
     timeout?: number | string;
+    /** AbortSignal for external cancellation of the AI call */
+    abortSignal?: AbortSignal;
     /**
      * Disable tool execution (including built-in tools)
      *
@@ -235,6 +237,17 @@ export type GenerateOptions = {
      * ```
      */
     disableTools?: boolean;
+    /** Include only these tools by name (whitelist). If set, only matching tools are available. */
+    toolFilter?: string[];
+    /** Exclude these tools by name (blacklist). Applied after toolFilter. */
+    excludeTools?: string[];
+    /**
+     * Skip injecting tool schemas into the system prompt.
+     * When true, tools are ONLY passed natively via the provider's `tools` parameter,
+     * avoiding duplicate tool definitions (~30K tokens savings per call).
+     * Default: false (backward compatible — tool schemas are injected into system prompt).
+     */
+    skipToolPromptInjection?: boolean;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
     context?: StandardRecord;
@@ -389,6 +402,7 @@ export type GenerateResult = {
     } | null;
     provider?: string;
     model?: string;
+    finishReason?: string;
     usage?: TokenUsage;
     responseTime?: number;
     toolCalls?: Array<{
@@ -546,8 +560,14 @@ export type TextGenerationOptions = {
     };
     tools?: Record<string, Tool>;
     timeout?: number | string;
+    /** AbortSignal for external cancellation of the AI call */
+    abortSignal?: AbortSignal;
     disableTools?: boolean;
     maxSteps?: number;
+    /** Include only these tools by name (whitelist). If set, only matching tools are available. */
+    toolFilter?: string[];
+    /** Exclude these tools by name (blacklist). Applied after toolFilter. */
+    excludeTools?: string[];
     /**
      * Text-to-Speech (TTS) configuration
      *
@@ -609,6 +629,13 @@ export type TextGenerationOptions = {
      * @internal Set by NeuroLink SDK — not typically used directly by consumers.
      */
     fileRegistry?: unknown;
+    /**
+     * Skip injecting tool schemas into the system prompt.
+     * When true, tools are ONLY passed natively via the provider's `tools` parameter,
+     * avoiding duplicate tool definitions (~30K tokens savings per call).
+     * Default: false (backward compatible — tool schemas are injected into system prompt).
+     */
+    skipToolPromptInjection?: boolean;
     /**
      * ## Extended Thinking Options
      *
@@ -702,6 +729,7 @@ export type TextGenerationOptions = {
  */
 export type TextGenerationResult = {
     content: string;
+    finishReason?: string;
     provider?: string;
     model?: string;
     usage?: TokenUsage;

package/dist/lib/types/ragTypes.d.ts

@@ -133,7 +133,15 @@ export type RAGRetryConfig = {
     backoffMultiplier: number;
     /** Whether to add jitter (default: true) */
     jitter: boolean;
-    /** Custom function to determine if error is retryable */
+    /**
+     * Custom function to determine if error is retryable.
+     *
+     * Note: In `isRetryable()`, this callback is invoked *before* the built-in
+     * abort-error check. If you provide a custom `shouldRetry`, it should
+     * explicitly handle abort errors (e.g. return `false` for them) when
+     * cancellation correctness is required. Otherwise an aborted operation
+     * could be retried instead of propagating immediately.
+     */
     shouldRetry?: (error: Error) => boolean;
     /** Retryable error codes */
     retryableErrorCodes?: string[];

package/dist/lib/types/streamTypes.d.ts

@@ -321,8 +321,21 @@ export type StreamOptions = {
     schema?: ValidationSchema;
     tools?: Record<string, Tool>;
     timeout?: number | string;
+    /** AbortSignal for external cancellation of the AI call */
+    abortSignal?: AbortSignal;
     disableTools?: boolean;
     maxSteps?: number;
+    /** Include only these tools by name (whitelist). If set, only matching tools are available. */
+    toolFilter?: string[];
+    /** Exclude these tools by name (blacklist). Applied after toolFilter. */
+    excludeTools?: string[];
+    /**
+     * Skip injecting tool schemas into the system prompt.
+     * When true, tools are ONLY passed natively via the provider's `tools` parameter,
+     * avoiding duplicate tool definitions (~30K tokens savings per call).
+     * Default: false (backward compatible — tool schemas are injected into system prompt).
+     */
+    skipToolPromptInjection?: boolean;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
     context?: UnknownRecord;

package/dist/lib/utils/conversationMemory.js

@@ -104,6 +104,21 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
     }
     const userMessage = originalOptions.originalPrompt || originalOptions.prompt || "";
     const aiResponse = result.content ?? "";
+    // Guard: skip storing conversation turn if AI response is empty AND no tools were used.
+    // Empty assistant messages cause "text content blocks must be non-empty" errors
+    // when loaded as conversation history on the next interaction.
+    // However, tool-only turns (empty text but tools were invoked) must still be stored
+    // to preserve tool-calling conversation history.
+    const hasToolActivity = (result.toolsUsed && result.toolsUsed.length > 0) ||
+        (result.toolExecutions && result.toolExecutions.length > 0);
+    if (!aiResponse.trim() && !hasToolActivity) {
+        logger.warn("[conversationMemoryUtils] Skipping conversation turn storage — AI response is empty and no tool activity", {
+            sessionId,
+            userId,
+            userMessageLength: userMessage.length,
+        });
+        return;
+    }
     let providerDetails;
     if (result.provider && result.model) {
         providerDetails = {

package/dist/lib/utils/errorHandling.d.ts

@@ -244,6 +244,11 @@ export declare class CircuitBreaker {
     getState(): "closed" | "open" | "half-open";
     getFailureCount(): number;
 }
+/**
+ * Detect AbortError from any source (DOMException, plain Error, or message-based).
+ * Used to short-circuit retry/fallback loops when an abort signal fires.
+ */
+export declare function isAbortError(error: unknown): boolean;
 /**
  * Error handler that decides whether to retry based on error type
  */

package/dist/lib/utils/errorHandling.js

@@ -820,6 +820,25 @@ export class CircuitBreaker {
         return this.failures;
     }
 }
+/**
+ * Detect AbortError from any source (DOMException, plain Error, or message-based).
+ * Used to short-circuit retry/fallback loops when an abort signal fires.
+ */
+export function isAbortError(error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+        return true;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+        return true;
+    }
+    if (error instanceof Error &&
+        (error.message === "This operation was aborted" ||
+            error.message === "The operation was aborted" ||
+            error.message?.includes("The user aborted a request"))) {
+        return true;
+    }
+    return false;
+}
 /**
  * Error handler that decides whether to retry based on error type
  */

package/dist/lib/utils/pricing.d.ts

@@ -0,0 +1,12 @@
+import type { TokenUsage } from "../types/analytics.js";
+/**
+ * Calculate the dollar cost of a generate/stream call based on token usage.
+ * Returns 0 if the provider/model combination is not in the pricing table.
+ */
+export declare function calculateCost(provider: string, model: string, usage: TokenUsage): number;
+/**
+ * Check if pricing is available for a provider/model combination.
+ * Checks the rate table directly instead of computing a cost,
+ * so even very cheap models (e.g. gemini-1.5-flash) are detected correctly.
+ */
+export declare function hasPricing(provider: string, model: string): boolean;

package/dist/lib/utils/pricing.js

@@ -0,0 +1,134 @@
+/**
+ * Per-token pricing data (USD per token). Updated Feb 2026.
+ * Sources:
+ * - Anthropic: https://www.anthropic.com/pricing
+ * - OpenAI: https://openai.com/api/pricing
+ * - Google: https://ai.google.dev/pricing
+ *
+ * Note: Not all supported providers have pricing data. Missing providers
+ * (Bedrock, Azure, Mistral, etc.) will return 0 from calculateCost().
+ */
+const PRICING = {
+    // Anthropic (direct API)
+    anthropic: {
+        "claude-sonnet-4-5-20250929": {
+            input: 3.0 / 1_000_000,
+            output: 15.0 / 1_000_000,
+            cacheRead: 0.3 / 1_000_000,
+            cacheCreation: 3.75 / 1_000_000,
+        },
+        "claude-opus-4-6": {
+            input: 15.0 / 1_000_000,
+            output: 75.0 / 1_000_000,
+            cacheRead: 1.5 / 1_000_000,
+            cacheCreation: 18.75 / 1_000_000,
+        },
+        "claude-haiku-4-5-20251001": {
+            input: 0.8 / 1_000_000,
+            output: 4.0 / 1_000_000,
+            cacheRead: 0.08 / 1_000_000,
+            cacheCreation: 1.0 / 1_000_000,
+        },
+    },
+    // Google Vertex AI (same models, same pricing)
+    vertex: {
+        "claude-sonnet-4-5@20250929": {
+            input: 3.0 / 1_000_000,
+            output: 15.0 / 1_000_000,
+            cacheRead: 0.3 / 1_000_000,
+            cacheCreation: 3.75 / 1_000_000,
+        },
+        "claude-opus-4-6": {
+            input: 15.0 / 1_000_000,
+            output: 75.0 / 1_000_000,
+            cacheRead: 1.5 / 1_000_000,
+            cacheCreation: 18.75 / 1_000_000,
+        },
+        "claude-haiku-4-5@20251001": {
+            input: 0.8 / 1_000_000,
+            output: 4.0 / 1_000_000,
+            cacheRead: 0.08 / 1_000_000,
+            cacheCreation: 1.0 / 1_000_000,
+        },
+    },
+    // OpenAI
+    openai: {
+        "gpt-4o": { input: 2.5 / 1_000_000, output: 10.0 / 1_000_000 },
+        "gpt-4o-mini": { input: 0.15 / 1_000_000, output: 0.6 / 1_000_000 },
+        "gpt-4-turbo": { input: 10.0 / 1_000_000, output: 30.0 / 1_000_000 },
+        o1: { input: 15.0 / 1_000_000, output: 60.0 / 1_000_000 },
+        "o1-mini": { input: 1.1 / 1_000_000, output: 4.4 / 1_000_000 },
+    },
+    // Google (Gemini)
+    google: {
+        "gemini-2.0-flash": { input: 0.1 / 1_000_000, output: 0.4 / 1_000_000 },
+        "gemini-2.0-pro": { input: 1.25 / 1_000_000, output: 10.0 / 1_000_000 },
+        "gemini-1.5-pro": { input: 1.25 / 1_000_000, output: 5.0 / 1_000_000 },
+        "gemini-1.5-flash": { input: 0.075 / 1_000_000, output: 0.3 / 1_000_000 },
+    },
+};
+/**
+ * Map of normalized provider aliases to canonical PRICING keys.
+ * After stripping non-alpha characters, e.g. "google-ai" becomes "googleai".
+ */
+const PROVIDER_ALIASES = {
+    googleai: "google",
+    googleaistudio: "google",
+    anthropic: "anthropic",
+    openai: "openai",
+    vertex: "vertex",
+    google: "google",
+};
+/**
+ * Look up per-token rates for a provider/model combination.
+ * Normalises the provider name via aliases, then tries an exact model match
+ * followed by a longest-prefix match so that e.g. "gpt-4o-2024-08-06"
+ * resolves to the "gpt-4o" entry without a false hit on "gpt-4".
+ *
+ * @returns The rate entry, or undefined when the combination is unknown.
+ */
+function findRates(provider, model) {
+    const stripped = provider.toLowerCase().replace(/[^a-z]/g, "");
+    const normalizedProvider = PROVIDER_ALIASES[stripped] ?? stripped;
+    const providerPricing = PRICING[normalizedProvider] || PRICING[provider];
+    if (!providerPricing) {
+        return undefined;
+    }
+    // Exact match
+    if (providerPricing[model]) {
+        return providerPricing[model];
+    }
+    // Longest-prefix match
+    const sortedKeys = Object.keys(providerPricing).sort((a, b) => b.length - a.length);
+    const key = sortedKeys.find((k) => model.startsWith(k));
+    return key ? providerPricing[key] : undefined;
+}
+/**
+ * Calculate the dollar cost of a generate/stream call based on token usage.
+ * Returns 0 if the provider/model combination is not in the pricing table.
+ */
+export function calculateCost(provider, model, usage) {
+    const rates = findRates(provider, model);
+    if (!rates) {
+        return 0;
+    }
+    let cost = 0;
+    cost += (usage.input || 0) * rates.input;
+    cost += (usage.output || 0) * rates.output;
+    if (usage.cacheReadTokens && rates.cacheRead) {
+        cost += usage.cacheReadTokens * rates.cacheRead;
+    }
+    if (usage.cacheCreationTokens && rates.cacheCreation) {
+        cost += usage.cacheCreationTokens * rates.cacheCreation;
+    }
+    return Math.round(cost * 1_000_000) / 1_000_000; // Round to 6 decimal places
+}
+/**
+ * Check if pricing is available for a provider/model combination.
+ * Checks the rate table directly instead of computing a cost,
+ * so even very cheap models (e.g. gemini-1.5-flash) are detected correctly.
+ */
+export function hasPricing(provider, model) {
+    return findRates(provider, model) !== undefined;
+}
+//# sourceMappingURL=pricing.js.map

package/dist/lib/utils/redis.d.ts

@@ -5,6 +5,23 @@
 import { createClient } from "redis";
 import type { RedisStorageConfig, RedisConversationObject } from "../types/conversation.js";
 type RedisClient = ReturnType<typeof createClient>;
+/**
+ * Get a pooled Redis connection. Multiple callers with the same host:port:db
+ * share a single connection, reducing connection count.
+ */
+export declare function getPooledRedisClient(config: Required<RedisStorageConfig>): Promise<RedisClient>;
+/**
+ * Release a pooled Redis connection. Only closes when refCount reaches 0.
+ */
+export declare function releasePooledRedisClient(config: Required<RedisStorageConfig>): Promise<void>;
+/**
+ * Get stats about the connection pool
+ */
+export declare function getPoolStats(): Array<{
+    key: string;
+    refCount: number;
+    isOpen: boolean;
+}>;
 /**
  * Creates a Redis client with the provided configuration
  */