@google/adk 2.3.0 → 2.5.0

package/dist/esm/telemetry/api/internal/common/accumulators.js

@@ -0,0 +1,139 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { context, createContextKey } from "@opentelemetry/api";
+import { TokenUsage } from "./token_usage.js";
+const AGENT_FRAME_KEY = createContextKey("adk_agent_frame");
+const WORKFLOW_FRAME_KEY = createContextKey("adk_workflow_frame");
+const AGENT_FRAME_SYMBOL = /* @__PURE__ */ Symbol("adk.telemetry.agentFrame");
+const WORKFLOW_FRAME_SYMBOL = /* @__PURE__ */ Symbol("adk.telemetry.workflowFrame");
+function isAgentFrame(value) {
+  return typeof value === "object" && value !== null && AGENT_FRAME_SYMBOL in value;
+}
+__name(isAgentFrame, "isAgentFrame");
+function isWorkflowFrame(value) {
+  return typeof value === "object" && value !== null && WORKFLOW_FRAME_SYMBOL in value;
+}
+__name(isWorkflowFrame, "isWorkflowFrame");
+function getAgentFrame(ctx) {
+  const value = ctx.getValue(AGENT_FRAME_KEY);
+  return isAgentFrame(value) ? value : void 0;
+}
+__name(getAgentFrame, "getAgentFrame");
+function getWorkflowFrame(ctx) {
+  const value = ctx.getValue(WORKFLOW_FRAME_KEY);
+  return isWorkflowFrame(value) ? value : void 0;
+}
+__name(getWorkflowFrame, "getWorkflowFrame");
+function createTotals() {
+  return {
+    tokens: void 0,
+    inferenceCalls: 0,
+    toolCalls: 0,
+    skillLoads: 0,
+    compactions: 0
+  };
+}
+__name(createTotals, "createTotals");
+function openAgentFrame(parentContext = context.active()) {
+  const frame = {
+    [AGENT_FRAME_SYMBOL]: true,
+    totals: createTotals()
+  };
+  return {
+    frame,
+    context: parentContext.setValue(AGENT_FRAME_KEY, frame)
+  };
+}
+__name(openAgentFrame, "openAgentFrame");
+function openWorkflowFrame({
+  workflowName,
+  config,
+  entrypoint,
+  parentContext = context.active()
+}) {
+  var _a, _b;
+  const enclosing = getWorkflowFrame(parentContext);
+  const frame = {
+    [WORKFLOW_FRAME_SYMBOL]: true,
+    totals: createTotals(),
+    parent: enclosing,
+    rootAgentName: (_a = enclosing == null ? void 0 : enclosing.rootAgentName) != null ? _a : workflowName,
+    workflowName,
+    config: (_b = enclosing == null ? void 0 : enclosing.config) != null ? _b : config,
+    entrypoint
+  };
+  return {
+    frame,
+    context: parentContext.setValue(WORKFLOW_FRAME_KEY, frame)
+  };
+}
+__name(openWorkflowFrame, "openWorkflowFrame");
+function claimEntrypointWorkflowFrame(workflow, ctx = context.active()) {
+  const frame = getWorkflowFrame(ctx);
+  if (frame === void 0 || frame.entrypoint !== workflow) {
+    return void 0;
+  }
+  frame.entrypoint = void 0;
+  return ctx;
+}
+__name(claimEntrypointWorkflowFrame, "claimEntrypointWorkflowFrame");
+function captureAccumulators(ctx = context.active()) {
+  const agent = getAgentFrame(ctx);
+  const workflow = getWorkflowFrame(ctx);
+  const each = /* @__PURE__ */ __name((fn) => {
+    if (agent) {
+      fn(agent.totals);
+    }
+    let current = workflow;
+    while (current) {
+      fn(current.totals);
+      current = current.parent;
+    }
+  }, "each");
+  return {
+    addInferenceCall() {
+      each((t) => {
+        t.inferenceCalls += 1;
+      });
+    },
+    addToolCall() {
+      each((t) => {
+        t.toolCalls += 1;
+      });
+    },
+    addSkillLoad() {
+      each((t) => {
+        t.skillLoads += 1;
+      });
+    },
+    addCompaction() {
+      let current = workflow;
+      while (current) {
+        current.totals.compactions += 1;
+        current = current.parent;
+      }
+    },
+    addTokens(usage) {
+      each((t) => {
+        if (t.tokens === void 0) {
+          t.tokens = new TokenUsage();
+        }
+        t.tokens.add(usage);
+      });
+    }
+  };
+}
+__name(captureAccumulators, "captureAccumulators");
+export {
+  captureAccumulators,
+  claimEntrypointWorkflowFrame,
+  openAgentFrame,
+  openWorkflowFrame
+};

package/dist/esm/telemetry/api/internal/common/attributes.js

@@ -0,0 +1,94 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var GenAiAttr = /* @__PURE__ */ ((GenAiAttr2) => {
+  GenAiAttr2["AGENT_DESCRIPTION"] = "gen_ai.agent.description";
+  GenAiAttr2["AGENT_NAME"] = "gen_ai.agent.name";
+  GenAiAttr2["CONVERSATION_ID"] = "gen_ai.conversation.id";
+  GenAiAttr2["OPERATION_NAME"] = "gen_ai.operation.name";
+  GenAiAttr2["PROVIDER_NAME"] = "gen_ai.provider.name";
+  GenAiAttr2["SYSTEM"] = "gen_ai.system";
+  GenAiAttr2["WORKFLOW_NAME"] = "gen_ai.workflow.name";
+  GenAiAttr2["WORKFLOW_NESTED"] = "gen_ai.workflow.nested";
+  GenAiAttr2["TOOL_CALL_ID"] = "gen_ai.tool.call.id";
+  GenAiAttr2["TOOL_CALL_ARGUMENTS"] = "gen_ai.tool.call.arguments";
+  GenAiAttr2["TOOL_CALL_RESULT"] = "gen_ai.tool.call.result";
+  GenAiAttr2["TOOL_DEFINITIONS"] = "gen_ai.tool.definitions";
+  GenAiAttr2["TOOL_DESCRIPTION"] = "gen_ai.tool.description";
+  GenAiAttr2["TOOL_NAME"] = "gen_ai.tool.name";
+  GenAiAttr2["TOOL_TYPE"] = "gen_ai.tool.type";
+  GenAiAttr2["REQUEST_MODEL"] = "gen_ai.request.model";
+  GenAiAttr2["REQUEST_TOP_P"] = "gen_ai.request.top_p";
+  GenAiAttr2["REQUEST_MAX_TOKENS"] = "gen_ai.request.max_tokens";
+  GenAiAttr2["RESPONSE_FINISH_REASONS"] = "gen_ai.response.finish_reasons";
+  GenAiAttr2["INPUT_MESSAGES"] = "gen_ai.input.messages";
+  GenAiAttr2["OUTPUT_MESSAGES"] = "gen_ai.output.messages";
+  GenAiAttr2["SYSTEM_INSTRUCTIONS"] = "gen_ai.system_instructions";
+  GenAiAttr2["USAGE_INPUT_TOKENS"] = "gen_ai.usage.input_tokens";
+  GenAiAttr2["USAGE_OUTPUT_TOKENS"] = "gen_ai.usage.output_tokens";
+  GenAiAttr2["USAGE_CACHE_READ_INPUT_TOKENS"] = "gen_ai.usage.cache_read.input_tokens";
+  GenAiAttr2["USAGE_REASONING_OUTPUT_TOKENS"] = "gen_ai.usage.reasoning.output_tokens";
+  GenAiAttr2["SKILL_NAME"] = "gen_ai.skill.name";
+  GenAiAttr2["SKILL_DESCRIPTION"] = "gen_ai.skill.description";
+  GenAiAttr2["SKILL_RESOURCE_NAME"] = "gen_ai.skill.resource.name";
+  GenAiAttr2["COMPACTION_TRIGGER"] = "gen_ai.compaction.trigger";
+  GenAiAttr2["COMPACTION_EVENT_COUNT"] = "gen_ai.compaction.event_count";
+  GenAiAttr2["COMPACTION_RESULT_EVENT_ID"] = "gen_ai.compaction.result_event_id";
+  GenAiAttr2["COMPACTION_START_TIMESTAMP"] = "gen_ai.compaction.start_timestamp";
+  GenAiAttr2["COMPACTION_END_TIMESTAMP"] = "gen_ai.compaction.end_timestamp";
+  return GenAiAttr2;
+})(GenAiAttr || {});
+var AdkAttr = /* @__PURE__ */ ((AdkAttr2) => {
+  AdkAttr2["SKILL_ADDITIONAL_TOOLS"] = "adk.skill.additional_tools";
+  AdkAttr2["EXPERIMENTAL_ROOT_AGENT_NAME"] = "adk.experimental.root_agent.name";
+  AdkAttr2["EXPERIMENTAL_GROUNDING_QUERY_COUNT"] = "adk.experimental.grounding.query_count";
+  AdkAttr2["EXPERIMENTAL_GROUNDING_CHUNK_COUNT"] = "adk.experimental.grounding.chunk_count";
+  AdkAttr2["EXPERIMENTAL_GROUNDING_WEB_SEARCH_QUERIES"] = "adk.experimental.grounding.web_search_queries";
+  AdkAttr2["EXPERIMENTAL_GROUNDING_SOURCE_URIS"] = "adk.experimental.grounding.source_uris";
+  return AdkAttr2;
+})(AdkAttr || {});
+var GcpAttr = /* @__PURE__ */ ((GcpAttr2) => {
+  GcpAttr2["INVOCATION_ID"] = "gcp.vertex.agent.invocation_id";
+  GcpAttr2["EVENT_ID"] = "gcp.vertex.agent.event_id";
+  GcpAttr2["ASSOCIATED_EVENT_IDS"] = "gcp.vertex.agent.associated_event_ids";
+  GcpAttr2["DATA"] = "gcp.vertex.agent.data";
+  return GcpAttr2;
+})(GcpAttr || {});
+var HttpAttr = /* @__PURE__ */ ((HttpAttr2) => {
+  HttpAttr2["REQUEST_METHOD"] = "http.request.method";
+  HttpAttr2["RESPONSE_STATUS_CODE"] = "http.response.status_code";
+  HttpAttr2["REQUEST_BODY_CONTENT"] = "http.request.body.content";
+  HttpAttr2["RESPONSE_BODY_CONTENT"] = "http.response.body.content";
+  HttpAttr2["REQUEST_HEADER_PREFIX"] = "http.request.header.";
+  HttpAttr2["RESPONSE_HEADER_PREFIX"] = "http.response.header.";
+  HttpAttr2["URL_FULL"] = "url.full";
+  HttpAttr2["SERVER_ADDRESS"] = "server.address";
+  HttpAttr2["SERVER_PORT"] = "server.port";
+  return HttpAttr2;
+})(HttpAttr || {});
+var McpAttr = /* @__PURE__ */ ((McpAttr2) => {
+  McpAttr2["SESSION_ID"] = "mcp.session.id";
+  McpAttr2["PROTOCOL_VERSION"] = "mcp.protocol.version";
+  return McpAttr2;
+})(McpAttr || {});
+const ERROR_TYPE_ATTR = "error.type";
+const USER_ID_ATTR = "user.id";
+const SUPPORT_ID_ATTR = "supportID";
+const GEN_AI_SYSTEM_VALUE = "gcp.vertex.agent";
+const SCHEMA_URL = "https://opentelemetry.io/schemas/1.44.0";
+export {
+  AdkAttr,
+  ERROR_TYPE_ATTR,
+  GEN_AI_SYSTEM_VALUE,
+  GcpAttr,
+  GenAiAttr,
+  HttpAttr,
+  McpAttr,
+  SCHEMA_URL,
+  SUPPORT_ID_ATTR,
+  USER_ID_ATTR
+};

package/dist/esm/telemetry/api/internal/common/config.js

@@ -0,0 +1,128 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getEnvVar } from "../../../../utils/env_aware_utils.js";
+import { logger } from "../../../../utils/logger.js";
+const CAPTURE_MESSAGE_CONTENT_ENV = "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT";
+const EXPERIMENTAL_TELEMETRY_ENV = "ADK_EXPERIMENTAL_TELEMETRY";
+const EXPERIMENTAL_TELEMETRY_FEATURES_ENV = "ADK_EXPERIMENTAL_TELEMETRY_FEATURES";
+const IGNORE_RUN_CONFIG_ENV = "ADK_TELEMETRY_IGNORE_RUN_CONFIG";
+const TRUTHY_ENV_VALUES = /* @__PURE__ */ new Set(["1", "true"]);
+const CONTENT_CAPTURING_MODES = /* @__PURE__ */ new Set([
+  "NO_CONTENT",
+  "EVENT_ONLY",
+  "SPAN_ONLY",
+  "SPAN_AND_EVENT"
+]);
+const EXPERIMENTAL_FEATURES = /* @__PURE__ */ new Set(
+  [
+    "skills",
+    "workflow",
+    "context_cache",
+    "grounding",
+    "mcp",
+    "token_usage",
+    "compaction"
+  ]
+);
+const warnedFeatures = /* @__PURE__ */ new Set();
+function isExperimentalFeature(value) {
+  return EXPERIMENTAL_FEATURES.has(value);
+}
+__name(isExperimentalFeature, "isExperimentalFeature");
+function isContentCapturingMode(value) {
+  return CONTENT_CAPTURING_MODES.has(value);
+}
+__name(isContentCapturingMode, "isContentCapturingMode");
+function readContentCapturingMode() {
+  var _a;
+  const value = ((_a = getEnvVar(CAPTURE_MESSAGE_CONTENT_ENV)) != null ? _a : "").trim();
+  if (TRUTHY_ENV_VALUES.has(value.toLowerCase())) {
+    return "EVENT_ONLY";
+  }
+  const mode = value.toUpperCase();
+  return isContentCapturingMode(mode) ? mode : "NO_CONTENT";
+}
+__name(readContentCapturingMode, "readContentCapturingMode");
+function isTruthyEnv(name) {
+  var _a;
+  return TRUTHY_ENV_VALUES.has(((_a = getEnvVar(name)) != null ? _a : "").trim().toLowerCase());
+}
+__name(isTruthyEnv, "isTruthyEnv");
+function normalizeExperimentalFeatures(names) {
+  const features = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const feature = name.trim().toLowerCase();
+    if (!feature) {
+      continue;
+    }
+    if (isExperimentalFeature(feature)) {
+      features.add(feature);
+    } else if (!warnedFeatures.has(feature)) {
+      warnedFeatures.add(feature);
+      logger.warn(
+        `Ignoring unrecognized experimental telemetry feature: ${feature}`
+      );
+    }
+  }
+  return features;
+}
+__name(normalizeExperimentalFeatures, "normalizeExperimentalFeatures");
+function resolveTelemetryConfig(overrides) {
+  var _a, _b, _c;
+  const env = {
+    contentCapturingMode: readContentCapturingMode(),
+    experimentalTelemetry: isTruthyEnv(EXPERIMENTAL_TELEMETRY_ENV),
+    experimentalFeatures: normalizeExperimentalFeatures(
+      ((_a = getEnvVar(EXPERIMENTAL_TELEMETRY_FEATURES_ENV)) != null ? _a : "").split(",")
+    )
+  };
+  if (overrides === void 0 || isTruthyEnv(IGNORE_RUN_CONFIG_ENV)) {
+    return env;
+  }
+  const contentCapturingMode = (_b = overrides.captureMessageContent) != null ? _b : env.contentCapturingMode;
+  if (overrides.adkExperimentalTelemetryOptIn !== void 0) {
+    return {
+      contentCapturingMode,
+      experimentalTelemetry: overrides.adkExperimentalTelemetryOptIn,
+      experimentalFeatures: /* @__PURE__ */ new Set()
+    };
+  }
+  const features = normalizeExperimentalFeatures(
+    (_c = overrides.experimentalFeaturesOptIn) != null ? _c : []
+  );
+  if (features.size > 0) {
+    return {
+      contentCapturingMode,
+      experimentalTelemetry: false,
+      experimentalFeatures: features
+    };
+  }
+  return { ...env, contentCapturingMode };
+}
+__name(resolveTelemetryConfig, "resolveTelemetryConfig");
+function shouldAddContentToLogs(config) {
+  return config.contentCapturingMode === "EVENT_ONLY" || config.contentCapturingMode === "SPAN_AND_EVENT";
+}
+__name(shouldAddContentToLogs, "shouldAddContentToLogs");
+function shouldAddContentToSpans(config) {
+  return config.contentCapturingMode === "SPAN_ONLY" || config.contentCapturingMode === "SPAN_AND_EVENT";
+}
+__name(shouldAddContentToSpans, "shouldAddContentToSpans");
+function isExperimentalFeatureEnabled(config, feature) {
+  return config.experimentalTelemetry || config.experimentalFeatures.has(feature);
+}
+__name(isExperimentalFeatureEnabled, "isExperimentalFeatureEnabled");
+export {
+  isExperimentalFeatureEnabled,
+  isTruthyEnv,
+  resolveTelemetryConfig,
+  shouldAddContentToLogs,
+  shouldAddContentToSpans
+};

package/dist/esm/telemetry/api/internal/common/error.js

@@ -0,0 +1,69 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ApiError } from "@google/genai";
+function normalizeErrorClassification(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return void 0;
+}
+__name(normalizeErrorClassification, "normalizeErrorClassification");
+function resolveErrorType(error) {
+  var _a, _b;
+  if (error !== null && (typeof error === "object" || typeof error === "function")) {
+    try {
+      const errorObject = error;
+      const customErrorType = (_a = normalizeErrorClassification(errorObject.errorType)) != null ? _a : normalizeErrorClassification(errorObject.error_type);
+      if (customErrorType !== void 0) {
+        return customErrorType;
+      }
+      if (error instanceof ApiError) {
+        const apiStatus = normalizeErrorClassification(error.status);
+        if (apiStatus !== void 0) {
+          return apiStatus;
+        }
+      }
+      const constructorName = normalizeErrorClassification(
+        (_b = errorObject.constructor) == null ? void 0 : _b.name
+      );
+      if (constructorName !== void 0) {
+        return constructorName;
+      }
+    } catch {
+    }
+  }
+  return typeof error;
+}
+__name(resolveErrorType, "resolveErrorType");
+function getToolResponseErrorType(result) {
+  var _a, _b, _c;
+  if (result === null || typeof result !== "object" || Array.isArray(result)) {
+    return void 0;
+  }
+  try {
+    if (!Object.hasOwn(result, "error")) {
+      return void 0;
+    }
+    const response = result;
+    return (_c = (_b = (_a = normalizeErrorClassification(response.errorType)) != null ? _a : normalizeErrorClassification(response.error_type)) != null ? _b : normalizeErrorClassification(response.errorCode)) != null ? _c : normalizeErrorClassification(response.error_code);
+  } catch {
+    return void 0;
+  }
+}
+__name(getToolResponseErrorType, "getToolResponseErrorType");
+export {
+  getToolResponseErrorType,
+  normalizeErrorClassification,
+  resolveErrorType
+};

package/dist/esm/telemetry/api/internal/common/finish_reason.js

@@ -0,0 +1,35 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FinishReason } from "@google/genai";
+function isReportedFinishReason(finishReason) {
+  return finishReason !== void 0 && finishReason !== FinishReason.FINISH_REASON_UNSPECIFIED;
+}
+__name(isReportedFinishReason, "isReportedFinishReason");
+function toOutputMessageFinishReason(finishReason) {
+  if (!isReportedFinishReason(finishReason)) {
+    return "";
+  }
+  switch (finishReason) {
+    // The output message schema has no value for OTHER.
+    case FinishReason.OTHER:
+      return "error";
+    case FinishReason.STOP:
+      return "stop";
+    case FinishReason.MAX_TOKENS:
+      return "length";
+    default:
+      return String(finishReason).toLowerCase();
+  }
+}
+__name(toOutputMessageFinishReason, "toOutputMessageFinishReason");
+export {
+  isReportedFinishReason,
+  toOutputMessageFinishReason
+};

package/dist/esm/telemetry/api/internal/common/genai_messages.js

@@ -0,0 +1,188 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { toSnakeCaseName } from "../../../../utils/case_utils.js";
+import { GenAiAttr } from "./attributes.js";
+import { toOutputMessageFinishReason } from "./finish_reason.js";
+const FUNCTION_TOOL_DEFINITION_TYPE = "function";
+function toAnyValue(value, seen) {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value !== "object" || seen.has(value)) {
+    return "<not serializable>";
+  }
+  const nextSeen = new Set(seen).add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => toAnyValue(item, nextSeen));
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item !== void 0) {
+      result[key] = toAnyValue(item, nextSeen);
+    }
+  }
+  return result;
+}
+__name(toAnyValue, "toAnyValue");
+function toOptionalMapping(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  const normalized = toAnyValue(value, /* @__PURE__ */ new Set());
+  return typeof normalized === "object" && normalized !== null && !Array.isArray(normalized) && !(normalized instanceof Uint8Array) ? normalized : { value: normalized };
+}
+__name(toOptionalMapping, "toOptionalMapping");
+function toRole(role) {
+  if (role === "user") {
+    return "user";
+  }
+  if (role === "model") {
+    return "assistant";
+  }
+  return "";
+}
+__name(toRole, "toRole");
+function toMessagePart(part, index) {
+  var _a, _b, _c, _d, _e, _f;
+  const fallbackId = /* @__PURE__ */ __name((name) => name ? `${name}_${index}` : `${index}`, "fallbackId");
+  if (part.text !== void 0) {
+    return { content: part.text, type: "text" };
+  }
+  if (part.inlineData) {
+    return { mime_type: (_a = part.inlineData.mimeType) != null ? _a : "", type: "blob" };
+  }
+  if (part.fileData) {
+    return {
+      mime_type: (_b = part.fileData.mimeType) != null ? _b : "",
+      uri: (_c = part.fileData.fileUri) != null ? _c : "",
+      type: "file_data"
+    };
+  }
+  if (part.functionCall) {
+    const call = part.functionCall;
+    return {
+      id: (_d = call.id) != null ? _d : fallbackId(call.name),
+      name: (_e = call.name) != null ? _e : "",
+      arguments: toOptionalMapping(call.args),
+      type: "tool_call"
+    };
+  }
+  if (part.functionResponse) {
+    const response = part.functionResponse;
+    return {
+      id: (_f = response.id) != null ? _f : fallbackId(response.name),
+      response: toOptionalMapping(response.response),
+      type: "tool_call_response"
+    };
+  }
+  return void 0;
+}
+__name(toMessagePart, "toMessagePart");
+function toMessageParts(parts) {
+  return (parts != null ? parts : []).flatMap((part, index) => {
+    const converted = toMessagePart(part, index);
+    return converted ? [converted] : [];
+  });
+}
+__name(toMessageParts, "toMessageParts");
+function toInputMessage(content) {
+  return { role: toRole(content.role), parts: toMessageParts(content.parts) };
+}
+__name(toInputMessage, "toInputMessage");
+function isContent(value) {
+  return "parts" in value || "role" in value;
+}
+__name(isContent, "isContent");
+function toParts(instruction) {
+  var _a;
+  if (typeof instruction === "string") {
+    return [{ text: instruction }];
+  }
+  if (Array.isArray(instruction)) {
+    return instruction.map(
+      (part) => typeof part === "string" ? { text: part } : part
+    );
+  }
+  return isContent(instruction) ? (_a = instruction.parts) != null ? _a : [] : [instruction];
+}
+__name(toParts, "toParts");
+function toSystemInstructions(config) {
+  if (!(config == null ? void 0 : config.systemInstruction)) {
+    return [];
+  }
+  return toMessageParts(toParts(config.systemInstruction));
+}
+__name(toSystemInstructions, "toSystemInstructions");
+function toToolDefinitions(tool) {
+  var _a, _b, _c;
+  if (!("functionDeclarations" in tool) && "callTool" in tool) {
+    return [{ name: "UnserializableTool", type: "CallableTool" }];
+  }
+  const definitions = [];
+  for (const declaration of (_a = tool.functionDeclarations) != null ? _a : []) {
+    const parameters = (_b = declaration.parameters) != null ? _b : declaration.parametersJsonSchema;
+    definitions.push({
+      name: (_c = declaration.name) != null ? _c : "FunctionDeclaration",
+      description: declaration.description,
+      parameters: parameters === void 0 ? null : toOptionalMapping(parameters),
+      type: FUNCTION_TOOL_DEFINITION_TYPE
+    });
+  }
+  for (const [key, value] of Object.entries(tool)) {
+    if (key !== "functionDeclarations" && value !== void 0) {
+      const toolType = toSnakeCaseName(key);
+      definitions.push({ name: toolType, type: toolType });
+    }
+  }
+  return definitions;
+}
+__name(toToolDefinitions, "toToolDefinitions");
+function buildRequestOperationDetails(llmRequest) {
+  var _a, _b;
+  return {
+    [GenAiAttr.INPUT_MESSAGES]: llmRequest.contents.map(toInputMessage),
+    [GenAiAttr.SYSTEM_INSTRUCTIONS]: toSystemInstructions(llmRequest.config),
+    [GenAiAttr.TOOL_DEFINITIONS]: ((_b = (_a = llmRequest.config) == null ? void 0 : _a.tools) != null ? _b : []).flatMap(
+      toToolDefinitions
+    )
+  };
+}
+__name(buildRequestOperationDetails, "buildRequestOperationDetails");
+function buildOutputMessage(llmResponse) {
+  if (!llmResponse.content) {
+    return void 0;
+  }
+  return {
+    ...toInputMessage(llmResponse.content),
+    finish_reason: toOutputMessageFinishReason(llmResponse.finishReason)
+  };
+}
+__name(buildOutputMessage, "buildOutputMessage");
+function withoutContent(details) {
+  const toolDefinitions = details[GenAiAttr.TOOL_DEFINITIONS];
+  if (!(toolDefinitions == null ? void 0 : toolDefinitions.length)) {
+    return {};
+  }
+  return {
+    [GenAiAttr.TOOL_DEFINITIONS]: toolDefinitions.map((definition) => {
+      if (typeof definition !== "object" || definition === null || Array.isArray(definition) || definition instanceof Uint8Array || !("parameters" in definition)) {
+        return definition;
+      }
+      const { parameters: _parameters, ...rest } = definition;
+      return rest;
+    })
+  };
+}
+__name(withoutContent, "withoutContent");
+export {
+  buildOutputMessage,
+  buildRequestOperationDetails,
+  withoutContent
+};