@iqai/adk 0.1.3 → 0.1.5

package/dist/index.mjs

@@ -26,8 +26,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/helpers/logger.ts
+import chalk from "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 }) {
         this.name = name;
       }
+      colorize(message) {
+        return chalk.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));
       }
     };
   }
 });
 
 // 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 = class {
       /**
        * Name of the tool
@@ -96,6 +162,7 @@ var init_base_tool = __esm({
        * Maximum delay for retry in ms
        */
       maxRetryDelay = 1e4;
+      logger = new Logger({ name: "BaseTool" });
       /**
        * Constructor for BaseTool
        */
@@ -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(
@@ -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.
    */
   finishReason;
+  /**
+   * Error object if the response is an error.
+   */
+  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
@@ -1127,12 +1220,12 @@ var traceLlmCall = (invocationContext, eventId, llmRequest, llmResponse) => tele
 );
 
 // src/models/base-llm.ts
-var logger2 = new Logger({ name: "BaseLlm" });
 var BaseLlm = class {
   /**
    * The name of the LLM, e.g. gemini-1.5-flash or gemini-1.5-flash-001.
    */
   model;
+  logger = new Logger({ name: "BaseLlm" });
   /**
    * Constructor for BaseLlm
    */
@@ -1183,12 +1276,6 @@ var BaseLlm = class {
             }),
             "adk.streaming": stream || false
           });
-          logger2.debug("ADK LLM Request:", {
-            model: this.model,
-            contentCount: llmRequest.contents?.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: response.parts?.map((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
           });
@@ -1280,13 +1359,10 @@ var BaseLLMConnection = class {
 };
 
 // src/models/google-llm.ts
-init_logger();
 import {
   FinishReason,
   GoogleGenAI
 } from "@google/genai";
-import dedent from "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 = class extends BaseLlm {
@@ -1294,7 +1370,6 @@ var GoogleLlm = class extends BaseLlm {
   _liveApiClient;
   _apiBackend;
   _trackingHeaders;
-  logger = new Logger({ name: "GoogleLlm" });
   /**
    * Constructor for Gemini
    */
@@ -1318,10 +1393,6 @@ var GoogleLlm = 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,7 +1408,6 @@ var GoogleLlm = 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 (llmResponse.content?.parts?.[0]?.text) {
@@ -1390,8 +1460,11 @@ var GoogleLlm = 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: ${llmResponse.usageMetadata?.candidatesTokenCount || 0} tokens`
+      );
+      yield llmResponse;
     }
   }
   /**
@@ -1466,60 +1539,6 @@ var GoogleLlm = class extends BaseLlm {
     }
     return `${funcDecl.name}: ${paramStr}`;
   }
-  /**
-   * Builds request log string.
-   */
-  buildRequestLog(req) {
-    const functionDecls = req.config?.tools?.[0]?.functionDeclarations || [];
-    const functionLogs = functionDecls.length > 0 ? functionDecls.map(
-      (funcDecl) => this.buildFunctionDeclarationLog(funcDecl)
-    ) : [];
-    const contentsLogs = req.contents?.map(
-      (content) => JSON.stringify(content, (key, value) => {
-        if (key === "data" && typeof value === "string" && value.length > 100) {
-          return "[EXCLUDED]";
-        }
-        return value;
-      })
-    ) || [];
-    return dedent`
-		LLM Request:
-		-----------------------------------------------------------
-		System Instruction:
-		${req.config?.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 dedent`
-		LLM Response:
-		-----------------------------------------------------------
-		Text:
-		${resp.text || ""}
-		-----------------------------------------------------------
-		Function calls:
-		${functionCallsText.join(NEW_LINE)}
-		-----------------------------------------------------------
-		Raw response:
-		${JSON.stringify(resp, null, 2)}
-		-----------------------------------------------------------`;
-  }
   /**
    * Provides the api client.
    */
@@ -1613,10 +1632,10 @@ var GoogleLlm = class extends BaseLlm {
 // src/models/anthropic-llm.ts
 init_logger();
 import Anthropic from "@anthropic-ai/sdk";
-var logger3 = new Logger({ name: "AnthropicLlm" });
 var MAX_TOKENS = 1024;
 var AnthropicLlm = class extends BaseLlm {
   _client;
+  logger = new Logger({ name: "AnthropicLlm" });
   /**
    * Constructor for Anthropic LLM
    */
@@ -1633,9 +1652,6 @@ 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)
@@ -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",
@@ -1836,11 +1854,7 @@ var AnthropicLlm = class extends BaseLlm {
 };
 
 // src/models/openai-llm.ts
-init_logger();
-import dedent2 from "dedent";
 import OpenAI from "openai";
-var logger4 = new Logger({ name: "OpenAiLlm" });
-var NEW_LINE2 = "\n";
 var OpenAiLlm = class extends BaseLlm {
   _client;
   /**
@@ -1860,10 +1874,6 @@ 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)
@@ -1905,12 +1915,10 @@ 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 (llmResponse.content?.parts?.[0]?.text) {
           const part0 = llmResponse.content.parts[0];
           if (part0.thought) {
@@ -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: ${response.usage?.completion_tokens || 0} tokens`
+        );
         yield llmResponse;
       }
     }
@@ -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 });
@@ -2276,67 +2281,6 @@ var OpenAiLlm = class extends BaseLlm {
     const parts = response.content?.parts;
     return parts?.some((part) => part.inlineData) || false;
   }
-  /**
-   * Build request log string for debugging (similar to Google LLM)
-   */
-  buildRequestLog(req) {
-    const functionDecls = req.config?.tools?.[0]?.functionDeclarations || [];
-    const functionLogs = functionDecls.length > 0 ? functionDecls.map(
-      (funcDecl) => `${funcDecl.name}: ${JSON.stringify(funcDecl.parameters?.properties || {})}`
-    ) : [];
-    const contentsLogs = req.contents?.map(
-      (content) => JSON.stringify(content, (key, value) => {
-        if (key === "data" && typeof value === "string" && value.length > 100) {
-          return "[EXCLUDED]";
-        }
-        return value;
-      })
-    ) || [];
-    return dedent2`
-		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 (response.content?.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 = response.content?.parts?.filter((part) => part.text)?.map((part) => part.text)?.join("") || "";
-    return dedent2`
-		LLM Response:
-		-----------------------------------------------------------
-		Text:
-		${text}
-		-----------------------------------------------------------
-		Function calls:
-		${functionCallsText.join(NEW_LINE2)}
-		-----------------------------------------------------------
-		Usage:
-		${JSON.stringify(response.usageMetadata, null, 2)}
-		-----------------------------------------------------------
-		Finish Reason:
-		${response.finishReason}
-		-----------------------------------------------------------`;
-  }
   /**
    * Gets the OpenAI client
    */
@@ -2356,14 +2300,289 @@ var OpenAiLlm = class extends BaseLlm {
   }
 };
 
+// src/models/ai-sdk.ts
+init_logger();
+import {
+  generateText,
+  jsonSchema,
+  streamText
+} from "ai";
+var AiSdkLlm = class extends BaseLlm {
+  modelInstance;
+  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");
+    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: request.config?.maxOutputTokens,
+        temperature: request.config?.temperature,
+        topP: request.config?.topP
+      };
+      if (stream) {
+        const result = streamText(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 generateText(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 (llmRequest.config?.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: jsonSchema(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 (content.parts?.some((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 (content.parts?.some((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";
+    }
+  }
+};
+
 // src/models/llm-registry.ts
 init_logger();
-var logger5 = new Logger({ name: "LLMRegistry" });
 var LLMRegistry = class _LLMRegistry {
   /**
    * Map of model name regex to LLM class
    */
   static llmRegistry = /* @__PURE__ */ new Map();
+  static logger = new Logger({ name: "LLMRegistry" });
   /**
    * Creates a new LLM instance
    *
@@ -2415,7 +2634,7 @@ var LLMRegistry = 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())
     );
@@ -4665,15 +4884,13 @@ var McpClientService = 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 = 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 = 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 StdioClientTransport({
         command: this.config.transport.command,
         args: this.config.transport.args,
@@ -4733,9 +4946,7 @@ var McpClientService = 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 = 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;
@@ -4805,9 +5014,7 @@ var McpClientService = 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 = 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 = 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 = 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 = 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);
       });
     }
   }
@@ -4881,7 +5080,7 @@ var McpClientService = class {
       try {
         this.client.removeRequestHandler?.("sampling/createMessage");
       } catch (error) {
-        console.error("Failed to remove sampling handler:", error);
+        this.logger.error("Failed to remove sampling handler:", error);
       }
     }
   }
@@ -5177,7 +5376,13 @@ var McpToolAdapter = class extends BaseTool {
 
 // 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
   );
@@ -5670,89 +5876,47 @@ var BaseLlmFlow = class {
   responseProcessors = [];
   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 = class {
       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 = class {
       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 = class {
         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: processor.constructor?.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: tool.constructor?.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: tool.description?.substring(0, 50) + (tool.description?.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 = class {
       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 = class {
       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: !!functionResponseEvent.actions?.transferToAgent
-        });
         yield functionResponseEvent;
         const transferToAgent = functionResponseEvent.actions?.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 agentToRun.runLive?.(invocationContext) || 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
-          });
         }
       }
     }
-    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: processor.constructor?.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 = functionResponseEvent.actions?.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 = class {
     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 = llmRequest.config?.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 (tool.function?.name) return tool.function.name;
+      if (tool.function?.function?.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 = llmRequest.contents?.length > 0 ? this._formatContentPreview(llmRequest.contents[0]) : "none";
+    this.logger.debugStructured("\u{1F4E4} LLM Request", {
+      Model: llm.model,
+      Agent: invocationContext.agent.name,
+      "Content Items": llmRequest.contents?.length || 0,
+      "Content Preview": contentPreview,
+      "System Instruction": truncatedSystemInstruction || "none",
+      "Available Tools": toolNames || "none",
+      "Tool Count": llmRequest.config?.tools?.length || 0,
+      Streaming: isStreaming ? "Yes" : "No"
     });
     let responseCount = 0;
     for await (const llmResponse of llm.generateContentAsync(
@@ -6123,59 +6143,46 @@ var BaseLlmFlow = class {
       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 = llmResponse.usageMetadata?.totalTokenCount || "unknown";
+      const functionCallCount = llmResponse.content?.parts?.filter((part) => part.functionCall).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 = class {
         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 = class {
         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,91 +6232,55 @@ var BaseLlmFlow = class {
     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: llm?.model || "unknown",
-      llmType: llm?.constructor?.name || "unknown"
-    });
     return llm;
   }
 };
 
-// src/flows/llm-flows/single-flow.ts
-init_logger();
-
 // src/flows/llm-flows/base-llm-processor.ts
 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 requestProcessor3 = new IdentityLlmRequestProcessor();
+var requestProcessor2 = new BasicLlmRequestProcessor();
 
-// 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;
+// src/code-executors/base-code-executor.ts
+var BaseCodeExecutor = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      optimizeDataFile: config.optimizeDataFile ?? false,
+      stateful: config.stateful ?? false,
+      errorRetryAttempts: config.errorRetryAttempts ?? 2,
+      codeBlockDelimiters: config.codeBlockDelimiters ?? [
+        ["`tool_code\n", "\n`"],
+        ["`python\n", "\n`"]
+      ],
+      executionResultDelimiters: 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;
+  }
+};
+
+// src/code-executors/built-in-code-executor.ts
+var BuiltInCodeExecutor = class extends BaseCodeExecutor {
+  constructor(config = {}) {
+    super(config);
+  }
+  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 (!llmRequest.model?.startsWith("gemini-2")) {
+      throw new Error(
+        `Gemini code execution tool is not supported for model ${llmRequest.model}`
+      );
     }
-    result.push(string.slice(lastEnd));
-    return result.join("");
+    if (!llmRequest.config) {
+      llmRequest.config = {};
+    }
+    if (!llmRequest.config.tools) {
+      llmRequest.config.tools = [];
+    }
+    const codeExecutionTool = {
+      codeExecution: {}
+    };
+    llmRequest.config.tools.push(codeExecutionTool);
   }
-  async function replaceMatch(match) {
-    let varName = match[0].replace(/[{}]/g, "").trim();
-    let optional = false;
-    if (varName.endsWith("?")) {
-      optional = true;
-      varName = varName.slice(0, -1);
+};
+
+// src/code-executors/code-execution-utils.ts
+import { Language, Outcome } from "@google/genai";
+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 (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];
+    if (_CodeExecutionUtils.isBase64Encoded(decodedData)) {
+      return decodedData;
+    }
+    return btoa(decodedData);
+  }
+  static isBase64Encoded(str) {
+    try {
+      return btoa(atob(str)) === str;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Extracts the first code block from the content and truncates everything after it
+   */
+  static extractCodeAndTruncateContent(content, codeBlockDelimiters) {
+    if (!content?.parts?.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 sessionState = invocationContext.session.state;
-      if (varName in sessionState) {
-        return String(sessionState[varName]);
+    }
+    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: Language.PYTHON
       }
-      if (optional) {
-        return "";
+    };
+  }
+  /**
+   * Builds the code execution result part from the code execution result
+   */
+  static buildCodeExecutionResultPart(codeExecutionResult) {
+    if (codeExecutionResult.stderr) {
+      return {
+        codeExecutionResult: {
+          outcome: 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: Outcome.OUTCOME_OK,
+        output: finalResult.join("\n\n")
       }
-      throw new Error(`Context variable not found: \`${varName}\`.`);
+    };
+  }
+  /**
+   * Converts the code execution parts to text parts in a Content
+   */
+  static convertCodeExecutionParts(content, codeBlockDelimiter, executionResultDelimiters) {
+    if (!content.parts?.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";
     }
   }
-  return await asyncReplace(/{[^{}]*}/g, replaceMatch, template);
-}
-function isValidStateName(varName) {
-  const parts = varName.split(":");
-  if (parts.length === 1) {
-    return isValidIdentifier(varName);
+};
+
+// 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 {
+  context;
+  sessionState;
+  constructor(sessionState) {
+    this.sessionState = sessionState;
+    this.context = this.getCodeExecutorContext(sessionState);
   }
-  if (parts.length === 2) {
-    const validPrefixes = ["app:", "user:", "temp:"];
-    const prefix = `${parts[0]}:`;
-    if (validPrefixes.includes(prefix)) {
-      return isValidIdentifier(parts[1]);
+  /**
+   * 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];
   }
-  return false;
-}
-function isValidIdentifier(name) {
-  const identifierRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-  return identifierRegex.test(name);
-}
+  /**
+   * 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 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/instructions.ts
-var InstructionsLlmRequestProcessor = class extends BaseLlmRequestProcessor {
+// 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 < (llmRequest.contents?.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) || !agent.codeExecutor?.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++) {
@@ -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 {
 };
@@ -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,7 +8070,7 @@ 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");
   }
 };
 
@@ -7475,6 +8095,10 @@ var LlmAgent = class _LlmAgent extends BaseAgent {
    * Tools available to this agent
    */
   tools;
+  /**
+   * Code executor for this agent
+   */
+  codeExecutor;
   /**
    * Disallows LLM-controlled transferring to the parent agent
    */
@@ -7542,6 +8166,7 @@ var LlmAgent = class _LlmAgent extends BaseAgent {
     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 = 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) {
@@ -8331,8 +8959,6 @@ var RunConfig = class {
 };
 
 // src/artifacts/in-memory-artifact-service.ts
-init_logger();
-var logger9 = new Logger({ name: "InMemoryArtifactService" });
 var InMemoryArtifactService = class {
   artifacts = /* @__PURE__ */ new Map();
   fileHasUserNamespace(filename) {
@@ -8780,7 +9406,6 @@ var InMemorySessionService = class extends BaseSessionService {
 };
 
 // src/runners.ts
-var logger10 = new Logger({ name: "Runner" });
 function _findFunctionCallEventIfLastEventIsFunctionResponse(session) {
   const events = session.events;
   if (!events || events.length === 0) {
@@ -8825,6 +9450,7 @@ var Runner = class {
    * The memory service for the runner.
    */
   memoryService;
+  logger = new Logger({ name: "Runner" });
   /**
    * Initializes the Runner.
    */
@@ -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: SpanStatusCode.ERROR,
@@ -8991,7 +9617,7 @@ var Runner = class {
       }
       const agent = rootAgent.findSubAgent?.(event2.author);
       if (!agent) {
-        logger10.debug(
+        this.logger.debug(
           `Event from an unknown agent: ${event2.author}, event id: ${event2.id}`
         );
         continue;
@@ -9270,6 +9896,20 @@ var AgentBuilder = 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,15 +9948,6 @@ var AgentBuilder = 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
-        });
     }
   }
 };
@@ -10054,11 +10685,11 @@ var DatabaseSessionService = class extends BaseSessionService {
 };
 
 // src/sessions/database-factories.ts
-import dedent3 from "dedent";
+import dedent from "dedent";
 import { Kysely, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
 function createDependencyError(packageName, dbType) {
   return new Error(
-    dedent3`
+    dedent`
 		Missing required peer dependency: ${packageName}
 		To use ${dbType} sessions, install the required package:
 			npm install ${packageName}
@@ -10131,11 +10762,9 @@ function createDatabaseSessionService(databaseUrl, options) {
 }
 
 // src/artifacts/gcs-artifact-service.ts
-init_logger();
 import {
   Storage
 } from "@google-cloud/storage";
-var logger11 = new Logger({ name: "GcsArtifactService" });
 var GcsArtifactService = class {
   bucketName;
   storageClient;
@@ -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
 });
@@ -10315,6 +10944,7 @@ export {
   LlmAgent as Agent,
   AgentBuilder,
   agents_exports as Agents,
+  AiSdkLlm,
   AnthropicLlm,
   ApiKeyCredential,
   ApiKeyScheme,
@@ -10327,6 +10957,7 @@ export {
   AuthTool,
   AutoFlow,
   BaseAgent,
+  BaseCodeExecutor,
   BaseLLMConnection,
   BaseLlm,
   BaseLlmFlow,
@@ -10337,8 +10968,11 @@ export {
   BaseTool,
   BasicAuthCredential,
   BearerTokenCredential,
+  BuiltInCodeExecutor,
   BuiltInPlanner,
   CallbackContext,
+  CodeExecutionUtils,
+  CodeExecutorContext,
   DatabaseSessionService,
   EnhancedAuthConfig,
   Event,
@@ -10410,11 +11044,11 @@ export {
   VertexAiSessionService,
   adkToMcpToolType,
   requestProcessor8 as agentTransferRequestProcessor,
-  requestProcessor as basicRequestProcessor,
+  requestProcessor2 as basicRequestProcessor,
   buildFunctionDeclaration,
-  requestProcessor7 as codeExecutionRequestProcessor,
-  responseProcessor2 as codeExecutionResponseProcessor,
-  requestProcessor5 as contentRequestProcessor,
+  requestProcessor3 as codeExecutionRequestProcessor,
+  responseProcessor as codeExecutionResponseProcessor,
+  requestProcessor4 as contentRequestProcessor,
   createAuthToolArguments,
   createDatabaseSessionService,
   createFunctionTool,
@@ -10428,22 +11062,22 @@ export {
   getMcpTools,
   handleFunctionCallsAsync,
   handleFunctionCallsLive,
-  requestProcessor3 as identityRequestProcessor,
+  requestProcessor5 as identityRequestProcessor,
   initializeTelemetry,
   injectSessionState,
-  requestProcessor4 as instructionsRequestProcessor,
+  requestProcessor6 as instructionsRequestProcessor,
   isEnhancedAuthConfig,
   jsonSchemaToDeclaration,
   mcpSchemaToParameters,
   mergeParallelFunctionResponseEvents,
   newInvocationContextId,
-  requestProcessor6 as nlPlanningRequestProcessor,
-  responseProcessor as nlPlanningResponseProcessor,
+  requestProcessor7 as nlPlanningRequestProcessor,
+  responseProcessor2 as nlPlanningResponseProcessor,
   normalizeJsonSchema,
   populateClientFunctionCallId,
   registerProviders,
   removeClientFunctionCallId,
-  requestProcessor2 as requestProcessor,
+  requestProcessor,
   shutdownTelemetry,
   telemetryService,
   traceLlmCall,