@j0hanz/code-review-analyst-mcp 1.7.2 → 1.7.4

package/dist/lib/gemini.js

@@ -514,12 +514,27 @@ async function throwGeminiFailure(attemptsMade, lastError, onLog) {
 async function runWithRetries(request, model, timeoutMs, maxRetries, onLog) {
     let lastError;
     let attempt = 0;
+    let currentModel = model;
     for (; attempt <= maxRetries; attempt += 1) {
         try {
-            return await executeAttempt(request, model, timeoutMs, attempt, onLog);
+            return await executeAttempt(request, currentModel, timeoutMs, attempt, onLog);
         }
         catch (error) {
             lastError = error;
+            if (getNumericErrorCode(error) === 404 &&
+                currentModel === 'gemini-3-flash-preview') {
+                currentModel = 'gemini-2.5-flash';
+                delete request.thinkingLevel;
+                await emitGeminiLog(onLog, 'warning', {
+                    event: 'gemini_model_fallback',
+                    details: {
+                        from: 'gemini-3-flash-preview',
+                        to: 'gemini-2.5-flash',
+                        reason: 'Model not found (404)',
+                    },
+                });
+                continue;
+            }
             if (!canRetryAttempt(attempt, maxRetries, error)) {
                 attempt += 1; // Count this attempt before breaking
                 break;
@@ -737,6 +752,43 @@ async function cancelBatchIfNeeded(request, batches, batchName, onLog, completed
         });
     }
 }
+async function createBatchJobWithFallback(request, batches, model, onLog) {
+    let currentModel = model;
+    const createSignal = request.signal ?? NEVER_ABORT_SIGNAL;
+    for (let attempt = 0; attempt <= 1; attempt += 1) {
+        try {
+            const createPayload = {
+                model: currentModel,
+                src: [
+                    {
+                        contents: [{ role: 'user', parts: [{ text: request.prompt }] }],
+                        config: buildGenerationConfig(request, createSignal),
+                    },
+                ],
+            };
+            return await batches.create(createPayload);
+        }
+        catch (error) {
+            if (attempt === 0 &&
+                getNumericErrorCode(error) === 404 &&
+                currentModel === 'gemini-3-flash-preview') {
+                currentModel = 'gemini-2.5-flash';
+                delete request.thinkingLevel;
+                await emitGeminiLog(onLog, 'warning', {
+                    event: 'gemini_model_fallback',
+                    details: {
+                        from: 'gemini-3-flash-preview',
+                        to: 'gemini-2.5-flash',
+                        reason: 'Model not found (404) during batch create',
+                    },
+                });
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error('Unexpected state: batch creation loop exited without returning or throwing.');
+}
 async function runInlineBatchWithPolling(request, model, onLog) {
     const client = getClient();
     const { batches } = client;
@@ -747,17 +799,7 @@ 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, createSignal),
-                },
-            ],
-        };
-        const createdJob = await batches.create(createPayload);
+        const createdJob = await createBatchJobWithFallback(request, batches, model, onLog);
         const createdRecord = toRecord(createdJob);
         batchName =
             typeof createdRecord?.name === 'string' ? createdRecord.name : undefined;

package/dist/lib/tool-factory.js

@@ -183,13 +183,17 @@ function createProgressReporter(extra) {
         };
     }
     const progressToken = rawToken;
-    let lastCurrent = 0;
+    let lastCurrent = -1;
     let didSendTerminal = false;
     return async (payload) => {
         if (didSendTerminal) {
             return;
         }
-        const current = Math.max(payload.current, lastCurrent);
+        let { current } = payload;
+        if (current <= lastCurrent && current < (payload.total ?? Infinity)) {
+            current = lastCurrent + 0.01;
+        }
+        current = Math.max(current, lastCurrent);
         const total = payload.total !== undefined
             ? Math.max(payload.total, current)
             : undefined;
@@ -265,18 +269,20 @@ async function sendSingleStepProgress(extra, toolName, context, current, state)
 async function reportProgressStepUpdate(reportProgress, toolName, context, current, metadata) {
     await reportProgress({
         current,
+        total: TASK_PROGRESS_TOTAL,
         message: formatProgressStep(toolName, context, metadata),
     });
 }
 async function reportProgressCompletionUpdate(reportProgress, toolName, context, outcome) {
     await reportProgress({
         current: TASK_PROGRESS_TOTAL,
+        total: TASK_PROGRESS_TOTAL,
         message: formatProgressCompletion(toolName, context, outcome),
     });
 }
 async function reportSchemaRetryProgressBestEffort(reportProgress, toolName, context, retryCount, maxRetries) {
     try {
-        await reportProgressStepUpdate(reportProgress, toolName, context, STEP_VALIDATING_RESPONSE, `Schema repair in progress (attempt ${retryCount}/${maxRetries})...`);
+        await reportProgressStepUpdate(reportProgress, toolName, context, STEP_VALIDATING_RESPONSE + retryCount / (maxRetries + 1), `Schema repair in progress (attempt ${retryCount}/${maxRetries})...`);
     }
     catch {
         // Progress updates are best-effort and must not interrupt retries.
@@ -392,6 +398,11 @@ export class ToolExecutionRunner {
             await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, msg);
             await this.updateStatusMessage(msg);
         }
+        else if (record.event === 'gemini_queue_acquired') {
+            const msg = 'Model queue acquired, generating response...';
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, msg);
+            await this.updateStatusMessage(msg);
+        }
     }
     setResponseSchemaOverride(responseSchema) {
         this.responseSchema = responseSchema;
@@ -552,35 +563,54 @@ export function registerStructuredToolTask(server, config) {
         geminiSchema: config.geminiSchema,
         resultSchema: config.resultSchema,
     });
-    server.registerTool(config.name, {
+    server.experimental.tasks.registerToolTask(config.name, {
         title: config.title,
         description: config.description,
         inputSchema: config.inputSchema,
         outputSchema: DefaultOutputSchema,
         annotations: buildToolAnnotations(config.annotations),
-    }, 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
+        execution: {
+            taskSupport: 'optional',
+        },
+    }, {
+        createTask: async (input, extra) => {
+            const task = await extra.taskStore.createTask({ ttl: 300000 });
+            const extendedStore = extra.taskStore;
+            const runner = new ToolExecutionRunner(config, {
+                onLog: async (level, data) => {
+                    try {
+                        await server.sendLoggingMessage({
+                            level: toLoggingLevel(level),
+                            logger: 'gemini',
+                            data: asObjectRecord(data),
+                        });
+                    }
+                    catch {
+                        // Fallback if logging fails
+                    }
                 },
-            },
-        });
-        runner.setResponseSchemaOverride(responseSchema);
-        return await runner.run(input);
+                reportProgress: createProgressReporter(extra),
+                statusReporter: {
+                    updateStatus: async (message) => {
+                        await extendedStore.updateTaskStatus(task.taskId, 'working', message);
+                    },
+                    storeResult: async (status, result) => {
+                        await extra.taskStore.storeTaskResult(task.taskId, status, result);
+                    },
+                },
+            });
+            runner.setResponseSchemaOverride(responseSchema);
+            // Run in background
+            runner.run(input).catch(async (error) => {
+                await extendedStore.updateTaskStatus(task.taskId, 'failed', getErrorMessage(error));
+            });
+            return { task };
+        },
+        getTask: async (input, extra) => {
+            return await extra.taskStore.getTask(extra.taskId);
+        },
+        getTaskResult: async (input, extra) => {
+            return (await extra.taskStore.getTaskResult(extra.taskId));
+        },
     });
 }

package/package.json

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