@rlabs-inc/gemini-mcp 0.6.1 → 0.6.3

package/dist/gemini-client.d.ts

@@ -120,3 +120,38 @@ export declare function checkVideoStatus(operationName: string): Promise<VideoGe
  * Get the output directory path
  */
 export declare function getOutputDir(): string;
+/**
+ * Token count result
+ */
+export interface TokenCountResult {
+    totalTokens: number;
+    modelName: string;
+}
+/**
+ * Count tokens for content using specified model
+ */
+export declare function countTokens(content: string, model?: 'pro' | 'flash'): Promise<TokenCountResult>;
+/**
+ * Deep Research interaction result
+ */
+export interface DeepResearchResult {
+    id: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    outputs?: {
+        text?: string;
+    }[];
+    error?: string;
+    savedPath?: string;
+}
+/**
+ * Start a deep research task
+ */
+export declare function startDeepResearch(prompt: string): Promise<DeepResearchResult>;
+/**
+ * Check deep research status
+ */
+export declare function checkDeepResearch(researchId: string): Promise<DeepResearchResult>;
+/**
+ * Follow up on completed research
+ */
+export declare function followUpResearch(researchId: string, question: string): Promise<string>;

package/dist/gemini-client.js

@@ -397,3 +397,120 @@ export async function checkVideoStatus(operationName) {
 export function getOutputDir() {
     return outputDir;
 }
+/**
+ * Count tokens for content using specified model
+ */
+export async function countTokens(content, model = 'flash') {
+    const modelName = model === 'pro' ? proModelName : flashModelName;
+    const result = await genAI.models.countTokens({
+        model: modelName,
+        contents: content,
+    });
+    return {
+        totalTokens: result.totalTokens || 0,
+        modelName,
+    };
+}
+// Deep Research agent model
+const DEEP_RESEARCH_AGENT = 'deep-research-pro-preview-12-2025';
+/**
+ * Start a deep research task
+ */
+export async function startDeepResearch(prompt) {
+    try {
+        // The Interactions API is properly typed in @google/genai v1.34.0+
+        const interaction = await genAI.interactions.create({
+            input: prompt,
+            agent: DEEP_RESEARCH_AGENT,
+            background: true,
+            agent_config: {
+                type: 'deep-research',
+                thinking_summaries: 'auto',
+            },
+        });
+        return {
+            id: interaction.id || `research-${Date.now()}`,
+            status: 'pending',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Deep research not available: ${message}`);
+    }
+}
+/**
+ * Check deep research status
+ */
+export async function checkDeepResearch(researchId) {
+    try {
+        const interaction = await genAI.interactions.get(researchId);
+        const status = interaction.status || 'unknown';
+        if (status === 'completed') {
+            // Save the FULL raw response to the output directory
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const outputPath = path.join(getOutputDir(), `deep-research-${timestamp}.json`);
+            const fullResponse = {
+                id: researchId,
+                status: interaction.status,
+                created: interaction.created,
+                agent: interaction.agent,
+                model: interaction.model,
+                outputs: interaction.outputs,
+                rawInteraction: interaction,
+            };
+            fs.writeFileSync(outputPath, JSON.stringify(fullResponse, null, 2));
+            logger.info(`Full deep research response saved to: ${outputPath}`);
+            // Extract text for the summary (but full data is saved)
+            const textOutputs = (interaction.outputs || [])
+                .filter((output) => 'type' in output && output.type === 'text')
+                .map(output => ({ text: output.text }));
+            return {
+                id: researchId,
+                status: 'completed',
+                outputs: textOutputs,
+                savedPath: outputPath,
+            };
+        }
+        else if (status === 'failed' || status === 'cancelled') {
+            return {
+                id: researchId,
+                status: 'failed',
+                error: 'Research task failed or was cancelled',
+            };
+        }
+        return {
+            id: researchId,
+            status: 'processing',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to check research status: ${message}`);
+    }
+}
+/**
+ * Follow up on completed research
+ */
+export async function followUpResearch(researchId, question) {
+    try {
+        const interaction = await genAI.interactions.create({
+            input: question,
+            model: proModelName,
+            previous_interaction_id: researchId,
+        });
+        // Extract text from TextContent outputs
+        const outputs = interaction.outputs || [];
+        const textOutputs = outputs
+            .filter((output) => 'type' in output && output.type === 'text')
+            .map(output => output.text)
+            .filter((text) => !!text);
+        if (textOutputs.length > 0) {
+            return textOutputs[textOutputs.length - 1];
+        }
+        return 'No text response received';
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Research follow-up failed: ${message}`);
+    }
+}

package/dist/index.js

@@ -113,7 +113,7 @@ async function main() {
         // Create MCP server
         const server = new McpServer({
             name: 'Gemini',
-            version: '0.6.1',
+            version: '0.6.3',
         });
         // Register tools
         registerQueryTool(server);

package/dist/tools/deep-research.d.ts

@@ -4,7 +4,7 @@
  * Uses the Gemini Deep Research Agent for complex research tasks.
  * The agent autonomously plans, searches, reads, and synthesizes research.
  */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /**
  * Register deep research tools with the MCP server
  */

package/dist/tools/deep-research.js

@@ -4,20 +4,18 @@
  * Uses the Gemini Deep Research Agent for complex research tasks.
  * The agent autonomously plans, searches, reads, and synthesizes research.
  */
-import { z } from "zod";
-import { logger } from "../utils/logger.js";
-import { genAI } from "../gemini-client.js";
+import { z } from 'zod';
+import { logger } from '../utils/logger.js';
+import { startDeepResearch, checkDeepResearch, followUpResearch, } from '../gemini-client.js';
 // Store active research operations for polling
 const activeResearchOperations = new Map();
-// Deep Research agent model
-const DEEP_RESEARCH_AGENT = "deep-research-pro-preview-12-2025";
 /**
  * Register deep research tools with the MCP server
  */
 export function registerDeepResearchTool(server) {
     // Start a deep research task
-    server.tool("gemini-deep-research", {
-        query: z.string().describe("The research question or topic to investigate"),
+    server.tool('gemini-deep-research', {
+        query: z.string().describe('The research question or topic to investigate'),
         format: z
             .string()
             .optional()
@@ -30,33 +28,22 @@ export function registerDeepResearchTool(server) {
             if (format) {
                 researchPrompt = `${query}\n\nFormat the output as: ${format}`;
             }
-            // Start the research task in the background
-            // The Interactions API is accessed via genAI.interactions
-            const interaction = await genAI.interactions.create({
-                input: researchPrompt,
-                agent: DEEP_RESEARCH_AGENT,
-                background: true,
-                agentConfig: {
-                    type: "deep-research",
-                    thinkingSummaries: "auto"
-                }
-            });
-            const interactionId = interaction.id || `research-${Date.now()}`;
+            const result = await startDeepResearch(researchPrompt);
             // Store for later polling
-            activeResearchOperations.set(interactionId, {
-                interactionId,
+            activeResearchOperations.set(result.id, {
                 startedAt: new Date(),
-                prompt: query
+                prompt: query,
             });
-            logger.info(`Deep research started: ${interactionId}`);
+            logger.info(`Deep research started: ${result.id}`);
             return {
-                content: [{
-                        type: "text",
+                content: [
+                    {
+                        type: 'text',
                         text: `**Deep Research Started**
 
 | Field | Value |
 |-------|-------|
-| **Research ID** | \`${interactionId}\` |
+| **Research ID** | \`${result.id}\` |
 | **Query** | ${query.substring(0, 100)}${query.length > 100 ? '...' : ''} |
 | **Status** | In Progress |
 | **Started** | ${new Date().toISOString()} |
@@ -69,18 +56,20 @@ export function registerDeepResearchTool(server) {
 **To check progress:**
 Use \`gemini-check-research\` with the Research ID above.
 
-**Note:** Deep research tasks run in the background. You can continue working while waiting.`
-                    }]
+**Note:** Deep research tasks run in the background. You can continue working while waiting.`,
+                    },
+                ],
             };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error(`Error starting deep research: ${errorMessage}`);
             // Check if it's an API availability issue
-            if (errorMessage.includes("interactions") || errorMessage.includes("not found")) {
+            if (errorMessage.includes('not available') || errorMessage.includes('interactions')) {
                 return {
-                    content: [{
-                            type: "text",
+                    content: [
+                        {
+                            type: 'text',
                             text: `**Deep Research Not Available**
 
 The Interactions API required for Deep Research may not be available yet in your SDK version or API access.
@@ -90,44 +79,46 @@ The Interactions API required for Deep Research may not be available yet in your
 **Alternatives:**
 - Use \`gemini-search\` for real-time web search
 - Use \`gemini-query\` with a detailed research prompt
-- Wait for Interactions API to become available in your region`
-                        }],
-                    isError: true
+- Wait for Interactions API to become available in your region`,
+                        },
+                    ],
+                    isError: true,
                 };
             }
             return {
-                content: [{ type: "text", text: `Error starting deep research: ${errorMessage}` }],
-                isError: true
+                content: [{ type: 'text', text: `Error starting deep research: ${errorMessage}` }],
+                isError: true,
             };
         }
     });
     // Check research status
-    server.tool("gemini-check-research", {
-        researchId: z.string().describe("The research ID returned from gemini-deep-research")
+    server.tool('gemini-check-research', {
+        researchId: z.string().describe('The research ID returned from gemini-deep-research'),
     }, async ({ researchId }) => {
         logger.info(`Checking research status: ${researchId}`);
         try {
             // Get stored operation info
             const operationInfo = activeResearchOperations.get(researchId);
-            // Get the current status
-            const interaction = await genAI.interactions.get(researchId);
-            const status = interaction.status || "unknown";
-            const elapsedMs = operationInfo
-                ? Date.now() - operationInfo.startedAt.getTime()
-                : 0;
+            const elapsedMs = operationInfo ? Date.now() - operationInfo.startedAt.getTime() : 0;
             const elapsedMinutes = Math.floor(elapsedMs / 60000);
             const elapsedSeconds = Math.floor((elapsedMs % 60000) / 1000);
-            if (status === "completed") {
+            const result = await checkDeepResearch(researchId);
+            if (result.status === 'completed') {
                 // Research is done - extract the result
                 activeResearchOperations.delete(researchId);
-                const outputs = interaction.outputs || [];
-                const result = outputs.length > 0
-                    ? outputs[outputs.length - 1].text || "No text output"
-                    : "Research completed but no output found";
+                const outputs = result.outputs || [];
+                const resultText = outputs.length > 0
+                    ? outputs[outputs.length - 1].text || 'No text output'
+                    : 'Research completed but no output found';
                 logger.info(`Research completed: ${researchId}`);
+                // Build the saved path info if available
+                const savedPathInfo = result.savedPath
+                    ? `| **Full Response** | \`${result.savedPath}\` |`
+                    : '';
                 return {
-                    content: [{
-                            type: "text",
+                    content: [
+                        {
+                            type: 'text',
                             text: `**Deep Research Complete**
 
 | Field | Value |
@@ -135,55 +126,62 @@ The Interactions API required for Deep Research may not be available yet in your
 | **Research ID** | \`${researchId}\` |
 | **Status** | ✅ Completed |
 | **Duration** | ${elapsedMinutes}m ${elapsedSeconds}s |
+${savedPathInfo}
+
+> **Note:** The full response (including citations, images, and all metadata) has been saved to the file above.
 
 ---
 
 ## Research Results
 
-${result}`
-                        }]
+${resultText}`,
+                        },
+                    ],
                 };
             }
-            else if (status === "failed") {
+            else if (result.status === 'failed') {
                 activeResearchOperations.delete(researchId);
-                const errorInfo = interaction.error || "Unknown error";
-                logger.error(`Research failed: ${researchId} - ${errorInfo}`);
+                logger.error(`Research failed: ${researchId} - ${result.error}`);
                 return {
-                    content: [{
-                            type: "text",
+                    content: [
+                        {
+                            type: 'text',
                             text: `**Deep Research Failed**
 
 | Field | Value |
 |-------|-------|
 | **Research ID** | \`${researchId}\` |
 | **Status** | ❌ Failed |
-| **Error** | ${errorInfo} |
+| **Error** | ${result.error} |
 
 The research task encountered an error. You can try:
 - Starting a new research task with a different query
-- Using \`gemini-search\` for simpler web searches`
-                        }],
-                    isError: true
+- Using \`gemini-search\` for simpler web searches`,
+                        },
+                    ],
+                    isError: true,
                 };
             }
             else {
                 // Still in progress
                 return {
-                    content: [{
-                            type: "text",
+                    content: [
+                        {
+                            type: 'text',
                             text: `**Deep Research In Progress**
 
 | Field | Value |
 |-------|-------|
 | **Research ID** | \`${researchId}\` |
-| **Status** | ⏳ ${status} |
+| **Status** | ⏳ ${result.status} |
 | **Elapsed** | ${elapsedMinutes}m ${elapsedSeconds}s |
 | **Query** | ${operationInfo?.prompt.substring(0, 50) || 'Unknown'}... |
 
 The agent is still working. Deep research typically takes 2-10 minutes.
 
-Check again in 30-60 seconds using \`gemini-check-research\`.`
-                        }]
+Check again in 30-60 seconds using \`gemini-check-research\`.`,
+                        },
+                    ],
                 };
             }
         }
@@ -191,45 +189,39 @@ Check again in 30-60 seconds using \`gemini-check-research\`.`
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error(`Error checking research status: ${errorMessage}`);
             return {
-                content: [{ type: "text", text: `Error checking research status: ${errorMessage}` }],
-                isError: true
+                content: [{ type: 'text', text: `Error checking research status: ${errorMessage}` }],
+                isError: true,
             };
         }
     });
     // Follow-up on completed research
-    server.tool("gemini-research-followup", {
-        researchId: z.string().describe("The research ID from a completed research task"),
-        question: z.string().describe("Follow-up question about the research results")
+    server.tool('gemini-research-followup', {
+        researchId: z.string().describe('The research ID from a completed research task'),
+        question: z.string().describe('Follow-up question about the research results'),
     }, async ({ researchId, question }) => {
         logger.info(`Research follow-up on ${researchId}: ${question.substring(0, 50)}...`);
         try {
-            const interaction = await genAI.interactions.create({
-                input: question,
-                model: "gemini-3-pro-preview",
-                previousInteractionId: researchId
-            });
-            const outputs = interaction.outputs || [];
-            const result = outputs.length > 0
-                ? outputs[outputs.length - 1].text || "No response"
-                : "No response received";
+            const result = await followUpResearch(researchId, question);
             return {
-                content: [{
-                        type: "text",
+                content: [
+                    {
+                        type: 'text',
                         text: `**Research Follow-up**
 
 **Question:** ${question}
 
 **Answer:**
-${result}`
-                    }]
+${result}`,
+                    },
+                ],
             };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error(`Error with research follow-up: ${errorMessage}`);
             return {
-                content: [{ type: "text", text: `Error with follow-up: ${errorMessage}` }],
-                isError: true
+                content: [{ type: 'text', text: `Error with follow-up: ${errorMessage}` }],
+                isError: true,
             };
         }
     });

package/dist/tools/token-count.d.ts

@@ -3,7 +3,7 @@
  *
  * Helps users estimate costs and manage context windows.
  */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /**
  * Register token counting tool with the MCP server
  */

package/dist/tools/token-count.js

@@ -3,37 +3,31 @@
  *
  * Helps users estimate costs and manage context windows.
  */
-import { z } from "zod";
-import { logger } from "../utils/logger.js";
-import { genAI } from "../gemini-client.js";
+import { z } from 'zod';
+import { logger } from '../utils/logger.js';
+import { countTokens } from '../gemini-client.js';
 /**
  * Register token counting tool with the MCP server
  */
 export function registerTokenCountTool(server) {
-    server.tool("gemini-count-tokens", {
-        content: z.string().describe("The text content to count tokens for"),
+    server.tool('gemini-count-tokens', {
+        content: z.string().describe('The text content to count tokens for'),
         model: z
-            .enum(["pro", "flash"])
-            .default("flash")
-            .describe("Which model to use for counting (affects tokenization)")
-    }, async ({ content, model = "flash" }) => {
+            .enum(['pro', 'flash'])
+            .default('flash')
+            .describe('Which model to use for counting (affects tokenization)'),
+    }, async ({ content, model = 'flash' }) => {
         logger.info(`Counting tokens for ${content.length} characters using ${model} model`);
         try {
-            const modelName = model === "pro"
-                ? (process.env.GEMINI_PRO_MODEL || "gemini-3-pro-preview")
-                : (process.env.GEMINI_FLASH_MODEL || "gemini-3-flash-preview");
-            const result = await genAI.models.countTokens({
-                model: modelName,
-                contents: content
-            });
-            const totalTokens = result.totalTokens || 0;
+            const result = await countTokens(content, model);
+            const totalTokens = result.totalTokens;
             // Estimate costs (approximate, based on typical pricing)
             // Gemini 3 Pro: ~$1.25 per 1M input tokens
             // Gemini 3 Flash: ~$0.075 per 1M input tokens
-            const costPer1M = model === "pro" ? 1.25 : 0.075;
+            const costPer1M = model === 'pro' ? 1.25 : 0.075;
             const estimatedCost = (totalTokens / 1_000_000) * costPer1M;
             // Context window info
-            const contextWindow = model === "pro" ? 1_000_000 : 1_000_000;
+            const contextWindow = model === 'pro' ? 1_000_000 : 1_000_000;
             const percentUsed = (totalTokens / contextWindow) * 100;
             const response = `**Token Count Results**
 
@@ -41,7 +35,7 @@ export function registerTokenCountTool(server) {
 |--------|-------|
 | **Total Tokens** | ${totalTokens.toLocaleString()} |
 | **Characters** | ${content.length.toLocaleString()} |
-| **Model** | ${modelName} |
+| **Model** | ${result.modelName} |
 
 **Context Window Usage:**
 - Context window: ${contextWindow.toLocaleString()} tokens
@@ -55,15 +49,15 @@ export function registerTokenCountTool(server) {
 *Note: Actual costs may vary. Check [Google AI pricing](https://ai.google.dev/pricing) for current rates.*`;
             logger.info(`Token count: ${totalTokens}`);
             return {
-                content: [{ type: "text", text: response }]
+                content: [{ type: 'text', text: response }],
             };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error(`Error counting tokens: ${errorMessage}`);
             return {
-                content: [{ type: "text", text: `Error counting tokens: ${errorMessage}` }],
-                isError: true
+                content: [{ type: 'text', text: `Error counting tokens: ${errorMessage}` }],
+                isError: true,
             };
         }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rlabs-inc/gemini-mcp",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "MCP server for Gemini 3 integration with Claude Code - full frontier AI capabilities",
   "main": "dist/index.js",
   "type": "module",