@google/adk 1.3.0 → 1.5.0

package/dist/web/agents/routed_agent.js

@@ -102,6 +102,29 @@ let RoutedAgent = class extends (_b = BaseAgent, _a = ROUTED_AGENT_SIGNATURE_SYM
     }
     this.router = config.router;
   }
+  /**
+   * Creates a detached copy of this routed agent.
+   *
+   * The inherited {@link BaseAgent.clone} only deep-clones `subAgents`, but a
+   * `RoutedAgent` derives its routing targets from `config.agents`. Rebuilding
+   * through the base clone alone would re-read the already-parented original
+   * agents and throw "already has a parent agent". This override deep-clones the
+   * routing targets (unless the caller overrides `agents`) so the rebuilt
+   * constructor re-parents fresh, detached copies. The array-vs-record shape
+   * and, for records, the keys are preserved so the router keeps selecting the
+   * same targets.
+   *
+   * @param overrides Config fields to override on the clone. Overriding
+   *     `parentAgent` is rejected by the base implementation.
+   * @returns A new detached `RoutedAgent` of the same concrete class.
+   */
+  clone(overrides) {
+    const nextOverrides = __spreadValues({}, overrides);
+    if (!("agents" in nextOverrides)) {
+      nextOverrides.agents = cloneRoutingTargets(this.config.agents);
+    }
+    return super.clone(nextOverrides);
+  }
   /**
    * Runs the selected agent via text-based conversation.
    */
@@ -132,6 +155,14 @@ let RoutedAgent = class extends (_b = BaseAgent, _a = ROUTED_AGENT_SIGNATURE_SYM
 RoutedAgent = __decorateClass([
   experimental
 ], RoutedAgent);
+function cloneRoutingTargets(agents) {
+  if (Array.isArray(agents)) {
+    return agents.map((agent) => agent.clone());
+  }
+  return Object.fromEntries(
+    Object.entries(agents).map(([key, agent]) => [key, agent.clone()])
+  );
+}
 export {
   RoutedAgent,
   isRoutedAgent

package/dist/web/agents/run_config.js

@@ -1,6 +1,8 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -16,6 +18,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -29,14 +32,16 @@ var StreamingMode = /* @__PURE__ */ ((StreamingMode2) => {
   return StreamingMode2;
 })(StreamingMode || {});
 function createRunConfig(params = {}) {
-  return __spreadValues({
+  var _a;
+  return __spreadProps(__spreadValues({
     saveInputBlobsAsArtifacts: false,
     supportCfc: false,
     enableAffectiveDialog: false,
     streamingMode: "none" /* NONE */,
-    maxLlmCalls: validateMaxLlmCalls(params.maxLlmCalls || 500),
     pauseOnToolCalls: false
-  }, params);
+  }, params), {
+    maxLlmCalls: validateMaxLlmCalls((_a = params.maxLlmCalls) != null ? _a : 500)
+  });
 }
 function validateMaxLlmCalls(value) {
   if (value > Number.MAX_SAFE_INTEGER) {

package/dist/web/apps/app.js

@@ -0,0 +1,49 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+import { isBaseAgent } from "../agents/base_agent.js";
+const VALID_APP_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+function validateAppName(name) {
+  if (!VALID_APP_NAME_RE.test(name)) {
+    throw new Error(
+      "Invalid app name '".concat(name, "': must start with a letter and can only consist of letters, digits, underscores, and hyphens.")
+    );
+  }
+  if (name === "user") {
+    throw new Error("App name cannot be 'user'; reserved for end-user input.");
+  }
+}
+const APP_SIGNATURE_SYMBOL = Symbol.for("google.adk.app");
+function isApp(obj) {
+  return typeof obj === "object" && obj !== null && APP_SIGNATURE_SYMBOL in obj && obj[APP_SIGNATURE_SYMBOL] === true;
+}
+_a = APP_SIGNATURE_SYMBOL;
+class App {
+  constructor(options) {
+    this[_a] = true;
+    var _a2, _b, _c, _d;
+    validateAppName(options.name);
+    if (options.rootAgent === void 0 || options.rootAgent === null) {
+      throw new Error("rootAgent must be provided.");
+    }
+    if (!isBaseAgent(options.rootAgent)) {
+      throw new TypeError(
+        "rootAgent must be a BaseAgent instance, got ".concat((_c = (_b = (_a2 = options.rootAgent) == null ? void 0 : _a2.constructor) == null ? void 0 : _b.name) != null ? _c : typeof options.rootAgent)
+      );
+    }
+    this.name = options.name;
+    this.rootAgent = options.rootAgent;
+    this.plugins = (_d = options.plugins) != null ? _d : [];
+    this.resumabilityConfig = options.resumabilityConfig;
+  }
+}
+export {
+  App,
+  isApp,
+  validateAppName
+};

package/dist/web/apps/resumability_config.js

@@ -0,0 +1,31 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createResumabilityConfig(params = {}) {
+  return __spreadValues({
+    isResumable: false
+  }, params);
+}
+export {
+  createResumabilityConfig
+};

package/dist/web/artifacts/file_artifact_service.js

@@ -43,7 +43,7 @@ class FileArtifactService {
     artifact,
     customMetadata
   }) {
-    if (!artifact.inlineData && !artifact.text) {
+    if (!artifact.inlineData && !artifact.text && !artifact.fileData) {
       throw new Error("Artifact must have either inlineData or text content.");
     }
     const artifactDir = getArtifactDir(
@@ -61,12 +61,19 @@ class FileArtifactService {
     const storedFilename = path.basename(artifactDir);
     const contentPath = path.join(versionDir, storedFilename);
     let mimeType;
+    let fileUri;
     if (artifact.inlineData) {
       const data = artifact.inlineData.data || "";
       await fs.writeFile(contentPath, Buffer.from(data, "base64"));
       mimeType = artifact.inlineData.mimeType || "application/octet-stream";
     } else if (artifact.text !== void 0) {
       await fs.writeFile(contentPath, artifact.text, "utf-8");
+    } else {
+      fileUri = artifact.fileData.fileUri;
+      if (!fileUri) {
+        throw new Error("Artifact fileData must have a fileUri.");
+      }
+      mimeType = artifact.fileData.mimeType;
     }
     const canonicalUri = await getCanonicalUri(
       this.rootDir,
@@ -78,6 +85,7 @@ class FileArtifactService {
     const metadata = {
       fileName: filename,
       mimeType,
+      fileUri,
       version: nextVersion,
       canonicalUri,
       customMetadata
@@ -129,6 +137,11 @@ class FileArtifactService {
       );
       const metadataPath = path.join(versionDir, "metadata.json");
       const metadata = await readMetadata(metadataPath);
+      if (metadata.fileUri) {
+        return {
+          fileData: { fileUri: metadata.fileUri, mimeType: metadata.mimeType }
+        };
+      }
       const storedFilename = path.basename(artifactDir);
       let contentPath = path.join(versionDir, storedFilename);
       if (metadata.canonicalUri) {

package/dist/web/artifacts/gcs_artifact_service.js

@@ -27,12 +27,16 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import { Storage } from "@google-cloud/storage";
 import { createPartFromBase64, createPartFromText } from "@google/genai";
 import { logger } from "../utils/logger.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 {
-  constructor(bucket) {
-    this.bucket = new Storage().bucket(bucket);
+  constructor(bucket, options) {
+    this.bucket = new Storage(options).bucket(bucket);
   }
   async saveArtifact(request) {
-    if (!request.artifact.inlineData && !request.artifact.text) {
+    if (!request.artifact.inlineData && !request.artifact.text && !request.artifact.fileData) {
       throw new Error("Artifact must have either inlineData or text content.");
     }
     const versions = await this.listVersions(request);
@@ -42,24 +46,46 @@ class GcsArtifactService {
         version
       }))
     );
-    const metadata = request.customMetadata || {};
+    const customMetadata = __spreadValues({}, request.customMetadata);
     if (request.artifact.inlineData) {
+      if (request.artifact.inlineData.displayName) {
+        customMetadata[GCS_DISPLAY_NAME_METADATA_KEY] = request.artifact.inlineData.displayName;
+      }
       await file.save(
         Buffer.from(request.artifact.inlineData.data || "", "base64"),
         {
           contentType: request.artifact.inlineData.mimeType,
-          metadata
+          metadata: { metadata: customMetadata }
         }
       );
       return version;
+    } else if (request.artifact.text !== void 0) {
+      await file.save(request.artifact.text, {
+        contentType: "text/plain",
+        metadata: {
+          metadata: __spreadProps(__spreadValues({}, customMetadata), { [GCS_IS_TEXT_METADATA_KEY]: "true" })
+        }
+      });
+      return version;
+    } else {
+      const fileData = request.artifact.fileData;
+      const fileUri = fileData == null ? void 0 : fileData.fileUri;
+      if (!fileUri) {
+        throw new Error("Artifact fileData must have a fileUri.");
+      }
+      customMetadata[GCS_FILE_URI_METADATA_KEY] = fileUri;
+      if (fileData.mimeType) {
+        customMetadata[GCS_FILE_MIME_TYPE_METADATA_KEY] = fileData.mimeType;
+      }
+      await file.save("", {
+        contentType: fileData.mimeType || void 0,
+        metadata: { metadata: customMetadata }
+      });
+      return version;
     }
-    await file.save(request.artifact.text, {
-      contentType: "text/plain",
-      metadata
-    });
-    return version;
   }
   async loadArtifact(request) {
+    var _a, _b, _c;
     try {
       let version = request.version;
       if (version === void 0) {
@@ -74,11 +100,25 @@ class GcsArtifactService {
           version
         }))
       );
-      const [[metadata], [rawDataBuffer]] = await Promise.all([
-        file.getMetadata(),
-        file.download()
-      ]);
-      if (metadata.contentType === "text/plain") {
+      const [metadata] = await file.getMetadata();
+      const customMeta = (_a = metadata.metadata) != null ? _a : {};
+      const fileUri = customMeta[GCS_FILE_URI_METADATA_KEY];
+      if (fileUri) {
+        const mimeType = (_c = (_b = customMeta[GCS_FILE_MIME_TYPE_METADATA_KEY]) != null ? _b : metadata.contentType) != null ? _c : void 0;
+        return { fileData: { fileUri, mimeType } };
+      }
+      const [rawDataBuffer] = await file.download();
+      const displayName = customMeta[GCS_DISPLAY_NAME_METADATA_KEY];
+      if (displayName) {
+        return {
+          inlineData: {
+            data: rawDataBuffer.toString("base64"),
+            mimeType: metadata.contentType,
+            displayName
+          }
+        };
+      }
+      if (customMeta[GCS_IS_TEXT_METADATA_KEY] === "true" || metadata.contentType === "text/plain") {
         return createPartFromText(rawDataBuffer.toString("utf-8"));
       }
       return createPartFromBase64(

package/dist/web/artifacts/in_memory_artifact_service.js

@@ -5,6 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { logger } from "../utils/logger.js";
 function isInMemoryConnectionString(uri) {
   return uri === "memory://";
 }
@@ -20,7 +21,7 @@ class InMemoryArtifactService {
     artifact,
     customMetadata
   }) {
-    if (!artifact.inlineData && !artifact.text) {
+    if (!artifact.inlineData && !artifact.text && !artifact.fileData) {
       return Promise.reject(
         new Error("Artifact must have either inlineData or text content.")
       );
@@ -34,6 +35,10 @@ class InMemoryArtifactService {
       version,
       customMetadata
     };
+    if (!artifact.inlineData && artifact.text === void 0) {
+      const fileData = artifact.fileData;
+      metadata.mimeType = fileData.mimeType;
+    }
     this.artifacts[path].push({ part: artifact, metadata });
     return Promise.resolve(version);
   }
@@ -52,6 +57,12 @@ class InMemoryArtifactService {
     if (version === void 0) {
       version = versions.length - 1;
     }
+    if (!versions[version]) {
+      logger.warn(
+        "[InMemoryArtifactService] loadArtifact: Artifact ".concat(filename, " version ").concat(version, " not found")
+      );
+      return Promise.resolve(void 0);
+    }
     return Promise.resolve(versions[version].part);
   }
   listArtifactKeys({

package/dist/web/artifacts/scoped_artifact_service.js

@@ -0,0 +1,86 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ScopedArtifactService {
+  constructor(delegate, appName, userId, sessionId) {
+    this.delegate = delegate;
+    this.appName = appName;
+    this.userId = userId;
+    this.sessionId = sessionId;
+  }
+  async saveArtifact(request) {
+    return this.delegate.saveArtifact(__spreadValues({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId
+    }, request));
+  }
+  async loadArtifact(request) {
+    return this.delegate.loadArtifact(__spreadValues({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId
+    }, request));
+  }
+  async listArtifactKeys() {
+    return this.delegate.listArtifactKeys({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId
+    });
+  }
+  async deleteArtifact(filename) {
+    return this.delegate.deleteArtifact({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId,
+      filename
+    });
+  }
+  async listVersions(filename) {
+    return this.delegate.listVersions({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId,
+      filename
+    });
+  }
+  async listArtifactVersions(filename) {
+    return this.delegate.listArtifactVersions({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId,
+      filename
+    });
+  }
+  async getArtifactVersion(request) {
+    return this.delegate.getArtifactVersion(__spreadValues({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId
+    }, request));
+  }
+}
+export {
+  ScopedArtifactService
+};

package/dist/web/artifacts/session_artifact_service.js

@@ -0,0 +1,7 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/web/auth/oauth2/oauth2_discovery.js

@@ -55,7 +55,11 @@ class OAuth2DiscoveryManager {
           method: "GET",
           headers: {
             Accept: "application/json"
-          }
+          },
+          // Never follow redirects: validateDiscoveryUrl only checks the
+          // initial URL, so following a 3xx would let a validated host
+          // redirect discovery to a private/cloud-metadata address (CWE-918).
+          redirect: "error"
         });
         if (!response.ok) {
           continue;
@@ -103,7 +107,11 @@ class OAuth2DiscoveryManager {
         method: "GET",
         headers: {
           Accept: "application/json"
-        }
+        },
+        // Never follow redirects: validateDiscoveryUrl only checks the
+        // initial URL, so following a 3xx would let a validated host
+        // redirect discovery to a private/cloud-metadata address (CWE-918).
+        redirect: "error"
       });
       if (!response.ok) {
         return void 0;
@@ -143,7 +151,7 @@ function validateDiscoveryUrl(urlStr) {
       return false;
     }
     const host = normaliseHostname(url.hostname.toLowerCase());
-    if (host === "localhost" || host === "metadata.google.internal" || host === "metadata.goog" || host.startsWith("127.") || host === "[::1]" || host === "0.0.0.0" || host.startsWith("10.") || host.startsWith("192.168.") || host.startsWith("169.254.")) {
+    if (host === "localhost" || host === "metadata.google.internal" || host === "metadata.goog" || host.startsWith("127.") || host === "[::1]" || host === "[::]" || host === "0.0.0.0" || host.startsWith("10.") || host.startsWith("192.168.") || host.startsWith("169.254.")) {
       logger.warn("Unsafe host for discovery URL: ".concat(host));
       return false;
     }
@@ -176,5 +184,7 @@ function validateDiscoveryUrl(urlStr) {
 export {
   AuthorizationServerMetadataSchema,
   OAuth2DiscoveryManager,
-  ProtectedResourceMetadataSchema
+  ProtectedResourceMetadataSchema,
+  normaliseHostname,
+  validateDiscoveryUrl
 };

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

@@ -6,6 +6,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * SPDX-License-Identifier: Apache-2.0
  */
 import { logger } from "../../utils/logger.js";
+import { validateDiscoveryUrl } from "./oauth2_discovery.js";
 function getTokenEndpoint(authScheme) {
   if (authScheme.type === "openIdConnect" && authScheme.tokenEndpoint) {
     return authScheme.tokenEndpoint;
@@ -20,13 +21,23 @@ function getTokenEndpoint(authScheme) {
   return void 0;
 }
 async function fetchOAuth2Tokens(endpoint, body) {
+  if (!validateDiscoveryUrl(endpoint)) {
+    throw new Error(
+      "SSRF protection: OAuth2 token endpoint '".concat(endpoint, "' is not allowed. Must use HTTPS and must not target private/loopback/cloud-metadata addresses.")
+    );
+  }
   try {
     const response = await fetch(endpoint, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: body.toString()
+      body: body.toString(),
+      // Never follow redirects: the SSRF blocklist only validates `endpoint`,
+      // so a validated host that responds with a 3xx could otherwise redirect
+      // this credential-bearing POST (client_secret/refresh_token) to a
+      // private/cloud-metadata address (CWE-918).
+      redirect: "error"
     });
     if (!response.ok) {
       throw new Error("Token request failed with status ".concat(response.status));