@iqai/adk 0.5.6 → 0.5.7

package/dist/index.js

@@ -4666,248 +4666,29 @@ var AgentTool = (_class15 = class extends BaseTool {
   }
 }, _class15);
 
-// 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.
-   */
-  
-  /**
-   * 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();
-
-var GoogleSearch = (_class16 = class extends BaseTool {
-  __init26() {this.logger = new Logger({ name: "GoogleSearch" })}
+var ExitLoopTool = (_class16 = class extends BaseTool {
+  __init26() {this.logger = new Logger({ name: "ExitLoopTool" })}
   /**
-   * Constructor for GoogleSearch
+   * Constructor for ExitLoopTool
    */
   constructor() {
     super({
-      name: "google_search",
-      description: "Search the web using Google"
+      name: "exit_loop",
+      description: "Exits the loop. Call this function only when you are instructed to do so."
     });_class16.prototype.__init26.call(this);;
   }
   /**
-   * Get the function declaration for the tool
-   */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: _genai.Type.OBJECT,
-        properties: {
-          query: {
-            type: _genai.Type.STRING,
-            description: "The search query to execute"
-          },
-          num_results: {
-            type: _genai.Type.INTEGER,
-            description: "Number of results to return (max 10)",
-            default: 5
-          }
-        },
-        required: ["query"]
-      }
-    };
-  }
-  /**
-   * Execute the search
-   * This is a simplified implementation that doesn't actually search, just returns mock results
+   * Execute the exit loop action
    */
-  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}".`
-        }
-      ]
-    };
+  async runAsync(_args, context4) {
+    this.logger.debug("Executing exit loop tool");
+    context4.actions.escalate = true;
   }
 }, _class16);
 
-// src/tools/common/http-request-tool.ts
-init_base_tool();
-
-var HttpRequestTool = class extends BaseTool {
-  constructor() {
-    super({
-      name: "http_request",
-      description: "Make HTTP requests to external APIs and web services"
-    });
-  }
-  /**
-   * Get the function declaration for the tool
-   */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: _genai.Type.OBJECT,
-        properties: {
-          url: {
-            type: _genai.Type.STRING,
-            description: "The URL to send the request to"
-          },
-          method: {
-            type: _genai.Type.STRING,
-            description: "The HTTP method to use (GET, POST, PUT, DELETE, etc.)",
-            enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
-            default: "GET"
-          },
-          headers: {
-            type: _genai.Type.OBJECT,
-            description: "Request headers to include"
-          },
-          body: {
-            type: _genai.Type.STRING,
-            description: "Request body content (as string, typically JSON)"
-          },
-          params: {
-            type: _genai.Type.OBJECT,
-            description: "URL query parameters to include"
-          },
-          timeout: {
-            type: _genai.Type.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
-   */
-  isValidJson(str) {
-    try {
-      JSON.parse(str);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-};
-
 // src/tools/common/file-operations-tool.ts
 init_base_tool();
 var _promises = require('fs/promises'); var fs2 = _interopRequireWildcard(_promises);
@@ -5158,112 +4939,12 @@ var FileOperationsTool = class extends BaseTool {
   }
 };
 
-// src/tools/common/user-interaction-tool.ts
-init_base_tool();
-
-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: _genai.Type.OBJECT,
-        properties: {
-          prompt: {
-            type: _genai.Type.STRING,
-            description: "The prompt message to display to the user"
-          },
-          options: {
-            type: _genai.Type.ARRAY,
-            description: "Optional array of choices to present to the user",
-            items: {
-              type: _genai.Type.STRING
-            }
-          },
-          defaultValue: {
-            type: _genai.Type.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 = (_class17 = class extends BaseTool {
-  __init27() {this.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."
-    });_class17.prototype.__init27.call(this);;
-  }
-  /**
-   * Execute the exit loop action
-   */
-  async runAsync(_args, context4) {
-    this.logger.debug("Executing exit loop tool");
-    context4.actions.escalate = true;
-  }
-}, _class17);
-
 // src/tools/common/get-user-choice-tool.ts
 init_logger();
 init_base_tool();
 
-var GetUserChoiceTool = (_class18 = class extends BaseTool {
-  __init28() {this.logger = new Logger({ name: "GetUserChoiceTool" })}
+var GetUserChoiceTool = (_class17 = class extends BaseTool {
+  __init27() {this.logger = new Logger({ name: "GetUserChoiceTool" })}
   /**
    * Constructor for GetUserChoiceTool
    */
@@ -5272,7 +4953,7 @@ var GetUserChoiceTool = (_class18 = class extends BaseTool {
       name: "get_user_choice",
       description: "This tool provides the options to the user and asks them to choose one. Use this tool when you need the user to make a selection between multiple options. Do not list options in your response - use this tool instead.",
       isLongRunning: true
-    });_class18.prototype.__init28.call(this);;
+    });_class17.prototype.__init27.call(this);;
   }
   /**
    * Get the function declaration for the tool
@@ -5315,22 +4996,22 @@ var GetUserChoiceTool = (_class18 = class extends BaseTool {
     context4.actions.skipSummarization = true;
     return null;
   }
-}, _class18);
+}, _class17);
 
-// src/tools/common/transfer-to-agent-tool.ts
+// src/tools/common/google-search.ts
 init_logger();
 init_base_tool();
 
-var TransferToAgentTool = (_class19 = class extends BaseTool {
-  __init29() {this.logger = new Logger({ name: "TransferToAgentTool" })}
+var GoogleSearch = (_class18 = class extends BaseTool {
+  __init28() {this.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."
-    });_class19.prototype.__init29.call(this);;
+      name: "google_search",
+      description: "Search the web using Google"
+    });_class18.prototype.__init28.call(this);;
   }
   /**
    * Get the function declaration for the tool
@@ -5342,38 +5023,54 @@ var TransferToAgentTool = (_class19 = class extends BaseTool {
       parameters: {
         type: _genai.Type.OBJECT,
         properties: {
-          agent_name: {
+          query: {
             type: _genai.Type.STRING,
-            description: "The name of the agent to transfer control to"
+            description: "The search query to execute"
+          },
+          num_results: {
+            type: _genai.Type.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}".`
+        }
+      ]
+    };
   }
-}, _class19);
+}, _class18);
 
-// src/tools/common/load-memory-tool.ts
-init_logger();
+// src/tools/common/http-request-tool.ts
 init_base_tool();
 
-var LoadMemoryTool = (_class20 = class extends BaseTool {
-  __init30() {this.logger = new Logger({ name: "LoadMemoryTool" })}
-  /**
-   * Constructor for LoadMemoryTool
-   */
+var HttpRequestTool = class extends BaseTool {
   constructor() {
     super({
-      name: "load_memory",
-      description: "Loads the memory for the current user based on a query."
-    });_class20.prototype.__init30.call(this);;
+      name: "http_request",
+      description: "Make HTTP requests to external APIs and web services"
+    });
   }
   /**
    * Get the function declaration for the tool
@@ -5385,35 +5082,99 @@ var LoadMemoryTool = (_class20 = class extends BaseTool {
       parameters: {
         type: _genai.Type.OBJECT,
         properties: {
-          query: {
+          url: {
             type: _genai.Type.STRING,
-            description: "The query to load memories for"
+            description: "The URL to send the request to"
+          },
+          method: {
+            type: _genai.Type.STRING,
+            description: "The HTTP method to use (GET, POST, PUT, DELETE, etc.)",
+            enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
+            default: "GET"
+          },
+          headers: {
+            type: _genai.Type.OBJECT,
+            description: "Request headers to include"
+          },
+          body: {
+            type: _genai.Type.STRING,
+            description: "Request body content (as string, typically JSON)"
+          },
+          params: {
+            type: _genai.Type.OBJECT,
+            description: "URL query parameters to include"
+          },
+          timeout: {
+            type: _genai.Type.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: _optionalChain([searchResult, 'access', _165 => _165.memories, 'optionalAccess', _166 => _166.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)
       };
     }
   }
-}, _class20);
+  /**
+   * 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();
@@ -5528,10 +5289,197 @@ than the function call.
   }
 };
 
+// src/tools/common/load-memory-tool.ts
+init_logger();
+init_base_tool();
+
+var LoadMemoryTool = (_class19 = class extends BaseTool {
+  __init29() {this.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."
+    });_class19.prototype.__init29.call(this);;
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: _genai.Type.OBJECT,
+        properties: {
+          query: {
+            type: _genai.Type.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: _optionalChain([searchResult, 'access', _165 => _165.memories, 'optionalAccess', _166 => _166.length]) || 0
+      };
+    } catch (error) {
+      console.error("Error searching memory:", error);
+      return {
+        error: "Memory search failed",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+}, _class19);
+
+// src/tools/common/transfer-to-agent-tool.ts
+init_logger();
+init_base_tool();
+
+var TransferToAgentTool = (_class20 = class extends BaseTool {
+  __init30() {this.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."
+    });_class20.prototype.__init30.call(this);;
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: _genai.Type.OBJECT,
+        properties: {
+          agent_name: {
+            type: _genai.Type.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;
+  }
+}, _class20);
+
+// src/tools/common/user-interaction-tool.ts
+init_base_tool();
+
+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: _genai.Type.OBJECT,
+        properties: {
+          prompt: {
+            type: _genai.Type.STRING,
+            description: "The prompt message to display to the user"
+          },
+          options: {
+            type: _genai.Type.ARRAY,
+            description: "Optional array of choices to present to the user",
+            items: {
+              type: _genai.Type.STRING
+            }
+          },
+          defaultValue: {
+            type: _genai.Type.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();
 var _indexjs = require('@modelcontextprotocol/sdk/client/index.js');
-var _ssejs = require('@modelcontextprotocol/sdk/client/sse.js');
+var _streamableHttpjs = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
 var _stdiojs = require('@modelcontextprotocol/sdk/client/stdio.js');
 var _typesjs = require('@modelcontextprotocol/sdk/types.js');
 
@@ -5683,7 +5631,7 @@ var McpSamplingHandler = (_class21 = 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" : _nullishCoalesce(_optionalChain([mcpMessage, 'access', _167 => _167.content, 'optionalAccess', _168 => _168.type]), () => ( "unknown"))}`
     );
     return adkContent;
   }
@@ -5691,29 +5639,54 @@ var McpSamplingHandler = (_class21 = 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 = (_class22 = class {
         },
         {
           capabilities: {
-            prompts: {},
-            resources: {},
-            tools: {},
             sampling: {}
             // Enable sampling capability
           }
@@ -5880,7 +5850,7 @@ var McpClientService = (_class22 = class {
           ...this.config.transport.headers || {},
           ...this.config.headers || {}
         };
-        return new (0, _ssejs.SSEClientTransport)(
+        return new (0, _streamableHttpjs.StreamableHTTPClientTransport)(
           new URL(this.config.transport.serverUrl),
           {
             requestInit: {
@@ -5930,7 +5900,7 @@ var McpClientService = (_class22 = class {
           if (typeof this.client.close === "function") {
             await this.client.close();
           }
-        } catch (err) {
+        } catch (_err) {
         }
       }
       if (this.transport && typeof this.transport.close === "function") {
@@ -5960,7 +5930,7 @@ var McpClientService = (_class22 = class {
         },
         this,
         async (instance) => await instance.reinitialize(),
-        _optionalChain([this, 'access', _167 => _167.config, 'access', _168 => _168.retryOptions, 'optionalAccess', _169 => _169.maxRetries]) || 2
+        _optionalChain([this, 'access', _169 => _169.config, 'access', _170 => _170.retryOptions, 'optionalAccess', _171 => _171.maxRetries]) || 2
       );
       return await wrappedCall();
     } catch (error) {
@@ -6044,7 +6014,7 @@ var McpClientService = (_class22 = class {
     this.mcpSamplingHandler = null;
     if (this.client) {
       try {
-        _optionalChain([this, 'access', _170 => _170.client, 'access', _171 => _171.removeRequestHandler, 'optionalCall', _172 => _172("sampling/createMessage")]);
+        _optionalChain([this, 'access', _172 => _172.client, 'access', _173 => _173.removeRequestHandler, 'optionalCall', _174 => _174("sampling/createMessage")]);
       } catch (error) {
         this.logger.error("Failed to remove sampling handler:", error);
       }
@@ -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 = (_class23 = class extends BaseTool {
   
   __init38() {this.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 = (_class23 = 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) {
@@ -6588,7 +6563,7 @@ var McpToolset = (_class24 = class {
           "resource_closed_error" /* RESOURCE_CLOSED_ERROR */
         );
       }
-      if (this.tools.length > 0 && !_optionalChain([this, 'access', _173 => _173.config, 'access', _174 => _174.cacheConfig, 'optionalAccess', _175 => _175.enabled]) === false) {
+      if (this.tools.length > 0 && !_optionalChain([this, 'access', _175 => _175.config, 'access', _176 => _176.cacheConfig, 'optionalAccess', _177 => _177.enabled]) === false) {
         return this.tools;
       }
       if (!this.clientService) {
@@ -6617,7 +6592,7 @@ var McpToolset = (_class24 = class {
           }
         }
       }
-      if (_optionalChain([this, 'access', _176 => _176.config, 'access', _177 => _177.cacheConfig, 'optionalAccess', _178 => _178.enabled]) !== false) {
+      if (_optionalChain([this, 'access', _178 => _178.config, 'access', _179 => _179.cacheConfig, 'optionalAccess', _180 => _180.enabled]) !== false) {
         this.tools = tools;
       }
       return tools;
@@ -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.
+   */
+  
+  /**
+   * 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
 
 var AF_FUNCTION_CALL_ID_PREFIX = "adk-";
@@ -6706,12 +6731,12 @@ function populateClientFunctionCallId(modelResponseEvent) {
   }
 }
 function removeClientFunctionCallId(content) {
-  if (_optionalChain([content, 'optionalAccess', _179 => _179.parts])) {
+  if (_optionalChain([content, 'optionalAccess', _181 => _181.parts])) {
     for (const part of content.parts) {
-      if (_optionalChain([part, 'access', _180 => _180.functionCall, 'optionalAccess', _181 => _181.id, 'optionalAccess', _182 => _182.startsWith, 'call', _183 => _183(AF_FUNCTION_CALL_ID_PREFIX)])) {
+      if (_optionalChain([part, 'access', _182 => _182.functionCall, 'optionalAccess', _183 => _183.id, 'optionalAccess', _184 => _184.startsWith, 'call', _185 => _185(AF_FUNCTION_CALL_ID_PREFIX)])) {
         part.functionCall.id = void 0;
       }
-      if (_optionalChain([part, 'access', _184 => _184.functionResponse, 'optionalAccess', _185 => _185.id, 'optionalAccess', _186 => _186.startsWith, 'call', _187 => _187(AF_FUNCTION_CALL_ID_PREFIX)])) {
+      if (_optionalChain([part, 'access', _186 => _186.functionResponse, 'optionalAccess', _187 => _187.id, 'optionalAccess', _188 => _188.startsWith, 'call', _189 => _189(AF_FUNCTION_CALL_ID_PREFIX)])) {
         part.functionResponse.id = void 0;
       }
     }
@@ -6906,7 +6931,7 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
   }
   const mergedParts = [];
   for (const event of functionResponseEvents) {
-    if (_optionalChain([event, 'access', _188 => _188.content, 'optionalAccess', _189 => _189.parts])) {
+    if (_optionalChain([event, 'access', _190 => _190.content, 'optionalAccess', _191 => _191.parts])) {
       for (const part of event.content.parts) {
         mergedParts.push(part);
       }
@@ -7027,7 +7052,7 @@ var BaseLlmFlow = (_class25 = class {constructor() { _class25.prototype.__init43
       const seen = /* @__PURE__ */ new Set();
       const filtered = [];
       for (const t of tools) {
-        const name = _optionalChain([t, 'optionalAccess', _190 => _190.name]);
+        const name = _optionalChain([t, 'optionalAccess', _192 => _192.name]);
         if (!name) continue;
         if (seen.has(name)) {
           continue;
@@ -7044,7 +7069,7 @@ var BaseLlmFlow = (_class25 = class {constructor() { _class25.prototype.__init43
     if (tools.length > 0) {
       const toolsData = tools.map((tool) => ({
         Name: tool.name,
-        Description: _optionalChain([tool, 'access', _191 => _191.description, 'optionalAccess', _192 => _192.substring, 'call', _193 => _193(0, 50)]) + (_optionalChain([tool, 'access', _194 => _194.description, 'optionalAccess', _195 => _195.length]) > 50 ? "..." : ""),
+        Description: _optionalChain([tool, 'access', _193 => _193.description, 'optionalAccess', _194 => _194.substring, 'call', _195 => _195(0, 50)]) + (_optionalChain([tool, 'access', _196 => _196.description, 'optionalAccess', _197 => _197.length]) > 50 ? "..." : ""),
         "Long Running": tool.isLongRunning ? "Yes" : "No"
       }));
       this.logger.debugArray("\u{1F6E0}\uFE0F Available Tools", toolsData);
@@ -7107,14 +7132,14 @@ var BaseLlmFlow = (_class25 = class {constructor() { _class25.prototype.__init43
       );
       if (functionResponseEvent) {
         yield functionResponseEvent;
-        const transferToAgent = _optionalChain([functionResponseEvent, 'access', _196 => _196.actions, 'optionalAccess', _197 => _197.transferToAgent]);
+        const transferToAgent = _optionalChain([functionResponseEvent, 'access', _198 => _198.actions, 'optionalAccess', _199 => _199.transferToAgent]);
         if (transferToAgent) {
           this.logger.debug(`\u{1F504} Live transfer to agent '${transferToAgent}'`);
           const agentToRun = this._getAgentToRun(
             invocationContext,
             transferToAgent
           );
-          for await (const event of _optionalChain([agentToRun, 'access', _198 => _198.runLive, 'optionalCall', _199 => _199(invocationContext)]) || agentToRun.runAsync(invocationContext)) {
+          for await (const event of _optionalChain([agentToRun, 'access', _200 => _200.runLive, 'optionalCall', _201 => _201(invocationContext)]) || agentToRun.runAsync(invocationContext)) {
             yield event;
           }
         }
@@ -7146,7 +7171,7 @@ var BaseLlmFlow = (_class25 = class {constructor() { _class25.prototype.__init43
         yield authEvent;
       }
       yield functionResponseEvent;
-      const transferToAgent = _optionalChain([functionResponseEvent, 'access', _200 => _200.actions, 'optionalAccess', _201 => _201.transferToAgent]);
+      const transferToAgent = _optionalChain([functionResponseEvent, 'access', _202 => _202.actions, 'optionalAccess', _203 => _203.transferToAgent]);
       if (transferToAgent) {
         this.logger.debug(`\u{1F504} Transferring to agent '${transferToAgent}'`);
         const agentToRun = this._getAgentToRun(
@@ -7192,7 +7217,7 @@ var BaseLlmFlow = (_class25 = class {constructor() { _class25.prototype.__init43
     }
     invocationContext.incrementLlmCallCount();
     const isStreaming = invocationContext.runConfig.streamingMode === "sse" /* SSE */;
-    let tools = _optionalChain([llmRequest, 'access', _202 => _202.config, 'optionalAccess', _203 => _203.tools]) || [];
+    let tools = _optionalChain([llmRequest, 'access', _204 => _204.config, 'optionalAccess', _205 => _205.tools]) || [];
     if (tools.length) {
       const deduped = [];
       const seenFn = /* @__PURE__ */ new Set();
@@ -7201,7 +7226,7 @@ var BaseLlmFlow = (_class25 = class {constructor() { _class25.prototype.__init43
         if (tool && Array.isArray(tool.functionDeclarations)) {
           const newFds = tool.functionDeclarations.filter(
             (fd) => {
-              if (_optionalChain([fd, 'optionalAccess', _204 => _204.name])) {
+              if (_optionalChain([fd, 'optionalAccess', _206 => _206.name])) {
                 if (seenFn.has(fd.name)) {
                   return false;
                 }
@@ -7213,7 +7238,7 @@ var BaseLlmFlow = (_class25 = class {constructor() { _class25.prototype.__init43
           if (newFds.length) {
             deduped.push({ ...tool, functionDeclarations: newFds });
           }
-        } else if (_optionalChain([tool, 'optionalAccess', _205 => _205.name])) {
+        } else if (_optionalChain([tool, 'optionalAccess', _207 => _207.name])) {
           if (seenFn.has(tool.name)) continue;
           seenFn.add(tool.name);
           deduped.push(tool);
@@ -7233,21 +7258,21 @@ var BaseLlmFlow = (_class25 = class {constructor() { _class25.prototype.__init43
         return tool.functionDeclarations.map((fn) => fn.name).join(", ");
       }
       if (tool.name) return tool.name;
-      if (_optionalChain([tool, 'access', _206 => _206.function, 'optionalAccess', _207 => _207.name])) return tool.function.name;
-      if (_optionalChain([tool, 'access', _208 => _208.function, 'optionalAccess', _209 => _209.function, 'optionalAccess', _210 => _210.name])) return tool.function.function.name;
+      if (_optionalChain([tool, 'access', _208 => _208.function, 'optionalAccess', _209 => _209.name])) return tool.function.name;
+      if (_optionalChain([tool, 'access', _210 => _210.function, 'optionalAccess', _211 => _211.function, 'optionalAccess', _212 => _212.name])) return tool.function.function.name;
       return "unknown";
     }).join(", ");
     const systemInstruction = llmRequest.getSystemInstructionText() || "";
     const truncatedSystemInstruction = systemInstruction.length > 100 ? `${systemInstruction.substring(0, 100)}...` : systemInstruction;
-    const contentPreview = _optionalChain([llmRequest, 'access', _211 => _211.contents, 'optionalAccess', _212 => _212.length]) > 0 ? LogFormatter.formatContentPreview(llmRequest.contents[0]) : "none";
+    const contentPreview = _optionalChain([llmRequest, 'access', _213 => _213.contents, 'optionalAccess', _214 => _214.length]) > 0 ? LogFormatter.formatContentPreview(llmRequest.contents[0]) : "none";
     this.logger.debugStructured("\u{1F4E4} LLM Request", {
       Model: llm.model,
       Agent: invocationContext.agent.name,
-      "Content Items": _optionalChain([llmRequest, 'access', _213 => _213.contents, 'optionalAccess', _214 => _214.length]) || 0,
+      "Content Items": _optionalChain([llmRequest, 'access', _215 => _215.contents, 'optionalAccess', _216 => _216.length]) || 0,
       "Content Preview": contentPreview,
       "System Instruction": truncatedSystemInstruction || "none",
       "Available Tools": toolNames || "none",
-      "Tool Count": _optionalChain([llmRequest, 'access', _215 => _215.config, 'optionalAccess', _216 => _216.tools, 'optionalAccess', _217 => _217.length]) || 0,
+      "Tool Count": _optionalChain([llmRequest, 'access', _217 => _217.config, 'optionalAccess', _218 => _218.tools, 'optionalAccess', _219 => _219.length]) || 0,
       Streaming: isStreaming ? "Yes" : "No"
     });
     let responseCount = 0;
@@ -7262,8 +7287,8 @@ var BaseLlmFlow = (_class25 = class {constructor() { _class25.prototype.__init43
         llmRequest,
         llmResponse
       );
-      const tokenCount = _optionalChain([llmResponse, 'access', _218 => _218.usageMetadata, 'optionalAccess', _219 => _219.totalTokenCount]) || "unknown";
-      const functionCalls = _optionalChain([llmResponse, 'access', _220 => _220.content, 'optionalAccess', _221 => _221.parts, 'optionalAccess', _222 => _222.filter, 'call', _223 => _223((part) => part.functionCall)]) || [];
+      const tokenCount = _optionalChain([llmResponse, 'access', _220 => _220.usageMetadata, 'optionalAccess', _221 => _221.totalTokenCount]) || "unknown";
+      const functionCalls = _optionalChain([llmResponse, 'access', _222 => _222.content, 'optionalAccess', _223 => _223.parts, 'optionalAccess', _224 => _224.filter, 'call', _225 => _225((part) => part.functionCall)]) || [];
       const functionCallsDisplay = LogFormatter.formatFunctionCalls(functionCalls);
       const responsePreview = LogFormatter.formatResponsePreview(llmResponse);
       this.logger.debugStructured("\u{1F4E5} LLM Response", {
@@ -7407,7 +7432,7 @@ var EnhancedAuthConfig = class {
    */
   generateCredentialKey() {
     const schemeKey = this.authScheme.type || "unknown";
-    const credentialKey = _optionalChain([this, 'access', _224 => _224.rawAuthCredential, 'optionalAccess', _225 => _225.type]) || "none";
+    const credentialKey = _optionalChain([this, 'access', _226 => _226.rawAuthCredential, 'optionalAccess', _227 => _227.type]) || "none";
     const timestamp = Date.now();
     return `adk_${schemeKey}_${credentialKey}_${timestamp}`;
   }
@@ -7564,7 +7589,7 @@ var AuthLlmRequestProcessor = class extends BaseLlmRequestProcessor {
    */
   parseAndStoreAuthResponse(authHandler, invocationContext) {
     try {
-      const credentialKey = _optionalChain([authHandler, 'access', _226 => _226.authConfig, 'access', _227 => _227.context, 'optionalAccess', _228 => _228.credentialKey]) || `temp:${Date.now()}`;
+      const credentialKey = _optionalChain([authHandler, 'access', _228 => _228.authConfig, 'access', _229 => _229.context, 'optionalAccess', _230 => _230.credentialKey]) || `temp:${Date.now()}`;
       const fullCredentialKey = credentialKey.startsWith("temp:") ? credentialKey : `temp:${credentialKey}`;
       invocationContext.session.state[fullCredentialKey] = authHandler.credential;
       if (authHandler.authConfig.authScheme.type === "oauth2" || authHandler.authConfig.authScheme.type === "openIdConnect") {
@@ -7593,7 +7618,7 @@ var BasicLlmRequestProcessor = class extends BaseLlmRequestProcessor {
       llmRequest.config = {};
     }
     if (agent.outputSchema) {
-      const hasTools = await _asyncOptionalChain([(await _optionalChain([agent, 'access', _229 => _229.canonicalTools, 'optionalCall', _230 => _230(invocationContext)])), 'optionalAccess', async _231 => _231.length]) > 0;
+      const hasTools = await _asyncOptionalChain([(await _optionalChain([agent, 'access', _231 => _231.canonicalTools, 'optionalCall', _232 => _232(invocationContext)])), 'optionalAccess', async _233 => _233.length]) > 0;
       const hasTransfers = !!("subAgents" in agent && agent.subAgents && agent.subAgents.length > 0 && !(agent.disallowTransferToParent && agent.disallowTransferToPeers));
       if (!hasTools && !hasTransfers) {
         llmRequest.setOutputSchema(agent.outputSchema);
@@ -7685,7 +7710,7 @@ var BuiltInCodeExecutor = class extends BaseCodeExecutor {
    * Pre-process the LLM request for Gemini 2.0+ models to use the code execution tool
    */
   processLlmRequest(llmRequest) {
-    if (!_optionalChain([llmRequest, 'access', _232 => _232.model, 'optionalAccess', _233 => _233.startsWith, 'call', _234 => _234("gemini-2")])) {
+    if (!_optionalChain([llmRequest, 'access', _234 => _234.model, 'optionalAccess', _235 => _235.startsWith, 'call', _236 => _236("gemini-2")])) {
       throw new Error(
         `Gemini code execution tool is not supported for model ${llmRequest.model}`
       );
@@ -7730,7 +7755,7 @@ var CodeExecutionUtils = class _CodeExecutionUtils {
    * Extracts the first code block from the content and truncates everything after it
    */
   static extractCodeAndTruncateContent(content, codeBlockDelimiters) {
-    if (!_optionalChain([content, 'optionalAccess', _235 => _235.parts, 'optionalAccess', _236 => _236.length])) {
+    if (!_optionalChain([content, 'optionalAccess', _237 => _237.parts, 'optionalAccess', _238 => _238.length])) {
       return null;
     }
     for (let idx = 0; idx < content.parts.length; idx++) {
@@ -7816,7 +7841,7 @@ ${fileNames}`);
    * Converts the code execution parts to text parts in a Content
    */
   static convertCodeExecutionParts(content, codeBlockDelimiter, executionResultDelimiters) {
-    if (!_optionalChain([content, 'access', _237 => _237.parts, 'optionalAccess', _238 => _238.length])) {
+    if (!_optionalChain([content, 'access', _239 => _239.parts, 'optionalAccess', _240 => _240.length])) {
       return;
     }
     const lastPart = content.parts[content.parts.length - 1];
@@ -8209,7 +8234,7 @@ async function* runPostProcessor(invocationContext, llmResponse) {
 function extractAndReplaceInlineFiles(codeExecutorContext, llmRequest) {
   const allInputFiles = codeExecutorContext.getInputFiles();
   const savedFileNames = new Set(allInputFiles.map((f) => f.name));
-  for (let i = 0; i < (_optionalChain([llmRequest, 'access', _239 => _239.contents, 'optionalAccess', _240 => _240.length]) || 0); i++) {
+  for (let i = 0; i < (_optionalChain([llmRequest, 'access', _241 => _241.contents, 'optionalAccess', _242 => _242.length]) || 0); i++) {
     const content = llmRequest.contents[i];
     if (content.role !== "user" || !content.parts) {
       continue;
@@ -8241,7 +8266,7 @@ Available file: \`${fileName}\`
 }
 function getOrSetExecutionId(invocationContext, codeExecutorContext) {
   const agent = invocationContext.agent;
-  if (!hasCodeExecutor(agent) || !_optionalChain([agent, 'access', _241 => _241.codeExecutor, 'optionalAccess', _242 => _242.stateful])) {
+  if (!hasCodeExecutor(agent) || !_optionalChain([agent, 'access', _243 => _243.codeExecutor, 'optionalAccess', _244 => _244.stateful])) {
     return void 0;
   }
   let executionId = codeExecutorContext.getExecutionId();
@@ -8472,7 +8497,7 @@ function rearrangeEventsForLatestFunctionResponse(events) {
       continue;
     }
     const functionResponses2 = event.getFunctionResponses();
-    if (_optionalChain([functionResponses2, 'optionalAccess', _243 => _243.some, 'call', _244 => _244((fr) => fr.id && functionResponsesIds.has(fr.id))])) {
+    if (_optionalChain([functionResponses2, 'optionalAccess', _245 => _245.some, 'call', _246 => _246((fr) => fr.id && functionResponsesIds.has(fr.id))])) {
       functionResponseEvents.push(event);
     }
   }
@@ -8492,7 +8517,7 @@ function getContents(currentBranch, events, agentName = "") {
   let i = events.length - 1;
   while (i >= 0) {
     const event = events[i];
-    if (_optionalChain([event, 'access', _245 => _245.actions, 'optionalAccess', _246 => _246.rewindBeforeInvocationId])) {
+    if (_optionalChain([event, 'access', _247 => _247.actions, 'optionalAccess', _248 => _248.rewindBeforeInvocationId])) {
       const rewindInvocationId = event.actions.rewindBeforeInvocationId;
       const rewindIndex = invocationIdToIndex.get(rewindInvocationId);
       if (rewindIndex !== void 0 && rewindIndex < i) {
@@ -8594,7 +8619,7 @@ function mergeFunctionResponseEvents(functionResponseEvents) {
   const partIndicesInMergedEvent = {};
   for (let idx = 0; idx < partsInMergedEvent.length; idx++) {
     const part = partsInMergedEvent[idx];
-    if (_optionalChain([part, 'access', _247 => _247.functionResponse, 'optionalAccess', _248 => _248.id])) {
+    if (_optionalChain([part, 'access', _249 => _249.functionResponse, 'optionalAccess', _250 => _250.id])) {
       partIndicesInMergedEvent[part.functionResponse.id] = idx;
     }
   }
@@ -8603,7 +8628,7 @@ function mergeFunctionResponseEvents(functionResponseEvents) {
       throw new Error("There should be at least one function_response part.");
     }
     for (const part of event.content.parts) {
-      if (_optionalChain([part, 'access', _249 => _249.functionResponse, 'optionalAccess', _250 => _250.id])) {
+      if (_optionalChain([part, 'access', _251 => _251.functionResponse, 'optionalAccess', _252 => _252.id])) {
         const functionCallId = part.functionResponse.id;
         if (functionCallId in partIndicesInMergedEvent) {
           partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = part;
@@ -8643,7 +8668,7 @@ function processCompactionEvents(events) {
   let lastCompactionStartTime = Number.POSITIVE_INFINITY;
   for (let i = events.length - 1; i >= 0; i--) {
     const event = events[i];
-    if (_optionalChain([event, 'access', _251 => _251.actions, 'optionalAccess', _252 => _252.compaction])) {
+    if (_optionalChain([event, 'access', _253 => _253.actions, 'optionalAccess', _254 => _254.compaction])) {
       const compaction = event.actions.compaction;
       const synthesizedEvent = new Event({
         timestamp: compaction.endTimestamp,
@@ -8965,7 +8990,7 @@ var PlanReActPlanner = class extends BasePlanner {
     let firstFcPartIndex = -1;
     for (let i = 0; i < responseParts.length; i++) {
       if (responseParts[i].functionCall) {
-        if (!_optionalChain([responseParts, 'access', _253 => _253[i], 'access', _254 => _254.functionCall, 'optionalAccess', _255 => _255.name])) {
+        if (!_optionalChain([responseParts, 'access', _255 => _255[i], 'access', _256 => _256.functionCall, 'optionalAccess', _257 => _257.name])) {
           continue;
         }
         preservedParts.push(responseParts[i]);
@@ -9004,7 +9029,7 @@ var PlanReActPlanner = class extends BasePlanner {
    * Handles non-function-call parts of the response
    */
   _handleNonFunctionCallParts(responsePart, preservedParts) {
-    if (_optionalChain([responsePart, 'access', _256 => _256.text, 'optionalAccess', _257 => _257.includes, 'call', _258 => _258(FINAL_ANSWER_TAG)])) {
+    if (_optionalChain([responsePart, 'access', _258 => _258.text, 'optionalAccess', _259 => _259.includes, 'call', _260 => _260(FINAL_ANSWER_TAG)])) {
       const [reasoningText, finalAnswerText] = this._splitByLastPattern(
         responsePart.text,
         FINAL_ANSWER_TAG
@@ -9243,7 +9268,7 @@ var OutputSchemaResponseProcessor = (_class26 = class extends BaseLlmResponsePro
   stripCodeFences(raw) {
     const fencePattern = /```(?:json)?\s*([\s\S]*?)```/i;
     const fenceMatch = raw.match(fencePattern);
-    if (_optionalChain([fenceMatch, 'optionalAccess', _259 => _259[1]])) {
+    if (_optionalChain([fenceMatch, 'optionalAccess', _261 => _261[1]])) {
       return fenceMatch[1].trim();
     }
     const lines = raw.split(/\r?\n/).map((l) => l.trim());
@@ -9280,7 +9305,7 @@ var SharedMemoryRequestProcessor = class extends BaseLlmRequestProcessor {
     const memoryService = invocationContext.memoryService;
     if (!memoryService) return;
     const lastUserEvent = invocationContext.session.events.findLast(
-      (e) => e.author === "user" && _optionalChain([e, 'access', _260 => _260.content, 'optionalAccess', _261 => _261.parts, 'optionalAccess', _262 => _262.length])
+      (e) => e.author === "user" && _optionalChain([e, 'access', _262 => _262.content, 'optionalAccess', _263 => _263.parts, 'optionalAccess', _264 => _264.length])
     );
     if (!lastUserEvent) return;
     const query = (_nullishCoalesce(lastUserEvent.content.parts, () => ( []))).map((p) => p.text || "").join(" ");
@@ -9291,7 +9316,7 @@ var SharedMemoryRequestProcessor = class extends BaseLlmRequestProcessor {
     });
     const sessionTexts = new Set(
       (llmRequest.contents || []).flatMap(
-        (c) => _optionalChain([c, 'access', _263 => _263.parts, 'optionalAccess', _264 => _264.map, 'call', _265 => _265((p) => p.text)]) || []
+        (c) => _optionalChain([c, 'access', _265 => _265.parts, 'optionalAccess', _266 => _266.map, 'call', _267 => _267((p) => p.text)]) || []
       )
     );
     for (const memory of results.memories) {
@@ -9712,7 +9737,7 @@ var LlmAgent = (_class27 = class _LlmAgent extends BaseAgent {
    * This matches the Python implementation's _llm_flow property
    */
   get llmFlow() {
-    if (this.disallowTransferToParent && this.disallowTransferToPeers && !_optionalChain([this, 'access', _266 => _266.subAgents, 'optionalAccess', _267 => _267.length])) {
+    if (this.disallowTransferToParent && this.disallowTransferToPeers && !_optionalChain([this, 'access', _268 => _268.subAgents, 'optionalAccess', _269 => _269.length])) {
       return new SingleFlow();
     }
     return new AutoFlow();
@@ -9728,7 +9753,7 @@ var LlmAgent = (_class27 = class _LlmAgent extends BaseAgent {
       );
       return;
     }
-    if (this.outputKey && event.isFinalResponse() && _optionalChain([event, 'access', _268 => _268.content, 'optionalAccess', _269 => _269.parts])) {
+    if (this.outputKey && event.isFinalResponse() && _optionalChain([event, 'access', _270 => _270.content, 'optionalAccess', _271 => _271.parts])) {
       let result = event.content.parts.map((part) => part.text || "").join("");
       if (this.outputSchema) {
         if (!result.trim()) {
@@ -9948,7 +9973,7 @@ var LoopAgent = class extends BaseAgent {
       for (const subAgent of this.subAgents) {
         for await (const event of subAgent.runAsync(ctx)) {
           yield event;
-          if (_optionalChain([event, 'access', _270 => _270.actions, 'optionalAccess', _271 => _271.escalate])) {
+          if (_optionalChain([event, 'access', _272 => _272.actions, 'optionalAccess', _273 => _273.escalate])) {
             return;
           }
         }
@@ -10260,17 +10285,17 @@ var RunConfig = class {
    */
   
   constructor(config) {
-    this.speechConfig = _optionalChain([config, 'optionalAccess', _272 => _272.speechConfig]);
-    this.responseModalities = _optionalChain([config, 'optionalAccess', _273 => _273.responseModalities]);
-    this.saveInputBlobsAsArtifacts = _optionalChain([config, 'optionalAccess', _274 => _274.saveInputBlobsAsArtifacts]) || false;
-    this.supportCFC = _optionalChain([config, 'optionalAccess', _275 => _275.supportCFC]) || false;
-    this.streamingMode = _optionalChain([config, 'optionalAccess', _276 => _276.streamingMode]) || "NONE" /* NONE */;
-    this.outputAudioTranscription = _optionalChain([config, 'optionalAccess', _277 => _277.outputAudioTranscription]);
-    this.inputAudioTranscription = _optionalChain([config, 'optionalAccess', _278 => _278.inputAudioTranscription]);
-    this.realtimeInputConfig = _optionalChain([config, 'optionalAccess', _279 => _279.realtimeInputConfig]);
-    this.enableAffectiveDialog = _optionalChain([config, 'optionalAccess', _280 => _280.enableAffectiveDialog]);
-    this.proactivity = _optionalChain([config, 'optionalAccess', _281 => _281.proactivity]);
-    this.maxLlmCalls = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _282 => _282.maxLlmCalls]), () => ( 500));
+    this.speechConfig = _optionalChain([config, 'optionalAccess', _274 => _274.speechConfig]);
+    this.responseModalities = _optionalChain([config, 'optionalAccess', _275 => _275.responseModalities]);
+    this.saveInputBlobsAsArtifacts = _optionalChain([config, 'optionalAccess', _276 => _276.saveInputBlobsAsArtifacts]) || false;
+    this.supportCFC = _optionalChain([config, 'optionalAccess', _277 => _277.supportCFC]) || false;
+    this.streamingMode = _optionalChain([config, 'optionalAccess', _278 => _278.streamingMode]) || "NONE" /* NONE */;
+    this.outputAudioTranscription = _optionalChain([config, 'optionalAccess', _279 => _279.outputAudioTranscription]);
+    this.inputAudioTranscription = _optionalChain([config, 'optionalAccess', _280 => _280.inputAudioTranscription]);
+    this.realtimeInputConfig = _optionalChain([config, 'optionalAccess', _281 => _281.realtimeInputConfig]);
+    this.enableAffectiveDialog = _optionalChain([config, 'optionalAccess', _282 => _282.enableAffectiveDialog]);
+    this.proactivity = _optionalChain([config, 'optionalAccess', _283 => _283.proactivity]);
+    this.maxLlmCalls = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _284 => _284.maxLlmCalls]), () => ( 500));
     this.validateMaxLlmCalls();
   }
   /**
@@ -10328,7 +10353,7 @@ function getArtifactUri(args) {
 }
 function isArtifactRef(artifact) {
   return Boolean(
-    _optionalChain([artifact, 'access', _283 => _283.fileData, 'optionalAccess', _284 => _284.fileUri]) && artifact.fileData.fileUri.startsWith("artifact://")
+    _optionalChain([artifact, 'access', _285 => _285.fileData, 'optionalAccess', _286 => _286.fileUri]) && artifact.fileData.fileUri.startsWith("artifact://")
   );
 }
 
@@ -10377,10 +10402,10 @@ var InMemoryArtifactService = (_class29 = class {constructor() { _class29.protot
       return null;
     }
     if (isArtifactRef(artifactEntry)) {
-      const parsedUri = parseArtifactUri(_optionalChain([artifactEntry, 'access', _285 => _285.fileData, 'optionalAccess', _286 => _286.fileUri]) || "");
+      const parsedUri = parseArtifactUri(_optionalChain([artifactEntry, 'access', _287 => _287.fileData, 'optionalAccess', _288 => _288.fileUri]) || "");
       if (!parsedUri) {
         throw new Error(
-          `Invalid artifact reference URI: ${_optionalChain([artifactEntry, 'access', _287 => _287.fileData, 'optionalAccess', _288 => _288.fileUri])}`
+          `Invalid artifact reference URI: ${_optionalChain([artifactEntry, 'access', _289 => _289.fileData, 'optionalAccess', _290 => _290.fileUri])}`
         );
       }
       return await this.loadArtifact({
@@ -10391,7 +10416,7 @@ var InMemoryArtifactService = (_class29 = class {constructor() { _class29.protot
         version: parsedUri.version
       });
     }
-    if (!artifactEntry.text && (!_optionalChain([artifactEntry, 'access', _289 => _289.inlineData, 'optionalAccess', _290 => _290.data]) || artifactEntry.inlineData.data.length === 0) && !artifactEntry.fileData) {
+    if (!artifactEntry.text && (!_optionalChain([artifactEntry, 'access', _291 => _291.inlineData, 'optionalAccess', _292 => _292.data]) || artifactEntry.inlineData.data.length === 0) && !artifactEntry.fileData) {
       return null;
     }
     return artifactEntry;
@@ -10478,7 +10503,7 @@ var InMemoryMemoryService = (_class30 = class {
     }
     const userSessions = this._sessionEvents.get(userKey);
     const filteredEvents = session.events.filter(
-      (event) => _optionalChain([event, 'access', _291 => _291.content, 'optionalAccess', _292 => _292.parts])
+      (event) => _optionalChain([event, 'access', _293 => _293.content, 'optionalAccess', _294 => _294.parts])
     );
     userSessions.set(session.id, filteredEvents);
   }
@@ -10622,7 +10647,7 @@ var InMemorySessionService = (_class31 = class extends BaseSessionService {const
     return this.createSessionImpl(appName, userId, state, sessionId);
   }
   createSessionImpl(appName, userId, state, sessionId) {
-    const finalSessionId = _optionalChain([sessionId, 'optionalAccess', _293 => _293.trim, 'call', _294 => _294()]) || _crypto.randomUUID.call(void 0, );
+    const finalSessionId = _optionalChain([sessionId, 'optionalAccess', _295 => _295.trim, 'call', _296 => _296()]) || _crypto.randomUUID.call(void 0, );
     const session = {
       appName,
       userId,
@@ -10779,7 +10804,7 @@ var InMemorySessionService = (_class31 = class extends BaseSessionService {const
       warning(`sessionId ${sessionId} not in sessions[appName][userId]`);
       return event;
     }
-    if (_optionalChain([event, 'access', _295 => _295.actions, 'optionalAccess', _296 => _296.stateDelta])) {
+    if (_optionalChain([event, 'access', _297 => _297.actions, 'optionalAccess', _298 => _298.stateDelta])) {
       for (const key in event.actions.stateDelta) {
         const value = event.actions.stateDelta[key];
         if (key.startsWith(State.APP_PREFIX)) {
@@ -10813,14 +10838,14 @@ function _findFunctionCallEventIfLastEventIsFunctionResponse(session) {
     return null;
   }
   const lastEvent = events[events.length - 1];
-  if (_optionalChain([lastEvent, 'access', _297 => _297.content, 'optionalAccess', _298 => _298.parts, 'optionalAccess', _299 => _299.some, 'call', _300 => _300((part) => part.functionResponse)])) {
-    const functionCallId = _optionalChain([lastEvent, 'access', _301 => _301.content, 'access', _302 => _302.parts, 'access', _303 => _303.find, 'call', _304 => _304(
+  if (_optionalChain([lastEvent, 'access', _299 => _299.content, 'optionalAccess', _300 => _300.parts, 'optionalAccess', _301 => _301.some, 'call', _302 => _302((part) => part.functionResponse)])) {
+    const functionCallId = _optionalChain([lastEvent, 'access', _303 => _303.content, 'access', _304 => _304.parts, 'access', _305 => _305.find, 'call', _306 => _306(
       (part) => part.functionResponse
-    ), 'optionalAccess', _305 => _305.functionResponse, 'optionalAccess', _306 => _306.id]);
+    ), 'optionalAccess', _307 => _307.functionResponse, 'optionalAccess', _308 => _308.id]);
     if (!functionCallId) return null;
     for (let i = events.length - 2; i >= 0; i--) {
       const event = events[i];
-      const functionCalls = _optionalChain([event, 'access', _307 => _307.getFunctionCalls, 'optionalCall', _308 => _308()]) || [];
+      const functionCalls = _optionalChain([event, 'access', _309 => _309.getFunctionCalls, 'optionalCall', _310 => _310()]) || [];
       for (const functionCall of functionCalls) {
         if (functionCall.id === functionCallId) {
           return event;
@@ -11033,15 +11058,15 @@ var Runner = (_class32 = class {
    */
   _findAgentToRun(session, rootAgent) {
     const event = _findFunctionCallEventIfLastEventIsFunctionResponse(session);
-    if (_optionalChain([event, 'optionalAccess', _309 => _309.author])) {
+    if (_optionalChain([event, 'optionalAccess', _311 => _311.author])) {
       return rootAgent.findAgent(event.author);
     }
-    const nonUserEvents = _optionalChain([session, 'access', _310 => _310.events, 'optionalAccess', _311 => _311.filter, 'call', _312 => _312((e) => e.author !== "user"), 'access', _313 => _313.reverse, 'call', _314 => _314()]) || [];
+    const nonUserEvents = _optionalChain([session, 'access', _312 => _312.events, 'optionalAccess', _313 => _313.filter, 'call', _314 => _314((e) => e.author !== "user"), 'access', _315 => _315.reverse, 'call', _316 => _316()]) || [];
     for (const event2 of nonUserEvents) {
       if (event2.author === rootAgent.name) {
         return rootAgent;
       }
-      const agent = _optionalChain([rootAgent, 'access', _315 => _315.findSubAgent, 'optionalCall', _316 => _316(event2.author)]);
+      const agent = _optionalChain([rootAgent, 'access', _317 => _317.findSubAgent, 'optionalCall', _318 => _318(event2.author)]);
       if (!agent) {
         this.logger.debug(
           `Event from an unknown agent: ${event2.author}, event id: ${event2.id}`
@@ -11119,7 +11144,7 @@ var Runner = (_class32 = class {
    * Gets the configured summarizer or creates a default LLM-based one.
    */
   _getOrCreateSummarizer() {
-    if (_optionalChain([this, 'access', _317 => _317.eventsCompactionConfig, 'optionalAccess', _318 => _318.summarizer])) {
+    if (_optionalChain([this, 'access', _319 => _319.eventsCompactionConfig, 'optionalAccess', _320 => _320.summarizer])) {
       return this.eventsCompactionConfig.summarizer;
     }
     if (this.agent instanceof LlmAgent) {
@@ -11183,7 +11208,7 @@ var Runner = (_class32 = class {
     const stateAtRewindPoint = {};
     for (let i = 0; i < rewindEventIndex; i++) {
       const event = session.events[i];
-      if (_optionalChain([event, 'access', _319 => _319.actions, 'optionalAccess', _320 => _320.stateDelta])) {
+      if (_optionalChain([event, 'access', _321 => _321.actions, 'optionalAccess', _322 => _322.stateDelta])) {
         for (const [k, v] of Object.entries(event.actions.stateDelta)) {
           if (k.startsWith("app:") || k.startsWith("user:")) {
             continue;
@@ -11220,13 +11245,13 @@ var Runner = (_class32 = class {
     const versionsAtRewindPoint = {};
     for (let i = 0; i < rewindEventIndex; i++) {
       const event = session.events[i];
-      if (_optionalChain([event, 'access', _321 => _321.actions, 'optionalAccess', _322 => _322.artifactDelta])) {
+      if (_optionalChain([event, 'access', _323 => _323.actions, 'optionalAccess', _324 => _324.artifactDelta])) {
         Object.assign(versionsAtRewindPoint, event.actions.artifactDelta);
       }
     }
     const currentVersions = {};
     for (const event of session.events) {
-      if (_optionalChain([event, 'access', _323 => _323.actions, 'optionalAccess', _324 => _324.artifactDelta])) {
+      if (_optionalChain([event, 'access', _325 => _325.actions, 'optionalAccess', _326 => _326.artifactDelta])) {
         Object.assign(currentVersions, event.actions.artifactDelta);
       }
     }
@@ -11911,7 +11936,7 @@ var AgentBuilder = (_class33 = class _AgentBuilder {
     const outputSchema = this.config.outputSchema;
     const agentType = this.agentType;
     const isMulti = agentType === "parallel" || agentType === "sequential";
-    const subAgentNames = _optionalChain([this, 'access', _325 => _325.config, 'access', _326 => _326.subAgents, 'optionalAccess', _327 => _327.map, 'call', _328 => _328((a) => a.name)]) || [];
+    const subAgentNames = _optionalChain([this, 'access', _327 => _327.config, 'access', _328 => _328.subAgents, 'optionalAccess', _329 => _329.map, 'call', _330 => _330((a) => a.name)]) || [];
     const runConfig = this.runConfig;
     return {
       __outputSchema: outputSchema,
@@ -11920,7 +11945,7 @@ var AgentBuilder = (_class33 = class _AgentBuilder {
         let combinedResponse = "";
         const perAgentBuffers = {};
         const authors = /* @__PURE__ */ new Set();
-        if (!_optionalChain([sessionOptions, 'optionalAccess', _329 => _329.userId])) {
+        if (!_optionalChain([sessionOptions, 'optionalAccess', _331 => _331.userId])) {
           throw new Error("Session configuration is required");
         }
         for await (const event of baseRunner.runAsync({
@@ -11929,7 +11954,7 @@ var AgentBuilder = (_class33 = class _AgentBuilder {
           newMessage,
           runConfig
         })) {
-          if (_optionalChain([event, 'access', _330 => _330.content, 'optionalAccess', _331 => _331.parts]) && Array.isArray(event.content.parts)) {
+          if (_optionalChain([event, 'access', _332 => _332.content, 'optionalAccess', _333 => _333.parts]) && Array.isArray(event.content.parts)) {
             const content = event.content.parts.map(
               (part) => (part && typeof part === "object" && "text" in part ? part.text : "") || ""
             ).join("");
@@ -12219,7 +12244,7 @@ var VertexAiSessionService = class extends BaseSessionService {
         path: `operations/${operationId}`,
         request_dict: {}
       });
-      if (_optionalChain([lroResponse, 'optionalAccess', _332 => _332.done])) {
+      if (_optionalChain([lroResponse, 'optionalAccess', _334 => _334.done])) {
         break;
       }
       await new Promise((resolve) => setTimeout(resolve, 1e3));
@@ -12590,12 +12615,12 @@ var DatabaseSessionService = (_class34 = class extends BaseSessionService {
   }
   async createSession(appName, userId, state, sessionId) {
     await this.ensureInitialized();
-    const id = _optionalChain([sessionId, 'optionalAccess', _333 => _333.trim, 'call', _334 => _334()]) || this.generateSessionId();
+    const id = _optionalChain([sessionId, 'optionalAccess', _335 => _335.trim, 'call', _336 => _336()]) || this.generateSessionId();
     return await this.db.transaction().execute(async (trx) => {
       const appState = await trx.selectFrom("app_states").selectAll().where("app_name", "=", appName).executeTakeFirst();
       const userState = await trx.selectFrom("user_states").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).executeTakeFirst();
-      let currentAppState = this.parseJsonSafely(_optionalChain([appState, 'optionalAccess', _335 => _335.state]), {});
-      let currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _336 => _336.state]), {});
+      let currentAppState = this.parseJsonSafely(_optionalChain([appState, 'optionalAccess', _337 => _337.state]), {});
+      let currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _338 => _338.state]), {});
       if (!appState) {
         await trx.insertInto("app_states").values({
           app_name: appName,
@@ -12654,21 +12679,21 @@ var DatabaseSessionService = (_class34 = class extends BaseSessionService {
         return void 0;
       }
       let eventQuery = trx.selectFrom("events").selectAll().where("session_id", "=", sessionId).orderBy("timestamp", "desc");
-      if (_optionalChain([config, 'optionalAccess', _337 => _337.afterTimestamp])) {
+      if (_optionalChain([config, 'optionalAccess', _339 => _339.afterTimestamp])) {
         eventQuery = eventQuery.where(
           "timestamp",
           ">=",
           new Date(config.afterTimestamp * 1e3)
         );
       }
-      if (_optionalChain([config, 'optionalAccess', _338 => _338.numRecentEvents])) {
+      if (_optionalChain([config, 'optionalAccess', _340 => _340.numRecentEvents])) {
         eventQuery = eventQuery.limit(config.numRecentEvents);
       }
       const storageEvents = await eventQuery.execute();
       const appState = await trx.selectFrom("app_states").selectAll().where("app_name", "=", appName).executeTakeFirst();
       const userState = await trx.selectFrom("user_states").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).executeTakeFirst();
-      const currentAppState = this.parseJsonSafely(_optionalChain([appState, 'optionalAccess', _339 => _339.state]), {});
-      const currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _340 => _340.state]), {});
+      const currentAppState = this.parseJsonSafely(_optionalChain([appState, 'optionalAccess', _341 => _341.state]), {});
+      const currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _342 => _342.state]), {});
       const sessionState = this.parseJsonSafely(storageSession.state, {});
       const mergedState = this.mergeState(
         currentAppState,
@@ -12726,13 +12751,13 @@ var DatabaseSessionService = (_class34 = class extends BaseSessionService {
       }
       const appState = await trx.selectFrom("app_states").selectAll().where("app_name", "=", session.appName).executeTakeFirst();
       const userState = await trx.selectFrom("user_states").selectAll().where("app_name", "=", session.appName).where("user_id", "=", session.userId).executeTakeFirst();
-      let currentAppState = this.parseJsonSafely(_optionalChain([appState, 'optionalAccess', _341 => _341.state]), {});
-      let currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _342 => _342.state]), {});
+      let currentAppState = this.parseJsonSafely(_optionalChain([appState, 'optionalAccess', _343 => _343.state]), {});
+      let currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _344 => _344.state]), {});
       let sessionState = this.parseJsonSafely(storageSession.state, {});
       let appStateDelta = {};
       let userStateDelta = {};
       let sessionStateDelta = {};
-      if (_optionalChain([event, 'access', _343 => _343.actions, 'optionalAccess', _344 => _344.stateDelta])) {
+      if (_optionalChain([event, 'access', _345 => _345.actions, 'optionalAccess', _346 => _346.stateDelta])) {
         const deltas = this.extractStateDelta(event.actions.stateDelta);
         appStateDelta = deltas.appStateDelta;
         userStateDelta = deltas.userStateDelta;
@@ -12878,7 +12903,7 @@ var DatabaseSessionService = (_class34 = class extends BaseSessionService {
    * Overrides the base class method to work with plain object state.
    */
   updateSessionState(session, event) {
-    if (!_optionalChain([event, 'access', _345 => _345.actions, 'optionalAccess', _346 => _346.stateDelta])) {
+    if (!_optionalChain([event, 'access', _347 => _347.actions, 'optionalAccess', _348 => _348.stateDelta])) {
       return;
     }
     for (const [key, value] of Object.entries(event.actions.stateDelta)) {
@@ -13048,7 +13073,7 @@ var GcsArtifactService = class {
       };
       return part;
     } catch (error) {
-      if (_optionalChain([error, 'optionalAccess', _347 => _347.code]) === 404) {
+      if (_optionalChain([error, 'optionalAccess', _349 => _349.code]) === 404) {
         return null;
       }
       throw error;
@@ -13299,13 +13324,13 @@ var VertexAiEvalFacade = class _VertexAiEvalFacade {
     };
   }
   _getText(content) {
-    if (_optionalChain([content, 'optionalAccess', _348 => _348.parts])) {
+    if (_optionalChain([content, 'optionalAccess', _350 => _350.parts])) {
       return content.parts.map((p) => p.text || "").filter((text) => text.length > 0).join("\n");
     }
     return "";
   }
   _getScore(evalResult) {
-    if (_optionalChain([evalResult, 'optionalAccess', _349 => _349.summaryMetrics, 'optionalAccess', _350 => _350[0], 'optionalAccess', _351 => _351.meanScore]) !== void 0 && typeof evalResult.summaryMetrics[0].meanScore === "number" && !Number.isNaN(evalResult.summaryMetrics[0].meanScore)) {
+    if (_optionalChain([evalResult, 'optionalAccess', _351 => _351.summaryMetrics, 'optionalAccess', _352 => _352[0], 'optionalAccess', _353 => _353.meanScore]) !== void 0 && typeof evalResult.summaryMetrics[0].meanScore === "number" && !Number.isNaN(evalResult.summaryMetrics[0].meanScore)) {
       return evalResult.summaryMetrics[0].meanScore;
     }
     return void 0;
@@ -13455,7 +13480,7 @@ var ResponseEvaluator = class extends Evaluator {
     return fmeasure;
   }
   extractText(content) {
-    if (_optionalChain([content, 'optionalAccess', _352 => _352.parts])) {
+    if (_optionalChain([content, 'optionalAccess', _354 => _354.parts])) {
       return content.parts.map((p) => p.text || "").filter((text) => text.length > 0).join(" ");
     }
     return "";
@@ -13488,7 +13513,7 @@ var TrajectoryEvaluator = class extends Evaluator {
     for (let i = 0; i < actualInvocations.length; i++) {
       const actual = actualInvocations[i];
       const expected = expectedInvocations[i];
-      if (!_optionalChain([actual, 'access', _353 => _353.intermediateData, 'optionalAccess', _354 => _354.toolUses]) || !_optionalChain([expected, 'access', _355 => _355.intermediateData, 'optionalAccess', _356 => _356.toolUses])) {
+      if (!_optionalChain([actual, 'access', _355 => _355.intermediateData, 'optionalAccess', _356 => _356.toolUses]) || !_optionalChain([expected, 'access', _357 => _357.intermediateData, 'optionalAccess', _358 => _358.toolUses])) {
         perInvocationResults.push({
           actualInvocation: actual,
           expectedInvocation: expected,
@@ -13576,7 +13601,7 @@ var SafetyEvaluatorV1 = class extends Evaluator {
 
 // src/evaluation/llm-as-judge-utils.ts
 function getTextFromContent(content) {
-  if (_optionalChain([content, 'optionalAccess', _357 => _357.parts])) {
+  if (_optionalChain([content, 'optionalAccess', _359 => _359.parts])) {
     return content.parts.map((part) => part.text).filter(Boolean).join("\n");
   }
   return "";
@@ -13588,9 +13613,9 @@ function getEvalStatus(score, threshold) {
 // src/evaluation/llm-as-judge.ts
 var LlmAsJudge = class {
   async sampleJudge(prompt, numSamples, critiqueParser, judgeModelOptions) {
-    const modelName = _optionalChain([judgeModelOptions, 'optionalAccess', _358 => _358.judgeModel]) || "gemini-2.5-flash";
+    const modelName = _optionalChain([judgeModelOptions, 'optionalAccess', _360 => _360.judgeModel]) || "gemini-2.5-flash";
     const model = LLMRegistry.getModelOrCreate(modelName);
-    const config = _optionalChain([judgeModelOptions, 'optionalAccess', _359 => _359.judgeModelConfig]) || {};
+    const config = _optionalChain([judgeModelOptions, 'optionalAccess', _361 => _361.judgeModelConfig]) || {};
     const samples = [];
     for (let i = 0; i < numSamples; i++) {
       try {
@@ -13656,7 +13681,7 @@ function parseCritique(response) {
   const labelMatchIsResponseValid = response.match(
     /"is_the_agent_response_valid":\s*\[*[\n\s]*"*([^"^\]^\s]*)"*[\n\s]*\]*\s*[,\n\}]/
   );
-  if (_optionalChain([labelMatchIsResponseValid, 'optionalAccess', _360 => _360[1]])) {
+  if (_optionalChain([labelMatchIsResponseValid, 'optionalAccess', _362 => _362[1]])) {
     const label = labelMatchIsResponseValid[1].toLowerCase();
     return label === "valid" ? "valid" /* VALID */ : "invalid" /* INVALID */;
   }
@@ -13701,7 +13726,7 @@ var FinalResponseMatchV2Evaluator = class extends Evaluator {
         "{prompt}",
         prompt
       ).replace("{response}", response).replace("{golden_response}", goldenResponse);
-      const numSamples = _nullishCoalesce(_optionalChain([this, 'access', _361 => _361.metric, 'access', _362 => _362.judgeModelOptions, 'optionalAccess', _363 => _363.numSamples]), () => ( DEFAULT_NUM_SAMPLES));
+      const numSamples = _nullishCoalesce(_optionalChain([this, 'access', _363 => _363.metric, 'access', _364 => _364.judgeModelOptions, 'optionalAccess', _365 => _365.numSamples]), () => ( DEFAULT_NUM_SAMPLES));
       const labels = await this.llmAsJudge.sampleJudge(
         formattedPrompt,
         numSamples,
@@ -13741,7 +13766,7 @@ var MetricEvaluatorRegistry = (_class35 = class {constructor() { _class35.protot
     const metricName = metricInfo.metricName;
     if (this.registry.has(metricName)) {
       console.info(
-        `Updating Evaluator class for ${metricName} from ${_optionalChain([this, 'access', _364 => _364.registry, 'access', _365 => _365.get, 'call', _366 => _366(metricName), 'optionalAccess', _367 => _367.evaluator, 'access', _368 => _368.name])} to ${evaluator.name}`
+        `Updating Evaluator class for ${metricName} from ${_optionalChain([this, 'access', _366 => _366.registry, 'access', _367 => _367.get, 'call', _368 => _368(metricName), 'optionalAccess', _369 => _369.evaluator, 'access', _370 => _370.name])} to ${evaluator.name}`
       );
     }
     this.registry.set(metricName, {
@@ -13855,10 +13880,10 @@ var LocalEvalService = class extends BaseEvalService {
       for (const evalMetric of evaluateConfig.evalMetrics) {
         const evaluator = DEFAULT_METRIC_EVALUATOR_REGISTRY.getEvaluator(evalMetric);
         const actual = results.filter(
-          (r) => !_optionalChain([r, 'access', _369 => _369.invocationId, 'optionalAccess', _370 => _370.includes, 'call', _371 => _371("expected")])
+          (r) => !_optionalChain([r, 'access', _371 => _371.invocationId, 'optionalAccess', _372 => _372.includes, 'call', _373 => _373("expected")])
         );
         const expected = results.filter(
-          (r) => _optionalChain([r, 'access', _372 => _372.invocationId, 'optionalAccess', _373 => _373.includes, 'call', _374 => _374("expected")])
+          (r) => _optionalChain([r, 'access', _374 => _374.invocationId, 'optionalAccess', _375 => _375.includes, 'call', _376 => _376("expected")])
         );
         const result = await evaluator.evaluateInvocations(actual, expected);
         evalResult.evalCaseResults.push({
@@ -14250,13 +14275,13 @@ ${failures.join(
     console.log("\n\n");
   }
   static _convertContentToText(content) {
-    if (_optionalChain([content, 'optionalAccess', _375 => _375.parts])) {
+    if (_optionalChain([content, 'optionalAccess', _377 => _377.parts])) {
       return content.parts.map((p) => p.text || "").filter((text) => text.length > 0).join("\n");
     }
     return "";
   }
   static _convertToolCallsToText(intermediateData) {
-    if (_optionalChain([intermediateData, 'optionalAccess', _376 => _376.toolUses])) {
+    if (_optionalChain([intermediateData, 'optionalAccess', _378 => _378.toolUses])) {
       return intermediateData.toolUses.map((t) => JSON.stringify(t)).join("\n");
     }
     return "";
@@ -14311,7 +14336,7 @@ ${failures.join(
     for (const [metricName, evalMetricResultsWithInvocations] of Object.entries(
       evalMetricResults
     )) {
-      const threshold = _optionalChain([evalMetricResultsWithInvocations, 'access', _377 => _377[0], 'optionalAccess', _378 => _378.evalMetricResult, 'access', _379 => _379.threshold]) || 0;
+      const threshold = _optionalChain([evalMetricResultsWithInvocations, 'access', _379 => _379[0], 'optionalAccess', _380 => _380.evalMetricResult, 'access', _381 => _381.threshold]) || 0;
       const scores = evalMetricResultsWithInvocations.map((m) => m.evalMetricResult.score).filter((s) => s !== void 0);
       let overallScore;
       let overallEvalStatus;
@@ -14400,7 +14425,7 @@ var RougeEvaluator = class extends Evaluator {
   }
 };
 function getTextFromContent2(content) {
-  if (_optionalChain([content, 'optionalAccess', _380 => _380.parts])) {
+  if (_optionalChain([content, 'optionalAccess', _382 => _382.parts])) {
     return content.parts.map((part) => part.text).filter(Boolean).join("\n");
   }
   return "";