@google/adk 2.0.0 → 2.1.0

package/dist/cjs/agents/sequential_agent.js

@@ -49,7 +49,7 @@ var import_readonly_context = require("./readonly_context.js");
  */
 var _a, _b;
 const TASK_COMPLETED_TOOL_NAME = "task_completed";
-const SEQUENTIAL_AGENT_SIGNATURE_SYMBOL = Symbol.for(
+const SEQUENTIAL_AGENT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
   "google.adk.sequentialAgent"
 );
 function isSequentialAgent(obj) {

package/dist/cjs/apps/app.js

@@ -49,7 +49,7 @@ function validateAppName(name) {
   }
 }
 __name(validateAppName, "validateAppName");
-const APP_SIGNATURE_SYMBOL = Symbol.for("google.adk.app");
+const APP_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.app");
 function isApp(obj) {
   return typeof obj === "object" && obj !== null && APP_SIGNATURE_SYMBOL in obj && obj[APP_SIGNATURE_SYMBOL] === true;
 }

package/dist/cjs/artifacts/file_artifact_service.js

@@ -514,10 +514,9 @@ async function* iterateArtifactDirs(dir) {
     );
     if (hasVersions) {
       yield dir;
-      return;
     }
     for (const entry of entries) {
-      if (entry.isDirectory()) {
+      if (entry.isDirectory() && entry.name !== "versions") {
         const subdir = path.join(dir, entry.name);
         for await (const foundDir of iterateArtifactDirs(subdir)) {
           yield foundDir;

package/dist/cjs/artifacts/scoped_artifact_service.js

@@ -33,12 +33,21 @@ module.exports = __toCommonJS(scoped_artifact_service_exports);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
+const SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.sessionArtifactService"
+);
+_a = SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL;
 const _ScopedArtifactService = class _ScopedArtifactService {
   constructor(delegate, appName, userId, sessionId) {
     this.delegate = delegate;
     this.appName = appName;
     this.userId = userId;
     this.sessionId = sessionId;
+    /**
+     * Brands this class as a session-scoped artifact service.
+     */
+    this[_a] = true;
   }
   async saveArtifact(request) {
     return this.delegate.saveArtifact({

package/dist/cjs/artifacts/session_artifact_service.js

@@ -9,6 +9,11 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -19,9 +24,23 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var session_artifact_service_exports = {};
+__export(session_artifact_service_exports, {
+  isSessionArtifactService: () => isSessionArtifactService
+});
 module.exports = __toCommonJS(session_artifact_service_exports);
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.sessionArtifactService"
+);
+function isSessionArtifactService(service) {
+  return typeof service === "object" && service !== null && SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL in service && service[SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL] === true;
+}
+__name(isSessionArtifactService, "isSessionArtifactService");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isSessionArtifactService
+});

package/dist/cjs/auth/auth_handler.js

@@ -30,11 +30,13 @@ __export(auth_handler_exports, {
 module.exports = __toCommonJS(auth_handler_exports);
 var import_env_aware_utils = require("../utils/env_aware_utils.js");
 var import_oauth2_credential_exchanger = require("./oauth2/oauth2_credential_exchanger.js");
+var import_oauth2_utils = require("./oauth2/oauth2_utils.js");
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const S256_CODE_CHALLENGE_METHOD = "S256";
 const _AuthHandler = class _AuthHandler {
   constructor(authConfig) {
     this.authConfig = authConfig;
@@ -43,7 +45,16 @@ const _AuthHandler = class _AuthHandler {
     const credentialKey = "temp:" + this.authConfig.credentialKey;
     return state.get(credentialKey);
   }
+  /**
+   * Stores the exchanged credential in the session state.
+   *
+   * @param state The session state to store the credential in.
+   * @throws Error: If the auth config has no credentialKey.
+   */
   async parseAndStoreAuthResponse(state) {
+    if (!this.authConfig.credentialKey) {
+      throw new Error("credentialKey is empty.");
+    }
     const credentialKey = "temp:" + this.authConfig.credentialKey;
     const authSchemeType = this.authConfig.authScheme.type;
     if (!["oauth2", "openIdConnect"].includes(authSchemeType)) {
@@ -99,9 +110,14 @@ const _AuthHandler = class _AuthHandler {
   /**
    * Generates an response containing the auth uri for user to sign in.
    *
+   * When the credential requests PKCE, the URI also carries the S256 code
+   * challenge derived from the credential's code verifier, and the returned
+   * credential carries the verifier the later token exchange must send.
+   *
    * @return An AuthCredential object containing the auth URI and state.
    * @throws Error: If the authorization endpoint is not configured in the
-   *     auth scheme.
+   *     auth scheme, or the credential requests a code challenge method other
+   *     than 'S256'.
    */
   generateAuthUri() {
     const authScheme = this.authConfig.authScheme;
@@ -109,6 +125,13 @@ const _AuthHandler = class _AuthHandler {
     if (!authCredential || !authCredential.oauth2) {
       return authCredential;
     }
+    const oauth2 = authCredential.oauth2;
+    const codeChallengeMethod = oauth2.codeChallengeMethod;
+    if (codeChallengeMethod && codeChallengeMethod !== S256_CODE_CHALLENGE_METHOD) {
+      throw new Error(
+        `Unsupported codeChallengeMethod: ${codeChallengeMethod}. Only '${S256_CODE_CHALLENGE_METHOD}' is supported.`
+      );
+    }
     let authorizationEndpoint = "";
     let scopes = [];
     if ("authorizationEndpoint" in authScheme) {
@@ -133,22 +156,35 @@ const _AuthHandler = class _AuthHandler {
     }
     const state = (0, import_env_aware_utils.randomUUID)();
     const url = new URL(authorizationEndpoint);
-    url.searchParams.set("client_id", authCredential.oauth2.clientId || "");
-    url.searchParams.set(
-      "redirect_uri",
-      authCredential.oauth2.redirectUri || ""
-    );
+    url.searchParams.set("client_id", oauth2.clientId || "");
+    url.searchParams.set("redirect_uri", oauth2.redirectUri || "");
     url.searchParams.set("response_type", "code");
     url.searchParams.set("scope", scopes.join(" "));
     url.searchParams.set("state", state);
     url.searchParams.set("access_type", "offline");
     url.searchParams.set("prompt", "consent");
+    if (oauth2.audience) {
+      url.searchParams.set("audience", oauth2.audience);
+    }
+    if (oauth2.nonce) {
+      url.searchParams.set("nonce", oauth2.nonce);
+    }
+    let codeVerifier = oauth2.codeVerifier;
+    if (codeChallengeMethod) {
+      codeVerifier != null ? codeVerifier : codeVerifier = (0, import_oauth2_utils.generateCodeVerifier)();
+      url.searchParams.set(
+        "code_challenge",
+        (0, import_oauth2_utils.createS256CodeChallenge)(codeVerifier)
+      );
+      url.searchParams.set("code_challenge_method", codeChallengeMethod);
+    }
     const exchangedAuthCredential = {
       ...authCredential,
       oauth2: {
-        ...authCredential.oauth2,
+        ...oauth2,
         authUri: url.toString(),
-        state
+        state,
+        codeVerifier
       }
     };
     return exchangedAuthCredential;

package/dist/cjs/auth/oauth2/oauth2_credential_refresher.js

@@ -41,7 +41,7 @@ const _OAuth2CredentialRefresher = class _OAuth2CredentialRefresher {
    *
    * @param authCredential The OAuth2 credential to check.
    * @param authScheme The OAuth2 authentication scheme (optional).
-   * @returns True if the credential needs to be refreshed, False otherwise.
+   * @returns True if the credential needs to be refreshed, false otherwise.
    */
   async isRefreshNeeded(authCredential) {
     if (!authCredential.oauth2) {

package/dist/cjs/auth/oauth2/oauth2_utils.js

@@ -26,19 +26,32 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var oauth2_utils_exports = {};
 __export(oauth2_utils_exports, {
   createOAuth2TokenRequestBody: () => createOAuth2TokenRequestBody,
+  createS256CodeChallenge: () => createS256CodeChallenge,
   fetchOAuth2Tokens: () => fetchOAuth2Tokens,
+  generateCodeVerifier: () => generateCodeVerifier,
   getTokenEndpoint: () => getTokenEndpoint,
   isTokenExpired: () => isTokenExpired,
   parseAuthorizationCode: () => parseAuthorizationCode
 });
 module.exports = __toCommonJS(oauth2_utils_exports);
+var import_node_crypto = require("node:crypto");
 var import_logger = require("../../utils/logger.js");
+var import_redact_uri = require("../../utils/redact_uri.js");
 var import_oauth2_discovery = require("./oauth2_discovery.js");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const CODE_VERIFIER_BYTES = 36;
+function generateCodeVerifier() {
+  return (0, import_node_crypto.randomBytes)(CODE_VERIFIER_BYTES).toString("base64url");
+}
+__name(generateCodeVerifier, "generateCodeVerifier");
+function createS256CodeChallenge(codeVerifier) {
+  return (0, import_node_crypto.createHash)("sha256").update(codeVerifier).digest("base64url");
+}
+__name(createS256CodeChallenge, "createS256CodeChallenge");
 function getTokenEndpoint(authScheme) {
   if (authScheme.type === "openIdConnect" && authScheme.tokenEndpoint) {
     return authScheme.tokenEndpoint;
@@ -93,8 +106,8 @@ function parseAuthorizationCode(uri) {
   try {
     const url = new URL(uri);
     return url.searchParams.get("code") || void 0;
-  } catch (e) {
-    import_logger.logger.warn(`Failed to parse authorization URI ${uri}: ${e}`);
+  } catch {
+    import_logger.logger.warn(`Failed to parse authorization URI ${(0, import_redact_uri.redactUriPassword)(uri)}`);
     return void 0;
   }
 }
@@ -129,7 +142,9 @@ __name(isTokenExpired, "isTokenExpired");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createOAuth2TokenRequestBody,
+  createS256CodeChallenge,
   fetchOAuth2Tokens,
+  generateCodeVerifier,
   getTokenEndpoint,
   isTokenExpired,
   parseAuthorizationCode

package/dist/cjs/code_executors/base_code_executor.js

@@ -35,7 +35,7 @@ module.exports = __toCommonJS(base_code_executor_exports);
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-const BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL = Symbol.for(
+const BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
   "google.adk.baseCodeExecutor"
 );
 function isBaseCodeExecutor(obj) {

package/dist/cjs/code_executors/built_in_code_executor.js

@@ -37,7 +37,7 @@ var import_base_code_executor = require("./base_code_executor.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a, _b;
-const BUILT_IN_CODE_EXECUTOR_SIGNATURE_SYMBOL = Symbol.for(
+const BUILT_IN_CODE_EXECUTOR_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
   "google.adk.builtInCodeExecutor"
 );
 function isBuiltInCodeExecutor(obj) {

package/dist/cjs/code_executors/code_execution_utils.js

@@ -70,7 +70,7 @@ function extractCodeAndTruncateContent(content, codeBlockDelimiters) {
     const part = content.parts[i];
     if (part.executableCode && (i === content.parts.length - 1 || !content.parts[i + 1].codeExecutionResult)) {
       content.parts = content.parts.slice(0, i + 1);
-      return part.executableCode.code;
+      return part.executableCode.code || "";
     }
   }
   const textParts = content.parts.filter((part) => part.text);
@@ -145,7 +145,7 @@ function convertCodeExecutionParts(content, codeBlockDelimiter, executionResultD
   const lastPart = content.parts[content.parts.length - 1];
   if (lastPart.executableCode) {
     content.parts[content.parts.length - 1] = {
-      text: codeBlockDelimiter[0] + lastPart.executableCode.code + codeBlockDelimiter[1]
+      text: codeBlockDelimiter[0] + (lastPart.executableCode.code || "") + codeBlockDelimiter[1]
     };
   } else if (content.parts.length == 1 && lastPart.codeExecutionResult) {
     content.parts[content.parts.length - 1] = {

package/dist/cjs/code_executors/container_code_executor.js

@@ -0,0 +1,186 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var container_code_executor_exports = {};
+__export(container_code_executor_exports, {
+  ContainerCodeExecutor: () => ContainerCodeExecutor
+});
+module.exports = __toCommonJS(container_code_executor_exports);
+var path = __toESM(require("node:path"), 1);
+var import_experimental = require("../utils/experimental.js");
+var import_logger = require("../utils/logger.js");
+var import_base_code_executor = require("./base_code_executor.js");
+var import_code_execution_utils = require("./code_execution_utils.js");
+var import_docker_container = require("./docker_container.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_IMAGE_TAG = "adk-code-executor:latest";
+const DEFAULT_TIMEOUT_SECONDS = 300;
+const TIMEOUT_COMMAND = ["timeout", "-s", "KILL"];
+const LANGUAGE_RUNTIME_COMMAND_MAP = {
+  [import_code_execution_utils.CodeExecutionLanguage.PYTHON]: ["python3", "-c"],
+  [import_code_execution_utils.CodeExecutionLanguage.JAVASCRIPT]: ["node", "-e"],
+  [import_code_execution_utils.CodeExecutionLanguage.TYPESCRIPT]: ["tsx", "--eval"],
+  [import_code_execution_utils.CodeExecutionLanguage.SHELL]: ["sh", "-c"]
+};
+let ContainerCodeExecutor = class extends import_base_code_executor.BaseCodeExecutor {
+  constructor(options = {}) {
+    var _a, _b, _c;
+    super();
+    if (!options.image && !options.dockerPath) {
+      throw new Error(
+        "Either image or dockerPath must be set for ContainerCodeExecutor."
+      );
+    }
+    this.timeoutSeconds = (_a = options.timeoutSeconds) != null ? _a : DEFAULT_TIMEOUT_SECONDS;
+    if (this.timeoutSeconds <= 0) {
+      throw new Error(
+        "timeoutSeconds must be greater than 0 for ContainerCodeExecutor."
+      );
+    }
+    this.dockerPath = options.dockerPath ? path.resolve(options.dockerPath) : void 0;
+    this.containerOptions = {
+      image: (_b = options.image) != null ? _b : DEFAULT_IMAGE_TAG,
+      networkEnabled: (_c = options.networkEnabled) != null ? _c : false,
+      baseUrl: options.baseUrl,
+      docker: options.docker
+    };
+    defineFrozenFalse(this, "stateful");
+    defineFrozenFalse(this, "optimizeDataFile");
+  }
+  async executeCode(params) {
+    const { code, language } = params.codeExecutionInput;
+    const command = LANGUAGE_RUNTIME_COMMAND_MAP[language];
+    if (!command) {
+      throw new Error(
+        `Unsupported language for ContainerCodeExecutor: ${language}. Supported: ${Object.keys(LANGUAGE_RUNTIME_COMMAND_MAP).join(", ")}.`
+      );
+    }
+    await this.ensureContainer();
+    const { stdout, stderr, exitCode } = await this.container.execute(
+      [...TIMEOUT_COMMAND, String(this.timeoutSeconds), ...command, code],
+      this.timeoutSeconds
+    );
+    import_logger.logger.debug(`Executed ${language} code:
+\`\`\`
+${code}
+\`\`\``);
+    return {
+      stdout,
+      stderr: this.describeExit(stderr, exitCode),
+      outputFiles: []
+    };
+  }
+  /**
+   * Turns a non-zero exit into stderr the model can see. An empty stderr maps
+   * to `OUTCOME_OK` downstream, so a program that exits non-zero without
+   * writing stderr would otherwise look successful (matching
+   * `UnsafeLocalCodeExecutor`).
+   */
+  describeExit(stderr, exitCode) {
+    if (exitCode === import_docker_container.TIMEOUT_EXIT_CODE) {
+      const message = `Code execution timed out after ${this.timeoutSeconds} seconds.`;
+      return stderr ? `${stderr}
+${message}` : message;
+    }
+    if (exitCode !== 0 && exitCode !== null && !stderr) {
+      return `Exit code ${exitCode}`;
+    }
+    return stderr;
+  }
+  /**
+   * Stops and removes the container. Safe to call when no container has been
+   * started; provided for deterministic teardown in tests and app shutdown.
+   */
+  async close() {
+    const container = this.container;
+    this.container = void 0;
+    this.initPromise = void 0;
+    await (container == null ? void 0 : container.stop());
+  }
+  /** Lazily builds/starts the container exactly once. */
+  ensureContainer() {
+    if (!this.initPromise) {
+      this.initPromise = this.initContainer().catch((error) => {
+        this.initPromise = void 0;
+        throw error;
+      });
+    }
+    return this.initPromise;
+  }
+  async initContainer() {
+    const container = new import_docker_container.DockerContainer(this.containerOptions);
+    if (this.dockerPath) {
+      await container.build(this.dockerPath);
+    }
+    await container.start();
+    this.container = container;
+    const { exitCode } = await container.execute(
+      ["which", "python3"],
+      this.timeoutSeconds
+    );
+    if (exitCode !== 0) {
+      throw new Error("python3 is not installed in the container.");
+    }
+  }
+};
+__name(ContainerCodeExecutor, "ContainerCodeExecutor");
+ContainerCodeExecutor = __decorateClass([
+  import_experimental.experimental
+], ContainerCodeExecutor);
+function defineFrozenFalse(target, key) {
+  Object.defineProperty(target, key, {
+    value: false,
+    writable: false,
+    enumerable: true,
+    configurable: false
+  });
+}
+__name(defineFrozenFalse, "defineFrozenFalse");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContainerCodeExecutor
+});