@google/adk 1.2.0 → 1.4.0

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

@@ -24,6 +24,13 @@ var __asyncGenerator = (__this, __arguments, generator) => {
 import { appendInstructions } from "../../models/llm_request.js";
 import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
 class IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
+  /**
+   * Appends agent name and description as identity instructions to the system
+   * prompt of the request.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request object to append instructions to.
+   */
   // eslint-disable-next-line require-yield
   runAsync(invocationContext, llmRequest) {
     return __asyncGenerator(this, null, function* () {

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

@@ -64,6 +64,11 @@ class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
         }
         appendInstructions(llmRequest, [instructionWithState]);
       }
+      if (agent.outputSchema && agent.tools && agent.tools.length > 0) {
+        appendInstructions(llmRequest, [
+          'To output the final result, you must call the "set_model_response" function with the appropriate values. Do not output anything else.'
+        ]);
+      }
     });
   }
 }

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

@@ -0,0 +1,52 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+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 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isGemini } from "../../models/google_llm.js";
+import { isLlmAgent } from "../llm_agent.js";
+class InteractionsRequestProcessor {
+  // eslint-disable-next-line require-yield
+  runAsync(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      const agent = invocationContext.agent;
+      if (!agent || !isLlmAgent(agent)) {
+        return;
+      }
+      const model = agent.canonicalModel;
+      if (isGemini(model) && model.useInteractionsApi) {
+        const events = invocationContext.session.events;
+        for (let i = events.length - 1; i >= 0; i--) {
+          const event = events[i];
+          if (event.branch === invocationContext.branch && event.author === agent.name && event.interactionId) {
+            llmRequest.previousInteractionId = event.interactionId;
+            break;
+          }
+        }
+      }
+    });
+  }
+}
+const INTERACTIONS_REQUEST_PROCESSOR = new InteractionsRequestProcessor();
+export {
+  INTERACTIONS_REQUEST_PROCESSOR,
+  InteractionsRequestProcessor
+};

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

@@ -34,7 +34,15 @@ 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. */
+  /**
+   * Resumes tool calls that were paused for user confirmation, re-invoking
+   * them with the confirmed or denied decision before the next LLM turn.
+   *
+   * @param invocationContext - The current invocation context, including the
+   *   session event history used to locate pending confirmation responses.
+   * @yields Function response events for tools that have been confirmed and
+   *   are ready to resume.
+   */
   runAsync(invocationContext) {
     return __asyncGenerator(this, null, function* () {
       const agent = invocationContext.agent;

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

@@ -26,7 +26,13 @@ import { isLlmAgent } from "../llm_agent.js";
 import { ReadonlyContext } from "../readonly_context.js";
 import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
 class ToolFilterRequestProcessor extends BaseLlmRequestProcessor {
-  /** Filters the set of tools on the request based on plugins. */
+  /**
+   * Invokes plugin-based tool filtering and updates {@link LlmRequest.allowedTools}
+   * with the reduced tool set if any plugin returns a filtered result.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request whose allowed tools may be restricted.
+   */
   // eslint-disable-next-line require-yield
   runAsync(invocationContext, llmRequest) {
     return __asyncGenerator(this, null, function* () {

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

@@ -20,7 +20,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 +34,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);
   }

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/auth_preprocessor.js

@@ -33,6 +33,7 @@ import {
   getFunctionResponses
 } from "../events/event.js";
 import { State } from "../sessions/state.js";
+import { camelCaseKeys } from "../utils/case_utils.js";
 import { AuthHandler } from "./auth_handler.js";
 const TOOLSET_AUTH_CREDENTIAL_ID_PREFIX = "_adk_toolset_auth_";
 async function storeAuthAndCollectResumeTargets(events, authFcIds, authResponses, state) {
@@ -41,17 +42,15 @@ async function storeAuthAndCollectResumeTargets(events, authFcIds, authResponses
     const eventFunctionCalls = getFunctionCalls(event);
     for (const functionCall of eventFunctionCalls) {
       if (functionCall.id && authFcIds.has(functionCall.id) && functionCall.name === REQUEST_EUC_FUNCTION_CALL_NAME) {
-        const args = functionCall.args;
-        if (args && args.authConfig) {
-          requestedAuthConfigById[functionCall.id] = args.authConfig;
+        const args = camelCaseKeys(functionCall.args);
+        const authConfig = args == null ? void 0 : args.authConfig;
+        if (authConfig) {
+          requestedAuthConfigById[functionCall.id] = authConfig;
         }
       }
     }
   }
   for (const fcId of authFcIds) {
-    if (!(fcId in authResponses)) {
-      continue;
-    }
     const authConfig = authResponses[fcId];
     const requestedAuthConfig = requestedAuthConfigById[fcId];
     if (requestedAuthConfig && requestedAuthConfig.credentialKey) {
@@ -69,12 +68,15 @@ async function storeAuthAndCollectResumeTargets(events, authFcIds, authResponses
       const eventFunctionCalls = getFunctionCalls(event);
       for (const functionCall of eventFunctionCalls) {
         if (functionCall.id === fcId && functionCall.name === REQUEST_EUC_FUNCTION_CALL_NAME) {
-          const args = functionCall.args;
-          if (args && args.functionCallId) {
-            if (args.functionCallId.startsWith(TOOLSET_AUTH_CREDENTIAL_ID_PREFIX)) {
+          const args = camelCaseKeys(
+            functionCall.args
+          );
+          const functionCallId = args == null ? void 0 : args.functionCallId;
+          if (functionCallId) {
+            if (functionCallId.startsWith(TOOLSET_AUTH_CREDENTIAL_ID_PREFIX)) {
               continue;
             }
-            toolsToResume.add(args.functionCallId);
+            toolsToResume.add(functionCallId);
           }
         }
       }

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 === "127.0.0.1" || 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));

package/dist/web/code_executors/code_executor_context.js

@@ -70,7 +70,7 @@ class CodeExecutorContext {
    * @return A list of input files in the code executor context.
    */
   getInputFiles() {
-    if (!(INPUT_FILE_KEY in this.sessionState)) {
+    if (!this.sessionState.has(INPUT_FILE_KEY)) {
       return [];
     }
     return this.sessionState.get(INPUT_FILE_KEY);
@@ -80,13 +80,13 @@ class CodeExecutorContext {
    * @param inputFiles The input files to add to the session state.
    */
   addInputFiles(inputFiles) {
-    if (!(INPUT_FILE_KEY in this.sessionState)) {
+    if (!this.sessionState.has(INPUT_FILE_KEY)) {
       this.sessionState.set(INPUT_FILE_KEY, []);
     }
     this.sessionState.get(INPUT_FILE_KEY).push(...inputFiles);
   }
   clearInputFiles() {
-    if (INPUT_FILE_KEY in this.sessionState) {
+    if (this.sessionState.has(INPUT_FILE_KEY)) {
       this.sessionState.set(INPUT_FILE_KEY, []);
     }
     if (PROCESSED_FILE_NAMES_KEY in this.context) {
@@ -99,7 +99,7 @@ class CodeExecutorContext {
    * @return The error count for the given invocation ID.
    */
   getErrorCount(invocationId) {
-    if (!(ERROR_COUNT_KEY in this.sessionState)) {
+    if (!this.sessionState.has(ERROR_COUNT_KEY)) {
       return 0;
     }
     return this.sessionState.get(ERROR_COUNT_KEY)[invocationId] || 0;
@@ -109,7 +109,7 @@ class CodeExecutorContext {
    * @param invocationId The invocation ID to increment the error count for.
    */
   incrementErrorCount(invocationId) {
-    if (!(ERROR_COUNT_KEY in this.sessionState)) {
+    if (!this.sessionState.has(ERROR_COUNT_KEY)) {
       this.sessionState.set(ERROR_COUNT_KEY, {});
     }
     this.sessionState.get(ERROR_COUNT_KEY)[invocationId] = this.getErrorCount(invocationId) + 1;
@@ -119,7 +119,7 @@ class CodeExecutorContext {
    * @param invocationId The invocation ID to reset the error count for.
    */
   resetErrorCount(invocationId) {
-    if (!(ERROR_COUNT_KEY in this.sessionState)) {
+    if (!this.sessionState.has(ERROR_COUNT_KEY)) {
       return;
     }
     const errorCounts = this.sessionState.get(ERROR_COUNT_KEY);
@@ -141,7 +141,7 @@ class CodeExecutorContext {
     resultStdout,
     resultStderr
   }) {
-    if (!(CODE_EXECUTION_RESULTS_KEY in this.sessionState)) {
+    if (!this.sessionState.has(CODE_EXECUTION_RESULTS_KEY)) {
       this.sessionState.set(CODE_EXECUTION_RESULTS_KEY, {});
     }
     const codeExecutionResults = this.sessionState.get(