@google/adk 2.2.1 → 2.3.0

package/dist/esm/runner/runner.js

@@ -31,6 +31,7 @@ import {
   BuiltInCodeExecutor,
   isBuiltInCodeExecutor
 } from "../code_executors/built_in_code_executor.js";
+import { buildAbortEvents, isAbortEvent } from "../events/abort_events.js";
 import { createEvent } from "../events/event.js";
 import { createEventActions } from "../events/event_actions.js";
 import {
@@ -64,8 +65,8 @@ const _Runner = class _Runner {
    */
   constructor(input) {
     this[_a] = true;
-    var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
-    const appName = (_b = (_a2 = input.app) == null ? void 0 : _a2.name) != null ? _b : input.appName;
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const appName = (_b = input.appName) != null ? _b : (_a2 = input.app) == null ? void 0 : _a2.name;
     const agent = (_d = (_c = input.app) == null ? void 0 : _c.rootAgent) != null ? _d : input.agent;
     if (!agent) {
       throw new Error(
@@ -82,6 +83,20 @@ const _Runner = class _Runner {
     this.memoryService = input.memoryService;
     this.credentialService = input.credentialService;
     this.resumabilityConfig = (_i = (_h = input.app) == null ? void 0 : _h.resumabilityConfig) != null ? _i : input.resumabilityConfig;
+    this.autoCreateSession = (_j = input.autoCreateSession) != null ? _j : false;
+  }
+  /**
+   * Looks the session up, creating it first when `autoCreateSession` is set.
+   *
+   * A runner with no `appName` cannot address a session, so it falls through to
+   * the plain lookup rather than creating one under an undefined app name.
+   */
+  async resolveSession(userId, sessionId) {
+    const key = { appName: this.appName, userId, sessionId };
+    if (this.autoCreateSession && this.appName) {
+      return this.sessionService.getOrCreateSession(key);
+    }
+    return this.sessionService.getSession(key);
   }
   /**
    * Runs the agent with a new, ephemeral session.
@@ -142,12 +157,8 @@ const _Runner = class _Runner {
         ctx,
         this,
         async function* () {
-          var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
-          const session = await this.sessionService.getSession({
-            appName: this.appName,
-            userId,
-            sessionId
-          });
+          var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+          const session = await this.resolveSession(userId, sessionId);
           if ((_a2 = params.abortSignal) == null ? void 0 : _a2.aborted) {
             return;
           }
@@ -258,35 +269,45 @@ const _Runner = class _Runner {
               }
               yield earlyExitEvent;
             } else {
-              for await (const event of this.runRoot(invocationContext)) {
-                if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
-                  return;
-                }
-                const modifiedEvent = await this.pluginManager.runOnEventCallback({
-                  invocationContext,
-                  event
-                });
-                const outputEvent = modifiedEvent ? {
-                  ...withInternalMetadataOf(event, modifiedEvent),
-                  id: event.id,
-                  invocationId: event.invocationId,
-                  timestamp: event.timestamp,
-                  author: modifiedEvent.author || event.author,
-                  branch: (_i = modifiedEvent.branch) != null ? _i : event.branch
-                } : event;
-                if (!event.partial) {
-                  await this.sessionService.appendEvent({
-                    session,
-                    event: outputEvent
-                  });
+              let abortSealed = false;
+              const sealAbortedInvocation = /* @__PURE__ */ __name(() => {
+                abortSealed = true;
+                return this.synthesizeAbortEvents(invocationContext);
+              }, "sealAbortedInvocation");
+              try {
+                for await (const event of this.runRoot(invocationContext)) {
+                  if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
+                    break;
+                  }
+                  const outputEvent = await this.processAndAppendEvent(
+                    invocationContext,
+                    event
+                  );
+                  if ((_i = params.abortSignal) == null ? void 0 : _i.aborted) {
+                    break;
+                  }
+                  yield outputEvent;
                 }
                 if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
+                  for (const abortEvent of await sealAbortedInvocation()) {
+                    yield abortEvent;
+                  }
                   return;
                 }
-                yield outputEvent;
+              } finally {
+                if (((_k = params.abortSignal) == null ? void 0 : _k.aborted) && !abortSealed) {
+                  try {
+                    await sealAbortedInvocation();
+                  } catch (e) {
+                    logger.error(
+                      `Failed to seal aborted invocation ${invocationContext.invocationId}.`,
+                      e
+                    );
+                  }
+                }
               }
               await this.pluginManager.runAfterRunCallback({ invocationContext });
-              if ((_k = params.abortSignal) == null ? void 0 : _k.aborted) {
+              if ((_l = params.abortSignal) == null ? void 0 : _l.aborted) {
                 return;
               }
             }
@@ -318,6 +339,56 @@ const _Runner = class _Runner {
     }
     yield* runNodeAsInvocation(this.agent, invocationContext);
   }
+  /**
+   * Runs the on_event plugin callbacks on an event and appends the result to
+   * the session unless it is partial.
+   *
+   * @returns The event as streamed to the caller.
+   */
+  async processAndAppendEvent(invocationContext, event) {
+    var _a2;
+    const modifiedEvent = await this.pluginManager.runOnEventCallback({
+      invocationContext,
+      event
+    });
+    const outputEvent = modifiedEvent ? {
+      ...withInternalMetadataOf(event, modifiedEvent),
+      id: event.id,
+      invocationId: event.invocationId,
+      timestamp: event.timestamp,
+      author: modifiedEvent.author || event.author,
+      branch: (_a2 = modifiedEvent.branch) != null ? _a2 : event.branch
+    } : event;
+    if (!event.partial) {
+      await this.sessionService.appendEvent({
+        session: invocationContext.session,
+        event: outputEvent
+      });
+    }
+    return outputEvent;
+  }
+  /**
+   * Seals an aborted invocation in session history: answers its dangling
+   * function calls with error responses, or records a plain abort event when
+   * there is nothing to answer.
+   *
+   * @returns The synthetic events after plugin processing and persistence.
+   */
+  async synthesizeAbortEvents(invocationContext) {
+    const abortEvents = buildAbortEvents({
+      events: invocationContext.session.events,
+      invocationId: invocationContext.invocationId,
+      rootAgentName: this.agent.name,
+      branch: invocationContext.branch
+    });
+    const outputEvents = [];
+    for (const event of abortEvents) {
+      outputEvents.push(
+        await this.processAndAppendEvent(invocationContext, event)
+      );
+    }
+    return outputEvents;
+  }
   /**
    * Saves artifacts from the message parts and replaces the inline data with
    * a file name placeholder and optional file reference.
@@ -564,7 +635,8 @@ function isLiveModelMediaEventWithInlineData(event) {
 }
 __name(isLiveModelMediaEventWithInlineData, "isLiveModelMediaEventWithInlineData");
 function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
-  const event = findEventByLastFunctionResponseId(session.events);
+  const lastEvent = session.events[session.events.length - 1];
+  const event = lastEvent && !isAbortEvent(lastEvent) ? findEventByLastFunctionResponseId(session.events) : null;
   const isResumable = Boolean(resumabilityConfig == null ? void 0 : resumabilityConfig.isResumable);
   if (event && event.author && isResumable) {
     const conflictingAuthors = getConflictingFunctionResponseAuthors(
@@ -588,7 +660,7 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
   for (let i = session.events.length - 1; i >= 0; i--) {
     logger.debug("event:", stringifyWithRedactedInlineData(session.events[i]));
     const event2 = session.events[i];
-    if (event2.author === "user" || !event2.author) {
+    if (event2.author === "user" || !event2.author || isAbortEvent(event2)) {
       continue;
     }
     if (event2.author === rootAgent.name) {

package/dist/esm/sessions/db/operations.js

@@ -281,7 +281,7 @@ async function getConnectionOptionsFromUri(uri) {
     );
     return {
       entities: ENTITIES,
-      dbName: uri === "sqlite://:memory:" ? ":memory:" : uri.substring("sqlite://".length),
+      dbName: uri === "sqlite://:memory:" || uri === "sqlite:///:memory:" ? ":memory:" : uri.substring("sqlite://".length),
       driver: SqliteDriver
     };
   }

package/dist/esm/sessions/in_memory_session_service.js

@@ -47,7 +47,9 @@ const _InMemorySessionService = class _InMemorySessionService extends BaseSessio
     var _a;
     const filteredState = state ? trimTempState(state) : void 0;
     const session = createSession({
-      id: sessionId || randomUUID(),
+      // Surrounding whitespace is dropped so that a later lookup by the bare
+      // id finds the session, and a blank id gets a generated one.
+      id: (sessionId == null ? void 0 : sessionId.trim()) || randomUUID(),
       appName,
       userId,
       state: filteredState,

package/dist/esm/sessions/state.js

@@ -74,16 +74,19 @@ const _State = class _State {
   /**
    * Returns the value of the state dict for the given key.
    *
+   * Only keys the state holds itself are found. Names inherited from
+   * `Object.prototype`, such as `toString`, are treated as missing.
+   *
    * @param key The key to get the value for.
    * @param defaultValue The default value to return if the key is not found.
    * @return The value of the state for the given key, or the default value if
    *     not found.
    */
   get(key, defaultValue) {
-    if (key in this.delta) {
+    if (Object.hasOwn(this.delta, key)) {
       return this.delta[key];
     }
-    if (key in this.value) {
+    if (Object.hasOwn(this.value, key)) {
       return this.value[key];
     }
     return defaultValue;
@@ -101,10 +104,11 @@ const _State = class _State {
     recordStateWrite(this.value, this.delta, key);
   }
   /**
-   * Whether the state has pending delta.
+   * Whether the state holds the given key, either as a stored value or as a
+   * pending delta. Names inherited from `Object.prototype` are not keys.
    */
   has(key) {
-    return key in this.value || key in this.delta;
+    return Object.hasOwn(this.value, key) || Object.hasOwn(this.delta, key);
   }
   /**
    * Whether the state has pending delta.

package/dist/esm/sessions/vertex_ai_session_service.js

@@ -44,17 +44,22 @@ function quoteFilterLiteral(value) {
   return `"${escaped}"`;
 }
 __name(quoteFilterLiteral, "quoteFilterLiteral");
+function toStateMap(state) {
+  return Object.assign(/* @__PURE__ */ Object.create(null), state);
+}
+__name(toStateMap, "toStateMap");
 let VertexAiSessionService = class extends BaseSessionService {
   constructor(options) {
     super();
     this.agentEngineId = options.agentEngineId;
-    this.projectId = options.projectId;
-    this.location = options.location;
     this.expressModeApiKey = getExpressModeApiKey(
-      this.projectId,
-      this.location,
+      options.projectId,
+      options.location,
       options.expressModeApiKey
     );
+    const useEnvironment = !options.expressModeApiKey;
+    this.projectId = options.projectId || (useEnvironment ? process.env["GOOGLE_CLOUD_PROJECT"] : void 0);
+    this.location = options.location || (useEnvironment ? process.env["GOOGLE_CLOUD_LOCATION"] : void 0);
     if (options.sessions) {
       this.sessions = options.sessions;
     } else {
@@ -140,7 +145,7 @@ let VertexAiSessionService = class extends BaseSessionService {
       id,
       appName,
       userId,
-      state: getSessionResponse.sessionState,
+      state: toStateMap(getSessionResponse.sessionState),
       events: [],
       lastUpdateTime: getSessionResponse.updateTime ? Date.parse(getSessionResponse.updateTime) : Date.now()
     });
@@ -155,13 +160,14 @@ let VertexAiSessionService = class extends BaseSessionService {
     const sessionResourceName = `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`;
     try {
       let getSessionResponse;
-      let eventsIterator = [];
+      const eventsIterator = [];
+      const listConfig = {};
+      let pageToken;
       if (config && config.numRecentEvents === 0) {
         getSessionResponse = await this.sessions.get({
           name: sessionResourceName
         });
       } else {
-        const listConfig = {};
         if (config && config.afterTimestamp) {
           listConfig.filter = `timestamp>="${new Date(
             config.afterTimestamp
@@ -175,7 +181,9 @@ let VertexAiSessionService = class extends BaseSessionService {
           })
         ]);
         getSessionResponse = sessionRes;
-        eventsIterator = eventsRes.sessionEvents || [];
+        const firstPage = eventsRes;
+        eventsIterator.push(...firstPage.sessionEvents || []);
+        pageToken = firstPage.nextPageToken;
       }
       const sessionObj = getSessionResponse;
       if (sessionObj.userId !== userId) {
@@ -183,20 +191,29 @@ let VertexAiSessionService = class extends BaseSessionService {
           `Session ${sessionId} does not belong to user ${userId}.`
         );
       }
+      while (pageToken) {
+        const eventsRes = await this.sessions.events.listInternal({
+          name: sessionResourceName,
+          config: {
+            ...listConfig,
+            pageToken
+          }
+        });
+        eventsIterator.push(...eventsRes.sessionEvents || []);
+        pageToken = eventsRes.nextPageToken;
+      }
       const session = createSession({
         id: sessionId,
         appName,
         userId,
-        state: sessionObj.sessionState,
+        state: toStateMap(sessionObj.sessionState),
         events: [],
         lastUpdateTime: sessionObj.updateTime ? Date.parse(sessionObj.updateTime) : Date.now()
       });
-      for (const event of eventsIterator) {
+      const recentEvents = config && config.numRecentEvents ? eventsIterator.slice(-config.numRecentEvents) : eventsIterator;
+      for (const event of recentEvents) {
         session.events.push(_fromApiEvent(event));
       }
-      if (config && config.numRecentEvents) {
-        session.events = session.events.slice(-config.numRecentEvents);
-      }
       return session;
     } catch (error) {
       const err = error;
@@ -235,7 +252,7 @@ let VertexAiSessionService = class extends BaseSessionService {
             id,
             appName,
             userId: sessionObj.userId,
-            state: sessionObj.sessionState,
+            state: toStateMap(sessionObj.sessionState),
             events: [],
             lastUpdateTime: sessionObj.updateTime ? new Date(sessionObj.updateTime).getTime() : Date.now()
           })
@@ -481,7 +498,9 @@ function _fromApiEvent(apiEventObj) {
     }
   }
   const eventActions = {
-    stateDelta: actions["stateDelta"] || {},
+    stateDelta: toStateMap(
+      actions["stateDelta"]
+    ),
     artifactDelta: actions["artifactDelta"] || {},
     requestedAuthConfigs: actions.requestedAuthConfigs || {},
     requestedToolConfirmations: actions["requestedToolConfirmations"] || {},

package/dist/esm/telemetry/tracing.js

@@ -9,21 +9,46 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { context, trace } from "@opentelemetry/api";
 import { version } from "../version.js";
-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 ADK_WORKFLOW_NAME = "adk.workflow.name";
-const ADK_NODE_PATH = "adk.node.path";
-const ADK_NODE_RUN_ID = "adk.node.run_id";
-const ADK_NODE_ATTEMPT = "adk.node.attempt";
-const ADK_NODE_STATUS = "adk.node.status";
-const ADK_NODE_INTERRUPT_COUNT = "adk.node.interrupt_count";
-const tracer = trace.getTracer("gcp.vertex.agent", version);
+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["SYSTEM"] = "gen_ai.system";
+  GenAiAttr2["TOOL_CALL_ID"] = "gen_ai.tool.call.id";
+  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["USAGE_INPUT_TOKENS"] = "gen_ai.usage.input_tokens";
+  GenAiAttr2["USAGE_OUTPUT_TOKENS"] = "gen_ai.usage.output_tokens";
+  GenAiAttr2["RESPONSE_FINISH_REASONS"] = "gen_ai.response.finish_reasons";
+  return GenAiAttr2;
+})(GenAiAttr || {});
+var AdkAttr = /* @__PURE__ */ ((AdkAttr2) => {
+  AdkAttr2["WORKFLOW_NAME"] = "adk.workflow.name";
+  AdkAttr2["NODE_PATH"] = "adk.node.path";
+  AdkAttr2["NODE_RUN_ID"] = "adk.node.run_id";
+  AdkAttr2["NODE_ATTEMPT"] = "adk.node.attempt";
+  AdkAttr2["NODE_STATUS"] = "adk.node.status";
+  AdkAttr2["NODE_INTERRUPT_COUNT"] = "adk.node.interrupt_count";
+  return AdkAttr2;
+})(AdkAttr || {});
+var GcpAttr = /* @__PURE__ */ ((GcpAttr2) => {
+  GcpAttr2["INVOCATION_ID"] = "gcp.vertex.agent.invocation_id";
+  GcpAttr2["SESSION_ID"] = "gcp.vertex.agent.session_id";
+  GcpAttr2["EVENT_ID"] = "gcp.vertex.agent.event_id";
+  GcpAttr2["LLM_REQUEST"] = "gcp.vertex.agent.llm_request";
+  GcpAttr2["LLM_RESPONSE"] = "gcp.vertex.agent.llm_response";
+  GcpAttr2["TOOL_CALL_ARGS"] = "gcp.vertex.agent.tool_call_args";
+  GcpAttr2["TOOL_RESPONSE"] = "gcp.vertex.agent.tool_response";
+  GcpAttr2["DATA"] = "gcp.vertex.agent.data";
+  return GcpAttr2;
+})(GcpAttr || {});
+const GEN_AI_SYSTEM_VALUE = "gcp.vertex.agent";
+const tracer = trace.getTracer(GEN_AI_SYSTEM_VALUE, version);
 function safeJsonSerialize(obj) {
   try {
     return JSON.stringify(obj);
@@ -39,11 +64,11 @@ function traceAgentInvocation({
   const span = trace.getActiveSpan();
   if (!span) return;
   span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "invoke_agent",
+    ["gen_ai.operation.name" /* 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
+    ["gen_ai.agent.description" /* AGENT_DESCRIPTION */]: agent.description,
+    ["gen_ai.agent.name" /* AGENT_NAME */]: agent.name,
+    ["gen_ai.conversation.id" /* CONVERSATION_ID */]: invocationContext.session.id
   });
 }
 __name(traceAgentInvocation, "traceAgentInvocation");
@@ -55,10 +80,10 @@ function traceWorkflowInvocation({
   const span = trace.getActiveSpan();
   if (!span) return;
   span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "invoke_workflow",
-    [GEN_AI_CONVERSATION_ID]: sessionId,
-    [ADK_WORKFLOW_NAME]: workflowName,
-    [ADK_NODE_PATH]: nodePath
+    ["gen_ai.operation.name" /* OPERATION_NAME */]: "invoke_workflow",
+    ["gen_ai.conversation.id" /* CONVERSATION_ID */]: sessionId,
+    ["adk.workflow.name" /* WORKFLOW_NAME */]: workflowName,
+    ["adk.node.path" /* NODE_PATH */]: nodePath
   });
 }
 __name(traceWorkflowInvocation, "traceWorkflowInvocation");
@@ -72,34 +97,37 @@ function traceNodeExecution({
   const span = trace.getActiveSpan();
   if (!span) return;
   span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "execute_node",
-    [ADK_NODE_PATH]: nodePath,
-    [ADK_NODE_RUN_ID]: runId,
-    [ADK_NODE_ATTEMPT]: attempt,
-    [ADK_NODE_STATUS]: status,
-    [ADK_NODE_INTERRUPT_COUNT]: interruptCount
+    ["gen_ai.operation.name" /* OPERATION_NAME */]: "execute_node",
+    ["adk.node.path" /* NODE_PATH */]: nodePath,
+    ["adk.node.run_id" /* NODE_RUN_ID */]: runId,
+    ["adk.node.attempt" /* NODE_ATTEMPT */]: attempt,
+    ["adk.node.status" /* NODE_STATUS */]: status,
+    ["adk.node.interrupt_count" /* NODE_INTERRUPT_COUNT */]: interruptCount
   });
 }
 __name(traceNodeExecution, "traceNodeExecution");
 function traceToolCall({
   tool,
   args,
-  functionResponseEvent
+  functionResponseEvent,
+  invocationContext
 }) {
   var _a, _b;
   const span = 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,
+    ["gen_ai.operation.name" /* OPERATION_NAME */]: "execute_tool",
+    ["gen_ai.system" /* SYSTEM */]: GEN_AI_SYSTEM_VALUE,
+    ["gen_ai.tool.description" /* TOOL_DESCRIPTION */]: tool.description || "",
+    ["gen_ai.tool.name" /* TOOL_NAME */]: tool.name,
     // e.g. FunctionTool
-    [GEN_AI_TOOL_TYPE]: tool.constructor.name,
+    ["gen_ai.tool.type" /* TOOL_TYPE */]: tool.constructor.name,
+    ["gcp.vertex.agent.invocation_id" /* INVOCATION_ID */]: invocationContext.invocationId,
     // 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) : "{}"
+    ["gcp.vertex.agent.llm_request" /* LLM_REQUEST */]: "{}",
+    ["gcp.vertex.agent.llm_response" /* LLM_RESPONSE */]: "{}",
+    ["gcp.vertex.agent.tool_call_args" /* TOOL_CALL_ARGS */]: shouldAddRequestResponseToSpans() ? safeJsonSerialize(args) : "{}"
   });
   let toolCallId = "<not specified>";
   let toolResponse = "<not specified>";
@@ -117,32 +145,35 @@ function traceToolCall({
     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) : "{}"
+    ["gen_ai.tool.call.id" /* TOOL_CALL_ID */]: toolCallId,
+    ["gcp.vertex.agent.event_id" /* EVENT_ID */]: functionResponseEvent.id,
+    ["gcp.vertex.agent.tool_response" /* TOOL_RESPONSE */]: shouldAddRequestResponseToSpans() ? safeJsonSerialize(toolResponse) : "{}"
   });
 }
 __name(traceToolCall, "traceToolCall");
 function traceMergedToolCalls({
   responseEventId,
-  functionResponseEvent
+  functionResponseEvent,
+  invocationContext
 }) {
   const span = 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,
+    ["gen_ai.operation.name" /* OPERATION_NAME */]: "execute_tool",
+    ["gen_ai.system" /* SYSTEM */]: GEN_AI_SYSTEM_VALUE,
+    ["gen_ai.tool.name" /* TOOL_NAME */]: "(merged tools)",
+    ["gen_ai.tool.description" /* TOOL_DESCRIPTION */]: "(merged tools)",
+    ["gen_ai.tool.call.id" /* TOOL_CALL_ID */]: responseEventId,
+    ["gcp.vertex.agent.invocation_id" /* INVOCATION_ID */]: invocationContext.invocationId,
+    ["gcp.vertex.agent.tool_call_args" /* TOOL_CALL_ARGS */]: "N/A",
+    ["gcp.vertex.agent.event_id" /* 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": "{}"
+    ["gcp.vertex.agent.llm_request" /* LLM_REQUEST */]: "{}",
+    ["gcp.vertex.agent.llm_response" /* LLM_RESPONSE */]: "{}"
   });
   span.setAttribute(
-    "gcp.vertex.agent.tool_response",
+    "gcp.vertex.agent.tool_response" /* TOOL_RESPONSE */,
     shouldAddRequestResponseToSpans() ? safeJsonSerialize(functionResponseEvent) : "{}"
   );
 }
@@ -157,43 +188,43 @@ function traceCallLlm({
   const span = trace.getActiveSpan();
   if (!span) return;
   span.setAttributes({
-    "gen_ai.system": "gcp.vertex.agent",
-    "gen_ai.request.model": llmRequest.model,
-    ...((_a = invocationContext.agent) == null ? void 0 : _a.name) ? { [GEN_AI_AGENT_NAME]: invocationContext.agent.name } : {},
-    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
-    "gcp.vertex.agent.session_id": invocationContext.session.id,
-    "gcp.vertex.agent.event_id": eventId,
+    ["gen_ai.system" /* SYSTEM */]: GEN_AI_SYSTEM_VALUE,
+    ["gen_ai.request.model" /* REQUEST_MODEL */]: llmRequest.model,
+    ...((_a = invocationContext.agent) == null ? void 0 : _a.name) ? { ["gen_ai.agent.name" /* AGENT_NAME */]: invocationContext.agent.name } : {},
+    ["gcp.vertex.agent.invocation_id" /* INVOCATION_ID */]: invocationContext.invocationId,
+    ["gcp.vertex.agent.session_id" /* SESSION_ID */]: invocationContext.session.id,
+    ["gcp.vertex.agent.event_id" /* EVENT_ID */]: eventId,
     // Consider removing once GenAI SDK provides a way to record this info.
-    "gcp.vertex.agent.llm_request": shouldAddRequestResponseToSpans() ? safeJsonSerialize(buildLlmRequestForTrace(llmRequest)) : "{}"
+    ["gcp.vertex.agent.llm_request" /* LLM_REQUEST */]: shouldAddRequestResponseToSpans() ? safeJsonSerialize(buildLlmRequestForTrace(llmRequest)) : "{}"
   });
   if ((_b = llmRequest.config) == null ? void 0 : _b.topP) {
-    span.setAttribute("gen_ai.request.top_p", llmRequest.config.topP);
+    span.setAttribute("gen_ai.request.top_p" /* REQUEST_TOP_P */, llmRequest.config.topP);
   }
   if (((_c = llmRequest.config) == null ? void 0 : _c.maxOutputTokens) !== void 0) {
     span.setAttribute(
-      "gen_ai.request.max_tokens",
+      "gen_ai.request.max_tokens" /* REQUEST_MAX_TOKENS */,
       llmRequest.config.maxOutputTokens
     );
   }
   span.setAttribute(
-    "gcp.vertex.agent.llm_response",
+    "gcp.vertex.agent.llm_response" /* LLM_RESPONSE */,
     shouldAddRequestResponseToSpans() ? safeJsonSerialize(llmResponse) : "{}"
   );
   if (llmResponse.usageMetadata) {
     span.setAttribute(
-      "gen_ai.usage.input_tokens",
+      "gen_ai.usage.input_tokens" /* USAGE_INPUT_TOKENS */,
       llmResponse.usageMetadata.promptTokenCount || 0
     );
   }
   if ((_d = llmResponse.usageMetadata) == null ? void 0 : _d.candidatesTokenCount) {
     span.setAttribute(
-      "gen_ai.usage.output_tokens",
+      "gen_ai.usage.output_tokens" /* 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]);
+    span.setAttribute("gen_ai.response.finish_reasons" /* RESPONSE_FINISH_REASONS */, [finishReasonValue]);
   }
 }
 __name(traceCallLlm, "traceCallLlm");
@@ -205,11 +236,11 @@ function traceSendData({
   const span = trace.getActiveSpan();
   if (!span) return;
   span.setAttributes({
-    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
-    "gcp.vertex.agent.event_id": eventId
+    ["gcp.vertex.agent.invocation_id" /* INVOCATION_ID */]: invocationContext.invocationId,
+    ["gcp.vertex.agent.event_id" /* EVENT_ID */]: eventId
   });
   span.setAttribute(
-    "gcp.vertex.agent.data",
+    "gcp.vertex.agent.data" /* DATA */,
     shouldAddRequestResponseToSpans() ? safeJsonSerialize(data) : "{}"
   );
 }