@google/adk 2.4.0 → 2.5.0

package/dist/esm/tools/openapi_tool/auth/auth_helpers.js

@@ -12,6 +12,7 @@ import {
   AuthCredentialTypes
 } from "../../../auth/auth_credential.js";
 import { camelCaseKeys } from "../../../utils/case_utils.js";
+import { formatError } from "../../../utils/error_utils.js";
 const INTERNAL_AUTH_PREFIX = "_auth_prefix_vaf_";
 const API_KEY_LOCATIONS = ["header", "query", "cookie"];
 const OPENID_FETCH_TIMEOUT_MS = 1e4;
@@ -165,7 +166,7 @@ function tokenToSchemeCredential(tokenType, location, name, credentialValue) {
   throw new Error(`Invalid security scheme type: ${tokenType}`);
 }
 __name(tokenToSchemeCredential, "tokenToSchemeCredential");
-function serviceAccountDictToSchemeCredential(config, scopes) {
+function serviceAccountRecordToSchemeCredential(config, scopes) {
   const authCredential = {
     authType: AuthCredentialTypes.SERVICE_ACCOUNT,
     serviceAccount: {
@@ -179,7 +180,7 @@ function serviceAccountDictToSchemeCredential(config, scopes) {
   };
   return [bearerJwtScheme(), authCredential];
 }
-__name(serviceAccountDictToSchemeCredential, "serviceAccountDictToSchemeCredential");
+__name(serviceAccountRecordToSchemeCredential, "serviceAccountRecordToSchemeCredential");
 function serviceAccountSchemeCredential(config) {
   const authCredential = {
     authType: AuthCredentialTypes.SERVICE_ACCOUNT,
@@ -188,9 +189,9 @@ function serviceAccountSchemeCredential(config) {
   return [bearerJwtScheme(), authCredential];
 }
 __name(serviceAccountSchemeCredential, "serviceAccountSchemeCredential");
-function openidDictToSchemeCredential(configDict, scopes, credentialDict) {
+function openidRecordToSchemeCredential(configRecord, scopes, credentialRecord) {
   const parsedConfig = OpenIdConnectConfigSchema.safeParse(
-    camelCaseKeys(configDict)
+    camelCaseKeys(configRecord)
   );
   if (!parsedConfig.success) {
     throw new Error(
@@ -198,33 +199,33 @@ function openidDictToSchemeCredential(configDict, scopes, credentialDict) {
     );
   }
   const openidScheme = { ...parsedConfig.data, scopes };
-  const values = Object.values(credentialDict);
+  const values = Object.values(credentialRecord);
   if (values.length === 1) {
     const wrapped = JsonObjectSchema.safeParse(values[0]);
     if (wrapped.success && "client_id" in wrapped.data && "client_secret" in wrapped.data) {
-      credentialDict = wrapped.data;
+      credentialRecord = wrapped.data;
     }
   }
   const missingFields = REQUIRED_CREDENTIAL_FIELDS.filter(
-    (field) => !(field in credentialDict)
+    (field) => !(field in credentialRecord)
   );
   if (missingFields.length > 0) {
     throw new Error(
-      `Missing required fields in credential_dict: ${missingFields.join(", ")}`
+      `Missing required fields in credentialRecord: ${missingFields.join(", ")}`
     );
   }
   const authCredential = {
     authType: AuthCredentialTypes.OPEN_ID_CONNECT,
     oauth2: {
-      clientId: String(credentialDict["client_id"]),
-      clientSecret: String(credentialDict["client_secret"]),
-      redirectUri: "redirect_uri" in credentialDict ? String(credentialDict["redirect_uri"]) : void 0
+      clientId: String(credentialRecord["client_id"]),
+      clientSecret: String(credentialRecord["client_secret"]),
+      redirectUri: "redirect_uri" in credentialRecord ? String(credentialRecord["redirect_uri"]) : void 0
     }
   };
   return [openidScheme, authCredential];
 }
-__name(openidDictToSchemeCredential, "openidDictToSchemeCredential");
-async function openidUrlToSchemeCredential(openidUrl, scopes, credentialDict) {
+__name(openidRecordToSchemeCredential, "openidRecordToSchemeCredential");
+async function openidUrlToSchemeCredential(openidUrl, scopes, credentialRecord) {
   let response;
   try {
     response = await fetch(openidUrl, {
@@ -235,21 +236,21 @@ async function openidUrlToSchemeCredential(openidUrl, scopes, credentialDict) {
     }
   } catch (e) {
     throw new Error(
-      `Failed to fetch OpenID configuration from ${openidUrl}: ${String(e)}`
+      `Failed to fetch OpenID configuration from ${openidUrl}: ${formatError(e)}`
     );
   }
-  let configDict;
+  let configRecord;
   try {
-    configDict = JsonObjectSchema.parse(await response.json());
+    configRecord = JsonObjectSchema.parse(await response.json());
   } catch (e) {
     throw new Error(
-      `Invalid JSON response from OpenID configuration endpoint ${openidUrl}: ${String(e)}`
+      `Invalid JSON response from OpenID configuration endpoint ${openidUrl}: ${formatError(e)}`
     );
   }
-  return openidDictToSchemeCredential(
-    { ...configDict, openIdConnectUrl: openidUrl },
+  return openidRecordToSchemeCredential(
+    { ...configRecord, openIdConnectUrl: openidUrl },
     scopes,
-    credentialDict
+    credentialRecord
   );
 }
 __name(openidUrlToSchemeCredential, "openidUrlToSchemeCredential");
@@ -300,9 +301,9 @@ function parseSecurityScheme(schema, data) {
   return result.data;
 }
 __name(parseSecurityScheme, "parseSecurityScheme");
-function dictToAuthScheme(data) {
+function recordToAuthScheme(data) {
   if (!("type" in data)) {
-    throw new Error("Missing 'type' field in security scheme dictionary.");
+    throw new Error("Missing 'type' field in security scheme object.");
   }
   const securityType = data["type"];
   switch (securityType) {
@@ -318,17 +319,17 @@ function dictToAuthScheme(data) {
       throw new Error(`Invalid security scheme type: ${securityType}`);
   }
 }
-__name(dictToAuthScheme, "dictToAuthScheme");
+__name(recordToAuthScheme, "recordToAuthScheme");
 export {
   INTERNAL_AUTH_PREFIX,
   applyCredential,
   createApiKeyScheme,
   createBearerScheme,
   credentialToParam,
-  dictToAuthScheme,
-  openidDictToSchemeCredential,
+  openidRecordToSchemeCredential,
   openidUrlToSchemeCredential,
-  serviceAccountDictToSchemeCredential,
+  recordToAuthScheme,
+  serviceAccountRecordToSchemeCredential,
   serviceAccountSchemeCredential,
   tokenToSchemeCredential
 };

package/dist/esm/tools/openapi_tool/auth/credential_exchangers/oauth2_exchanger.js

@@ -24,7 +24,7 @@ import { experimental } from "../../../../utils/experimental.js";
 function checkSchemeCredentialType(authScheme, authCredential) {
   if (!authCredential) {
     throw new Error(
-      "auth_credential is empty. Please create AuthCredential using OAuth2Auth."
+      "authCredential is empty. Please create AuthCredential using OAuth2Auth."
     );
   }
   if (authScheme.type !== AuthSchemeType.OPEN_ID_CONNECT && authScheme.type !== AuthSchemeType.OAUTH2) {
@@ -34,7 +34,7 @@ function checkSchemeCredentialType(authScheme, authCredential) {
   }
   if (!authCredential.oauth2 && !authCredential.http) {
     throw new Error(
-      "auth_credential is not configured with oauth2. Please create AuthCredential and set OAuth2Auth."
+      "authCredential is not configured with oauth2. Please create AuthCredential and set OAuth2Auth."
     );
   }
 }

package/dist/esm/tools/openapi_tool/rest_api_tool.js

@@ -176,22 +176,32 @@ function encodePathParamValue(name, value) {
   return encodeURIComponent(value);
 }
 __name(encodePathParamValue, "encodePathParamValue");
+function toParamString(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => item !== void 0 && item !== null).map(toParamString).join(",");
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.entries(value).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${k},${toParamString(v)}`).join(",");
+  }
+  return String(value);
+}
+__name(toParamString, "toParamString");
 function serializeQueryValue(value) {
   return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
 }
 __name(serializeQueryValue, "serializeQueryValue");
-function appendQueryParam(queryParams, name, value) {
+function appendParamValue(target, name, value) {
   if (!Array.isArray(value)) {
-    queryParams.append(name, serializeQueryValue(value));
+    target.append(name, serializeQueryValue(value));
     return;
   }
   for (const item of value) {
     if (item !== void 0 && item !== null) {
-      queryParams.append(name, serializeQueryValue(item));
+      target.append(name, serializeQueryValue(item));
     }
   }
 }
-__name(appendQueryParam, "appendQueryParam");
+__name(appendParamValue, "appendParamValue");
 function prepareRequestParams(endpoint, parameters, args) {
   const headers = {};
   const queryParams = new URLSearchParams();
@@ -206,18 +216,24 @@ function prepareRequestParams(endpoint, parameters, args) {
     const originalName = param.originalName;
     const location = param.paramLocation;
     if (location === "path") {
-      pathParams[originalName] = encodePathParamValue(
-        originalName,
-        String(argValue)
-      );
+      if (argValue !== void 0 && argValue !== null) {
+        pathParams[originalName] = encodePathParamValue(
+          originalName,
+          toParamString(argValue)
+        );
+      }
     } else if (location === "query") {
       if (argValue !== void 0 && argValue !== null && argValue !== "") {
-        appendQueryParam(queryParams, originalName, argValue);
+        appendParamValue(queryParams, originalName, argValue);
       }
     } else if (location === "header") {
-      headers[originalName] = String(argValue);
+      if (argValue !== void 0 && argValue !== null) {
+        headers[originalName] = toParamString(argValue);
+      }
     } else if (location === "cookie") {
-      cookies[originalName] = String(argValue);
+      if (argValue !== void 0 && argValue !== null) {
+        cookies[originalName] = toParamString(argValue);
+      }
     } else if (location === "body") {
       if (originalName === "body" || originalName === "array" || originalName === "") {
         body = argValue;
@@ -251,6 +267,18 @@ function isRawBody(value) {
   return typeof value === "string" || ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Blob;
 }
 __name(isRawBody, "isRawBody");
+function isFormFields(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isFormFields, "isFormFields");
+function appendFormFields(target, fields) {
+  for (const [name, value] of Object.entries(fields)) {
+    if (value !== void 0 && value !== null) {
+      appendParamValue(target, name, value);
+    }
+  }
+}
+__name(appendFormFields, "appendFormFields");
 function prepareRequestBody(requestBody, body, bodyData, headers) {
   const finalData = body !== void 0 ? body : Object.keys(bodyData).length > 0 ? bodyData : void 0;
   if (requestBody && "content" in requestBody) {
@@ -261,13 +289,16 @@ function prepareRequestBody(requestBody, body, bodyData, headers) {
         headers["Content-Type"] = mimeType;
         return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
       } else if (mimeType === "application/x-www-form-urlencoded") {
+        if (isFormFields(finalData)) {
+          const formParams = new URLSearchParams();
+          appendFormFields(formParams, finalData);
+          return formParams;
+        }
         return new URLSearchParams(finalData);
       } else if (mimeType === "multipart/form-data") {
         const formData = new FormData();
         if (typeof finalData === "object" && finalData !== null) {
-          for (const [key, value] of Object.entries(finalData)) {
-            formData.append(key, String(value));
-          }
+          appendFormFields(formData, finalData);
         }
         return formData;
       } else if (mimeType === "application/octet-stream") {

package/dist/esm/tools/skill/load_skill_resource_tool.js

@@ -18,6 +18,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  */
 import { Type } from "@google/genai";
 import path from "node:path";
+import { recordSkillActivity } from "../../telemetry/api/instrumentation.js";
 import { experimental } from "../../utils/experimental.js";
 import { guessMimeType } from "../../utils/file_utils.js";
 import {
@@ -72,6 +73,11 @@ let LoadSkillResourceTool = class extends BaseTool {
       };
     }
     resourcePath = path.posix.normalize(resourcePath);
+    const skillActivity = recordSkillActivity({
+      kind: "resource",
+      skillName,
+      resourcePath
+    });
     let skill;
     try {
       skill = await this.toolset.getOrFetchSkill(
@@ -90,6 +96,7 @@ let LoadSkillResourceTool = class extends BaseTool {
         error_code: "SKILL_NOT_FOUND"
       };
     }
+    skillActivity.recordSkill(skill);
     let content;
     const skillResources = skill.resources || {};
     if (resourcePath.startsWith("references/")) {

package/dist/esm/tools/skill/load_skill_tool.js

@@ -18,6 +18,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  */
 import { Type } from "@google/genai";
 import { requireAgent } from "../../agents/invocation_context.js";
+import { recordSkillActivity } from "../../telemetry/api/instrumentation.js";
 import { experimental } from "../../utils/experimental.js";
 import { BaseTool } from "../base_tool.js";
 let LoadSkillTool = class extends BaseTool {
@@ -55,6 +56,7 @@ let LoadSkillTool = class extends BaseTool {
         error_code: "MISSING_SKILL_NAME"
       };
     }
+    const skillActivity = recordSkillActivity({ kind: "load", skillName });
     let skill;
     try {
       skill = await this.toolset.getOrFetchSkill(
@@ -73,6 +75,7 @@ let LoadSkillTool = class extends BaseTool {
         error_code: "SKILL_NOT_FOUND"
       };
     }
+    skillActivity.recordSkill(skill);
     const agentName = requireAgent(toolContext.invocationContext).name;
     const stateKey = `_adk_activated_skill_${agentName}`;
     const currentActivated = toolContext.state.get(stateKey) || [];

package/dist/esm/tools/skill/run_skill_script_tool.js

@@ -22,6 +22,7 @@ import { isLlmAgent } from "../../agents/llm_agent.js";
 import {
   CodeExecutionLanguage
 } from "../../code_executors/code_execution_utils.js";
+import { recordSkillActivity } from "../../telemetry/api/instrumentation.js";
 import { experimental } from "../../utils/experimental.js";
 import {
   getMimeTypeAndEncoding,
@@ -81,6 +82,11 @@ let RunSkillScriptTool = class extends BaseTool {
         errorCode: "MISSING_SCRIPT_PATH"
       };
     }
+    const skillActivity = recordSkillActivity({
+      kind: "script",
+      skillName,
+      scriptPath
+    });
     let skill;
     try {
       skill = await this.toolset.getOrFetchSkill(
@@ -99,9 +105,11 @@ let RunSkillScriptTool = class extends BaseTool {
         errorCode: "SKILL_NOT_FOUND"
       };
     }
-    const relScriptPath = scriptPath.startsWith("scripts/") ? scriptPath.substring("scripts/".length) : scriptPath;
+    skillActivity.recordSkill(skill);
+    let relScriptPath = scriptPath.startsWith("scripts/") ? scriptPath.substring("scripts/".length) : scriptPath;
     let script = (_b = (_a = skill.resources) == null ? void 0 : _a.scripts) == null ? void 0 : _b[relScriptPath];
     if (!script) {
+      relScriptPath = scriptPath;
       script = (_d = (_c = skill.resources) == null ? void 0 : _c.scripts) == null ? void 0 : _d[scriptPath];
     }
     if (!script) {
@@ -128,7 +136,9 @@ let RunSkillScriptTool = class extends BaseTool {
       const result = await codeExecutor.executeCode({
         invocationContext: toolContext.invocationContext,
         codeExecutionInput: {
-          code: buildWrapperCode(scriptPath, language),
+          // Scripts are always written under scripts/ (see
+          // getSkillResourceFiles), with or without the prefix in script_path.
+          code: buildWrapperCode(`scripts/${relScriptPath}`, language),
           inputFiles: getSkillResourceFiles(skill),
           language,
           args: scriptArgs

package/dist/esm/tools/toolbox_toolset.js

@@ -38,26 +38,43 @@ function isToolOptionsObject(value) {
   return typeof value === "object" && value !== null && "execute" in value && typeof value.execute === "function";
 }
 __name(isToolOptionsObject, "isToolOptionsObject");
+function wrapPrefixedBaseTool(rawTool, name) {
+  return new Proxy(rawTool, {
+    get(target, prop, receiver) {
+      if (prop === "name") {
+        return name;
+      }
+      if (prop === "_getDeclaration") {
+        return () => {
+          const declaration = target._getDeclaration();
+          return declaration ? { ...declaration, name } : void 0;
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+__name(wrapPrefixedBaseTool, "wrapPrefixedBaseTool");
 function wrapLoadedTool(rawTool, prefix) {
   var _a2;
   if (isBaseTool(rawTool)) {
-    if (!prefix) {
+    const name = prefix ? `${prefix}_${rawTool.name}` : rawTool.name;
+    if (name === rawTool.name) {
       return rawTool;
     }
-    return Object.assign(
-      Object.create(Object.getPrototypeOf(rawTool)),
-      rawTool,
-      { name: `${prefix}_${rawTool.name}` }
-    );
+    return wrapPrefixedBaseTool(rawTool, name);
   }
   if (typeof rawTool === "function") {
     const fn = rawTool;
-    const baseName = fn.name || "toolbox_tool";
+    const baseName = typeof fn.getName === "function" ? fn.getName() : fn.toolName || (fn.name && fn.name !== "callable" ? fn.name : void 0) || "toolbox_tool";
     const name = prefix ? `${prefix}_${baseName}` : baseName;
-    const description = (_a2 = fn.description) != null ? _a2 : "";
+    const description = typeof fn.getDescription === "function" ? fn.getDescription() : (_a2 = fn.description) != null ? _a2 : "";
+    const parameters = typeof fn.getParamSchema === "function" ? fn.getParamSchema() : fn.parameters;
     return new FunctionTool({
       name,
       description,
+      parameters,
       execute: fn
     });
   }
@@ -78,53 +95,55 @@ function wrapLoadedTool(rawTool, prefix) {
 __name(wrapLoadedTool, "wrapLoadedTool");
 const _ToolboxToolset = class _ToolboxToolset extends (_b = BaseToolset, _a = TOOLBOX_TOOLSET_SIGNATURE_SYMBOL, _b) {
   constructor(serverUrlOrOptions, extraOptions) {
-    var _a2, _b2, _c, _d;
+    var _a2, _b2, _c, _d, _e;
     const options = typeof serverUrlOrOptions === "string" ? { serverUrl: serverUrlOrOptions, ...extraOptions } : serverUrlOrOptions;
+    const normalizedServerUrl = (_a2 = options.serverUrl) == null ? void 0 : _a2.trim();
+    if (!options.client && !normalizedServerUrl) {
+      throw new Error("Either client or a non-empty serverUrl is required.");
+    }
     if ((!options.toolNames || options.toolNames.length === 0) && !options.toolsetName) {
       throw new Error("toolNames and toolsetName cannot both be undefined.");
     }
-    super((_a2 = options.toolFilter) != null ? _a2 : [], options.prefix);
+    super((_b2 = options.toolFilter) != null ? _b2 : [], options.prefix);
     /** A unique symbol to identify ADK ToolboxToolset class. */
     this[_a] = true;
     this.serverUrl = options.serverUrl;
     this.toolsetName = options.toolsetName;
     this.toolNames = options.toolNames;
-    this.authTokenGetters = (_b2 = options.authTokenGetters) != null ? _b2 : {};
-    this.boundParams = (_c = options.boundParams) != null ? _c : {};
-    this.toolboxClient = (_d = options.client) != null ? _d : createUnconfiguredToolboxToolsetClient(this.serverUrl);
+    this.authTokenGetters = (_c = options.authTokenGetters) != null ? _c : {};
+    this.boundParams = (_d = options.boundParams) != null ? _d : {};
+    this.toolboxClient = (_e = options.client) != null ? _e : createUnconfiguredToolboxToolsetClient(normalizedServerUrl != null ? normalizedServerUrl : "");
   }
   /**
    * Loads the configured toolset and/or individual tools from the Toolbox
    * client and returns the selected {@link BaseTool} instances.
    */
   async getTools(context) {
-    var _a2, _b2, _c, _d, _e, _f;
-    const loadOptions = {
-      authTokenGetters: this.authTokenGetters,
-      boundParams: this.boundParams
-    };
+    var _a2, _b2;
     const tools = [];
     if (this.toolsetName) {
-      const loader = (_c = (_a2 = this.toolboxClient.loadToolset) == null ? void 0 : _a2.bind(this.toolboxClient)) != null ? _c : (_b2 = this.toolboxClient.load_toolset) == null ? void 0 : _b2.bind(this.toolboxClient);
+      const loader = (_a2 = this.toolboxClient.loadToolset) == null ? void 0 : _a2.bind(this.toolboxClient);
       if (!loader) {
-        throw new Error(
-          "ToolboxClient does not implement loadToolset or load_toolset."
-        );
+        throw new Error("ToolboxClient does not implement loadToolset.");
       }
-      const loadedToolset = await loader(this.toolsetName, loadOptions);
+      const loadedToolset = await loader(
+        this.toolsetName,
+        this.authTokenGetters,
+        this.boundParams
+      );
       for (const rawTool of loadedToolset) {
         tools.push(wrapLoadedTool(rawTool, this.prefix));
       }
     }
     if (this.toolNames && this.toolNames.length > 0) {
-      const loader = (_f = (_d = this.toolboxClient.loadTool) == null ? void 0 : _d.bind(this.toolboxClient)) != null ? _f : (_e = this.toolboxClient.load_tool) == null ? void 0 : _e.bind(this.toolboxClient);
+      const loader = (_b2 = this.toolboxClient.loadTool) == null ? void 0 : _b2.bind(this.toolboxClient);
       if (!loader) {
-        throw new Error(
-          "ToolboxClient does not implement loadTool or load_tool."
-        );
+        throw new Error("ToolboxClient does not implement loadTool.");
       }
       const loadedSingleTools = await Promise.all(
-        this.toolNames.map((toolName) => loader(toolName, loadOptions))
+        this.toolNames.map(
+          (toolName) => loader(toolName, this.authTokenGetters, this.boundParams)
+        )
       );
       for (const rawTool of loadedSingleTools) {
         tools.push(wrapLoadedTool(rawTool, this.prefix));

package/dist/esm/utils/async_queue.js

@@ -26,14 +26,43 @@ const _AsyncQueue = class _AsyncQueue {
    * immediately; otherwise the value is buffered. No-op once closed/failed.
    */
   push(value) {
-    if (this.closed) return;
+    this.enqueue(value);
+  }
+  /**
+   * Enqueues a value like {@link push}, and resolves once the consumer has
+   * finished with it: when it asks for the next item, or when the queue closes
+   * or fails. Resolves at once if the queue is already closed.
+   */
+  pushAndWait(value) {
+    return new Promise((resolve) => this.enqueue(value, resolve));
+  }
+  enqueue(value, ack) {
+    if (this.closed) {
+      ack == null ? void 0 : ack();
+      return;
+    }
     const resolver = this.resolvers.shift();
     if (resolver) {
+      this.deliveredAck = ack;
       resolver.resolve({ value, done: false });
     } else {
-      this.queue.push(value);
+      this.queue.push({ value, ack });
+    }
+  }
+  /** Releases every producer still waiting in {@link pushAndWait}. */
+  releaseAll() {
+    var _a;
+    this.releaseDelivered();
+    for (const item of this.queue) {
+      (_a = item.ack) == null ? void 0 : _a.call(item);
+      item.ack = void 0;
     }
   }
+  releaseDelivered() {
+    const ack = this.deliveredAck;
+    this.deliveredAck = void 0;
+    ack == null ? void 0 : ack();
+  }
   /**
    * Signals that production failed. Buffered items are still delivered first;
    * once the buffer drains, the consumer's next `next()` rejects with `error`.
@@ -43,6 +72,7 @@ const _AsyncQueue = class _AsyncQueue {
     if (this.failure) return;
     this.failure = { error };
     this.closed = true;
+    this.releaseAll();
     while (this.resolvers.length > 0) {
       this.resolvers.shift().reject(error);
     }
@@ -58,6 +88,7 @@ const _AsyncQueue = class _AsyncQueue {
   close() {
     if (this.closed) return;
     this.closed = true;
+    this.releaseAll();
     while (this.resolvers.length > 0) {
       this.resolvers.shift().resolve({ value: void 0, done: true });
     }
@@ -65,8 +96,11 @@ const _AsyncQueue = class _AsyncQueue {
   [Symbol.asyncIterator]() {
     return {
       next: /* @__PURE__ */ __name(() => {
+        this.releaseDelivered();
         if (this.queue.length > 0) {
-          return Promise.resolve({ value: this.queue.shift(), done: false });
+          const item = this.queue.shift();
+          this.deliveredAck = item.ack;
+          return Promise.resolve({ value: item.value, done: false });
         }
         if (this.failure) {
           return Promise.reject(this.failure.error);

package/dist/esm/utils/client_labels.js

@@ -116,19 +116,17 @@ function mergeTrackingHeaders(headers) {
       otherHeaders.append(name, value);
     }
   }
-  const normalizedEntries = [];
+  const mergedEntries = /* @__PURE__ */ new Map();
   otherHeaders.forEach((value, name) => {
-    normalizedEntries.push([name, value]);
+    var _a2;
+    const key = (_a2 = originalNames.get(name)) != null ? _a2 : name;
+    const existing = mergedEntries.get(key);
+    mergedEntries.set(
+      key,
+      existing !== void 0 ? `${existing}, ${value}` : value
+    );
   });
-  const merged = Object.fromEntries(
-    normalizedEntries.map(([name, value]) => {
-      var _a2;
-      return [
-        (_a2 = originalNames.get(name)) != null ? _a2 : name,
-        value
-      ];
-    })
-  );
+  const merged = Object.fromEntries(mergedEntries);
   for (const [name, trackingValue] of Object.entries(getTrackingHeaders())) {
     const tokens = trackingValue.split(" ");
     for (const value of (_b = callerValues.get(name)) != null ? _b : []) {

package/dist/esm/utils/env_aware_utils.js

@@ -65,11 +65,16 @@ function isBase64Encoded(data) {
   }
 }
 __name(isBase64Encoded, "isBase64Encoded");
-function getBooleanEnvVar(envVar) {
-  if (!process.env) {
-    return false;
+function getEnvVar(envVar) {
+  var _a;
+  if (typeof process === "undefined") {
+    return void 0;
   }
-  const envVarValue = (process.env[envVar] || "").toLowerCase();
+  return (_a = process.env) == null ? void 0 : _a[envVar];
+}
+__name(getEnvVar, "getEnvVar");
+function getBooleanEnvVar(envVar) {
+  const envVarValue = (getEnvVar(envVar) || "").toLowerCase();
   return ["true", "1"].includes(envVarValue);
 }
 __name(getBooleanEnvVar, "getBooleanEnvVar");
@@ -83,9 +88,8 @@ function warnDeprecatedEnterpriseModeEnvVar(message) {
 }
 __name(warnDeprecatedEnterpriseModeEnvVar, "warnDeprecatedEnterpriseModeEnvVar");
 function isEnterpriseModeEnabled() {
-  var _a, _b;
-  const deprecatedIsSet = ((_a = process.env) == null ? void 0 : _a[DEPRECATED_ENTERPRISE_MODE_ENV_VAR]) !== void 0;
-  if (((_b = process.env) == null ? void 0 : _b[ENTERPRISE_MODE_ENV_VAR]) !== void 0) {
+  const deprecatedIsSet = getEnvVar(DEPRECATED_ENTERPRISE_MODE_ENV_VAR) !== void 0;
+  if (getEnvVar(ENTERPRISE_MODE_ENV_VAR) !== void 0) {
     if (deprecatedIsSet) {
       warnDeprecatedEnterpriseModeEnvVar(
         `${DEPRECATED_ENTERPRISE_MODE_ENV_VAR} is set but ignored because ${ENTERPRISE_MODE_ENV_VAR} takes precedence. ${DEPRECATED_ENTERPRISE_MODE_ENV_VAR} is deprecated, please use ${ENTERPRISE_MODE_ENV_VAR} instead.`
@@ -106,6 +110,7 @@ export {
   base64Decode,
   base64Encode,
   getBooleanEnvVar,
+  getEnvVar,
   isBase64Encoded,
   isBrowser,
   isEnterpriseModeEnabled,