@j0hanz/code-review-analyst-mcp 1.5.0 → 1.5.2

package/README.md

@@ -371,17 +371,21 @@ Create a test plan covering the changes in the diff using the Flash model with t
 
 ### Environment Variables
 
-| Variable                       | Description                                          | Default      | Required |
-| ------------------------------ | ---------------------------------------------------- | ------------ | -------- |
-| `GEMINI_API_KEY`               | Gemini API key                                       | —            | Yes      |
-| `GOOGLE_API_KEY`               | Alternative API key (if `GEMINI_API_KEY` not set)    | —            | No       |
-| `GEMINI_MODEL`                 | Override default model selection                     | —            | No       |
-| `GEMINI_HARM_BLOCK_THRESHOLD`  | Safety threshold (BLOCK_NONE, BLOCK_ONLY_HIGH, etc.) | `BLOCK_NONE` | No       |
-| `MAX_DIFF_CHARS`               | Max chars for diff input                             | `120000`     | No       |
-| `MAX_CONTEXT_CHARS`            | Max combined context for inspection                  | `500000`     | No       |
-| `MAX_CONCURRENT_CALLS`         | Max concurrent Gemini requests                       | `10`         | No       |
-| `MAX_CONCURRENT_CALLS_WAIT_MS` | Max wait time for a free Gemini slot                 | `2000`       | No       |
-| `MAX_CONCURRENT_CALLS_POLL_MS` | Poll interval while waiting for a free slot          | `25`         | No       |
+| Variable                        | Description                                          | Default      | Required |
+| ------------------------------- | ---------------------------------------------------- | ------------ | -------- |
+| `GEMINI_API_KEY`                | Gemini API key                                       | —            | Yes      |
+| `GOOGLE_API_KEY`                | Alternative API key (if `GEMINI_API_KEY` not set)    | —            | No       |
+| `GEMINI_MODEL`                  | Override default model selection                     | —            | No       |
+| `GEMINI_HARM_BLOCK_THRESHOLD`   | Safety threshold (BLOCK_NONE, BLOCK_ONLY_HIGH, etc.) | `BLOCK_NONE` | No       |
+| `MAX_DIFF_CHARS`                | Max chars for diff input                             | `120000`     | No       |
+| `MAX_CONTEXT_CHARS`             | Max combined context for inspection                  | `500000`     | No       |
+| `MAX_CONCURRENT_CALLS`          | Max concurrent Gemini requests                       | `10`         | No       |
+| `MAX_CONCURRENT_BATCH_CALLS`    | Max concurrent inline batch requests                 | `2`          | No       |
+| `MAX_CONCURRENT_CALLS_WAIT_MS`  | Max wait time for a free Gemini slot                 | `2000`       | No       |
+| `MAX_SCHEMA_RETRY_ERROR_CHARS`  | Max chars from schema error injected into retry text | `1500`       | No       |
+| `GEMINI_BATCH_MODE`             | Request mode for Gemini calls (`off`, `inline`)      | `off`        | No       |
+| `GEMINI_BATCH_POLL_INTERVAL_MS` | Poll interval for batch job status                   | `2000`       | No       |
+| `GEMINI_BATCH_TIMEOUT_MS`       | Max wait for batch completion                        | `120000`     | No       |
 
 ### Models
 

package/dist/lib/diff-parser.js

@@ -32,24 +32,35 @@ function sortPaths(paths) {
     }
     return Array.from(paths).sort(PATH_SORTER);
 }
-function buildDiffComputation(files) {
+function buildDiffComputation(files, options) {
     let added = 0;
     let deleted = 0;
-    const paths = new Set();
-    const summaries = new Array(files.length);
+    const paths = options.needPaths ? new Set() : undefined;
+    const summaries = options.needSummaries
+        ? new Array(files.length)
+        : undefined;
     let index = 0;
     for (const file of files) {
         added += file.additions;
         deleted += file.deletions;
-        const path = resolveChangedPath(file);
-        if (path) {
-            paths.add(path);
+        if (options.needPaths || options.needSummaries) {
+            const path = resolveChangedPath(file);
+            if (paths && path) {
+                paths.add(path);
+            }
+            if (summaries) {
+                summaries[index] =
+                    `${path ?? UNKNOWN_PATH} (+${file.additions} -${file.deletions})`;
+            }
         }
-        summaries[index] =
-            `${path ?? UNKNOWN_PATH} (+${file.additions} -${file.deletions})`;
         index += 1;
     }
-    return { added, deleted, paths, summaries };
+    return {
+        added,
+        deleted,
+        paths: paths ?? new Set(),
+        summaries: summaries ?? [],
+    };
 }
 function buildStats(filesCount, added, deleted) {
     return { files: filesCount, added, deleted };
@@ -61,7 +72,10 @@ export function computeDiffStatsAndSummaryFromFiles(files) {
             summary: NO_FILES_CHANGED,
         };
     }
-    const computed = buildDiffComputation(files);
+    const computed = buildDiffComputation(files, {
+        needPaths: false,
+        needSummaries: true,
+    });
     const stats = buildStats(files.length, computed.added, computed.deleted);
     return {
         stats,
@@ -75,7 +89,10 @@ export function computeDiffStatsAndPathsFromFiles(files) {
             paths: EMPTY_PATHS,
         };
     }
-    const computed = buildDiffComputation(files);
+    const computed = buildDiffComputation(files, {
+        needPaths: true,
+        needSummaries: false,
+    });
     return {
         stats: buildStats(files.length, computed.added, computed.deleted),
         paths: sortPaths(computed.paths),
@@ -86,7 +103,7 @@ export function extractChangedPathsFromFiles(files) {
     if (files.length === 0) {
         return EMPTY_PATHS;
     }
-    return sortPaths(buildDiffComputation(files).paths);
+    return sortPaths(buildDiffComputation(files, { needPaths: true, needSummaries: false }).paths);
 }
 /** Extract all unique changed file paths (renamed: returns new path). */
 export function extractChangedPaths(diff) {
@@ -96,7 +113,10 @@ export function computeDiffStatsFromFiles(files) {
     if (files.length === 0) {
         return EMPTY_STATS;
     }
-    const computed = buildDiffComputation(files);
+    const computed = buildDiffComputation(files, {
+        needPaths: false,
+        needSummaries: false,
+    });
     return buildStats(files.length, computed.added, computed.deleted);
 }
 /** Count changed files, added lines, and deleted lines. */

package/dist/lib/diff-store.d.ts

@@ -1,4 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ParsedFile } from './diff-parser.js';
 import { createErrorToolResponse } from './tool-response.js';
 export declare const DIFF_RESOURCE_URI = "diff://current";
 export interface DiffStats {
@@ -8,15 +9,16 @@ export interface DiffStats {
 }
 export interface DiffSlot {
     diff: string;
+    parsedFiles: readonly ParsedFile[];
     stats: DiffStats;
     generatedAt: string;
     mode: string;
 }
 /** Call once during server setup so the store can emit resource-updated notifications. */
 export declare function initDiffStore(server: McpServer): void;
-export declare function storeDiff(data: DiffSlot): void;
-export declare function getDiff(): DiffSlot | undefined;
-export declare function hasDiff(): boolean;
+export declare function storeDiff(data: DiffSlot, key?: string): void;
+export declare function getDiff(key?: string): DiffSlot | undefined;
+export declare function hasDiff(key?: string): boolean;
 /** Test-only: directly set or clear the diff slot without emitting resource-updated. */
-export declare function setDiffForTesting(data: DiffSlot | undefined): void;
+export declare function setDiffForTesting(data: DiffSlot | undefined, key?: string): void;
 export declare function createNoDiffError(): ReturnType<typeof createErrorToolResponse>;

package/dist/lib/diff-store.js

@@ -1,27 +1,32 @@
 import { createErrorToolResponse } from './tool-response.js';
 export const DIFF_RESOURCE_URI = 'diff://current';
-let slot;
+const diffSlots = new Map();
 let sendResourceUpdated;
 /** Call once during server setup so the store can emit resource-updated notifications. */
 export function initDiffStore(server) {
     const inner = server.server;
     sendResourceUpdated = inner.sendResourceUpdated.bind(inner);
 }
-export function storeDiff(data) {
-    slot = data;
+export function storeDiff(data, key = process.cwd()) {
+    diffSlots.set(key, data);
     void sendResourceUpdated?.({ uri: DIFF_RESOURCE_URI }).catch(() => {
-        // Notification is best-effort; never block the tool response.
+        // Ignore errors sending resource-updated, which can happen if the server is not fully initialized yet.
     });
 }
-export function getDiff() {
-    return slot;
+export function getDiff(key = process.cwd()) {
+    return diffSlots.get(key);
 }
-export function hasDiff() {
-    return slot !== undefined;
+export function hasDiff(key = process.cwd()) {
+    return diffSlots.has(key);
 }
 /** Test-only: directly set or clear the diff slot without emitting resource-updated. */
-export function setDiffForTesting(data) {
-    slot = data;
+export function setDiffForTesting(data, key = process.cwd()) {
+    if (data) {
+        diffSlots.set(key, data);
+    }
+    else {
+        diffSlots.delete(key);
+    }
 }
 export function createNoDiffError() {
     return createErrorToolResponse('E_NO_DIFF', 'No diff cached. You must call the generate_diff tool before using any review tool. Run generate_diff with mode="unstaged" or mode="staged" to capture the current branch changes, then retry this tool.', undefined, { retryable: false, kind: 'validation' });

package/dist/lib/gemini.d.ts

@@ -4,4 +4,8 @@ import type { GeminiStructuredRequest } from './types.js';
 export declare const geminiEvents: EventEmitter<[never]>;
 export declare function getCurrentRequestId(): string;
 export declare function setClientForTesting(client: GoogleGenAI): void;
+export declare function getGeminiQueueSnapshot(): {
+    activeCalls: number;
+    waitingCalls: number;
+};
 export declare function generateStructuredJson(request: GeminiStructuredRequest): Promise<unknown>;

package/dist/lib/gemini.js

@@ -13,6 +13,7 @@ const DEFAULT_MODEL = 'gemini-3-flash-preview';
 const GEMINI_MODEL_ENV_VAR = 'GEMINI_MODEL';
 const GEMINI_HARM_BLOCK_THRESHOLD_ENV_VAR = 'GEMINI_HARM_BLOCK_THRESHOLD';
 const GEMINI_INCLUDE_THOUGHTS_ENV_VAR = 'GEMINI_INCLUDE_THOUGHTS';
+const GEMINI_BATCH_MODE_ENV_VAR = 'GEMINI_BATCH_MODE';
 const GEMINI_API_KEY_ENV_VAR = 'GEMINI_API_KEY';
 const GOOGLE_API_KEY_ENV_VAR = 'GOOGLE_API_KEY';
 function getDefaultModel() {
@@ -30,14 +31,20 @@ const RETRY_DELAY_MAX_MS = 5_000;
 const RETRY_JITTER_RATIO = 0.2;
 const DEFAULT_SAFETY_THRESHOLD = HarmBlockThreshold.BLOCK_NONE;
 const DEFAULT_INCLUDE_THOUGHTS = false;
+const DEFAULT_BATCH_MODE = 'off';
 const UNKNOWN_REQUEST_CONTEXT_VALUE = 'unknown';
 const RETRYABLE_NUMERIC_CODES = new Set([429, 500, 502, 503, 504]);
 const DIGITS_ONLY_PATTERN = /^\d+$/;
 const SLEEP_UNREF_OPTIONS = { ref: false };
 const maxConcurrentCallsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS', 10);
+const maxConcurrentBatchCallsConfig = createCachedEnvInt('MAX_CONCURRENT_BATCH_CALLS', 2);
 const concurrencyWaitMsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS_WAIT_MS', 2_000);
+const batchPollIntervalMsConfig = createCachedEnvInt('GEMINI_BATCH_POLL_INTERVAL_MS', 2_000);
+const batchTimeoutMsConfig = createCachedEnvInt('GEMINI_BATCH_TIMEOUT_MS', 120_000);
 let activeCalls = 0;
+let activeBatchCalls = 0;
 const slotWaiters = [];
+const batchSlotWaiters = [];
 const RETRYABLE_TRANSIENT_CODES = new Set([
     'RESOURCE_EXHAUSTED',
     'UNAVAILABLE',
@@ -149,6 +156,25 @@ function getDefaultIncludeThoughts() {
     cachedIncludeThoughts = parseBooleanEnv(value) ?? DEFAULT_INCLUDE_THOUGHTS;
     return cachedIncludeThoughts;
 }
+function getDefaultBatchMode() {
+    const value = process.env[GEMINI_BATCH_MODE_ENV_VAR]?.trim().toLowerCase();
+    if (value === 'inline') {
+        return 'inline';
+    }
+    return DEFAULT_BATCH_MODE;
+}
+function applyResponseKeyOrdering(responseSchema, responseKeyOrdering) {
+    if (!responseKeyOrdering || responseKeyOrdering.length === 0) {
+        return responseSchema;
+    }
+    return {
+        ...responseSchema,
+        propertyOrdering: [...responseKeyOrdering],
+    };
+}
+function getPromptWithFunctionCallingContext(request) {
+    return request.prompt;
+}
 function getSafetySettings(threshold) {
     const cached = safetySettingsCache.get(threshold);
     if (cached) {
@@ -281,19 +307,21 @@ function findFirstStringCode(record, keys) {
     }
     return undefined;
 }
+const NUMERIC_ERROR_KEYS = ['status', 'statusCode', 'code'];
 function getNumericErrorCode(error) {
     const record = getNestedError(error);
     if (!record) {
         return undefined;
     }
-    return findFirstNumericCode(record, ['status', 'statusCode', 'code']);
+    return findFirstNumericCode(record, NUMERIC_ERROR_KEYS);
 }
+const TRANSIENT_ERROR_KEYS = ['code', 'status', 'statusText'];
 function getTransientErrorCode(error) {
     const record = getNestedError(error);
     if (!record) {
         return undefined;
     }
-    return findFirstStringCode(record, ['code', 'status', 'statusText']);
+    return findFirstStringCode(record, TRANSIENT_ERROR_KEYS);
 }
 function shouldRetry(error) {
     const numericCode = getNumericErrorCode(error);
@@ -322,10 +350,8 @@ function buildGenerationConfig(request, abortSignal) {
         temperature: request.temperature ?? 1.0,
         maxOutputTokens: request.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
         responseMimeType: 'application/json',
-        responseSchema: request.responseSchema,
+        responseSchema: applyResponseKeyOrdering(request.responseSchema, request.responseKeyOrdering),
         safetySettings: getSafetySettings(getSafetyThreshold()),
-        topP: 0.95,
-        topK: 40,
         abortSignal,
     };
     if (request.systemInstruction) {
@@ -366,12 +392,12 @@ async function generateContentWithTimeout(request, model, timeoutMs) {
     try {
         return await getClient().models.generateContent({
             model,
-            contents: request.prompt,
+            contents: getPromptWithFunctionCallingContext(request),
             config: buildGenerationConfig(request, signal),
         });
     }
     catch (error) {
-        if (request.signal?.aborted) {
+        if (request.signal?.aborted === true) {
             throw new Error('Gemini request was cancelled.');
         }
         if (controller.signal.aborted) {
@@ -388,6 +414,14 @@ async function executeAttempt(request, model, timeoutMs, attempt, onLog) {
     const response = await generateContentWithTimeout(request, model, timeoutMs);
     const latencyMs = Math.round(performance.now() - startedAt);
     const finishReason = response.candidates?.[0]?.finishReason;
+    let thoughts;
+    const parts = response.candidates?.[0]?.content?.parts;
+    if (Array.isArray(parts)) {
+        const thoughtParts = parts.filter((p) => p.thought === true && typeof p.text === 'string');
+        if (thoughtParts.length > 0) {
+            thoughts = thoughtParts.map((p) => p.text).join('\n\n');
+        }
+    }
     await emitGeminiLog(onLog, 'info', {
         event: 'gemini_call',
         details: {
@@ -395,6 +429,7 @@ async function executeAttempt(request, model, timeoutMs, attempt, onLog) {
             latencyMs,
             finishReason: finishReason ?? null,
             usageMetadata: response.usageMetadata ?? null,
+            ...(thoughts ? { thoughts } : {}),
         },
     });
     if (finishReason === FinishReason.MAX_TOKENS) {
@@ -429,33 +464,34 @@ async function waitBeforeRetry(attempt, error, onLog, requestSignal) {
         throw sleepError;
     }
 }
-async function throwGeminiFailure(maxRetries, lastError, onLog) {
-    const attempts = maxRetries + 1;
+async function throwGeminiFailure(attemptsMade, lastError, onLog) {
     const message = getErrorMessage(lastError);
     await emitGeminiLog(onLog, 'error', {
         event: 'gemini_failure',
         details: {
             error: message,
-            attempts,
+            attempts: attemptsMade,
         },
     });
-    throw new Error(`Gemini request failed after ${attempts} attempts: ${message}`, { cause: lastError });
+    throw new Error(`Gemini request failed after ${attemptsMade} attempts: ${message}`, { cause: lastError });
 }
 async function runWithRetries(request, model, timeoutMs, maxRetries, onLog) {
     let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    let attempt = 0;
+    for (; attempt <= maxRetries; attempt += 1) {
         try {
             return await executeAttempt(request, model, timeoutMs, attempt, onLog);
         }
         catch (error) {
             lastError = error;
             if (!canRetryAttempt(attempt, maxRetries, error)) {
+                attempt += 1; // Count this attempt before breaking
                 break;
             }
             await waitBeforeRetry(attempt, error, onLog, request.signal);
         }
     }
-    return throwGeminiFailure(maxRetries, lastError, onLog);
+    return throwGeminiFailure(attempt, lastError, onLog);
 }
 function canRetryAttempt(attempt, maxRetries, error) {
     return attempt < maxRetries && shouldRetry(error);
@@ -466,8 +502,9 @@ function tryWakeNextWaiter() {
         next();
     }
 }
-async function waitForConcurrencySlot(limit, requestSignal) {
-    if (activeCalls < limit) {
+async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestSignal) {
+    if (waiters.length === 0 && getActiveCount() < limit) {
+        acquireSlot();
         return;
     }
     if (requestSignal?.aborted) {
@@ -484,16 +521,17 @@ async function waitForConcurrencySlot(limit, requestSignal) {
             if (requestSignal) {
                 requestSignal.removeEventListener('abort', onAbort);
             }
+            acquireSlot();
             resolve();
         };
-        slotWaiters.push(waiter);
+        waiters.push(waiter);
         const deadlineTimer = setTimeout(() => {
             if (settled)
                 return;
             settled = true;
-            const idx = slotWaiters.indexOf(waiter);
+            const idx = waiters.indexOf(waiter);
             if (idx !== -1) {
-                slotWaiters.splice(idx, 1);
+                waiters.splice(idx, 1);
             }
             if (requestSignal) {
                 requestSignal.removeEventListener('abort', onAbort);
@@ -505,9 +543,9 @@ async function waitForConcurrencySlot(limit, requestSignal) {
             if (settled)
                 return;
             settled = true;
-            const idx = slotWaiters.indexOf(waiter);
+            const idx = waiters.indexOf(waiter);
             if (idx !== -1) {
-                slotWaiters.splice(idx, 1);
+                waiters.splice(idx, 1);
             }
             clearTimeout(deadlineTimer);
             reject(new Error('Gemini request was cancelled.'));
@@ -517,19 +555,254 @@ async function waitForConcurrencySlot(limit, requestSignal) {
         }
     });
 }
+async function waitForConcurrencySlot(limit, requestSignal) {
+    return waitForSlot(limit, () => activeCalls, () => {
+        activeCalls += 1;
+    }, slotWaiters, requestSignal);
+}
+function tryWakeNextBatchWaiter() {
+    const next = batchSlotWaiters.shift();
+    if (next !== undefined) {
+        next();
+    }
+}
+async function waitForBatchConcurrencySlot(limit, requestSignal) {
+    return waitForSlot(limit, () => activeBatchCalls, () => {
+        activeBatchCalls += 1;
+    }, batchSlotWaiters, requestSignal);
+}
+function getBatchState(payload) {
+    const record = asRecord(payload);
+    if (!record) {
+        return undefined;
+    }
+    const directState = toUpperStringCode(record.state);
+    if (directState) {
+        return directState;
+    }
+    const metadata = asRecord(record.metadata);
+    if (!metadata) {
+        return undefined;
+    }
+    return toUpperStringCode(metadata.state);
+}
+function extractBatchResponseText(payload) {
+    const record = asRecord(payload);
+    if (!record) {
+        return undefined;
+    }
+    const inlineResponse = asRecord(record.inlineResponse);
+    const inlineText = typeof inlineResponse?.text === 'string' ? inlineResponse.text : undefined;
+    if (inlineText) {
+        return inlineText;
+    }
+    const response = asRecord(record.response);
+    if (!response) {
+        return undefined;
+    }
+    const responseText = typeof response.text === 'string' ? response.text : undefined;
+    if (responseText) {
+        return responseText;
+    }
+    const { inlineResponses } = response;
+    if (!Array.isArray(inlineResponses) || inlineResponses.length === 0) {
+        return undefined;
+    }
+    const firstInline = asRecord(inlineResponses[0]);
+    return typeof firstInline?.text === 'string' ? firstInline.text : undefined;
+}
+function extractBatchErrorDetail(payload) {
+    const record = asRecord(payload);
+    if (!record) {
+        return undefined;
+    }
+    const directError = asRecord(record.error);
+    const directMessage = typeof directError?.message === 'string' ? directError.message : undefined;
+    if (directMessage) {
+        return directMessage;
+    }
+    const metadata = asRecord(record.metadata);
+    const metadataError = asRecord(metadata?.error);
+    const metadataMessage = typeof metadataError?.message === 'string'
+        ? metadataError.message
+        : undefined;
+    if (metadataMessage) {
+        return metadataMessage;
+    }
+    const response = asRecord(record.response);
+    const responseError = asRecord(response?.error);
+    return typeof responseError?.message === 'string'
+        ? responseError.message
+        : undefined;
+}
+function getBatchSuccessResponseText(polled) {
+    const responseText = extractBatchResponseText(polled);
+    if (!responseText) {
+        const errorDetail = extractBatchErrorDetail(polled);
+        throw new Error(errorDetail
+            ? `Gemini batch request succeeded but returned no response text: ${errorDetail}`
+            : 'Gemini batch request succeeded but returned no response text.');
+    }
+    return responseText;
+}
+function handleBatchTerminalState(state, payload) {
+    if (state === 'JOB_STATE_FAILED' || state === 'JOB_STATE_CANCELLED') {
+        const errorDetail = extractBatchErrorDetail(payload);
+        throw new Error(errorDetail
+            ? `Gemini batch request ended with state ${state}: ${errorDetail}`
+            : `Gemini batch request ended with state ${state}.`);
+    }
+}
+async function pollBatchStatusWithRetries(batches, batchName, onLog, requestSignal) {
+    const maxPollRetries = 2;
+    for (let attempt = 0; attempt <= maxPollRetries; attempt += 1) {
+        try {
+            return await batches.get({ name: batchName });
+        }
+        catch (error) {
+            if (!canRetryAttempt(attempt, maxPollRetries, error)) {
+                throw error;
+            }
+            await waitBeforeRetry(attempt, error, onLog, requestSignal);
+        }
+    }
+    throw new Error('Batch polling retries exhausted unexpectedly.');
+}
+async function cancelBatchIfNeeded(request, batches, batchName, onLog, completed, timedOut) {
+    const aborted = request.signal?.aborted === true;
+    if (completed || (!aborted && !timedOut) || !batchName) {
+        return;
+    }
+    if (batches.cancel === undefined) {
+        return;
+    }
+    try {
+        await batches.cancel({ name: batchName });
+        await emitGeminiLog(onLog, 'info', {
+            event: 'gemini_batch_cancelled',
+            details: {
+                batchName,
+                reason: timedOut ? 'timeout' : 'aborted',
+            },
+        });
+    }
+    catch (error) {
+        await emitGeminiLog(onLog, 'warning', {
+            event: 'gemini_batch_cancel_failed',
+            details: {
+                batchName,
+                reason: timedOut ? 'timeout' : 'aborted',
+                error: getErrorMessage(error),
+            },
+        });
+    }
+}
+async function runInlineBatchWithPolling(request, model, onLog) {
+    const client = getClient();
+    const { batches } = client;
+    if (batches === undefined) {
+        throw new Error('Batch mode requires SDK batch support, but batches API is unavailable.');
+    }
+    let batchName;
+    let completed = false;
+    let timedOut = false;
+    try {
+        const createPayload = {
+            model,
+            src: [
+                {
+                    contents: [{ role: 'user', parts: [{ text: request.prompt }] }],
+                    config: buildGenerationConfig(request, new AbortController().signal),
+                },
+            ],
+        };
+        const createdJob = await batches.create(createPayload);
+        const createdRecord = asRecord(createdJob);
+        batchName =
+            typeof createdRecord?.name === 'string' ? createdRecord.name : undefined;
+        if (!batchName) {
+            throw new Error('Batch mode failed to return a job name.');
+        }
+        const pollStart = performance.now();
+        const timeoutMs = batchTimeoutMsConfig.get();
+        const pollIntervalMs = batchPollIntervalMsConfig.get();
+        await emitGeminiLog(onLog, 'info', {
+            event: 'gemini_batch_created',
+            details: { batchName },
+        });
+        for (;;) {
+            if (request.signal?.aborted === true) {
+                throw new Error('Gemini request was cancelled.');
+            }
+            const elapsedMs = Math.round(performance.now() - pollStart);
+            if (elapsedMs > timeoutMs) {
+                timedOut = true;
+                throw new Error(`Gemini batch request timed out after ${formatNumber(timeoutMs)}ms.`);
+            }
+            const polled = await pollBatchStatusWithRetries(batches, batchName, onLog, request.signal);
+            const state = getBatchState(polled);
+            if (state === 'JOB_STATE_SUCCEEDED') {
+                const responseText = getBatchSuccessResponseText(polled);
+                completed = true;
+                return parseStructuredResponse(responseText);
+            }
+            handleBatchTerminalState(state, polled);
+            await sleep(pollIntervalMs, undefined, request.signal
+                ? { ...SLEEP_UNREF_OPTIONS, signal: request.signal }
+                : SLEEP_UNREF_OPTIONS);
+        }
+    }
+    finally {
+        await cancelBatchIfNeeded(request, batches, batchName, onLog, completed, timedOut);
+    }
+}
+export function getGeminiQueueSnapshot() {
+    return {
+        activeCalls,
+        waitingCalls: slotWaiters.length,
+    };
+}
 export async function generateStructuredJson(request) {
     const model = request.model ?? getDefaultModel();
     const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const maxRetries = request.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const batchMode = request.batchMode ?? getDefaultBatchMode();
     const { onLog } = request;
-    const limit = maxConcurrentCallsConfig.get();
-    await waitForConcurrencySlot(limit, request.signal);
-    activeCalls += 1;
+    const limit = batchMode === 'inline'
+        ? maxConcurrentBatchCallsConfig.get()
+        : maxConcurrentCallsConfig.get();
+    const queueWaitStartedAt = performance.now();
+    if (batchMode === 'inline') {
+        await waitForBatchConcurrencySlot(limit, request.signal);
+    }
+    else {
+        await waitForConcurrencySlot(limit, request.signal);
+    }
+    const queueWaitMs = Math.round(performance.now() - queueWaitStartedAt);
+    await safeCallOnLog(onLog, 'info', {
+        event: 'gemini_queue_acquired',
+        queueWaitMs,
+        waitingCalls: batchMode === 'inline' ? batchSlotWaiters.length : slotWaiters.length,
+        activeCalls,
+        activeBatchCalls,
+        mode: batchMode,
+    });
     try {
-        return await geminiContext.run({ requestId: nextRequestId(), model }, () => runWithRetries(request, model, timeoutMs, maxRetries, onLog));
+        return await geminiContext.run({ requestId: nextRequestId(), model }, () => {
+            if (batchMode === 'inline') {
+                return runInlineBatchWithPolling(request, model, onLog);
+            }
+            return runWithRetries(request, model, timeoutMs, maxRetries, onLog);
+        });
     }
     finally {
-        activeCalls -= 1;
-        tryWakeNextWaiter();
+        if (batchMode === 'inline') {
+            activeBatchCalls -= 1;
+            tryWakeNextBatchWaiter();
+        }
+        else {
+            activeCalls -= 1;
+            tryWakeNextWaiter();
+        }
     }
 }