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

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.
@@ -557,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.3",
+  "version": "1.7.4",
   "mcpName": "io.github.j0hanz/code-review-analyst",
   "description": "Gemini-powered MCP server for code review analysis.",
   "type": "module",