@iqai/adk 0.1.13 → 0.1.14

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"
           }
         },
@@ -4603,6 +4869,7 @@ var TransferToAgentTool = class extends BaseTool {
 // src/tools/common/load-memory-tool.ts
 init_logger();
 init_base_tool();
+import { Type as Type8 } from "@google/genai";
 var LoadMemoryTool = class extends BaseTool {
   logger = new Logger({ name: "LoadMemoryTool" });
   /**
@@ -4622,10 +4889,10 @@ var LoadMemoryTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: "object",
+        type: Type8.OBJECT,
         properties: {
           query: {
-            type: "string",
+            type: Type8.STRING,
             description: "The query to load memories for"
           }
         },
@@ -4656,6 +4923,7 @@ var LoadMemoryTool = class extends BaseTool {
 
 // src/tools/common/load-artifacts-tool.ts
 init_base_tool();
+import { Type as Type9 } from "@google/genai";
 var LoadArtifactsTool = class extends BaseTool {
   constructor() {
     super({
@@ -4671,12 +4939,12 @@ var LoadArtifactsTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: "object",
+        type: Type9.OBJECT,
         properties: {
           artifact_names: {
-            type: "array",
+            type: Type9.ARRAY,
             items: {
-              type: "string"
+              type: Type9.STRING
             },
             description: "List of artifact names to load"
           }
@@ -5295,6 +5563,7 @@ init_logger();
 init_base_tool();
 
 // src/tools/mcp/schema-conversion.ts
+import { Type as Type10 } from "@google/genai";
 function adkToMcpToolType(tool) {
   const declaration = tool.getDeclaration();
   const params = declarationToJsonSchema(declaration);
@@ -5323,13 +5592,13 @@ function jsonSchemaToDeclaration(name, description, schema) {
       parameters = schema;
     } else {
       parameters = {
-        type: "object",
+        type: Type10.OBJECT,
         properties: schema
       };
     }
   } else {
     parameters = {
-      type: "object",
+      type: Type10.OBJECT,
       properties: {}
     };
   }
@@ -5341,7 +5610,7 @@ function jsonSchemaToDeclaration(name, description, schema) {
 }
 function normalizeJsonSchema(schema) {
   if (!schema) {
-    return { type: "object", properties: {} };
+    return { type: Type10.OBJECT, properties: {} };
   }
   const normalizedSchema = { ...schema };
   if (!normalizedSchema.type) {
@@ -5358,39 +5627,39 @@ function normalizeJsonSchema(schema) {
     case "integer":
       return normalizeNumberSchema(normalizedSchema);
     case "boolean":
-      return { type: "boolean" };
+      return { type: Type10.BOOLEAN };
     case "null":
-      return { type: "null" };
+      return { type: Type10.NULL };
     default:
       return normalizedSchema;
   }
 }
 function determineSchemaType(schema) {
   if (schema.properties || schema.required || schema.additionalProperties !== void 0) {
-    return "object";
+    return Type10.OBJECT;
   }
   if (schema.items) {
-    return "array";
+    return Type10.ARRAY;
   }
   if (schema.enum !== void 0) {
-    if (schema.enum.length === 0) return "string";
+    if (schema.enum.length === 0) return Type10.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 Type10.STRING;
+    if (typeof firstItem === "number") return Type10.NUMBER;
+    if (typeof firstItem === "boolean") return Type10.BOOLEAN;
+    return Type10.STRING;
   }
   if (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern) {
-    return "string";
+    return Type10.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 ? Type10.INTEGER : Type10.NUMBER;
   }
-  return "object";
+  return Type10.OBJECT;
 }
 function normalizeObjectSchema(schema) {
   const normalizedSchema = {
-    type: "object",
+    type: Type10.OBJECT,
     properties: {}
   };
   if (schema.properties) {
@@ -5402,15 +5671,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: Type10.ARRAY
   };
   if (schema.items) {
     normalizedSchema.items = normalizeJsonSchema(
@@ -5421,15 +5688,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: Type10.STRING
   };
   if (schema.minLength !== void 0)
     normalizedSchema.minLength = schema.minLength;
@@ -5448,12 +5713,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 +5727,7 @@ function mcpSchemaToParameters(mcpTool) {
   }
   if (!schema) {
     return {
-      type: "object",
+      type: Type10.OBJECT,
       properties: {}
     };
   }
@@ -5961,7 +6220,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 +6344,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 +8392,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 +8442,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.
@@ -8187,14 +8483,7 @@ 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);
@@ -8549,155 +8838,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 +9885,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 +10028,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 +10101,24 @@ 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;
+  }
   /**
    * Configure as a sequential agent
    * @param subAgents Sub-agents to execute in sequence
@@ -10006,14 +10169,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 +10226,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 +10236,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 +10288,12 @@ 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,
+          memoryService: this.memoryService,
+          artifactService: this.artifactService,
+          outputKey: this.config.outputKey,
+          sessionService: this.sessionService
         });
       }
       case "sequential":
@@ -10160,16 +10358,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 +10380,7 @@ var AgentBuilder = class _AgentBuilder {
             }
           }
         }
-        return response;
+        return response.trim();
       },
       runAsync(params) {
         return baseRunner.runAsync(params);
@@ -11182,6 +11380,7 @@ export {
   AF_FUNCTION_CALL_ID_PREFIX,
   LlmAgent as Agent,
   AgentBuilder,
+  AgentTool,
   agents_exports as Agents,
   AiSdkLlm,
   AnthropicLlm,