@google/adk 1.6.0 → 2.1.0

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

@@ -1,190 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { z } from "zod";
-import { logger } from "../../utils/logger.js";
-const AuthorizationServerMetadataSchema = z.object({
-  issuer: z.string(),
-  authorization_endpoint: z.string(),
-  token_endpoint: z.string(),
-  scopes_supported: z.array(z.string()).optional(),
-  registration_endpoint: z.string().optional()
-});
-const ProtectedResourceMetadataSchema = z.object({
-  resource: z.string(),
-  authorization_servers: z.array(z.string()).default([])
-});
-class OAuth2DiscoveryManager {
-  /**
-   * Discovers the OAuth2 authorization server metadata.
-   */
-  async discoverAuthServerMetadata(issuerUrl) {
-    if (!validateDiscoveryUrl(issuerUrl)) {
-      return void 0;
-    }
-    let baseUrl;
-    let path;
-    try {
-      const url = new URL(issuerUrl);
-      baseUrl = "".concat(url.protocol, "//").concat(url.host);
-      path = url.pathname;
-    } catch (e) {
-      logger.warn("Failed to parse issuerUrl ".concat(issuerUrl, ": ").concat(e));
-      return void 0;
-    }
-    const endpointsToTry = [];
-    if (path && path !== "/") {
-      endpointsToTry.push(
-        "".concat(baseUrl, "/.well-known/oauth-authorization-server").concat(path),
-        "".concat(baseUrl, "/.well-known/openid-configuration").concat(path),
-        "".concat(baseUrl).concat(path, "/.well-known/openid-configuration")
-      );
-    } else {
-      endpointsToTry.push(
-        "".concat(baseUrl, "/.well-known/oauth-authorization-server"),
-        "".concat(baseUrl, "/.well-known/openid-configuration")
-      );
-    }
-    for (const endpoint of endpointsToTry) {
-      try {
-        const response = await fetch(endpoint, {
-          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;
-        }
-        const data = await response.json();
-        const metadata = AuthorizationServerMetadataSchema.parse(data);
-        if (metadata.issuer.replace(/\/$/, "") === issuerUrl.replace(/\/$/, "")) {
-          return metadata;
-        } else {
-          logger.warn(
-            "Issuer in metadata ".concat(metadata.issuer, " does not match issuerUrl ").concat(issuerUrl)
-          );
-        }
-      } catch (e) {
-        logger.debug("Failed to fetch metadata from ".concat(endpoint, ": ").concat(e));
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Discovers the OAuth2 protected resource metadata.
-   */
-  async discoverResourceMetadata(resourceUrl) {
-    if (!validateDiscoveryUrl(resourceUrl)) {
-      return void 0;
-    }
-    let baseUrl;
-    let path;
-    try {
-      const url = new URL(resourceUrl);
-      baseUrl = "".concat(url.protocol, "//").concat(url.host);
-      path = url.pathname;
-    } catch (e) {
-      logger.warn("Failed to parse resourceUrl ".concat(resourceUrl, ": ").concat(e));
-      return void 0;
-    }
-    let wellKnownEndpoint;
-    if (path && path !== "/") {
-      wellKnownEndpoint = "".concat(baseUrl, "/.well-known/oauth-protected-resource").concat(path);
-    } else {
-      wellKnownEndpoint = "".concat(baseUrl, "/.well-known/oauth-protected-resource");
-    }
-    try {
-      const response = await fetch(wellKnownEndpoint, {
-        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;
-      }
-      const data = await response.json();
-      const metadata = ProtectedResourceMetadataSchema.parse(data);
-      if (metadata.resource.replace(/\/$/, "") === resourceUrl.replace(/\/$/, "")) {
-        return metadata;
-      } else {
-        logger.warn(
-          "Resource in metadata ".concat(metadata.resource, " does not match resourceUrl ").concat(resourceUrl)
-        );
-      }
-    } catch (e) {
-      logger.debug("Failed to fetch metadata from ".concat(wellKnownEndpoint, ": ").concat(e));
-    }
-    return void 0;
-  }
-}
-function normaliseHostname(raw) {
-  const stripped = raw.replace(/^\[|\]$/g, "");
-  const m = stripped.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
-  if (m) {
-    const hi = parseInt(m[1], 16);
-    const lo = parseInt(m[2], 16);
-    return [hi >> 8 & 255, hi & 255, lo >> 8 & 255, lo & 255].join(".");
-  }
-  const mDot = stripped.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
-  if (mDot) return mDot[1];
-  return raw;
-}
-function validateDiscoveryUrl(urlStr) {
-  try {
-    const url = new URL(urlStr);
-    if (url.protocol !== "https:") {
-      logger.warn("Unsafe protocol for discovery URL: ".concat(url.protocol));
-      return false;
-    }
-    const host = normaliseHostname(url.hostname.toLowerCase());
-    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;
-    }
-    const match = host.match(/^172\.(\d+)\./);
-    if (match) {
-      const secondOctet = parseInt(match[1], 10);
-      if (secondOctet >= 16 && secondOctet <= 31) {
-        logger.warn("Unsafe host for discovery URL: ".concat(host));
-        return false;
-      }
-    }
-    const cgnatMatch = host.match(/^100\.(\d+)\./);
-    if (cgnatMatch) {
-      const secondOctet = parseInt(cgnatMatch[1], 10);
-      if (secondOctet >= 64 && secondOctet <= 127) {
-        logger.warn("Unsafe host for discovery URL: ".concat(host));
-        return false;
-      }
-    }
-    if (/^\[(f[cd][0-9a-f]{2}|fe[89ab][0-9a-f]):/i.test(url.hostname)) {
-      logger.warn("Unsafe host for discovery URL: ".concat(url.hostname));
-      return false;
-    }
-    return true;
-  } catch (e) {
-    logger.warn("Failed to parse URL for validation ".concat(urlStr, ": ").concat(e));
-    return false;
-  }
-}
-export {
-  AuthorizationServerMetadataSchema,
-  OAuth2DiscoveryManager,
-  ProtectedResourceMetadataSchema,
-  normaliseHostname,
-  validateDiscoveryUrl
-};

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

@@ -1,98 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2026 Google LLC
- * 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;
-  }
-  if (authScheme.type === "oauth2" && authScheme.flows) {
-    const flows = authScheme.flows;
-    const flow = flows.authorizationCode || flows.clientCredentials || flows.password || flows.implicit;
-    if (flow && "tokenUrl" in flow) {
-      return flow.tokenUrl;
-    }
-  }
-  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(),
-      // 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));
-    }
-    const data = await response.json();
-    return {
-      accessToken: data.access_token,
-      refreshToken: data.refresh_token,
-      idToken: data.id_token,
-      expiresIn: data.expires_in,
-      expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
-    };
-  } catch (e) {
-    logger.error("Failed to fetch OAuth2 tokens: ".concat(e));
-    throw e;
-  }
-}
-function parseAuthorizationCode(uri) {
-  try {
-    const url = new URL(uri);
-    return url.searchParams.get("code") || void 0;
-  } catch (e) {
-    logger.warn("Failed to parse authorization URI ".concat(uri, ": ").concat(e));
-    return void 0;
-  }
-}
-function createOAuth2TokenRequestBody(params) {
-  const body = new URLSearchParams();
-  body.set("grant_type", params.grantType);
-  body.set("client_id", params.clientId);
-  body.set("client_secret", params.clientSecret);
-  if (params.grantType === "authorization_code") {
-    body.set("code", params.code);
-    if (params.redirectUri) {
-      body.set("redirect_uri", params.redirectUri);
-    }
-    if (params.codeVerifier) {
-      body.set("code_verifier", params.codeVerifier);
-    }
-  } else if (params.grantType === "refresh_token") {
-    body.set("refresh_token", params.refreshToken);
-  }
-  return body;
-}
-function isTokenExpired(token, leeway = 60) {
-  if (typeof token.expiresAt !== "number") {
-    return false;
-  }
-  const expirationThreshold = token.expiresAt - leeway * 1e3;
-  return expirationThreshold < Date.now();
-}
-export {
-  createOAuth2TokenRequestBody,
-  fetchOAuth2Tokens,
-  getTokenEndpoint,
-  isTokenExpired,
-  parseAuthorizationCode
-};

package/dist/web/auth/refresher/base_credential_refresher.js

@@ -1,16 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-class CredentialRefresherError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CredentialRefresherError";
-  }
-}
-export {
-  CredentialRefresherError
-};

package/dist/web/auth/refresher/credential_refresher_registry.js

@@ -1,40 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { AuthCredentialTypes } from "../auth_credential.js";
-class CredentialRefresherRegistry {
-  constructor() {
-    this.refreshers = {
-      [AuthCredentialTypes.API_KEY]: void 0,
-      [AuthCredentialTypes.HTTP]: void 0,
-      [AuthCredentialTypes.OAUTH2]: void 0,
-      [AuthCredentialTypes.OPEN_ID_CONNECT]: void 0,
-      [AuthCredentialTypes.SERVICE_ACCOUNT]: void 0
-    };
-  }
-  /**
-   * Register a refresher instance for a credential type.
-   *
-   * @param credentialType The credential type to register for.
-   * @param refresherInstance The refresher instance to register.
-   */
-  register(credentialType, refresherInstance) {
-    this.refreshers[credentialType] = refresherInstance;
-  }
-  /**
-   * Get the refresher instance for a credential type.
-   *
-   * @param credentialType The credential type to get refresher for.
-   * @returns The refresher instance if registered, undefined otherwise.
-   */
-  getRefresher(credentialType) {
-    return this.refreshers[credentialType];
-  }
-}
-export {
-  CredentialRefresherRegistry
-};

package/dist/web/code_executors/agent_engine_sandbox_code_executor.js

@@ -1,281 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-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;
-};
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Client } from "@google-cloud/vertexai";
-import { Language } from "@google-cloud/vertexai/build/src/genai/types.js";
-import { experimental } from "../utils/experimental.js";
-import { guessMimeType } from "../utils/file_utils.js";
-const SANDBOX_PATTERN = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)\/sandboxEnvironments\/(\d+)$/;
-const ENGINE_PATTERN = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)$/;
-import { logger } from "../utils/logger.js";
-import { BaseCodeExecutor } from "./base_code_executor.js";
-import {
-  CodeExecutionLanguage
-} from "./code_execution_utils.js";
-const DEFAULT_MAX_ATTEMPTS = 180;
-const DEFAULT_SANDBOX_TTL = "31536000s";
-const DEFAULT_SANDBOX_DISPLAY_NAME = "default_sandbox";
-const DEFAULT_ENGINE_DISPLAY_NAME = "default_engine";
-function mapLanguage(lang) {
-  switch (lang) {
-    case CodeExecutionLanguage.PYTHON:
-      return Language.LANGUAGE_PYTHON;
-    case CodeExecutionLanguage.JAVASCRIPT:
-      return Language.LANGUAGE_JAVASCRIPT;
-    default:
-      throw new Error("Unsupported language for Agent Engine Sandbox: ".concat(lang));
-  }
-}
-let AgentEngineSandboxCodeExecutor = class extends BaseCodeExecutor {
-  constructor(options = {}) {
-    super();
-    this.sandboxResourceName = options.sandboxResourceName;
-    this.agentEngineResourceName = options.agentEngineResourceName;
-    this.projectId = options.projectId || process.env.GOOGLE_CLOUD_PROJECT;
-    this.location = options.location || process.env.GOOGLE_CLOUD_LOCATION || "us-central1";
-    if (this.sandboxResourceName) {
-      const match = this.sandboxResourceName.match(SANDBOX_PATTERN);
-      if (match) {
-        this.projectId = match[1];
-        this.location = match[2];
-      } else {
-        throw new Error(
-          "Invalid sandbox resource name: ".concat(this.sandboxResourceName)
-        );
-      }
-    } else if (this.agentEngineResourceName) {
-      const match = this.agentEngineResourceName.match(ENGINE_PATTERN);
-      if (match) {
-        this.projectId = match[1];
-        this.location = match[2];
-      } else {
-        throw new Error(
-          "Invalid agent engine resource name: ".concat(this.agentEngineResourceName)
-        );
-      }
-    }
-    if (options.client) {
-      this.client = options.client;
-    } else {
-      if (!this.projectId) {
-        throw new Error("Project ID is required.");
-      }
-      this.client = new Client({
-        project: this.projectId,
-        location: this.location
-      });
-    }
-  }
-  async executeCode(params) {
-    var _a;
-    const { invocationContext, codeExecutionInput } = params;
-    const language = mapLanguage(codeExecutionInput.language);
-    const agentEngineName = await this.getOrCreateAgentEngine();
-    const sandboxName = await this.getOrCreateSandbox(
-      invocationContext,
-      agentEngineName,
-      language
-    );
-    const inputs = [
-      {
-        mimeType: "application/json",
-        data: Buffer.from(
-          JSON.stringify({ code: codeExecutionInput.code })
-        ).toString("base64")
-      }
-    ];
-    if (codeExecutionInput.inputFiles) {
-      for (const file of codeExecutionInput.inputFiles) {
-        inputs.push({
-          mimeType: file.mimeType,
-          data: file.content,
-          // Assumed to be already base64 encoded based on CodeExecutionInput definition
-          metadata: {
-            attributes: {
-              file_name: Buffer.from(file.name).toString("base64")
-            }
-          }
-        });
-      }
-    }
-    logger.debug("Executing code in sandbox ".concat(sandboxName, "..."));
-    const response = await this.client.agentEnginesInternal.sandboxes.executeCodeInternal({
-      name: sandboxName,
-      inputs
-    });
-    let stdout = "";
-    let stderr = "";
-    const outputFiles = [];
-    if (response.outputs) {
-      for (const output of response.outputs) {
-        const attributes = ((_a = output.metadata) == null ? void 0 : _a.attributes) || {};
-        const encodedFileName = attributes["file_name"];
-        const fileName = encodedFileName ? Buffer.from(encodedFileName, "base64").toString("utf-8") : void 0;
-        if (output.mimeType === "application/json" && !fileName) {
-          if (output.data) {
-            const jsonStr = Buffer.from(output.data, "base64").toString(
-              "utf-8"
-            );
-            try {
-              const jsonData = JSON.parse(jsonStr);
-              if (jsonData.msg_out !== void 0) {
-                stdout = jsonData.msg_out;
-              } else {
-                stdout = "";
-              }
-              if (jsonData.msg_err !== void 0) {
-                stderr = jsonData.msg_err;
-              } else {
-                stderr = "";
-              }
-            } catch (e) {
-              logger.warn("Failed to parse JSON output from sandbox", e);
-              stdout = jsonStr;
-            }
-          }
-        } else {
-          let mimeType = output.mimeType;
-          const name = fileName || "output_file";
-          if (!mimeType) {
-            mimeType = guessMimeType(name);
-          }
-          outputFiles.push({
-            name,
-            content: output.data || "",
-            mimeType
-          });
-        }
-      }
-    }
-    return {
-      stdout,
-      stderr,
-      outputFiles
-    };
-  }
-  async getOrCreateAgentEngine() {
-    if (this.agentEngineResourceName) {
-      return this.agentEngineResourceName;
-    }
-    if (!this.agentEngineCreationPromise) {
-      this.agentEngineCreationPromise = (async () => {
-        logger.debug(
-          "No Agent Engine resource name provided. Creating a new one..."
-        );
-        const operation = await this.client.agentEnginesInternal.createInternal(
-          {
-            config: {
-              displayName: DEFAULT_ENGINE_DISPLAY_NAME
-            }
-          }
-        );
-        let apiResponse = operation;
-        let attempts = 0;
-        while (!apiResponse.done && attempts < DEFAULT_MAX_ATTEMPTS) {
-          await new Promise((resolve) => setTimeout(resolve, 1e3));
-          apiResponse = await this.client.agentEnginesInternal.getAgentOperationInternal({
-            operationName: operation.name
-          });
-          attempts++;
-        }
-        if (!apiResponse.done) {
-          throw new Error(
-            "Agent Engine creation operation ".concat(operation.name, " did not complete in time.")
-          );
-        }
-        const response = apiResponse.response;
-        this.agentEngineResourceName = response.name;
-        logger.debug("Created Agent Engine: ".concat(this.agentEngineResourceName));
-        return this.agentEngineResourceName;
-      })();
-    }
-    return this.agentEngineCreationPromise;
-  }
-  async getOrCreateSandbox(invocationContext, agentEngineName, language) {
-    var _a, _b;
-    if (this.sandboxResourceName) {
-      return this.sandboxResourceName;
-    }
-    const stateKey = "sandbox_name_".concat(language.toLowerCase());
-    let sandboxName = (_b = (_a = invocationContext.session) == null ? void 0 : _a.state) == null ? void 0 : _b[stateKey];
-    let createNewSandbox = false;
-    if (!sandboxName) {
-      createNewSandbox = true;
-    } else {
-      try {
-        const sandbox = await this.client.agentEnginesInternal.sandboxes.getInternal({
-          name: sandboxName
-        });
-        if (!sandbox || sandbox.state !== "STATE_RUNNING") {
-          createNewSandbox = true;
-        }
-      } catch (error) {
-        logger.debug(
-          "Failed to get sandbox ".concat(sandboxName, ", will create a new one"),
-          error
-        );
-        createNewSandbox = true;
-      }
-    }
-    if (createNewSandbox) {
-      logger.debug("Creating a new ".concat(language, " code execution sandbox..."));
-      const operation = await this.client.agentEnginesInternal.sandboxes.createInternal({
-        name: agentEngineName,
-        spec: {
-          codeExecutionEnvironment: {
-            codeLanguage: language
-          }
-        },
-        config: {
-          displayName: DEFAULT_SANDBOX_DISPLAY_NAME,
-          ttl: DEFAULT_SANDBOX_TTL
-        }
-      });
-      let apiResponse = operation;
-      let attempts = 0;
-      while (!apiResponse.done && attempts < DEFAULT_MAX_ATTEMPTS) {
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-        apiResponse = await this.client.agentEnginesInternal.sandboxes.getSandboxOperationInternal(
-          {
-            operationName: operation.name
-          }
-        );
-        attempts++;
-      }
-      if (!apiResponse.done) {
-        throw new Error(
-          "Sandbox creation operation ".concat(operation.name, " did not complete in time.")
-        );
-      }
-      const response = apiResponse.response;
-      sandboxName = response.name;
-      if (invocationContext.session) {
-        if (!invocationContext.session.state) {
-          invocationContext.session.state = {};
-        }
-        invocationContext.session.state[stateKey] = sandboxName;
-      }
-    }
-    return sandboxName;
-  }
-};
-AgentEngineSandboxCodeExecutor = __decorateClass([
-  experimental
-], AgentEngineSandboxCodeExecutor);
-export {
-  AgentEngineSandboxCodeExecutor
-};

package/dist/web/code_executors/base_code_executor.js

@@ -1,63 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-var _a;
-const BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL = Symbol.for(
-  "google.adk.baseCodeExecutor"
-);
-function isBaseCodeExecutor(obj) {
-  return typeof obj === "object" && obj !== null && BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL in obj && obj[BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL] === true;
-}
-_a = BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL;
-class BaseCodeExecutor {
-  constructor() {
-    /** A unique symbol to identify BaseCodeExecutor class. */
-    this[_a] = true;
-    /**
-     * If true, extract and process data files from the model request
-     * and attach them to the code executor.
-     *
-     * Supported data file MimeTypes are [text/csv].
-     * Default to false.
-     */
-    this.optimizeDataFile = false;
-    /**
-     * Whether the code executor is stateful. Default to false.
-     */
-    this.stateful = false;
-    /**
-     * The number of attempts to retry on consecutive code execution errors.
-     * Default to 2.
-     */
-    this.errorRetryAttempts = 2;
-    /**
-     * The list of the enclosing delimiters to identify the code blocks.
-     * For example, the delimiter('```javascript\\n', '\\n```') can be used to
-     * identify code blocks with the following format:
-     *
-     * ```javascript
-     *  console.log("hello")
-     * ```
-     */
-    this.codeBlockDelimiters = [
-      ["```tool_code\n", "\n```"],
-      ["```python\n", "\n```"],
-      ["```javascript\n", "\n```"],
-      ["```typescript\n", "\n```"],
-      ["```bash\n", "\n```"],
-      ["```sh\n", "\n```"]
-    ];
-    /**
-     * The delimiters to format the code execution result.
-     */
-    this.executionResultDelimiters = ["```tool_output\n", "\n```"];
-  }
-}
-export {
-  BaseCodeExecutor,
-  isBaseCodeExecutor
-};