@iqai/adk 0.0.7 → 0.0.8

package/dist/index.mjs

@@ -2945,7 +2945,14 @@ init_logger();
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { CreateMessageRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { CreateMessageRequestSchema as CreateMessageRequestSchema2 } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/mcp/sampling-handler.ts
+init_logger();
+import {
+  CreateMessageRequestSchema,
+  CreateMessageResultSchema
+} from "@modelcontextprotocol/sdk/types.js";
 
 // src/tools/mcp/types.ts
 var McpErrorType = /* @__PURE__ */ ((McpErrorType2) => {
@@ -2969,6 +2976,154 @@ var McpError = class extends Error {
   }
 };
 
+// src/tools/mcp/sampling-handler.ts
+var McpSamplingHandler = class {
+  logger = new Logger({ name: "McpSamplingHandler" });
+  adkHandler;
+  constructor(adkHandler) {
+    this.adkHandler = adkHandler;
+  }
+  /**
+   * Handle MCP sampling request and convert between formats
+   */
+  async handleSamplingRequest(request) {
+    try {
+      const validationResult = CreateMessageRequestSchema.safeParse(request);
+      if (!validationResult.success) {
+        this.logger.error(
+          "Invalid MCP sampling request:",
+          validationResult.error
+        );
+        throw new McpError(
+          `Invalid sampling request: ${validationResult.error.message}`,
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
+      }
+      const mcpParams = request.params;
+      if (!mcpParams.messages || !Array.isArray(mcpParams.messages)) {
+        throw new McpError(
+          "Invalid sampling request: messages array is required",
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
+      }
+      if (!mcpParams.maxTokens || mcpParams.maxTokens <= 0) {
+        throw new McpError(
+          "Invalid sampling request: maxTokens must be a positive number",
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
+      }
+      this.logger.debug("Converting MCP request to ADK format");
+      const adkMessages = this.convertMcpMessagesToADK(mcpParams.messages);
+      const adkRequest = {
+        messages: adkMessages,
+        systemPrompt: mcpParams.systemPrompt,
+        modelPreferences: mcpParams.modelPreferences,
+        includeContext: mcpParams.includeContext,
+        temperature: mcpParams.temperature,
+        maxTokens: mcpParams.maxTokens,
+        stopSequences: mcpParams.stopSequences,
+        metadata: mcpParams.metadata
+      };
+      this.logger.debug("Calling ADK sampling handler");
+      const adkResponse = await this.adkHandler(adkRequest);
+      this.logger.debug("Converting ADK response to MCP format");
+      const mcpResponse = this.convertADKResponseToMcp(adkResponse);
+      const responseValidation = CreateMessageResultSchema.safeParse(mcpResponse);
+      if (!responseValidation.success) {
+        this.logger.error(
+          "Invalid MCP response generated:",
+          responseValidation.error
+        );
+        throw new McpError(
+          `Invalid response generated: ${responseValidation.error.message}`,
+          "SAMPLING_ERROR" /* SAMPLING_ERROR */
+        );
+      }
+      return mcpResponse;
+    } catch (error) {
+      this.logger.error("Error handling sampling request:", error);
+      if (error instanceof McpError) {
+        throw error;
+      }
+      throw new McpError(
+        `Sampling request failed: ${error instanceof Error ? error.message : String(error)}`,
+        "SAMPLING_ERROR" /* SAMPLING_ERROR */,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Convert MCP messages to ADK message format
+   */
+  convertMcpMessagesToADK(mcpMessages) {
+    return mcpMessages.map((mcpMessage) => {
+      const adkRole = mcpMessage.role === "assistant" ? "assistant" : "user";
+      let adkContent;
+      if (mcpMessage.content.type === "text") {
+        adkContent = mcpMessage.content.text || "";
+      } else if (mcpMessage.content.type === "image") {
+        const contentParts = [];
+        if (mcpMessage.content.text) {
+          contentParts.push({
+            type: "text",
+            text: mcpMessage.content.text
+          });
+        }
+        if (mcpMessage.content.data) {
+          const mimeType = mcpMessage.content.mimeType || "image/jpeg";
+          const dataUrl = `data:${mimeType};base64,${mcpMessage.content.data}`;
+          contentParts.push({
+            type: "image",
+            image_url: {
+              url: dataUrl
+            }
+          });
+        }
+        adkContent = contentParts.length > 0 ? contentParts : "";
+      } else {
+        this.logger.warn(
+          `Unknown MCP content type: ${mcpMessage.content.type}`
+        );
+        adkContent = mcpMessage.content.text || "";
+      }
+      const adkMessage = {
+        role: adkRole,
+        content: adkContent
+      };
+      this.logger.debug(
+        `Converted MCP message - role: ${mcpMessage.role} -> ${adkRole}, content type: ${mcpMessage.content.type}`
+      );
+      return adkMessage;
+    });
+  }
+  /**
+   * Convert ADK response to MCP response format
+   */
+  convertADKResponseToMcp(adkResponse) {
+    const mcpResponse = {
+      model: adkResponse.model,
+      stopReason: adkResponse.stopReason,
+      role: "assistant",
+      // ADK responses are always from assistant
+      content: {
+        type: "text",
+        text: adkResponse.content || ""
+      }
+    };
+    this.logger.debug(
+      `Converted ADK response - model: ${adkResponse.model}, content length: ${adkResponse.content?.length || 0}`
+    );
+    return mcpResponse;
+  }
+  /**
+   * Update the ADK handler
+   */
+  updateHandler(handler) {
+    this.adkHandler = handler;
+    this.logger.debug("ADK sampling handler updated");
+  }
+};
+
 // src/tools/mcp/utils.ts
 function withRetry(fn, instance, reinitMethod, maxRetries = 1) {
   return async (...args) => {
@@ -3003,11 +3158,10 @@ var McpClientService = class {
   client = null;
   transport = null;
   isClosing = false;
-  samplingHandler = null;
+  mcpSamplingHandler = null;
   logger = new Logger({ name: "McpClientService" });
   constructor(config) {
     this.config = config;
-    this.samplingHandler = config.samplingHandler || null;
   }
   /**
    * Initializes and returns an MCP client based on configuration.
@@ -3209,7 +3363,7 @@ var McpClientService = class {
     return !!this.client && !this.isClosing;
   }
   async setupSamplingHandler(client) {
-    if (!this.samplingHandler) {
+    if (!this.mcpSamplingHandler) {
       if (this.config.debug) {
         console.log(
           "\u26A0\uFE0F No sampling handler provided - sampling requests will be rejected"
@@ -3217,26 +3371,10 @@ var McpClientService = class {
       }
       return;
     }
-    client.setRequestHandler(CreateMessageRequestSchema, async (request) => {
+    client.setRequestHandler(CreateMessageRequestSchema2, async (request) => {
       try {
         this.logger.debug("Received sampling request:", request);
-        const samplingRequest = request.params;
-        if (!samplingRequest.messages || !Array.isArray(samplingRequest.messages)) {
-          throw new McpError(
-            "Invalid sampling request: messages array is required",
-            "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
-          );
-        }
-        if (!samplingRequest.maxTokens || samplingRequest.maxTokens <= 0) {
-          throw new McpError(
-            "Invalid sampling request: maxTokens must be a positive number",
-            "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
-          );
-        }
-        const response = await this.samplingHandler({
-          method: request.method,
-          params: request.params
-        });
+        const response = await this.mcpSamplingHandler.handleSamplingRequest(request);
         if (this.config.debug) {
           console.log("\u2705 Sampling request completed successfully");
         }
@@ -3257,16 +3395,22 @@ var McpClientService = class {
       console.log("\u{1F3AF} Sampling handler registered successfully");
     }
   }
+  /**
+   * Set an ADK sampling handler
+   */
   setSamplingHandler(handler) {
-    this.samplingHandler = handler;
+    this.mcpSamplingHandler = new McpSamplingHandler(handler);
     if (this.client) {
       this.setupSamplingHandler(this.client).catch((error) => {
         console.error("Failed to update sampling handler:", error);
       });
     }
   }
+  /**
+   * Remove the sampling handler
+   */
   removeSamplingHandler() {
-    this.samplingHandler = null;
+    this.mcpSamplingHandler = null;
     if (this.client) {
       try {
         this.client.removeRequestHandler?.("sampling/createMessage");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iqai/adk",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Agent Development Kit for TypeScript with multi-provider LLM support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",