@j0hanz/code-review-analyst-mcp 1.7.0 → 1.7.1

package/README.md

@@ -12,13 +12,13 @@ Gemini-powered MCP server for pull request analysis with structured outputs for
 
 ## Overview
 
-This server accepts unified diffs and returns structured JSON results — findings with severity, impact categories, merge risk, test plans, and verbatim search/replace fixes. It uses Gemini Thinking models (Flash for fast tools, Pro for deep analysis) and runs over **stdio transport**.
+This server accepts unified diffs and returns structured JSON results — findings with severity, impact categories, merge risk, test plans, and verbatim search/replace fixes. It uses Gemini Thinking models (Flash for fast tools, Flash for deep analysis) and runs over **stdio transport**.
 
 ## Key Features
 
 - **Impact Analysis** — Objective severity scoring, breaking change detection, and rollback complexity assessment.
 - **Review Summary** — Concise PR digest with merge recommendation and change statistics.
-- **Deep Code Inspection** — Pro model with high thinking level for context-aware analysis using full file contents.
+- **Deep Code Inspection** — Flash model with high thinking level for context-aware analysis using full file contents.
 - **Search & Replace Fixes** — Verbatim, copy-paste-ready code fixes tied to specific findings.
 - **Test Plan Generation** — Systematic test case generation with priority ranking and pseudocode.
 - **Async Task Support** — All tools support MCP task lifecycle with progress notifications.
@@ -279,13 +279,25 @@ docker build -t code-review-analyst-mcp .
 
 ## Tools
 
+> [!IMPORTANT]
+> Call `generate_diff` first (`mode: "unstaged"` or `"staged"`). All review tools read the cached server-side diff (`diff://current`) and do not accept a direct `diff` parameter.
+
+### `generate_diff`
+
+Generate and cache the current branch diff for downstream review tools.
+
+| Parameter | Type     | Required | Description                                        |
+| --------- | -------- | -------- | -------------------------------------------------- |
+| `mode`    | `string` | Yes      | `unstaged` (working tree) or `staged` (git index). |
+
+**Returns:** `diffRef`, `stats` (files, added, deleted), `generatedAt`, `mode`, `message`.
+
 ### `analyze_pr_impact`
 
-Assess the impact and risk of a pull request diff using the Flash model.
+Assess the impact and risk of cached pull request changes using the Flash model.
 
 | Parameter    | Type     | Required | Description                              |
 | ------------ | -------- | -------- | ---------------------------------------- |
-| `diff`       | `string` | Yes      | Unified diff text.                       |
 | `repository` | `string` | Yes      | Repository identifier (e.g. `org/repo`). |
 | `language`   | `string` | No       | Primary language hint.                   |
 
@@ -297,7 +309,6 @@ Summarize a pull request diff and assess high-level risk using the Flash model.
 
 | Parameter    | Type     | Required | Description                              |
 | ------------ | -------- | -------- | ---------------------------------------- |
-| `diff`       | `string` | Yes      | Unified diff text.                       |
 | `repository` | `string` | Yes      | Repository identifier (e.g. `org/repo`). |
 | `language`   | `string` | No       | Primary language hint.                   |
 
@@ -305,11 +316,10 @@ Summarize a pull request diff and assess high-level risk using the Flash model.
 
 ### `inspect_code_quality`
 
-Deep-dive code review using the Pro model with thinking (16K token budget).
+Deep-dive code review using the Flash model with high thinking (16K token budget).
 
 | Parameter     | Type       | Required | Description                                   |
 | ------------- | ---------- | -------- | --------------------------------------------- |
-| `diff`        | `string`   | Yes      | Unified diff text.                            |
 | `repository`  | `string`   | Yes      | Repository identifier (e.g. `org/repo`).      |
 | `language`    | `string`   | No       | Primary language hint.                        |
 | `focusAreas`  | `string[]` | No       | Areas to inspect: security, correctness, etc. |
@@ -322,11 +332,10 @@ Deep-dive code review using the Pro model with thinking (16K token budget).
 
 ### `suggest_search_replace`
 
-Generate verbatim search-and-replace blocks to fix a specific finding using the Pro model with thinking.
+Generate verbatim search-and-replace blocks to fix a specific finding using the Flash model with high thinking.
 
 | Parameter        | Type     | Required | Description                              |
 | ---------------- | -------- | -------- | ---------------------------------------- |
-| `diff`           | `string` | Yes      | Unified diff that contains the issue.    |
 | `findingTitle`   | `string` | Yes      | Short title of the finding to fix.       |
 | `findingDetails` | `string` | Yes      | Detailed explanation of the bug or risk. |
 
@@ -338,7 +347,6 @@ Create a test plan covering the changes in the diff using the Flash model with t
 
 | Parameter       | Type     | Required | Description                                 |
 | --------------- | -------- | -------- | ------------------------------------------- |
-| `diff`          | `string` | Yes      | Unified diff to generate tests for.         |
 | `repository`    | `string` | Yes      | Repository identifier (e.g. `org/repo`).    |
 | `language`      | `string` | No       | Primary language hint.                      |
 | `testFramework` | `string` | No       | Test framework (e.g. jest, vitest, pytest). |
@@ -391,8 +399,8 @@ Create a test plan covering the changes in the diff using the Flash model with t
 | ------------------------- | ------------------------ | -------------- |
 | `analyze_pr_impact`       | `gemini-3-flash-preview` | `minimal`      |
 | `generate_review_summary` | `gemini-3-flash-preview` | `minimal`      |
-| `inspect_code_quality`    | `gemini-3-pro-preview`   | `high`         |
-| `suggest_search_replace`  | `gemini-3-pro-preview`   | `high`         |
+| `inspect_code_quality`    | `gemini-3-flash-preview` | `high`         |
+| `suggest_search_replace`  | `gemini-3-flash-preview` | `high`         |
 | `generate_test_plan`      | `gemini-3-flash-preview` | `medium`       |
 
 ## Workflows
@@ -456,7 +464,7 @@ The pipeline runs lint, type-check, test, and build, then publishes to three tar
 | ------------------------------------------ | ------------------------------------------------------------------------------------ |
 | `Missing GEMINI_API_KEY or GOOGLE_API_KEY` | Set one of the API key env vars in your MCP client config.                           |
 | `E_INPUT_TOO_LARGE`                        | Diff exceeds budget. Split into smaller diffs.                                       |
-| `Gemini request timed out`                 | Pro model tasks may take 60-120s. Increase your client timeout.                      |
+| `Gemini request timed out`                 | Deep analysis tasks may take 60-120s. Increase your client timeout.                  |
 | `Too many concurrent Gemini calls`         | Reduce parallel tool calls or increase `MAX_CONCURRENT_CALLS`.                       |
 | No tool output visible                     | Ensure your MCP client is not swallowing `stderr` — the server uses stdio transport. |
 

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

@@ -2,6 +2,7 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ParsedFile } from './diff.js';
 import { createErrorToolResponse } from './tool-response.js';
 export declare const DIFF_RESOURCE_URI = "diff://current";
+export declare const diffStaleWarningMs: import("./env-config.js").CachedEnvInt;
 export interface DiffStats {
     files: number;
     added: number;

package/dist/lib/diff-store.js

@@ -3,6 +3,8 @@ import { createErrorToolResponse } from './tool-response.js';
 export const DIFF_RESOURCE_URI = 'diff://current';
 const diffCacheTtlMs = createCachedEnvInt('DIFF_CACHE_TTL_MS', 60 * 60 * 1_000 // 1 hour default
 );
+export const diffStaleWarningMs = createCachedEnvInt('DIFF_STALE_WARNING_MS', 5 * 60 * 1_000 // 5 minutes default
+);
 const diffSlots = new Map();
 let sendResourceUpdated;
 function setDiffSlot(key, data) {

package/dist/lib/gemini.js

@@ -39,6 +39,7 @@ const TRUE_ENV_VALUES = new Set(['1', 'true', 'yes', 'on']);
 const FALSE_ENV_VALUES = new Set(['0', 'false', 'no', 'off']);
 const SLEEP_UNREF_OPTIONS = { ref: false };
 const JSON_CODE_BLOCK_PATTERN = /```(?:json)?\n?([\s\S]*?)(?=\n?```)/u;
+const NEVER_ABORT_SIGNAL = new AbortController().signal;
 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);
@@ -746,12 +747,13 @@ async function runInlineBatchWithPolling(request, model, onLog) {
     let completed = false;
     let timedOut = false;
     try {
+        const createSignal = request.signal ?? NEVER_ABORT_SIGNAL;
         const createPayload = {
             model,
             src: [
                 {
                     contents: [{ role: 'user', parts: [{ text: request.prompt }] }],
-                    config: buildGenerationConfig(request, new AbortController().signal),
+                    config: buildGenerationConfig(request, createSignal),
                 },
             ],
         };

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

@@ -1,34 +1,32 @@
 /** Fast, cost-effective model for summarization and light analysis. */
 export declare const FLASH_MODEL = "gemini-3-flash-preview";
-/** High-capability model for deep reasoning, quality inspection, and reliable code generation. */
-export declare const PRO_MODEL = "gemini-3-pro-preview";
 /** Default language hint. */
 export declare const DEFAULT_LANGUAGE = "detect";
 /** Default test-framework hint. */
 export declare const DEFAULT_FRAMEWORK = "detect";
-/** Extended timeout for Pro model calls (ms). */
-export declare const DEFAULT_TIMEOUT_PRO_MS = 120000;
+/** Extended timeout for deep analysis calls (ms). */
+export declare const DEFAULT_TIMEOUT_EXTENDED_MS = 120000;
 export declare const MODEL_TIMEOUT_MS: {
-    readonly defaultPro: 120000;
+    readonly extended: 120000;
 };
 /** Thinking level for Flash triage. */
 export declare const FLASH_TRIAGE_THINKING_LEVEL: "minimal";
 /** Thinking level for Flash analysis. */
 export declare const FLASH_THINKING_LEVEL: "medium";
-/** Thinking level for Pro deep analysis. */
-export declare const PRO_THINKING_LEVEL: "high";
+/** Thinking level for Flash deep analysis. */
+export declare const FLASH_HIGH_THINKING_LEVEL: "high";
 /** Output cap for Flash API breaking-change detection. */
-export declare const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS: 4096;
+export declare const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS = 65536;
 /** Output cap for Flash complexity analysis. */
-export declare const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS: 4096;
+export declare const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS = 65536;
 /** Output cap for Flash test-plan generation. */
-export declare const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS: 8192;
+export declare const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS = 65536;
 /** Output cap for Flash triage tools. */
-export declare const FLASH_TRIAGE_MAX_OUTPUT_TOKENS: 4096;
-/** Output cap for Pro patch generation. */
-export declare const PRO_PATCH_MAX_OUTPUT_TOKENS: 8192;
-/** Output cap for Pro deep review findings. */
-export declare const PRO_REVIEW_MAX_OUTPUT_TOKENS: 12288;
+export declare const FLASH_TRIAGE_MAX_OUTPUT_TOKENS = 65536;
+/** Output cap for Flash patch generation. */
+export declare const FLASH_PATCH_MAX_OUTPUT_TOKENS = 65536;
+/** Output cap for Flash deep review findings. */
+export declare const FLASH_REVIEW_MAX_OUTPUT_TOKENS = 65536;
 /** Temperature for analytical tools. */
 export declare const ANALYSIS_TEMPERATURE: 1;
 /** Temperature for creative synthesis (test plans). */

package/dist/lib/model-config.js

@@ -1,15 +1,13 @@
 /** Fast, cost-effective model for summarization and light analysis. */
 export const FLASH_MODEL = 'gemini-3-flash-preview';
-/** High-capability model for deep reasoning, quality inspection, and reliable code generation. */
-export const PRO_MODEL = 'gemini-3-pro-preview';
 /** Default language hint. */
 export const DEFAULT_LANGUAGE = 'detect';
 /** Default test-framework hint. */
 export const DEFAULT_FRAMEWORK = 'detect';
-/** Extended timeout for Pro model calls (ms). */
-export const DEFAULT_TIMEOUT_PRO_MS = 120_000;
+/** Extended timeout for deep analysis calls (ms). */
+export const DEFAULT_TIMEOUT_EXTENDED_MS = 120_000;
 export const MODEL_TIMEOUT_MS = {
-    defaultPro: DEFAULT_TIMEOUT_PRO_MS,
+    extended: DEFAULT_TIMEOUT_EXTENDED_MS,
 };
 Object.freeze(MODEL_TIMEOUT_MS);
 // ---------------------------------------------------------------------------
@@ -21,35 +19,28 @@ const THINKING_LEVELS = {
     /** Medium thinking for analysis tasks. */
     flash: 'medium',
     /** High thinking for deep review and patches. */
-    pro: 'high',
-};
-// 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: 4_096,
-    flashTestPlan: 8_192,
-    flashTriage: 4_096,
-    proPatch: 8_192,
-    proReview: 12_288,
+    flashHigh: 'high',
 };
 /** Thinking level for Flash triage. */
 export const FLASH_TRIAGE_THINKING_LEVEL = THINKING_LEVELS.flashTriage;
 /** Thinking level for Flash analysis. */
 export const FLASH_THINKING_LEVEL = THINKING_LEVELS.flash;
-/** Thinking level for Pro deep analysis. */
-export const PRO_THINKING_LEVEL = THINKING_LEVELS.pro;
+/** Thinking level for Flash deep analysis. */
+export const FLASH_HIGH_THINKING_LEVEL = THINKING_LEVELS.flashHigh;
+// Output token caps for various tools. Set to a high default to avoid cutting off important information, but can be adjusted as needed.
+const DEFAULT_OUTPUT_CAP = 65_536;
 /** Output cap for Flash API breaking-change detection. */
-export const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.flashApiBreaking;
+export const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
 /** Output cap for Flash complexity analysis. */
-export const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.flashComplexity;
+export const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
 /** Output cap for Flash test-plan generation. */
-export const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.flashTestPlan;
+export const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
 /** Output cap for Flash triage tools. */
-export const FLASH_TRIAGE_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.flashTriage;
-/** Output cap for Pro patch generation. */
-export const PRO_PATCH_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.proPatch;
-/** Output cap for Pro deep review findings. */
-export const PRO_REVIEW_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.proReview;
+export const FLASH_TRIAGE_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+/** Output cap for Flash patch generation. */
+export const FLASH_PATCH_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+/** Output cap for Flash deep review findings. */
+export const FLASH_REVIEW_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
 // ---------------------------------------------------------------------------
 // Temperatures
 // ---------------------------------------------------------------------------

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

@@ -57,7 +57,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "minimal";
-    readonly maxOutputTokens: 4096;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -82,7 +82,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "minimal";
-    readonly maxOutputTokens: 4096;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -104,10 +104,10 @@ export declare const TOOL_CONTRACTS: readonly [{
 }, {
     readonly name: "inspect_code_quality";
     readonly purpose: "Deep code review over the cached diff.";
-    readonly model: "gemini-3-pro-preview";
+    readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 120000;
     readonly thinkingLevel: "high";
-    readonly maxOutputTokens: 12288;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -142,10 +142,10 @@ export declare const TOOL_CONTRACTS: readonly [{
 }, {
     readonly name: "suggest_search_replace";
     readonly purpose: "Generate verbatim search/replace fix blocks for one finding.";
-    readonly model: "gemini-3-pro-preview";
+    readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 120000;
     readonly thinkingLevel: "high";
-    readonly maxOutputTokens: 8192;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -171,7 +171,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "medium";
-    readonly maxOutputTokens: 8192;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -208,7 +208,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "medium";
-    readonly maxOutputTokens: 4096;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -227,7 +227,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "minimal";
-    readonly maxOutputTokens: 4096;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{

package/dist/lib/tool-contracts.js

@@ -1,4 +1,4 @@
-import { ANALYSIS_TEMPERATURE, CREATIVE_TEMPERATURE, DEFAULT_TIMEOUT_PRO_MS, FLASH_API_BREAKING_MAX_OUTPUT_TOKENS, FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS, FLASH_MODEL, FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS, FLASH_THINKING_LEVEL, FLASH_TRIAGE_MAX_OUTPUT_TOKENS, FLASH_TRIAGE_THINKING_LEVEL, PATCH_TEMPERATURE, PRO_MODEL, PRO_PATCH_MAX_OUTPUT_TOKENS, PRO_REVIEW_MAX_OUTPUT_TOKENS, PRO_THINKING_LEVEL, TRIAGE_TEMPERATURE, } from './model-config.js';
+import { ANALYSIS_TEMPERATURE, CREATIVE_TEMPERATURE, DEFAULT_TIMEOUT_EXTENDED_MS, FLASH_API_BREAKING_MAX_OUTPUT_TOKENS, FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS, FLASH_HIGH_THINKING_LEVEL, FLASH_MODEL, FLASH_PATCH_MAX_OUTPUT_TOKENS, FLASH_REVIEW_MAX_OUTPUT_TOKENS, FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS, FLASH_THINKING_LEVEL, FLASH_TRIAGE_MAX_OUTPUT_TOKENS, FLASH_TRIAGE_THINKING_LEVEL, PATCH_TEMPERATURE, TRIAGE_TEMPERATURE, } from './model-config.js';
 const DEFAULT_TIMEOUT_FLASH_MS = 90_000;
 export const INSPECTION_FOCUS_AREAS = [
     'security',
@@ -119,10 +119,10 @@ export const TOOL_CONTRACTS = [
     {
         name: 'inspect_code_quality',
         purpose: 'Deep code review over the cached diff.',
-        model: PRO_MODEL,
-        timeoutMs: DEFAULT_TIMEOUT_PRO_MS,
-        thinkingLevel: PRO_THINKING_LEVEL,
-        maxOutputTokens: PRO_REVIEW_MAX_OUTPUT_TOKENS,
+        model: FLASH_MODEL,
+        timeoutMs: DEFAULT_TIMEOUT_EXTENDED_MS,
+        thinkingLevel: FLASH_HIGH_THINKING_LEVEL,
+        maxOutputTokens: FLASH_REVIEW_MAX_OUTPUT_TOKENS,
         temperature: ANALYSIS_TEMPERATURE,
         deterministicJson: true,
         params: [
@@ -169,10 +169,10 @@ export const TOOL_CONTRACTS = [
     {
         name: 'suggest_search_replace',
         purpose: 'Generate verbatim search/replace fix blocks for one finding.',
-        model: PRO_MODEL,
-        timeoutMs: DEFAULT_TIMEOUT_PRO_MS,
-        thinkingLevel: PRO_THINKING_LEVEL,
-        maxOutputTokens: PRO_PATCH_MAX_OUTPUT_TOKENS,
+        model: FLASH_MODEL,
+        timeoutMs: DEFAULT_TIMEOUT_EXTENDED_MS,
+        thinkingLevel: FLASH_HIGH_THINKING_LEVEL,
+        maxOutputTokens: FLASH_PATCH_MAX_OUTPUT_TOKENS,
         temperature: PATCH_TEMPERATURE,
         deterministicJson: true,
         params: [

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

@@ -1,4 +1,3 @@
-import type { CreateTaskRequestHandlerExtra } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ZodRawShapeCompat } from '@modelcontextprotocol/sdk/server/zod-compat.js';
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
@@ -26,6 +25,11 @@ interface ProgressNotificationParams {
     total?: number;
     message?: string;
 }
+interface ProgressPayload {
+    current: number;
+    total?: number;
+    message?: string;
+}
 interface ProgressExtra {
     _meta?: {
         progressToken?: unknown;
@@ -66,8 +70,6 @@ export interface StructuredToolTaskConfig<TInput extends object = Record<string,
     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. */
     thinkingLevel?: 'minimal' | 'low' | 'medium' | 'high';
     /** Optional timeout in ms for the Gemini call. Defaults to 90,000 ms. Use DEFAULT_TIMEOUT_PRO_MS for Pro model calls. */
@@ -101,29 +103,33 @@ export declare function wrapToolHandler<TInput, TResult extends CallToolResult>(
     toolName: string;
     progressContext?: (input: TInput) => string;
 }, handler: (input: TInput, extra: ProgressExtra) => Promise<TResult> | TResult): (input: TInput, extra: ProgressExtra) => Promise<TResult>;
-interface TaskLike {
-    taskId: string;
+interface TaskStatusReporter {
+    updateStatus: (message: string) => Promise<void>;
+    storeResult?: (status: 'completed' | 'failed', result: CallToolResult) => Promise<void>;
 }
-export declare class ToolTaskRunner<TInput extends object, TResult extends object, TFinal extends TResult> {
-    private readonly server;
+export declare class ToolExecutionRunner<TInput extends object, TResult extends object, TFinal extends TResult> {
     private readonly config;
-    private readonly extra;
-    private readonly task;
+    private readonly signal?;
     private diffSlotSnapshot;
     private hasSnapshot;
     private responseSchema;
     private readonly onLog;
     private readonly reportProgress;
+    private readonly statusReporter;
     private progressContext;
     private lastStatusMessage;
-    constructor(server: McpServer, config: StructuredToolTaskConfig<TInput, TResult, TFinal>, extra: CreateTaskRequestHandlerExtra, task: TaskLike);
+    constructor(config: StructuredToolTaskConfig<TInput, TResult, TFinal>, dependencies: {
+        onLog: (level: string, data: unknown) => Promise<void>;
+        reportProgress: (payload: ProgressPayload) => Promise<void>;
+        statusReporter: TaskStatusReporter;
+    }, signal?: AbortSignal | undefined);
     setResponseSchemaOverride(responseSchema: Record<string, unknown>): void;
     setDiffSlotSnapshot(diffSlotSnapshot: DiffSlot | undefined): void;
     private updateStatusMessage;
     private storeResultSafely;
     private executeValidation;
     private executeModelCall;
-    run(input: unknown): Promise<void>;
+    run(input: unknown): Promise<CallToolResult>;
 }
 export declare function registerStructuredToolTask<TInput extends object, TResult extends object = Record<string, unknown>, TFinal extends TResult = TResult>(server: McpServer, config: StructuredToolTaskConfig<TInput, TResult, TFinal>): void;
 export {};

package/dist/lib/tool-factory.js

@@ -1,13 +1,12 @@
 import { z } from 'zod';
 import { DefaultOutputSchema } from '../schemas/outputs.js';
-import { createNoDiffError, getDiff } from './diff-store.js';
+import { createNoDiffError, diffStaleWarningMs, getDiff, } from './diff-store.js';
 import { validateDiffBudget } from './diff.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';
+import { generateStructuredJson } from './gemini.js';
 import { createErrorToolResponse, createToolResponse, } from './tool-response.js';
-const DEFAULT_TASK_TTL_MS = 30 * 60 * 1_000;
 // Named progress step indices for 7-step progress (0–6).
 const STEP_STARTING = 0;
 const STEP_VALIDATING = 1;
@@ -28,7 +27,6 @@ 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.';
 const JSON_PARSE_ERROR_PATTERN = /model produced invalid json/i;
-const MODEL_IMMEDIATE_RESPONSE_META_KEY = 'io.modelcontextprotocol/model-immediate-response';
 const responseSchemaCache = new WeakMap();
 const progressReporterCache = new WeakMap();
 function buildToolAnnotations(annotations) {
@@ -107,9 +105,6 @@ function createGenerationRequest(config, promptParts, responseSchema, onLog, sig
         responseSchema,
         onLog,
     };
-    if (config.model !== undefined) {
-        request.model = config.model;
-    }
     if (config.thinkingLevel !== undefined) {
         request.thinkingLevel = config.thinkingLevel;
     }
@@ -248,16 +243,6 @@ function normalizeProgressContext(context) {
 function formatProgressStep(toolName, context, metadata) {
     return `${toolName}: ${context} [${metadata}]`;
 }
-function friendlyModelName(model) {
-    if (!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) {
     return `🗒 ${toolName}: ${context} • ${outcome}`;
 }
@@ -318,32 +303,6 @@ function asObjectRecord(value) {
     }
     return { payload: value };
 }
-function createGeminiLogger(server, taskId) {
-    return async (level, data) => {
-        try {
-            await server.sendLoggingMessage({
-                level: toLoggingLevel(level),
-                logger: 'gemini',
-                data: {
-                    requestId: getCurrentRequestId(),
-                    taskId,
-                    ...asObjectRecord(data),
-                },
-            });
-        }
-        catch {
-            try {
-                const timestamp = new Date().toISOString();
-                const payload = JSON.stringify(asObjectRecord(data));
-                console.error(`[${timestamp}] [gemini:${level}] ${taskId} - ${payload}`);
-            }
-            catch {
-                // Safe fallback if JSON stringify fails
-                console.error(`[gemini:${level}] ${taskId} - (logging failed)`);
-            }
-        }
-    };
-}
 export function wrapToolHandler(options, handler) {
     return async (input, extra) => {
         const context = normalizeProgressContext(options.progressContext?.(input));
@@ -396,26 +355,24 @@ async function validateRequest(config, inputRecord, ctx) {
     }
     return undefined;
 }
-export class ToolTaskRunner {
-    server;
+export class ToolExecutionRunner {
     config;
-    extra;
-    task;
+    signal;
     diffSlotSnapshot;
     hasSnapshot = false;
     responseSchema;
     onLog;
     reportProgress;
+    statusReporter;
     progressContext;
     lastStatusMessage;
-    constructor(server, config, extra, task) {
-        this.server = server;
+    constructor(config, dependencies, signal) {
         this.config = config;
-        this.extra = extra;
-        this.task = task;
+        this.signal = signal;
         this.responseSchema = getCachedGeminiResponseSchema(config);
-        this.onLog = createGeminiLogger(server, task.taskId);
-        this.reportProgress = createProgressReporter(extra);
+        this.onLog = dependencies.onLog;
+        this.reportProgress = dependencies.reportProgress;
+        this.statusReporter = dependencies.statusReporter;
         this.progressContext = DEFAULT_PROGRESS_CONTEXT;
     }
     setResponseSchemaOverride(responseSchema) {
@@ -431,7 +388,7 @@ export class ToolTaskRunner {
             return;
         }
         try {
-            await this.extra.taskStore.updateTaskStatus(this.task.taskId, 'working', message);
+            await this.statusReporter.updateStatus(message);
             this.lastStatusMessage = message;
         }
         catch {
@@ -439,8 +396,11 @@ export class ToolTaskRunner {
         }
     }
     async storeResultSafely(status, result) {
+        if (!this.statusReporter.storeResult) {
+            return;
+        }
         try {
-            await this.extra.taskStore.storeTaskResult(this.task.taskId, status, result);
+            await this.statusReporter.storeResult(status, result);
         }
         catch (storeErr) {
             await this.onLog('error', {
@@ -468,9 +428,9 @@ export class ToolTaskRunner {
             await this.updateStatusMessage(validationMessage);
             await reportProgressCompletionUpdate(this.reportProgress, this.config.name, this.progressContext, 'rejected');
             await this.storeResultSafely('completed', validationError);
-            return false;
+            return validationError;
         }
-        return true;
+        return undefined;
     }
     async executeModelCall(systemInstruction, prompt) {
         let parsed;
@@ -478,7 +438,7 @@ export class ToolTaskRunner {
         const maxRetries = this.config.schemaRetries ?? geminiSchemaRetriesConfig.get();
         for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
             try {
-                const raw = await generateStructuredJson(createGenerationRequest(this.config, { systemInstruction, prompt: retryPrompt }, this.responseSchema, this.onLog, this.extra.signal));
+                const raw = await generateStructuredJson(createGenerationRequest(this.config, { systemInstruction, prompt: retryPrompt }, this.responseSchema, this.onLog, this.signal));
                 if (attempt === 0) {
                     await this.updateStatusMessage('validating response');
                     await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING_RESPONSE, 'validating response');
@@ -513,8 +473,6 @@ export class ToolTaskRunner {
         try {
             const inputRecord = parseToolInput(input, this.config.fullInputSchema);
             this.progressContext = normalizeProgressContext(this.config.progressContext?.(inputRecord));
-            // Prefer createTask snapshot; fallback preserves backward compatibility
-            // for any direct constructor callers.
             const ctx = {
                 diffSlot: this.hasSnapshot ? this.diffSlotSnapshot : getDiff(),
             };
@@ -522,40 +480,52 @@ export class ToolTaskRunner {
             await this.updateStatusMessage('starting');
             await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING, 'validating input');
             await this.updateStatusMessage('validating input');
-            if (!(await this.executeValidation(inputRecord, ctx))) {
-                return;
+            const validationError = await this.executeValidation(inputRecord, ctx);
+            if (validationError) {
+                return validationError;
             }
             await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_BUILDING_PROMPT, 'building prompt');
             await this.updateStatusMessage('building prompt');
             const promptParts = this.config.buildPrompt(inputRecord, ctx);
             const { prompt, systemInstruction } = promptParts;
-            const modelLabel = friendlyModelName(this.config.model);
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, modelLabel);
-            await this.updateStatusMessage(modelLabel);
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, 'calling model');
+            await this.updateStatusMessage('calling model');
             const parsed = await this.executeModelCall(systemInstruction, prompt);
             await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_FINALIZING, 'finalizing');
             await this.updateStatusMessage('finalizing');
             const finalResult = (this.config.transformResult
                 ? this.config.transformResult(inputRecord, parsed, ctx)
                 : parsed);
-            const textContent = this.config.formatOutput
+            let textContent = this.config.formatOutput
                 ? this.config.formatOutput(finalResult)
                 : undefined;
+            if (ctx.diffSlot) {
+                const ageMs = Date.now() - new Date(ctx.diffSlot.generatedAt).getTime();
+                if (ageMs > diffStaleWarningMs.get()) {
+                    const ageMinutes = Math.round(ageMs / 60_000);
+                    const warning = `\n\n⚠️ Warning: The analyzed diff is over ${ageMinutes} minutes old. If you have made recent changes, please run generate_diff again.`;
+                    textContent = textContent ? textContent + warning : warning;
+                }
+            }
             const outcome = this.config.formatOutcome?.(finalResult) ?? 'completed';
             await reportProgressCompletionUpdate(this.reportProgress, this.config.name, this.progressContext, outcome);
             await this.updateStatusMessage(`completed: ${outcome}`);
-            await this.storeResultSafely('completed', createToolResponse({
+            const successResponse = createToolResponse({
                 ok: true,
                 result: finalResult,
-            }, textContent));
+            }, textContent);
+            await this.storeResultSafely('completed', successResponse);
+            return successResponse;
         }
         catch (error) {
             const errorMessage = getErrorMessage(error);
             const errorMeta = classifyErrorMeta(error, errorMessage);
             const outcome = errorMeta.kind === 'cancelled' ? 'cancelled' : 'failed';
             await this.updateStatusMessage(createFailureStatusMessage(outcome, errorMessage));
-            await this.storeResultSafely('failed', createErrorToolResponse(this.config.errorCode, errorMessage, undefined, errorMeta));
+            const errorResponse = createErrorToolResponse(this.config.errorCode, errorMessage, undefined, errorMeta);
+            await this.storeResultSafely('failed', errorResponse);
             await reportProgressCompletionUpdate(this.reportProgress, this.config.name, this.progressContext, outcome);
+            return errorResponse; // Return safe error response
         }
     }
 }
@@ -564,50 +534,35 @@ export function registerStructuredToolTask(server, config) {
         geminiSchema: config.geminiSchema,
         resultSchema: config.resultSchema,
     });
-    server.experimental.tasks.registerToolTask(config.name, {
+    server.registerTool(config.name, {
         title: config.title,
         description: config.description,
         inputSchema: config.inputSchema,
         outputSchema: DefaultOutputSchema,
         annotations: buildToolAnnotations(config.annotations),
-    }, {
-        createTask: async (input, extra) => {
-            const task = await extra.taskStore.createTask({
-                ttl: extra.taskRequestedTtl ?? DEFAULT_TASK_TTL_MS,
-            });
-            const currentDiff = getDiff();
-            // Snapshot by reference: diff-store replaces slots on update, so this
-            // preserves task-level TOCTOU safety without deep-clone overhead.
-            const diffSlotSnapshot = currentDiff;
-            const runner = new ToolTaskRunner(server, config, extra, task);
-            runner.setResponseSchemaOverride(responseSchema);
-            runner.setDiffSlotSnapshot(diffSlotSnapshot);
-            setImmediate(() => {
-                void runner.run(input).catch(async (error) => {
-                    try {
-                        await server.sendLoggingMessage({
-                            level: 'error',
-                            logger: 'task-runner',
-                            data: { task: config.name, error: getErrorMessage(error) },
-                        });
-                    }
-                    catch {
-                        console.error(`[task-runner:${config.name}] ${getErrorMessage(error)}`);
-                    }
-                });
-            });
-            return {
-                task,
-                _meta: {
-                    [MODEL_IMMEDIATE_RESPONSE_META_KEY]: `${config.name} accepted as task ${task.taskId}`,
+    }, async (input, extra) => {
+        const runner = new ToolExecutionRunner(config, {
+            onLog: async (level, data) => {
+                // Standard logging for tool calls
+                try {
+                    await server.sendLoggingMessage({
+                        level: toLoggingLevel(level),
+                        logger: 'gemini',
+                        data: asObjectRecord(data),
+                    });
+                }
+                catch {
+                    // Fallback if logging fails
+                }
+            },
+            reportProgress: createProgressReporter(extra),
+            statusReporter: {
+                updateStatus: async () => {
+                    // No-op for standard tool calls as they don't have a persistent task status
                 },
-            };
-        },
-        getTask: async (_input, extra) => {
-            return await extra.taskStore.getTask(extra.taskId);
-        },
-        getTaskResult: async (_input, extra) => {
-            return (await extra.taskStore.getTaskResult(extra.taskId));
-        },
+            },
+        });
+        runner.setResponseSchemaOverride(responseSchema);
+        return await runner.run(input);
     });
 }

package/dist/resources/index.js

@@ -83,7 +83,7 @@ function registerToolInfoResources(server) {
 }
 export const DIFF_RESOURCE_DESCRIPTION = 'The most recently generated diff, cached by generate_diff. Read by all review tools automatically.';
 function registerDiffResource(server) {
-    server.registerResource('diff-current', new ResourceTemplate(DIFF_RESOURCE_URI, { list: undefined }), {
+    server.registerResource('diff-current', DIFF_RESOURCE_URI, {
         title: 'Current Diff',
         description: DIFF_RESOURCE_DESCRIPTION,
         mimeType: PATCH_MIME_TYPE,

package/dist/resources/instructions.js

@@ -22,7 +22,7 @@ ${parameterLines.join('\n')}
 - **Output**: \`${contract.outputShape}\``;
     }
     const modelInfo = [
-        contract.model.includes('flash') ? 'Flash' : 'Pro',
+        'Flash',
         contract.thinkingLevel ? `Thinking:${contract.thinkingLevel}` : '',
         `${Math.round(contract.timeoutMs / 1_000)}s`,
         `MaxTokens:${contract.maxOutputTokens}`,

package/dist/resources/tool-catalog.js

@@ -26,8 +26,8 @@ generate_review_summary ──→ overallRisk ──────┤
 
 ## When to Use Each Tool
 
-- **Triage**: \`analyze_pr_impact\`, \`generate_review_summary\` (Flash).
-- **Inspection**: \`inspect_code_quality\` (Pro).
+- **Triage**: \`analyze_pr_impact\`, \`generate_review_summary\`.
+- **Inspection**: \`inspect_code_quality\`.
 - **Fixes**: \`suggest_search_replace\` (one finding/call).
 - **Tests**: \`generate_test_plan\`.
 - **Complexity**: \`analyze_time_space_complexity\`.

package/dist/tools/analyze-complexity.js

@@ -19,7 +19,6 @@ export function registerAnalyzeComplexityTool(server) {
         fullInputSchema: AnalyzeComplexityInputSchema,
         resultSchema: AnalyzeComplexityResultSchema,
         errorCode: 'E_ANALYZE_COMPLEXITY',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

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

@@ -22,7 +22,6 @@ export function registerAnalyzePrImpactTool(server) {
         fullInputSchema: AnalyzePrImpactInputSchema,
         resultSchema: PrImpactResultSchema,
         errorCode: 'E_ANALYZE_IMPACT',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

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

@@ -19,7 +19,6 @@ export function registerDetectApiBreakingTool(server) {
         fullInputSchema: DetectApiBreakingInputSchema,
         resultSchema: DetectApiBreakingResultSchema,
         errorCode: 'E_DETECT_API_BREAKING',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/generate-review-summary.js

@@ -36,7 +36,6 @@ export function registerGenerateReviewSummaryTool(server) {
         fullInputSchema: GenerateReviewSummaryInputSchema,
         resultSchema: ReviewSummaryModelSchema,
         errorCode: 'E_REVIEW_SUMMARY',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/generate-test-plan.js

@@ -23,7 +23,6 @@ export function registerGenerateTestPlanTool(server) {
         fullInputSchema: GenerateTestPlanInputSchema,
         resultSchema: TestPlanResultSchema,
         errorCode: 'E_GENERATE_TEST_PLAN',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/inspect-code-quality.js

@@ -28,7 +28,6 @@ export function registerInspectCodeQualityTool(server) {
         resultSchema: CodeQualityOutputSchema,
         geminiSchema: CodeQualityResultSchema,
         errorCode: 'E_INSPECT_QUALITY',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/suggest-search-replace.js

@@ -23,7 +23,6 @@ export function registerSuggestSearchReplaceTool(server) {
         fullInputSchema: SuggestSearchReplaceInputSchema,
         resultSchema: SearchReplaceResultSchema,
         errorCode: 'E_SUGGEST_SEARCH_REPLACE',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/code-review-analyst-mcp",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "mcpName": "io.github.j0hanz/code-review-analyst",
   "description": "Gemini-powered MCP server for code review analysis.",
   "type": "module",