gemini-as-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,28 @@
+MIT License (Non-Commercial)
+
+Original work Copyright (c) 2025 jamubc
+Modified work Copyright (c) 2025 baljinnyamday
+
+This project is a fork of gemini-mcp-tool (https://github.com/jamubc/gemini-mcp-tool)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software for non-commercial purposes only, including without limitation
+the rights to use, copy, modify, merge, publish, and distribute copies of the
+Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+Commercial use of this software is prohibited without prior written permission
+from the copyright holder. For commercial licensing, please contact the
+copyright holder directly.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,303 @@
+
+# Gemini as MCP
+
+<div align="center">
+
+[![GitHub Release](https://img.shields.io/github/v/release/baljinnyamday/gemini-as-mcp?logo=github&label=GitHub)](https://github.com/baljinnyamday/gemini-as-mcp/releases)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Open Source](https://img.shields.io/badge/Open%20Source-❤️-red.svg)](https://github.com/baljinnyamday/gemini-as-mcp)
+
+</div>
+
+## TLDR: [![Claude](https://img.shields.io/badge/Claude-D97757?logo=claude&logoColor=fff)](#) + [![Google Gemini](https://img.shields.io/badge/Google%20Gemini-886FBF?logo=googlegemini&logoColor=fff)](#)
+
+**Goal**: Supercharge Claude Code with Gemini's 2M+ token context and built-in tools for:
+- 🔍 **Web Search** - Get latest docs, APIs, tutorials (via `google_web_search`)
+- 🌐 **URL Fetching** - Process documentation, blogs, articles (via `web_fetch`)
+- 📂 **Large Codebase Analysis** - Analyze entire projects that exceed Claude's context
+- ✅ **Implementation Verification** - Check if features/patterns exist in your code
+- 🛠️ **Code Execution** - Safely run and test code in sandbox mode
+
+## Prerequisites
+
+Before using this tool, ensure you have:
+
+1. **[Node.js](https://nodejs.org/)** (v16.0.0 or higher)
+2. **[Google Gemini CLI](https://github.com/google-gemini/gemini-cli)** installed and configured
+
+
+### One-Line Setup
+
+```bash
+claude mcp add gemini-cli -- npx -y gemini-as-mcp
+```
+
+### Verify Installation
+
+Type `/mcp` inside Claude Code to verify the gemini-cli MCP is active.
+
+---
+
+### Alternative: Import from Claude Desktop
+
+If you already have it configured in Claude Desktop:
+
+1. Add to your Claude Desktop config:
+```json
+"gemini-cli": {
+  "command": "npx",
+  "args": ["-y", "gemini-as-mcp"]
+}
+```
+
+2. Import to Claude Code:
+```bash
+claude mcp add-from-claude-desktop
+```
+
+## Configuration
+
+Register the MCP server with your MCP client:
+
+### For NPX Usage (Recommended)
+
+Add this configuration to your Claude Desktop config file:
+
+```json
+{
+  "mcpServers": {
+    "gemini-cli": {
+      "command": "npx",
+      "args": ["-y", "gemini-as-mcp"]
+    }
+  }
+}
+```
+
+### For Global Installation
+
+If you installed globally, use this configuration instead:
+
+```json
+{
+  "mcpServers": {
+    "gemini-cli": {
+      "command": "gemini-as-mcp"
+    }
+  }
+}
+```
+
+**Configuration File Locations:**
+
+- **Claude Desktop**:
+  - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+  - **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+  - **Linux**: `~/.config/claude/claude_desktop_config.json`
+
+After updating the configuration, restart your terminal session.
+
+## 🚀 Available Tools
+
+This MCP server provides specialized tools that leverage Gemini's capabilities. Claude Code can use these tools naturally through conversation.
+
+### 1. 🔍 `web-search` - Search the Web via Gemini
+
+Search the web and get AI-processed summaries with citations. Perfect for getting current information beyond Claude's knowledge cutoff.
+
+**Use Cases:**
+- Latest package versions and breaking changes
+- Current API documentation
+- Recent tutorials and best practices
+- Technology news and updates
+
+**Example Prompts for Claude:**
+```
+"Search the web for React 19 breaking changes"
+"Find the latest Next.js App Router documentation"
+"What are the new features in TypeScript 5.5?"
+```
+
+**Parameters:**
+- `query` (required): Your search query
+- `model` (optional): Model to use (default: `gemini-2.5-pro`)
+
+---
+
+### 2. 🌐 `web-fetch` - Fetch and Process URLs
+
+Fetch content from URLs and have Gemini process it according to your instructions. Handles 1-20 URLs per request.
+
+**Use Cases:**
+- Fetching and summarizing documentation
+- Comparing multiple API references
+- Extracting code examples from blogs
+- Analyzing articles and tutorials
+
+**Example Prompts for Claude:**
+```
+"Fetch https://nextjs.org/docs/app and explain the new routing system"
+"Compare the APIs at [url1] and [url2]"
+"Extract all code examples from https://example.com/tutorial"
+```
+
+**Parameters:**
+- `urls` (required): Single URL or array of URLs
+- `instruction` (required): What to do with the content
+- `model` (optional): Model to use (default: `gemini-2.5-pro`)
+
+---
+
+### 3. 📂 `analyze-codebase` - Large Codebase Analysis
+
+Analyze entire codebases using Gemini's 2M+ token context window. Perfect for projects that exceed Claude's context limits.
+
+**Use Cases:**
+- Understanding project architecture
+- Finding patterns across codebase
+- Analyzing all API endpoints
+- Reviewing entire feature implementations
+
+**Example Prompts for Claude:**
+```
+"Analyze @src/ and explain the authentication flow"
+"Review @./ and summarize the project structure"
+"Find all API endpoints in @backend/ and @routes/"
+```
+
+**Parameters:**
+- `paths` (required): File/directory paths with `@` syntax
+- `question` (required): What you want to know
+- `model` (optional): Model to use (default: `gemini-2.5-pro`)
+
+**@ Syntax Examples:**
+- `@src/` - Entire src directory
+- `@package.json` - Single file
+- `@./` - Current directory and subdirectories
+- `@src/ @tests/` - Multiple directories
+
+---
+
+### 4. ✅ `verify-implementation` - Check Feature Implementation
+
+Verify if specific features, patterns, or security measures are implemented in your codebase. Returns detailed findings with file paths.
+
+**Use Cases:**
+- Check if authentication is implemented
+- Verify error handling exists
+- Find security measures
+- Locate specific patterns (e.g., WebSocket usage)
+
+**Example Prompts for Claude:**
+```
+"Check if JWT authentication is implemented in @src/"
+"Verify rate limiting exists in @api/ @middleware/"
+"Is Redis caching implemented? Check @services/"
+"Find all WebSocket connections in @src/"
+```
+
+**Parameters:**
+- `paths` (required): Directories to search with `@` syntax
+- `feature` (required): Feature/pattern to check for
+- `details` (optional): Specific aspects to verify
+- `model` (optional): Model to use (default: `gemini-2.5-pro`)
+
+---
+
+### 5. 🛠️ `ask-gemini` - General Purpose Gemini Query
+
+The most flexible tool - automatically uses Gemini's built-in tools (`web_search`, `web_fetch`, file analysis) as needed.
+
+**Capabilities:**
+- File/directory analysis via `@` syntax
+- Automatic web search for current info
+- Automatic URL fetching
+- Code execution in sandbox mode
+- Structured code edits (changeMode)
+
+**Example Prompts for Claude:**
+```
+"Ask Gemini to analyze @src/auth.js and suggest improvements"
+"Use Gemini to search for the latest React hooks best practices"
+"Have Gemini explain this codebase @./"
+```
+
+**Parameters:**
+- `prompt` (required): Your request (supports @syntax, URLs, search queries)
+- `model` (optional): Model to use (default: `gemini-2.5-pro`)
+- `sandbox` (optional): Run in sandbox mode (default: false)
+- `changeMode` (optional): Return structured edits (default: false)
+
+---
+
+## 💡 Usage Tips
+
+### When to Use Each Tool
+
+**Use `web-search` when:**
+- You need current information (latest docs, packages, APIs)
+- You want AI-processed summaries with citations
+- Claude's knowledge cutoff is limiting
+
+**Use `web-fetch` when:**
+- You have specific URLs to analyze
+- You need to compare documentation
+- You want to extract information from web pages
+
+**Use `analyze-codebase` when:**
+- Your codebase exceeds Claude's context
+- You need to understand entire project structure
+- You're looking for patterns across many files
+
+**Use `verify-implementation` when:**
+- You need to check if features exist
+- You're auditing security measures
+- You want to find specific patterns
+
+**Use `ask-gemini` when:**
+- You want Gemini to decide which tools to use
+- You have a complex multi-part request
+- You need flexibility
+
+---
+
+## 📝 Example Workflows
+
+### Workflow 1: Learning a New Library
+```
+1. Claude: "Search the web for Drizzle ORM latest version"
+2. Claude: "Fetch https://orm.drizzle.team/docs and explain core concepts"
+3. Claude: "Analyze @src/db/ and suggest how to integrate Drizzle"
+```
+
+### Workflow 2: Codebase Audit
+```
+1. Claude: "Verify if authentication is implemented in @src/"
+2. Claude: "Check if error handling exists in @api/"
+3. Claude: "Analyze @src/ for security vulnerabilities"
+```
+
+### Workflow 3: Feature Implementation
+```
+1. Claude: "Search the web for Next.js 14 server actions best practices"
+2. Claude: "Verify if server actions are used in @app/"
+3. Claude: "Analyze @app/ and suggest where to add server actions"
+```
+
+## Attribution
+
+This project is a fork of [gemini-mcp-tool](https://github.com/jamubc/gemini-mcp-tool) by jamubc. The original project provided the foundation for integrating Google's Gemini CLI with the Model Context Protocol. This fork maintains the core functionality while diverging in direction and implementation to explore new capabilities and use cases.
+
+This is a simple Model Context Protocol (MCP) server that allows AI assistants to interact with the [Gemini CLI](https://github.com/google-gemini/gemini-cli). It enables the AI to leverage the power of Gemini's massive token window for large analysis, especially with large files and codebases using the `@` syntax for direction.
+
+- Ask gemini natural questions, through claude or Brainstorm new ideas in a party of 3!
+
+## Contributing
+
+Contributions are welcome! Please see our [Contributing Guidelines](CONTRIBUTING.md) for details on how to submit pull requests, report issues, and contribute to the project.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+**Disclaimer:** This is an unofficial, third-party tool and is not affiliated with, endorsed, or sponsored by Google.

package/dist/constants.d.ts

@@ -0,0 +1,74 @@
+export declare const LOG_PREFIX = "[GMCPT]";
+export declare const ERROR_MESSAGES: {
+    readonly QUOTA_EXCEEDED: "Quota exceeded for quota metric 'Gemini 2.5 Pro Requests'";
+    readonly QUOTA_EXCEEDED_SHORT: "⚠️ Gemini 2.5 Pro daily quota exceeded. Please retry with model: 'gemini-2.5-flash'";
+    readonly TOOL_NOT_FOUND: "not found in registry";
+    readonly NO_PROMPT_PROVIDED: "Please provide a prompt for analysis. Use @ syntax to include files (e.g., '@largefile.js explain what this does') or ask general questions";
+};
+export declare const STATUS_MESSAGES: {
+    readonly QUOTA_SWITCHING: "🚫 Gemini 2.5 Pro quota exceeded, switching to Flash model...";
+    readonly FLASH_RETRY: "⚡ Retrying with Gemini 2.5 Flash...";
+    readonly FLASH_SUCCESS: "✅ Flash model completed successfully";
+    readonly SANDBOX_EXECUTING: "🔒 Executing Gemini CLI command in sandbox mode...";
+    readonly GEMINI_RESPONSE: "Gemini response:";
+    readonly PROCESSING_START: "🔍 Starting analysis (may take 5-15 minutes for large codebases)";
+    readonly PROCESSING_CONTINUE: "⏳ Still processing... Gemini is working on your request";
+    readonly PROCESSING_COMPLETE: "✅ Analysis completed successfully";
+};
+export declare const MODELS: {
+    readonly PRO: "gemini-2.5-pro";
+    readonly FLASH: "gemini-2.5-flash";
+};
+export declare const PROTOCOL: {
+    readonly ROLES: {
+        readonly USER: "user";
+        readonly ASSISTANT: "assistant";
+    };
+    readonly CONTENT_TYPES: {
+        readonly TEXT: "text";
+    };
+    readonly STATUS: {
+        readonly SUCCESS: "success";
+        readonly ERROR: "error";
+        readonly FAILED: "failed";
+        readonly REPORT: "report";
+    };
+    readonly NOTIFICATIONS: {
+        readonly PROGRESS: "notifications/progress";
+    };
+    readonly KEEPALIVE_INTERVAL: 25000;
+};
+export declare const CLI: {
+    readonly COMMANDS: {
+        readonly GEMINI: "gemini";
+        readonly ECHO: "echo";
+    };
+    readonly FLAGS: {
+        readonly MODEL: "-m";
+        readonly SANDBOX: "-s";
+        readonly PROMPT: "-p";
+        readonly HELP: "-help";
+    };
+    readonly DEFAULTS: {
+        readonly MODEL: "default";
+        readonly BOOLEAN_TRUE: "true";
+        readonly BOOLEAN_FALSE: "false";
+    };
+};
+export interface ToolArguments {
+    prompt?: string;
+    model?: string;
+    sandbox?: boolean | string;
+    changeMode?: boolean | string;
+    chunkIndex?: number | string;
+    chunkCacheKey?: string;
+    message?: string;
+    methodology?: string;
+    domain?: string;
+    constraints?: string;
+    existingContext?: string;
+    ideaCount?: number;
+    includeAnalysis?: boolean;
+    [key: string]: string | boolean | number | undefined;
+}
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,YAAY,CAAC;AAGpC,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAGX,eAAO,MAAM,eAAe;;;;;;;;;CAUlB,CAAC;AAGX,eAAO,MAAM,MAAM;;;CAGT,CAAC;AAGX,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;CAuBX,CAAC;AAIX,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;CAmBN,CAAC;AAIX,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IAGjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;CACtD"}

package/dist/constants.js

@@ -0,0 +1,73 @@
+// Logging
+export const LOG_PREFIX = "[GMCPT]";
+// Error messages
+export const ERROR_MESSAGES = {
+    QUOTA_EXCEEDED: "Quota exceeded for quota metric 'Gemini 2.5 Pro Requests'",
+    QUOTA_EXCEEDED_SHORT: "⚠️ Gemini 2.5 Pro daily quota exceeded. Please retry with model: 'gemini-2.5-flash'",
+    TOOL_NOT_FOUND: "not found in registry",
+    NO_PROMPT_PROVIDED: "Please provide a prompt for analysis. Use @ syntax to include files (e.g., '@largefile.js explain what this does') or ask general questions",
+};
+// Status messages
+export const STATUS_MESSAGES = {
+    QUOTA_SWITCHING: "🚫 Gemini 2.5 Pro quota exceeded, switching to Flash model...",
+    FLASH_RETRY: "⚡ Retrying with Gemini 2.5 Flash...",
+    FLASH_SUCCESS: "✅ Flash model completed successfully",
+    SANDBOX_EXECUTING: "🔒 Executing Gemini CLI command in sandbox mode...",
+    GEMINI_RESPONSE: "Gemini response:",
+    // Timeout prevention messages
+    PROCESSING_START: "🔍 Starting analysis (may take 5-15 minutes for large codebases)",
+    PROCESSING_CONTINUE: "⏳ Still processing... Gemini is working on your request",
+    PROCESSING_COMPLETE: "✅ Analysis completed successfully",
+};
+// Models
+export const MODELS = {
+    PRO: "gemini-2.5-pro",
+    FLASH: "gemini-2.5-flash",
+};
+// MCP Protocol Constants
+export const PROTOCOL = {
+    // Message roles
+    ROLES: {
+        USER: "user",
+        ASSISTANT: "assistant",
+    },
+    // Content types
+    CONTENT_TYPES: {
+        TEXT: "text",
+    },
+    // Status codes
+    STATUS: {
+        SUCCESS: "success",
+        ERROR: "error",
+        FAILED: "failed",
+        REPORT: "report",
+    },
+    // Notification methods
+    NOTIFICATIONS: {
+        PROGRESS: "notifications/progress",
+    },
+    // Timeout prevention
+    KEEPALIVE_INTERVAL: 25000, // 25 seconds
+};
+// CLI Constants
+export const CLI = {
+    // Command names
+    COMMANDS: {
+        GEMINI: "gemini",
+        ECHO: "echo",
+    },
+    // Command flags
+    FLAGS: {
+        MODEL: "-m",
+        SANDBOX: "-s",
+        PROMPT: "-p",
+        HELP: "-help",
+    },
+    // Default values
+    DEFAULTS: {
+        MODEL: "default", // Fallback model used when no specific model is provided
+        BOOLEAN_TRUE: "true",
+        BOOLEAN_FALSE: "false",
+    },
+};
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,UAAU;AACV,MAAM,CAAC,MAAM,UAAU,GAAG,SAAS,CAAC;AAEpC,iBAAiB;AACjB,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,cAAc,EAAE,2DAA2D;IAC3E,oBAAoB,EAAE,qFAAqF;IAC3G,cAAc,EAAE,uBAAuB;IACvC,kBAAkB,EAAE,6IAA6I;CACzJ,CAAC;AAEX,kBAAkB;AAClB,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,eAAe,EAAE,+DAA+D;IAChF,WAAW,EAAE,qCAAqC;IAClD,aAAa,EAAE,sCAAsC;IACrD,iBAAiB,EAAE,oDAAoD;IACvE,eAAe,EAAE,kBAAkB;IACnC,8BAA8B;IAC9B,gBAAgB,EAAE,kEAAkE;IACpF,mBAAmB,EAAE,yDAAyD;IAC9E,mBAAmB,EAAE,mCAAmC;CAChD,CAAC;AAEX,SAAS;AACT,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,GAAG,EAAE,gBAAgB;IACrB,KAAK,EAAE,kBAAkB;CACjB,CAAC;AAEX,yBAAyB;AACzB,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,gBAAgB;IAChB,KAAK,EAAE;QACL,IAAI,EAAE,MAAM;QACZ,SAAS,EAAE,WAAW;KACvB;IACD,gBAAgB;IAChB,aAAa,EAAE;QACb,IAAI,EAAE,MAAM;KACb;IACD,eAAe;IACf,MAAM,EAAE;QACN,OAAO,EAAE,SAAS;QAClB,KAAK,EAAE,OAAO;QACd,MAAM,EAAE,QAAQ;QAChB,MAAM,EAAE,QAAQ;KACjB;IACD,uBAAuB;IACvB,aAAa,EAAE;QACb,QAAQ,EAAE,wBAAwB;KACnC;IACD,qBAAqB;IACrB,kBAAkB,EAAE,KAAK,EAAE,aAAa;CAChC,CAAC;AAGX,gBAAgB;AAChB,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,gBAAgB;IAChB,QAAQ,EAAE;QACR,MAAM,EAAE,QAAQ;QAChB,IAAI,EAAE,MAAM;KACb;IACD,gBAAgB;IAChB,KAAK,EAAE;QACL,KAAK,EAAE,IAAI;QACX,OAAO,EAAE,IAAI;QACb,MAAM,EAAE,IAAI;QACZ,IAAI,EAAE,OAAO;KACd;IACD,iBAAiB;IACjB,QAAQ,EAAE;QACR,KAAK,EAAE,SAAS,EAAE,yDAAyD;QAC3E,YAAY,EAAE,MAAM;QACpB,aAAa,EAAE,OAAO;KACvB;CACO,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { Logger } from "./utils/logger.js";
+import { PROTOCOL } from "./constants.js";
+import { getToolDefinitions, getPromptDefinitions, executeTool, toolExists, getPromptMessage } from "./tools/index.js";
+const server = new Server({
+    name: "gemini-as-mcp",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+        prompts: {},
+        logging: {},
+    },
+});
+let isProcessing = false;
+let currentOperationName = "";
+let latestOutput = "";
+async function sendNotification(method, params) {
+    try {
+        await server.notification({ method, params });
+    }
+    catch (error) {
+        Logger.error("notification failed: ", error);
+    }
+}
+/**
+ * @param progressToken The progress token provided by the client
+ * @param progress The current progress value
+ * @param total Optional total value
+ * @param message Optional status message
+ */
+async function sendProgressNotification(progressToken, progress, total, message) {
+    if (!progressToken)
+        return; // Only send if client requested progress
+    try {
+        const params = {
+            progressToken,
+            progress
+        };
+        if (total !== undefined)
+            params.total = total; // future cache progress
+        if (message)
+            params.message = message;
+        await server.notification({
+            method: PROTOCOL.NOTIFICATIONS.PROGRESS,
+            params
+        });
+    }
+    catch (error) {
+        Logger.error("Failed to send progress notification:", error);
+    }
+}
+function startProgressUpdates(operationName, progressToken) {
+    isProcessing = true;
+    currentOperationName = operationName;
+    latestOutput = ""; // Reset latest output
+    const progressMessages = [
+        `🧠 ${operationName} - Gemini is analyzing your request...`,
+        `📊 ${operationName} - Processing files and generating insights...`,
+        `✨ ${operationName} - Creating structured response for your review...`,
+        `⏱️ ${operationName} - Large analysis in progress (this is normal for big requests)...`,
+        `🔍 ${operationName} - Still working... Gemini takes time for quality results...`,
+    ];
+    let messageIndex = 0;
+    let progress = 0;
+    // Send immediate acknowledgment if progress requested
+    if (progressToken) {
+        sendProgressNotification(progressToken, 0, undefined, // No total - indeterminate progress
+        `🔍 Starting ${operationName}`);
+    }
+    // Keep client alive with periodic updates
+    const progressInterval = setInterval(async () => {
+        if (isProcessing && progressToken) {
+            // Simply increment progress value
+            progress += 1;
+            // Include latest output if available
+            const baseMessage = progressMessages[messageIndex % progressMessages.length];
+            const outputPreview = latestOutput.slice(-150).trim(); // Last 150 chars
+            const message = outputPreview
+                ? `${baseMessage}\n📝 Output: ...${outputPreview}`
+                : baseMessage;
+            await sendProgressNotification(progressToken, progress, undefined, // No total - indeterminate progress
+            message);
+            messageIndex++;
+        }
+        else if (!isProcessing) {
+            clearInterval(progressInterval);
+        }
+    }, PROTOCOL.KEEPALIVE_INTERVAL); // Every 25 seconds
+    return { interval: progressInterval, progressToken };
+}
+function stopProgressUpdates(progressData, success = true) {
+    const operationName = currentOperationName; // Store before clearing
+    isProcessing = false;
+    currentOperationName = "";
+    clearInterval(progressData.interval);
+    // Send final progress notification if client requested progress
+    if (progressData.progressToken) {
+        sendProgressNotification(progressData.progressToken, 100, 100, success ? `✅ ${operationName} completed successfully` : `❌ ${operationName} failed`);
+    }
+}
+// tools/list
+server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+    return { tools: getToolDefinitions() };
+});
+// tools/get
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    if (toolExists(toolName)) {
+        // Check if client requested progress updates
+        const progressToken = request.params._meta?.progressToken;
+        // Start progress updates if client requested them
+        const progressData = startProgressUpdates(toolName, progressToken);
+        try {
+            // Get prompt and other parameters from arguments with proper typing
+            const args = request.params.arguments || {};
+            Logger.toolInvocation(toolName, request.params.arguments);
+            // Execute the tool using the unified registry with progress callback
+            const result = await executeTool(toolName, args, (newOutput) => {
+                latestOutput = newOutput;
+            });
+            // Stop progress updates
+            stopProgressUpdates(progressData, true);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+                isError: false,
+            };
+        }
+        catch (error) {
+            // Stop progress updates on error
+            stopProgressUpdates(progressData, false);
+            Logger.error(`Error in tool '${toolName}':`, error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error executing ${toolName}: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    else {
+        throw new Error(`Unknown tool: ${request.params.name}`);
+    }
+});
+// prompts/list
+server.setRequestHandler(ListPromptsRequestSchema, async (request) => {
+    return { prompts: getPromptDefinitions() };
+});
+// prompts/get
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const promptName = request.params.name;
+    const args = request.params.arguments || {};
+    const promptMessage = getPromptMessage(promptName, args);
+    if (!promptMessage) {
+        throw new Error(`Unknown prompt: ${promptName}`);
+    }
+    return {
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: promptMessage
+                }
+            }]
+    };
+});
+// Start the server
+async function main() {
+    Logger.debug("init gemini-mcp-tool");
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    Logger.debug("gemini-mcp-tool listening on stdio");
+}
+main().catch((error) => { Logger.error("Fatal error:", error); process.exit(1); });
+//# sourceMappingURL=index.js.map