@softactivate/adk 1.1.0

package/dist/cjs/skills/prompt.js

@@ -0,0 +1,58 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prompt_exports = {};
+__export(prompt_exports, {
+  formatSkillsAsXml: () => formatSkillsAsXml
+});
+module.exports = __toCommonJS(prompt_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function escapeHtml(unsafe) {
+  return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function formatSkillsAsXml(skills) {
+  if (!skills || skills.length === 0) {
+    return "<available_skills>\n</available_skills>";
+  }
+  const lines = ["<available_skills>"];
+  for (const item of skills) {
+    const frontmatter = "frontmatter" in item ? item.frontmatter : item;
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeHtml(frontmatter.name)}</name>`);
+    lines.push(
+      `    <description>${escapeHtml(frontmatter.description)}</description>`
+    );
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatSkillsAsXml
+});

package/dist/cjs/skills/skill.js

@@ -0,0 +1,78 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var skill_exports = {};
+__export(skill_exports, {
+  FrontmatterSchema: () => FrontmatterSchema,
+  SNAKE_OR_KEBAB_NAME_PATTERN: () => SNAKE_OR_KEBAB_NAME_PATTERN
+});
+module.exports = __toCommonJS(skill_exports);
+var import_zod = require("zod");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const SNAKE_OR_KEBAB_NAME_PATTERN = /^([a-z0-9]+(-[a-z0-9]+)*|[a-z0-9]+(_[a-z0-9]+)*)$/;
+const FrontmatterSchema = import_zod.z.preprocess(
+  (data) => {
+    if (typeof data === "object" && data !== null) {
+      const obj = data;
+      if ("allowed-tools" in obj && !("allowedTools" in obj)) {
+        return {
+          ...obj,
+          allowedTools: obj["allowed-tools"]
+        };
+      }
+    }
+    return data;
+  },
+  import_zod.z.object({
+    name: import_zod.z.string().regex(SNAKE_OR_KEBAB_NAME_PATTERN, {
+      message: "name must be lowercase kebab-case (a-z, 0-9, hyphens) or snake_case (a-z, 0-9, underscores), with no leading, trailing, or consecutive delimiters. Mixing hyphens and underscores is not allowed."
+    }).max(64),
+    description: import_zod.z.string().min(1).max(1024),
+    license: import_zod.z.string().optional(),
+    compatibility: import_zod.z.string().max(500).optional(),
+    "allowed-tools": import_zod.z.string().optional(),
+    metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).default({}).refine(
+      (data) => {
+        if ("adk_additional_tools" in data) {
+          return Array.isArray(data.adk_additional_tools) && data.adk_additional_tools.every(
+            (item) => typeof item === "string"
+          );
+        }
+        return true;
+      },
+      {
+        message: "adk_additional_tools must be a list of strings"
+      }
+    )
+  }).loose()
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FrontmatterSchema,
+  SNAKE_OR_KEBAB_NAME_PATTERN
+});

package/dist/cjs/telemetry/google_cloud.js

@@ -0,0 +1,83 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var google_cloud_exports = {};
+__export(google_cloud_exports, {
+  getGcpExporters: () => getGcpExporters,
+  getGcpResource: () => getGcpResource
+});
+module.exports = __toCommonJS(google_cloud_exports);
+var import_opentelemetry_cloud_monitoring_exporter = require("@google-cloud/opentelemetry-cloud-monitoring-exporter");
+var import_opentelemetry_cloud_trace_exporter = require("@google-cloud/opentelemetry-cloud-trace-exporter");
+var import_resource_detector_gcp = require("@opentelemetry/resource-detector-gcp");
+var import_resources = require("@opentelemetry/resources");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_google_auth_library = require("google-auth-library");
+var import_logger = require("../utils/logger.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const GCP_PROJECT_ERROR_MESSAGE = "Cannot determine GCP Project. OTel GCP Exporters cannot be set up. Please make sure to log into correct GCP Project.";
+async function getGcpProjectId() {
+  try {
+    const auth = new import_google_auth_library.GoogleAuth();
+    const projectId = await auth.getProjectId();
+    return projectId || void 0;
+  } catch (_e) {
+    return void 0;
+  }
+}
+async function getGcpExporters(config = {}) {
+  const {
+    enableTracing = false,
+    enableMetrics = false
+    // enableCloudLogging = false,
+  } = config;
+  const projectId = await getGcpProjectId();
+  if (!projectId) {
+    import_logger.logger.warn(GCP_PROJECT_ERROR_MESSAGE);
+    return {};
+  }
+  return {
+    spanProcessors: enableTracing ? [new import_sdk_trace_base.BatchSpanProcessor(new import_opentelemetry_cloud_trace_exporter.TraceExporter({ projectId }))] : [],
+    metricReaders: enableMetrics ? [
+      new import_sdk_metrics.PeriodicExportingMetricReader({
+        exporter: new import_opentelemetry_cloud_monitoring_exporter.MetricExporter({ projectId }),
+        exportIntervalMillis: 5e3
+      })
+    ] : [],
+    logRecordProcessors: []
+  };
+}
+function getGcpResource() {
+  return (0, import_resources.detectResources)({ detectors: [import_resource_detector_gcp.gcpDetector] });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getGcpExporters,
+  getGcpResource
+});

package/dist/cjs/telemetry/setup.js

@@ -0,0 +1,105 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setup_exports = {};
+__export(setup_exports, {
+  maybeSetOtelProviders: () => maybeSetOtelProviders
+});
+module.exports = __toCommonJS(setup_exports);
+var import_api = require("@opentelemetry/api");
+var import_api_logs = require("@opentelemetry/api-logs");
+var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
+var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_resources = require("@opentelemetry/resources");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function maybeSetOtelProviders(otelHooksToSetup = [], otelResource) {
+  const resource = otelResource || getOtelResource();
+  const allHooks = [...otelHooksToSetup, getOtelExporters()];
+  const spanProcessors = allHooks.flatMap(
+    (hooks) => hooks.spanProcessors || []
+  );
+  const metricReaders = allHooks.flatMap((hooks) => hooks.metricReaders || []);
+  const logRecordProcessors = allHooks.flatMap(
+    (hooks) => hooks.logRecordProcessors || []
+  );
+  if (spanProcessors.length > 0) {
+    const tracerProvider = new import_sdk_trace_node.NodeTracerProvider({
+      resource,
+      spanProcessors
+    });
+    tracerProvider.register();
+    import_api.trace.setGlobalTracerProvider(tracerProvider);
+  }
+  if (metricReaders.length > 0) {
+    const meterProvider = new import_sdk_metrics.MeterProvider({
+      readers: metricReaders,
+      resource
+    });
+    import_api.metrics.setGlobalMeterProvider(meterProvider);
+  }
+  if (logRecordProcessors.length > 0) {
+    const loggerProvider = new import_sdk_logs.LoggerProvider({
+      resource,
+      processors: logRecordProcessors
+    });
+    import_api_logs.logs.setGlobalLoggerProvider(loggerProvider);
+  }
+}
+function getOtelResource() {
+  return (0, import_resources.detectResources)({
+    detectors: []
+  });
+}
+function getOtelExportersConfig() {
+  return {
+    enableTracing: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT),
+    enableMetrics: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT),
+    enableLogging: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT)
+  };
+}
+function getOtelExporters(config = getOtelExportersConfig()) {
+  const { enableTracing, enableMetrics, enableLogging } = config;
+  return {
+    spanProcessors: enableTracing ? [new import_sdk_trace_base.BatchSpanProcessor(new import_exporter_trace_otlp_http.OTLPTraceExporter())] : [],
+    metricReaders: enableMetrics ? [
+      new import_sdk_metrics.PeriodicExportingMetricReader({
+        exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter()
+      })
+    ] : [],
+    logRecordProcessors: enableLogging ? [new import_sdk_logs.BatchLogRecordProcessor(new import_exporter_logs_otlp_http.OTLPLogExporter())] : []
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  maybeSetOtelProviders
+});

package/dist/cjs/telemetry/tracing.js

@@ -0,0 +1,253 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tracing_exports = {};
+__export(tracing_exports, {
+  runAsyncGeneratorWithOtelContext: () => runAsyncGeneratorWithOtelContext,
+  traceAgentInvocation: () => traceAgentInvocation,
+  traceCallLlm: () => traceCallLlm,
+  traceMergedToolCalls: () => traceMergedToolCalls,
+  traceSendData: () => traceSendData,
+  traceToolCall: () => traceToolCall,
+  tracer: () => tracer
+});
+module.exports = __toCommonJS(tracing_exports);
+var import_api = require("@opentelemetry/api");
+var import_version = require("../version.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const GEN_AI_AGENT_DESCRIPTION = "gen_ai.agent.description";
+const GEN_AI_AGENT_NAME = "gen_ai.agent.name";
+const GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id";
+const GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+const GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
+const GEN_AI_TOOL_DESCRIPTION = "gen_ai.tool.description";
+const GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+const GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
+const tracer = import_api.trace.getTracer("gcp.vertex.agent", import_version.version);
+function safeJsonSerialize(obj) {
+  try {
+    return JSON.stringify(obj);
+  } catch (_e) {
+    return "<not serializable>";
+  }
+}
+function traceAgentInvocation({
+  agent,
+  invocationContext
+}) {
+  const span = import_api.trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    [GEN_AI_OPERATION_NAME]: "invoke_agent",
+    // Conditionally Required
+    [GEN_AI_AGENT_DESCRIPTION]: agent.description,
+    [GEN_AI_AGENT_NAME]: agent.name,
+    [GEN_AI_CONVERSATION_ID]: invocationContext.session.id
+  });
+}
+function traceToolCall({
+  tool,
+  args,
+  functionResponseEvent
+}) {
+  var _a, _b;
+  const span = import_api.trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    [GEN_AI_OPERATION_NAME]: "execute_tool",
+    [GEN_AI_TOOL_DESCRIPTION]: tool.description || "",
+    [GEN_AI_TOOL_NAME]: tool.name,
+    // e.g. FunctionTool
+    [GEN_AI_TOOL_TYPE]: tool.constructor.name,
+    // Setting empty llm request and response (as UI expect these) while not
+    // applicable for tool_response.
+    "gcp.vertex.agent.llm_request": "{}",
+    "gcp.vertex.agent.llm_response": "{}",
+    "gcp.vertex.agent.tool_call_args": shouldAddRequestResponseToSpans() ? safeJsonSerialize(args) : "{}"
+  });
+  let toolCallId = "<not specified>";
+  let toolResponse = "<not specified>";
+  if ((_a = functionResponseEvent.content) == null ? void 0 : _a.parts) {
+    const responseParts = functionResponseEvent.content.parts;
+    const functionResponse = (_b = responseParts[0]) == null ? void 0 : _b.functionResponse;
+    if (functionResponse == null ? void 0 : functionResponse.id) {
+      toolCallId = functionResponse.id;
+    }
+    if (functionResponse == null ? void 0 : functionResponse.response) {
+      toolResponse = functionResponse.response;
+    }
+  }
+  if (typeof toolResponse !== "object" || toolResponse === null) {
+    toolResponse = { result: toolResponse };
+  }
+  span.setAttributes({
+    [GEN_AI_TOOL_CALL_ID]: toolCallId,
+    "gcp.vertex.agent.event_id": functionResponseEvent.id,
+    "gcp.vertex.agent.tool_response": shouldAddRequestResponseToSpans() ? safeJsonSerialize(toolResponse) : "{}"
+  });
+}
+function traceMergedToolCalls({
+  responseEventId,
+  functionResponseEvent
+}) {
+  const span = import_api.trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    [GEN_AI_OPERATION_NAME]: "execute_tool",
+    [GEN_AI_TOOL_NAME]: "(merged tools)",
+    [GEN_AI_TOOL_DESCRIPTION]: "(merged tools)",
+    [GEN_AI_TOOL_CALL_ID]: responseEventId,
+    "gcp.vertex.agent.tool_call_args": "N/A",
+    "gcp.vertex.agent.event_id": responseEventId,
+    // Setting empty llm request and response (as UI expect these) while not
+    // applicable for tool_response.
+    "gcp.vertex.agent.llm_request": "{}",
+    "gcp.vertex.agent.llm_response": "{}"
+  });
+  span.setAttribute(
+    "gcp.vertex.agent.tool_response",
+    shouldAddRequestResponseToSpans() ? safeJsonSerialize(functionResponseEvent) : "{}"
+  );
+}
+function traceCallLlm({
+  invocationContext,
+  eventId,
+  llmRequest,
+  llmResponse
+}) {
+  var _a, _b, _c;
+  const span = import_api.trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    "gen_ai.system": "gcp.vertex.agent",
+    "gen_ai.request.model": llmRequest.model,
+    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
+    "gcp.vertex.agent.session_id": invocationContext.session.id,
+    "gcp.vertex.agent.event_id": eventId,
+    // Consider removing once GenAI SDK provides a way to record this info.
+    "gcp.vertex.agent.llm_request": shouldAddRequestResponseToSpans() ? safeJsonSerialize(buildLlmRequestForTrace(llmRequest)) : "{}"
+  });
+  if ((_a = llmRequest.config) == null ? void 0 : _a.topP) {
+    span.setAttribute("gen_ai.request.top_p", llmRequest.config.topP);
+  }
+  if (((_b = llmRequest.config) == null ? void 0 : _b.maxOutputTokens) !== void 0) {
+    span.setAttribute(
+      "gen_ai.request.max_tokens",
+      llmRequest.config.maxOutputTokens
+    );
+  }
+  span.setAttribute(
+    "gcp.vertex.agent.llm_response",
+    shouldAddRequestResponseToSpans() ? safeJsonSerialize(llmResponse) : "{}"
+  );
+  if (llmResponse.usageMetadata) {
+    span.setAttribute(
+      "gen_ai.usage.input_tokens",
+      llmResponse.usageMetadata.promptTokenCount || 0
+    );
+  }
+  if ((_c = llmResponse.usageMetadata) == null ? void 0 : _c.candidatesTokenCount) {
+    span.setAttribute(
+      "gen_ai.usage.output_tokens",
+      llmResponse.usageMetadata.candidatesTokenCount
+    );
+  }
+  if (llmResponse.finishReason) {
+    const finishReasonValue = typeof llmResponse.finishReason === "string" ? llmResponse.finishReason.toLowerCase() : String(llmResponse.finishReason).toLowerCase();
+    span.setAttribute("gen_ai.response.finish_reasons", [finishReasonValue]);
+  }
+}
+function traceSendData({
+  invocationContext,
+  eventId,
+  data
+}) {
+  const span = import_api.trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
+    "gcp.vertex.agent.event_id": eventId
+  });
+  span.setAttribute(
+    "gcp.vertex.agent.data",
+    shouldAddRequestResponseToSpans() ? safeJsonSerialize(data) : "{}"
+  );
+}
+function buildLlmRequestForTrace(llmRequest) {
+  const result = {
+    model: llmRequest.model,
+    contents: []
+  };
+  if (llmRequest.config) {
+    const { responseSchema, ...cleanConfig } = llmRequest.config;
+    result.config = cleanConfig;
+  }
+  result.contents = llmRequest.contents.map((content) => {
+    var _a;
+    return {
+      role: content.role,
+      parts: ((_a = content.parts) == null ? void 0 : _a.filter((part) => !part.inlineData)) || []
+    };
+  });
+  return result;
+}
+function bindOtelContextToAsyncGenerator(ctx, generator) {
+  return {
+    // Bind the next() method to execute within the provided context
+    next: import_api.context.bind(ctx, generator.next.bind(generator)),
+    // Bind the return() method to execute within the provided context
+    return: import_api.context.bind(ctx, generator.return.bind(generator)),
+    // Bind the throw() method to execute within the provided context
+    throw: import_api.context.bind(ctx, generator.throw.bind(generator)),
+    // Ensure the async iterator symbol also returns a context-bound generator
+    [Symbol.asyncIterator]() {
+      return bindOtelContextToAsyncGenerator(
+        ctx,
+        generator[Symbol.asyncIterator]()
+      );
+    }
+  };
+}
+function runAsyncGeneratorWithOtelContext(otelContext, generatorFnContext, generatorFn) {
+  const generator = generatorFn.call(generatorFnContext);
+  return bindOtelContextToAsyncGenerator(otelContext, generator);
+}
+function shouldAddRequestResponseToSpans() {
+  const envValue = process.env.ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS || "true";
+  return envValue === "true" || envValue === "1";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runAsyncGeneratorWithOtelContext,
+  traceAgentInvocation,
+  traceCallLlm,
+  traceMergedToolCalls,
+  traceSendData,
+  traceToolCall,
+  tracer
+});