@google/adk 0.3.0 → 0.5.0

package/dist/web/agents/processors/instructions_llm_request_processor.js

@@ -0,0 +1,72 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { appendInstructions } from "../../models/llm_request.js";
+import { injectSessionState } from "../instructions.js";
+import { isLlmAgent } from "../llm_agent.js";
+import { ReadonlyContext } from "../readonly_context.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
+  /**
+   * Handles instructions and global instructions for LLM flow.
+   */
+  // eslint-disable-next-line require-yield
+  runAsync(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      const agent = invocationContext.agent;
+      if (!isLlmAgent(agent) || !isLlmAgent(agent.rootAgent)) {
+        return;
+      }
+      const rootAgent = agent.rootAgent;
+      if (isLlmAgent(rootAgent) && rootAgent.globalInstruction) {
+        const { instruction, requireStateInjection } = yield new __await(rootAgent.canonicalGlobalInstruction(
+          new ReadonlyContext(invocationContext)
+        ));
+        let instructionWithState = instruction;
+        if (requireStateInjection) {
+          instructionWithState = yield new __await(injectSessionState(
+            instruction,
+            new ReadonlyContext(invocationContext)
+          ));
+        }
+        appendInstructions(llmRequest, [instructionWithState]);
+      }
+      if (agent.instruction) {
+        const { instruction, requireStateInjection } = yield new __await(agent.canonicalInstruction(
+          new ReadonlyContext(invocationContext)
+        ));
+        let instructionWithState = instruction;
+        if (requireStateInjection) {
+          instructionWithState = yield new __await(injectSessionState(
+            instruction,
+            new ReadonlyContext(invocationContext)
+          ));
+        }
+        appendInstructions(llmRequest, [instructionWithState]);
+      }
+    });
+  }
+}
+const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();
+export {
+  INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
+  InstructionsLlmRequestProcessor
+};

package/dist/web/agents/processors/request_confirmation_llm_request_processor.js

@@ -0,0 +1,158 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  getFunctionCalls,
+  getFunctionResponses
+} from "../../events/event.js";
+import { ToolConfirmation } from "../../tools/tool_confirmation.js";
+import {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  handleFunctionCallList
+} from "../functions.js";
+import { isLlmAgent } from "../llm_agent.js";
+import { ReadonlyContext } from "../readonly_context.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+class RequestConfirmationLlmRequestProcessor extends BaseLlmRequestProcessor {
+  /** Handles tool confirmation information to build the LLM request. */
+  runAsync(invocationContext) {
+    return __asyncGenerator(this, null, function* () {
+      const agent = invocationContext.agent;
+      if (!isLlmAgent(agent)) {
+        return;
+      }
+      const events = invocationContext.session.events;
+      if (!events || events.length === 0) {
+        return;
+      }
+      const requestConfirmationFunctionResponses = {};
+      let confirmationEventIndex = -1;
+      for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (event.author !== "user") {
+          continue;
+        }
+        const responses = getFunctionResponses(event);
+        if (!responses) {
+          continue;
+        }
+        let foundConfirmation = false;
+        for (const functionResponse of responses) {
+          if (functionResponse.name !== REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+            continue;
+          }
+          foundConfirmation = true;
+          let toolConfirmation = null;
+          if (functionResponse.response && Object.keys(functionResponse.response).length === 1 && "response" in functionResponse.response) {
+            toolConfirmation = JSON.parse(
+              functionResponse.response["response"]
+            );
+          } else if (functionResponse.response) {
+            toolConfirmation = new ToolConfirmation({
+              hint: functionResponse.response["hint"],
+              payload: functionResponse.response["payload"],
+              confirmed: functionResponse.response["confirmed"]
+            });
+          }
+          if (functionResponse.id && toolConfirmation) {
+            requestConfirmationFunctionResponses[functionResponse.id] = toolConfirmation;
+          }
+        }
+        if (foundConfirmation) {
+          confirmationEventIndex = i;
+          break;
+        }
+      }
+      if (Object.keys(requestConfirmationFunctionResponses).length === 0) {
+        return;
+      }
+      for (let i = confirmationEventIndex - 1; i >= 0; i--) {
+        const event = events[i];
+        const functionCalls = getFunctionCalls(event);
+        if (!functionCalls) {
+          continue;
+        }
+        const toolsToResumeWithConfirmation = {};
+        const toolsToResumeWithArgs = {};
+        for (const functionCall of functionCalls) {
+          if (!functionCall.id || !(functionCall.id in requestConfirmationFunctionResponses)) {
+            continue;
+          }
+          const args = functionCall.args;
+          if (!args || !("originalFunctionCall" in args)) {
+            continue;
+          }
+          const originalFunctionCall = args["originalFunctionCall"];
+          if (originalFunctionCall.id) {
+            toolsToResumeWithConfirmation[originalFunctionCall.id] = requestConfirmationFunctionResponses[functionCall.id];
+            toolsToResumeWithArgs[originalFunctionCall.id] = originalFunctionCall;
+          }
+        }
+        if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+          continue;
+        }
+        for (let j = events.length - 1; j > confirmationEventIndex; j--) {
+          const eventToCheck = events[j];
+          const functionResponses = getFunctionResponses(eventToCheck);
+          if (!functionResponses) {
+            continue;
+          }
+          for (const fr of functionResponses) {
+            if (fr.id && fr.id in toolsToResumeWithConfirmation) {
+              delete toolsToResumeWithConfirmation[fr.id];
+              delete toolsToResumeWithArgs[fr.id];
+            }
+          }
+          if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+            break;
+          }
+        }
+        if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+          continue;
+        }
+        const toolsList = yield new __await(agent.canonicalTools(
+          new ReadonlyContext(invocationContext)
+        ));
+        const toolsDict = Object.fromEntries(
+          toolsList.map((tool) => [tool.name, tool])
+        );
+        const functionResponseEvent = yield new __await(handleFunctionCallList({
+          invocationContext,
+          functionCalls: Object.values(toolsToResumeWithArgs),
+          toolsDict,
+          beforeToolCallbacks: agent.canonicalBeforeToolCallbacks,
+          afterToolCallbacks: agent.canonicalAfterToolCallbacks,
+          filters: new Set(Object.keys(toolsToResumeWithConfirmation)),
+          toolConfirmationDict: toolsToResumeWithConfirmation
+        }));
+        if (functionResponseEvent) {
+          yield functionResponseEvent;
+        }
+        return;
+      }
+    });
+  }
+}
+const REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR = new RequestConfirmationLlmRequestProcessor();
+export {
+  REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
+  RequestConfirmationLlmRequestProcessor
+};

package/dist/web/agents/readonly_context.js

@@ -20,6 +20,18 @@ class ReadonlyContext {
   get invocationId() {
     return this.invocationContext.invocationId;
   }
+  /**
+   * The user ID of the current session.
+   */
+  get userId() {
+    return this.invocationContext.userId;
+  }
+  /**
+   * The ID of the current session.
+   */
+  get sessionId() {
+    return this.invocationContext.session.id;
+  }
   /**
    * The current agent name.
    */

package/dist/web/agents/run_config.js

@@ -32,7 +32,8 @@ function createRunConfig(params = {}) {
     supportCfc: false,
     enableAffectiveDialog: false,
     streamingMode: "none" /* NONE */,
-    maxLlmCalls: validateMaxLlmCalls(params.maxLlmCalls || 500)
+    maxLlmCalls: validateMaxLlmCalls(params.maxLlmCalls || 500),
+    pauseOnToolCalls: false
   }, params);
 }
 function validateMaxLlmCalls(value) {