@iqai/adk 0.1.13 → 0.1.15

package/dist/index.mjs

@@ -323,15 +323,17 @@ var init_base_tool = __esm({
         if (!llmRequest.config || !llmRequest.config.tools) {
           return null;
         }
-        return llmRequest.config.tools.find(
-          (tool) => tool.functionDeclarations && tool.functionDeclarations.length > 0
+        const toolWithFunctionDeclaration = llmRequest.config.tools.find(
+          (tool) => "functionDeclarations" in tool && tool.functionDeclarations && tool.functionDeclarations.length > 0
         ) || null;
+        return toolWithFunctionDeclaration;
       }
     };
   }
 });
 
 // src/tools/function/function-utils.ts
+import { Type as Type2 } from "@google/genai";
 function buildFunctionDeclaration(func, options = {}) {
   const funcStr = func.toString();
   const name = options.name || func.name;
@@ -352,10 +354,10 @@ function buildFunctionDeclaration(func, options = {}) {
 function extractParametersSchema(func, ignoreParams = []) {
   const funcStr = func.toString();
   const paramMatch = funcStr.match(/\(([^)]*)\)/);
-  if (!paramMatch) return { type: "object", properties: {} };
+  if (!paramMatch) return { type: Type2.OBJECT, properties: {} };
   const paramList = paramMatch[1].split(",").map((param) => param.trim()).filter((param) => param !== "");
   if (paramList.length === 0 || paramList.length === 1 && paramList[0] === "") {
-    return { type: "object", properties: {} };
+    return { type: Type2.OBJECT, properties: {} };
   }
   const jsDocParams = extractJSDocParams(funcStr);
   const jsDocTypes = extractJSDocTypes(funcStr);
@@ -395,7 +397,7 @@ function extractParametersSchema(func, ignoreParams = []) {
     }
   }
   const schema = {
-    type: "object",
+    type: Type2.OBJECT,
     properties
   };
   if (required.length > 0) {
@@ -1397,7 +1399,7 @@ var GoogleLlm = class extends BaseLlm {
     this.preprocessRequest(llmRequest);
     const model = llmRequest.model || this.model;
     const contents = this.convertContents(llmRequest.contents || []);
-    const config = this.convertConfig(llmRequest.config);
+    const config = llmRequest.config;
     if (stream) {
       const responses = await this.apiClient.models.generateContentStream({
         model,
@@ -1491,19 +1493,6 @@ var GoogleLlm = class extends BaseLlm {
       parts: content.parts || [{ text: content.content || "" }]
     }));
   }
-  /**
-   * Convert LlmRequest config to GoogleGenAI format
-   */
-  convertConfig(config) {
-    if (!config) return {};
-    return {
-      temperature: config.temperature,
-      topP: config.top_p,
-      maxOutputTokens: config.max_tokens,
-      tools: config.tools,
-      systemInstruction: config.system_instruction
-    };
-  }
   /**
    * Preprocesses the request based on the API backend.
    */
@@ -3295,7 +3284,7 @@ var CallbackContext = class extends ReadonlyContext {
   constructor(invocationContext, options = {}) {
     super(invocationContext);
     this._eventActions = options.eventActions || new EventActions();
-    this._state = new State(
+    this._state = State.create(
       invocationContext.session.state,
       this._eventActions.stateDelta
     );
@@ -3821,6 +3810,7 @@ ${argsStr}
 // src/tools/index.ts
 var tools_exports = {};
 __export(tools_exports, {
+  AgentTool: () => AgentTool,
   BaseTool: () => BaseTool,
   ExitLoopTool: () => ExitLoopTool,
   FileOperationsTool: () => FileOperationsTool,
@@ -3925,6 +3915,283 @@ function createTool(config) {
   return new CreatedTool(config);
 }
 
+// src/tools/common/agent-tool.ts
+init_logger();
+import { Type } from "@google/genai";
+import { v4 as uuidv42 } from "uuid";
+
+// src/agents/invocation-context.ts
+var LlmCallsLimitExceededError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LlmCallsLimitExceededError";
+  }
+};
+var InvocationCostManager = class {
+  /**
+   * A counter that keeps track of number of llm calls made.
+   */
+  _numberOfLlmCalls = 0;
+  /**
+   * Increments _numberOfLlmCalls and enforces the limit.
+   */
+  incrementAndEnforceLlmCallsLimit(runConfig) {
+    this._numberOfLlmCalls += 1;
+    if (runConfig && runConfig.maxLlmCalls > 0 && this._numberOfLlmCalls > runConfig.maxLlmCalls) {
+      throw new LlmCallsLimitExceededError(
+        `Max number of llm calls limit of \`${runConfig.maxLlmCalls}\` exceeded`
+      );
+    }
+  }
+};
+function newInvocationContextId() {
+  return `e-${crypto.randomUUID()}`;
+}
+var InvocationContext = class _InvocationContext {
+  artifactService;
+  sessionService;
+  memoryService;
+  /**
+   * The id of this invocation context. Readonly.
+   */
+  invocationId;
+  /**
+   * The branch of the invocation context.
+   *
+   * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
+   * agent_2, and agent_2 is the parent of agent_3.
+   *
+   * Branch is used when multiple sub-agents shouldn't see their peer agents'
+   * conversation history.
+   */
+  branch;
+  /**
+   * The current agent of this invocation context. Readonly.
+   */
+  agent;
+  /**
+   * The user content that started this invocation. Readonly.
+   */
+  userContent;
+  /**
+   * The current session of this invocation context. Readonly.
+   */
+  session;
+  /**
+   * Whether to end this invocation.
+   *
+   * Set to True in callbacks or tools to terminate this invocation.
+   */
+  endInvocation = false;
+  /**
+   * The queue to receive live requests.
+   */
+  liveRequestQueue;
+  /**
+   * The running streaming tools of this invocation.
+   */
+  activeStreamingTools;
+  /**
+   * Caches necessary, data audio or contents, that are needed by transcription.
+   */
+  transcriptionCache;
+  /**
+   * Configurations for live agents under this invocation.
+   */
+  runConfig;
+  /**
+   * A container to keep track of different kinds of costs incurred as a part
+   * of this invocation.
+   */
+  _invocationCostManager = new InvocationCostManager();
+  /**
+   * Constructor for InvocationContext
+   */
+  constructor(options) {
+    this.artifactService = options.artifactService;
+    this.sessionService = options.sessionService;
+    this.memoryService = options.memoryService;
+    this.invocationId = options.invocationId || newInvocationContextId();
+    this.branch = options.branch;
+    this.agent = options.agent;
+    this.userContent = options.userContent;
+    this.session = options.session;
+    this.endInvocation = options.endInvocation || false;
+    this.liveRequestQueue = options.liveRequestQueue;
+    this.activeStreamingTools = options.activeStreamingTools;
+    this.transcriptionCache = options.transcriptionCache;
+    this.runConfig = options.runConfig;
+  }
+  /**
+   * App name from the session
+   */
+  get appName() {
+    return this.session.appName;
+  }
+  /**
+   * User ID from the session
+   */
+  get userId() {
+    return this.session.userId;
+  }
+  /**
+   * Tracks number of llm calls made.
+   *
+   * @throws {LlmCallsLimitExceededError} If number of llm calls made exceed the set threshold.
+   */
+  incrementLlmCallCount() {
+    this._invocationCostManager.incrementAndEnforceLlmCallsLimit(
+      this.runConfig
+    );
+  }
+  /**
+   * Creates a child invocation context for a sub-agent
+   */
+  createChildContext(agent) {
+    return new _InvocationContext({
+      artifactService: this.artifactService,
+      sessionService: this.sessionService,
+      memoryService: this.memoryService,
+      invocationId: this.invocationId,
+      // Keep same invocation ID
+      branch: this.branch ? `${this.branch}.${agent.name}` : agent.name,
+      // Update branch
+      agent,
+      // Update to the new agent
+      userContent: this.userContent,
+      session: this.session,
+      endInvocation: this.endInvocation,
+      liveRequestQueue: this.liveRequestQueue,
+      activeStreamingTools: this.activeStreamingTools,
+      transcriptionCache: this.transcriptionCache,
+      runConfig: this.runConfig
+    });
+  }
+};
+
+// src/tools/common/agent-tool.ts
+init_base_tool();
+function isLlmAgent(agent) {
+  return true;
+}
+var AgentTool = class extends BaseTool {
+  /**
+   * The agent used by this tool
+   */
+  agent;
+  /**
+   * The function declaration schema
+   */
+  functionDeclaration;
+  /**
+   * The key to store the tool output in the state
+   */
+  outputKey;
+  /**
+   * Whether to skip summarization of the agent's response
+   */
+  skipSummarization;
+  logger = new Logger({ name: "AgentTool" });
+  /**
+   * Create a new agent tool
+   */
+  constructor(config) {
+    super({
+      name: config.name,
+      description: config.description || config.agent.description,
+      isLongRunning: config.isLongRunning || false,
+      shouldRetryOnFailure: config.shouldRetryOnFailure || false,
+      maxRetryAttempts: config.maxRetryAttempts || 3
+    });
+    this.agent = config.agent;
+    this.functionDeclaration = config.functionDeclaration;
+    this.outputKey = config.outputKey;
+    this.skipSummarization = config.skipSummarization || false;
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    if (this.functionDeclaration) {
+      return this.functionDeclaration;
+    }
+    const description = isLlmAgent(this.agent) ? typeof this.agent.instruction === "string" ? this.agent.instruction : this.description : this.description;
+    return {
+      name: this.name,
+      description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          input: {
+            type: Type.STRING,
+            description: "The input to provide to the agent"
+          }
+        },
+        required: ["input"]
+      }
+    };
+  }
+  /**
+   * Execute the tool by running the agent with the provided input
+   */
+  async runAsync(params, context) {
+    try {
+      const input = params.input || Object.values(params)[0];
+      if (!isLlmAgent(this.agent)) {
+        throw new Error(
+          `Agent ${this.name} does not support running as a tool`
+        );
+      }
+      const parentInvocation = context._invocationContext;
+      const childInvocationContext = new InvocationContext({
+        invocationId: uuidv42(),
+        agent: this.agent,
+        session: parentInvocation.session,
+        artifactService: parentInvocation.artifactService,
+        sessionService: parentInvocation.sessionService,
+        memoryService: parentInvocation.memoryService,
+        runConfig: parentInvocation.runConfig,
+        userContent: {
+          role: "user",
+          parts: [{ text: String(input) }]
+        },
+        branch: parentInvocation.branch ? `${parentInvocation.branch}.${this.agent.name}` : this.agent.name
+      });
+      let lastEvent = null;
+      for await (const event of this.agent.runAsync(childInvocationContext)) {
+        if (!event.partial) {
+          await childInvocationContext.sessionService.appendEvent(
+            childInvocationContext.session,
+            event
+          );
+        }
+        if (event.content && event.author === this.agent.name) {
+          lastEvent = event;
+        }
+      }
+      if (!lastEvent || !lastEvent.content || !lastEvent.content.parts) {
+        return "";
+      }
+      const mergedText = lastEvent.content.parts.filter((part) => part.text !== void 0 && part.text !== null).map((part) => part.text).join("\n");
+      let toolResult;
+      try {
+        toolResult = JSON.parse(mergedText);
+      } catch {
+        toolResult = mergedText;
+      }
+      if (this.outputKey && context?.state) {
+        context.state[this.outputKey] = toolResult;
+      }
+      return toolResult;
+    } catch (error) {
+      this.logger.error(`Error executing agent tool ${this.name}:`, error);
+      throw new Error(
+        `Agent tool execution failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+
 // src/tools/tool-context.ts
 var ToolContext = class extends CallbackContext {
   /**
@@ -3992,6 +4259,7 @@ init_function_utils();
 // src/tools/common/google-search.ts
 init_logger();
 init_base_tool();
+import { Type as Type3 } from "@google/genai";
 var GoogleSearch = class extends BaseTool {
   logger = new Logger({ name: "GoogleSearch" });
   /**
@@ -4011,14 +4279,14 @@ var GoogleSearch = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: "object",
+        type: Type3.OBJECT,
         properties: {
           query: {
-            type: "string",
+            type: Type3.STRING,
             description: "The search query to execute"
           },
           num_results: {
-            type: "integer",
+            type: Type3.INTEGER,
             description: "Number of results to return (max 10)",
             default: 5
           }
@@ -4054,6 +4322,7 @@ var GoogleSearch = class extends BaseTool {
 
 // src/tools/common/http-request-tool.ts
 init_base_tool();
+import { Type as Type4 } from "@google/genai";
 var HttpRequestTool = class extends BaseTool {
   constructor() {
     super({
@@ -4069,38 +4338,32 @@ var HttpRequestTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: "object",
+        type: Type4.OBJECT,
         properties: {
           url: {
-            type: "string",
+            type: Type4.STRING,
             description: "The URL to send the request to"
           },
           method: {
-            type: "string",
+            type: Type4.STRING,
             description: "The HTTP method to use (GET, POST, PUT, DELETE, etc.)",
             enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
             default: "GET"
           },
           headers: {
-            type: "object",
-            description: "Request headers to include",
-            additionalProperties: {
-              type: "string"
-            }
+            type: Type4.OBJECT,
+            description: "Request headers to include"
           },
           body: {
-            type: "string",
+            type: Type4.STRING,
             description: "Request body content (as string, typically JSON)"
           },
           params: {
-            type: "object",
-            description: "URL query parameters to include",
-            additionalProperties: {
-              type: "string"
-            }
+            type: Type4.OBJECT,
+            description: "URL query parameters to include"
           },
           timeout: {
-            type: "integer",
+            type: Type4.INTEGER,
             description: "Request timeout in milliseconds",
             default: 1e4
           }
@@ -4175,6 +4438,7 @@ var HttpRequestTool = class extends BaseTool {
 init_base_tool();
 import fs from "fs/promises";
 import path from "path";
+import { Type as Type5 } from "@google/genai";
 var FileOperationsTool = class extends BaseTool {
   basePath;
   constructor(options) {
@@ -4192,10 +4456,10 @@ var FileOperationsTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: "object",
+        type: Type5.OBJECT,
         properties: {
           operation: {
-            type: "string",
+            type: Type5.STRING,
             description: "The file operation to perform",
             enum: [
               "read",
@@ -4208,15 +4472,15 @@ var FileOperationsTool = class extends BaseTool {
             ]
           },
           filepath: {
-            type: "string",
+            type: Type5.STRING,
             description: "Path to the file or directory (relative to the base path)"
           },
           content: {
-            type: "string",
+            type: Type5.STRING,
             description: "Content to write to the file (for write and append operations)"
           },
           encoding: {
-            type: "string",
+            type: Type5.STRING,
             description: "File encoding to use",
             default: "utf8"
           }
@@ -4422,6 +4686,7 @@ var FileOperationsTool = class extends BaseTool {
 
 // src/tools/common/user-interaction-tool.ts
 init_base_tool();
+import { Type as Type6 } from "@google/genai";
 var UserInteractionTool = class extends BaseTool {
   constructor() {
     super({
@@ -4438,21 +4703,21 @@ var UserInteractionTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: "object",
+        type: Type6.OBJECT,
         properties: {
           prompt: {
-            type: "string",
+            type: Type6.STRING,
             description: "The prompt message to display to the user"
           },
           options: {
-            type: "array",
+            type: Type6.ARRAY,
             description: "Optional array of choices to present to the user",
             items: {
-              type: "string"
+              type: Type6.STRING
             }
           },
           defaultValue: {
-            type: "string",
+            type: Type6.STRING,
             description: "Optional default value for the input field"
           }
         },
@@ -4522,6 +4787,7 @@ var ExitLoopTool = class extends BaseTool {
 // src/tools/common/get-user-choice-tool.ts
 init_logger();
 init_base_tool();
+import { Type as Type7 } from "@google/genai";
 var GetUserChoiceTool = class extends BaseTool {
   logger = new Logger({ name: "GetUserChoiceTool" });
   /**
@@ -4542,17 +4808,17 @@ var GetUserChoiceTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: "object",
+        type: Type7.OBJECT,
         properties: {
           options: {
-            type: "array",
+            type: Type7.ARRAY,
             description: "List of options for the user to choose from",
             items: {
-              type: "string"
+              type: Type7.STRING
             }
           },
           question: {
-            type: "string",
+            type: Type7.STRING,
             description: "The question or prompt to show the user before presenting options"
           }
         },
@@ -4580,6 +4846,7 @@ var GetUserChoiceTool = class extends BaseTool {
 // src/tools/common/transfer-to-agent-tool.ts
 init_logger();
 init_base_tool();
+import { Type as Type8 } from "@google/genai";
 var TransferToAgentTool = class extends BaseTool {
   logger = new Logger({ name: "TransferToAgentTool" });
   /**
@@ -4588,9 +4855,28 @@ var TransferToAgentTool = class extends BaseTool {
   constructor() {
     super({
       name: "transfer_to_agent",
-      description: "Transfer the question to another agent."
+      description: "Transfer the question to another agent when it's more suitable to answer the user's question according to the agent's description. Use this function when you determine that another agent in the system would be better equipped to handle the user's request based on their specialized capabilities and expertise areas."
     });
   }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type8.OBJECT,
+        properties: {
+          agent_name: {
+            type: Type8.STRING,
+            description: "The name of the agent to transfer control to"
+          }
+        },
+        required: ["agent_name"]
+      }
+    };
+  }
   /**
    * Execute the transfer to agent action
    */
@@ -4603,6 +4889,7 @@ var TransferToAgentTool = class extends BaseTool {
 // src/tools/common/load-memory-tool.ts
 init_logger();
 init_base_tool();
+import { Type as Type9 } from "@google/genai";
 var LoadMemoryTool = class extends BaseTool {
   logger = new Logger({ name: "LoadMemoryTool" });
   /**
@@ -4622,10 +4909,10 @@ var LoadMemoryTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: "object",
+        type: Type9.OBJECT,
         properties: {
           query: {
-            type: "string",
+            type: Type9.STRING,
             description: "The query to load memories for"
           }
         },
@@ -4656,6 +4943,7 @@ var LoadMemoryTool = class extends BaseTool {
 
 // src/tools/common/load-artifacts-tool.ts
 init_base_tool();
+import { Type as Type10 } from "@google/genai";
 var LoadArtifactsTool = class extends BaseTool {
   constructor() {
     super({
@@ -4671,12 +4959,12 @@ var LoadArtifactsTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: "object",
+        type: Type10.OBJECT,
         properties: {
           artifact_names: {
-            type: "array",
+            type: Type10.ARRAY,
             items: {
-              type: "string"
+              type: Type10.STRING
             },
             description: "List of artifact names to load"
           }
@@ -5295,6 +5583,7 @@ init_logger();
 init_base_tool();
 
 // src/tools/mcp/schema-conversion.ts
+import { Type as Type11 } from "@google/genai";
 function adkToMcpToolType(tool) {
   const declaration = tool.getDeclaration();
   const params = declarationToJsonSchema(declaration);
@@ -5323,13 +5612,13 @@ function jsonSchemaToDeclaration(name, description, schema) {
       parameters = schema;
     } else {
       parameters = {
-        type: "object",
+        type: Type11.OBJECT,
         properties: schema
       };
     }
   } else {
     parameters = {
-      type: "object",
+      type: Type11.OBJECT,
       properties: {}
     };
   }
@@ -5341,7 +5630,7 @@ function jsonSchemaToDeclaration(name, description, schema) {
 }
 function normalizeJsonSchema(schema) {
   if (!schema) {
-    return { type: "object", properties: {} };
+    return { type: Type11.OBJECT, properties: {} };
   }
   const normalizedSchema = { ...schema };
   if (!normalizedSchema.type) {
@@ -5358,39 +5647,39 @@ function normalizeJsonSchema(schema) {
     case "integer":
       return normalizeNumberSchema(normalizedSchema);
     case "boolean":
-      return { type: "boolean" };
+      return { type: Type11.BOOLEAN };
     case "null":
-      return { type: "null" };
+      return { type: Type11.NULL };
     default:
       return normalizedSchema;
   }
 }
 function determineSchemaType(schema) {
   if (schema.properties || schema.required || schema.additionalProperties !== void 0) {
-    return "object";
+    return Type11.OBJECT;
   }
   if (schema.items) {
-    return "array";
+    return Type11.ARRAY;
   }
   if (schema.enum !== void 0) {
-    if (schema.enum.length === 0) return "string";
+    if (schema.enum.length === 0) return Type11.STRING;
     const firstItem = schema.enum[0];
-    if (typeof firstItem === "string") return "string";
-    if (typeof firstItem === "number") return "number";
-    if (typeof firstItem === "boolean") return "boolean";
-    return "string";
+    if (typeof firstItem === "string") return Type11.STRING;
+    if (typeof firstItem === "number") return Type11.NUMBER;
+    if (typeof firstItem === "boolean") return Type11.BOOLEAN;
+    return Type11.STRING;
   }
   if (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern) {
-    return "string";
+    return Type11.STRING;
   }
   if (schema.minimum !== void 0 || schema.maximum !== void 0 || schema.exclusiveMinimum !== void 0 || schema.exclusiveMaximum !== void 0) {
-    return schema.multipleOf === void 0 || schema.multipleOf % 1 === 0 ? "integer" : "number";
+    return schema.multipleOf === void 0 || schema.multipleOf % 1 === 0 ? Type11.INTEGER : Type11.NUMBER;
   }
-  return "object";
+  return Type11.OBJECT;
 }
 function normalizeObjectSchema(schema) {
   const normalizedSchema = {
-    type: "object",
+    type: Type11.OBJECT,
     properties: {}
   };
   if (schema.properties) {
@@ -5402,15 +5691,13 @@ function normalizeObjectSchema(schema) {
     }
   }
   if (schema.required) normalizedSchema.required = schema.required;
-  if (schema.additionalProperties !== void 0)
-    normalizedSchema.additionalProperties = schema.additionalProperties;
   if (schema.title) normalizedSchema.title = schema.title;
   if (schema.description) normalizedSchema.description = schema.description;
   return normalizedSchema;
 }
 function normalizeArraySchema(schema) {
   const normalizedSchema = {
-    type: "array"
+    type: Type11.ARRAY
   };
   if (schema.items) {
     normalizedSchema.items = normalizeJsonSchema(
@@ -5421,15 +5708,13 @@ function normalizeArraySchema(schema) {
     normalizedSchema.minItems = schema.minItems;
   if (schema.maxItems !== void 0)
     normalizedSchema.maxItems = schema.maxItems;
-  if (schema.uniqueItems !== void 0)
-    normalizedSchema.uniqueItems = schema.uniqueItems;
   if (schema.title) normalizedSchema.title = schema.title;
   if (schema.description) normalizedSchema.description = schema.description;
   return normalizedSchema;
 }
 function normalizeStringSchema(schema) {
   const normalizedSchema = {
-    type: "string"
+    type: Type11.STRING
   };
   if (schema.minLength !== void 0)
     normalizedSchema.minLength = schema.minLength;
@@ -5448,12 +5733,6 @@ function normalizeNumberSchema(schema) {
   };
   if (schema.minimum !== void 0) normalizedSchema.minimum = schema.minimum;
   if (schema.maximum !== void 0) normalizedSchema.maximum = schema.maximum;
-  if (schema.exclusiveMinimum !== void 0)
-    normalizedSchema.exclusiveMinimum = schema.exclusiveMinimum;
-  if (schema.exclusiveMaximum !== void 0)
-    normalizedSchema.exclusiveMaximum = schema.exclusiveMaximum;
-  if (schema.multipleOf !== void 0)
-    normalizedSchema.multipleOf = schema.multipleOf;
   if (schema.enum) normalizedSchema.enum = schema.enum;
   if (schema.title) normalizedSchema.title = schema.title;
   if (schema.description) normalizedSchema.description = schema.description;
@@ -5468,7 +5747,7 @@ function mcpSchemaToParameters(mcpTool) {
   }
   if (!schema) {
     return {
-      type: "object",
+      type: Type11.OBJECT,
       properties: {}
     };
   }
@@ -5961,7 +6240,7 @@ function generateAuthEvent(invocationContext, functionResponseEvent) {
 }
 async function handleFunctionCallsAsync(invocationContext, functionCallEvent, toolsDict, filters) {
   const agent = invocationContext.agent;
-  if (!isLlmAgent(agent)) {
+  if (!isLlmAgent2(agent)) {
     return null;
   }
   const functionCalls = functionCallEvent.getFunctionCalls();
@@ -6085,7 +6364,7 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
   mergedEvent.timestamp = baseEvent.timestamp;
   return mergedEvent;
 }
-function isLlmAgent(agent) {
+function isLlmAgent2(agent) {
   return agent && typeof agent === "object" && "canonicalModel" in agent;
 }
 
@@ -8133,6 +8412,42 @@ function removeThoughtFromRequest(llmRequest) {
 var requestProcessor7 = new NlPlanningRequestProcessor();
 var responseProcessor2 = new NlPlanningResponseProcessor();
 
+// src/flows/llm-flows/shared-memory.ts
+var SharedMemoryRequestProcessor = class extends BaseLlmRequestProcessor {
+  async *runAsync(invocationContext, llmRequest) {
+    const memoryService = invocationContext.memoryService;
+    if (!memoryService) return;
+    const lastUserEvent = invocationContext.session.events.findLast((e) => e.author === "user" && e.content?.parts?.length);
+    if (!lastUserEvent) return;
+    const query = (lastUserEvent.content.parts ?? []).map((p) => p.text || "").join(" ");
+    const results = await memoryService.searchMemory({
+      appName: invocationContext.appName,
+      userId: invocationContext.userId,
+      query
+    });
+    const sessionTexts = new Set(
+      (llmRequest.contents || []).flatMap(
+        (c) => c.parts?.map((p) => p.text) || []
+      )
+    );
+    for (const memory of results.memories) {
+      const memoryText = (memory.content.parts ?? []).map((p) => p.text || "").join(" ");
+      if (!sessionTexts.has(memoryText)) {
+        llmRequest.contents = llmRequest.contents || [];
+        llmRequest.contents.push({
+          role: "user",
+          parts: [
+            {
+              text: `[${memory.author}] said: ${memoryText}`
+            }
+          ]
+        });
+      }
+    }
+  }
+};
+var sharedMemoryRequestProcessor = new SharedMemoryRequestProcessor();
+
 // src/flows/llm-flows/single-flow.ts
 var SingleFlow = class extends BaseLlmFlow {
   /**
@@ -8147,6 +8462,7 @@ var SingleFlow = class extends BaseLlmFlow {
       requestProcessor6,
       requestProcessor5,
       requestProcessor4,
+      sharedMemoryRequestProcessor,
       // 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.
@@ -8168,12 +8484,12 @@ var SingleFlow = class extends BaseLlmFlow {
 };
 
 // src/flows/llm-flows/agent-transfer.ts
+import dedent from "dedent";
 var AgentTransferLlmRequestProcessor = class extends BaseLlmRequestProcessor {
   /**
    * Processes agent transfer by adding transfer instructions and tools
    * if the agent has transfer targets available
    */
-  // eslint-disable-next-line @typescript-eslint/require-yield
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;
     if (!("subAgents" in agent) || typeof agent.subAgents !== "object") {
@@ -8187,71 +8503,65 @@ var AgentTransferLlmRequestProcessor = class extends BaseLlmRequestProcessor {
       agent,
       transferTargets
     );
-    if (llmRequest.appendInstructions) {
-      llmRequest.appendInstructions([transferInstructions]);
-    } else {
-      const existingInstructions = llmRequest.instructions || "";
-      llmRequest.instructions = `${existingInstructions}
-
-${transferInstructions}`;
-    }
+    llmRequest.appendInstructions([transferInstructions]);
     const transferToAgentTool = new TransferToAgentTool();
     const toolContext = new ToolContext(invocationContext);
     await transferToAgentTool.processLlmRequest(toolContext, llmRequest);
-    for await (const _ of []) {
-      yield _;
+    const shouldYield = false;
+    if (shouldYield) {
+      yield {};
     }
   }
 };
 function buildTargetAgentsInfo(targetAgent) {
-  return `
-Agent name: ${targetAgent.name}
-Agent description: ${targetAgent.description}
-`;
+  return dedent`
+		Agent name: ${targetAgent.name}
+		Agent description: ${targetAgent.description}
+	`;
 }
 function buildTargetAgentsInstructions(agent, targetAgents) {
   const lineBreak = "\n";
   const transferFunctionName = "transfer_to_agent";
-  let instructions = `
-You have a list of other agents to transfer to:
+  let instructions = dedent`
+		You have a list of other agents to transfer to:
 
-${targetAgents.map((targetAgent) => buildTargetAgentsInfo(targetAgent)).join(lineBreak)}
+		${targetAgents.map((targetAgent) => buildTargetAgentsInfo(targetAgent)).join(lineBreak)}
 
-If you are the best to answer the question according to your description, you
-can answer it.
+		If you are the best to answer the question according to your description, you
+		can answer it.
 
-If another agent is better for answering the question according to its
-description, call \`${transferFunctionName}\` function to transfer the
-question to that agent. When transferring, do not generate any text other than
-the function call.
+		If another agent is better for answering the question according to its
+		description, call \`${transferFunctionName}\` function to transfer the
+		question to that agent. When transferring, do not generate any text other than
+		the function call.
 `;
   if (agent.parentAgent && !agent.disallowTransferToParent) {
-    instructions += `
-Your parent agent is ${agent.parentAgent.name}. If neither the other agents nor
-you are best for answering the question according to the descriptions, transfer
-to your parent agent.
-`;
+    instructions += dedent`
+			Your parent agent is ${agent.parentAgent.name}. If neither the other agents nor
+			you are best for answering the question according to the descriptions, transfer
+			to your parent agent.
+		`;
   }
   return instructions;
 }
 function getTransferTargets(agent) {
-  const result = [];
+  const targets = [];
   if (agent.subAgents && Array.isArray(agent.subAgents)) {
-    result.push(...agent.subAgents);
+    targets.push(...agent.subAgents);
   }
   if (!agent.parentAgent || !("subAgents" in agent.parentAgent)) {
-    return result;
+    return targets;
   }
   if (!agent.disallowTransferToParent) {
-    result.push(agent.parentAgent);
+    targets.push(agent.parentAgent);
   }
   if (!agent.disallowTransferToPeers && agent.parentAgent.subAgents) {
     const peerAgents = agent.parentAgent.subAgents.filter(
       (peerAgent) => peerAgent.name !== agent.name
     );
-    result.push(...peerAgents);
+    targets.push(...peerAgents);
   }
-  return result;
+  return targets;
 }
 var requestProcessor8 = new AgentTransferLlmRequestProcessor();
 
@@ -8353,7 +8663,10 @@ var LlmAgent = class _LlmAgent extends BaseAgent {
   constructor(config) {
     super({
       name: config.name,
-      description: config.description
+      description: config.description,
+      subAgents: config.subAgents,
+      beforeAgentCallback: config.beforeAgentCallback,
+      afterAgentCallback: config.afterAgentCallback
     });
     this.model = config.model || "";
     this.instruction = config.instruction || "";
@@ -8549,155 +8862,6 @@ do not generate any text other than the function call.`;
   }
 };
 
-// src/agents/invocation-context.ts
-var LlmCallsLimitExceededError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LlmCallsLimitExceededError";
-  }
-};
-var InvocationCostManager = class {
-  /**
-   * A counter that keeps track of number of llm calls made.
-   */
-  _numberOfLlmCalls = 0;
-  /**
-   * Increments _numberOfLlmCalls and enforces the limit.
-   */
-  incrementAndEnforceLlmCallsLimit(runConfig) {
-    this._numberOfLlmCalls += 1;
-    if (runConfig && runConfig.maxLlmCalls > 0 && this._numberOfLlmCalls > runConfig.maxLlmCalls) {
-      throw new LlmCallsLimitExceededError(
-        `Max number of llm calls limit of \`${runConfig.maxLlmCalls}\` exceeded`
-      );
-    }
-  }
-};
-function newInvocationContextId() {
-  return `e-${crypto.randomUUID()}`;
-}
-var InvocationContext = class _InvocationContext {
-  artifactService;
-  sessionService;
-  memoryService;
-  /**
-   * The id of this invocation context. Readonly.
-   */
-  invocationId;
-  /**
-   * The branch of the invocation context.
-   *
-   * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
-   * agent_2, and agent_2 is the parent of agent_3.
-   *
-   * Branch is used when multiple sub-agents shouldn't see their peer agents'
-   * conversation history.
-   */
-  branch;
-  /**
-   * The current agent of this invocation context. Readonly.
-   */
-  agent;
-  /**
-   * The user content that started this invocation. Readonly.
-   */
-  userContent;
-  /**
-   * The current session of this invocation context. Readonly.
-   */
-  session;
-  /**
-   * Whether to end this invocation.
-   *
-   * Set to True in callbacks or tools to terminate this invocation.
-   */
-  endInvocation = false;
-  /**
-   * The queue to receive live requests.
-   */
-  liveRequestQueue;
-  /**
-   * The running streaming tools of this invocation.
-   */
-  activeStreamingTools;
-  /**
-   * Caches necessary, data audio or contents, that are needed by transcription.
-   */
-  transcriptionCache;
-  /**
-   * Configurations for live agents under this invocation.
-   */
-  runConfig;
-  /**
-   * A container to keep track of different kinds of costs incurred as a part
-   * of this invocation.
-   */
-  _invocationCostManager = new InvocationCostManager();
-  /**
-   * Constructor for InvocationContext
-   */
-  constructor(options) {
-    this.artifactService = options.artifactService;
-    this.sessionService = options.sessionService;
-    this.memoryService = options.memoryService;
-    this.invocationId = options.invocationId || newInvocationContextId();
-    this.branch = options.branch;
-    this.agent = options.agent;
-    this.userContent = options.userContent;
-    this.session = options.session;
-    this.endInvocation = options.endInvocation || false;
-    this.liveRequestQueue = options.liveRequestQueue;
-    this.activeStreamingTools = options.activeStreamingTools;
-    this.transcriptionCache = options.transcriptionCache;
-    this.runConfig = options.runConfig;
-  }
-  /**
-   * App name from the session
-   */
-  get appName() {
-    return this.session.appName;
-  }
-  /**
-   * User ID from the session
-   */
-  get userId() {
-    return this.session.userId;
-  }
-  /**
-   * Tracks number of llm calls made.
-   *
-   * @throws {LlmCallsLimitExceededError} If number of llm calls made exceed the set threshold.
-   */
-  incrementLlmCallCount() {
-    this._invocationCostManager.incrementAndEnforceLlmCallsLimit(
-      this.runConfig
-    );
-  }
-  /**
-   * Creates a child invocation context for a sub-agent
-   */
-  createChildContext(agent) {
-    return new _InvocationContext({
-      artifactService: this.artifactService,
-      sessionService: this.sessionService,
-      memoryService: this.memoryService,
-      invocationId: this.invocationId,
-      // Keep same invocation ID
-      branch: this.branch ? `${this.branch}.${agent.name}` : agent.name,
-      // Update branch
-      agent,
-      // Update to the new agent
-      userContent: this.userContent,
-      session: this.session,
-      endInvocation: this.endInvocation,
-      liveRequestQueue: this.liveRequestQueue,
-      activeStreamingTools: this.activeStreamingTools,
-      transcriptionCache: this.transcriptionCache,
-      runConfig: this.runConfig
-    });
-  }
-};
-
 // src/agents/parallel-agent.ts
 function createBranchContextForSubAgent(agent, subAgent, invocationContext) {
   const branchSuffix = `${agent.name}.${subAgent.name}`;
@@ -9745,6 +9909,9 @@ var Runner = class {
       )) {
         if (!event.partial) {
           await this.sessionService.appendEvent(session, event);
+          if (this.memoryService) {
+            await this.memoryService.addSessionToMemory(session);
+          }
         }
         yield event;
       }
@@ -9885,10 +10052,12 @@ var InMemoryRunner = class extends Runner {
 // src/agents/agent-builder.ts
 var AgentBuilder = class _AgentBuilder {
   config;
-  sessionConfig;
+  sessionService;
+  sessionOptions;
   memoryService;
   artifactService;
   agentType = "llm";
+  existingSession;
   /**
    * Private constructor - use static create() method
    */
@@ -9956,6 +10125,51 @@ var AgentBuilder = class _AgentBuilder {
     this.config.planner = planner;
     return this;
   }
+  /**
+   * Set the code executor for the agent
+   * @param codeExecutor The code executor to use for running code
+   * @returns This builder instance for chaining
+   */
+  withCodeExecutor(codeExecutor) {
+    this.config.codeExecutor = codeExecutor;
+    return this;
+  }
+  /**
+   * Set the output key for the agent
+   * @param outputKey The output key in session state to store the output of the agent
+   * @returns This builder instance for chaining
+   */
+  withOutputKey(outputKey) {
+    this.config.outputKey = outputKey;
+    return this;
+  }
+  /**
+   * Add sub-agents to the agent
+   * @param subAgents Sub-agents to add to the agent
+   * @returns This builder instance for chaining
+   */
+  withSubAgents(subAgents) {
+    this.config.subAgents = subAgents;
+    return this;
+  }
+  /**
+   * Set the before agent callback
+   * @param callback Callback to invoke before agent execution
+   * @returns This builder instance for chaining
+   */
+  withBeforeAgentCallback(callback) {
+    this.config.beforeAgentCallback = callback;
+    return this;
+  }
+  /**
+   * Set the after agent callback
+   * @param callback Callback to invoke after agent execution
+   * @returns This builder instance for chaining
+   */
+  withAfterAgentCallback(callback) {
+    this.config.afterAgentCallback = callback;
+    return this;
+  }
   /**
    * Configure as a sequential agent
    * @param subAgents Sub-agents to execute in sequence
@@ -10006,14 +10220,38 @@ var AgentBuilder = class _AgentBuilder {
    * @param options Session configuration options (userId and appName)
    * @returns This builder instance for chaining
    */
-  withSession(service, options = {}) {
-    this.sessionConfig = {
-      service,
+  withSessionService(service, options = {}) {
+    this.sessionService = service;
+    this.sessionOptions = {
       userId: options.userId || this.generateDefaultUserId(),
-      appName: options.appName || this.generateDefaultAppName()
+      appName: options.appName || this.generateDefaultAppName(),
+      state: options.state,
+      sessionId: options.sessionId
     };
     return this;
   }
+  /**
+   * Configure with an existing session instance
+   * @param session Existing session to use
+   * @returns This builder instance for chaining
+   * @throws Error if no session service has been configured via withSessionService()
+   */
+  withSession(session) {
+    if (!this.sessionService) {
+      throw new Error(
+        "Session service must be configured before using withSession(). Call withSessionService() first, or use withQuickSession() for in-memory sessions."
+      );
+    }
+    this.sessionOptions = {
+      ...this.sessionOptions,
+      userId: session.userId,
+      appName: session.appName,
+      sessionId: session.id,
+      state: session.state
+    };
+    this.existingSession = session;
+    return this;
+  }
   /**
    * Configure memory service for the agent
    * @param memoryService Memory service to use for conversation history and context
@@ -10039,7 +10277,7 @@ var AgentBuilder = class _AgentBuilder {
    * @returns This builder instance for chaining
    */
   withQuickSession(options = {}) {
-    return this.withSession(new InMemorySessionService(), options);
+    return this.withSessionService(new InMemorySessionService(), options);
   }
   /**
    * Build the agent and optionally create runner and session
@@ -10049,18 +10287,24 @@ var AgentBuilder = class _AgentBuilder {
     const agent = this.createAgent();
     let runner;
     let session;
-    if (!this.sessionConfig) {
+    if (!this.sessionService) {
       this.withQuickSession();
     }
-    if (this.sessionConfig) {
-      session = await this.sessionConfig.service.createSession(
-        this.sessionConfig.appName,
-        this.sessionConfig.userId
-      );
+    if (this.sessionService && this.sessionOptions) {
+      if (this.existingSession) {
+        session = this.existingSession;
+      } else {
+        session = await this.sessionService.createSession(
+          this.sessionOptions.appName,
+          this.sessionOptions.userId,
+          this.sessionOptions.state,
+          this.sessionOptions.sessionId
+        );
+      }
       const runnerConfig = {
-        appName: this.sessionConfig.appName,
+        appName: this.sessionOptions.appName,
         agent,
-        sessionService: this.sessionConfig.service,
+        sessionService: this.sessionService,
         memoryService: this.memoryService,
         artifactService: this.artifactService
       };
@@ -10095,7 +10339,15 @@ var AgentBuilder = class _AgentBuilder {
           description: this.config.description,
           instruction: this.config.instruction,
           tools: this.config.tools,
-          planner: this.config.planner
+          planner: this.config.planner,
+          codeExecutor: this.config.codeExecutor,
+          subAgents: this.config.subAgents,
+          beforeAgentCallback: this.config.beforeAgentCallback,
+          afterAgentCallback: this.config.afterAgentCallback,
+          memoryService: this.memoryService,
+          artifactService: this.artifactService,
+          outputKey: this.config.outputKey,
+          sessionService: this.sessionService
         });
       }
       case "sequential":
@@ -10160,16 +10412,16 @@ var AgentBuilder = class _AgentBuilder {
    * @returns Enhanced runner with simplified API
    */
   createEnhancedRunner(baseRunner, session) {
-    const sessionConfig = this.sessionConfig;
+    const sessionOptions = this.sessionOptions;
     return {
       async ask(message) {
         const newMessage = typeof message === "string" ? { parts: [{ text: message }] } : typeof message === "object" && "contents" in message ? { parts: message.contents[message.contents.length - 1].parts } : message;
         let response = "";
-        if (!sessionConfig) {
+        if (!sessionOptions?.userId) {
           throw new Error("Session configuration is required");
         }
         for await (const event of baseRunner.runAsync({
-          userId: sessionConfig.userId,
+          userId: sessionOptions.userId,
           sessionId: session.id,
           newMessage
         })) {
@@ -10182,7 +10434,7 @@ var AgentBuilder = class _AgentBuilder {
             }
           }
         }
-        return response;
+        return response.trim();
       },
       runAsync(params) {
         return baseRunner.runAsync(params);
@@ -10924,11 +11176,11 @@ var DatabaseSessionService = class extends BaseSessionService {
 };
 
 // src/sessions/database-factories.ts
-import dedent from "dedent";
+import dedent2 from "dedent";
 import { Kysely, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
 function createDependencyError(packageName, dbType) {
   return new Error(
-    dedent`
+    dedent2`
 		Missing required peer dependency: ${packageName}
 		To use ${dbType} sessions, install the required package:
 			npm install ${packageName}
@@ -11182,6 +11434,7 @@ export {
   AF_FUNCTION_CALL_ID_PREFIX,
   LlmAgent as Agent,
   AgentBuilder,
+  AgentTool,
   agents_exports as Agents,
   AiSdkLlm,
   AnthropicLlm,