@google/adk 1.6.0 → 2.1.0

package/dist/esm/artifacts/file_artifact_service.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -10,7 +12,7 @@ import * as path from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 import { logger } from "../utils/logger.js";
 const USER_NAMESPACE_PREFIX = "user:";
-class FileArtifactService {
+const _FileArtifactService = class _FileArtifactService {
   constructor(rootDirOrUri) {
     try {
       const rootDir = rootDirOrUri.startsWith("file://") ? fileURLToPath(rootDirOrUri) : rootDirOrUri;
@@ -321,7 +323,9 @@ class FileArtifactService {
       return void 0;
     }
   }
-}
+};
+__name(_FileArtifactService, "FileArtifactService");
+let FileArtifactService = _FileArtifactService;
 const SAFE_SEGMENT_RE = /^[a-zA-Z0-9_@-][a-zA-Z0-9_.@-]{0,255}$/;
 function assertSafeSegment(value, label) {
   if (!value || !SAFE_SEGMENT_RE.test(value)) {
@@ -330,6 +334,7 @@ function assertSafeSegment(value, label) {
     );
   }
 }
+__name(assertSafeSegment, "assertSafeSegment");
 function assertInsideRoot(resolvedPath, rootDir, label) {
   const root = path.resolve(rootDir);
   const resolved = path.resolve(resolvedPath);
@@ -339,27 +344,33 @@ function assertInsideRoot(resolvedPath, rootDir, label) {
     );
   }
 }
+__name(assertInsideRoot, "assertInsideRoot");
 function getUserRoot(rootDir, userId) {
   assertSafeSegment(userId, "userId");
   const result = path.join(rootDir, "users", userId);
   assertInsideRoot(result, rootDir, "userRoot");
   return result;
 }
+__name(getUserRoot, "getUserRoot");
 function isUserScoped(sessionId, filename) {
   return !sessionId || filename.startsWith(USER_NAMESPACE_PREFIX);
 }
+__name(isUserScoped, "isUserScoped");
 function getUserArtifactsDir(userRoot) {
   return path.join(userRoot, "artifacts");
 }
+__name(getUserArtifactsDir, "getUserArtifactsDir");
 function getSessionArtifactsDir(baseRoot, sessionId) {
   assertSafeSegment(sessionId, "sessionId");
   const result = path.join(baseRoot, "sessions", sessionId, "artifacts");
   assertInsideRoot(result, baseRoot, "sessionArtifactsDir");
   return result;
 }
+__name(getSessionArtifactsDir, "getSessionArtifactsDir");
 function getVersionsDir(artifactDir) {
   return path.join(artifactDir, "versions");
 }
+__name(getVersionsDir, "getVersionsDir");
 function getArtifactDir(rootDir, userId, sessionId, filename) {
   const userRoot = getUserRoot(rootDir, userId);
   let scopeRoot;
@@ -391,6 +402,7 @@ function getArtifactDir(rootDir, userId, sessionId, filename) {
   }
   return artifactDir;
 }
+__name(getArtifactDir, "getArtifactDir");
 async function getArtifactVersionsFromDir(artifactDir) {
   const versionsDir = getVersionsDir(artifactDir);
   try {
@@ -405,6 +417,7 @@ async function getArtifactVersionsFromDir(artifactDir) {
     return [];
   }
 }
+__name(getArtifactVersionsFromDir, "getArtifactVersionsFromDir");
 async function getCanonicalUri(rootDir, userId, sessionId, filename, version) {
   const artifactDir = await getArtifactDir(
     rootDir,
@@ -421,13 +434,16 @@ async function getCanonicalUri(rootDir, userId, sessionId, filename, version) {
   );
   return pathToFileURL(payloadPath).toString();
 }
+__name(getCanonicalUri, "getCanonicalUri");
 async function writeMetadata(metadataPath, metadata) {
   await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
 }
+__name(writeMetadata, "writeMetadata");
 async function readMetadata(metadataPath) {
   const content = await fs.readFile(metadataPath, "utf-8");
   return JSON.parse(content);
 }
+__name(readMetadata, "readMetadata");
 async function getLatestMetadata(artifactDir) {
   const versions = await getArtifactVersionsFromDir(artifactDir);
   if (versions.length === 0) {
@@ -449,6 +465,7 @@ async function getLatestMetadata(artifactDir) {
     return void 0;
   }
 }
+__name(getLatestMetadata, "getLatestMetadata");
 async function* iterateArtifactDirs(dir) {
   try {
     const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -457,10 +474,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;
@@ -470,6 +486,7 @@ async function* iterateArtifactDirs(dir) {
   } catch (_e) {
   }
 }
+__name(iterateArtifactDirs, "iterateArtifactDirs");
 function fileUriToPath(uri) {
   try {
     return fileURLToPath(uri);
@@ -481,9 +498,11 @@ function fileUriToPath(uri) {
     return void 0;
   }
 }
+__name(fileUriToPath, "fileUriToPath");
 function asPosixPath(p) {
   return p.split(path.sep).join("/");
 }
+__name(asPosixPath, "asPosixPath");
 export {
   FileArtifactService,
   assertInsideRoot,

package/dist/esm/artifacts/gcs_artifact_service.js

@@ -1,20 +1,58 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+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 __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
+));
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Storage } from "@google-cloud/storage";
 import { createPartFromBase64, createPartFromText } from "@google/genai";
 import { logger } from "../utils/logger.js";
+import { loadOptionalPeer } from "../utils/optional_peer.js";
 const GCS_FILE_URI_METADATA_KEY = "adkFileUri";
 const GCS_FILE_MIME_TYPE_METADATA_KEY = "adkFileMimeType";
 const GCS_DISPLAY_NAME_METADATA_KEY = "adkDisplayName";
 const GCS_IS_TEXT_METADATA_KEY = "adkIsText";
-class GcsArtifactService {
+const _GcsArtifactService = class _GcsArtifactService {
   constructor(bucket, options) {
-    this.bucket = new Storage(options).bucket(bucket);
+    this.bucketName = bucket;
+    this.storageOptions = options;
+  }
+  /**
+   * Resolves the GCS bucket handle, loading the `@google-cloud/storage`
+   * optional peer on first use.
+   */
+  getBucket() {
+    var _a;
+    (_a = this.bucketPromise) != null ? _a : this.bucketPromise = loadOptionalPeer(
+      { packageName: "@google-cloud/storage", feature: "GcsArtifactService" },
+      () => Promise.resolve().then(() => __toESM(require("@google-cloud/storage"), 1))
+    ).then(
+      ({ Storage }) => new Storage(this.storageOptions).bucket(this.bucketName)
+    );
+    return this.bucketPromise;
   }
   async saveArtifact(request) {
     if (!request.artifact.inlineData && !request.artifact.text && !request.artifact.fileData) {
@@ -22,7 +60,8 @@ class GcsArtifactService {
     }
     const versions = await this.listVersions(request);
     const version = versions.length > 0 ? Math.max(...versions) + 1 : 0;
-    const file = this.bucket.file(
+    const bucket = await this.getBucket();
+    const file = bucket.file(
       getFileName({
         ...request,
         version
@@ -79,7 +118,7 @@ class GcsArtifactService {
         }
         version = Math.max(...versions);
       }
-      const file = this.bucket.file(
+      const file = (await this.getBucket()).file(
         getFileName({
           ...request,
           version
@@ -121,9 +160,10 @@ class GcsArtifactService {
   async listArtifactKeys(request) {
     const sessionPrefix = `${request.appName}/${request.userId}/${request.sessionId}/`;
     const usernamePrefix = `${request.appName}/${request.userId}/user/`;
+    const bucket = await this.getBucket();
     const [[sessionFiles], [userSessionFiles]] = await Promise.all([
-      this.bucket.getFiles({ prefix: sessionPrefix }),
-      this.bucket.getFiles({ prefix: usernamePrefix })
+      bucket.getFiles({ prefix: sessionPrefix }),
+      bucket.getFiles({ prefix: usernamePrefix })
     ]);
     return [
       ...extractArtifactKeys(sessionFiles, sessionPrefix),
@@ -132,9 +172,10 @@ class GcsArtifactService {
   }
   async deleteArtifact(request) {
     const versions = await this.listVersions(request);
+    const bucket = await this.getBucket();
     await Promise.all(
       versions.map((version) => {
-        const file = this.bucket.file(
+        const file = bucket.file(
           getFileName({
             ...request,
             version
@@ -148,7 +189,8 @@ class GcsArtifactService {
   async listVersions(request) {
     const prefix = getFileName(request);
     const searchPrefix = prefix + "/";
-    const [files] = await this.bucket.getFiles({ prefix: searchPrefix });
+    const bucket = await this.getBucket();
+    const [files] = await bucket.getFiles({ prefix: searchPrefix });
     const versions = [];
     for (const file of files) {
       const version = file.name.split("/").pop();
@@ -183,7 +225,7 @@ class GcsArtifactService {
         }
         version = Math.max(...versions);
       }
-      const file = this.bucket.file(
+      const file = (await this.getBucket()).file(
         getFileName({
           ...request,
           version
@@ -204,7 +246,9 @@ class GcsArtifactService {
       return void 0;
     }
   }
-}
+};
+__name(_GcsArtifactService, "GcsArtifactService");
+let GcsArtifactService = _GcsArtifactService;
 function getFileName({
   appName,
   userId,
@@ -217,6 +261,7 @@ function getFileName({
   const prefix = isUser ? `${appName}/${userId}/user/${cleanFilename}` : `${appName}/${userId}/${sessionId}/${cleanFilename}`;
   return version !== void 0 ? `${prefix}/${version}` : prefix;
 }
+__name(getFileName, "getFileName");
 function extractArtifactKeys(files, fileNamePrefix, keyPrefix = "") {
   const keys = /* @__PURE__ */ new Set();
   for (const file of files) {
@@ -229,6 +274,7 @@ function extractArtifactKeys(files, fileNamePrefix, keyPrefix = "") {
   }
   return [...keys];
 }
+__name(extractArtifactKeys, "extractArtifactKeys");
 function getFileNameFromPath(filePath) {
   const parts = filePath.split("/");
   if (parts.length < 2) {
@@ -236,6 +282,7 @@ function getFileNameFromPath(filePath) {
   }
   return parts.slice(0, -1).join("/");
 }
+__name(getFileNameFromPath, "getFileNameFromPath");
 export {
   GcsArtifactService
 };

package/dist/esm/artifacts/in_memory_artifact_service.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -9,7 +11,8 @@ import { logger } from "../utils/logger.js";
 function isInMemoryConnectionString(uri) {
   return uri === "memory://";
 }
-class InMemoryArtifactService {
+__name(isInMemoryConnectionString, "isInMemoryConnectionString");
+const _InMemoryArtifactService = class _InMemoryArtifactService {
   constructor() {
     this.artifacts = {};
   }
@@ -145,19 +148,24 @@ class InMemoryArtifactService {
     }
     return Promise.resolve(void 0);
   }
-}
+};
+__name(_InMemoryArtifactService, "InMemoryArtifactService");
+let InMemoryArtifactService = _InMemoryArtifactService;
 function artifactPath(appName, userId, sessionId, filename) {
   if (fileHasUserNamespace(filename)) {
     return `${artifactPrefix("user", appName, userId)}${encodeURIComponent(filename)}`;
   }
   return `${artifactPrefix("session", appName, userId, sessionId)}${encodeURIComponent(filename)}`;
 }
+__name(artifactPath, "artifactPath");
 function artifactPrefix(scope, ...parts) {
   return `${[scope, ...parts].map(encodeURIComponent).join("/")}/`;
 }
+__name(artifactPrefix, "artifactPrefix");
 function fileHasUserNamespace(filename) {
   return filename.startsWith("user:");
 }
+__name(fileHasUserNamespace, "fileHasUserNamespace");
 export {
   InMemoryArtifactService,
   isInMemoryConnectionString

package/dist/esm/artifacts/registry.js

@@ -1,10 +1,13 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { redactUriPassword } from "../utils/redact_uri.js";
 import { FileArtifactService } from "./file_artifact_service.js";
 import { GcsArtifactService } from "./gcs_artifact_service.js";
 import {
@@ -23,8 +26,11 @@ function getArtifactServiceFromUri(uri) {
     const rootDir = uri.split("://")[1];
     return new FileArtifactService(rootDir);
   }
-  throw new Error(`Unsupported artifact service URI: ${uri}`);
+  throw new Error(
+    `Unsupported artifact service URI: ${redactUriPassword(uri)}`
+  );
 }
+__name(getArtifactServiceFromUri, "getArtifactServiceFromUri");
 export {
   getArtifactServiceFromUri
 };

package/dist/esm/artifacts/scoped_artifact_service.js

@@ -1,16 +1,27 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class ScopedArtifactService {
+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({
@@ -67,7 +78,9 @@ class ScopedArtifactService {
       ...request
     });
   }
-}
+};
+__name(_ScopedArtifactService, "ScopedArtifactService");
+let ScopedArtifactService = _ScopedArtifactService;
 export {
   ScopedArtifactService
 };

package/dist/esm/artifacts/session_artifact_service.js

@@ -1,7 +1,19 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @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");
+export {
+  isSessionArtifactService
+};

package/dist/esm/auth/auth_handler.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -7,7 +9,12 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { randomUUID } from "../utils/env_aware_utils.js";
 import { OAuth2CredentialExchanger } from "./oauth2/oauth2_credential_exchanger.js";
-class AuthHandler {
+import {
+  createS256CodeChallenge,
+  generateCodeVerifier
+} from "./oauth2/oauth2_utils.js";
+const S256_CODE_CHALLENGE_METHOD = "S256";
+const _AuthHandler = class _AuthHandler {
   constructor(authConfig) {
     this.authConfig = authConfig;
   }
@@ -15,7 +22,16 @@ 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)) {
@@ -71,9 +87,14 @@ 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;
@@ -81,6 +102,13 @@ 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) {
@@ -105,27 +133,42 @@ class AuthHandler {
     }
     const state = 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 = generateCodeVerifier();
+      url.searchParams.set(
+        "code_challenge",
+        createS256CodeChallenge(codeVerifier)
+      );
+      url.searchParams.set("code_challenge_method", codeChallengeMethod);
+    }
     const exchangedAuthCredential = {
       ...authCredential,
       oauth2: {
-        ...authCredential.oauth2,
+        ...oauth2,
         authUri: url.toString(),
-        state
+        state,
+        codeVerifier
       }
     };
     return exchangedAuthCredential;
   }
-}
+};
+__name(_AuthHandler, "AuthHandler");
+let AuthHandler = _AuthHandler;
 export {
   AuthHandler
 };