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

package/dist/lib/model-config.d.ts

@@ -20,7 +20,7 @@ export declare const PRO_THINKING_LEVEL: "high";
 /** Output cap for Flash API breaking-change detection. */
 export declare const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS: 4096;
 /** Output cap for Flash complexity analysis. */
-export declare const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS: 2048;
+export declare const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS: 4096;
 /** Output cap for Flash test-plan generation. */
 export declare const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS: 8192;
 /** Output cap for Flash triage tools. */

package/dist/lib/model-config.js

@@ -28,7 +28,7 @@ const THINKING_LEVELS = {
 // Thinking budget in tokens for Flash and Pro tools. Note that these are not hard limits, but rather guidelines to encourage concise responses and manage latency/cost.
 const OUTPUT_TOKEN_BUDGET = {
     flashApiBreaking: 4_096,
-    flashComplexity: 2_048,
+    flashComplexity: 4_096,
     flashTestPlan: 8_192,
     flashTriage: 4_096,
     proPatch: 8_192,

package/dist/lib/tool-contracts.d.ts

@@ -18,11 +18,11 @@ export interface ToolContract {
     maxOutputTokens: number;
     /**
      * Sampling temperature for the Gemini call.
-     * Lower values (0.0–0.1) favour deterministic structured output;
-     * higher values (0.2) add diversity for creative synthesis tasks.
-     * Omit to use the global default (0.2).
+     * Gemini 3 recommends 1.0 for all tasks.
      */
     temperature?: number;
+    /** Enables deterministic JSON guidance and schema key ordering. */
+    deterministicJson?: boolean;
     params: readonly ToolParameterContract[];
     outputShape: string;
     gotchas: readonly string[];
@@ -53,6 +53,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly thinkingLevel: "minimal";
     readonly maxOutputTokens: 4096;
     readonly temperature: 1;
+    readonly deterministicJson: true;
     readonly params: readonly [{
         readonly name: "repository";
         readonly type: "string";
@@ -77,6 +78,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly thinkingLevel: "minimal";
     readonly maxOutputTokens: 4096;
     readonly temperature: 1;
+    readonly deterministicJson: true;
     readonly params: readonly [{
         readonly name: "repository";
         readonly type: "string";
@@ -101,6 +103,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly thinkingLevel: "high";
     readonly maxOutputTokens: 12288;
     readonly temperature: 1;
+    readonly deterministicJson: true;
     readonly params: readonly [{
         readonly name: "repository";
         readonly type: "string";
@@ -144,6 +147,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly thinkingLevel: "high";
     readonly maxOutputTokens: 8192;
     readonly temperature: 1;
+    readonly deterministicJson: true;
     readonly params: readonly [{
         readonly name: "findingTitle";
         readonly type: "string";
@@ -169,6 +173,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly thinkingLevel: "medium";
     readonly maxOutputTokens: 8192;
     readonly temperature: 1;
+    readonly deterministicJson: true;
     readonly params: readonly [{
         readonly name: "repository";
         readonly type: "string";
@@ -203,8 +208,9 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "medium";
-    readonly maxOutputTokens: 2048;
+    readonly maxOutputTokens: 4096;
     readonly temperature: 1;
+    readonly deterministicJson: true;
     readonly params: readonly [{
         readonly name: "language";
         readonly type: "string";
@@ -223,6 +229,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly thinkingLevel: "minimal";
     readonly maxOutputTokens: 4096;
     readonly temperature: 1;
+    readonly deterministicJson: true;
     readonly params: readonly [{
         readonly name: "language";
         readonly type: "string";

package/dist/lib/tool-contracts.js

@@ -43,6 +43,7 @@ export const TOOL_CONTRACTS = [
         thinkingLevel: FLASH_TRIAGE_THINKING_LEVEL,
         maxOutputTokens: FLASH_TRIAGE_MAX_OUTPUT_TOKENS,
         temperature: TRIAGE_TEMPERATURE,
+        deterministicJson: true,
         params: [
             {
                 name: 'repository',
@@ -76,6 +77,7 @@ export const TOOL_CONTRACTS = [
         thinkingLevel: FLASH_TRIAGE_THINKING_LEVEL,
         maxOutputTokens: FLASH_TRIAGE_MAX_OUTPUT_TOKENS,
         temperature: TRIAGE_TEMPERATURE,
+        deterministicJson: true,
         params: [
             {
                 name: 'repository',
@@ -109,6 +111,7 @@ export const TOOL_CONTRACTS = [
         thinkingLevel: PRO_THINKING_LEVEL,
         maxOutputTokens: PRO_REVIEW_MAX_OUTPUT_TOKENS,
         temperature: ANALYSIS_TEMPERATURE,
+        deterministicJson: true,
         params: [
             {
                 name: 'repository',
@@ -166,6 +169,7 @@ export const TOOL_CONTRACTS = [
         thinkingLevel: PRO_THINKING_LEVEL,
         maxOutputTokens: PRO_PATCH_MAX_OUTPUT_TOKENS,
         temperature: PATCH_TEMPERATURE,
+        deterministicJson: true,
         params: [
             {
                 name: 'findingTitle',
@@ -201,6 +205,7 @@ export const TOOL_CONTRACTS = [
         thinkingLevel: FLASH_THINKING_LEVEL,
         maxOutputTokens: FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS,
         temperature: CREATIVE_TEMPERATURE,
+        deterministicJson: true,
         params: [
             {
                 name: 'repository',
@@ -248,6 +253,7 @@ export const TOOL_CONTRACTS = [
         thinkingLevel: FLASH_THINKING_LEVEL,
         maxOutputTokens: FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS,
         temperature: ANALYSIS_TEMPERATURE,
+        deterministicJson: true,
         params: [
             {
                 name: 'language',
@@ -272,6 +278,7 @@ export const TOOL_CONTRACTS = [
         thinkingLevel: FLASH_TRIAGE_THINKING_LEVEL,
         maxOutputTokens: FLASH_API_BREAKING_MAX_OUTPUT_TOKENS,
         temperature: TRIAGE_TEMPERATURE,
+        deterministicJson: true,
         params: [
             {
                 name: 'language',

package/dist/lib/tool-factory.d.ts

@@ -55,6 +55,10 @@ export interface StructuredToolTaskConfig<TInput extends object = Record<string,
     transformResult?: (input: TInput, result: TResult, ctx: ToolExecutionContext) => TFinal;
     /** Optional validation hook for input parameters. */
     validateInput?: (input: TInput, ctx: ToolExecutionContext) => Promise<ReturnType<typeof createErrorToolResponse> | undefined> | ReturnType<typeof createErrorToolResponse> | undefined;
+    /** Optional flag to enforce diff presence and budget check before tool execution. */
+    requiresDiff?: boolean;
+    /** Optional override for schema validation retries. Defaults to GEMINI_SCHEMA_RETRIES env var. */
+    schemaRetries?: number;
     /** Optional Gemini model to use (e.g. 'gemini-3-pro-preview'). */
     model?: string;
     /** Optional thinking level. */
@@ -65,13 +69,15 @@ export interface StructuredToolTaskConfig<TInput extends object = Record<string,
     maxOutputTokens?: number;
     /**
      * Optional sampling temperature for this tool's Gemini call.
-     * Lower values (0.0–0.1) favour determinism for structured extraction;
-     * higher values (0.2) add useful diversity for creative synthesis tasks.
-     * Falls back to the global default (0.2) when omitted.
+     * Gemini 3 recommends 1.0 for all tasks.
      */
     temperature?: number;
     /** Optional opt-in to Gemini thought output. Defaults to false. */
     includeThoughts?: boolean;
+    /** Optional deterministic JSON mode for stricter key ordering and repair prompting. */
+    deterministicJson?: boolean;
+    /** Optional batch execution mode. Defaults to runtime setting. */
+    batchMode?: 'off' | 'inline';
     /** Optional formatter for human-readable text output. */
     formatOutput?: (result: TFinal) => string;
     /** Optional context text used in progress messages. */
@@ -81,6 +87,7 @@ export interface StructuredToolTaskConfig<TInput extends object = Record<string,
     /** Builds the system instruction and user prompt from parsed tool input. */
     buildPrompt: (input: TInput, ctx: ToolExecutionContext) => PromptParts;
 }
+export declare function summarizeSchemaValidationErrorForRetry(errorMessage: string): string;
 export declare function wrapToolHandler<TInput, TResult extends CallToolResult>(options: {
     toolName: string;
     progressContext?: (input: TInput) => string;

package/dist/lib/tool-factory.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { DefaultOutputSchema } from '../schemas/outputs.js';
-import { getDiff } from './diff-store.js';
+import { validateDiffBudget } from './diff-budget.js';
+import { createNoDiffError, getDiff } from './diff-store.js';
+import { createCachedEnvInt } from './env-config.js';
 import { getErrorMessage, RETRYABLE_UPSTREAM_ERROR_PATTERN } from './errors.js';
 import { stripJsonSchemaConstraints } from './gemini-schema.js';
 import { generateStructuredJson, getCurrentRequestId } from './gemini.js';
@@ -13,7 +15,11 @@ const CANCELLED_ERROR_PATTERN = /cancelled|canceled/i;
 const TIMEOUT_ERROR_PATTERN = /timed out|timeout/i;
 const BUDGET_ERROR_PATTERN = /exceeds limit|max allowed size|input too large/i;
 const BUSY_ERROR_PATTERN = /too many concurrent/i;
-const MAX_SCHEMA_RETRIES = 1;
+const DEFAULT_SCHEMA_RETRIES = 1;
+const geminiSchemaRetriesConfig = createCachedEnvInt('GEMINI_SCHEMA_RETRIES', DEFAULT_SCHEMA_RETRIES);
+const DEFAULT_SCHEMA_RETRY_ERROR_CHARS = 1_500;
+const schemaRetryErrorCharsConfig = createCachedEnvInt('MAX_SCHEMA_RETRY_ERROR_CHARS', DEFAULT_SCHEMA_RETRY_ERROR_CHARS);
+const DETERMINISTIC_JSON_RETRY_NOTE = 'Deterministic JSON mode: keep key names exactly as schema-defined and preserve stable field ordering.';
 function createGeminiResponseSchema(config) {
     const sourceSchema = config.geminiSchema ?? config.resultSchema;
     return stripJsonSchemaConstraints(z.toJSONSchema(sourceSchema));
@@ -21,6 +27,35 @@ function createGeminiResponseSchema(config) {
 function parseToolInput(input, fullInputSchema) {
     return fullInputSchema.parse(input);
 }
+function extractResponseKeyOrdering(responseSchema) {
+    const schemaType = responseSchema.type;
+    if (schemaType !== 'object') {
+        return undefined;
+    }
+    const { properties } = responseSchema;
+    if (typeof properties !== 'object' || properties === null) {
+        return undefined;
+    }
+    return Object.keys(properties);
+}
+export function summarizeSchemaValidationErrorForRetry(errorMessage) {
+    const maxChars = Math.max(200, schemaRetryErrorCharsConfig.get());
+    const compact = errorMessage.replace(/\s+/g, ' ').trim();
+    if (compact.length <= maxChars) {
+        return compact;
+    }
+    return `${compact.slice(0, maxChars - 3)}...`;
+}
+function createSchemaRetryPrompt(prompt, errorMessage, deterministicJson) {
+    const summarizedError = summarizeSchemaValidationErrorForRetry(errorMessage);
+    const deterministicNote = deterministicJson
+        ? `\n${DETERMINISTIC_JSON_RETRY_NOTE}`
+        : '';
+    return {
+        summarizedError,
+        prompt: `${prompt}\n\nCRITICAL: The previous response failed schema validation. Error: ${summarizedError}${deterministicNote}`,
+    };
+}
 function createGenerationRequest(config, promptParts, responseSchema, onLog, signal) {
     const request = {
         systemInstruction: promptParts.systemInstruction,
@@ -46,13 +81,23 @@ function createGenerationRequest(config, promptParts, responseSchema, onLog, sig
     if (config.includeThoughts !== undefined) {
         request.includeThoughts = config.includeThoughts;
     }
+    if (config.deterministicJson) {
+        const responseKeyOrdering = extractResponseKeyOrdering(responseSchema);
+        if (responseKeyOrdering !== undefined) {
+            request.responseKeyOrdering = responseKeyOrdering;
+        }
+    }
+    if (config.batchMode !== undefined) {
+        request.batchMode = config.batchMode;
+    }
     if (signal !== undefined) {
         request.signal = signal;
     }
     return request;
 }
+const VALIDATION_ERROR_PATTERN = /validation/i;
 function classifyErrorMeta(error, message) {
-    if (error instanceof z.ZodError || /validation/i.test(message)) {
+    if (error instanceof z.ZodError || VALIDATION_ERROR_PATTERN.test(message)) {
         return {
             kind: 'validation',
             retryable: false,
@@ -91,30 +136,15 @@ function isRetryableUpstreamMessage(message) {
     return (RETRYABLE_UPSTREAM_ERROR_PATTERN.test(message) ||
         BUSY_ERROR_PATTERN.test(message));
 }
-async function sendTaskProgress(extra, payload) {
-    const progressToken = extra._meta?.progressToken;
-    if (typeof progressToken !== 'string' && typeof progressToken !== 'number') {
+function ignoreProgressInput(value) {
+    if (value === null) {
         return;
     }
-    try {
-        const params = {
-            progressToken,
-            progress: payload.current,
-        };
-        if (payload.total !== undefined) {
-            params.total = payload.total;
-        }
-        if (payload.message !== undefined) {
-            params.message = payload.message;
-        }
-        await extra.sendNotification({
-            method: 'notifications/progress',
-            params,
-        });
-    }
-    catch {
-        // Progress is best-effort; never fail the tool call.
-    }
+}
+function sendTaskProgress(extra, payload) {
+    ignoreProgressInput(extra);
+    ignoreProgressInput(payload);
+    return Promise.resolve();
 }
 function createProgressReporter(extra) {
     let lastCurrent = 0;
@@ -152,21 +182,26 @@ function normalizeProgressContext(context) {
     return `${compact.slice(0, 77)}...`;
 }
 function formatProgressStep(toolName, context, metadata) {
-    const prefix = metadata === 'starting' ? '▸' : '◦';
-    return `${prefix} ${toolName}: ${context} [${metadata}]`;
+    return `${toolName}: ${context} [${metadata}]`;
 }
 function friendlyModelName(model) {
     if (!model)
-        return 'model';
-    if (model.includes('pro'))
-        return 'Pro';
-    if (model.includes('flash'))
-        return 'Flash';
-    return 'model';
+        return 'calling model';
+    const normalized = model.toLowerCase();
+    if (normalized.includes('pro'))
+        return 'calling Pro';
+    if (normalized.includes('flash'))
+        return 'calling Flash';
+    return 'calling model';
 }
-function formatProgressCompletion(toolName, context, outcome, success = true) {
-    const prefix = success ? '◆' : '◇';
-    return `${prefix} ${toolName}: ${context} • ${outcome}`;
+function formatProgressCompletion(toolName, context, outcome) {
+    return `🗒 ${toolName}: ${context} • ${outcome}`;
+}
+function createFailureStatusMessage(outcome, errorMessage) {
+    if (outcome === 'cancelled') {
+        return `cancelled: ${errorMessage}`;
+    }
+    return errorMessage;
 }
 async function reportProgressStepUpdate(reportProgress, toolName, context, current, metadata) {
     await reportProgress({
@@ -175,13 +210,21 @@ async function reportProgressStepUpdate(reportProgress, toolName, context, curre
         message: formatProgressStep(toolName, context, metadata),
     });
 }
-async function reportProgressCompletionUpdate(reportProgress, toolName, context, outcome, success = true) {
+async function reportProgressCompletionUpdate(reportProgress, toolName, context, outcome) {
     await reportProgress({
         current: TASK_PROGRESS_TOTAL,
         total: TASK_PROGRESS_TOTAL,
-        message: formatProgressCompletion(toolName, context, outcome, success),
+        message: formatProgressCompletion(toolName, context, outcome),
     });
 }
+async function reportSchemaRetryProgressBestEffort(reportProgress, toolName, context, retryCount, maxRetries) {
+    try {
+        await reportProgressStepUpdate(reportProgress, toolName, context, 3, `repairing schema retry ${retryCount}/${maxRetries}`);
+    }
+    catch {
+        // Progress updates are best-effort and must not interrupt retries.
+    }
+}
 function toLoggingLevel(level) {
     switch (level) {
         case 'debug':
@@ -234,21 +277,23 @@ export function wrapToolHandler(options, handler) {
             const result = await handler(input, extra);
             // End progress (1/1)
             const outcome = result.isError ? 'failed' : 'completed';
-            const success = !result.isError;
             await sendTaskProgress(extra, {
                 current: 1,
                 total: 1,
-                message: formatProgressCompletion(options.toolName, context, outcome, success),
+                message: formatProgressCompletion(options.toolName, context, outcome),
             });
             return result;
         }
         catch (error) {
+            const errorMessage = getErrorMessage(error);
+            const failureMeta = classifyErrorMeta(error, errorMessage);
+            const outcome = failureMeta.kind === 'cancelled' ? 'cancelled' : 'failed';
             // Progress is best-effort; must never mask the original error.
             try {
                 await sendTaskProgress(extra, {
                     current: 1,
                     total: 1,
-                    message: formatProgressCompletion(options.toolName, context, 'failed', false),
+                    message: formatProgressCompletion(options.toolName, context, outcome),
                 });
             }
             catch {
@@ -258,6 +303,21 @@ export function wrapToolHandler(options, handler) {
         }
     };
 }
+async function validateRequest(config, inputRecord, ctx) {
+    if (config.requiresDiff) {
+        if (!ctx.diffSlot) {
+            return createNoDiffError();
+        }
+        const budgetError = validateDiffBudget(ctx.diffSlot.diff);
+        if (budgetError) {
+            return budgetError;
+        }
+    }
+    if (config.validateInput) {
+        return await config.validateInput(inputRecord, ctx);
+    }
+    return undefined;
+}
 export function registerStructuredToolTask(server, config) {
     const responseSchema = createGeminiResponseSchema({
         geminiSchema: config.geminiSchema,
@@ -307,18 +367,16 @@ export function registerStructuredToolTask(server, config) {
                     // could replace the slot and silently bypass the budget check.
                     const ctx = { diffSlot: getDiff() };
                     await reportProgressStepUpdate(reportProgress, config.name, progressContext, 0, 'starting');
-                    if (config.validateInput) {
-                        const validationError = await config.validateInput(inputRecord, ctx);
-                        if (validationError) {
-                            const validationMessage = validationError.structuredContent.error?.message ??
-                                INPUT_VALIDATION_FAILED;
-                            await updateStatusMessage(validationMessage);
-                            await reportProgressCompletionUpdate(reportProgress, config.name, progressContext, 'rejected', false);
-                            await storeResultSafely('completed', validationError);
-                            return;
-                        }
+                    const validationError = await validateRequest(config, inputRecord, ctx);
+                    if (validationError) {
+                        const validationMessage = validationError.structuredContent.error?.message ??
+                            INPUT_VALIDATION_FAILED;
+                        await updateStatusMessage(validationMessage);
+                        await reportProgressCompletionUpdate(reportProgress, config.name, progressContext, 'rejected');
+                        await storeResultSafely('completed', validationError);
+                        return;
                     }
-                    await reportProgressStepUpdate(reportProgress, config.name, progressContext, 1, 'preparing');
+                    await reportProgressStepUpdate(reportProgress, config.name, progressContext, 1, 'building prompt');
                     const promptParts = config.buildPrompt(inputRecord, ctx);
                     const { prompt } = promptParts;
                     const { systemInstruction } = promptParts;
@@ -326,26 +384,33 @@ export function registerStructuredToolTask(server, config) {
                     await reportProgressStepUpdate(reportProgress, config.name, progressContext, 2, modelLabel);
                     let parsed;
                     let retryPrompt = prompt;
-                    for (let attempt = 0; attempt <= MAX_SCHEMA_RETRIES; attempt += 1) {
+                    const maxRetries = config.schemaRetries ?? geminiSchemaRetriesConfig.get();
+                    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
                         try {
                             const raw = await generateStructuredJson(createGenerationRequest(config, { systemInstruction, prompt: retryPrompt }, responseSchema, onLog, extra.signal));
                             if (attempt === 0) {
-                                await reportProgressStepUpdate(reportProgress, config.name, progressContext, 3, 'processing response');
+                                await reportProgressStepUpdate(reportProgress, config.name, progressContext, 3, 'validating response');
                             }
                             parsed = config.resultSchema.parse(raw);
                             break;
                         }
                         catch (error) {
-                            if (attempt >= MAX_SCHEMA_RETRIES ||
-                                !(error instanceof z.ZodError)) {
+                            if (attempt >= maxRetries || !(error instanceof z.ZodError)) {
                                 throw error;
                             }
                             const errorMessage = getErrorMessage(error);
+                            const schemaRetryPrompt = createSchemaRetryPrompt(prompt, errorMessage, config.deterministicJson === true);
                             await onLog('warning', {
                                 event: 'schema_validation_failed',
-                                details: { attempt, error: errorMessage },
+                                details: {
+                                    attempt,
+                                    error: schemaRetryPrompt.summarizedError,
+                                    originalChars: errorMessage.length,
+                                },
                             });
-                            retryPrompt = `${prompt}\n\nCRITICAL: The previous response failed schema validation. Error: ${errorMessage}`;
+                            const retryCount = attempt + 1;
+                            await reportSchemaRetryProgressBestEffort(reportProgress, config.name, progressContext, retryCount, maxRetries);
+                            retryPrompt = schemaRetryPrompt.prompt;
                         }
                     }
                     if (!parsed) {
@@ -367,9 +432,10 @@ export function registerStructuredToolTask(server, config) {
                 catch (error) {
                     const errorMessage = getErrorMessage(error);
                     const errorMeta = classifyErrorMeta(error, errorMessage);
-                    await reportProgressCompletionUpdate(reportProgress, config.name, progressContext, 'failed', false);
-                    await updateStatusMessage(errorMessage);
+                    const outcome = errorMeta.kind === 'cancelled' ? 'cancelled' : 'failed';
+                    await updateStatusMessage(createFailureStatusMessage(outcome, errorMessage));
                     await storeResultSafely('failed', createErrorToolResponse(config.errorCode, errorMessage, undefined, errorMeta));
+                    await reportProgressCompletionUpdate(reportProgress, config.name, progressContext, outcome);
                 }
             };
             queueMicrotask(() => {

package/dist/lib/types.d.ts

@@ -1,5 +1,8 @@
 export type JsonObject = Record<string, unknown>;
 export type GeminiLogHandler = (level: string, data: unknown) => Promise<void>;
+export interface GeminiFunctionCallingContext {
+    readonly modelParts: readonly unknown[];
+}
 export interface GeminiRequestExecutionOptions {
     maxRetries?: number;
     timeoutMs?: number;
@@ -9,6 +12,9 @@ export interface GeminiRequestExecutionOptions {
     includeThoughts?: boolean;
     signal?: AbortSignal;
     onLog?: GeminiLogHandler;
+    responseKeyOrdering?: readonly string[];
+    functionCallingContext?: GeminiFunctionCallingContext;
+    batchMode?: 'off' | 'inline';
 }
 export interface GeminiStructuredRequestOptions extends GeminiRequestExecutionOptions {
     model?: string;

package/dist/resources/server-config.js

@@ -8,13 +8,18 @@ const DEFAULT_CONCURRENT_WAIT_MS = 2_000;
 const DEFAULT_SAFETY_THRESHOLD = 'BLOCK_NONE';
 const GEMINI_HARM_BLOCK_THRESHOLD_ENV_VAR = 'GEMINI_HARM_BLOCK_THRESHOLD';
 const GEMINI_MODEL_ENV_VAR = 'GEMINI_MODEL';
+const GEMINI_BATCH_MODE_ENV_VAR = 'GEMINI_BATCH_MODE';
 const diffCharsConfig = createCachedEnvInt('MAX_DIFF_CHARS', DEFAULT_MAX_DIFF_CHARS);
 const contextCharsConfig = createCachedEnvInt('MAX_CONTEXT_CHARS', DEFAULT_MAX_CONTEXT_CHARS);
 const concurrentCallsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS', DEFAULT_MAX_CONCURRENT_CALLS);
+const concurrentBatchCallsConfig = createCachedEnvInt('MAX_CONCURRENT_BATCH_CALLS', 2);
 const concurrentWaitConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS_WAIT_MS', DEFAULT_CONCURRENT_WAIT_MS);
 function getModelOverride() {
     return process.env[GEMINI_MODEL_ENV_VAR] ?? FLASH_MODEL;
 }
+function getBatchMode() {
+    return process.env[GEMINI_BATCH_MODE_ENV_VAR] ?? 'off';
+}
 function getSafetyThreshold() {
     return (process.env[GEMINI_HARM_BLOCK_THRESHOLD_ENV_VAR] ?? DEFAULT_SAFETY_THRESHOLD);
 }
@@ -31,8 +36,10 @@ export function buildServerConfig() {
     const maxDiffChars = diffCharsConfig.get();
     const maxContextChars = contextCharsConfig.get();
     const maxConcurrent = concurrentCallsConfig.get();
+    const maxConcurrentBatch = concurrentBatchCallsConfig.get();
     const concurrentWaitMs = concurrentWaitConfig.get();
     const defaultModel = getModelOverride();
+    const batchMode = getBatchMode();
     const safetyThreshold = getSafetyThreshold();
     const toolRows = getToolContracts()
         .filter((contract) => contract.model !== 'none')
@@ -49,7 +56,9 @@ export function buildServerConfig() {
 | Diff limit | ${formatNumber(maxDiffChars)} chars | \`MAX_DIFF_CHARS\` |
 | Context limit (inspect) | ${formatNumber(maxContextChars)} chars | \`MAX_CONTEXT_CHARS\` |
 | Concurrency limit | ${maxConcurrent} | \`MAX_CONCURRENT_CALLS\` |
+| Batch concurrency limit | ${maxConcurrentBatch} | \`MAX_CONCURRENT_BATCH_CALLS\` |
 | Wait timeout | ${formatNumber(concurrentWaitMs)}ms | \`MAX_CONCURRENT_CALLS_WAIT_MS\` |
+| Batch mode | ${batchMode} | \`GEMINI_BATCH_MODE\` |
 
 ## Model Assignments
 
@@ -67,5 +76,11 @@ ${toolRows}
 ## API Keys
 
 - Set \`GEMINI_API_KEY\` or \`GOOGLE_API_KEY\` environment variable (required)
+
+## Batch Mode
+
+- \`GEMINI_BATCH_MODE\`: \`off\` (default) or \`inline\`
+- \`GEMINI_BATCH_POLL_INTERVAL_MS\`: poll cadence for batch status checks
+- \`GEMINI_BATCH_TIMEOUT_MS\`: max wait for batch completion
 `;
 }

package/dist/tools/analyze-complexity.js

@@ -1,5 +1,3 @@
-import { validateDiffBudget } from '../lib/diff-budget.js';
-import { createNoDiffError } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { AnalyzeComplexityInputSchema } from '../schemas/inputs.js';
@@ -29,12 +27,10 @@ export function registerAnalyzeComplexityTool(server) {
         ...(TOOL_CONTRACT.temperature !== undefined
             ? { temperature: TOOL_CONTRACT.temperature }
             : undefined),
-        validateInput: (_input, ctx) => {
-            const slot = ctx.diffSlot;
-            if (!slot)
-                return createNoDiffError();
-            return validateDiffBudget(slot.diff);
-        },
+        ...(TOOL_CONTRACT.deterministicJson !== undefined
+            ? { deterministicJson: TOOL_CONTRACT.deterministicJson }
+            : undefined),
+        requiresDiff: true,
         formatOutcome: (result) => result.isDegradation
             ? 'Performance degradation detected'
             : 'No degradation',

package/dist/tools/analyze-pr-impact.js

@@ -1,6 +1,4 @@
-import { validateDiffBudget } from '../lib/diff-budget.js';
-import { computeDiffStatsAndSummaryFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
-import { createNoDiffError } from '../lib/diff-store.js';
+import { computeDiffStatsAndSummaryFromFiles } from '../lib/diff-parser.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { AnalyzePrImpactInputSchema } from '../schemas/inputs.js';
@@ -33,17 +31,15 @@ export function registerAnalyzePrImpactTool(server) {
         ...(TOOL_CONTRACT.temperature !== undefined
             ? { temperature: TOOL_CONTRACT.temperature }
             : undefined),
-        validateInput: (_input, ctx) => {
-            const slot = ctx.diffSlot;
-            if (!slot)
-                return createNoDiffError();
-            return validateDiffBudget(slot.diff);
-        },
+        ...(TOOL_CONTRACT.deterministicJson !== undefined
+            ? { deterministicJson: TOOL_CONTRACT.deterministicJson }
+            : undefined),
+        requiresDiff: true,
         formatOutcome: (result) => `severity: ${result.severity}`,
         formatOutput: (result) => `Impact Analysis (${result.severity}): ${result.summary}`,
         buildPrompt: (input, ctx) => {
             const diff = ctx.diffSlot?.diff ?? '';
-            const files = parseDiffFiles(diff);
+            const files = ctx.diffSlot?.parsedFiles ?? [];
             const { stats, summary: fileSummary } = computeDiffStatsAndSummaryFromFiles(files);
             const languageSegment = formatLanguageSegment(input.language);
             return {

package/dist/tools/detect-api-breaking.js

@@ -1,5 +1,3 @@
-import { validateDiffBudget } from '../lib/diff-budget.js';
-import { createNoDiffError } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { DetectApiBreakingInputSchema } from '../schemas/inputs.js';
@@ -29,12 +27,10 @@ export function registerDetectApiBreakingTool(server) {
         ...(TOOL_CONTRACT.temperature !== undefined
             ? { temperature: TOOL_CONTRACT.temperature }
             : undefined),
-        validateInput: (_input, ctx) => {
-            const slot = ctx.diffSlot;
-            if (!slot)
-                return createNoDiffError();
-            return validateDiffBudget(slot.diff);
-        },
+        ...(TOOL_CONTRACT.deterministicJson !== undefined
+            ? { deterministicJson: TOOL_CONTRACT.deterministicJson }
+            : undefined),
+        requiresDiff: true,
         formatOutcome: (result) => `${result.breakingChanges.length} breaking change(s) found`,
         formatOutput: (result) => result.hasBreakingChanges
             ? `API Breaking Changes: ${result.breakingChanges.length} found.`