@iqai/adk 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27; var _class28; var _class29;var __defProp = Object.defineProperty;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27; var _class28; var _class29; var _class30; var _class31; var _class32;var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
@@ -26,8 +26,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/helpers/logger.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 function isDebugEnabled() {
-  return process.env.NODE_ENV === "development" || process.env.DEBUG === "true";
+  return process.env.NODE_ENV === "development" || process.env.ADK_DEBUG === "true";
 }
 var Logger;
 var init_logger = __esm({
@@ -38,34 +39,99 @@ var init_logger = __esm({
       constructor({ name }) {;_class.prototype.__init2.call(this);
         this.name = name;
       }
+      colorize(message) {
+        return _chalk2.default.blue(message);
+      }
       debug(message, ...args) {
-        const time = (/* @__PURE__ */ new Date()).toISOString();
         if (this.isDebugEnabled) {
-          console.log(`[${time}] \u{1F41B} [DEBUG] \u2728 [${this.name}] ${message}`, ...args);
+          const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+          console.log(
+            this.colorize(`[${time}] \u{1F41B} [${this.name}] ${message}`),
+            ...args
+          );
         }
       }
       info(message, ...args) {
-        const time = (/* @__PURE__ */ new Date()).toISOString();
-        console.info(`[${time}] \u2139\uFE0F [INFO] \u2728 [${this.name}] ${message}`, ...args);
+        const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        console.info(
+          this.colorize(`[${time}] \u2139\uFE0F [${this.name}] ${message}`),
+          ...args
+        );
       }
       warn(message, ...args) {
-        const time = (/* @__PURE__ */ new Date()).toISOString();
-        console.warn(`[${time}] \u{1F6A7} [WARN] \u2728 [${this.name}] ${message}`, ...args);
+        const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        console.warn(
+          this.colorize(`[${time}] \u{1F6A7} [${this.name}] ${message}`),
+          ...args
+        );
       }
       error(message, ...args) {
-        const time = (/* @__PURE__ */ new Date()).toISOString();
-        console.error(`[${time}] \u274C [ERROR] \u2728 [${this.name}] ${message}`, ...args);
+        const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        console.error(
+          this.colorize(`[${time}] \u274C [${this.name}] ${message}`),
+          ...args
+        );
+      }
+      /**
+       * Logs structured data in a visually appealing table format.
+       * Uses vertical layout for better readability and respects debug settings.
+       */
+      debugStructured(title, data) {
+        if (!this.isDebugEnabled) return;
+        const terminalWidth = process.stdout.columns || 60;
+        const width = Math.min(terminalWidth, 100);
+        const contentWidth = width - 4;
+        const topBorder = `\u250C${"\u2500".repeat(width - 2)}\u2510`;
+        const bottomBorder = `\u2514${"\u2500".repeat(width - 2)}\u2518`;
+        const middleBorder = `\u251C${"\u2500".repeat(width - 2)}\u2524`;
+        console.log(this.colorize(topBorder));
+        console.log(this.colorize(`\u2502 ${title.padEnd(contentWidth)} \u2502`));
+        console.log(this.colorize(middleBorder));
+        Object.entries(data).forEach(([key, value]) => {
+          const formattedKey = key.padEnd(20);
+          const formattedValue = String(value);
+          const availableValueSpace = contentWidth - 20 - 2;
+          const truncatedValue = formattedValue.length > availableValueSpace ? `${formattedValue.substring(0, availableValueSpace - 3)}...` : formattedValue;
+          const content = `${formattedKey}: ${truncatedValue}`;
+          const paddedContent = content.padEnd(contentWidth);
+          console.log(this.colorize(`\u2502 ${paddedContent} \u2502`));
+        });
+        console.log(this.colorize(bottomBorder));
+      }
+      /**
+       * Logs array data in a compact, readable format.
+       */
+      debugArray(title, items) {
+        if (!this.isDebugEnabled) return;
+        const terminalWidth = process.stdout.columns || 78;
+        const width = Math.min(terminalWidth, 120);
+        const contentWidth = width - 4;
+        const topBorder = `\u250C${"\u2500".repeat(width - 2)}\u2510`;
+        const bottomBorder = `\u2514${"\u2500".repeat(width - 2)}\u2518`;
+        const middleBorder = `\u251C${"\u2500".repeat(width - 2)}\u2524`;
+        console.log(this.colorize(topBorder));
+        console.log(this.colorize(`\u2502 ${title.padEnd(contentWidth)} \u2502`));
+        console.log(this.colorize(middleBorder));
+        items.forEach((item, index) => {
+          const itemStr = Object.entries(item).map(([k, v]) => `${k}: ${v}`).join(" \u2022 ");
+          const indexPart = `[${index + 1}] `;
+          const availableSpace = contentWidth - indexPart.length;
+          const truncatedItem = itemStr.length > availableSpace ? `${itemStr.substring(0, availableSpace - 3)}...` : itemStr;
+          const content = `${indexPart}${truncatedItem}`;
+          const paddedContent = content.padEnd(contentWidth);
+          console.log(this.colorize(`\u2502 ${paddedContent} \u2502`));
+        });
+        console.log(this.colorize(bottomBorder));
       }
     }, _class);
   }
 });
 
 // src/tools/base/base-tool.ts
-var logger6, BaseTool;
+var BaseTool;
 var init_base_tool = __esm({
   "src/tools/base/base-tool.ts"() {
     init_logger();
-    logger6 = new Logger({ name: "BaseTool" });
     BaseTool = exports.BaseTool = (_class2 = class {
       /**
        * Name of the tool
@@ -96,10 +162,11 @@ var init_base_tool = __esm({
        * Maximum delay for retry in ms
        */
       __init4() {this.maxRetryDelay = 1e4}
+      __init5() {this.logger = new Logger({ name: "BaseTool" })}
       /**
        * Constructor for BaseTool
        */
-      constructor(config) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
+      constructor(config) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);
         this.name = config.name;
         this.description = config.description;
         this.isLongRunning = config.isLongRunning || false;
@@ -226,7 +293,7 @@ var init_base_tool = __esm({
         while (attempts <= (this.shouldRetryOnFailure ? this.maxRetryAttempts : 0)) {
           try {
             if (attempts > 0) {
-              logger6.debug(
+              this.logger.debug(
                 `Retrying tool ${this.name} (attempt ${attempts} of ${this.maxRetryAttempts})...`
               );
               const delay = Math.min(
@@ -406,8 +473,8 @@ var init_function_tool = __esm({
     init_function_utils();
     FunctionTool = exports.FunctionTool = (_class3 = class extends BaseTool {
       
-      __init5() {this.mandatoryArgs = []}
-      __init6() {this.parameterTypes = {}}
+      __init6() {this.mandatoryArgs = []}
+      __init7() {this.parameterTypes = {}}
       /**
        * Creates a new FunctionTool wrapping the provided function.
        *
@@ -423,7 +490,7 @@ var init_function_tool = __esm({
           isLongRunning: _optionalChain([options, 'optionalAccess', _8 => _8.isLongRunning]) || false,
           shouldRetryOnFailure: _optionalChain([options, 'optionalAccess', _9 => _9.shouldRetryOnFailure]) || false,
           maxRetryAttempts: _optionalChain([options, 'optionalAccess', _10 => _10.maxRetryAttempts]) || 3
-        });_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);;
+        });_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);;
         this.func = func;
         this.mandatoryArgs = this.getMandatoryArgs(func);
         this.parameterTypes = _optionalChain([options, 'optionalAccess', _11 => _11.parameterTypes]) || {};
@@ -613,6 +680,7 @@ __export(agents_exports, {
 // src/models/index.ts
 var models_exports = {};
 __export(models_exports, {
+  AiSdkLlm: () => AiSdkLlm,
   AnthropicLlm: () => AnthropicLlm,
   ApiKeyCredential: () => ApiKeyCredential,
   ApiKeyScheme: () => ApiKeyScheme,
@@ -640,8 +708,6 @@ __export(models_exports, {
 });
 
 // src/models/llm-request.ts
-init_logger();
-var logger = new Logger({ name: "LlmRequest" });
 var LlmRequest = class {
   /**
    * The model name.
@@ -805,6 +871,10 @@ var LlmResponse = class _LlmResponse {
    * Reason why the model finished generating.
    */
   
+  /**
+   * Error object if the response is an error.
+   */
+  
   /**
    * Creates a new LlmResponse.
    */
@@ -848,6 +918,29 @@ var LlmResponse = class _LlmResponse {
       usageMetadata
     });
   }
+  /**
+   * Creates an LlmResponse from an error.
+   *
+   * @param error The error object or message.
+   * @param options Additional options for the error response.
+   * @param options.errorCode A specific error code for the response.
+   * @param options.model The model that was being used when the error occurred.
+   * @returns The LlmResponse.
+   */
+  static fromError(error, options = {}) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorCode = options.errorCode || "UNKNOWN_ERROR";
+    return new _LlmResponse({
+      errorCode,
+      errorMessage: `LLM call failed for model ${options.model || "unknown"}: ${errorMessage}`,
+      content: {
+        role: "model",
+        parts: [{ text: `Error: ${errorMessage}` }]
+      },
+      finishReason: "STOP",
+      error: error instanceof Error ? error : new Error(errorMessage)
+    });
+  }
 };
 
 // src/models/base-llm.ts
@@ -869,11 +962,11 @@ var _sdknode = require('@opentelemetry/sdk-node');
 
 var _semanticconventions = require('@opentelemetry/semantic-conventions');
 var TelemetryService = (_class4 = class {
-  __init7() {this.sdk = null}
-  __init8() {this.isInitialized = false}
+  __init8() {this.sdk = null}
+  __init9() {this.isInitialized = false}
   
-  __init9() {this.config = null}
-  constructor() {;_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);
+  __init10() {this.config = null}
+  constructor() {;_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);
     this.tracer = _api.trace.getTracer("iqai-adk", "0.1.0");
   }
   /**
@@ -1127,16 +1220,16 @@ var traceLlmCall = (invocationContext, eventId, llmRequest, llmResponse) => tele
 );
 
 // src/models/base-llm.ts
-var logger2 = new Logger({ name: "BaseLlm" });
-var BaseLlm = class {
+var BaseLlm = (_class5 = class {
   /**
    * The name of the LLM, e.g. gemini-1.5-flash or gemini-1.5-flash-001.
    */
   
+  __init11() {this.logger = new Logger({ name: "BaseLlm" })}
   /**
    * Constructor for BaseLlm
    */
-  constructor(model) {
+  constructor(model) {;_class5.prototype.__init11.call(this);
     this.model = model;
   }
   /**
@@ -1183,12 +1276,6 @@ var BaseLlm = class {
             }),
             "adk.streaming": stream || false
           });
-          logger2.debug("ADK LLM Request:", {
-            model: this.model,
-            contentCount: _optionalChain([llmRequest, 'access', _45 => _45.contents, 'optionalAccess', _46 => _46.length]) || 0,
-            streaming: stream || false,
-            config: llmRequest.config
-          });
           let responseCount = 0;
           let totalTokens = 0;
           for await (const response of this.generateContentAsyncImpl(
@@ -1196,14 +1283,6 @@ var BaseLlm = class {
             stream
           )) {
             responseCount++;
-            logger2.debug(`ADK LLM Response ${responseCount}:`, {
-              model: this.model,
-              parts: _optionalChain([response, 'access', _47 => _47.parts, 'optionalAccess', _48 => _48.map, 'call', _49 => _49((part) => ({
-                text: typeof part.text === "string" ? part.text.substring(0, 200) + (part.text.length > 200 ? "..." : "") : "[non_text_content]"
-              }))]),
-              finishReason: response.finish_reason,
-              usage: response.usage
-            });
             if (response.usage) {
               totalTokens += response.usage.total_tokens || 0;
               span.setAttributes({
@@ -1224,7 +1303,7 @@ var BaseLlm = class {
         } catch (error) {
           span.recordException(error);
           span.setStatus({ code: 2, message: error.message });
-          console.error("\u274C ADK LLM Error:", {
+          this.logger.error("\u274C ADK LLM Error:", {
             model: this.model,
             error: error.message
           });
@@ -1273,33 +1352,29 @@ var BaseLlm = class {
   connect(llmRequest) {
     throw new Error(`Live connection is not supported for ${this.model}.`);
   }
-};
+}, _class5);
 
 // src/models/base-llm-connection.ts
 var BaseLLMConnection = class {
 };
 
 // src/models/google-llm.ts
-init_logger();
 
 
 
 var _genai = require('@google/genai');
-var _dedent = require('dedent'); var _dedent2 = _interopRequireDefault(_dedent);
-var NEW_LINE = "\n";
 var AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
 var AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
-var GoogleLlm = (_class5 = class extends BaseLlm {
+var GoogleLlm = class extends BaseLlm {
   
   
   
   
-  __init10() {this.logger = new Logger({ name: "GoogleLlm" })}
   /**
    * Constructor for Gemini
    */
   constructor(model = "gemini-1.5-flash") {
-    super(model);_class5.prototype.__init10.call(this);;
+    super(model);
   }
   /**
    * Provides the list of supported models.
@@ -1318,10 +1393,6 @@ var GoogleLlm = (_class5 = class extends BaseLlm {
    */
   async *generateContentAsyncImpl(llmRequest, stream = false) {
     this.preprocessRequest(llmRequest);
-    this.logger.debug(
-      `Sending out request, model: ${llmRequest.model || this.model}, backend: ${this.apiBackend}, stream: ${stream}`
-    );
-    this.logger.debug(this.buildRequestLog(llmRequest));
     const model = llmRequest.model || this.model;
     const contents = this.convertContents(llmRequest.contents || []);
     const config = this.convertConfig(llmRequest.config);
@@ -1337,10 +1408,9 @@ var GoogleLlm = (_class5 = class extends BaseLlm {
       let usageMetadata = null;
       for await (const resp of responses) {
         response = resp;
-        this.logger.debug(this.buildResponseLog(resp));
         const llmResponse = LlmResponse.create(resp);
         usageMetadata = llmResponse.usageMetadata;
-        if (_optionalChain([llmResponse, 'access', _50 => _50.content, 'optionalAccess', _51 => _51.parts, 'optionalAccess', _52 => _52[0], 'optionalAccess', _53 => _53.text])) {
+        if (_optionalChain([llmResponse, 'access', _45 => _45.content, 'optionalAccess', _46 => _46.parts, 'optionalAccess', _47 => _47[0], 'optionalAccess', _48 => _48.text])) {
           const part0 = llmResponse.content.parts[0];
           if (part0.thought) {
             thoughtText += part0.text;
@@ -1368,7 +1438,7 @@ var GoogleLlm = (_class5 = class extends BaseLlm {
         }
         yield llmResponse;
       }
-      if ((text || thoughtText) && response && response.candidates && _optionalChain([response, 'access', _54 => _54.candidates, 'access', _55 => _55[0], 'optionalAccess', _56 => _56.finishReason]) === _genai.FinishReason.STOP) {
+      if ((text || thoughtText) && response && response.candidates && _optionalChain([response, 'access', _49 => _49.candidates, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.finishReason]) === _genai.FinishReason.STOP) {
         const parts = [];
         if (thoughtText) {
           parts.push({ text: thoughtText, thought: true });
@@ -1390,8 +1460,11 @@ var GoogleLlm = (_class5 = class extends BaseLlm {
         contents,
         config
       });
-      this.logger.debug(this.buildResponseLog(response));
-      yield LlmResponse.create(response);
+      const llmResponse = LlmResponse.create(response);
+      this.logger.debug(
+        `Google response: ${_optionalChain([llmResponse, 'access', _52 => _52.usageMetadata, 'optionalAccess', _53 => _53.candidatesTokenCount]) || 0} tokens`
+      );
+      yield llmResponse;
     }
   }
   /**
@@ -1404,8 +1477,8 @@ var GoogleLlm = (_class5 = class extends BaseLlm {
    * Check if response has inline data
    */
   hasInlineData(response) {
-    const parts = _optionalChain([response, 'access', _57 => _57.candidates, 'optionalAccess', _58 => _58[0], 'optionalAccess', _59 => _59.content, 'optionalAccess', _60 => _60.parts]);
-    return _optionalChain([parts, 'optionalAccess', _61 => _61.some, 'call', _62 => _62((part) => _optionalChain([part, 'optionalAccess', _63 => _63.inlineData]))]) || false;
+    const parts = _optionalChain([response, 'access', _54 => _54.candidates, 'optionalAccess', _55 => _55[0], 'optionalAccess', _56 => _56.content, 'optionalAccess', _57 => _57.parts]);
+    return _optionalChain([parts, 'optionalAccess', _58 => _58.some, 'call', _59 => _59((part) => _optionalChain([part, 'optionalAccess', _60 => _60.inlineData]))]) || false;
   }
   /**
    * Convert LlmRequest contents to GoogleGenAI format
@@ -1452,7 +1525,7 @@ var GoogleLlm = (_class5 = class extends BaseLlm {
    * Sets display_name to null for the Gemini API (non-Vertex) backend.
    */
   removeDisplayNameIfPresent(dataObj) {
-    if (_optionalChain([dataObj, 'optionalAccess', _64 => _64.displayName])) {
+    if (_optionalChain([dataObj, 'optionalAccess', _61 => _61.displayName])) {
       dataObj.displayName = null;
     }
   }
@@ -1461,65 +1534,11 @@ var GoogleLlm = (_class5 = class extends BaseLlm {
    */
   buildFunctionDeclarationLog(funcDecl) {
     let paramStr = "{}";
-    if (_optionalChain([funcDecl, 'access', _65 => _65.parameters, 'optionalAccess', _66 => _66.properties])) {
+    if (_optionalChain([funcDecl, 'access', _62 => _62.parameters, 'optionalAccess', _63 => _63.properties])) {
       paramStr = JSON.stringify(funcDecl.parameters.properties);
     }
     return `${funcDecl.name}: ${paramStr}`;
   }
-  /**
-   * Builds request log string.
-   */
-  buildRequestLog(req) {
-    const functionDecls = _optionalChain([req, 'access', _67 => _67.config, 'optionalAccess', _68 => _68.tools, 'optionalAccess', _69 => _69[0], 'optionalAccess', _70 => _70.functionDeclarations]) || [];
-    const functionLogs = functionDecls.length > 0 ? functionDecls.map(
-      (funcDecl) => this.buildFunctionDeclarationLog(funcDecl)
-    ) : [];
-    const contentsLogs = _optionalChain([req, 'access', _71 => _71.contents, 'optionalAccess', _72 => _72.map, 'call', _73 => _73(
-      (content) => JSON.stringify(content, (key, value) => {
-        if (key === "data" && typeof value === "string" && value.length > 100) {
-          return "[EXCLUDED]";
-        }
-        return value;
-      })
-    )]) || [];
-    return _dedent2.default`
-		LLM Request:
-		-----------------------------------------------------------
-		System Instruction:
-		${_optionalChain([req, 'access', _74 => _74.config, 'optionalAccess', _75 => _75.systemInstruction]) || ""}
-		-----------------------------------------------------------
-		Contents:
-		${contentsLogs.join(NEW_LINE)}
-		-----------------------------------------------------------
-		Functions:
-		${functionLogs.join(NEW_LINE)}
-		-----------------------------------------------------------`;
-  }
-  /**
-   * Builds response log string.
-   */
-  buildResponseLog(resp) {
-    const functionCallsText = [];
-    if (resp.functionCalls) {
-      for (const funcCall of resp.functionCalls) {
-        functionCallsText.push(
-          `name: ${funcCall.name}, args: ${JSON.stringify(funcCall.args)}`
-        );
-      }
-    }
-    return _dedent2.default`
-		LLM Response:
-		-----------------------------------------------------------
-		Text:
-		${resp.text || ""}
-		-----------------------------------------------------------
-		Function calls:
-		${functionCallsText.join(NEW_LINE)}
-		-----------------------------------------------------------
-		Raw response:
-		${JSON.stringify(resp, null, 2)}
-		-----------------------------------------------------------`;
-  }
   /**
    * Provides the api client.
    */
@@ -1608,20 +1627,20 @@ var GoogleLlm = (_class5 = class extends BaseLlm {
     }
     return this._liveApiClient;
   }
-}, _class5);
+};
 
 // src/models/anthropic-llm.ts
 init_logger();
 var _sdk = require('@anthropic-ai/sdk'); var _sdk2 = _interopRequireDefault(_sdk);
-var logger3 = new Logger({ name: "AnthropicLlm" });
 var MAX_TOKENS = 1024;
-var AnthropicLlm = class extends BaseLlm {
+var AnthropicLlm = (_class6 = class extends BaseLlm {
   
+  __init12() {this.logger = new Logger({ name: "AnthropicLlm" })}
   /**
    * Constructor for Anthropic LLM
    */
   constructor(model = "claude-3-5-sonnet-20241022") {
-    super(model);
+    super(model);_class6.prototype.__init12.call(this);;
   }
   /**
    * Provides the list of supported models
@@ -1633,15 +1652,12 @@ var AnthropicLlm = class extends BaseLlm {
    * Main content generation method - handles both streaming and non-streaming
    */
   async *generateContentAsyncImpl(llmRequest, stream = false) {
-    logger3.debug(
-      `Sending Anthropic request, model: ${llmRequest.model || this.model}, stream: ${stream}`
-    );
     const model = llmRequest.model || this.model;
     const messages = (llmRequest.contents || []).map(
       (content) => this.contentToAnthropicMessage(content)
     );
     let tools;
-    if (_optionalChain([llmRequest, 'access', _76 => _76.config, 'optionalAccess', _77 => _77.tools, 'optionalAccess', _78 => _78[0], 'optionalAccess', _79 => _79.functionDeclarations])) {
+    if (_optionalChain([llmRequest, 'access', _64 => _64.config, 'optionalAccess', _65 => _65.tools, 'optionalAccess', _66 => _66[0], 'optionalAccess', _67 => _67.functionDeclarations])) {
       tools = llmRequest.config.tools[0].functionDeclarations.map(
         (decl) => this.functionDeclarationToAnthropicTool(decl)
       );
@@ -1663,9 +1679,9 @@ var AnthropicLlm = class extends BaseLlm {
       messages: anthropicMessages,
       tools,
       tool_choice: tools ? { type: "auto" } : void 0,
-      max_tokens: _optionalChain([llmRequest, 'access', _80 => _80.config, 'optionalAccess', _81 => _81.maxOutputTokens]) || MAX_TOKENS,
-      temperature: _optionalChain([llmRequest, 'access', _82 => _82.config, 'optionalAccess', _83 => _83.temperature]),
-      top_p: _optionalChain([llmRequest, 'access', _84 => _84.config, 'optionalAccess', _85 => _85.topP])
+      max_tokens: _optionalChain([llmRequest, 'access', _68 => _68.config, 'optionalAccess', _69 => _69.maxOutputTokens]) || MAX_TOKENS,
+      temperature: _optionalChain([llmRequest, 'access', _70 => _70.config, 'optionalAccess', _71 => _71.temperature]),
+      top_p: _optionalChain([llmRequest, 'access', _72 => _72.config, 'optionalAccess', _73 => _73.topP])
     });
     yield this.anthropicMessageToLlmResponse(message);
   }
@@ -1679,7 +1695,9 @@ var AnthropicLlm = class extends BaseLlm {
    * Convert Anthropic Message to ADK LlmResponse
    */
   anthropicMessageToLlmResponse(message) {
-    logger3.debug("Anthropic response:", JSON.stringify(message, null, 2));
+    this.logger.debug(
+      `Anthropic response: ${message.usage.output_tokens} tokens, ${message.stop_reason}`
+    );
     return new LlmResponse({
       content: {
         role: "model",
@@ -1724,7 +1742,7 @@ var AnthropicLlm = class extends BaseLlm {
     }
     if (part.function_response) {
       let content = "";
-      if (_optionalChain([part, 'access', _86 => _86.function_response, 'access', _87 => _87.response, 'optionalAccess', _88 => _88.result])) {
+      if (_optionalChain([part, 'access', _74 => _74.function_response, 'access', _75 => _75.response, 'optionalAccess', _76 => _76.result])) {
         content = String(part.function_response.response.result);
       }
       return {
@@ -1759,7 +1777,7 @@ var AnthropicLlm = class extends BaseLlm {
    */
   functionDeclarationToAnthropicTool(functionDeclaration) {
     const properties = {};
-    if (_optionalChain([functionDeclaration, 'access', _89 => _89.parameters, 'optionalAccess', _90 => _90.properties])) {
+    if (_optionalChain([functionDeclaration, 'access', _77 => _77.parameters, 'optionalAccess', _78 => _78.properties])) {
       for (const [key, value] of Object.entries(
         functionDeclaration.parameters.properties
       )) {
@@ -1833,14 +1851,10 @@ var AnthropicLlm = class extends BaseLlm {
     }
     return this._client;
   }
-};
+}, _class6);
 
 // src/models/openai-llm.ts
-init_logger();
-
 var _openai = require('openai'); var _openai2 = _interopRequireDefault(_openai);
-var logger4 = new Logger({ name: "OpenAiLlm" });
-var NEW_LINE2 = "\n";
 var OpenAiLlm = class extends BaseLlm {
   
   /**
@@ -1860,16 +1874,12 @@ var OpenAiLlm = class extends BaseLlm {
    */
   async *generateContentAsyncImpl(llmRequest, stream = false) {
     this.preprocessRequest(llmRequest);
-    logger4.debug(
-      `Sending OpenAI request, model: ${llmRequest.model || this.model}, stream: ${stream}`
-    );
-    logger4.debug(this.buildRequestLog(llmRequest));
     const model = llmRequest.model || this.model;
     const messages = (llmRequest.contents || []).map(
       (content) => this.contentToOpenAiMessage(content)
     );
     let tools;
-    if (_optionalChain([llmRequest, 'access', _91 => _91.config, 'optionalAccess', _92 => _92.tools, 'optionalAccess', _93 => _93[0], 'optionalAccess', _94 => _94.functionDeclarations])) {
+    if (_optionalChain([llmRequest, 'access', _79 => _79.config, 'optionalAccess', _80 => _80.tools, 'optionalAccess', _81 => _81[0], 'optionalAccess', _82 => _82.functionDeclarations])) {
       tools = llmRequest.config.tools[0].functionDeclarations.map(
         (funcDecl) => this.functionDeclarationToOpenAiTool(funcDecl)
       );
@@ -1887,9 +1897,9 @@ var OpenAiLlm = class extends BaseLlm {
       messages: openAiMessages,
       tools,
       tool_choice: tools ? "auto" : void 0,
-      max_tokens: _optionalChain([llmRequest, 'access', _95 => _95.config, 'optionalAccess', _96 => _96.maxOutputTokens]),
-      temperature: _optionalChain([llmRequest, 'access', _97 => _97.config, 'optionalAccess', _98 => _98.temperature]),
-      top_p: _optionalChain([llmRequest, 'access', _99 => _99.config, 'optionalAccess', _100 => _100.topP]),
+      max_tokens: _optionalChain([llmRequest, 'access', _83 => _83.config, 'optionalAccess', _84 => _84.maxOutputTokens]),
+      temperature: _optionalChain([llmRequest, 'access', _85 => _85.config, 'optionalAccess', _86 => _86.temperature]),
+      top_p: _optionalChain([llmRequest, 'access', _87 => _87.config, 'optionalAccess', _88 => _88.topP]),
       stream
     };
     if (stream) {
@@ -1905,13 +1915,11 @@ var OpenAiLlm = class extends BaseLlm {
         const choice = chunk.choices[0];
         if (!choice) continue;
         const delta = choice.delta;
-        logger4.debug("Delta content:", delta.content);
         const llmResponse = this.createChunkResponse(delta, chunk.usage);
         if (chunk.usage) {
           usageMetadata = chunk.usage;
         }
-        logger4.debug(this.buildResponseLog(llmResponse));
-        if (_optionalChain([llmResponse, 'access', _101 => _101.content, 'optionalAccess', _102 => _102.parts, 'optionalAccess', _103 => _103[0], 'optionalAccess', _104 => _104.text])) {
+        if (_optionalChain([llmResponse, 'access', _89 => _89.content, 'optionalAccess', _90 => _90.parts, 'optionalAccess', _91 => _91[0], 'optionalAccess', _92 => _92.text])) {
           const part0 = llmResponse.content.parts[0];
           if (part0.thought) {
             thoughtText += part0.text;
@@ -1952,10 +1960,10 @@ var OpenAiLlm = class extends BaseLlm {
                 function: { name: "", arguments: "" }
               };
             }
-            if (_optionalChain([toolCall, 'access', _105 => _105.function, 'optionalAccess', _106 => _106.name])) {
+            if (_optionalChain([toolCall, 'access', _93 => _93.function, 'optionalAccess', _94 => _94.name])) {
               accumulatedToolCalls[index].function.name += toolCall.function.name;
             }
-            if (_optionalChain([toolCall, 'access', _107 => _107.function, 'optionalAccess', _108 => _108.arguments])) {
+            if (_optionalChain([toolCall, 'access', _95 => _95.function, 'optionalAccess', _96 => _96.arguments])) {
               accumulatedToolCalls[index].function.arguments += toolCall.function.arguments;
             }
           }
@@ -1970,7 +1978,7 @@ var OpenAiLlm = class extends BaseLlm {
           }
           if (accumulatedToolCalls.length > 0) {
             for (const toolCall of accumulatedToolCalls) {
-              if (_optionalChain([toolCall, 'access', _109 => _109.function, 'optionalAccess', _110 => _110.name])) {
+              if (_optionalChain([toolCall, 'access', _97 => _97.function, 'optionalAccess', _98 => _98.name])) {
                 parts.push({
                   functionCall: {
                     id: toolCall.id,
@@ -1993,7 +2001,6 @@ var OpenAiLlm = class extends BaseLlm {
             } : void 0,
             finishReason: this.toAdkFinishReason(choice.finish_reason)
           });
-          logger4.debug(this.buildResponseLog(finalResponse));
           yield finalResponse;
         } else {
           yield llmResponse;
@@ -2030,7 +2037,9 @@ var OpenAiLlm = class extends BaseLlm {
           choice,
           response.usage
         );
-        logger4.debug(this.buildResponseLog(llmResponse));
+        this.logger.debug(
+          `OpenAI response: ${_optionalChain([response, 'access', _99 => _99.usage, 'optionalAccess', _100 => _100.completion_tokens]) || 0} tokens`
+        );
         yield llmResponse;
       }
     }
@@ -2056,7 +2065,7 @@ var OpenAiLlm = class extends BaseLlm {
     }
     if (delta.tool_calls) {
       for (const toolCall of delta.tool_calls) {
-        if (toolCall.type === "function" && _optionalChain([toolCall, 'access', _111 => _111.function, 'optionalAccess', _112 => _112.name])) {
+        if (toolCall.type === "function" && _optionalChain([toolCall, 'access', _101 => _101.function, 'optionalAccess', _102 => _102.name])) {
           parts.push({
             functionCall: {
               id: toolCall.id || "",
@@ -2084,10 +2093,6 @@ var OpenAiLlm = class extends BaseLlm {
    */
   openAiMessageToLlmResponse(choice, usage) {
     const message = choice.message;
-    logger4.debug(
-      "OpenAI response:",
-      JSON.stringify({ message, usage }, null, 2)
-    );
     const parts = [];
     if (message.content) {
       parts.push({ text: message.content });
@@ -2126,10 +2131,10 @@ var OpenAiLlm = class extends BaseLlm {
     if (role === "system") {
       return {
         role: "system",
-        content: _optionalChain([content, 'access', _113 => _113.parts, 'optionalAccess', _114 => _114[0], 'optionalAccess', _115 => _115.text]) || ""
+        content: _optionalChain([content, 'access', _103 => _103.parts, 'optionalAccess', _104 => _104[0], 'optionalAccess', _105 => _105.text]) || ""
       };
     }
-    if (_optionalChain([content, 'access', _116 => _116.parts, 'optionalAccess', _117 => _117.some, 'call', _118 => _118((part) => part.functionCall)])) {
+    if (_optionalChain([content, 'access', _106 => _106.parts, 'optionalAccess', _107 => _107.some, 'call', _108 => _108((part) => part.functionCall)])) {
       const functionCallPart = content.parts.find(
         (part) => part.functionCall
       );
@@ -2149,7 +2154,7 @@ var OpenAiLlm = class extends BaseLlm {
         ]
       };
     }
-    if (_optionalChain([content, 'access', _119 => _119.parts, 'optionalAccess', _120 => _120.some, 'call', _121 => _121((part) => part.functionResponse)])) {
+    if (_optionalChain([content, 'access', _109 => _109.parts, 'optionalAccess', _110 => _110.some, 'call', _111 => _111((part) => part.functionResponse)])) {
       const functionResponsePart = content.parts.find(
         (part) => part.functionResponse
       );
@@ -2161,7 +2166,7 @@ var OpenAiLlm = class extends BaseLlm {
         )
       };
     }
-    if (_optionalChain([content, 'access', _122 => _122.parts, 'optionalAccess', _123 => _123.length]) === 1 && content.parts[0].text) {
+    if (_optionalChain([content, 'access', _112 => _112.parts, 'optionalAccess', _113 => _113.length]) === 1 && content.parts[0].text) {
       return {
         role,
         content: content.parts[0].text
@@ -2184,7 +2189,7 @@ var OpenAiLlm = class extends BaseLlm {
         text: part.text
       };
     }
-    if (_optionalChain([part, 'access', _124 => _124.inline_data, 'optionalAccess', _125 => _125.mime_type]) && _optionalChain([part, 'access', _126 => _126.inline_data, 'optionalAccess', _127 => _127.data])) {
+    if (_optionalChain([part, 'access', _114 => _114.inline_data, 'optionalAccess', _115 => _115.mime_type]) && _optionalChain([part, 'access', _116 => _116.inline_data, 'optionalAccess', _117 => _117.data])) {
       return {
         type: "image_url",
         image_url: {
@@ -2273,69 +2278,8 @@ var OpenAiLlm = class extends BaseLlm {
    * Check if response has inline data (similar to Google LLM)
    */
   hasInlineData(response) {
-    const parts = _optionalChain([response, 'access', _128 => _128.content, 'optionalAccess', _129 => _129.parts]);
-    return _optionalChain([parts, 'optionalAccess', _130 => _130.some, 'call', _131 => _131((part) => part.inlineData)]) || false;
-  }
-  /**
-   * Build request log string for debugging (similar to Google LLM)
-   */
-  buildRequestLog(req) {
-    const functionDecls = _optionalChain([req, 'access', _132 => _132.config, 'optionalAccess', _133 => _133.tools, 'optionalAccess', _134 => _134[0], 'optionalAccess', _135 => _135.functionDeclarations]) || [];
-    const functionLogs = functionDecls.length > 0 ? functionDecls.map(
-      (funcDecl) => `${funcDecl.name}: ${JSON.stringify(_optionalChain([funcDecl, 'access', _136 => _136.parameters, 'optionalAccess', _137 => _137.properties]) || {})}`
-    ) : [];
-    const contentsLogs = _optionalChain([req, 'access', _138 => _138.contents, 'optionalAccess', _139 => _139.map, 'call', _140 => _140(
-      (content) => JSON.stringify(content, (key, value) => {
-        if (key === "data" && typeof value === "string" && value.length > 100) {
-          return "[EXCLUDED]";
-        }
-        return value;
-      })
-    )]) || [];
-    return _dedent2.default`
-		LLM Request:
-		-----------------------------------------------------------
-		System Instruction:
-		${req.getSystemInstructionText() || ""}
-		-----------------------------------------------------------
-		Contents:
-		${contentsLogs.join(NEW_LINE2)}
-		-----------------------------------------------------------
-		Functions:
-		${functionLogs.join(NEW_LINE2)}
-		-----------------------------------------------------------`;
-  }
-  /**
-   * Build response log string for debugging (similar to Google LLM)
-   */
-  buildResponseLog(response) {
-    const functionCallsText = [];
-    if (_optionalChain([response, 'access', _141 => _141.content, 'optionalAccess', _142 => _142.parts])) {
-      for (const part of response.content.parts) {
-        if (part.functionCall) {
-          const funcCall = part.functionCall;
-          functionCallsText.push(
-            `name: ${funcCall.name}, args: ${JSON.stringify(funcCall.args)}`
-          );
-        }
-      }
-    }
-    const text = _optionalChain([response, 'access', _143 => _143.content, 'optionalAccess', _144 => _144.parts, 'optionalAccess', _145 => _145.filter, 'call', _146 => _146((part) => part.text), 'optionalAccess', _147 => _147.map, 'call', _148 => _148((part) => part.text), 'optionalAccess', _149 => _149.join, 'call', _150 => _150("")]) || "";
-    return _dedent2.default`
-		LLM Response:
-		-----------------------------------------------------------
-		Text:
-		${text}
-		-----------------------------------------------------------
-		Function calls:
-		${functionCallsText.join(NEW_LINE2)}
-		-----------------------------------------------------------
-		Usage:
-		${JSON.stringify(response.usageMetadata, null, 2)}
-		-----------------------------------------------------------
-		Finish Reason:
-		${response.finishReason}
-		-----------------------------------------------------------`;
+    const parts = _optionalChain([response, 'access', _118 => _118.content, 'optionalAccess', _119 => _119.parts]);
+    return _optionalChain([parts, 'optionalAccess', _120 => _120.some, 'call', _121 => _121((part) => part.inlineData)]) || false;
   }
   /**
    * Gets the OpenAI client
@@ -2356,14 +2300,289 @@ var OpenAiLlm = class extends BaseLlm {
   }
 };
 
+// src/models/ai-sdk.ts
+init_logger();
+
+
+
+
+var _ai = require('ai');
+var AiSdkLlm = (_class7 = class extends BaseLlm {
+  
+  __init13() {this.logger = new Logger({ name: "AiSdkLlm" })}
+  /**
+   * Constructor accepts a pre-configured LanguageModel instance
+   * @param model - Pre-configured LanguageModel from provider(modelName)
+   */
+  constructor(modelInstance) {
+    super(modelInstance.modelId || "ai-sdk-model");_class7.prototype.__init13.call(this);;
+    this.modelInstance = modelInstance;
+  }
+  /**
+   * Returns empty array - following Python ADK pattern
+   */
+  static supportedModels() {
+    return [];
+  }
+  async *generateContentAsyncImpl(request, stream = false) {
+    try {
+      const messages = this.convertToAiSdkMessages(request);
+      const systemMessage = request.getSystemInstructionText();
+      const tools = this.convertToAiSdkTools(request);
+      const requestParams = {
+        model: this.modelInstance,
+        messages,
+        system: systemMessage,
+        tools: Object.keys(tools).length > 0 ? tools : void 0,
+        maxTokens: _optionalChain([request, 'access', _122 => _122.config, 'optionalAccess', _123 => _123.maxOutputTokens]),
+        temperature: _optionalChain([request, 'access', _124 => _124.config, 'optionalAccess', _125 => _125.temperature]),
+        topP: _optionalChain([request, 'access', _126 => _126.config, 'optionalAccess', _127 => _127.topP])
+      };
+      if (stream) {
+        const result = _ai.streamText.call(void 0, requestParams);
+        let accumulatedText = "";
+        for await (const delta of result.textStream) {
+          accumulatedText += delta;
+          yield new LlmResponse({
+            content: {
+              role: "model",
+              parts: [{ text: accumulatedText }]
+            },
+            partial: true
+          });
+        }
+        const toolCalls = await result.toolCalls;
+        const parts = [];
+        if (accumulatedText) {
+          parts.push({ text: accumulatedText });
+        }
+        if (toolCalls && toolCalls.length > 0) {
+          for (const toolCall of toolCalls) {
+            parts.push({
+              functionCall: {
+                id: toolCall.toolCallId,
+                name: toolCall.toolName,
+                args: toolCall.args
+              }
+            });
+          }
+        }
+        const finalUsage = await result.usage;
+        const finishReason = await result.finishReason;
+        yield new LlmResponse({
+          content: {
+            role: "model",
+            parts: parts.length > 0 ? parts : [{ text: "" }]
+          },
+          usageMetadata: finalUsage ? {
+            promptTokenCount: finalUsage.promptTokens,
+            candidatesTokenCount: finalUsage.completionTokens,
+            totalTokenCount: finalUsage.totalTokens
+          } : void 0,
+          finishReason: this.mapFinishReason(finishReason),
+          turnComplete: true
+        });
+      } else {
+        const result = await _ai.generateText.call(void 0, requestParams);
+        const parts = [];
+        if (result.text) {
+          parts.push({ text: result.text });
+        }
+        if (result.toolCalls && result.toolCalls.length > 0) {
+          for (const toolCall of result.toolCalls) {
+            parts.push({
+              functionCall: {
+                id: toolCall.toolCallId,
+                name: toolCall.toolName,
+                args: toolCall.args
+              }
+            });
+          }
+        }
+        yield new LlmResponse({
+          content: {
+            role: "model",
+            parts: parts.length > 0 ? parts : [{ text: "" }]
+          },
+          usageMetadata: result.usage ? {
+            promptTokenCount: result.usage.promptTokens,
+            candidatesTokenCount: result.usage.completionTokens,
+            totalTokenCount: result.usage.totalTokens
+          } : void 0,
+          finishReason: this.mapFinishReason(result.finishReason),
+          turnComplete: true
+        });
+      }
+    } catch (error) {
+      this.logger.error(`AI SDK Error: ${String(error)}`, { error, request });
+      yield LlmResponse.fromError(error, {
+        errorCode: "AI_SDK_ERROR",
+        model: this.model
+      });
+    }
+  }
+  /**
+   * Convert ADK LlmRequest to AI SDK CoreMessage format
+   */
+  convertToAiSdkMessages(llmRequest) {
+    const messages = [];
+    for (const content of llmRequest.contents || []) {
+      const message = this.contentToAiSdkMessage(content);
+      if (message) {
+        messages.push(message);
+      }
+    }
+    return messages;
+  }
+  /**
+   * Convert ADK tools to AI SDK tools format
+   */
+  convertToAiSdkTools(llmRequest) {
+    const tools = {};
+    if (_optionalChain([llmRequest, 'access', _128 => _128.config, 'optionalAccess', _129 => _129.tools])) {
+      for (const toolConfig of llmRequest.config.tools) {
+        if ("functionDeclarations" in toolConfig) {
+          for (const funcDecl of toolConfig.functionDeclarations) {
+            tools[funcDecl.name] = {
+              description: funcDecl.description,
+              parameters: _ai.jsonSchema.call(void 0, funcDecl.parameters || {})
+            };
+          }
+        }
+      }
+    }
+    return tools;
+  }
+  /**
+   * Convert ADK Content to AI SDK CoreMessage
+   */
+  contentToAiSdkMessage(content) {
+    const role = this.mapRole(content.role);
+    if (!content.parts || content.parts.length === 0) {
+      return null;
+    }
+    if (content.parts.length === 1 && content.parts[0].text) {
+      const textContent = content.parts[0].text;
+      if (role === "system") {
+        return { role: "system", content: textContent };
+      }
+      if (role === "assistant") {
+        return { role: "assistant", content: textContent };
+      }
+      return { role: "user", content: textContent };
+    }
+    if (_optionalChain([content, 'access', _130 => _130.parts, 'optionalAccess', _131 => _131.some, 'call', _132 => _132((part) => part.functionCall)])) {
+      const textParts = content.parts.filter((part) => part.text);
+      const functionCalls = content.parts.filter((part) => part.functionCall);
+      const contentParts2 = [];
+      for (const textPart of textParts) {
+        if (textPart.text) {
+          contentParts2.push({
+            type: "text",
+            text: textPart.text
+          });
+        }
+      }
+      for (const funcPart of functionCalls) {
+        if (funcPart.functionCall) {
+          contentParts2.push({
+            type: "tool-call",
+            toolCallId: funcPart.functionCall.id,
+            toolName: funcPart.functionCall.name,
+            args: funcPart.functionCall.args
+          });
+        }
+      }
+      return {
+        role: "assistant",
+        content: contentParts2
+      };
+    }
+    if (_optionalChain([content, 'access', _133 => _133.parts, 'optionalAccess', _134 => _134.some, 'call', _135 => _135((part) => part.functionResponse)])) {
+      const functionResponses = content.parts.filter(
+        (part) => part.functionResponse
+      );
+      const contentParts2 = functionResponses.map((part) => ({
+        type: "tool-result",
+        toolCallId: part.functionResponse.id,
+        toolName: part.functionResponse.name || "unknown",
+        result: part.functionResponse.response
+      }));
+      return {
+        role: "tool",
+        content: contentParts2
+      };
+    }
+    const contentParts = [];
+    for (const part of content.parts) {
+      if (part.text) {
+        contentParts.push({
+          type: "text",
+          text: part.text
+        });
+      }
+    }
+    if (contentParts.length === 0) {
+      return null;
+    }
+    if (contentParts.length === 1) {
+      const textContent = contentParts[0].text;
+      if (role === "system") {
+        return { role: "system", content: textContent };
+      }
+      if (role === "assistant") {
+        return { role: "assistant", content: textContent };
+      }
+      return { role: "user", content: textContent };
+    }
+    if (role === "system") {
+      const combinedText = contentParts.map((p) => p.text).join("");
+      return { role: "system", content: combinedText };
+    }
+    if (role === "assistant") {
+      return { role: "assistant", content: contentParts };
+    }
+    return { role: "user", content: contentParts };
+  }
+  /**
+   * Map ADK role to AI SDK role
+   */
+  mapRole(role) {
+    switch (role) {
+      case "model":
+      case "assistant":
+        return "assistant";
+      case "system":
+        return "system";
+      default:
+        return "user";
+    }
+  }
+  /**
+   * Map AI SDK finish reason to ADK finish reason
+   */
+  mapFinishReason(finishReason) {
+    switch (finishReason) {
+      case "stop":
+      case "end_of_message":
+        return "STOP";
+      case "length":
+      case "max_tokens":
+        return "MAX_TOKENS";
+      default:
+        return "FINISH_REASON_UNSPECIFIED";
+    }
+  }
+}, _class7);
+
 // src/models/llm-registry.ts
 init_logger();
-var logger5 = new Logger({ name: "LLMRegistry" });
-var LLMRegistry = (_class6 = class _LLMRegistry {
+var LLMRegistry = (_class8 = class _LLMRegistry {
   /**
    * Map of model name regex to LLM class
    */
   static __initStatic() {this.llmRegistry = /* @__PURE__ */ new Map()}
+  static __initStatic2() {this.logger = new Logger({ name: "LLMRegistry" })}
   /**
    * Creates a new LLM instance
    *
@@ -2415,12 +2634,12 @@ var LLMRegistry = (_class6 = class _LLMRegistry {
    * Logs all registered models for debugging
    */
   static logRegisteredModels() {
-    logger5.debug(
+    _LLMRegistry.logger.debug(
       "Registered LLM models:",
       [..._LLMRegistry.llmRegistry.entries()].map(([regex]) => regex.toString())
     );
   }
-}, _class6.__initStatic(), _class6);
+}, _class8.__initStatic(), _class8.__initStatic2(), _class8);
 
 // src/models/registry.ts
 function registerProviders() {
@@ -2618,7 +2837,7 @@ var OAuth2Credential = class extends AuthCredential {
         "Cannot refresh token: no refresh token or refresh function"
       );
     }
-    const result = await _optionalChain([this, 'access', _151 => _151.refreshFunction, 'optionalCall', _152 => _152(this.refreshToken)]);
+    const result = await _optionalChain([this, 'access', _136 => _136.refreshFunction, 'optionalCall', _137 => _137(this.refreshToken)]);
     if (!result) {
       throw new Error("Failed to refresh token");
     }
@@ -2672,7 +2891,7 @@ var AuthHandler = class {
    * Gets the authentication token
    */
   getToken() {
-    return _optionalChain([this, 'access', _153 => _153.credential, 'optionalAccess', _154 => _154.getToken, 'call', _155 => _155()]);
+    return _optionalChain([this, 'access', _138 => _138.credential, 'optionalAccess', _139 => _139.getToken, 'call', _140 => _140()]);
   }
   /**
    * Gets headers for HTTP requests
@@ -2687,7 +2906,7 @@ var AuthHandler = class {
    * Refreshes the token if necessary
    */
   async refreshToken() {
-    if (_optionalChain([this, 'access', _156 => _156.credential, 'optionalAccess', _157 => _157.canRefresh, 'call', _158 => _158()])) {
+    if (_optionalChain([this, 'access', _141 => _141.credential, 'optionalAccess', _142 => _142.canRefresh, 'call', _143 => _143()])) {
       await this.credential.refresh();
     }
   }
@@ -2794,10 +3013,10 @@ var OpenIdConnectScheme = class extends AuthScheme {
 };
 
 // src/sessions/state.ts
-var State = (_class7 = class _State {
-  static __initStatic2() {this.APP_PREFIX = "app:"}
-  static __initStatic3() {this.USER_PREFIX = "user:"}
-  static __initStatic4() {this.TEMP_PREFIX = "temp:"}
+var State = (_class9 = class _State {
+  static __initStatic3() {this.APP_PREFIX = "app:"}
+  static __initStatic4() {this.USER_PREFIX = "user:"}
+  static __initStatic5() {this.TEMP_PREFIX = "temp:"}
   
   
   /**
@@ -2891,13 +3110,13 @@ var State = (_class7 = class _State {
     const state = new _State(value, delta);
     return _State.createProxy(state);
   }
-}, _class7.__initStatic2(), _class7.__initStatic3(), _class7.__initStatic4(), _class7);
+}, _class9.__initStatic3(), _class9.__initStatic4(), _class9.__initStatic5(), _class9);
 
 // src/events/event.ts
 var _uuid = require('uuid');
 
 // src/events/event-actions.ts
-var EventActions = (_class8 = class {
+var EventActions = (_class10 = class {
   /**
    * If true, it won't call model to summarize function response.
    * Only used for function_response event.
@@ -2906,12 +3125,12 @@ var EventActions = (_class8 = class {
   /**
    * Indicates that the event is updating the state with the given delta.
    */
-  __init11() {this.stateDelta = {}}
+  __init14() {this.stateDelta = {}}
   /**
    * Indicates that the event is updating an artifact. key is the filename,
    * value is the version.
    */
-  __init12() {this.artifactDelta = {}}
+  __init15() {this.artifactDelta = {}}
   /**
    * If set, the event transfers to the specified agent.
    */
@@ -2927,7 +3146,7 @@ var EventActions = (_class8 = class {
   /**
    * Constructor for EventActions
    */
-  constructor(options = {}) {;_class8.prototype.__init11.call(this);_class8.prototype.__init12.call(this);
+  constructor(options = {}) {;_class10.prototype.__init14.call(this);_class10.prototype.__init15.call(this);
     this.skipSummarization = options.skipSummarization;
     this.stateDelta = options.stateDelta || {};
     this.artifactDelta = options.artifactDelta || {};
@@ -2935,16 +3154,16 @@ var EventActions = (_class8 = class {
     this.escalate = options.escalate;
     this.requestedAuthConfigs = options.requestedAuthConfigs;
   }
-}, _class8);
+}, _class10);
 
 // src/events/event.ts
-var Event = (_class9 = class _Event extends LlmResponse {
+var Event = (_class11 = class _Event extends LlmResponse {
   /** The invocation ID of the event. */
-  __init13() {this.invocationId = ""}
+  __init16() {this.invocationId = ""}
   /** 'user' or the name of the agent, indicating who appended the event to the session. */
   
   /** The actions taken by the agent. */
-  __init14() {this.actions = new EventActions()}
+  __init17() {this.actions = new EventActions()}
   /**
    * Set of ids of the long running function calls.
    * Agent client will know from this field about which function call is long running.
@@ -2959,9 +3178,9 @@ var Event = (_class9 = class _Event extends LlmResponse {
    */
   
   /** The unique identifier of the event. */
-  __init15() {this.id = ""}
+  __init18() {this.id = ""}
   /** The timestamp of the event (seconds since epoch). */
-  __init16() {this.timestamp = Math.floor(Date.now() / 1e3)}
+  __init19() {this.timestamp = Math.floor(Date.now() / 1e3)}
   /**
    * Constructor for Event.
    */
@@ -2969,7 +3188,7 @@ var Event = (_class9 = class _Event extends LlmResponse {
     super({
       content: opts.content,
       partial: opts.partial
-    });_class9.prototype.__init13.call(this);_class9.prototype.__init14.call(this);_class9.prototype.__init15.call(this);_class9.prototype.__init16.call(this);;
+    });_class11.prototype.__init16.call(this);_class11.prototype.__init17.call(this);_class11.prototype.__init18.call(this);_class11.prototype.__init19.call(this);;
     this.invocationId = _nullishCoalesce(opts.invocationId, () => ( ""));
     this.author = opts.author;
     this.actions = _nullishCoalesce(opts.actions, () => ( new EventActions()));
@@ -3030,7 +3249,7 @@ var Event = (_class9 = class _Event extends LlmResponse {
   static newId() {
     return _uuid.v4.call(void 0, ).replace(/-/g, "").substring(0, 8);
   }
-}, _class9);
+}, _class11);
 
 // src/agents/readonly-context.ts
 var ReadonlyContext = class {
@@ -3136,7 +3355,7 @@ var CallbackContext = class extends ReadonlyContext {
 };
 
 // src/agents/base-agent.ts
-var BaseAgent = (_class10 = class {
+var BaseAgent = (_class12 = class {
   /**
    * The agent's name.
    * Agent name must be a valid identifier and unique within the agent tree.
@@ -3148,7 +3367,7 @@ var BaseAgent = (_class10 = class {
    * The model uses this to determine whether to delegate control to the agent.
    * One-line description is enough and preferred.
    */
-  __init17() {this.description = ""}
+  __init20() {this.description = ""}
   /**
    * The parent agent of this agent.
    * Note that an agent can ONLY be added as sub-agent once.
@@ -3160,7 +3379,7 @@ var BaseAgent = (_class10 = class {
   /**
    * The sub-agents of this agent.
    */
-  __init18() {this.subAgents = []}
+  __init21() {this.subAgents = []}
   /**
    * Callback or list of callbacks to be invoked before the agent run.
    * When a list of callbacks is provided, the callbacks will be called in the
@@ -3192,7 +3411,7 @@ var BaseAgent = (_class10 = class {
   /**
    * Constructor for BaseAgent
    */
-  constructor(config) {;_class10.prototype.__init17.call(this);_class10.prototype.__init18.call(this);
+  constructor(config) {;_class12.prototype.__init20.call(this);_class12.prototype.__init21.call(this);
     this.name = config.name;
     this.description = config.description || "";
     this.subAgents = config.subAgents || [];
@@ -3449,7 +3668,7 @@ var BaseAgent = (_class10 = class {
       subAgent.parentAgent = this;
     }
   }
-}, _class10);
+}, _class12);
 
 // src/agents/llm-agent.ts
 init_logger();
@@ -3573,8 +3792,8 @@ init_function_utils();
 // src/tools/common/google-search.ts
 init_logger();
 init_base_tool();
-var GoogleSearch = (_class11 = class extends BaseTool {
-  __init19() {this.logger = new Logger({ name: "GoogleSearch" })}
+var GoogleSearch = (_class13 = class extends BaseTool {
+  __init22() {this.logger = new Logger({ name: "GoogleSearch" })}
   /**
    * Constructor for GoogleSearch
    */
@@ -3582,7 +3801,7 @@ var GoogleSearch = (_class11 = class extends BaseTool {
     super({
       name: "google_search",
       description: "Search the web using Google"
-    });_class11.prototype.__init19.call(this);;
+    });_class13.prototype.__init22.call(this);;
   }
   /**
    * Get the function declaration for the tool
@@ -3631,7 +3850,7 @@ var GoogleSearch = (_class11 = class extends BaseTool {
       ]
     };
   }
-}, _class11);
+}, _class13);
 
 // src/tools/common/http-request-tool.ts
 init_base_tool();
@@ -3763,7 +3982,7 @@ var FileOperationsTool = class extends BaseTool {
       name: "file_operations",
       description: "Perform file system operations like reading, writing, and managing files"
     });
-    this.basePath = _optionalChain([options, 'optionalAccess', _159 => _159.basePath]) || process.cwd();
+    this.basePath = _optionalChain([options, 'optionalAccess', _144 => _144.basePath]) || process.cwd();
   }
   /**
    * Get the function declaration for the tool
@@ -4080,8 +4299,8 @@ var UserInteractionTool = class extends BaseTool {
 // src/tools/common/exit-loop-tool.ts
 init_logger();
 init_base_tool();
-var ExitLoopTool = (_class12 = class extends BaseTool {
-  __init20() {this.logger = new Logger({ name: "ExitLoopTool" })}
+var ExitLoopTool = (_class14 = class extends BaseTool {
+  __init23() {this.logger = new Logger({ name: "ExitLoopTool" })}
   /**
    * Constructor for ExitLoopTool
    */
@@ -4089,7 +4308,7 @@ var ExitLoopTool = (_class12 = class extends BaseTool {
     super({
       name: "exit_loop",
       description: "Exits the loop. Call this function only when you are instructed to do so."
-    });_class12.prototype.__init20.call(this);;
+    });_class14.prototype.__init23.call(this);;
   }
   /**
    * Execute the exit loop action
@@ -4098,13 +4317,13 @@ var ExitLoopTool = (_class12 = class extends BaseTool {
     this.logger.debug("Executing exit loop tool");
     context.actions.escalate = true;
   }
-}, _class12);
+}, _class14);
 
 // src/tools/common/get-user-choice-tool.ts
 init_logger();
 init_base_tool();
-var GetUserChoiceTool = (_class13 = class extends BaseTool {
-  __init21() {this.logger = new Logger({ name: "GetUserChoiceTool" })}
+var GetUserChoiceTool = (_class15 = class extends BaseTool {
+  __init24() {this.logger = new Logger({ name: "GetUserChoiceTool" })}
   /**
    * Constructor for GetUserChoiceTool
    */
@@ -4113,7 +4332,7 @@ var GetUserChoiceTool = (_class13 = 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
-    });_class13.prototype.__init21.call(this);;
+    });_class15.prototype.__init24.call(this);;
   }
   /**
    * Get the function declaration for the tool
@@ -4156,13 +4375,13 @@ var GetUserChoiceTool = (_class13 = class extends BaseTool {
     context.actions.skipSummarization = true;
     return null;
   }
-}, _class13);
+}, _class15);
 
 // src/tools/common/transfer-to-agent-tool.ts
 init_logger();
 init_base_tool();
-var TransferToAgentTool = (_class14 = class extends BaseTool {
-  __init22() {this.logger = new Logger({ name: "TransferToAgentTool" })}
+var TransferToAgentTool = (_class16 = class extends BaseTool {
+  __init25() {this.logger = new Logger({ name: "TransferToAgentTool" })}
   /**
    * Constructor for TransferToAgentTool
    */
@@ -4170,7 +4389,7 @@ var TransferToAgentTool = (_class14 = class extends BaseTool {
     super({
       name: "transfer_to_agent",
       description: "Transfer the question to another agent."
-    });_class14.prototype.__init22.call(this);;
+    });_class16.prototype.__init25.call(this);;
   }
   /**
    * Execute the transfer to agent action
@@ -4179,13 +4398,13 @@ var TransferToAgentTool = (_class14 = class extends BaseTool {
     this.logger.debug(`Executing transfer to agent: ${args.agent_name}`);
     context.actions.transferToAgent = args.agent_name;
   }
-}, _class14);
+}, _class16);
 
 // src/tools/common/load-memory-tool.ts
 init_logger();
 init_base_tool();
-var LoadMemoryTool = (_class15 = class extends BaseTool {
-  __init23() {this.logger = new Logger({ name: "LoadMemoryTool" })}
+var LoadMemoryTool = (_class17 = class extends BaseTool {
+  __init26() {this.logger = new Logger({ name: "LoadMemoryTool" })}
   /**
    * Constructor for LoadMemoryTool
    */
@@ -4193,7 +4412,7 @@ var LoadMemoryTool = (_class15 = class extends BaseTool {
     super({
       name: "load_memory",
       description: "Loads the memory for the current user based on a query."
-    });_class15.prototype.__init23.call(this);;
+    });_class17.prototype.__init26.call(this);;
   }
   /**
    * Get the function declaration for the tool
@@ -4223,7 +4442,7 @@ var LoadMemoryTool = (_class15 = class extends BaseTool {
       const searchResult = await context.searchMemory(args.query);
       return {
         memories: searchResult.memories || [],
-        count: _optionalChain([searchResult, 'access', _160 => _160.memories, 'optionalAccess', _161 => _161.length]) || 0
+        count: _optionalChain([searchResult, 'access', _145 => _145.memories, 'optionalAccess', _146 => _146.length]) || 0
       };
     } catch (error) {
       console.error("Error searching memory:", error);
@@ -4233,7 +4452,7 @@ var LoadMemoryTool = (_class15 = class extends BaseTool {
       };
     }
   }
-}, _class15);
+}, _class17);
 
 // src/tools/common/load-artifacts-tool.ts
 init_base_tool();
@@ -4384,10 +4603,10 @@ var McpError = class extends Error {
 };
 
 // src/tools/mcp/sampling-handler.ts
-var McpSamplingHandler = (_class16 = class {
-  __init24() {this.logger = new Logger({ name: "McpSamplingHandler" })}
+var McpSamplingHandler = (_class18 = class {
+  __init27() {this.logger = new Logger({ name: "McpSamplingHandler" })}
   
-  constructor(samplingHandler) {;_class16.prototype.__init24.call(this);
+  constructor(samplingHandler) {;_class18.prototype.__init27.call(this);
     this.samplingHandler = samplingHandler;
   }
   /**
@@ -4568,7 +4787,7 @@ var McpSamplingHandler = (_class16 = class {
     this.samplingHandler = handler;
     this.logger.debug("ADK sampling handler updated");
   }
-}, _class16);
+}, _class18);
 function createSamplingHandler(handler) {
   return handler;
 }
@@ -4602,14 +4821,14 @@ function withRetry(fn, instance, reinitMethod, maxRetries = 1) {
 }
 
 // src/tools/mcp/client.ts
-var McpClientService = (_class17 = class {
-  
-  __init25() {this.client = null}
-  __init26() {this.transport = null}
-  __init27() {this.isClosing = false}
-  __init28() {this.mcpSamplingHandler = null}
-  __init29() {this.logger = new Logger({ name: "McpClientService" })}
-  constructor(config) {;_class17.prototype.__init25.call(this);_class17.prototype.__init26.call(this);_class17.prototype.__init27.call(this);_class17.prototype.__init28.call(this);_class17.prototype.__init29.call(this);
+var McpClientService = (_class19 = class {
+  
+  __init28() {this.client = null}
+  __init29() {this.transport = null}
+  __init30() {this.isClosing = false}
+  __init31() {this.mcpSamplingHandler = null}
+  __init32() {this.logger = new Logger({ name: "McpClientService" })}
+  constructor(config) {;_class19.prototype.__init28.call(this);_class19.prototype.__init29.call(this);_class19.prototype.__init30.call(this);_class19.prototype.__init31.call(this);_class19.prototype.__init32.call(this);
     this.config = config;
     if (config.samplingHandler) {
       this.mcpSamplingHandler = new McpSamplingHandler(config.samplingHandler);
@@ -4665,15 +4884,13 @@ var McpClientService = (_class17 = class {
         await connectPromise;
       }
       await this.setupSamplingHandler(client);
-      if (this.config.debug) {
-        console.log("\u2705 MCP client connected successfully");
-      }
+      this.logger.debug("\u2705 MCP client connected successfully");
       this.client = client;
       return client;
     } catch (error) {
       await this.cleanupResources();
       if (!(error instanceof McpError)) {
-        console.error("Failed to initialize MCP client:", error);
+        this.logger.error("Failed to initialize MCP client:", error);
         throw new McpError(
           `Failed to initialize MCP client: ${error instanceof Error ? error.message : String(error)}`,
           "connection_error" /* CONNECTION_ERROR */,
@@ -4689,12 +4906,10 @@ var McpClientService = (_class17 = class {
   async createTransport() {
     try {
       if (this.config.transport.mode === "sse") {
-        if (this.config.debug) {
-          console.log(
-            "\u{1F680} Initializing MCP client in SSE mode",
-            this.config.transport.serverUrl
-          );
-        }
+        this.logger.debug(
+          "\u{1F680} Initializing MCP client in SSE mode",
+          this.config.transport.serverUrl
+        );
         const headers = {
           ...this.config.transport.headers || {},
           ...this.config.headers || {}
@@ -4709,12 +4924,10 @@ var McpClientService = (_class17 = class {
           }
         );
       }
-      if (this.config.debug) {
-        console.log(
-          "\u{1F680} Initializing MCP client in STDIO mode",
-          this.config.transport.command
-        );
-      }
+      this.logger.debug(
+        "\u{1F680} Initializing MCP client in STDIO mode",
+        this.config.transport.command
+      );
       return new (0, _stdiojs.StdioClientTransport)({
         command: this.config.transport.command,
         args: this.config.transport.args,
@@ -4733,9 +4946,7 @@ var McpClientService = (_class17 = class {
    * Used by the retry mechanism.
    */
   async reinitialize() {
-    if (this.config.debug) {
-      console.log("\u{1F504} Reinitializing MCP client after closed connection");
-    }
+    this.logger.debug("\u{1F504} Reinitializing MCP client after closed connection");
     await this.cleanupResources();
     this.client = null;
     this.transport = null;
@@ -4759,11 +4970,9 @@ var McpClientService = (_class17 = class {
       if (this.transport && typeof this.transport.close === "function") {
         await this.transport.close();
       }
-      if (this.config.debug) {
-        console.log("\u{1F9F9} Cleaned up MCP client resources");
-      }
+      this.logger.debug("\u{1F9F9} Cleaned up MCP client resources");
     } catch (error) {
-      console.error("Error cleaning up MCP resources:", error);
+      this.logger.error("Error cleaning up MCP resources:", error);
     } finally {
       this.client = null;
       this.transport = null;
@@ -4785,7 +4994,7 @@ var McpClientService = (_class17 = class {
         },
         this,
         async (instance) => await instance.reinitialize(),
-        _optionalChain([this, 'access', _162 => _162.config, 'access', _163 => _163.retryOptions, 'optionalAccess', _164 => _164.maxRetries]) || 2
+        _optionalChain([this, 'access', _147 => _147.config, 'access', _148 => _148.retryOptions, 'optionalAccess', _149 => _149.maxRetries]) || 2
       );
       return await wrappedCall();
     } catch (error) {
@@ -4805,9 +5014,7 @@ var McpClientService = (_class17 = class {
    * Similar to Python's close() method.
    */
   async close() {
-    if (this.config.debug) {
-      console.log("\u{1F51A} Closing MCP client service");
-    }
+    this.logger.debug("\u{1F51A} Closing MCP client service");
     await this.cleanupResources();
   }
   /**
@@ -4818,11 +5025,9 @@ var McpClientService = (_class17 = class {
   }
   async setupSamplingHandler(client) {
     if (!this.mcpSamplingHandler) {
-      if (this.config.debug) {
-        console.log(
-          "\u26A0\uFE0F No sampling handler provided - sampling requests will be rejected"
-        );
-      }
+      this.logger.debug(
+        "\u26A0\uFE0F No sampling handler provided - sampling requests will be rejected"
+      );
       return;
     }
     try {
@@ -4832,12 +5037,10 @@ var McpClientService = (_class17 = class {
           try {
             this.logger.debug("Received sampling request:", request);
             const response = await this.mcpSamplingHandler.handleSamplingRequest(request);
-            if (this.config.debug) {
-              console.log("\u2705 Sampling request completed successfully");
-            }
+            this.logger.debug("\u2705 Sampling request completed successfully");
             return response;
           } catch (error) {
-            console.error("\u274C Error handling sampling request:", error);
+            this.logger.error("\u274C Error handling sampling request:", error);
             if (error instanceof McpError) {
               throw error;
             }
@@ -4849,16 +5052,12 @@ var McpClientService = (_class17 = class {
           }
         }
       );
-      if (this.config.debug) {
-        console.log("\u{1F3AF} Sampling handler registered successfully");
-      }
+      this.logger.debug("\u{1F3AF} Sampling handler registered successfully");
     } catch (error) {
-      console.error("Failed to setup sampling handler:", error);
-      if (this.config.debug) {
-        console.log(
-          "\u26A0\uFE0F Sampling handler registration failed, continuing without sampling support"
-        );
-      }
+      this.logger.error("Failed to setup sampling handler:", error);
+      this.logger.debug(
+        "\u26A0\uFE0F Sampling handler registration failed, continuing without sampling support"
+      );
     }
   }
   /**
@@ -4868,7 +5067,7 @@ var McpClientService = (_class17 = class {
     this.mcpSamplingHandler = new McpSamplingHandler(handler);
     if (this.client) {
       this.setupSamplingHandler(this.client).catch((error) => {
-        console.error("Failed to update ADK sampling handler:", error);
+        this.logger.error("Failed to update ADK sampling handler:", error);
       });
     }
   }
@@ -4879,13 +5078,13 @@ var McpClientService = (_class17 = class {
     this.mcpSamplingHandler = null;
     if (this.client) {
       try {
-        _optionalChain([this, 'access', _165 => _165.client, 'access', _166 => _166.removeRequestHandler, 'optionalCall', _167 => _167("sampling/createMessage")]);
+        _optionalChain([this, 'access', _150 => _150.client, 'access', _151 => _151.removeRequestHandler, 'optionalCall', _152 => _152("sampling/createMessage")]);
       } catch (error) {
-        console.error("Failed to remove sampling handler:", error);
+        this.logger.error("Failed to remove sampling handler:", error);
       }
     }
   }
-}, _class17);
+}, _class19);
 
 // src/tools/mcp/create-tool.ts
 init_logger();
@@ -5087,11 +5286,11 @@ async function createTool(mcpTool, client) {
     throw error;
   }
 }
-var McpToolAdapter = (_class18 = class extends BaseTool {
+var McpToolAdapter = (_class20 = class extends BaseTool {
   
   
-  __init30() {this.clientService = null}
-  __init31() {this.logger = new Logger({ name: "McpToolAdapter" })}
+  __init33() {this.clientService = null}
+  __init34() {this.logger = new Logger({ name: "McpToolAdapter" })}
   constructor(mcpTool, client) {
     const metadata = mcpTool.metadata || {};
     super({
@@ -5100,7 +5299,7 @@ var McpToolAdapter = (_class18 = class extends BaseTool {
       isLongRunning: _nullishCoalesce(metadata.isLongRunning, () => ( false)),
       shouldRetryOnFailure: _nullishCoalesce(metadata.shouldRetryOnFailure, () => ( false)),
       maxRetryAttempts: _nullishCoalesce(metadata.maxRetryAttempts, () => ( 3))
-    });_class18.prototype.__init30.call(this);_class18.prototype.__init31.call(this);;
+    });_class20.prototype.__init33.call(this);_class20.prototype.__init34.call(this);;
     this.mcpTool = mcpTool;
     this.client = client;
     if (client.reinitialize && typeof client.reinitialize === "function") {
@@ -5173,11 +5372,17 @@ var McpToolAdapter = (_class18 = class extends BaseTool {
       throw error;
     }
   }
-}, _class18);
+}, _class20);
 
 // src/tools/mcp/servers.ts
 function createMcpConfig(name, packageName, config = {}) {
-  const { debug, description, retryOptions, env: envVars = {} } = config;
+  const {
+    debug,
+    description,
+    retryOptions,
+    env: envVars = {},
+    samplingHandler
+  } = config;
   const env = {};
   for (const [key, value] of Object.entries(envVars)) {
     if (value !== void 0) {
@@ -5197,7 +5402,8 @@ function createMcpConfig(name, packageName, config = {}) {
       command: "npx",
       args: ["-y", packageName],
       env
-    }
+    },
+    samplingHandler
   };
 }
 function McpAbi(config = {}) {
@@ -5242,7 +5448,7 @@ function McpNearAgent(config = {}) {
 }
 function McpNearIntentSwaps(config = {}) {
   const mcpConfig = createMcpConfig(
-    "NEAR Intent Swaps MCP Client",
+    "Near Intents Swaps MCP Client",
     "@iqai/mcp-near-intent-swaps",
     config
   );
@@ -5287,13 +5493,13 @@ function McpGeneric(packageName, config = {}, name) {
 }
 
 // src/tools/mcp/index.ts
-var McpToolset = (_class19 = class {
+var McpToolset = (_class21 = class {
   
-  __init32() {this.clientService = null}
-  __init33() {this.toolFilter = null}
-  __init34() {this.tools = []}
-  __init35() {this.isClosing = false}
-  constructor(config, toolFilter = null) {;_class19.prototype.__init32.call(this);_class19.prototype.__init33.call(this);_class19.prototype.__init34.call(this);_class19.prototype.__init35.call(this);
+  __init35() {this.clientService = null}
+  __init36() {this.toolFilter = null}
+  __init37() {this.tools = []}
+  __init38() {this.isClosing = false}
+  constructor(config, toolFilter = null) {;_class21.prototype.__init35.call(this);_class21.prototype.__init36.call(this);_class21.prototype.__init37.call(this);_class21.prototype.__init38.call(this);
     this.config = config;
     this.toolFilter = toolFilter;
     this.clientService = new McpClientService(config);
@@ -5368,7 +5574,7 @@ var McpToolset = (_class19 = class {
           "resource_closed_error" /* RESOURCE_CLOSED_ERROR */
         );
       }
-      if (this.tools.length > 0 && !_optionalChain([this, 'access', _168 => _168.config, 'access', _169 => _169.cacheConfig, 'optionalAccess', _170 => _170.enabled]) === false) {
+      if (this.tools.length > 0 && !_optionalChain([this, 'access', _153 => _153.config, 'access', _154 => _154.cacheConfig, 'optionalAccess', _155 => _155.enabled]) === false) {
         return this.tools;
       }
       if (!this.clientService) {
@@ -5394,7 +5600,7 @@ var McpToolset = (_class19 = class {
           }
         }
       }
-      if (_optionalChain([this, 'access', _171 => _171.config, 'access', _172 => _172.cacheConfig, 'optionalAccess', _173 => _173.enabled]) !== false) {
+      if (_optionalChain([this, 'access', _156 => _156.config, 'access', _157 => _157.cacheConfig, 'optionalAccess', _158 => _158.enabled]) !== false) {
         this.tools = tools;
       }
       return tools;
@@ -5454,7 +5660,7 @@ var McpToolset = (_class19 = class {
   async dispose() {
     await this.close();
   }
-}, _class19);
+}, _class21);
 async function getMcpTools(config, toolFilter) {
   const toolset = new McpToolset(config, toolFilter);
   try {
@@ -5482,12 +5688,12 @@ function populateClientFunctionCallId(modelResponseEvent) {
   }
 }
 function removeClientFunctionCallId(content) {
-  if (_optionalChain([content, 'optionalAccess', _174 => _174.parts])) {
+  if (_optionalChain([content, 'optionalAccess', _159 => _159.parts])) {
     for (const part of content.parts) {
-      if (_optionalChain([part, 'access', _175 => _175.functionCall, 'optionalAccess', _176 => _176.id, 'optionalAccess', _177 => _177.startsWith, 'call', _178 => _178(AF_FUNCTION_CALL_ID_PREFIX)])) {
+      if (_optionalChain([part, 'access', _160 => _160.functionCall, 'optionalAccess', _161 => _161.id, 'optionalAccess', _162 => _162.startsWith, 'call', _163 => _163(AF_FUNCTION_CALL_ID_PREFIX)])) {
         part.functionCall.id = void 0;
       }
-      if (_optionalChain([part, 'access', _179 => _179.functionResponse, 'optionalAccess', _180 => _180.id, 'optionalAccess', _181 => _181.startsWith, 'call', _182 => _182(AF_FUNCTION_CALL_ID_PREFIX)])) {
+      if (_optionalChain([part, 'access', _164 => _164.functionResponse, 'optionalAccess', _165 => _165.id, 'optionalAccess', _166 => _166.startsWith, 'call', _167 => _167(AF_FUNCTION_CALL_ID_PREFIX)])) {
         part.functionResponse.id = void 0;
       }
     }
@@ -5632,7 +5838,7 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
   }
   const mergedParts = [];
   for (const event of functionResponseEvents) {
-    if (_optionalChain([event, 'access', _183 => _183.content, 'optionalAccess', _184 => _184.parts])) {
+    if (_optionalChain([event, 'access', _168 => _168.content, 'optionalAccess', _169 => _169.parts])) {
       for (const part of event.content.parts) {
         mergedParts.push(part);
       }
@@ -5665,94 +5871,52 @@ function isLlmAgent(agent) {
 
 // src/flows/llm-flows/base-llm-flow.ts
 var _ADK_AGENT_NAME_LABEL_KEY = "adk_agent_name";
-var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36.call(this);_class20.prototype.__init37.call(this);_class20.prototype.__init38.call(this); }
-  __init36() {this.requestProcessors = []}
-  __init37() {this.responseProcessors = []}
-  __init38() {this.logger = new Logger({ name: "BaseLlmFlow" })}
+var BaseLlmFlow = (_class22 = class {constructor() { _class22.prototype.__init39.call(this);_class22.prototype.__init40.call(this);_class22.prototype.__init41.call(this); }
+  __init39() {this.requestProcessors = []}
+  __init40() {this.responseProcessors = []}
+  __init41() {this.logger = new Logger({ name: "BaseLlmFlow" })}
   async *runAsync(invocationContext) {
-    this.logger.debug("\u{1F680} Starting runAsync flow", {
-      invocationId: invocationContext.invocationId,
-      agentName: invocationContext.agent.name,
-      branch: invocationContext.branch
-    });
+    this.logger.info(`Agent '${invocationContext.agent.name}' started.`);
     let stepCount = 0;
     while (true) {
       stepCount++;
-      this.logger.debug(`\u{1F4CB} Running step ${stepCount}`, {
-        invocationId: invocationContext.invocationId
-      });
       let lastEvent = null;
-      let eventCount = 0;
       for await (const event of this._runOneStepAsync(invocationContext)) {
-        eventCount++;
         lastEvent = event;
-        this.logger.debug(
-          `\u{1F4E4} Yielding event ${eventCount} from step ${stepCount}`,
-          {
-            eventId: event.id,
-            eventType: event.constructor.name,
-            hasContent: !!event.content,
-            isFinalResponse: event.isFinalResponse(),
-            partial: event.partial
-          }
-        );
         yield event;
       }
       if (!lastEvent || lastEvent.isFinalResponse()) {
-        this.logger.debug("\u2705 Flow completed", {
-          reason: !lastEvent ? "no_events" : "final_response",
-          totalSteps: stepCount
-        });
+        this.logger.info(
+          `Agent '${invocationContext.agent.name}' finished after ${stepCount} steps.`
+        );
         break;
       }
       if (lastEvent.partial) {
-        this.logger.error("\u274C Flow error: Last event is partial", {
-          eventId: lastEvent.id,
-          stepCount
-        });
+        this.logger.error(
+          "Partial event encountered. LLM max output limit may be reached."
+        );
         throw new Error(
           "Last event shouldn't be partial. LLM max output limit may be reached."
         );
       }
     }
-    this.logger.debug("\u{1F3C1} runAsync flow finished", {
-      totalSteps: stepCount,
-      invocationId: invocationContext.invocationId
-    });
   }
   async *runLive(invocationContext) {
-    this.logger.debug("\u{1F534} Starting runLive flow", {
-      invocationId: invocationContext.invocationId,
-      agentName: invocationContext.agent.name
-    });
     this.logger.warn("\u26A0\uFE0F runLive not fully implemented, delegating to runAsync");
     yield* this.runAsync(invocationContext);
   }
   async *_runOneStepAsync(invocationContext) {
-    this.logger.debug("\u{1F504} Starting one step execution", {
-      invocationId: invocationContext.invocationId
-    });
     const llmRequest = new LlmRequest();
-    this.logger.debug("\u{1F4DD} Created new LlmRequest", {
-      requestId: llmRequest.id || "unknown"
-    });
-    this.logger.debug("\u{1F527} Starting preprocessing phase");
     let preprocessEventCount = 0;
     for await (const event of this._preprocessAsync(
       invocationContext,
       llmRequest
     )) {
       preprocessEventCount++;
-      this.logger.debug(`\u{1F4E4} Preprocessing event ${preprocessEventCount}`, {
-        eventId: event.id
-      });
       yield event;
     }
-    this.logger.debug("\u2705 Preprocessing completed", {
-      eventCount: preprocessEventCount
-    });
     if (invocationContext.endInvocation) {
-      this.logger.debug("\u{1F6D1} Invocation ended during preprocessing");
+      this.logger.info("Invocation ended during preprocessing.");
       return;
     }
     const modelResponseEvent = new Event({
@@ -5761,9 +5925,6 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
       author: invocationContext.agent.name,
       branch: invocationContext.branch
     });
-    this.logger.debug("\u{1F916} Starting LLM call phase", {
-      modelResponseEventId: modelResponseEvent.id
-    });
     let llmResponseCount = 0;
     for await (const llmResponse of this._callLlmAsync(
       invocationContext,
@@ -5771,12 +5932,6 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
       modelResponseEvent
     )) {
       llmResponseCount++;
-      this.logger.debug(`\u{1F504} Processing LLM response ${llmResponseCount}`, {
-        hasContent: !!llmResponse.content,
-        hasError: !!llmResponse.errorCode,
-        interrupted: !!llmResponse.interrupted,
-        partial: !!llmResponse.partial
-      });
       for await (const event of this._postprocessAsync(
         invocationContext,
         llmRequest,
@@ -5784,89 +5939,47 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
         modelResponseEvent
       )) {
         modelResponseEvent.id = Event.newId();
-        this.logger.debug("\u{1F4E4} Yielding postprocessed event", {
-          eventId: event.id,
-          hasFunctionCalls: !!event.getFunctionCalls()
-        });
         yield event;
       }
     }
-    this.logger.debug("\u2705 One step execution completed", {
-      llmResponseCount
-    });
   }
   async *_preprocessAsync(invocationContext, llmRequest) {
-    this.logger.debug("\u{1F527} Starting preprocessing", {
-      processorCount: this.requestProcessors.length
-    });
     const agent = invocationContext.agent;
     if (!("canonicalTools" in agent) || typeof agent.canonicalTools !== "function") {
-      this.logger.debug("\u2139\uFE0F Agent has no canonical tools");
       return;
     }
-    for (let i = 0; i < this.requestProcessors.length; i++) {
-      const processor = this.requestProcessors[i];
-      this.logger.debug(`\u{1F504} Running request processor ${i + 1}`, {
-        processorName: _optionalChain([processor, 'access', _185 => _185.constructor, 'optionalAccess', _186 => _186.name]) || "unknown"
-      });
-      let processorEventCount = 0;
+    for (const processor of this.requestProcessors) {
       for await (const event of processor.runAsync(
         invocationContext,
         llmRequest
       )) {
-        processorEventCount++;
-        this.logger.debug(
-          `\u{1F4E4} Request processor ${i + 1} event ${processorEventCount}`,
-          {
-            eventId: event.id
-          }
-        );
         yield event;
       }
-      this.logger.debug(`\u2705 Request processor ${i + 1} completed`, {
-        eventCount: processorEventCount
-      });
     }
     const tools = await agent.canonicalTools(
       new ReadonlyContext(invocationContext)
     );
-    this.logger.debug("\u{1F6E0}\uFE0F Processing canonical tools", {
-      toolCount: tools.length
-    });
-    for (let i = 0; i < tools.length; i++) {
-      const tool = tools[i];
-      this.logger.debug(`\u{1F504} Processing tool ${i + 1}`, {
-        toolName: _optionalChain([tool, 'access', _187 => _187.constructor, 'optionalAccess', _188 => _188.name]) || "unknown"
-      });
+    for (const tool of tools) {
       const toolContext = new ToolContext(invocationContext);
       await tool.processLlmRequest(toolContext, llmRequest);
-      this.logger.debug(`\u2705 Tool ${i + 1} processed`);
     }
-    this.logger.debug("\u2705 Preprocessing completed", {
-      totalTools: tools.length
-    });
+    if (tools.length > 0) {
+      const toolsData = tools.map((tool) => ({
+        Name: tool.name,
+        Description: _optionalChain([tool, 'access', _170 => _170.description, 'optionalAccess', _171 => _171.substring, 'call', _172 => _172(0, 50)]) + (_optionalChain([tool, 'access', _173 => _173.description, 'optionalAccess', _174 => _174.length]) > 50 ? "..." : ""),
+        "Long Running": tool.isLongRunning ? "Yes" : "No"
+      }));
+      this.logger.debugArray("\u{1F6E0}\uFE0F Available Tools", toolsData);
+    }
   }
   async *_postprocessAsync(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
-    this.logger.debug("\u{1F504} Starting postprocessing", {
-      hasContent: !!llmResponse.content,
-      hasError: !!llmResponse.errorCode,
-      interrupted: !!llmResponse.interrupted
-    });
-    let processorEventCount = 0;
     for await (const event of this._postprocessRunProcessorsAsync(
       invocationContext,
       llmResponse
     )) {
-      processorEventCount++;
-      this.logger.debug(`\u{1F4E4} Response processor event ${processorEventCount}`, {
-        eventId: event.id
-      });
       yield event;
     }
     if (!llmResponse.content && !llmResponse.errorCode && !llmResponse.interrupted) {
-      this.logger.debug(
-        "\u2139\uFE0F Skipping event creation - no content, error, or interruption"
-      );
       return;
     }
     const finalizedEvent = this._finalizeModelResponseEvent(
@@ -5874,54 +5987,32 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
       llmResponse,
       modelResponseEvent
     );
-    this.logger.debug("\u{1F4DD} Finalized model response event", {
-      eventId: finalizedEvent.id,
-      hasContent: !!finalizedEvent.content,
-      hasFunctionCalls: !!finalizedEvent.getFunctionCalls(),
-      longRunningToolIds: finalizedEvent.longRunningToolIds.entries.length || 0
-    });
     yield finalizedEvent;
     const functionCalls = finalizedEvent.getFunctionCalls();
-    if (functionCalls) {
-      this.logger.debug("\u{1F527} Processing function calls", {
-        functionCallCount: functionCalls.length
-      });
-      let functionEventCount = 0;
+    if (functionCalls && functionCalls.length > 0) {
+      const functionCallsData = functionCalls.map((fc) => ({
+        Name: fc.name,
+        Arguments: JSON.stringify(fc.args).substring(0, 100) + (JSON.stringify(fc.args).length > 100 ? "..." : ""),
+        ID: fc.id || "auto"
+      }));
+      this.logger.debugArray("\u{1F527} Function Calls", functionCallsData);
       for await (const event of this._postprocessHandleFunctionCallsAsync(
         invocationContext,
         finalizedEvent,
         llmRequest
       )) {
-        functionEventCount++;
-        this.logger.debug(`\u{1F4E4} Function call event ${functionEventCount}`, {
-          eventId: event.id
-        });
         yield event;
       }
-      this.logger.debug("\u2705 Function calls processed", {
-        eventCount: functionEventCount
-      });
     }
-    this.logger.debug("\u2705 Postprocessing completed");
   }
   async *_postprocessLive(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
-    this.logger.debug("\u{1F534} Starting live postprocessing", {
-      hasContent: !!llmResponse.content,
-      turnComplete: !!llmResponse.turnComplete
-    });
     for await (const event of this._postprocessRunProcessorsAsync(
       invocationContext,
       llmResponse
     )) {
-      this.logger.debug("\u{1F4E4} Live response processor event", {
-        eventId: event.id
-      });
       yield event;
     }
     if (!llmResponse.content && !llmResponse.errorCode && !llmResponse.interrupted && !llmResponse.turnComplete) {
-      this.logger.debug(
-        "\u2139\uFE0F Skipping live event - no content or completion signal"
-      );
       return;
     }
     const finalizedEvent = this._finalizeModelResponseEvent(
@@ -5929,165 +6020,83 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
       llmResponse,
       modelResponseEvent
     );
-    this.logger.debug("\u{1F4DD} Finalized live model response event", {
-      eventId: finalizedEvent.id,
-      hasFunctionCalls: !!finalizedEvent.getFunctionCalls()
-    });
     yield finalizedEvent;
     if (finalizedEvent.getFunctionCalls()) {
-      this.logger.debug("\u{1F527} Processing live function calls");
       const functionResponseEvent = await handleFunctionCallsAsync(
         invocationContext,
         finalizedEvent,
         llmRequest.toolsDict || {}
       );
       if (functionResponseEvent) {
-        this.logger.debug("\u{1F4E4} Live function response event", {
-          eventId: functionResponseEvent.id,
-          hasTransfer: !!_optionalChain([functionResponseEvent, 'access', _189 => _189.actions, 'optionalAccess', _190 => _190.transferToAgent])
-        });
         yield functionResponseEvent;
-        const transferToAgent = _optionalChain([functionResponseEvent, 'access', _191 => _191.actions, 'optionalAccess', _192 => _192.transferToAgent]);
+        const transferToAgent = _optionalChain([functionResponseEvent, 'access', _175 => _175.actions, 'optionalAccess', _176 => _176.transferToAgent]);
         if (transferToAgent) {
-          this.logger.debug("\u{1F504} Transferring to agent in live mode", {
-            targetAgent: transferToAgent
-          });
+          this.logger.info(`\u{1F504} Live transfer to agent '${transferToAgent}'`);
           const agentToRun = this._getAgentToRun(
             invocationContext,
             transferToAgent
           );
-          let transferEventCount = 0;
-          for await (const event of _optionalChain([agentToRun, 'access', _193 => _193.runLive, 'optionalCall', _194 => _194(invocationContext)]) || agentToRun.runAsync(invocationContext)) {
-            transferEventCount++;
-            this.logger.debug(`\u{1F4E4} Transfer agent event ${transferEventCount}`, {
-              eventId: event.id
-            });
+          for await (const event of _optionalChain([agentToRun, 'access', _177 => _177.runLive, 'optionalCall', _178 => _178(invocationContext)]) || agentToRun.runAsync(invocationContext)) {
             yield event;
           }
-          this.logger.debug("\u2705 Agent transfer completed", {
-            eventCount: transferEventCount
-          });
         }
       }
     }
-    this.logger.debug("\u2705 Live postprocessing completed");
   }
   async *_postprocessRunProcessorsAsync(invocationContext, llmResponse) {
-    this.logger.debug("\u{1F504} Running response processors", {
-      processorCount: this.responseProcessors.length
-    });
-    for (let i = 0; i < this.responseProcessors.length; i++) {
-      const processor = this.responseProcessors[i];
-      this.logger.debug(`\u{1F504} Running response processor ${i + 1}`, {
-        processorName: _optionalChain([processor, 'access', _195 => _195.constructor, 'optionalAccess', _196 => _196.name]) || "unknown"
-      });
-      let processorEventCount = 0;
+    for (const processor of this.responseProcessors) {
       for await (const event of processor.runAsync(
         invocationContext,
         llmResponse
       )) {
-        processorEventCount++;
-        this.logger.debug(
-          `\u{1F4E4} Response processor ${i + 1} event ${processorEventCount}`,
-          {
-            eventId: event.id
-          }
-        );
         yield event;
       }
-      this.logger;
-      this.logger.debug(`\u2705 Response processor ${i + 1} completed`, {
-        eventCount: processorEventCount
-      });
     }
-    this.logger.debug("\u2705 All response processors completed");
   }
   async *_postprocessHandleFunctionCallsAsync(invocationContext, functionCallEvent, llmRequest) {
-    this.logger.debug("\u{1F527} Handling function calls", {
-      eventId: functionCallEvent.id,
-      toolsDictSize: Object.keys(llmRequest.toolsDict || {}).length
-    });
     const functionResponseEvent = await handleFunctionCallsAsync(
       invocationContext,
       functionCallEvent,
       llmRequest.toolsDict || {}
     );
     if (functionResponseEvent) {
-      this.logger.debug("\u{1F4CB} Function calls executed", {
-        responseEventId: functionResponseEvent.id,
-        hasActions: !!functionResponseEvent.actions
-      });
       const authEvent = generateAuthEvent(
         invocationContext,
         functionResponseEvent
       );
       if (authEvent) {
-        this.logger.debug("\u{1F510} Generated auth event", {
-          authEventId: authEvent.id
-        });
         yield authEvent;
       }
       yield functionResponseEvent;
-      const transferToAgent = _optionalChain([functionResponseEvent, 'access', _197 => _197.actions, 'optionalAccess', _198 => _198.transferToAgent]);
+      const transferToAgent = _optionalChain([functionResponseEvent, 'access', _179 => _179.actions, 'optionalAccess', _180 => _180.transferToAgent]);
       if (transferToAgent) {
-        this.logger.debug("\u{1F504} Transferring to agent", {
-          targetAgent: transferToAgent
-        });
+        this.logger.info(`\u{1F504} Transferring to agent '${transferToAgent}'`);
         const agentToRun = this._getAgentToRun(
           invocationContext,
           transferToAgent
         );
-        let transferEventCount = 0;
         for await (const event of agentToRun.runAsync(invocationContext)) {
-          transferEventCount++;
-          this.logger.debug(`\u{1F4E4} Transfer agent event ${transferEventCount}`, {
-            eventId: event.id
-          });
           yield event;
         }
-        this.logger.debug("\u2705 Agent transfer completed", {
-          eventCount: transferEventCount
-        });
       }
-    } else {
-      this.logger.debug("\u2139\uFE0F No function response event generated");
     }
   }
   _getAgentToRun(invocationContext, agentName) {
-    this.logger.debug("\u{1F50D} Finding agent to run", {
-      targetAgent: agentName,
-      currentAgent: invocationContext.agent.name
-    });
     const rootAgent = invocationContext.agent.rootAgent;
     const agentToRun = rootAgent.findAgent(agentName);
     if (!agentToRun) {
-      this.logger.error("\u274C Agent not found", {
-        targetAgent: agentName,
-        rootAgent: rootAgent.name
-      });
+      this.logger.error(`Agent '${agentName}' not found in the agent tree.`);
       throw new Error(`Agent ${agentName} not found in the agent tree.`);
     }
-    this.logger.debug("\u2705 Agent found", {
-      targetAgent: agentName,
-      agentType: agentToRun.constructor.name
-    });
     return agentToRun;
   }
   async *_callLlmAsync(invocationContext, llmRequest, modelResponseEvent) {
-    this.logger.debug("\u{1F916} Starting LLM call", {
-      model: llmRequest.model || "default",
-      eventId: modelResponseEvent.id
-    });
-    this.logger.debug("\u{1F504} Processing before model callbacks");
     const beforeModelCallbackContent = await this._handleBeforeModelCallback(
       invocationContext,
       llmRequest,
       modelResponseEvent
     );
     if (beforeModelCallbackContent) {
-      this.logger.debug("\u{1F4CB} Before model callback returned content", {
-        hasContent: !!beforeModelCallbackContent.content
-      });
       yield beforeModelCallbackContent;
       return;
     }
@@ -6095,27 +6104,38 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
     llmRequest.config.labels = llmRequest.config.labels || {};
     if (!(_ADK_AGENT_NAME_LABEL_KEY in llmRequest.config.labels)) {
       llmRequest.config.labels[_ADK_AGENT_NAME_LABEL_KEY] = invocationContext.agent.name;
-      this.logger.debug("\u{1F3F7}\uFE0F Added agent name label", {
-        agentName: invocationContext.agent.name
-      });
     }
     const llm = this.__getLlm(invocationContext);
-    this.logger.debug("\u{1F527} Retrieved LLM instance", {
-      llmModel: llm.model,
-      llmType: llm.constructor.name
-    });
     const runConfig = invocationContext.runConfig;
     if (runConfig.supportCfc) {
       this.logger.warn(
-        "\u26A0\uFE0F CFC (supportCfc) not fully implemented, using standard flow"
+        "CFC (supportCfc) not fully implemented, using standard flow."
       );
     }
     invocationContext.incrementLlmCallCount();
-    this.logger.debug("\u{1F4C8} Incremented LLM call count");
     const isStreaming = invocationContext.runConfig.streamingMode === "sse" /* SSE */;
-    this.logger.debug("\u{1F30A} LLM generation mode", {
-      streaming: isStreaming,
-      streamingMode: invocationContext.runConfig.streamingMode
+    const tools = _optionalChain([llmRequest, 'access', _181 => _181.config, 'optionalAccess', _182 => _182.tools]) || [];
+    const toolNames = tools.map((tool) => {
+      if (tool.functionDeclarations && Array.isArray(tool.functionDeclarations)) {
+        return tool.functionDeclarations.map((fn) => fn.name).join(", ");
+      }
+      if (tool.name) return tool.name;
+      if (_optionalChain([tool, 'access', _183 => _183.function, 'optionalAccess', _184 => _184.name])) return tool.function.name;
+      if (_optionalChain([tool, 'access', _185 => _185.function, 'optionalAccess', _186 => _186.function, 'optionalAccess', _187 => _187.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', _188 => _188.contents, 'optionalAccess', _189 => _189.length]) > 0 ? this._formatContentPreview(llmRequest.contents[0]) : "none";
+    this.logger.debugStructured("\u{1F4E4} LLM Request", {
+      Model: llm.model,
+      Agent: invocationContext.agent.name,
+      "Content Items": _optionalChain([llmRequest, 'access', _190 => _190.contents, 'optionalAccess', _191 => _191.length]) || 0,
+      "Content Preview": contentPreview,
+      "System Instruction": truncatedSystemInstruction || "none",
+      "Available Tools": toolNames || "none",
+      "Tool Count": _optionalChain([llmRequest, 'access', _192 => _192.config, 'optionalAccess', _193 => _193.tools, 'optionalAccess', _194 => _194.length]) || 0,
+      Streaming: isStreaming ? "Yes" : "No"
     });
     let responseCount = 0;
     for await (const llmResponse of llm.generateContentAsync(
@@ -6123,59 +6143,46 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
       isStreaming
     )) {
       responseCount++;
-      this.logger.debug(`\u{1F4E5} Received LLM response ${responseCount}`, {
-        hasContent: !!llmResponse.content,
-        hasError: !!llmResponse.errorCode,
-        interrupted: !!llmResponse.interrupted,
-        partial: !!llmResponse.partial,
-        finishReason: llmResponse.finishReason,
-        usage: llmResponse.usageMetadata ? {
-          promptTokens: llmResponse.usageMetadata.promptTokenCount,
-          completionTokens: llmResponse.usageMetadata.candidatesTokenCount,
-          totalTokens: llmResponse.usageMetadata.totalTokenCount
-        } : null
-      });
       traceLlmCall(
         invocationContext,
         modelResponseEvent.id,
         llmRequest,
         llmResponse
       );
-      this.logger.debug("\u{1F504} Processing after model callbacks");
+      const tokenCount = _optionalChain([llmResponse, 'access', _195 => _195.usageMetadata, 'optionalAccess', _196 => _196.totalTokenCount]) || "unknown";
+      const functionCallCount = _optionalChain([llmResponse, 'access', _197 => _197.content, 'optionalAccess', _198 => _198.parts, 'optionalAccess', _199 => _199.filter, 'call', _200 => _200((part) => part.functionCall), 'access', _201 => _201.length]) || 0;
+      const responsePreview = this._formatResponsePreview(llmResponse);
+      this.logger.debugStructured("\u{1F4E5} LLM Response", {
+        Model: llm.model,
+        "Token Count": tokenCount,
+        "Function Calls": functionCallCount,
+        "Response Preview": responsePreview,
+        "Finish Reason": llmResponse.finishReason || "unknown",
+        "Response #": responseCount,
+        Partial: llmResponse.partial ? "Yes" : "No",
+        Error: llmResponse.errorCode || "none"
+      });
       const alteredLlmResponse = await this._handleAfterModelCallback(
         invocationContext,
         llmResponse,
         modelResponseEvent
       );
-      if (alteredLlmResponse) {
-        this.logger.debug("\u{1F4CB} After model callback altered response");
-      }
       yield alteredLlmResponse || llmResponse;
     }
-    this.logger.debug("\u2705 LLM call completed", {
-      totalResponses: responseCount
-    });
   }
   async _handleBeforeModelCallback(invocationContext, llmRequest, modelResponseEvent) {
     const agent = invocationContext.agent;
     if (!("canonicalBeforeModelCallbacks" in agent)) {
-      this.logger.debug("\u2139\uFE0F Agent has no before model callbacks");
       return;
     }
     const beforeCallbacks = agent.canonicalBeforeModelCallbacks;
     if (!beforeCallbacks) {
-      this.logger.debug("\u2139\uFE0F Before model callbacks is null/undefined");
       return;
     }
-    this.logger.debug("\u{1F504} Processing before model callbacks", {
-      callbackCount: beforeCallbacks.length
-    });
     const callbackContext = new CallbackContext(invocationContext, {
       eventActions: modelResponseEvent.actions
     });
-    for (let i = 0; i < beforeCallbacks.length; i++) {
-      const callback = beforeCallbacks[i];
-      this.logger.debug(`\u{1F504} Running before model callback ${i + 1}`);
+    for (const callback of beforeCallbacks) {
       let beforeModelCallbackContent = callback({
         callbackContext,
         llmRequest
@@ -6184,35 +6191,23 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
         beforeModelCallbackContent = await beforeModelCallbackContent;
       }
       if (beforeModelCallbackContent) {
-        this.logger.debug(`\u2705 Before model callback ${i + 1} returned content`);
         return beforeModelCallbackContent;
       }
-      this.logger.debug(
-        `\u2705 Before model callback ${i + 1} completed (no content)`
-      );
     }
-    this.logger.debug("\u2705 All before model callbacks completed");
   }
   async _handleAfterModelCallback(invocationContext, llmResponse, modelResponseEvent) {
     const agent = invocationContext.agent;
     if (!("canonicalAfterModelCallbacks" in agent)) {
-      this.logger.debug("\u2139\uFE0F Agent has no after model callbacks");
       return;
     }
     const afterCallbacks = agent.canonicalAfterModelCallbacks;
     if (!afterCallbacks) {
-      this.logger.debug("\u2139\uFE0F After model callbacks is null/undefined");
       return;
     }
-    this.logger.debug("\u{1F504} Processing after model callbacks", {
-      callbackCount: afterCallbacks.length
-    });
     const callbackContext = new CallbackContext(invocationContext, {
       eventActions: modelResponseEvent.actions
     });
-    for (let i = 0; i < afterCallbacks.length; i++) {
-      const callback = afterCallbacks[i];
-      this.logger.debug(`\u{1F504} Running after model callback ${i + 1}`);
+    for (const callback of afterCallbacks) {
       let afterModelCallbackContent = callback({
         callbackContext,
         llmResponse
@@ -6221,21 +6216,11 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
         afterModelCallbackContent = await afterModelCallbackContent;
       }
       if (afterModelCallbackContent) {
-        this.logger.debug(`\u2705 After model callback ${i + 1} returned content`);
         return afterModelCallbackContent;
       }
-      this.logger.debug(
-        `\u2705 After model callback ${i + 1} completed (no content)`
-      );
     }
-    this.logger.debug("\u2705 All after model callbacks completed");
   }
   _finalizeModelResponseEvent(llmRequest, llmResponse, modelResponseEvent) {
-    this.logger.debug("\u{1F4DD} Finalizing model response event", {
-      requestModel: llmRequest.model,
-      responseHasContent: !!llmResponse.content,
-      eventId: modelResponseEvent.id
-    });
     const eventData = { ...modelResponseEvent };
     const responseData = { ...llmResponse };
     Object.keys(responseData).forEach((key) => {
@@ -6247,38 +6232,48 @@ var BaseLlmFlow = (_class20 = class {constructor() { _class20.prototype.__init36
     if (event.content) {
       const functionCalls = event.getFunctionCalls();
       if (functionCalls) {
-        this.logger.debug("\u{1F527} Processing function calls in event", {
-          functionCallCount: functionCalls.length
-        });
         populateClientFunctionCallId(event);
         event.longRunningToolIds = getLongRunningFunctionCalls(
           functionCalls,
           llmRequest.toolsDict || {}
         );
-        this.logger.debug("\u2705 Function calls processed", {
-          longRunningToolCount: event.longRunningToolIds.entries.length || 0
-        });
       }
     }
-    this.logger.debug("\u2705 Model response event finalized", {
-      finalEventId: event.id,
-      hasContent: !!event.content,
-      hasFunctionCalls: !!event.getFunctionCalls()
-    });
     return event;
   }
+  /**
+   * Logs data in a visually appealing format that works well in any terminal size.
+   * Uses vertical layout for better readability and respects debug settings.
+   */
+  _formatContentPreview(content) {
+    if (!content) return "none";
+    if (content.parts && Array.isArray(content.parts)) {
+      const textParts = content.parts.filter((part) => part.text).map((part) => part.text).join(" ");
+      return textParts.length > 80 ? `${textParts.substring(0, 80)}...` : textParts || "no text content";
+    }
+    if (typeof content === "string") {
+      return content.length > 80 ? `${content.substring(0, 80)}...` : content;
+    }
+    const stringified = JSON.stringify(content);
+    return stringified.length > 80 ? `${stringified.substring(0, 80)}...` : stringified;
+  }
+  /**
+   * Formats response content preview for debug logging
+   */
+  _formatResponsePreview(llmResponse) {
+    if (!llmResponse.content) return "none";
+    if (llmResponse.content.parts && Array.isArray(llmResponse.content.parts)) {
+      const textParts = llmResponse.content.parts.filter((part) => part.text).map((part) => part.text).join(" ");
+      return textParts.length > 80 ? `${textParts.substring(0, 80)}...` : textParts || "no text content";
+    }
+    const stringified = JSON.stringify(llmResponse.content);
+    return stringified.length > 80 ? `${stringified.substring(0, 80)}...` : stringified;
+  }
   __getLlm(invocationContext) {
     const llm = invocationContext.agent.canonicalModel;
-    this.logger.debug("\u{1F527} Retrieved canonical model", {
-      model: _optionalChain([llm, 'optionalAccess', _199 => _199.model]) || "unknown",
-      llmType: _optionalChain([llm, 'optionalAccess', _200 => _200.constructor, 'optionalAccess', _201 => _201.name]) || "unknown"
-    });
     return llm;
   }
-}, _class20);
-
-// src/flows/llm-flows/single-flow.ts
-init_logger();
+}, _class22);
 
 // src/flows/llm-flows/base-llm-processor.ts
 var BaseLlmRequestProcessor = class {
@@ -6286,52 +6281,6 @@ var BaseLlmRequestProcessor = class {
 var BaseLlmResponseProcessor = class {
 };
 
-// src/flows/llm-flows/basic.ts
-var BasicLlmRequestProcessor = class extends BaseLlmRequestProcessor {
-  async *runAsync(invocationContext, llmRequest) {
-    const agent = invocationContext.agent;
-    if (!this.isLlmAgent(agent)) {
-      return;
-    }
-    llmRequest.model = typeof agent.canonicalModel === "string" ? agent.canonicalModel : agent.canonicalModel.model;
-    if (agent.generateContentConfig) {
-      llmRequest.config = JSON.parse(
-        JSON.stringify(agent.generateContentConfig)
-      );
-    } else {
-      llmRequest.config = {};
-    }
-    if (agent.outputSchema) {
-      llmRequest.setOutputSchema(agent.outputSchema);
-    }
-    const runConfig = invocationContext.runConfig;
-    if (!llmRequest.liveConnectConfig) {
-      llmRequest.liveConnectConfig = {};
-    }
-    if (runConfig.responseModalities) {
-      llmRequest.liveConnectConfig.responseModalities = runConfig.responseModalities;
-    }
-    llmRequest.liveConnectConfig.speechConfig = runConfig.speechConfig;
-    llmRequest.liveConnectConfig.outputAudioTranscription = runConfig.outputAudioTranscription;
-    llmRequest.liveConnectConfig.inputAudioTranscription = runConfig.inputAudioTranscription;
-    llmRequest.liveConnectConfig.realtimeInputConfig = runConfig.realtimeInputConfig;
-    llmRequest.liveConnectConfig.enableAffectiveDialog = runConfig.enableAffectiveDialog;
-    llmRequest.liveConnectConfig.proactivity = runConfig.proactivity;
-    const tools = await agent.canonicalTools();
-    llmRequest.appendTools(tools);
-    for await (const _ of []) {
-      yield _;
-    }
-  }
-  /**
-   * Type guard to check if agent is an LlmAgent
-   */
-  isLlmAgent(agent) {
-    return agent && typeof agent === "object" && "canonicalModel" in agent;
-  }
-};
-var requestProcessor = new BasicLlmRequestProcessor();
-
 // src/auth/auth-tool.ts
 var EnhancedAuthConfig = class {
   /**
@@ -6539,152 +6488,738 @@ var AuthLlmRequestProcessor = class extends BaseLlmRequestProcessor {
     }
   }
 };
-var requestProcessor2 = new AuthLlmRequestProcessor();
+var requestProcessor = new AuthLlmRequestProcessor();
 
-// src/flows/llm-flows/identity.ts
-var IdentityLlmRequestProcessor = class extends BaseLlmRequestProcessor {
+// src/flows/llm-flows/basic.ts
+var BasicLlmRequestProcessor = class extends BaseLlmRequestProcessor {
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;
-    const instructions = [
-      `You are an agent. Your internal name is "${agent.name}".`
-    ];
-    if (agent.description) {
-      instructions.push(` The description about you is "${agent.description}"`);
+    if (!this.isLlmAgent(agent)) {
+      return;
     }
-    llmRequest.appendInstructions(instructions);
+    llmRequest.model = typeof agent.canonicalModel === "string" ? agent.canonicalModel : agent.canonicalModel.model;
+    if (agent.generateContentConfig) {
+      llmRequest.config = JSON.parse(
+        JSON.stringify(agent.generateContentConfig)
+      );
+    } else {
+      llmRequest.config = {};
+    }
+    if (agent.outputSchema) {
+      llmRequest.setOutputSchema(agent.outputSchema);
+    }
+    const runConfig = invocationContext.runConfig;
+    if (!llmRequest.liveConnectConfig) {
+      llmRequest.liveConnectConfig = {};
+    }
+    if (runConfig.responseModalities) {
+      llmRequest.liveConnectConfig.responseModalities = runConfig.responseModalities;
+    }
+    llmRequest.liveConnectConfig.speechConfig = runConfig.speechConfig;
+    llmRequest.liveConnectConfig.outputAudioTranscription = runConfig.outputAudioTranscription;
+    llmRequest.liveConnectConfig.inputAudioTranscription = runConfig.inputAudioTranscription;
+    llmRequest.liveConnectConfig.realtimeInputConfig = runConfig.realtimeInputConfig;
+    llmRequest.liveConnectConfig.enableAffectiveDialog = runConfig.enableAffectiveDialog;
+    llmRequest.liveConnectConfig.proactivity = runConfig.proactivity;
+    const tools = await agent.canonicalTools();
+    llmRequest.appendTools(tools);
     for await (const _ of []) {
       yield _;
     }
   }
+  /**
+   * Type guard to check if agent is an LlmAgent
+   */
+  isLlmAgent(agent) {
+    return agent && typeof agent === "object" && "canonicalModel" in agent;
+  }
+};
+var requestProcessor2 = new BasicLlmRequestProcessor();
+
+// src/code-executors/base-code-executor.ts
+var BaseCodeExecutor = class {
+  
+  constructor(config = {}) {
+    this.config = {
+      optimizeDataFile: _nullishCoalesce(config.optimizeDataFile, () => ( false)),
+      stateful: _nullishCoalesce(config.stateful, () => ( false)),
+      errorRetryAttempts: _nullishCoalesce(config.errorRetryAttempts, () => ( 2)),
+      codeBlockDelimiters: _nullishCoalesce(config.codeBlockDelimiters, () => ( [
+        ["`tool_code\n", "\n`"],
+        ["`python\n", "\n`"]
+      ])),
+      executionResultDelimiters: _nullishCoalesce(config.executionResultDelimiters, () => ( [
+        "`tool_output\n",
+        "\n`"
+      ]))
+    };
+  }
+  // Getters for configuration
+  get optimizeDataFile() {
+    return this.config.optimizeDataFile;
+  }
+  get stateful() {
+    return this.config.stateful;
+  }
+  get errorRetryAttempts() {
+    return this.config.errorRetryAttempts;
+  }
+  get codeBlockDelimiters() {
+    return this.config.codeBlockDelimiters;
+  }
+  get executionResultDelimiters() {
+    return this.config.executionResultDelimiters;
+  }
 };
-var requestProcessor3 = new IdentityLlmRequestProcessor();
 
-// src/utils/instructions-utils.ts
-async function injectSessionState(template, readonlyContext) {
-  const invocationContext = readonlyContext._invocationContext;
-  async function asyncReplace(pattern, replaceAsyncFn, string) {
-    const result = [];
-    let lastEnd = 0;
-    const matches = Array.from(string.matchAll(pattern));
-    for (const match of matches) {
-      result.push(string.slice(lastEnd, match.index));
-      const replacement = await replaceAsyncFn(match);
-      result.push(replacement);
-      lastEnd = (match.index || 0) + match[0].length;
-    }
-    result.push(string.slice(lastEnd));
-    return result.join("");
+// src/code-executors/built-in-code-executor.ts
+var BuiltInCodeExecutor = class extends BaseCodeExecutor {
+  constructor(config = {}) {
+    super(config);
   }
-  async function replaceMatch(match) {
-    let varName = match[0].replace(/[{}]/g, "").trim();
-    let optional = false;
-    if (varName.endsWith("?")) {
-      optional = true;
-      varName = varName.slice(0, -1);
+  async executeCode(invocationContext, codeExecutionInput) {
+    throw new Error(
+      "BuiltInCodeExecutor.executeCode should not be called directly"
+    );
+  }
+  /**
+   * Pre-process the LLM request for Gemini 2.0+ models to use the code execution tool
+   */
+  processLlmRequest(llmRequest) {
+    if (!_optionalChain([llmRequest, 'access', _207 => _207.model, 'optionalAccess', _208 => _208.startsWith, 'call', _209 => _209("gemini-2")])) {
+      throw new Error(
+        `Gemini code execution tool is not supported for model ${llmRequest.model}`
+      );
     }
-    if (varName.startsWith("artifact.")) {
-      varName = varName.replace("artifact.", "");
-      if (!invocationContext.artifactService) {
-        throw new Error("Artifact service is not initialized.");
-      }
-      try {
-        const artifact = await invocationContext.artifactService.loadArtifact({
-          appName: invocationContext.session.appName,
-          userId: invocationContext.session.userId,
-          sessionId: invocationContext.session.id,
-          filename: varName
-        });
-        if (!artifact) {
-          throw new Error(`Artifact ${varName} not found.`);
-        }
-        return String(artifact);
-      } catch (error) {
-        if (optional) {
-          return "";
-        }
-        throw error;
-      }
-    } else {
-      if (!isValidStateName(varName)) {
-        return match[0];
-      }
-      const sessionState = invocationContext.session.state;
-      if (varName in sessionState) {
-        return String(sessionState[varName]);
-      }
-      if (optional) {
-        return "";
-      }
-      throw new Error(`Context variable not found: \`${varName}\`.`);
+    if (!llmRequest.config) {
+      llmRequest.config = {};
     }
+    if (!llmRequest.config.tools) {
+      llmRequest.config.tools = [];
+    }
+    const codeExecutionTool = {
+      codeExecution: {}
+    };
+    llmRequest.config.tools.push(codeExecutionTool);
   }
-  return await asyncReplace(/{[^{}]*}/g, replaceMatch, template);
-}
-function isValidStateName(varName) {
-  const parts = varName.split(":");
-  if (parts.length === 1) {
-    return isValidIdentifier(varName);
+};
+
+// src/code-executors/code-execution-utils.ts
+
+var CodeExecutionUtils = class _CodeExecutionUtils {
+  /**
+   * Gets the file content as a base64-encoded string
+   */
+  static getEncodedFileContent(data) {
+    let decodedData;
+    if (data instanceof ArrayBuffer) {
+      decodedData = new TextDecoder().decode(data);
+    }
+    if (_CodeExecutionUtils.isBase64Encoded(decodedData)) {
+      return decodedData;
+    }
+    return btoa(decodedData);
   }
-  if (parts.length === 2) {
-    const validPrefixes = ["app:", "user:", "temp:"];
-    const prefix = `${parts[0]}:`;
-    if (validPrefixes.includes(prefix)) {
-      return isValidIdentifier(parts[1]);
+  static isBase64Encoded(str) {
+    try {
+      return btoa(atob(str)) === str;
+    } catch (e3) {
+      return false;
     }
   }
-  return false;
-}
-function isValidIdentifier(name) {
-  const identifierRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-  return identifierRegex.test(name);
-}
+  /**
+   * Extracts the first code block from the content and truncates everything after it
+   */
+  static extractCodeAndTruncateContent(content, codeBlockDelimiters) {
+    if (!_optionalChain([content, 'optionalAccess', _210 => _210.parts, 'optionalAccess', _211 => _211.length])) {
+      return null;
+    }
+    for (let idx = 0; idx < content.parts.length; idx++) {
+      const part = content.parts[idx];
+      if (part.executableCode && (idx === content.parts.length - 1 || !content.parts[idx + 1].codeExecutionResult)) {
+        content.parts = content.parts.slice(0, idx + 1);
+        return part.executableCode.code;
+      }
+    }
+    const textParts = content.parts.filter((p) => p.text);
+    if (!textParts.length) {
+      return null;
+    }
+    const responseText = textParts.map((p) => p.text).join("\n");
+    const leadingDelimiterPattern = codeBlockDelimiters.map(([start]) => _CodeExecutionUtils.escapeRegex(start)).join("|");
+    const trailingDelimiterPattern = codeBlockDelimiters.map(([, end]) => _CodeExecutionUtils.escapeRegex(end)).join("|");
+    const pattern = new RegExp(
+      `(.*?)(${leadingDelimiterPattern})(.*?)(${trailingDelimiterPattern})(.*?)$`,
+      "s"
+    );
+    const match = responseText.match(pattern);
+    if (!match) {
+      return null;
+    }
+    const [, prefix, , code, , suffix] = match;
+    if (!code) {
+      return null;
+    }
+    content.parts = [];
+    if (prefix) {
+      content.parts.push({ text: prefix });
+    }
+    content.parts.push(_CodeExecutionUtils.buildExecutableCodePart(code));
+    return code;
+  }
+  static escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Builds an executable code part with code string
+   */
+  static buildExecutableCodePart(code) {
+    return {
+      executableCode: {
+        code,
+        language: _genai.Language.PYTHON
+      }
+    };
+  }
+  /**
+   * Builds the code execution result part from the code execution result
+   */
+  static buildCodeExecutionResultPart(codeExecutionResult) {
+    if (codeExecutionResult.stderr) {
+      return {
+        codeExecutionResult: {
+          outcome: _genai.Outcome.OUTCOME_FAILED,
+          output: codeExecutionResult.stderr
+        }
+      };
+    }
+    const finalResult = [];
+    if (codeExecutionResult.stdout || !codeExecutionResult.outputFiles.length) {
+      finalResult.push(
+        `Code execution result:
+${codeExecutionResult.stdout}
+`
+      );
+    }
+    if (codeExecutionResult.outputFiles.length) {
+      const fileNames = codeExecutionResult.outputFiles.map((f) => `\`${f.name}\``).join(",");
+      finalResult.push(`Saved artifacts:
+${fileNames}`);
+    }
+    return {
+      codeExecutionResult: {
+        outcome: _genai.Outcome.OUTCOME_OK,
+        output: finalResult.join("\n\n")
+      }
+    };
+  }
+  /**
+   * Converts the code execution parts to text parts in a Content
+   */
+  static convertCodeExecutionParts(content, codeBlockDelimiter, executionResultDelimiters) {
+    if (!_optionalChain([content, 'access', _212 => _212.parts, 'optionalAccess', _213 => _213.length])) {
+      return;
+    }
+    const lastPart = content.parts[content.parts.length - 1];
+    if (lastPart.executableCode) {
+      content.parts[content.parts.length - 1] = {
+        text: `${codeBlockDelimiter[0]}${lastPart.executableCode.code}${codeBlockDelimiter[1]}`
+      };
+    } else if (content.parts.length === 1 && lastPart.codeExecutionResult) {
+      content.parts[content.parts.length - 1] = {
+        text: `${executionResultDelimiters[0]}${lastPart.codeExecutionResult.output}${executionResultDelimiters[1]}`
+      };
+      content.role = "user";
+    }
+  }
+};
 
-// src/flows/llm-flows/instructions.ts
-var InstructionsLlmRequestProcessor = class extends BaseLlmRequestProcessor {
+// src/code-executors/code-executor-context.ts
+var CONTEXT_KEY = "_code_execution_context";
+var SESSION_ID_KEY = "execution_session_id";
+var PROCESSED_FILE_NAMES_KEY = "processed_input_files";
+var INPUT_FILE_KEY = "_code_executor_input_files";
+var ERROR_COUNT_KEY = "_code_executor_error_counts";
+var CODE_EXECUTION_RESULTS_KEY = "_code_execution_results";
+var CodeExecutorContext = class {
+  
+  
+  constructor(sessionState) {
+    this.sessionState = sessionState;
+    this.context = this.getCodeExecutorContext(sessionState);
+  }
+  /**
+   * Gets the state delta to update in the persistent session state.
+   */
+  getStateDelta() {
+    const contextToUpdate = JSON.parse(JSON.stringify(this.context));
+    return { [CONTEXT_KEY]: contextToUpdate };
+  }
+  /**
+   * Gets the session ID for the code executor.
+   */
+  getExecutionId() {
+    if (!(SESSION_ID_KEY in this.context)) {
+      return null;
+    }
+    return this.context[SESSION_ID_KEY];
+  }
+  /**
+   * Sets the session ID for the code executor.
+   */
+  setExecutionId(sessionId) {
+    this.context[SESSION_ID_KEY] = sessionId;
+  }
+  /**
+   * Gets the processed file names from the session state.
+   */
+  getProcessedFileNames() {
+    if (!(PROCESSED_FILE_NAMES_KEY in this.context)) {
+      return [];
+    }
+    return this.context[PROCESSED_FILE_NAMES_KEY];
+  }
+  /**
+   * Adds the processed file names to the session state.
+   */
+  addProcessedFileNames(fileNames) {
+    if (!(PROCESSED_FILE_NAMES_KEY in this.context)) {
+      this.context[PROCESSED_FILE_NAMES_KEY] = [];
+    }
+    this.context[PROCESSED_FILE_NAMES_KEY].push(...fileNames);
+  }
+  /**
+   * Gets the code executor input files from the session state.
+   */
+  getInputFiles() {
+    if (!(INPUT_FILE_KEY in this.sessionState)) {
+      return [];
+    }
+    return this.sessionState[INPUT_FILE_KEY].map(
+      (file) => file
+    );
+  }
+  /**
+   * Adds the input files to the code executor context.
+   */
+  addInputFiles(inputFiles) {
+    if (!(INPUT_FILE_KEY in this.sessionState)) {
+      this.sessionState[INPUT_FILE_KEY] = [];
+    }
+    const fileArray = this.sessionState[INPUT_FILE_KEY];
+    for (const inputFile of inputFiles) {
+      fileArray.push({
+        name: inputFile.name,
+        content: inputFile.content,
+        mimeType: inputFile.mimeType
+      });
+    }
+  }
+  /**
+   * Removes the input files and processed file names from the code executor context.
+   */
+  clearInputFiles() {
+    if (INPUT_FILE_KEY in this.sessionState) {
+      this.sessionState[INPUT_FILE_KEY] = [];
+    }
+    if (PROCESSED_FILE_NAMES_KEY in this.context) {
+      this.context[PROCESSED_FILE_NAMES_KEY] = [];
+    }
+  }
+  /**
+   * Gets the error count from the session state.
+   */
+  getErrorCount(invocationId) {
+    if (!(ERROR_COUNT_KEY in this.sessionState)) {
+      return 0;
+    }
+    const errorCounts = this.sessionState[ERROR_COUNT_KEY];
+    return _nullishCoalesce(errorCounts[invocationId], () => ( 0));
+  }
+  /**
+   * Increments the error count for the given invocation ID.
+   */
+  incrementErrorCount(invocationId) {
+    if (!(ERROR_COUNT_KEY in this.sessionState)) {
+      this.sessionState[ERROR_COUNT_KEY] = {};
+    }
+    const errorCounts = this.sessionState[ERROR_COUNT_KEY];
+    errorCounts[invocationId] = this.getErrorCount(invocationId) + 1;
+  }
+  /**
+   * Resets the error count for the given invocation ID.
+   */
+  resetErrorCount(invocationId) {
+    if (!(ERROR_COUNT_KEY in this.sessionState)) {
+      return;
+    }
+    const errorCounts = this.sessionState[ERROR_COUNT_KEY];
+    if (invocationId in errorCounts) {
+      delete errorCounts[invocationId];
+    }
+  }
+  /**
+   * Updates the code execution result.
+   */
+  updateCodeExecutionResult(invocationId, code, resultStdout, resultStderr) {
+    if (!(CODE_EXECUTION_RESULTS_KEY in this.sessionState)) {
+      this.sessionState[CODE_EXECUTION_RESULTS_KEY] = {};
+    }
+    const results = this.sessionState[CODE_EXECUTION_RESULTS_KEY];
+    if (!(invocationId in results)) {
+      results[invocationId] = [];
+    }
+    results[invocationId].push({
+      code,
+      resultStdout,
+      resultStderr,
+      timestamp: Math.floor(Date.now() / 1e3)
+    });
+  }
+  /**
+   * Gets the code executor context from the session state.
+   */
+  getCodeExecutorContext(sessionState) {
+    if (!(CONTEXT_KEY in sessionState)) {
+      sessionState[CONTEXT_KEY] = {};
+    }
+    return sessionState[CONTEXT_KEY];
+  }
+};
+
+// src/flows/llm-flows/code-execution.ts
+var DATA_FILE_UTIL_MAP = {
+  "text/csv": {
+    extension: ".csv",
+    loaderCodeTemplate: "pd.read_csv('{filename}')"
+  }
+};
+var DATA_FILE_HELPER_LIB = `
+import pandas as pd
+
+def explore_df(df: pd.DataFrame) -> None:
+  """Prints some information about a pandas DataFrame."""
+
+  with pd.option_context(
+      'display.max_columns', None, 'display.expand_frame_repr', False
+  ):
+    # Print the column names to never encounter KeyError when selecting one.
+    df_dtypes = df.dtypes
+
+    # Obtain information about data types and missing values.
+    df_nulls = (len(df) - df.isnull().sum()).apply(
+        lambda x: f'{x} / {df.shape[0]} non-null'
+    )
+
+    # Explore unique total values in columns using \`.unique()\`.
+    df_unique_count = df.apply(lambda x: len(x.unique()))
+
+    # Explore unique values in columns using \`.unique()\`.
+    df_unique = df.apply(lambda x: crop(str(list(x.unique()))))
+
+    df_info = pd.concat(
+        (
+            df_dtypes.rename('Dtype'),
+            df_nulls.rename('Non-Null Count'),
+            df_unique_count.rename('Unique Values Count'),
+            df_unique.rename('Unique Values'),
+        ),
+        axis=1,
+    )
+    df_info.index.name = 'Columns'
+    print(f"""Total rows: {df.shape[0]}
+Total columns: {df.shape[1]}
+
+{df_info}""")
+
+def crop(text: str, max_length: int = 100) -> str:
+    """Crop text to maximum length with ellipsis."""
+    return text if len(text) <= max_length else text[:max_length] + "..."
+`;
+function hasCodeExecutor(agent) {
+  return agent && typeof agent === "object" && "codeExecutor" in agent;
+}
+var CodeExecutionRequestProcessor = class extends BaseLlmRequestProcessor {
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;
-    if (!this.isLlmAgent(agent)) {
+    if (!hasCodeExecutor(agent)) {
       return;
     }
-    const rootAgent = agent.rootAgent;
-    if (this.isLlmAgent(rootAgent) && rootAgent.globalInstruction) {
-      const [rawInstruction, bypassStateInjection] = await rootAgent.canonicalGlobalInstruction(
-        new ReadonlyContext(invocationContext)
+    if (!(agent instanceof LlmAgent) || !agent.codeExecutor) {
+      return;
+    }
+    yield* runPreProcessor(invocationContext, llmRequest);
+    if (!(agent.codeExecutor instanceof BaseCodeExecutor)) {
+      return;
+    }
+    for (const content of llmRequest.contents || []) {
+      CodeExecutionUtils.convertCodeExecutionParts(
+        content,
+        agent.codeExecutor.codeBlockDelimiters[0] || ["", ""],
+        agent.codeExecutor.executionResultDelimiters
       );
-      let instruction = rawInstruction;
-      if (!bypassStateInjection) {
-        instruction = await injectSessionState(
-          rawInstruction,
-          new ReadonlyContext(invocationContext)
-        );
+    }
+  }
+};
+var CodeExecutionResponseProcessor = class extends BaseLlmResponseProcessor {
+  async *runAsync(invocationContext, llmResponse) {
+    if (llmResponse.partial) {
+      return;
+    }
+    yield* runPostProcessor(invocationContext, llmResponse);
+  }
+};
+async function* runPreProcessor(invocationContext, llmRequest) {
+  const agent = invocationContext.agent;
+  if (!hasCodeExecutor(agent)) {
+    return;
+  }
+  const codeExecutor = agent.codeExecutor;
+  if (!codeExecutor || !(codeExecutor instanceof BaseCodeExecutor)) {
+    return;
+  }
+  if (codeExecutor instanceof BuiltInCodeExecutor) {
+    codeExecutor.processLlmRequest(llmRequest);
+    return;
+  }
+  if (!codeExecutor.optimizeDataFile) {
+    return;
+  }
+  const codeExecutorContext = new CodeExecutorContext(
+    invocationContext.session.state
+    // Type assertion for State compatibility
+  );
+  if (codeExecutorContext.getErrorCount(invocationContext.invocationId) >= codeExecutor.errorRetryAttempts) {
+    return;
+  }
+  const allInputFiles = extractAndReplaceInlineFiles(
+    codeExecutorContext,
+    llmRequest
+  );
+  const processedFileNames = new Set(
+    codeExecutorContext.getProcessedFileNames()
+  );
+  const filesToProcess = allInputFiles.filter(
+    (f) => !processedFileNames.has(f.name)
+  );
+  for (const file of filesToProcess) {
+    const codeStr = getDataFilePreprocessingCode(file);
+    if (!codeStr) {
+      continue;
+    }
+    const codeContent = {
+      role: "model",
+      parts: [
+        { text: `Processing input file: \`${file.name}\`` },
+        CodeExecutionUtils.buildExecutableCodePart(codeStr)
+      ]
+    };
+    llmRequest.contents = llmRequest.contents || [];
+    llmRequest.contents.push(structuredClone(codeContent));
+    yield new Event({
+      invocationId: invocationContext.invocationId,
+      author: agent.name,
+      branch: invocationContext.branch,
+      content: codeContent
+    });
+    const codeExecutionResult = await codeExecutor.executeCode(
+      invocationContext,
+      {
+        code: codeStr,
+        inputFiles: [file],
+        executionId: getOrSetExecutionId(
+          invocationContext,
+          codeExecutorContext
+        )
       }
-      llmRequest.appendInstructions([instruction]);
+    );
+    codeExecutorContext.updateCodeExecutionResult(
+      invocationContext.invocationId,
+      codeStr,
+      codeExecutionResult.stdout,
+      codeExecutionResult.stderr
+    );
+    codeExecutorContext.addProcessedFileNames([file.name]);
+    const executionResultEvent = await postProcessCodeExecutionResult(
+      invocationContext,
+      codeExecutorContext,
+      codeExecutionResult
+    );
+    yield executionResultEvent;
+    llmRequest.contents.push(structuredClone(executionResultEvent.content));
+  }
+}
+async function* runPostProcessor(invocationContext, llmResponse) {
+  const agent = invocationContext.agent;
+  if (!hasCodeExecutor(agent)) {
+    return;
+  }
+  const codeExecutor = agent.codeExecutor;
+  if (!(codeExecutor instanceof BaseCodeExecutor)) {
+    return;
+  }
+  if (!llmResponse || !llmResponse.content) {
+    return;
+  }
+  if (codeExecutor instanceof BuiltInCodeExecutor) {
+    return;
+  }
+  const codeExecutorContext = new CodeExecutorContext(
+    invocationContext.session.state
+    // Type assertion for State compatibility
+  );
+  if (codeExecutorContext.getErrorCount(invocationContext.invocationId) >= codeExecutor.errorRetryAttempts) {
+    return;
+  }
+  const responseContent = llmResponse.content;
+  const codeStr = CodeExecutionUtils.extractCodeAndTruncateContent(
+    responseContent,
+    codeExecutor.codeBlockDelimiters
+  );
+  if (!codeStr) {
+    return;
+  }
+  yield new Event({
+    invocationId: invocationContext.invocationId,
+    author: agent.name,
+    branch: invocationContext.branch,
+    content: responseContent,
+    actions: new EventActions()
+  });
+  const codeExecutionResult = await codeExecutor.executeCode(
+    invocationContext,
+    {
+      code: codeStr,
+      inputFiles: codeExecutorContext.getInputFiles(),
+      executionId: getOrSetExecutionId(invocationContext, codeExecutorContext)
     }
-    if (agent.instruction) {
-      const [rawInstruction, bypassStateInjection] = await agent.canonicalInstruction(
-        new ReadonlyContext(invocationContext)
-      );
-      let instruction = rawInstruction;
-      if (!bypassStateInjection) {
-        instruction = await injectSessionState(
-          rawInstruction,
-          new ReadonlyContext(invocationContext)
-        );
+  );
+  codeExecutorContext.updateCodeExecutionResult(
+    invocationContext.invocationId,
+    codeStr,
+    codeExecutionResult.stdout,
+    codeExecutionResult.stderr
+  );
+  yield await postProcessCodeExecutionResult(
+    invocationContext,
+    codeExecutorContext,
+    codeExecutionResult
+  );
+  llmResponse.content = void 0;
+}
+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', _214 => _214.contents, 'optionalAccess', _215 => _215.length]) || 0); i++) {
+    const content = llmRequest.contents[i];
+    if (content.role !== "user" || !content.parts) {
+      continue;
+    }
+    for (let j = 0; j < content.parts.length; j++) {
+      const part = content.parts[j];
+      if (!part.inlineData || !(part.inlineData.mimeType in DATA_FILE_UTIL_MAP)) {
+        continue;
+      }
+      const mimeType = part.inlineData.mimeType;
+      const fileName = `data_${i + 1}_${j + 1}${DATA_FILE_UTIL_MAP[mimeType].extension}`;
+      llmRequest.contents[i].parts[j] = {
+        text: `
+Available file: \`${fileName}\`
+`
+      };
+      const file = {
+        name: fileName,
+        content: CodeExecutionUtils.getEncodedFileContent(part.inlineData.data),
+        mimeType
+      };
+      if (!savedFileNames.has(fileName)) {
+        codeExecutorContext.addInputFiles([file]);
+        allInputFiles.push(file);
       }
-      llmRequest.appendInstructions([instruction]);
     }
-    for await (const _ of []) {
-      yield _;
+  }
+  return allInputFiles;
+}
+function getOrSetExecutionId(invocationContext, codeExecutorContext) {
+  const agent = invocationContext.agent;
+  if (!hasCodeExecutor(agent) || !_optionalChain([agent, 'access', _216 => _216.codeExecutor, 'optionalAccess', _217 => _217.stateful])) {
+    return void 0;
+  }
+  let executionId = codeExecutorContext.getExecutionId();
+  if (!executionId) {
+    executionId = invocationContext.session.id;
+    codeExecutorContext.setExecutionId(executionId);
+  }
+  return executionId;
+}
+async function postProcessCodeExecutionResult(invocationContext, codeExecutorContext, codeExecutionResult) {
+  if (!invocationContext.artifactService) {
+    throw new Error("Artifact service is not initialized.");
+  }
+  const resultContent = {
+    role: "model",
+    parts: [
+      CodeExecutionUtils.buildCodeExecutionResultPart(codeExecutionResult)
+    ]
+  };
+  const eventActions = new EventActions({
+    stateDelta: codeExecutorContext.getStateDelta()
+  });
+  if (codeExecutionResult.stderr) {
+    codeExecutorContext.incrementErrorCount(invocationContext.invocationId);
+  } else {
+    codeExecutorContext.resetErrorCount(invocationContext.invocationId);
+  }
+  for (const outputFile of codeExecutionResult.outputFiles) {
+    const version = await invocationContext.artifactService.saveArtifact({
+      appName: invocationContext.appName,
+      userId: invocationContext.userId,
+      sessionId: invocationContext.session.id,
+      filename: outputFile.name,
+      artifact: {
+        inlineData: {
+          data: atob(outputFile.content),
+          // Convert from base64
+          mimeType: outputFile.mimeType
+        }
+      }
+    });
+    eventActions.artifactDelta[outputFile.name] = version;
+  }
+  return new Event({
+    invocationId: invocationContext.invocationId,
+    author: invocationContext.agent.name,
+    branch: invocationContext.branch,
+    content: resultContent,
+    actions: eventActions
+  });
+}
+function getDataFilePreprocessingCode(file) {
+  function getNormalizedFileName(fileName) {
+    const baseName = fileName.split(".")[0];
+    let varName2 = baseName.replace(/[^a-zA-Z0-9_]/g, "_");
+    if (/^\d/.test(varName2)) {
+      varName2 = `_${varName2}`;
     }
+    return varName2;
   }
-  /**
-   * Type guard to check if agent is an LlmAgent
-   */
-  isLlmAgent(agent) {
-    return agent && typeof agent === "object" && "canonicalModel" in agent;
+  if (!(file.mimeType in DATA_FILE_UTIL_MAP)) {
+    return void 0;
   }
-};
-var requestProcessor4 = new InstructionsLlmRequestProcessor();
+  const varName = getNormalizedFileName(file.name);
+  const loaderCode = DATA_FILE_UTIL_MAP[file.mimeType].loaderCodeTemplate.replace("{filename}", file.name);
+  return `
+${DATA_FILE_HELPER_LIB}
+
+# Load the dataframe.
+${varName} = ${loaderCode}
+
+# Use \`explore_df\` to guide my analysis.
+explore_df(${varName})
+`;
+}
+var requestProcessor3 = new CodeExecutionRequestProcessor();
+var responseProcessor = new CodeExecutionResponseProcessor();
 
 // src/flows/llm-flows/contents.ts
 var ContentLlmRequestProcessor = class extends BaseLlmRequestProcessor {
@@ -6717,7 +7252,7 @@ var ContentLlmRequestProcessor = class extends BaseLlmRequestProcessor {
     return agent && typeof agent === "object" && "canonicalModel" in agent;
   }
 };
-var requestProcessor5 = new ContentLlmRequestProcessor();
+var requestProcessor4 = new ContentLlmRequestProcessor();
 function rearrangeEventsForAsyncFunctionResponsesInHistory(events) {
   const functionCallIdToResponseEventsIndex = {};
   for (let i = 0; i < events.length; i++) {
@@ -6838,7 +7373,7 @@ function rearrangeEventsForLatestFunctionResponse(events) {
       continue;
     }
     const functionResponses2 = event.getFunctionResponses();
-    if (_optionalChain([functionResponses2, 'optionalAccess', _207 => _207.some, 'call', _208 => _208((fr) => fr.id && functionResponsesIds.has(fr.id))])) {
+    if (_optionalChain([functionResponses2, 'optionalAccess', _218 => _218.some, 'call', _219 => _219((fr) => fr.id && functionResponsesIds.has(fr.id))])) {
       functionResponseEvents.push(event);
     }
   }
@@ -6937,7 +7472,7 @@ function mergeFunctionResponseEvents(functionResponseEvents) {
   const partIndicesInMergedEvent = {};
   for (let idx = 0; idx < partsInMergedEvent.length; idx++) {
     const part = partsInMergedEvent[idx];
-    if (_optionalChain([part, 'access', _209 => _209.functionResponse, 'optionalAccess', _210 => _210.id])) {
+    if (_optionalChain([part, 'access', _220 => _220.functionResponse, 'optionalAccess', _221 => _221.id])) {
       partIndicesInMergedEvent[part.functionResponse.id] = idx;
     }
   }
@@ -6946,7 +7481,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', _211 => _211.functionResponse, 'optionalAccess', _212 => _212.id])) {
+      if (_optionalChain([part, 'access', _222 => _222.functionResponse, 'optionalAccess', _223 => _223.id])) {
         const functionCallId = part.functionResponse.id;
         if (functionCallId in partIndicesInMergedEvent) {
           partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = part;
@@ -6982,6 +7517,151 @@ function isAuthEvent(event) {
   return false;
 }
 
+// src/flows/llm-flows/identity.ts
+var IdentityLlmRequestProcessor = class extends BaseLlmRequestProcessor {
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    const instructions = [
+      `You are an agent. Your internal name is "${agent.name}".`
+    ];
+    if (agent.description) {
+      instructions.push(` The description about you is "${agent.description}"`);
+    }
+    llmRequest.appendInstructions(instructions);
+    for await (const _ of []) {
+      yield _;
+    }
+  }
+};
+var requestProcessor5 = new IdentityLlmRequestProcessor();
+
+// src/utils/instructions-utils.ts
+async function injectSessionState(template, readonlyContext) {
+  const invocationContext = readonlyContext._invocationContext;
+  async function asyncReplace(pattern, replaceAsyncFn, string) {
+    const result = [];
+    let lastEnd = 0;
+    const matches = Array.from(string.matchAll(pattern));
+    for (const match of matches) {
+      result.push(string.slice(lastEnd, match.index));
+      const replacement = await replaceAsyncFn(match);
+      result.push(replacement);
+      lastEnd = (match.index || 0) + match[0].length;
+    }
+    result.push(string.slice(lastEnd));
+    return result.join("");
+  }
+  async function replaceMatch(match) {
+    let varName = match[0].replace(/[{}]/g, "").trim();
+    let optional = false;
+    if (varName.endsWith("?")) {
+      optional = true;
+      varName = varName.slice(0, -1);
+    }
+    if (varName.startsWith("artifact.")) {
+      varName = varName.replace("artifact.", "");
+      if (!invocationContext.artifactService) {
+        throw new Error("Artifact service is not initialized.");
+      }
+      try {
+        const artifact = await invocationContext.artifactService.loadArtifact({
+          appName: invocationContext.session.appName,
+          userId: invocationContext.session.userId,
+          sessionId: invocationContext.session.id,
+          filename: varName
+        });
+        if (!artifact) {
+          throw new Error(`Artifact ${varName} not found.`);
+        }
+        return String(artifact);
+      } catch (error) {
+        if (optional) {
+          return "";
+        }
+        throw error;
+      }
+    } else {
+      if (!isValidStateName(varName)) {
+        return match[0];
+      }
+      const sessionState = invocationContext.session.state;
+      if (varName in sessionState) {
+        return String(sessionState[varName]);
+      }
+      if (optional) {
+        return "";
+      }
+      throw new Error(`Context variable not found: \`${varName}\`.`);
+    }
+  }
+  return await asyncReplace(/{[^{}]*}/g, replaceMatch, template);
+}
+function isValidStateName(varName) {
+  const parts = varName.split(":");
+  if (parts.length === 1) {
+    return isValidIdentifier(varName);
+  }
+  if (parts.length === 2) {
+    const validPrefixes = ["app:", "user:", "temp:"];
+    const prefix = `${parts[0]}:`;
+    if (validPrefixes.includes(prefix)) {
+      return isValidIdentifier(parts[1]);
+    }
+  }
+  return false;
+}
+function isValidIdentifier(name) {
+  const identifierRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+  return identifierRegex.test(name);
+}
+
+// src/flows/llm-flows/instructions.ts
+var InstructionsLlmRequestProcessor = class extends BaseLlmRequestProcessor {
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!this.isLlmAgent(agent)) {
+      return;
+    }
+    const rootAgent = agent.rootAgent;
+    if (this.isLlmAgent(rootAgent) && rootAgent.globalInstruction) {
+      const [rawInstruction, bypassStateInjection] = await rootAgent.canonicalGlobalInstruction(
+        new ReadonlyContext(invocationContext)
+      );
+      let instruction = rawInstruction;
+      if (!bypassStateInjection) {
+        instruction = await injectSessionState(
+          rawInstruction,
+          new ReadonlyContext(invocationContext)
+        );
+      }
+      llmRequest.appendInstructions([instruction]);
+    }
+    if (agent.instruction) {
+      const [rawInstruction, bypassStateInjection] = await agent.canonicalInstruction(
+        new ReadonlyContext(invocationContext)
+      );
+      let instruction = rawInstruction;
+      if (!bypassStateInjection) {
+        instruction = await injectSessionState(
+          rawInstruction,
+          new ReadonlyContext(invocationContext)
+        );
+      }
+      llmRequest.appendInstructions([instruction]);
+    }
+    for await (const _ of []) {
+      yield _;
+    }
+  }
+  /**
+   * Type guard to check if agent is an LlmAgent
+   */
+  isLlmAgent(agent) {
+    return agent && typeof agent === "object" && "canonicalModel" in agent;
+  }
+};
+var requestProcessor6 = new InstructionsLlmRequestProcessor();
+
 // src/planners/base-planner.ts
 var BasePlanner = class {
 };
@@ -7051,7 +7731,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', _213 => _213[i], 'access', _214 => _214.functionCall, 'optionalAccess', _215 => _215.name])) {
+        if (!_optionalChain([responseParts, 'access', _224 => _224[i], 'access', _225 => _225.functionCall, 'optionalAccess', _226 => _226.name])) {
           continue;
         }
         preservedParts.push(responseParts[i]);
@@ -7090,7 +7770,7 @@ var PlanReActPlanner = class extends BasePlanner {
    * Handles non-function-call parts of the response
    */
   _handleNonFunctionCallParts(responsePart, preservedParts) {
-    if (_optionalChain([responsePart, 'access', _216 => _216.text, 'optionalAccess', _217 => _217.includes, 'call', _218 => _218(FINAL_ANSWER_TAG)])) {
+    if (_optionalChain([responsePart, 'access', _227 => _227.text, 'optionalAccess', _228 => _228.includes, 'call', _229 => _229(FINAL_ANSWER_TAG)])) {
       const [reasoningText, finalAnswerText] = this._splitByLastPattern(
         responsePart.text,
         FINAL_ANSWER_TAG
@@ -7257,66 +7937,10 @@ function removeThoughtFromRequest(llmRequest) {
     }
   }
 }
-var requestProcessor6 = new NlPlanningRequestProcessor();
-var responseProcessor = new NlPlanningResponseProcessor();
-
-// src/flows/llm-flows/code-execution.ts
-var CodeExecutionRequestProcessor = class extends BaseLlmRequestProcessor {
-  async *runAsync(invocationContext, llmRequest) {
-    const agent = invocationContext.agent;
-    if (!("codeExecutor" in agent) || !agent.codeExecutor) {
-      return;
-    }
-    console.log(
-      "Code execution request processing - TODO: Implement when code-executors module is ready"
-    );
-    for await (const _ of []) {
-      yield _;
-    }
-  }
-  /**
-   * Placeholder for pre-processor logic
-   * TODO: Implement when code-executors are ready
-   */
-  async *runPreProcessor(invocationContext, llmRequest) {
-    console.log("Code execution pre-processor - placeholder");
-    for await (const _ of []) {
-      yield _;
-    }
-  }
-};
-var CodeExecutionResponseProcessor = class extends BaseLlmResponseProcessor {
-  async *runAsync(invocationContext, llmResponse) {
-    if (llmResponse.partial) {
-      return;
-    }
-    const agent = invocationContext.agent;
-    if (!("codeExecutor" in agent) || !agent.codeExecutor) {
-      return;
-    }
-    console.log(
-      "Code execution response processing - TODO: Implement when code-executors module is ready"
-    );
-    for await (const _ of []) {
-      yield _;
-    }
-  }
-  /**
-   * Placeholder for post-processor logic
-   * TODO: Implement when code-executors are ready
-   */
-  async *runPostProcessor(invocationContext, llmResponse) {
-    console.log("Code execution post-processor - placeholder");
-    for await (const _ of []) {
-      yield _;
-    }
-  }
-};
-var requestProcessor7 = new CodeExecutionRequestProcessor();
-var responseProcessor2 = new CodeExecutionResponseProcessor();
+var requestProcessor7 = new NlPlanningRequestProcessor();
+var responseProcessor2 = new NlPlanningResponseProcessor();
 
 // src/flows/llm-flows/single-flow.ts
-var logger7 = new Logger({ name: "SingleFlow" });
 var SingleFlow = class extends BaseLlmFlow {
   /**
    * Constructor for SingleFlow
@@ -7324,35 +7948,32 @@ var SingleFlow = class extends BaseLlmFlow {
   constructor() {
     super();
     this.requestProcessors.push(
-      requestProcessor,
       requestProcessor2,
+      requestProcessor,
       // Phase 3: Auth preprocessor
-      requestProcessor4,
-      requestProcessor3,
+      requestProcessor6,
       requestProcessor5,
+      requestProcessor4,
       // Some implementations of NL Planning mark planning contents as thoughts
       // in the post processor. Since these need to be unmarked, NL Planning
       // should be after contents.
-      requestProcessor6,
+      requestProcessor7,
       // Phase 5: NL Planning
       // Code execution should be after the contents as it mutates the contents
       // to optimize data files.
-      requestProcessor7
+      requestProcessor3
       // Phase 5: Code Execution (placeholder)
     );
     this.responseProcessors.push(
-      responseProcessor,
+      responseProcessor2,
       // Phase 5: NL Planning
-      responseProcessor2
+      responseProcessor
       // Phase 5: Code Execution (placeholder)
     );
-    logger7.debug("SingleFlow initialized with processors");
+    this.logger.debug("SingleFlow initialized with processors");
   }
 };
 
-// src/flows/llm-flows/auto-flow.ts
-init_logger();
-
 // src/flows/llm-flows/agent-transfer.ts
 var AgentTransferLlmRequestProcessor = class extends BaseLlmRequestProcessor {
   /**
@@ -7442,7 +8063,6 @@ function getTransferTargets(agent) {
 var requestProcessor8 = new AgentTransferLlmRequestProcessor();
 
 // src/flows/llm-flows/auto-flow.ts
-var logger8 = new Logger({ name: "AutoFlow" });
 var AutoFlow = class extends SingleFlow {
   /**
    * Constructor for AutoFlow
@@ -7450,13 +8070,13 @@ var AutoFlow = class extends SingleFlow {
   constructor() {
     super();
     this.requestProcessors.push(requestProcessor8);
-    logger8.debug("AutoFlow initialized with agent transfer capability");
+    this.logger.debug("AutoFlow initialized with agent transfer capability");
   }
 };
 
 // src/agents/llm-agent.ts
 init_function_tool();
-var LlmAgent = (_class21 = class _LlmAgent extends BaseAgent {
+var LlmAgent = (_class23 = class _LlmAgent extends BaseAgent {
   /**
    * The model to use for the agent
    * When not set, the agent will inherit the model from its ancestor
@@ -7475,6 +8095,10 @@ var LlmAgent = (_class21 = class _LlmAgent extends BaseAgent {
    * Tools available to this agent
    */
   
+  /**
+   * Code executor for this agent
+   */
+  
   /**
    * Disallows LLM-controlled transferring to the parent agent
    */
@@ -7529,7 +8153,7 @@ var LlmAgent = (_class21 = class _LlmAgent extends BaseAgent {
    */
   
   // Schema type - depends on specific implementation
-  __init39() {this.logger = new Logger({ name: "LlmAgent" })}
+  __init42() {this.logger = new Logger({ name: "LlmAgent" })}
   /**
    * Constructor for LlmAgent
    */
@@ -7537,11 +8161,12 @@ var LlmAgent = (_class21 = class _LlmAgent extends BaseAgent {
     super({
       name: config.name,
       description: config.description
-    });_class21.prototype.__init39.call(this);;
+    });_class23.prototype.__init42.call(this);;
     this.model = config.model || "";
     this.instruction = config.instruction || "";
     this.globalInstruction = config.globalInstruction || "";
     this.tools = config.tools || [];
+    this.codeExecutor = config.codeExecutor;
     this.disallowTransferToParent = config.disallowTransferToParent || false;
     this.disallowTransferToPeers = config.disallowTransferToPeers || false;
     this.includeContents = config.includeContents || "default";
@@ -7561,11 +8186,14 @@ var LlmAgent = (_class21 = class _LlmAgent extends BaseAgent {
    * This method is only for use by Agent Development Kit
    */
   get canonicalModel() {
-    if (typeof this.model !== "string") {
+    if (typeof this.model === "string") {
+      if (this.model) {
+        return LLMRegistry.newLLM(this.model);
+      }
+    } else if (this.model instanceof BaseLlm) {
       return this.model;
-    }
-    if (this.model) {
-      return LLMRegistry.newLLM(this.model);
+    } else if (this.model) {
+      return new AiSdkLlm(this.model);
     }
     let ancestorAgent = this.parentAgent;
     while (ancestorAgent !== null) {
@@ -7619,7 +8247,7 @@ var LlmAgent = (_class21 = class _LlmAgent extends BaseAgent {
    * This matches the Python implementation's _llm_flow property
    */
   get llmFlow() {
-    if (this.disallowTransferToParent && this.disallowTransferToPeers && !_optionalChain([this, 'access', _219 => _219.subAgents, 'optionalAccess', _220 => _220.length])) {
+    if (this.disallowTransferToParent && this.disallowTransferToPeers && !_optionalChain([this, 'access', _230 => _230.subAgents, 'optionalAccess', _231 => _231.length])) {
       return new SingleFlow();
     }
     return new AutoFlow();
@@ -7629,7 +8257,7 @@ var LlmAgent = (_class21 = class _LlmAgent extends BaseAgent {
    * This matches the Python implementation's __maybe_save_output_to_state
    */
   maybeSaveOutputToState(event) {
-    if (this.outputKey && event.isFinalResponse() && _optionalChain([event, 'access', _221 => _221.content, 'optionalAccess', _222 => _222.parts])) {
+    if (this.outputKey && event.isFinalResponse() && _optionalChain([event, 'access', _232 => _232.content, 'optionalAccess', _233 => _233.parts])) {
       const result = event.content.parts.map((part) => part.text || "").join("");
       if (result) {
         if (!event.actions.stateDelta) {
@@ -7669,7 +8297,7 @@ var LlmAgent = (_class21 = class _LlmAgent extends BaseAgent {
       yield errorEvent;
     }
   }
-}, _class21);
+}, _class23);
 
 // src/agents/sequential-agent.ts
 var SequentialAgent = class extends BaseAgent {
@@ -7735,11 +8363,11 @@ var LlmCallsLimitExceededError = class extends Error {
     this.name = "LlmCallsLimitExceededError";
   }
 };
-var InvocationCostManager = (_class22 = class {constructor() { _class22.prototype.__init40.call(this); }
+var InvocationCostManager = (_class24 = class {constructor() { _class24.prototype.__init43.call(this); }
   /**
    * A counter that keeps track of number of llm calls made.
    */
-  __init40() {this._numberOfLlmCalls = 0}
+  __init43() {this._numberOfLlmCalls = 0}
   /**
    * Increments _numberOfLlmCalls and enforces the limit.
    */
@@ -7751,11 +8379,11 @@ var InvocationCostManager = (_class22 = class {constructor() { _class22.prototyp
       );
     }
   }
-}, _class22);
+}, _class24);
 function newInvocationContextId() {
   return `e-${crypto.randomUUID()}`;
 }
-var InvocationContext = (_class23 = class _InvocationContext {
+var InvocationContext = (_class25 = class _InvocationContext {
   
   
   
@@ -7790,7 +8418,7 @@ var InvocationContext = (_class23 = class _InvocationContext {
    *
    * Set to True in callbacks or tools to terminate this invocation.
    */
-  __init41() {this.endInvocation = false}
+  __init44() {this.endInvocation = false}
   /**
    * The queue to receive live requests.
    */
@@ -7811,11 +8439,11 @@ var InvocationContext = (_class23 = class _InvocationContext {
    * A container to keep track of different kinds of costs incurred as a part
    * of this invocation.
    */
-  __init42() {this._invocationCostManager = new InvocationCostManager()}
+  __init45() {this._invocationCostManager = new InvocationCostManager()}
   /**
    * Constructor for InvocationContext
    */
-  constructor(options) {;_class23.prototype.__init41.call(this);_class23.prototype.__init42.call(this);
+  constructor(options) {;_class25.prototype.__init44.call(this);_class25.prototype.__init45.call(this);
     this.artifactService = options.artifactService;
     this.sessionService = options.sessionService;
     this.memoryService = options.memoryService;
@@ -7875,7 +8503,7 @@ var InvocationContext = (_class23 = class _InvocationContext {
       runConfig: this.runConfig
     });
   }
-}, _class23);
+}, _class25);
 
 // src/agents/parallel-agent.ts
 function createBranchContextForSubAgent(agent, subAgent, invocationContext) {
@@ -7992,7 +8620,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', _223 => _223.actions, 'optionalAccess', _224 => _224.escalate])) {
+          if (_optionalChain([event, 'access', _234 => _234.actions, 'optionalAccess', _235 => _235.escalate])) {
             return;
           }
         }
@@ -8010,7 +8638,7 @@ var LoopAgent = class extends BaseAgent {
 
 // src/agents/lang-graph-agent.ts
 init_logger();
-var LangGraphAgent = (_class24 = class extends BaseAgent {
+var LangGraphAgent = (_class26 = class extends BaseAgent {
   /**
    * Graph nodes (agents and their connections)
    */
@@ -8026,8 +8654,8 @@ var LangGraphAgent = (_class24 = class extends BaseAgent {
   /**
    * Results from node executions
    */
-  __init43() {this.results = []}
-  __init44() {this.logger = new Logger({ name: "LangGraphAgent" })}
+  __init46() {this.results = []}
+  __init47() {this.logger = new Logger({ name: "LangGraphAgent" })}
   /**
    * Constructor for LangGraphAgent
    */
@@ -8035,7 +8663,7 @@ var LangGraphAgent = (_class24 = class extends BaseAgent {
     super({
       name: config.name,
       description: config.description
-    });_class24.prototype.__init43.call(this);_class24.prototype.__init44.call(this);;
+    });_class26.prototype.__init46.call(this);_class26.prototype.__init47.call(this);;
     this.nodes = /* @__PURE__ */ new Map();
     for (const node of config.nodes) {
       if (this.nodes.has(node.name)) {
@@ -8231,7 +8859,7 @@ var LangGraphAgent = (_class24 = class extends BaseAgent {
     }
     this.maxSteps = maxSteps;
   }
-}, _class24);
+}, _class26);
 
 // src/runners.ts
 
@@ -8300,17 +8928,17 @@ var RunConfig = class {
    */
   
   constructor(config) {
-    this.speechConfig = _optionalChain([config, 'optionalAccess', _225 => _225.speechConfig]);
-    this.responseModalities = _optionalChain([config, 'optionalAccess', _226 => _226.responseModalities]);
-    this.saveInputBlobsAsArtifacts = _optionalChain([config, 'optionalAccess', _227 => _227.saveInputBlobsAsArtifacts]) || false;
-    this.supportCFC = _optionalChain([config, 'optionalAccess', _228 => _228.supportCFC]) || false;
-    this.streamingMode = _optionalChain([config, 'optionalAccess', _229 => _229.streamingMode]) || "NONE" /* NONE */;
-    this.outputAudioTranscription = _optionalChain([config, 'optionalAccess', _230 => _230.outputAudioTranscription]);
-    this.inputAudioTranscription = _optionalChain([config, 'optionalAccess', _231 => _231.inputAudioTranscription]);
-    this.realtimeInputConfig = _optionalChain([config, 'optionalAccess', _232 => _232.realtimeInputConfig]);
-    this.enableAffectiveDialog = _optionalChain([config, 'optionalAccess', _233 => _233.enableAffectiveDialog]);
-    this.proactivity = _optionalChain([config, 'optionalAccess', _234 => _234.proactivity]);
-    this.maxLlmCalls = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _235 => _235.maxLlmCalls]), () => ( 500));
+    this.speechConfig = _optionalChain([config, 'optionalAccess', _236 => _236.speechConfig]);
+    this.responseModalities = _optionalChain([config, 'optionalAccess', _237 => _237.responseModalities]);
+    this.saveInputBlobsAsArtifacts = _optionalChain([config, 'optionalAccess', _238 => _238.saveInputBlobsAsArtifacts]) || false;
+    this.supportCFC = _optionalChain([config, 'optionalAccess', _239 => _239.supportCFC]) || false;
+    this.streamingMode = _optionalChain([config, 'optionalAccess', _240 => _240.streamingMode]) || "NONE" /* NONE */;
+    this.outputAudioTranscription = _optionalChain([config, 'optionalAccess', _241 => _241.outputAudioTranscription]);
+    this.inputAudioTranscription = _optionalChain([config, 'optionalAccess', _242 => _242.inputAudioTranscription]);
+    this.realtimeInputConfig = _optionalChain([config, 'optionalAccess', _243 => _243.realtimeInputConfig]);
+    this.enableAffectiveDialog = _optionalChain([config, 'optionalAccess', _244 => _244.enableAffectiveDialog]);
+    this.proactivity = _optionalChain([config, 'optionalAccess', _245 => _245.proactivity]);
+    this.maxLlmCalls = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _246 => _246.maxLlmCalls]), () => ( 500));
     this.validateMaxLlmCalls();
   }
   /**
@@ -8331,10 +8959,8 @@ var RunConfig = class {
 };
 
 // src/artifacts/in-memory-artifact-service.ts
-init_logger();
-var logger9 = new Logger({ name: "InMemoryArtifactService" });
-var InMemoryArtifactService = (_class25 = class {constructor() { _class25.prototype.__init45.call(this); }
-  __init45() {this.artifacts = /* @__PURE__ */ new Map()}
+var InMemoryArtifactService = (_class27 = class {constructor() { _class27.prototype.__init48.call(this); }
+  __init48() {this.artifacts = /* @__PURE__ */ new Map()}
   fileHasUserNamespace(filename) {
     return filename.startsWith("user:");
   }
@@ -8407,7 +9033,7 @@ var InMemoryArtifactService = (_class25 = class {constructor() { _class25.protot
     }
     return Array.from({ length: versions.length }, (_, i) => i);
   }
-}, _class25);
+}, _class27);
 
 // src/runners.ts
 init_logger();
@@ -8434,15 +9060,15 @@ function _extractWordsLower(text) {
   const words = text.match(/[A-Za-z]+/g) || [];
   return new Set(words.map((word) => word.toLowerCase()));
 }
-var InMemoryMemoryService = (_class26 = class {
+var InMemoryMemoryService = (_class28 = class {
   /**
    * Keys are app_name/user_id, session_id. Values are session event lists.
    */
-  __init46() {this._sessionEvents = /* @__PURE__ */ new Map()}
+  __init49() {this._sessionEvents = /* @__PURE__ */ new Map()}
   /**
    * Constructor for InMemoryMemoryService
    */
-  constructor() {;_class26.prototype.__init46.call(this);
+  constructor() {;_class28.prototype.__init49.call(this);
     this._sessionEvents = /* @__PURE__ */ new Map();
   }
   /**
@@ -8456,7 +9082,7 @@ var InMemoryMemoryService = (_class26 = class {
     }
     const userSessions = this._sessionEvents.get(userKey);
     const filteredEvents = session.events.filter(
-      (event) => _optionalChain([event, 'access', _236 => _236.content, 'optionalAccess', _237 => _237.parts])
+      (event) => _optionalChain([event, 'access', _247 => _247.content, 'optionalAccess', _248 => _248.parts])
     );
     userSessions.set(session.id, filteredEvents);
   }
@@ -8526,7 +9152,7 @@ var InMemoryMemoryService = (_class26 = class {
   clear() {
     this._sessionEvents.clear();
   }
-}, _class26);
+}, _class28);
 
 // src/sessions/in-memory-session-service.ts
 var _crypto = require('crypto');
@@ -8568,19 +9194,19 @@ var BaseSessionService = class {
 };
 
 // src/sessions/in-memory-session-service.ts
-var InMemorySessionService = (_class27 = class extends BaseSessionService {constructor(...args2) { super(...args2); _class27.prototype.__init47.call(this);_class27.prototype.__init48.call(this);_class27.prototype.__init49.call(this); }
+var InMemorySessionService = (_class29 = class extends BaseSessionService {constructor(...args2) { super(...args2); _class29.prototype.__init50.call(this);_class29.prototype.__init51.call(this);_class29.prototype.__init52.call(this); }
   /**
    * A map from app name to a map from user ID to a map from session ID to session.
    */
-  __init47() {this.sessions = /* @__PURE__ */ new Map()}
+  __init50() {this.sessions = /* @__PURE__ */ new Map()}
   /**
    * A map from app name to a map from user ID to a map from key to the value.
    */
-  __init48() {this.userState = /* @__PURE__ */ new Map()}
+  __init51() {this.userState = /* @__PURE__ */ new Map()}
   /**
    * A map from app name to a map from key to the value.
    */
-  __init49() {this.appState = /* @__PURE__ */ new Map()}
+  __init52() {this.appState = /* @__PURE__ */ new Map()}
   /**
    * Creates a new session.
    */
@@ -8595,7 +9221,7 @@ var InMemorySessionService = (_class27 = class extends BaseSessionService {const
     return this.createSessionImpl(appName, userId, state, sessionId);
   }
   createSessionImpl(appName, userId, state, sessionId) {
-    const finalSessionId = _optionalChain([sessionId, 'optionalAccess', _238 => _238.trim, 'call', _239 => _239()]) || _crypto.randomUUID.call(void 0, );
+    const finalSessionId = _optionalChain([sessionId, 'optionalAccess', _249 => _249.trim, 'call', _250 => _250()]) || _crypto.randomUUID.call(void 0, );
     const session = {
       appName,
       userId,
@@ -8752,7 +9378,7 @@ var InMemorySessionService = (_class27 = class extends BaseSessionService {const
       warning(`sessionId ${sessionId} not in sessions[appName][userId]`);
       return event;
     }
-    if (_optionalChain([event, 'access', _240 => _240.actions, 'optionalAccess', _241 => _241.stateDelta])) {
+    if (_optionalChain([event, 'access', _251 => _251.actions, 'optionalAccess', _252 => _252.stateDelta])) {
       for (const key in event.actions.stateDelta) {
         const value = event.actions.stateDelta[key];
         if (key.startsWith(State.APP_PREFIX)) {
@@ -8777,24 +9403,23 @@ var InMemorySessionService = (_class27 = class extends BaseSessionService {const
     storageSession.lastUpdateTime = event.timestamp;
     return event;
   }
-}, _class27);
+}, _class29);
 
 // src/runners.ts
-var logger10 = new Logger({ name: "Runner" });
 function _findFunctionCallEventIfLastEventIsFunctionResponse(session) {
   const events = session.events;
   if (!events || events.length === 0) {
     return null;
   }
   const lastEvent = events[events.length - 1];
-  if (_optionalChain([lastEvent, 'access', _242 => _242.content, 'optionalAccess', _243 => _243.parts, 'optionalAccess', _244 => _244.some, 'call', _245 => _245((part) => part.functionResponse)])) {
-    const functionCallId = _optionalChain([lastEvent, 'access', _246 => _246.content, 'access', _247 => _247.parts, 'access', _248 => _248.find, 'call', _249 => _249(
+  if (_optionalChain([lastEvent, 'access', _253 => _253.content, 'optionalAccess', _254 => _254.parts, 'optionalAccess', _255 => _255.some, 'call', _256 => _256((part) => part.functionResponse)])) {
+    const functionCallId = _optionalChain([lastEvent, 'access', _257 => _257.content, 'access', _258 => _258.parts, 'access', _259 => _259.find, 'call', _260 => _260(
       (part) => part.functionResponse
-    ), 'optionalAccess', _250 => _250.functionResponse, 'optionalAccess', _251 => _251.id]);
+    ), 'optionalAccess', _261 => _261.functionResponse, 'optionalAccess', _262 => _262.id]);
     if (!functionCallId) return null;
     for (let i = events.length - 2; i >= 0; i--) {
       const event = events[i];
-      const functionCalls = _optionalChain([event, 'access', _252 => _252.getFunctionCalls, 'optionalCall', _253 => _253()]) || [];
+      const functionCalls = _optionalChain([event, 'access', _263 => _263.getFunctionCalls, 'optionalCall', _264 => _264()]) || [];
       for (const functionCall of functionCalls) {
         if (functionCall.id === functionCallId) {
           return event;
@@ -8804,7 +9429,7 @@ function _findFunctionCallEventIfLastEventIsFunctionResponse(session) {
   }
   return null;
 }
-var Runner = class {
+var Runner = (_class30 = class {
   /**
    * The app name of the runner.
    */
@@ -8825,6 +9450,7 @@ var Runner = class {
    * The memory service for the runner.
    */
   
+  __init53() {this.logger = new Logger({ name: "Runner" })}
   /**
    * Initializes the Runner.
    */
@@ -8834,7 +9460,7 @@ var Runner = class {
     artifactService,
     sessionService,
     memoryService
-  }) {
+  }) {;_class30.prototype.__init53.call(this);
     this.appName = appName;
     this.agent = agent;
     this.artifactService = artifactService;
@@ -8927,7 +9553,7 @@ var Runner = class {
         yield event;
       }
     } catch (error) {
-      logger10.debug("Error running agent:", error);
+      this.logger.debug("Error running agent:", error);
       span.recordException(error);
       span.setStatus({
         code: _api.SpanStatusCode.ERROR,
@@ -8981,17 +9607,17 @@ var Runner = class {
    */
   _findAgentToRun(session, rootAgent) {
     const event = _findFunctionCallEventIfLastEventIsFunctionResponse(session);
-    if (_optionalChain([event, 'optionalAccess', _254 => _254.author])) {
+    if (_optionalChain([event, 'optionalAccess', _265 => _265.author])) {
       return rootAgent.findAgent(event.author);
     }
-    const nonUserEvents = _optionalChain([session, 'access', _255 => _255.events, 'optionalAccess', _256 => _256.filter, 'call', _257 => _257((e) => e.author !== "user"), 'access', _258 => _258.reverse, 'call', _259 => _259()]) || [];
+    const nonUserEvents = _optionalChain([session, 'access', _266 => _266.events, 'optionalAccess', _267 => _267.filter, 'call', _268 => _268((e) => e.author !== "user"), 'access', _269 => _269.reverse, 'call', _270 => _270()]) || [];
     for (const event2 of nonUserEvents) {
       if (event2.author === rootAgent.name) {
         return rootAgent;
       }
-      const agent = _optionalChain([rootAgent, 'access', _260 => _260.findSubAgent, 'optionalCall', _261 => _261(event2.author)]);
+      const agent = _optionalChain([rootAgent, 'access', _271 => _271.findSubAgent, 'optionalCall', _272 => _272(event2.author)]);
       if (!agent) {
-        logger10.debug(
+        this.logger.debug(
           `Event from an unknown agent: ${event2.author}, event id: ${event2.id}`
         );
         continue;
@@ -9038,7 +9664,7 @@ var Runner = class {
       runConfig
     });
   }
-};
+}, _class30);
 var InMemoryRunner = class extends Runner {
   /**
    * Deprecated. Please don't use. The in-memory session service for the runner.
@@ -9061,14 +9687,14 @@ var InMemoryRunner = class extends Runner {
 };
 
 // src/agents/agent-builder.ts
-var AgentBuilder = (_class28 = class _AgentBuilder {
+var AgentBuilder = (_class31 = class _AgentBuilder {
   
   
-  __init50() {this.agentType = "llm"}
+  __init54() {this.agentType = "llm"}
   /**
    * Private constructor - use static create() method
    */
-  constructor(name) {;_class28.prototype.__init50.call(this);
+  constructor(name) {;_class31.prototype.__init54.call(this);
     this.config = { name };
   }
   /**
@@ -9255,7 +9881,7 @@ var AgentBuilder = (_class28 = class _AgentBuilder {
         parts: [{ text: message }]
       }
     })) {
-      if (_optionalChain([event, 'access', _262 => _262.content, 'optionalAccess', _263 => _263.parts])) {
+      if (_optionalChain([event, 'access', _273 => _273.content, 'optionalAccess', _274 => _274.parts])) {
         const content = event.content.parts.map((part) => part.text || "").join("");
         if (content) {
           response += content;
@@ -9270,6 +9896,20 @@ var AgentBuilder = (_class28 = class _AgentBuilder {
    */
   createAgent() {
     switch (this.agentType) {
+      case "llm": {
+        if (!this.config.model) {
+          throw new Error("Model is required for LLM agent");
+        }
+        const model = this.config.model;
+        return new LlmAgent({
+          name: this.config.name,
+          model,
+          description: this.config.description,
+          instruction: this.config.instruction,
+          tools: this.config.tools,
+          planner: this.config.planner
+        });
+      }
       case "sequential":
         if (!this.config.subAgents) {
           throw new Error("Sub-agents required for sequential agent");
@@ -9308,18 +9948,9 @@ var AgentBuilder = (_class28 = class _AgentBuilder {
           nodes: this.config.nodes,
           rootNode: this.config.rootNode
         });
-      default:
-        return new LlmAgent({
-          name: this.config.name,
-          model: this.config.model,
-          description: this.config.description,
-          instruction: this.config.instruction,
-          tools: this.config.tools,
-          planner: this.config.planner
-        });
     }
   }
-}, _class28);
+}, _class31);
 
 // src/memory/index.ts
 var memory_exports = {};
@@ -9383,7 +10014,7 @@ var VertexAiSessionService = class extends BaseSessionService {
         path: `operations/${operationId}`,
         request_dict: {}
       });
-      if (_optionalChain([lroResponse, 'optionalAccess', _264 => _264.done])) {
+      if (_optionalChain([lroResponse, 'optionalAccess', _275 => _275.done])) {
         break;
       }
       await new Promise((resolve) => setTimeout(resolve, 1e3));
@@ -9653,11 +10284,11 @@ var VertexAiSessionService = class extends BaseSessionService {
 
 // src/sessions/database-session-service.ts
 var _kysely = require('kysely');
-var DatabaseSessionService = (_class29 = class extends BaseSessionService {
+var DatabaseSessionService = (_class32 = class extends BaseSessionService {
   
-  __init51() {this.initialized = false}
+  __init55() {this.initialized = false}
   constructor(config) {
-    super();_class29.prototype.__init51.call(this);;
+    super();_class32.prototype.__init55.call(this);;
     this.db = config.db;
     if (!config.skipTableCreation) {
       this.initializeDatabase().catch((error) => {
@@ -9732,7 +10363,7 @@ var DatabaseSessionService = (_class29 = class extends BaseSessionService {
     if (!jsonString) return defaultValue;
     try {
       return JSON.parse(jsonString);
-    } catch (e3) {
+    } catch (e4) {
       return defaultValue;
     }
   }
@@ -9754,12 +10385,12 @@ var DatabaseSessionService = (_class29 = class extends BaseSessionService {
   }
   async createSession(appName, userId, state, sessionId) {
     await this.ensureInitialized();
-    const id = _optionalChain([sessionId, 'optionalAccess', _265 => _265.trim, 'call', _266 => _266()]) || this.generateSessionId();
+    const id = _optionalChain([sessionId, 'optionalAccess', _276 => _276.trim, 'call', _277 => _277()]) || 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', _267 => _267.state]), {});
-      let currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _268 => _268.state]), {});
+      let currentAppState = this.parseJsonSafely(_optionalChain([appState, 'optionalAccess', _278 => _278.state]), {});
+      let currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _279 => _279.state]), {});
       if (!appState) {
         await trx.insertInto("app_states").values({
           app_name: appName,
@@ -9818,21 +10449,21 @@ var DatabaseSessionService = (_class29 = class extends BaseSessionService {
         return void 0;
       }
       let eventQuery = trx.selectFrom("events").selectAll().where("session_id", "=", sessionId).orderBy("timestamp", "desc");
-      if (_optionalChain([config, 'optionalAccess', _269 => _269.afterTimestamp])) {
+      if (_optionalChain([config, 'optionalAccess', _280 => _280.afterTimestamp])) {
         eventQuery = eventQuery.where(
           "timestamp",
           ">=",
           new Date(config.afterTimestamp * 1e3)
         );
       }
-      if (_optionalChain([config, 'optionalAccess', _270 => _270.numRecentEvents])) {
+      if (_optionalChain([config, 'optionalAccess', _281 => _281.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', _271 => _271.state]), {});
-      const currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _272 => _272.state]), {});
+      const currentAppState = this.parseJsonSafely(_optionalChain([appState, 'optionalAccess', _282 => _282.state]), {});
+      const currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _283 => _283.state]), {});
       const sessionState = this.parseJsonSafely(storageSession.state, {});
       const mergedState = this.mergeState(
         currentAppState,
@@ -9890,13 +10521,13 @@ var DatabaseSessionService = (_class29 = 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', _273 => _273.state]), {});
-      let currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _274 => _274.state]), {});
+      let currentAppState = this.parseJsonSafely(_optionalChain([appState, 'optionalAccess', _284 => _284.state]), {});
+      let currentUserState = this.parseJsonSafely(_optionalChain([userState, 'optionalAccess', _285 => _285.state]), {});
       let sessionState = this.parseJsonSafely(storageSession.state, {});
       let appStateDelta = {};
       let userStateDelta = {};
       let sessionStateDelta = {};
-      if (_optionalChain([event, 'access', _275 => _275.actions, 'optionalAccess', _276 => _276.stateDelta])) {
+      if (_optionalChain([event, 'access', _286 => _286.actions, 'optionalAccess', _287 => _287.stateDelta])) {
         const deltas = this.extractStateDelta(event.actions.stateDelta);
         appStateDelta = deltas.appStateDelta;
         userStateDelta = deltas.userStateDelta;
@@ -10042,7 +10673,7 @@ var DatabaseSessionService = (_class29 = class extends BaseSessionService {
    * Overrides the base class method to work with plain object state.
    */
   updateSessionState(session, event) {
-    if (!_optionalChain([event, 'access', _277 => _277.actions, 'optionalAccess', _278 => _278.stateDelta])) {
+    if (!_optionalChain([event, 'access', _288 => _288.actions, 'optionalAccess', _289 => _289.stateDelta])) {
       return;
     }
     for (const [key, value] of Object.entries(event.actions.stateDelta)) {
@@ -10051,10 +10682,10 @@ var DatabaseSessionService = (_class29 = class extends BaseSessionService {
       }
     }
   }
-}, _class29);
+}, _class32);
 
 // src/sessions/database-factories.ts
-
+var _dedent = require('dedent'); var _dedent2 = _interopRequireDefault(_dedent);
 
 function createDependencyError(packageName, dbType) {
   return new Error(
@@ -10131,11 +10762,9 @@ function createDatabaseSessionService(databaseUrl, options) {
 }
 
 // src/artifacts/gcs-artifact-service.ts
-init_logger();
 
 
 var _storage = require('@google-cloud/storage');
-var logger11 = new Logger({ name: "GcsArtifactService" });
 var GcsArtifactService = class {
   
   
@@ -10214,7 +10843,7 @@ var GcsArtifactService = class {
       };
       return part;
     } catch (error) {
-      if (_optionalChain([error, 'optionalAccess', _279 => _279.code]) === 404) {
+      if (_optionalChain([error, 'optionalAccess', _290 => _290.code]) === 404) {
         return null;
       }
       throw error;
@@ -10290,20 +10919,20 @@ __export(flows_exports, {
   REQUEST_EUC_FUNCTION_CALL_NAME: () => REQUEST_EUC_FUNCTION_CALL_NAME,
   SingleFlow: () => SingleFlow,
   agentTransferRequestProcessor: () => requestProcessor8,
-  basicRequestProcessor: () => requestProcessor,
-  codeExecutionRequestProcessor: () => requestProcessor7,
-  codeExecutionResponseProcessor: () => responseProcessor2,
-  contentRequestProcessor: () => requestProcessor5,
+  basicRequestProcessor: () => requestProcessor2,
+  codeExecutionRequestProcessor: () => requestProcessor3,
+  codeExecutionResponseProcessor: () => responseProcessor,
+  contentRequestProcessor: () => requestProcessor4,
   generateAuthEvent: () => generateAuthEvent,
   generateClientFunctionCallId: () => generateClientFunctionCallId,
   getLongRunningFunctionCalls: () => getLongRunningFunctionCalls,
   handleFunctionCallsAsync: () => handleFunctionCallsAsync,
   handleFunctionCallsLive: () => handleFunctionCallsLive,
-  identityRequestProcessor: () => requestProcessor3,
-  instructionsRequestProcessor: () => requestProcessor4,
+  identityRequestProcessor: () => requestProcessor5,
+  instructionsRequestProcessor: () => requestProcessor6,
   mergeParallelFunctionResponseEvents: () => mergeParallelFunctionResponseEvents,
-  nlPlanningRequestProcessor: () => requestProcessor6,
-  nlPlanningResponseProcessor: () => responseProcessor,
+  nlPlanningRequestProcessor: () => requestProcessor7,
+  nlPlanningResponseProcessor: () => responseProcessor2,
   populateClientFunctionCallId: () => populateClientFunctionCallId,
   removeClientFunctionCallId: () => removeClientFunctionCallId
 });
@@ -10449,4 +11078,9 @@ var VERSION = "0.1.0";
 
 
 
-exports.AF_FUNCTION_CALL_ID_PREFIX = AF_FUNCTION_CALL_ID_PREFIX; exports.Agent = LlmAgent; exports.AgentBuilder = AgentBuilder; exports.Agents = agents_exports; exports.AnthropicLlm = AnthropicLlm; exports.ApiKeyCredential = ApiKeyCredential; exports.ApiKeyScheme = ApiKeyScheme; exports.AuthConfig = AuthConfig; exports.AuthCredential = AuthCredential; exports.AuthCredentialType = AuthCredentialType; exports.AuthHandler = AuthHandler; exports.AuthScheme = AuthScheme; exports.AuthSchemeType = AuthSchemeType; exports.AuthTool = AuthTool; exports.AutoFlow = AutoFlow; exports.BaseAgent = BaseAgent; exports.BaseLLMConnection = BaseLLMConnection; exports.BaseLlm = BaseLlm; exports.BaseLlmFlow = BaseLlmFlow; exports.BaseLlmRequestProcessor = BaseLlmRequestProcessor; exports.BaseLlmResponseProcessor = BaseLlmResponseProcessor; exports.BasePlanner = BasePlanner; exports.BaseSessionService = BaseSessionService; exports.BaseTool = BaseTool; exports.BasicAuthCredential = BasicAuthCredential; exports.BearerTokenCredential = BearerTokenCredential; exports.BuiltInPlanner = BuiltInPlanner; exports.CallbackContext = CallbackContext; exports.DatabaseSessionService = DatabaseSessionService; exports.EnhancedAuthConfig = EnhancedAuthConfig; exports.Event = Event; exports.EventActions = EventActions; exports.Events = events_exports; exports.ExitLoopTool = ExitLoopTool; exports.FileOperationsTool = FileOperationsTool; exports.Flows = flows_exports; exports.FunctionTool = FunctionTool; exports.GcsArtifactService = GcsArtifactService; exports.GetUserChoiceTool = GetUserChoiceTool; exports.GoogleLlm = GoogleLlm; exports.GoogleSearch = GoogleSearch; exports.HttpRequestTool = HttpRequestTool; exports.HttpScheme = HttpScheme; exports.InMemoryArtifactService = InMemoryArtifactService; exports.InMemoryMemoryService = InMemoryMemoryService; exports.InMemoryRunner = InMemoryRunner; exports.InMemorySessionService = InMemorySessionService; exports.InvocationContext = InvocationContext; exports.LLMRegistry = LLMRegistry; exports.LangGraphAgent = LangGraphAgent; exports.LlmAgent = LlmAgent; exports.LlmCallsLimitExceededError = LlmCallsLimitExceededError; exports.LlmRequest = LlmRequest; exports.LlmResponse = LlmResponse; exports.LoadArtifactsTool = LoadArtifactsTool; exports.LoadMemoryTool = LoadMemoryTool; exports.LoopAgent = LoopAgent; exports.McpAbi = McpAbi; exports.McpAtp = McpAtp; exports.McpBamm = McpBamm; exports.McpError = McpError; exports.McpErrorType = McpErrorType; exports.McpFilesystem = McpFilesystem; exports.McpFraxlend = McpFraxlend; exports.McpGeneric = McpGeneric; exports.McpIqWiki = McpIqWiki; exports.McpMemory = McpMemory; exports.McpNearAgent = McpNearAgent; exports.McpNearIntentSwaps = McpNearIntentSwaps; exports.McpOdos = McpOdos; exports.McpSamplingHandler = McpSamplingHandler; exports.McpTelegram = McpTelegram; exports.McpToolset = McpToolset; exports.Memory = memory_exports; exports.Models = models_exports; exports.OAuth2Credential = OAuth2Credential; exports.OAuth2Scheme = OAuth2Scheme; exports.OpenAiLlm = OpenAiLlm; exports.OpenIdConnectScheme = OpenIdConnectScheme; exports.ParallelAgent = ParallelAgent; exports.PlanReActPlanner = PlanReActPlanner; exports.REQUEST_EUC_FUNCTION_CALL_NAME = REQUEST_EUC_FUNCTION_CALL_NAME; exports.ReadonlyContext = ReadonlyContext; exports.RunConfig = RunConfig; exports.Runner = Runner; exports.SequentialAgent = SequentialAgent; exports.Sessions = sessions_exports; exports.SingleFlow = SingleFlow; exports.State = State; exports.StreamingMode = StreamingMode; exports.TelemetryService = TelemetryService; exports.ToolContext = ToolContext; exports.Tools = tools_exports; exports.TransferToAgentTool = TransferToAgentTool; exports.UserInteractionTool = UserInteractionTool; exports.VERSION = VERSION; exports.VertexAiSessionService = VertexAiSessionService; exports.adkToMcpToolType = adkToMcpToolType; exports.agentTransferRequestProcessor = requestProcessor8; exports.basicRequestProcessor = requestProcessor; exports.buildFunctionDeclaration = buildFunctionDeclaration; exports.codeExecutionRequestProcessor = requestProcessor7; exports.codeExecutionResponseProcessor = responseProcessor2; exports.contentRequestProcessor = requestProcessor5; exports.createAuthToolArguments = createAuthToolArguments; exports.createDatabaseSessionService = createDatabaseSessionService; exports.createFunctionTool = createFunctionTool; exports.createMysqlSessionService = createMysqlSessionService; exports.createPostgresSessionService = createPostgresSessionService; exports.createSamplingHandler = createSamplingHandler; exports.createSqliteSessionService = createSqliteSessionService; exports.generateAuthEvent = generateAuthEvent; exports.generateClientFunctionCallId = generateClientFunctionCallId; exports.getLongRunningFunctionCalls = getLongRunningFunctionCalls; exports.getMcpTools = getMcpTools; exports.handleFunctionCallsAsync = handleFunctionCallsAsync; exports.handleFunctionCallsLive = handleFunctionCallsLive; exports.identityRequestProcessor = requestProcessor3; exports.initializeTelemetry = initializeTelemetry; exports.injectSessionState = injectSessionState; exports.instructionsRequestProcessor = requestProcessor4; exports.isEnhancedAuthConfig = isEnhancedAuthConfig; exports.jsonSchemaToDeclaration = jsonSchemaToDeclaration; exports.mcpSchemaToParameters = mcpSchemaToParameters; exports.mergeParallelFunctionResponseEvents = mergeParallelFunctionResponseEvents; exports.newInvocationContextId = newInvocationContextId; exports.nlPlanningRequestProcessor = requestProcessor6; exports.nlPlanningResponseProcessor = responseProcessor; exports.normalizeJsonSchema = normalizeJsonSchema; exports.populateClientFunctionCallId = populateClientFunctionCallId; exports.registerProviders = registerProviders; exports.removeClientFunctionCallId = removeClientFunctionCallId; exports.requestProcessor = requestProcessor2; exports.shutdownTelemetry = shutdownTelemetry; exports.telemetryService = telemetryService; exports.traceLlmCall = traceLlmCall; exports.traceToolCall = traceToolCall; exports.tracer = tracer;
+
+
+
+
+
+exports.AF_FUNCTION_CALL_ID_PREFIX = AF_FUNCTION_CALL_ID_PREFIX; exports.Agent = LlmAgent; exports.AgentBuilder = AgentBuilder; exports.Agents = agents_exports; exports.AiSdkLlm = AiSdkLlm; exports.AnthropicLlm = AnthropicLlm; exports.ApiKeyCredential = ApiKeyCredential; exports.ApiKeyScheme = ApiKeyScheme; exports.AuthConfig = AuthConfig; exports.AuthCredential = AuthCredential; exports.AuthCredentialType = AuthCredentialType; exports.AuthHandler = AuthHandler; exports.AuthScheme = AuthScheme; exports.AuthSchemeType = AuthSchemeType; exports.AuthTool = AuthTool; exports.AutoFlow = AutoFlow; exports.BaseAgent = BaseAgent; exports.BaseCodeExecutor = BaseCodeExecutor; exports.BaseLLMConnection = BaseLLMConnection; exports.BaseLlm = BaseLlm; exports.BaseLlmFlow = BaseLlmFlow; exports.BaseLlmRequestProcessor = BaseLlmRequestProcessor; exports.BaseLlmResponseProcessor = BaseLlmResponseProcessor; exports.BasePlanner = BasePlanner; exports.BaseSessionService = BaseSessionService; exports.BaseTool = BaseTool; exports.BasicAuthCredential = BasicAuthCredential; exports.BearerTokenCredential = BearerTokenCredential; exports.BuiltInCodeExecutor = BuiltInCodeExecutor; exports.BuiltInPlanner = BuiltInPlanner; exports.CallbackContext = CallbackContext; exports.CodeExecutionUtils = CodeExecutionUtils; exports.CodeExecutorContext = CodeExecutorContext; exports.DatabaseSessionService = DatabaseSessionService; exports.EnhancedAuthConfig = EnhancedAuthConfig; exports.Event = Event; exports.EventActions = EventActions; exports.Events = events_exports; exports.ExitLoopTool = ExitLoopTool; exports.FileOperationsTool = FileOperationsTool; exports.Flows = flows_exports; exports.FunctionTool = FunctionTool; exports.GcsArtifactService = GcsArtifactService; exports.GetUserChoiceTool = GetUserChoiceTool; exports.GoogleLlm = GoogleLlm; exports.GoogleSearch = GoogleSearch; exports.HttpRequestTool = HttpRequestTool; exports.HttpScheme = HttpScheme; exports.InMemoryArtifactService = InMemoryArtifactService; exports.InMemoryMemoryService = InMemoryMemoryService; exports.InMemoryRunner = InMemoryRunner; exports.InMemorySessionService = InMemorySessionService; exports.InvocationContext = InvocationContext; exports.LLMRegistry = LLMRegistry; exports.LangGraphAgent = LangGraphAgent; exports.LlmAgent = LlmAgent; exports.LlmCallsLimitExceededError = LlmCallsLimitExceededError; exports.LlmRequest = LlmRequest; exports.LlmResponse = LlmResponse; exports.LoadArtifactsTool = LoadArtifactsTool; exports.LoadMemoryTool = LoadMemoryTool; exports.LoopAgent = LoopAgent; exports.McpAbi = McpAbi; exports.McpAtp = McpAtp; exports.McpBamm = McpBamm; exports.McpError = McpError; exports.McpErrorType = McpErrorType; exports.McpFilesystem = McpFilesystem; exports.McpFraxlend = McpFraxlend; exports.McpGeneric = McpGeneric; exports.McpIqWiki = McpIqWiki; exports.McpMemory = McpMemory; exports.McpNearAgent = McpNearAgent; exports.McpNearIntentSwaps = McpNearIntentSwaps; exports.McpOdos = McpOdos; exports.McpSamplingHandler = McpSamplingHandler; exports.McpTelegram = McpTelegram; exports.McpToolset = McpToolset; exports.Memory = memory_exports; exports.Models = models_exports; exports.OAuth2Credential = OAuth2Credential; exports.OAuth2Scheme = OAuth2Scheme; exports.OpenAiLlm = OpenAiLlm; exports.OpenIdConnectScheme = OpenIdConnectScheme; exports.ParallelAgent = ParallelAgent; exports.PlanReActPlanner = PlanReActPlanner; exports.REQUEST_EUC_FUNCTION_CALL_NAME = REQUEST_EUC_FUNCTION_CALL_NAME; exports.ReadonlyContext = ReadonlyContext; exports.RunConfig = RunConfig; exports.Runner = Runner; exports.SequentialAgent = SequentialAgent; exports.Sessions = sessions_exports; exports.SingleFlow = SingleFlow; exports.State = State; exports.StreamingMode = StreamingMode; exports.TelemetryService = TelemetryService; exports.ToolContext = ToolContext; exports.Tools = tools_exports; exports.TransferToAgentTool = TransferToAgentTool; exports.UserInteractionTool = UserInteractionTool; exports.VERSION = VERSION; exports.VertexAiSessionService = VertexAiSessionService; exports.adkToMcpToolType = adkToMcpToolType; exports.agentTransferRequestProcessor = requestProcessor8; exports.basicRequestProcessor = requestProcessor2; exports.buildFunctionDeclaration = buildFunctionDeclaration; exports.codeExecutionRequestProcessor = requestProcessor3; exports.codeExecutionResponseProcessor = responseProcessor; exports.contentRequestProcessor = requestProcessor4; exports.createAuthToolArguments = createAuthToolArguments; exports.createDatabaseSessionService = createDatabaseSessionService; exports.createFunctionTool = createFunctionTool; exports.createMysqlSessionService = createMysqlSessionService; exports.createPostgresSessionService = createPostgresSessionService; exports.createSamplingHandler = createSamplingHandler; exports.createSqliteSessionService = createSqliteSessionService; exports.generateAuthEvent = generateAuthEvent; exports.generateClientFunctionCallId = generateClientFunctionCallId; exports.getLongRunningFunctionCalls = getLongRunningFunctionCalls; exports.getMcpTools = getMcpTools; exports.handleFunctionCallsAsync = handleFunctionCallsAsync; exports.handleFunctionCallsLive = handleFunctionCallsLive; exports.identityRequestProcessor = requestProcessor5; exports.initializeTelemetry = initializeTelemetry; exports.injectSessionState = injectSessionState; exports.instructionsRequestProcessor = requestProcessor6; exports.isEnhancedAuthConfig = isEnhancedAuthConfig; exports.jsonSchemaToDeclaration = jsonSchemaToDeclaration; exports.mcpSchemaToParameters = mcpSchemaToParameters; exports.mergeParallelFunctionResponseEvents = mergeParallelFunctionResponseEvents; exports.newInvocationContextId = newInvocationContextId; exports.nlPlanningRequestProcessor = requestProcessor7; exports.nlPlanningResponseProcessor = responseProcessor2; exports.normalizeJsonSchema = normalizeJsonSchema; exports.populateClientFunctionCallId = populateClientFunctionCallId; exports.registerProviders = registerProviders; exports.removeClientFunctionCallId = removeClientFunctionCallId; exports.requestProcessor = requestProcessor; exports.shutdownTelemetry = shutdownTelemetry; exports.telemetryService = telemetryService; exports.traceLlmCall = traceLlmCall; exports.traceToolCall = traceToolCall; exports.tracer = tracer;