@iqai/adk 0.5.6 → 0.5.7

package/dist/index.mjs

@@ -533,7 +533,7 @@ var init_base_tool = __esm({
 });
 
 // src/tools/function/function-utils.ts
-import { Type as Type2 } from "@google/genai";
+import { Type as Type10 } from "@google/genai";
 function buildFunctionDeclaration(func, options = {}) {
   const funcStr = func.toString();
   const name = options.name || func.name;
@@ -554,10 +554,10 @@ function buildFunctionDeclaration(func, options = {}) {
 function extractParametersSchema(func, ignoreParams = []) {
   const funcStr = func.toString();
   const paramMatch = funcStr.match(/\(([^)]*)\)/);
-  if (!paramMatch) return { type: Type2.OBJECT, properties: {} };
+  if (!paramMatch) return { type: Type10.OBJECT, properties: {} };
   const paramList = paramMatch[1].split(",").map((param) => param.trim()).filter((param) => param !== "");
   if (paramList.length === 0 || paramList.length === 1 && paramList[0] === "") {
-    return { type: Type2.OBJECT, properties: {} };
+    return { type: Type10.OBJECT, properties: {} };
   }
   const jsDocParams = extractJSDocParams(funcStr);
   const jsDocTypes = extractJSDocTypes(funcStr);
@@ -597,7 +597,7 @@ function extractParametersSchema(func, ignoreParams = []) {
     }
   }
   const schema = {
-    type: Type2.OBJECT,
+    type: Type10.OBJECT,
     properties
   };
   if (required.length > 0) {
@@ -4666,245 +4666,26 @@ var AgentTool = class extends BaseTool {
   }
 };
 
-// src/tools/tool-context.ts
-var ToolContext = class extends CallbackContext {
-  /**
-   * The function call id of the current tool call. This id was
-   * returned in the function call event from LLM to identify a function call.
-   * If LLM didn't return this id, ADK will assign one to it. This id is used
-   * to map function call response to the original function call.
-   */
-  functionCallId;
-  /**
-   * Constructor for ToolContext
-   */
-  constructor(invocationContext, options = {}) {
-    super(invocationContext, { eventActions: options.eventActions });
-    this.functionCallId = options.functionCallId;
-  }
-  /**
-   * Gets the event actions of the current tool call
-   */
-  get actions() {
-    return this.eventActions;
-  }
-  /**
-   * Lists the filenames of the artifacts attached to the current session
-   */
-  async listArtifacts() {
-    if (!this._invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    return await this._invocationContext.artifactService.listArtifactKeys({
-      appName: this._invocationContext.appName,
-      userId: this._invocationContext.userId,
-      sessionId: this._invocationContext.session.id
-    });
-  }
-  /**
-   * Searches the memory of the current user
-   */
-  async searchMemory(query) {
-    if (!this._invocationContext.memoryService) {
-      throw new Error("Memory service is not available.");
-    }
-    return await this._invocationContext.memoryService.searchMemory({
-      query,
-      appName: this._invocationContext.appName,
-      userId: this._invocationContext.userId
-    });
-  }
-};
-
-// src/tools/index.ts
-init_function_tool();
-
-// src/tools/function/index.ts
-init_function_tool();
-init_function_utils();
-function createFunctionTool(func, options) {
-  const { FunctionTool: FunctionTool2 } = (init_function_tool(), __toCommonJS(function_tool_exports));
-  return new FunctionTool2(func, options);
-}
-
-// src/tools/index.ts
-init_function_utils();
-
-// src/tools/common/google-search.ts
+// src/tools/common/exit-loop-tool.ts
 init_logger();
 init_base_tool();
-import { Type as Type3 } from "@google/genai";
-var GoogleSearch = class extends BaseTool {
-  logger = new Logger({ name: "GoogleSearch" });
-  /**
-   * Constructor for GoogleSearch
-   */
-  constructor() {
-    super({
-      name: "google_search",
-      description: "Search the web using Google"
-    });
-  }
-  /**
-   * Get the function declaration for the tool
-   */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type3.OBJECT,
-        properties: {
-          query: {
-            type: Type3.STRING,
-            description: "The search query to execute"
-          },
-          num_results: {
-            type: Type3.INTEGER,
-            description: "Number of results to return (max 10)",
-            default: 5
-          }
-        },
-        required: ["query"]
-      }
-    };
-  }
+var ExitLoopTool = class extends BaseTool {
+  logger = new Logger({ name: "ExitLoopTool" });
   /**
-   * Execute the search
-   * This is a simplified implementation that doesn't actually search, just returns mock results
+   * Constructor for ExitLoopTool
    */
-  async runAsync(args, _context) {
-    this.logger.debug(
-      `[GoogleSearch] Executing Google search for: ${args.query}`
-    );
-    return {
-      results: [
-        {
-          title: `Result 1 for ${args.query}`,
-          link: "https://example.com/1",
-          snippet: `This is a sample result for the query "${args.query}".`
-        },
-        {
-          title: `Result 2 for ${args.query}`,
-          link: "https://example.com/2",
-          snippet: `Another sample result for "${args.query}".`
-        }
-      ]
-    };
-  }
-};
-
-// src/tools/common/http-request-tool.ts
-init_base_tool();
-import { Type as Type4 } from "@google/genai";
-var HttpRequestTool = class extends BaseTool {
   constructor() {
     super({
-      name: "http_request",
-      description: "Make HTTP requests to external APIs and web services"
+      name: "exit_loop",
+      description: "Exits the loop. Call this function only when you are instructed to do so."
     });
   }
   /**
-   * Get the function declaration for the tool
-   */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type4.OBJECT,
-        properties: {
-          url: {
-            type: Type4.STRING,
-            description: "The URL to send the request to"
-          },
-          method: {
-            type: Type4.STRING,
-            description: "The HTTP method to use (GET, POST, PUT, DELETE, etc.)",
-            enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
-            default: "GET"
-          },
-          headers: {
-            type: Type4.OBJECT,
-            description: "Request headers to include"
-          },
-          body: {
-            type: Type4.STRING,
-            description: "Request body content (as string, typically JSON)"
-          },
-          params: {
-            type: Type4.OBJECT,
-            description: "URL query parameters to include"
-          },
-          timeout: {
-            type: Type4.INTEGER,
-            description: "Request timeout in milliseconds",
-            default: 1e4
-          }
-        },
-        required: ["url"]
-      }
-    };
-  }
-  /**
-   * Execute the HTTP request
-   */
-  async runAsync(args, _context) {
-    try {
-      const {
-        url,
-        method = "GET",
-        headers = {},
-        body,
-        params,
-        timeout = 1e4
-      } = args;
-      const urlObj = new URL(url);
-      if (params) {
-        Object.entries(params).forEach(([key, value]) => {
-          urlObj.searchParams.append(key, value);
-        });
-      }
-      const requestHeaders = { ...headers };
-      if (body && !requestHeaders["Content-Type"] && this.isValidJson(body)) {
-        requestHeaders["Content-Type"] = "application/json";
-      }
-      const options = {
-        method,
-        headers: requestHeaders,
-        body,
-        signal: AbortSignal.timeout(timeout)
-      };
-      const response = await fetch(urlObj.toString(), options);
-      const responseHeaders = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-      });
-      const responseBody = await response.text();
-      return {
-        statusCode: response.status,
-        headers: responseHeaders,
-        body: responseBody
-      };
-    } catch (error) {
-      return {
-        statusCode: 0,
-        headers: {},
-        body: "",
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  /**
-   * Check if a string is valid JSON
+   * Execute the exit loop action
    */
-  isValidJson(str) {
-    try {
-      JSON.parse(str);
-      return true;
-    } catch (e) {
-      return false;
-    }
+  async runAsync(_args, context4) {
+    this.logger.debug("Executing exit loop tool");
+    context4.actions.escalate = true;
   }
 };
 
@@ -4912,7 +4693,7 @@ var HttpRequestTool = class extends BaseTool {
 init_base_tool();
 import fs from "fs/promises";
 import path from "path";
-import { Type as Type5 } from "@google/genai";
+import { Type as Type2 } from "@google/genai";
 var FileOperationsTool = class extends BaseTool {
   basePath;
   constructor(options) {
@@ -4930,10 +4711,10 @@ var FileOperationsTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type5.OBJECT,
+        type: Type2.OBJECT,
         properties: {
           operation: {
-            type: Type5.STRING,
+            type: Type2.STRING,
             description: "The file operation to perform",
             enum: [
               "read",
@@ -4946,15 +4727,15 @@ var FileOperationsTool = class extends BaseTool {
             ]
           },
           filepath: {
-            type: Type5.STRING,
+            type: Type2.STRING,
             description: "Path to the file or directory (relative to the base path)"
           },
           content: {
-            type: Type5.STRING,
+            type: Type2.STRING,
             description: "Content to write to the file (for write and append operations)"
           },
           encoding: {
-            type: Type5.STRING,
+            type: Type2.STRING,
             description: "File encoding to use",
             default: "utf8"
           }
@@ -5158,115 +4939,15 @@ var FileOperationsTool = class extends BaseTool {
   }
 };
 
-// src/tools/common/user-interaction-tool.ts
+// src/tools/common/get-user-choice-tool.ts
+init_logger();
 init_base_tool();
-import { Type as Type6 } from "@google/genai";
-var UserInteractionTool = class extends BaseTool {
-  constructor() {
-    super({
-      name: "user_interaction",
-      description: "Prompt the user for input during agent execution",
-      isLongRunning: true
-    });
-  }
-  /**
-   * Get the function declaration for the tool
-   */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type6.OBJECT,
-        properties: {
-          prompt: {
-            type: Type6.STRING,
-            description: "The prompt message to display to the user"
-          },
-          options: {
-            type: Type6.ARRAY,
-            description: "Optional array of choices to present to the user",
-            items: {
-              type: Type6.STRING
-            }
-          },
-          defaultValue: {
-            type: Type6.STRING,
-            description: "Optional default value for the input field"
-          }
-        },
-        required: ["prompt"]
-      }
-    };
-  }
-  /**
-   * Execute the user interaction
-   */
-  async runAsync(args, context4) {
-    try {
-      const actions = context4.actions;
-      if (!actions || !actions.promptUser) {
-        return {
-          success: false,
-          error: "User interaction is not supported in the current environment"
-        };
-      }
-      if (actions.skipSummarization) {
-        actions.skipSummarization(true);
-      }
-      const promptOptions = args.options && args.options.length > 0 ? {
-        choices: args.options
-      } : void 0;
-      const response = await actions.promptUser({
-        prompt: args.prompt,
-        defaultValue: args.defaultValue,
-        options: promptOptions
-      });
-      return {
-        success: true,
-        userInput: response
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-};
-
-// src/tools/common/exit-loop-tool.ts
-init_logger();
-init_base_tool();
-var ExitLoopTool = class extends BaseTool {
-  logger = new Logger({ name: "ExitLoopTool" });
-  /**
-   * Constructor for ExitLoopTool
-   */
-  constructor() {
-    super({
-      name: "exit_loop",
-      description: "Exits the loop. Call this function only when you are instructed to do so."
-    });
-  }
-  /**
-   * Execute the exit loop action
-   */
-  async runAsync(_args, context4) {
-    this.logger.debug("Executing exit loop tool");
-    context4.actions.escalate = true;
-  }
-};
-
-// src/tools/common/get-user-choice-tool.ts
-init_logger();
-init_base_tool();
-import { Type as Type7 } from "@google/genai";
-var GetUserChoiceTool = class extends BaseTool {
-  logger = new Logger({ name: "GetUserChoiceTool" });
-  /**
-   * Constructor for GetUserChoiceTool
-   */
+import { Type as Type3 } from "@google/genai";
+var GetUserChoiceTool = class extends BaseTool {
+  logger = new Logger({ name: "GetUserChoiceTool" });
+  /**
+   * Constructor for GetUserChoiceTool
+   */
   constructor() {
     super({
       name: "get_user_choice",
@@ -5282,17 +4963,17 @@ var GetUserChoiceTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type7.OBJECT,
+        type: Type3.OBJECT,
         properties: {
           options: {
-            type: Type7.ARRAY,
+            type: Type3.ARRAY,
             description: "List of options for the user to choose from",
             items: {
-              type: Type7.STRING
+              type: Type3.STRING
             }
           },
           question: {
-            type: Type7.STRING,
+            type: Type3.STRING,
             description: "The question or prompt to show the user before presenting options"
           }
         },
@@ -5317,19 +4998,19 @@ var GetUserChoiceTool = class extends BaseTool {
   }
 };
 
-// src/tools/common/transfer-to-agent-tool.ts
+// src/tools/common/google-search.ts
 init_logger();
 init_base_tool();
-import { Type as Type8 } from "@google/genai";
-var TransferToAgentTool = class extends BaseTool {
-  logger = new Logger({ name: "TransferToAgentTool" });
+import { Type as Type4 } from "@google/genai";
+var GoogleSearch = class extends BaseTool {
+  logger = new Logger({ name: "GoogleSearch" });
   /**
-   * Constructor for TransferToAgentTool
+   * Constructor for GoogleSearch
    */
   constructor() {
     super({
-      name: "transfer_to_agent",
-      description: "Transfer the question to another agent when it's more suitable to answer the user's question according to the agent's description. Use this function when you determine that another agent in the system would be better equipped to handle the user's request based on their specialized capabilities and expertise areas."
+      name: "google_search",
+      description: "Search the web using Google"
     });
   }
   /**
@@ -5340,39 +5021,55 @@ var TransferToAgentTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type8.OBJECT,
+        type: Type4.OBJECT,
         properties: {
-          agent_name: {
-            type: Type8.STRING,
-            description: "The name of the agent to transfer control to"
+          query: {
+            type: Type4.STRING,
+            description: "The search query to execute"
+          },
+          num_results: {
+            type: Type4.INTEGER,
+            description: "Number of results to return (max 10)",
+            default: 5
           }
         },
-        required: ["agent_name"]
+        required: ["query"]
       }
     };
   }
   /**
-   * Execute the transfer to agent action
+   * Execute the search
+   * This is a simplified implementation that doesn't actually search, just returns mock results
    */
-  async runAsync(args, context4) {
-    this.logger.debug(`Executing transfer to agent: ${args.agent_name}`);
-    context4.actions.transferToAgent = args.agent_name;
+  async runAsync(args, _context) {
+    this.logger.debug(
+      `[GoogleSearch] Executing Google search for: ${args.query}`
+    );
+    return {
+      results: [
+        {
+          title: `Result 1 for ${args.query}`,
+          link: "https://example.com/1",
+          snippet: `This is a sample result for the query "${args.query}".`
+        },
+        {
+          title: `Result 2 for ${args.query}`,
+          link: "https://example.com/2",
+          snippet: `Another sample result for "${args.query}".`
+        }
+      ]
+    };
   }
 };
 
-// src/tools/common/load-memory-tool.ts
-init_logger();
+// src/tools/common/http-request-tool.ts
 init_base_tool();
-import { Type as Type9 } from "@google/genai";
-var LoadMemoryTool = class extends BaseTool {
-  logger = new Logger({ name: "LoadMemoryTool" });
-  /**
-   * Constructor for LoadMemoryTool
-   */
+import { Type as Type5 } from "@google/genai";
+var HttpRequestTool = class extends BaseTool {
   constructor() {
     super({
-      name: "load_memory",
-      description: "Loads the memory for the current user based on a query."
+      name: "http_request",
+      description: "Make HTTP requests to external APIs and web services"
     });
   }
   /**
@@ -5383,41 +5080,105 @@ var LoadMemoryTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type9.OBJECT,
+        type: Type5.OBJECT,
         properties: {
-          query: {
-            type: Type9.STRING,
-            description: "The query to load memories for"
+          url: {
+            type: Type5.STRING,
+            description: "The URL to send the request to"
+          },
+          method: {
+            type: Type5.STRING,
+            description: "The HTTP method to use (GET, POST, PUT, DELETE, etc.)",
+            enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
+            default: "GET"
+          },
+          headers: {
+            type: Type5.OBJECT,
+            description: "Request headers to include"
+          },
+          body: {
+            type: Type5.STRING,
+            description: "Request body content (as string, typically JSON)"
+          },
+          params: {
+            type: Type5.OBJECT,
+            description: "URL query parameters to include"
+          },
+          timeout: {
+            type: Type5.INTEGER,
+            description: "Request timeout in milliseconds",
+            default: 1e4
           }
         },
-        required: ["query"]
+        required: ["url"]
       }
     };
   }
   /**
-   * Execute the memory loading action
+   * Execute the HTTP request
    */
-  async runAsync(args, context4) {
-    this.logger.debug(`Executing load_memory with query: ${args.query}`);
+  async runAsync(args, _context) {
     try {
-      const searchResult = await context4.searchMemory(args.query);
+      const {
+        url,
+        method = "GET",
+        headers = {},
+        body,
+        params,
+        timeout = 1e4
+      } = args;
+      const urlObj = new URL(url);
+      if (params) {
+        Object.entries(params).forEach(([key, value]) => {
+          urlObj.searchParams.append(key, value);
+        });
+      }
+      const requestHeaders = { ...headers };
+      if (body && !requestHeaders["Content-Type"] && this.isValidJson(body)) {
+        requestHeaders["Content-Type"] = "application/json";
+      }
+      const options = {
+        method,
+        headers: requestHeaders,
+        body,
+        signal: AbortSignal.timeout(timeout)
+      };
+      const response = await fetch(urlObj.toString(), options);
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      const responseBody = await response.text();
       return {
-        memories: searchResult.memories || [],
-        count: searchResult.memories?.length || 0
+        statusCode: response.status,
+        headers: responseHeaders,
+        body: responseBody
       };
     } catch (error) {
-      console.error("Error searching memory:", error);
       return {
-        error: "Memory search failed",
-        message: error instanceof Error ? error.message : String(error)
+        statusCode: 0,
+        headers: {},
+        body: "",
+        error: error instanceof Error ? error.message : String(error)
       };
     }
   }
+  /**
+   * Check if a string is valid JSON
+   */
+  isValidJson(str) {
+    try {
+      JSON.parse(str);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
 };
 
 // src/tools/common/load-artifacts-tool.ts
 init_base_tool();
-import { Type as Type10 } from "@google/genai";
+import { Type as Type6 } from "@google/genai";
 var LoadArtifactsTool = class extends BaseTool {
   constructor() {
     super({
@@ -5433,12 +5194,12 @@ var LoadArtifactsTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type10.OBJECT,
+        type: Type6.OBJECT,
         properties: {
           artifact_names: {
-            type: Type10.ARRAY,
+            type: Type6.ARRAY,
             items: {
-              type: Type10.STRING
+              type: Type6.STRING
             },
             description: "List of artifact names to load"
           }
@@ -5528,10 +5289,197 @@ than the function call.
   }
 };
 
+// src/tools/common/load-memory-tool.ts
+init_logger();
+init_base_tool();
+import { Type as Type7 } from "@google/genai";
+var LoadMemoryTool = class extends BaseTool {
+  logger = new Logger({ name: "LoadMemoryTool" });
+  /**
+   * Constructor for LoadMemoryTool
+   */
+  constructor() {
+    super({
+      name: "load_memory",
+      description: "Loads the memory for the current user based on a query."
+    });
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type7.OBJECT,
+        properties: {
+          query: {
+            type: Type7.STRING,
+            description: "The query to load memories for"
+          }
+        },
+        required: ["query"]
+      }
+    };
+  }
+  /**
+   * Execute the memory loading action
+   */
+  async runAsync(args, context4) {
+    this.logger.debug(`Executing load_memory with query: ${args.query}`);
+    try {
+      const searchResult = await context4.searchMemory(args.query);
+      return {
+        memories: searchResult.memories || [],
+        count: searchResult.memories?.length || 0
+      };
+    } catch (error) {
+      console.error("Error searching memory:", error);
+      return {
+        error: "Memory search failed",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/tools/common/transfer-to-agent-tool.ts
+init_logger();
+init_base_tool();
+import { Type as Type8 } from "@google/genai";
+var TransferToAgentTool = class extends BaseTool {
+  logger = new Logger({ name: "TransferToAgentTool" });
+  /**
+   * Constructor for TransferToAgentTool
+   */
+  constructor() {
+    super({
+      name: "transfer_to_agent",
+      description: "Transfer the question to another agent when it's more suitable to answer the user's question according to the agent's description. Use this function when you determine that another agent in the system would be better equipped to handle the user's request based on their specialized capabilities and expertise areas."
+    });
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type8.OBJECT,
+        properties: {
+          agent_name: {
+            type: Type8.STRING,
+            description: "The name of the agent to transfer control to"
+          }
+        },
+        required: ["agent_name"]
+      }
+    };
+  }
+  /**
+   * Execute the transfer to agent action
+   */
+  async runAsync(args, context4) {
+    this.logger.debug(`Executing transfer to agent: ${args.agent_name}`);
+    context4.actions.transferToAgent = args.agent_name;
+  }
+};
+
+// src/tools/common/user-interaction-tool.ts
+init_base_tool();
+import { Type as Type9 } from "@google/genai";
+var UserInteractionTool = class extends BaseTool {
+  constructor() {
+    super({
+      name: "user_interaction",
+      description: "Prompt the user for input during agent execution",
+      isLongRunning: true
+    });
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type9.OBJECT,
+        properties: {
+          prompt: {
+            type: Type9.STRING,
+            description: "The prompt message to display to the user"
+          },
+          options: {
+            type: Type9.ARRAY,
+            description: "Optional array of choices to present to the user",
+            items: {
+              type: Type9.STRING
+            }
+          },
+          defaultValue: {
+            type: Type9.STRING,
+            description: "Optional default value for the input field"
+          }
+        },
+        required: ["prompt"]
+      }
+    };
+  }
+  /**
+   * Execute the user interaction
+   */
+  async runAsync(args, context4) {
+    try {
+      const actions = context4.actions;
+      if (!actions || !actions.promptUser) {
+        return {
+          success: false,
+          error: "User interaction is not supported in the current environment"
+        };
+      }
+      if (actions.skipSummarization) {
+        actions.skipSummarization(true);
+      }
+      const promptOptions = args.options && args.options.length > 0 ? {
+        choices: args.options
+      } : void 0;
+      const response = await actions.promptUser({
+        prompt: args.prompt,
+        defaultValue: args.defaultValue,
+        options: promptOptions
+      });
+      return {
+        success: true,
+        userInput: response
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/tools/function/index.ts
+init_function_tool();
+init_function_utils();
+function createFunctionTool(func, options) {
+  const { FunctionTool: FunctionTool2 } = (init_function_tool(), __toCommonJS(function_tool_exports));
+  return new FunctionTool2(func, options);
+}
+
+// src/tools/index.ts
+init_function_tool();
+init_function_utils();
+
 // src/tools/mcp/client.ts
 init_logger();
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { CreateMessageRequestSchema as CreateMessageRequestSchema2 } from "@modelcontextprotocol/sdk/types.js";
 
@@ -5683,7 +5631,7 @@ var McpSamplingHandler = class {
       parts: adkParts
     };
     this.logger.debug(
-      `Converted MCP message - role: ${mcpMessage.role} -> ${adkRole}, content type: ${mcpMessage.content.type}`
+      `Converted MCP message - role: ${mcpMessage.role} -> ${adkRole}, content type: ${Array.isArray(mcpMessage.content) ? "array" : mcpMessage.content?.type ?? "unknown"}`
     );
     return adkContent;
   }
@@ -5691,29 +5639,54 @@ var McpSamplingHandler = class {
    * Convert MCP message content to ADK parts format
    */
   convertMcpContentToADKParts(mcpContent) {
-    if (mcpContent.type === "text") {
-      const textContent = mcpContent.text || "";
-      return [{ text: textContent }];
+    const safeText = (value) => typeof value === "string" ? value : "";
+    if (Array.isArray(mcpContent)) {
+      return mcpContent.flatMap((c) => this.convertMcpContentToADKParts(c));
     }
-    if (mcpContent.type === "image") {
-      const parts = [];
-      if (mcpContent.text && typeof mcpContent.text === "string") {
-        parts.push({ text: mcpContent.text });
+    switch (mcpContent.type) {
+      case "text": {
+        return [{ text: safeText(mcpContent.text) }];
       }
-      if (mcpContent.data && typeof mcpContent.data === "string") {
-        const mimeType = mcpContent.mimeType || "image/jpeg";
+      case "image":
+      case "audio": {
+        const parts = [];
+        if ("text" in mcpContent) {
+          const t = safeText(mcpContent.text);
+          if (t) parts.push({ text: t });
+        }
+        const hasData = typeof mcpContent.data === "string" && mcpContent.data.length > 0;
+        if (!hasData) {
+          this.logger.warn(
+            `Missing or invalid 'data' for ${mcpContent.type} content.`
+          );
+          return [
+            ...parts,
+            {
+              text: `[${mcpContent.type.toUpperCase()} CONTENT MISSING DATA]`
+            }
+          ];
+        }
         parts.push({
           inlineData: {
             data: mcpContent.data,
-            mimeType
+            mimeType: safeText(mcpContent.mimeType) || (mcpContent.type === "image" ? "image/jpeg" : "audio/mpeg")
           }
         });
+        return parts;
+      }
+      case "tool_use": {
+        return [{ text: `[Tool Use: ${safeText(mcpContent.name)}]` }];
+      }
+      case "tool_result": {
+        return [{ text: `[Tool Result: ${safeText(mcpContent.toolUseId)}]` }];
+      }
+      default: {
+        this.logger.warn(
+          `Unknown MCP content type: ${safeText(mcpContent.type)}`
+        );
+        return [{ text: "[Unknown content type]" }];
       }
-      return parts.length > 0 ? parts : [{ text: "" }];
     }
-    this.logger.warn(`Unknown MCP content type: ${mcpContent.type}`);
-    const fallbackText = typeof mcpContent.data === "string" ? mcpContent.data : "";
-    return [{ text: fallbackText }];
   }
   /**
    * Convert ADK response to MCP response format
@@ -5825,9 +5798,6 @@ var McpClientService = class {
         },
         {
           capabilities: {
-            prompts: {},
-            resources: {},
-            tools: {},
             sampling: {}
             // Enable sampling capability
           }
@@ -5880,7 +5850,7 @@ var McpClientService = class {
           ...this.config.transport.headers || {},
           ...this.config.headers || {}
         };
-        return new SSEClientTransport(
+        return new StreamableHTTPClientTransport(
           new URL(this.config.transport.serverUrl),
           {
             requestInit: {
@@ -5930,7 +5900,7 @@ var McpClientService = class {
           if (typeof this.client.close === "function") {
             await this.client.close();
           }
-        } catch (err) {
+        } catch (_err) {
         }
       }
       if (this.transport && typeof this.transport.close === "function") {
@@ -6216,7 +6186,7 @@ function mcpSchemaToParameters(mcpTool) {
   let schema;
   if (mcpTool.inputSchema) {
     schema = mcpTool.inputSchema;
-  } else if (mcpTool.parameters) {
+  } else if ("parameters" in mcpTool && mcpTool.parameters) {
     schema = mcpTool.parameters;
   }
   if (!schema) {
@@ -6254,7 +6224,12 @@ var McpToolAdapter = class extends BaseTool {
   toolHandler;
   logger = new Logger({ name: "McpToolAdapter" });
   constructor(mcpTool, client, handler) {
-    const metadata = mcpTool.metadata || {};
+    let metadata = {};
+    if ("metadata" in mcpTool && typeof mcpTool.metadata === "object") {
+      metadata = mcpTool.metadata;
+    } else if (mcpTool._meta && typeof mcpTool._meta === "object") {
+      metadata = mcpTool._meta;
+    }
     super({
       name: mcpTool.name || `mcp_${Date.now()}`,
       description: mcpTool.description || "MCP Tool",
@@ -6288,7 +6263,7 @@ var McpToolAdapter = class extends BaseTool {
   async runAsync(args, _context) {
     this.logger.debug(`Executing MCP tool ${this.name} with args:`, args);
     try {
-      if (typeof this.mcpTool.execute === "function") {
+      if ("execute" in this.mcpTool && typeof this.mcpTool.execute === "function") {
         return await this.mcpTool.execute(args);
       }
       if (this.clientService) {
@@ -6687,6 +6662,56 @@ async function getMcpTools(config, toolFilter) {
   }
 }
 
+// src/tools/tool-context.ts
+var ToolContext = class extends CallbackContext {
+  /**
+   * The function call id of the current tool call. This id was
+   * returned in the function call event from LLM to identify a function call.
+   * If LLM didn't return this id, ADK will assign one to it. This id is used
+   * to map function call response to the original function call.
+   */
+  functionCallId;
+  /**
+   * Constructor for ToolContext
+   */
+  constructor(invocationContext, options = {}) {
+    super(invocationContext, { eventActions: options.eventActions });
+    this.functionCallId = options.functionCallId;
+  }
+  /**
+   * Gets the event actions of the current tool call
+   */
+  get actions() {
+    return this.eventActions;
+  }
+  /**
+   * Lists the filenames of the artifacts attached to the current session
+   */
+  async listArtifacts() {
+    if (!this._invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return await this._invocationContext.artifactService.listArtifactKeys({
+      appName: this._invocationContext.appName,
+      userId: this._invocationContext.userId,
+      sessionId: this._invocationContext.session.id
+    });
+  }
+  /**
+   * Searches the memory of the current user
+   */
+  async searchMemory(query) {
+    if (!this._invocationContext.memoryService) {
+      throw new Error("Memory service is not available.");
+    }
+    return await this._invocationContext.memoryService.searchMemory({
+      query,
+      appName: this._invocationContext.appName,
+      userId: this._invocationContext.userId
+    });
+  }
+};
+
 // src/flows/llm-flows/functions.ts
 import { context as context2, trace as trace2 } from "@opentelemetry/api";
 var AF_FUNCTION_CALL_ID_PREFIX = "adk-";