@juspay/neurolink 10.10.6 → 10.10.8

package/dist/lib/core/redisConversationMemoryManager.js

@@ -15,7 +15,7 @@ import { withTimeout } from "../utils/errorHandling.js";
 import { buildContextFromPointer, getEffectiveTokenThreshold, } from "../utils/conversationMemory.js";
 import { runWithCurrentLangfuseContext } from "../services/server/ai/observability/instrumentation.js";
 import { logger } from "../utils/logger.js";
-import { createRedisClient, deserializeConversation, getNormalizedConfig, getPooledRedisClient, getSessionKey, getUserSessionsKey, releasePooledRedisClient, scanKeys, serializeConversation, } from "../utils/redis.js";
+import { createRedisClient, deserializeConversation, encodeStoredMessages, getSessionMessagesKey, MESSAGES_KEY_SUFFIX, isSessionMessagesKey, parseStoredMessages, serializeConversationMetadata, usesSplitMessageStorage, getNormalizedConfig, getPooledRedisClient, getSessionKey, getUserSessionsKey, releasePooledRedisClient, scanKeys, serializeConversation, } from "../utils/redis.js";
 const redisTracer = tracers.redis;
 const REDIS_TIMEOUT_MS = 5000;
 /**
@@ -140,7 +140,7 @@ export class RedisConversationMemoryManager {
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
                 const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
-                const conversation = deserializeConversation(conversationData || null);
+                const conversation = await this.hydrateMessages(deserializeConversation(conversationData || null), redisKey);
                 if (!conversation) {
                     span.setAttribute("session.found", false);
                     return undefined;
@@ -221,7 +221,7 @@ export class RedisConversationMemoryManager {
             }
             const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
             const conversationData = await this.redisClient.get(redisKey);
-            return deserializeConversation(conversationData || null);
+            return this.hydrateMessages(deserializeConversation(conversationData || null), redisKey);
         }
         catch (error) {
             logger.error("[RedisConversationMemoryManager] Failed to get raw session", {
@@ -391,7 +391,13 @@ export class RedisConversationMemoryManager {
                 }
                 const redisKey = getSessionKey(this.redisConfig, options.sessionId, options.userId);
                 const conversationData = await this.redisClient.get(redisKey);
-                let conversation = deserializeConversation(conversationData);
+                let conversation = await this.hydrateMessages(deserializeConversation(conversationData), redisKey);
+                // Split-storage bookkeeping: whether this session already keeps its
+                // messages in the companion LIST, and how many it held before this
+                // turn — so only the new ones are appended rather than rewriting the
+                // whole conversation on every turn.
+                const wasSplitStorage = usesSplitMessageStorage(conversation);
+                const messageCountBeforeTurn = conversation?.messages.length ?? 0;
                 const currentTime = new Date().toISOString();
                 const normalizedUserId = options.userId || "randomUser";
                 if (!conversation) {
@@ -486,6 +492,16 @@ export class RedisConversationMemoryManager {
                 const shouldSummarize = options.enableSummarization !== undefined
                     ? options.enableSummarization
                     : this.config.enableSummarization;
+                // Append-only: push just this turn's messages and persist a SMALL
+                // metadata blob. A session not yet using split storage (new, or a
+                // legacy blob) is converted once here, then every later turn appends.
+                await this.persistConversation(conversation, options.sessionId, options.userId, wasSplitStorage ? messageCountBeforeTurn : undefined);
+                // Scheduled AFTER the write, never before it. On the single turn that
+                // converts a legacy session, `checkAndSummarize` re-reads the blob and
+                // writes it back; observing the pre-conversion blob would make it
+                // re-serialize the record WITHOUT the split marker, so a later SET
+                // would strip the marker while the companion LIST already held the
+                // messages — the next read would then serve the stale inline copy.
                 if (shouldSummarize) {
                     const normalizedUserId = options.userId || "randomUser";
                     const summarizationKey = `${options.sessionId}:${normalizedUserId}`;
@@ -514,10 +530,8 @@ export class RedisConversationMemoryManager {
                         });
                     }
                 }
-                const serializedData = serializeConversation(conversation);
-                await this.redisClient.set(redisKey, serializedData);
                 // Log turn storage metadata for observability
-                const blobSizeBytes = Buffer.byteLength(serializedData, "utf8");
+                const blobSizeBytes = Buffer.byteLength(serializeConversationMetadata(conversation), "utf8");
                 logger.info("[ConversationMemory] Turn stored", {
                     requestId: options.requestId,
                     sessionId: options.sessionId,
@@ -611,7 +625,14 @@ export class RedisConversationMemoryManager {
                                 conversation.summarizedMessage;
                             latestConversation.lastTokenCount = conversation.lastTokenCount;
                             latestConversation.lastCountedAt = conversation.lastCountedAt;
-                            const freshSerialized = serializeConversation(latestConversation);
+                            // Only summarization metadata changed, so the companion LIST is
+                            // left alone. Critical: this re-read was NOT hydrated, so for a
+                            // split session `messages` is empty — writing it with
+                            // serializeConversation would drop the marker and make the record
+                            // look like a legacy blob with zero messages (silent data loss).
+                            const freshSerialized = usesSplitMessageStorage(latestConversation)
+                                ? serializeConversationMetadata(latestConversation)
+                                : serializeConversation(latestConversation);
                             await this.redisClient.set(redisKey, freshSerialized);
                             if (this.redisConfig.ttl > 0) {
                                 await this.redisClient.expire(redisKey, this.redisConfig.ttl);
@@ -631,6 +652,95 @@ export class RedisConversationMemoryManager {
             this.summarizationInProgress.delete(summarizationKey);
         }
     }
+    /**
+     * True only for keys holding a conversation BLOB — the sole key type these
+     * scan-then-GET paths may read.
+     *
+     * `${keyPrefix}*` also matches the companion message LISTs and, when a
+     * custom key prefix does not end in `conversation:`, the user-index SETs
+     * (whose derived prefix then collapses onto `keyPrefix`). `GET` against
+     * either raises WRONGTYPE, and counting them would inflate session totals.
+     */
+    isConversationBlobKey(key) {
+        return (!isSessionMessagesKey(key) &&
+            !key.endsWith(":sessions") &&
+            !key.startsWith(this.redisConfig.userSessionsKeyPrefix));
+    }
+    /**
+     * Hydrate a deserialized blob's messages from the companion LIST when the
+     * session uses split storage. Legacy blobs (messages inline) pass through
+     * untouched — that is what makes the migration backward compatible.
+     */
+    async hydrateMessages(conversation, redisKey) {
+        if (!conversation || !usesSplitMessageStorage(conversation)) {
+            return conversation;
+        }
+        if (!this.redisClient) {
+            return conversation;
+        }
+        // `getSession` and `buildContextMessages` guard their own GET with
+        // `withTimeout`; both now also depend on this read, so leaving it unguarded
+        // would let a hung LIST read block the request thread anyway.
+        const entries = await withTimeout(this.redisClient.lRange(`${redisKey}${MESSAGES_KEY_SUFFIX}`, 0, -1), REDIS_TIMEOUT_MS);
+        // `lRange` is typed `(string | Buffer)[]` — the client returns Buffers when
+        // a connection is opened in binary mode. Normalize rather than assert, so
+        // a binary-mode client reads its history instead of throwing on parse.
+        conversation.messages = parseStoredMessages(entries.map((entry) => entry.toString()));
+        return conversation;
+    }
+    /** Message count without materializing them — LLEN for split sessions. */
+    async countMessages(conversation, redisKey) {
+        if (!usesSplitMessageStorage(conversation) || !this.redisClient) {
+            return conversation.messages.length;
+        }
+        // `lLen` is typed `number | \`${number}\`` (RESP3 can deliver it as a
+        // string), and callers add it to numbers — coerce so the count never
+        // concatenates instead of summing.
+        return Number(await withTimeout(this.redisClient.lLen(`${redisKey}${MESSAGES_KEY_SUFFIX}`), REDIS_TIMEOUT_MS));
+    }
+    /** Load a session, messages included, regardless of storage format. */
+    async loadConversation(sessionId, userId) {
+        if (!this.redisClient) {
+            return null;
+        }
+        const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+        return this.hydrateMessages(deserializeConversation(await this.redisClient.get(redisKey)), redisKey);
+    }
+    /**
+     * Persist a conversation, splitting messages into the companion LIST.
+     * `appendFrom` appends only messages from that index onward (the per-turn
+     * fast path); omit it to rewrite the LIST wholesale, which is also how a
+     * legacy blob gets converted.
+     */
+    async persistConversation(conversation, sessionId, userId, appendFrom) {
+        if (!this.redisClient) {
+            return;
+        }
+        const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+        const messagesKey = getSessionMessagesKey(this.redisConfig, sessionId, userId);
+        // One MULTI, not four to six independent commands. The replace path is a
+        // DEL followed by an RPUSH, and on the legacy-conversion path the inline
+        // blob is the only copy of the history until the SET lands — so a failure
+        // between any two of them leaves the session either empty or unrecoverable.
+        // Grouping them also collapses the round trips, which is the point of the
+        // append-only layout.
+        const tx = this.redisClient.multi();
+        if (appendFrom === undefined) {
+            tx.del(messagesKey);
+        }
+        const toPush = appendFrom === undefined
+            ? conversation.messages
+            : conversation.messages.slice(appendFrom);
+        if (toPush.length > 0) {
+            tx.rPush(messagesKey, encodeStoredMessages(toPush));
+        }
+        tx.set(redisKey, serializeConversationMetadata(conversation));
+        if (this.redisConfig.ttl > 0) {
+            tx.expire(redisKey, this.redisConfig.ttl);
+            tx.expire(messagesKey, this.redisConfig.ttl);
+        }
+        await withTimeout(tx.exec(), REDIS_TIMEOUT_MS);
+    }
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)
@@ -664,7 +774,7 @@ export class RedisConversationMemoryManager {
                 });
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
                 const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
-                const conversation = deserializeConversation(conversationData || null);
+                const conversation = await this.hydrateMessages(deserializeConversation(conversationData || null), redisKey);
                 logger.debug("[RedisConversationMemoryManager] Retrieved conversation for context building", {
                     sessionId,
                     userId,
@@ -895,7 +1005,7 @@ export class RedisConversationMemoryManager {
                 return null;
             }
             // Deserialize the complete conversation object
-            const conversation = deserializeConversation(conversationData);
+            const conversation = await this.hydrateMessages(deserializeConversation(conversationData), sessionKey);
             if (!conversation) {
                 logger.debug("[RedisConversationMemoryManager] Failed to deserialize conversation data", {
                     userId,
@@ -1014,7 +1124,7 @@ User message: "${userMessage}"`;
         try {
             const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
             const conversationData = await this.redisClient.get(redisKey);
-            const conversation = deserializeConversation(conversationData || null);
+            const conversation = await this.hydrateMessages(deserializeConversation(conversationData || null), redisKey);
             return conversation?.messages ?? [];
         }
         catch (error) {
@@ -1050,11 +1160,8 @@ User message: "${userMessage}"`;
             conversation.summarizedMessage = undefined;
             conversation.lastTokenCount = undefined;
             conversation.lastCountedAt = undefined;
-            const serializedData = serializeConversation(conversation);
-            await this.redisClient.set(redisKey, serializedData);
-            if (this.redisConfig.ttl > 0) {
-                await this.redisClient.expire(redisKey, this.redisConfig.ttl);
-            }
+            // Wholesale replacement: rewrite the LIST rather than appending.
+            await this.persistConversation(conversation, sessionId, userId);
             logger.debug("[RedisConversationMemoryManager] Session messages replaced", {
                 sessionId,
                 userId,
@@ -1097,11 +1204,16 @@ User message: "${userMessage}"`;
             pattern,
             keyCount: keys.length,
         });
+        // Companion message LISTs share the session key prefix, so the SCAN above
+        // returns them too. GET on a LIST raises WRONGTYPE, and counting them as
+        // sessions would double `totalSessions` — filter them out exactly as the
+        // session listing already skips `:sessions` index keys.
+        const sessionKeys = keys.filter((key) => this.isConversationBlobKey(key));
         // Count messages in each session
         let totalTurns = 0;
-        for (const key of keys) {
+        for (const key of sessionKeys) {
             const conversationData = await this.redisClient.get(key);
-            const conversation = deserializeConversation(conversationData);
+            const conversation = await this.hydrateMessages(deserializeConversation(conversationData), key);
             if (conversation?.messages) {
                 // Pinned skill messages are extra rows inside a turn — exclude them
                 // so a skill-activating turn still counts as one turn.
@@ -1110,7 +1222,7 @@ User message: "${userMessage}"`;
             }
         }
         return {
-            totalSessions: keys.length,
+            totalSessions: sessionKeys.length,
             totalTurns,
         };
     }
@@ -1133,7 +1245,9 @@ User message: "${userMessage}"`;
         }, async (span) => {
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const result = await withTimeout(redisClient.del(redisKey), REDIS_TIMEOUT_MS);
+                // Delete the companion message LIST as well: leaving it behind would
+                // leak the messages and let a re-created session inherit them.
+                const result = await withTimeout(redisClient.del([redisKey, `${redisKey}${MESSAGES_KEY_SUFFIX}`]), REDIS_TIMEOUT_MS);
                 if (Number(result) > 0) {
                     // Remove session from user's session set
                     if (userId) {
@@ -1307,8 +1421,9 @@ User message: "${userMessage}"`;
             // List all sessions across all users by scanning Redis keys
             const keys = await scanKeys(this.redisClient, `${this.redisConfig.keyPrefix}*`);
             for (const key of keys) {
-                // Skip user session index keys (they end with :sessions)
-                if (key.endsWith(":sessions")) {
+                // Skip user session index keys (they end with :sessions) and the
+                // companion message LISTs — GET on a LIST raises WRONGTYPE.
+                if (!this.isConversationBlobKey(key)) {
                     continue;
                 }
                 const raw = await this.redisClient.get(key);
@@ -1325,7 +1440,9 @@ User message: "${userMessage}"`;
                     createdAt: session.createdAt,
                     updatedAt: session.updatedAt,
                     userId: session.userId,
-                    messageCount: session.messages.length,
+                    // LLEN for split sessions: the blob's inline array is empty here
+                    // because this branch reads the raw key without hydrating.
+                    messageCount: await this.countMessages(session, key),
                     lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
                 });
             }
@@ -1571,8 +1688,12 @@ User message: "${userMessage}"`;
                 logger.debug("[RedisConversationMemoryManager] Added new agentic loop report", { sessionId, reportId: report.reportId });
             }
             conversation.updatedAt = new Date().toISOString();
-            // Write back to Redis
-            const serializedData = serializeConversation(conversation);
+            // Write back to Redis. Metadata-only change, so the companion LIST is
+            // untouched — but the split marker must survive (see the summarization
+            // writeback above for why dropping it loses messages).
+            const serializedData = usesSplitMessageStorage(conversation)
+                ? serializeConversationMetadata(conversation)
+                : serializeConversation(conversation);
             await withTimeout(this.redisClient.set(redisKey, serializedData), 5000);
             if (this.redisConfig.ttl > 0) {
                 await withTimeout(this.redisClient.expire(redisKey, this.redisConfig.ttl), 5000);

package/dist/lib/processors/media/VideoProcessor.d.ts

@@ -44,7 +44,7 @@
  * ```
  */
 import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
-import type { FileInfo, ProcessedVideo, ProcessorFileProcessingResult, ProcessOptions } from "../../types/index.js";
+import type { FileInfo, ProcessedVideo, ProcessorFileProcessingResult, ProcessOptions, VideoProcessorOptions } from "../../types/index.js";
 /**
  * Narrow a loaded `fluent-ffmpeg` export to the shape this file actually uses:
  * a callable carrying the `ffprobe` and `setFfmpegPath` statics.
@@ -116,7 +116,7 @@ export declare class VideoProcessor extends BaseFileProcessor<ProcessedVideo> {
      * @param options - Optional processing options
      * @returns Processing result with extracted video data or error
      */
-    processFile(fileInfo: FileInfo, options?: ProcessOptions): Promise<ProcessorFileProcessingResult<ProcessedVideo>>;
+    processFile(fileInfo: FileInfo, options?: ProcessOptions & VideoProcessorOptions): Promise<ProcessorFileProcessingResult<ProcessedVideo>>;
     /**
      * Probe a video file to extract metadata using ffprobe.
      *
@@ -137,6 +137,11 @@ export declare class VideoProcessor extends BaseFileProcessor<ProcessedVideo> {
      * @returns Structured video metadata
      */
     private buildMetadata;
+    /**
+     * Clamp a caller-supplied frame quality into sharp's valid 1-100 range,
+     * falling back to the default when absent or non-numeric (#478).
+     */
+    private static resolveFrameQuality;
     /**
      * Extract keyframes from a video at calculated intervals.
      *
@@ -153,10 +158,15 @@ export declare class VideoProcessor extends BaseFileProcessor<ProcessedVideo> {
      * The interval is adaptive: if the tier interval would exceed MAX_FRAMES,
      * the interval widens to duration/MAX_FRAMES for full-video coverage.
      *
+     * A caller-supplied `options.frames` overrides the tier schedule entirely:
+     * that many frames are spread evenly across the clip, still capped at
+     * MAX_FRAMES. `options.quality` and `options.format` reach the encoder (#478).
+     *
      * @param videoPath - Path to the video file
      * @param tempDir - Temp directory for frame output
      * @param durationSec - Video duration in seconds
-     * @returns Array of JPEG frame buffers
+     * @param options - Caller frame budget / encoder settings
+     * @returns Array of encoded frame buffers (JPEG unless png was requested)
      */
     private extractKeyframes;
     /**

package/dist/lib/processors/media/VideoProcessor.js

@@ -313,7 +313,10 @@ export class VideoProcessor extends BaseFileProcessor {
      * @param options - Optional processing options
      * @returns Processing result with extracted video data or error
      */
-    async processFile(fileInfo, options) {
+    async processFile(fileInfo, 
+    // #478: widened with the keyframe knobs so `--video-frames`/`-quality`/
+    // `-format` can reach the encoder instead of being silently discarded.
+    options) {
         const filename = this.getFilename(fileInfo);
         const sizeBytes = fileInfo.size || fileInfo.buffer?.length || 0;
         return withSpan({
@@ -438,7 +441,7 @@ export class VideoProcessor extends BaseFileProcessor {
                 // Step 5: Extract keyframes
                 let keyframes = [];
                 try {
-                    keyframes = await this.extractKeyframes(tempVideoPath, tempDir, metadata.duration);
+                    keyframes = await this.extractKeyframes(tempVideoPath, tempDir, metadata.duration, options);
                 }
                 catch {
                     // Non-fatal: continue without keyframes if extraction fails
@@ -642,6 +645,16 @@ export class VideoProcessor extends BaseFileProcessor {
     // ===========================================================================
     // KEYFRAME EXTRACTION
     // ===========================================================================
+    /**
+     * Clamp a caller-supplied frame quality into sharp's valid 1-100 range,
+     * falling back to the default when absent or non-numeric (#478).
+     */
+    static resolveFrameQuality(quality) {
+        if (typeof quality !== "number" || !Number.isFinite(quality)) {
+            return VIDEO_CONFIG.FRAME_JPEG_QUALITY;
+        }
+        return Math.min(100, Math.max(1, Math.round(quality)));
+    }
     /**
      * Extract keyframes from a video at calculated intervals.
      *
@@ -658,20 +671,45 @@ export class VideoProcessor extends BaseFileProcessor {
      * The interval is adaptive: if the tier interval would exceed MAX_FRAMES,
      * the interval widens to duration/MAX_FRAMES for full-video coverage.
      *
+     * A caller-supplied `options.frames` overrides the tier schedule entirely:
+     * that many frames are spread evenly across the clip, still capped at
+     * MAX_FRAMES. `options.quality` and `options.format` reach the encoder (#478).
+     *
      * @param videoPath - Path to the video file
      * @param tempDir - Temp directory for frame output
      * @param durationSec - Video duration in seconds
-     * @returns Array of JPEG frame buffers
+     * @param options - Caller frame budget / encoder settings
+     * @returns Array of encoded frame buffers (JPEG unless png was requested)
      */
-    async extractKeyframes(videoPath, tempDir, durationSec) {
+    async extractKeyframes(videoPath, tempDir, durationSec, options) {
         if (durationSec <= 0) {
             return [];
         }
-        // Determine extraction interval based on duration
-        const intervalSec = this.getFrameInterval(durationSec);
+        // #478: honor the caller's frame budget, still bounded by MAX_FRAMES so a
+        // CLI flag can lower the cost but never raise it past the processor's own
+        // ceiling. A non-positive/non-finite request falls back to the default.
+        const requestedFrames = options?.frames;
+        const hasExplicitBudget = typeof requestedFrames === "number" &&
+            Number.isFinite(requestedFrames) &&
+            requestedFrames > 0;
+        const frameBudget = hasExplicitBudget
+            ? Math.min(Math.floor(requestedFrames), VIDEO_CONFIG.MAX_FRAMES)
+            : VIDEO_CONFIG.MAX_FRAMES;
+        // Determine extraction interval based on duration. When the caller asked
+        // for a specific frame count, spread that many evenly across the whole
+        // video instead of using the duration tier — otherwise a short interval
+        // would hit the budget early and only cover the opening seconds.
+        //
+        // Keyed on whether a budget was REQUESTED, not on whether it happens to be
+        // below MAX_FRAMES: asking for exactly MAX_FRAMES is still an explicit
+        // request and must produce that many frames, not silently fall back to the
+        // tier schedule (which yields far fewer on a short clip).
+        const intervalSec = hasExplicitBudget
+            ? Math.max(durationSec / frameBudget, Number.EPSILON)
+            : this.getFrameInterval(durationSec);
         // Calculate timestamps to extract
         const timestamps = [];
-        for (let t = 0; t < durationSec && timestamps.length < VIDEO_CONFIG.MAX_FRAMES; t += intervalSec) {
+        for (let t = 0; t < durationSec && timestamps.length < frameBudget; t += intervalSec) {
             timestamps.push(t);
         }
         if (timestamps.length === 0) {
@@ -691,13 +729,16 @@ export class VideoProcessor extends BaseFileProcessor {
                 const rawFrame = await fs.readFile(framePath);
                 // Resize to fit within max dimension while preserving aspect ratio
                 const sharp = (await import("sharp")).default;
-                const resized = await sharp(rawFrame)
-                    .resize(VIDEO_CONFIG.FRAME_MAX_DIMENSION, VIDEO_CONFIG.FRAME_MAX_DIMENSION, {
+                const pipeline = sharp(rawFrame).resize(VIDEO_CONFIG.FRAME_MAX_DIMENSION, VIDEO_CONFIG.FRAME_MAX_DIMENSION, {
                     fit: "inside",
                     withoutEnlargement: true,
-                })
-                    .jpeg({ quality: VIDEO_CONFIG.FRAME_JPEG_QUALITY })
-                    .toBuffer();
+                });
+                // #478: `--video-quality` / `--video-format` were accepted by the CLI
+                // and then dropped on the floor; both now reach the encoder.
+                const quality = VideoProcessor.resolveFrameQuality(options?.quality);
+                const resized = await (options?.format === "png"
+                    ? pipeline.png({ quality })
+                    : pipeline.jpeg({ quality })).toBuffer();
                 keyframes.push(resized);
             }
             catch {

package/dist/lib/providers/googleAiStudio/client.d.ts

@@ -2,37 +2,6 @@ import { type AIProviderName } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
 import type { ZodUnknownSchema, EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult } from "../../types/index.js";
 import type { LanguageModel, Schema } from "../../types/index.js";
-/**
- * Google AI Studio provider implementation using BaseProvider
- * Migrated from original GoogleAIStudio class to new factory pattern
- *
- * @important Structured Output Limitation
- * Google Gemini models cannot combine function calling (tools) with structured
- * output (JSON schema). When using schemas with output.format: "json", you MUST
- * set disableTools: true.
- *
- * Error without disableTools:
- * "Function calling with a response mime type: 'application/json' is unsupported"
- *
- * This is a Google API limitation documented at:
- * https://ai.google.dev/gemini-api/docs/function-calling
- *
- * @example
- * ```typescript
- * // ✅ Correct usage with schemas
- * const provider = new GoogleAIStudioProvider("gemini-2.5-flash");
- * const result = await provider.generate({
- *   input: { text: "Analyze data" },
- *   schema: MySchema,
- *   output: { format: "json" },
- *   disableTools: true  // Required
- * });
- * ```
- *
- * @note Gemini 3 Pro Preview (November 2025) will support combining tools + schemas
- * @note "Too many states for serving" errors can occur with complex schemas + tools.
- *       Solution: Simplify schema or use disableTools: true
- */
 export declare class GoogleAIStudioProvider extends BaseProvider {
     private credentials?;
     constructor(modelName?: string, sdk?: unknown, credentials?: {