@google/adk 2.2.0 → 2.3.0

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) : "{}"
   );
 }

package/dist/esm/tools/agent_tool.js

@@ -17,6 +17,44 @@ import { GoogleLLMVariant } from "../utils/variant_utils.js";
 import { State } from "../sessions/state.js";
 import { BaseTool } from "./base_tool.js";
 import { ForwardingArtifactService } from "./forwarding_artifact_service.js";
+import { parseWithSchema } from "../utils/schema.js";
+import { isZodSchema } from "../utils/simple_zod_to_json.js";
+function excludeNone(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => excludeNone(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      if (val !== null && val !== void 0) {
+        result[key] = excludeNone(val);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+__name(excludeNone, "excludeNone");
+function validateAndStripAgentInput(agent, args) {
+  var _a2;
+  if (typeof args !== "object" || args === null || Array.isArray(args)) {
+    throw new Error("AgentTool input args must be a plain object.");
+  }
+  const schema = isZodSchema(agent.inputSchema) ? agent.inputSchema : (_a2 = agent.inputSchemaSource) != null ? _a2 : agent.inputSchema;
+  const validated = parseWithSchema(schema, args);
+  return excludeNone(validated);
+}
+__name(validateAndStripAgentInput, "validateAndStripAgentInput");
+function validateAndStripAgentOutput(agent, mergedText) {
+  var _a2;
+  const parsed = JSON.parse(mergedText);
+  const validated = typeof agent.validateOutput === "function" ? agent.validateOutput(parsed) : parseWithSchema(
+    isZodSchema(agent.outputSchema) ? agent.outputSchema : (_a2 = agent.outputSchemaSource) != null ? _a2 : agent.outputSchema,
+    parsed
+  );
+  return excludeNone(validated);
+}
+__name(validateAndStripAgentOutput, "validateAndStripAgentOutput");
 const AGENT_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.agentTool");
 function isAgentTool(obj) {
   return typeof obj === "object" && obj !== null && AGENT_TOOL_SIGNATURE_SYMBOL in obj && obj[AGENT_TOOL_SIGNATURE_SYMBOL] === true;
@@ -70,6 +108,9 @@ const _AgentTool = class _AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGN
   }) {
     var _a2, _b2, _c, _d, _e, _f;
     const hasInputSchema = isLlmAgent(this.agent) && this.agent.inputSchema;
+    if (hasInputSchema && isLlmAgent(this.agent)) {
+      args = validateAndStripAgentInput(this.agent, args);
+    }
     const content = {
       role: "user",
       parts: [
@@ -124,6 +165,9 @@ const _AgentTool = class _AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGN
     }
     const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;
     const mergedText = lastEvent.content.parts.filter((part) => !part.thought).map((part) => part.text).filter((text) => text).join("\n");
+    if (hasOutputSchema && isLlmAgent(this.agent)) {
+      return validateAndStripAgentOutput(this.agent, mergedText);
+    }
     return hasOutputSchema ? JSON.parse(mergedText) : mergedText;
   }
 };

package/dist/esm/tools/apihub_tool/apihub_toolset.js

@@ -0,0 +1,106 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import yaml from "js-yaml";
+import { toSnakeCaseName } from "../../utils/case_utils.js";
+import { experimental } from "../../utils/experimental.js";
+import { BaseToolset } from "../base_toolset.js";
+import { OpenAPIToolset } from "../openapi_tool/openapi_toolset.js";
+import { APIHubClient } from "./clients/apihub_client.js";
+let APIHubToolset = class extends BaseToolset {
+  constructor(options) {
+    var _a, _b, _c, _d;
+    super([]);
+    this.name = (_a = options.name) != null ? _a : "";
+    this.description = (_b = options.description) != null ? _b : "";
+    this.apihubResourceName = options.apihubResourceName;
+    this.lazyLoadSpec = (_c = options.lazyLoadSpec) != null ? _c : false;
+    this.authScheme = options.authScheme;
+    this.authCredential = options.authCredential;
+    this.apihubClient = (_d = options.apihubClient) != null ? _d : new APIHubClient({
+      accessToken: options.accessToken,
+      serviceAccountJson: options.serviceAccountJson
+    });
+    if (!this.lazyLoadSpec) {
+      this.toolsetPromise = this.prepareTools();
+      this.toolsetPromise.catch(() => void 0);
+    }
+  }
+  /**
+   * Returns one tool per operation in the spec, or an empty array when the
+   * spec is empty.
+   *
+   * @throws When the spec cannot be fetched or is not valid YAML or JSON.
+   */
+  async getTools(context) {
+    const toolset = await this.loadToolset();
+    return toolset ? toolset.getTools(context) : [];
+  }
+  /**
+   * Returns the tool with the given name, or `undefined` when the spec
+   * produced no such tool.
+   *
+   * Unlike `OpenAPIToolset.getTool`, the result is a Promise, because the spec
+   * may still be loading.
+   *
+   * @param name The tool name, which is the operation ID in snake_case.
+   * @throws When the spec cannot be fetched or is not valid YAML or JSON.
+   */
+  async getTool(name) {
+    const toolset = await this.loadToolset();
+    return toolset == null ? void 0 : toolset.getTool(name);
+  }
+  async close() {
+  }
+  loadToolset() {
+    if (!this.toolsetPromise) {
+      const promise = this.prepareTools();
+      this.toolsetPromise = promise;
+      promise.catch(() => {
+        if (this.toolsetPromise === promise) {
+          this.toolsetPromise = void 0;
+        }
+      });
+    }
+    return this.toolsetPromise;
+  }
+  async prepareTools() {
+    var _a, _b, _c, _d;
+    const spec = await this.apihubClient.getSpecContent(
+      this.apihubResourceName
+    );
+    const specDict = yaml.load(spec);
+    if (!specDict) {
+      return void 0;
+    }
+    this.name || (this.name = toSnakeCaseName((_b = (_a = specDict.info) == null ? void 0 : _a.title) != null ? _b : "unnamed"));
+    this.description || (this.description = (_d = (_c = specDict.info) == null ? void 0 : _c.description) != null ? _d : "");
+    return new OpenAPIToolset({
+      specDict,
+      authScheme: this.authScheme,
+      authCredential: this.authCredential
+    });
+  }
+};
+__name(APIHubToolset, "APIHubToolset");
+APIHubToolset = __decorateClass([
+  experimental
+], APIHubToolset);
+export {
+  APIHubToolset
+};