@google/adk 2.2.0 → 2.3.0

package/dist/esm/events/abort_events.js

@@ -0,0 +1,110 @@
+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 {
+  createEvent,
+  getFunctionCalls,
+  getFunctionResponses,
+  isFinalResponse
+} from "./event.js";
+const INVOCATION_ABORTED = "INVOCATION_ABORTED";
+const ABORT_MESSAGE = "Invocation was aborted by client.";
+function isAbortEvent(event) {
+  return event.errorCode === INVOCATION_ABORTED;
+}
+__name(isAbortEvent, "isAbortEvent");
+function isPausedTaskReply(event) {
+  return Boolean(event.isolationScope) && event.author !== "user" && isFinalResponse(event);
+}
+__name(isPausedTaskReply, "isPausedTaskReply");
+function buildAbortEvents({
+  events,
+  invocationId,
+  rootAgentName,
+  branch
+}) {
+  var _a, _b;
+  const invocationEvents = events.filter(
+    (e) => e.invocationId === invocationId
+  );
+  if (invocationEvents.length > 0 && isPausedTaskReply(invocationEvents[invocationEvents.length - 1])) {
+    return [];
+  }
+  const answeredCallIds = /* @__PURE__ */ new Set();
+  for (const event of invocationEvents) {
+    for (const fr of getFunctionResponses(event)) {
+      if (fr.id) {
+        answeredCallIds.add(fr.id);
+      }
+    }
+  }
+  const groupedCalls = /* @__PURE__ */ new Map();
+  for (const event of invocationEvents) {
+    for (const fc of getFunctionCalls(event)) {
+      if (!fc.id || answeredCallIds.has(fc.id)) {
+        continue;
+      }
+      const callBranch = event.branch || branch;
+      const key = JSON.stringify([
+        (_a = event.author) != null ? _a : null,
+        callBranch != null ? callBranch : null,
+        (_b = event.isolationScope) != null ? _b : null
+      ]);
+      let group = groupedCalls.get(key);
+      if (!group) {
+        group = {
+          author: event.author,
+          branch: callBranch,
+          isolationScope: event.isolationScope,
+          calls: []
+        };
+        groupedCalls.set(key, group);
+      }
+      group.calls.push(fc);
+    }
+  }
+  if (groupedCalls.size === 0) {
+    return [
+      createEvent({
+        invocationId,
+        author: rootAgentName,
+        branch,
+        errorCode: INVOCATION_ABORTED,
+        errorMessage: ABORT_MESSAGE
+      })
+    ];
+  }
+  return [...groupedCalls.values()].map(
+    (group) => createEvent({
+      invocationId,
+      author: group.author,
+      branch: group.branch,
+      isolationScope: group.isolationScope,
+      content: {
+        role: "user",
+        parts: group.calls.map((fc) => ({
+          functionResponse: {
+            id: fc.id,
+            name: fc.name,
+            response: { error: ABORT_MESSAGE }
+          }
+        }))
+      },
+      errorCode: INVOCATION_ABORTED,
+      errorMessage: ABORT_MESSAGE
+    })
+  );
+}
+__name(buildAbortEvents, "buildAbortEvents");
+export {
+  ABORT_MESSAGE,
+  INVOCATION_ABORTED,
+  buildAbortEvents,
+  isAbortEvent
+};

package/dist/esm/events/event.js

@@ -91,8 +91,10 @@ function stringifyContent(event) {
 __name(stringifyContent, "stringifyContent");
 function getEventTokens(event) {
   var _a;
-  if (((_a = event.usageMetadata) == null ? void 0 : _a.promptTokenCount) !== void 0) {
-    return event.usageMetadata.promptTokenCount;
+  const usage = event.usageMetadata;
+  const promptTokenCount = (_a = usage == null ? void 0 : usage.initialPromptTokenCount) != null ? _a : usage == null ? void 0 : usage.promptTokenCount;
+  if (promptTokenCount !== void 0) {
+    return promptTokenCount;
   }
   const contentStr = stringifyContent(event);
   return Math.ceil(contentStr.length / 4);

package/dist/esm/events/internal_metadata.js

@@ -0,0 +1,97 @@
+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 { logger } from "../utils/logger.js";
+const INTERNAL_METADATA_PREFIX = "__adk_internal_";
+const RESTORED_EVENT_KEY = `${INTERNAL_METADATA_PREFIX}restored_event`;
+function isMetadataObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isMetadataObject, "isMetadataObject");
+function isInternalKey(key) {
+  return key.startsWith(INTERNAL_METADATA_PREFIX);
+}
+__name(isInternalKey, "isInternalKey");
+function dropInternalKeys(metadata) {
+  return Object.fromEntries(
+    Object.entries(metadata).filter(([key]) => !isInternalKey(key))
+  );
+}
+__name(dropInternalKeys, "dropInternalKeys");
+function hasInternalKeys(metadata) {
+  return isMetadataObject(metadata) && Object.keys(metadata).some(isInternalKey);
+}
+__name(hasInternalKeys, "hasInternalKeys");
+function withoutInternalMetadata(metadata) {
+  if (!isMetadataObject(metadata)) {
+    return metadata;
+  }
+  const kept = dropInternalKeys(metadata);
+  const dropped = Object.keys(metadata).filter(isInternalKey);
+  if (dropped.length > 0) {
+    logger.debug(
+      `Dropping ADK-internal customMetadata keys: ${JSON.stringify(dropped.sort())}`
+    );
+  }
+  return kept;
+}
+__name(withoutInternalMetadata, "withoutInternalMetadata");
+function publicMetadata(metadata) {
+  if (!isMetadataObject(metadata)) {
+    return metadata;
+  }
+  const kept = dropInternalKeys(metadata);
+  return Object.keys(kept).length > 0 ? kept : void 0;
+}
+__name(publicMetadata, "publicMetadata");
+function internalMetadata(metadata) {
+  if (!isMetadataObject(metadata)) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(metadata).filter(([key]) => isInternalKey(key))
+  );
+}
+__name(internalMetadata, "internalMetadata");
+function markRestored(event) {
+  var _a;
+  event.customMetadata = {
+    ...(_a = withoutInternalMetadata(event.customMetadata)) != null ? _a : {},
+    [RESTORED_EVENT_KEY]: true
+  };
+  return event;
+}
+__name(markRestored, "markRestored");
+function publicEvent(event) {
+  if (!hasInternalKeys(event.customMetadata)) {
+    return event;
+  }
+  return { ...event, customMetadata: publicMetadata(event.customMetadata) };
+}
+__name(publicEvent, "publicEvent");
+function publicSession(session) {
+  var _a;
+  const events = (_a = session.events) != null ? _a : [];
+  const publicEvents = events.map((event) => publicEvent(event));
+  if (publicEvents.every((event, i) => event === events[i])) {
+    return session;
+  }
+  return { ...session, events: publicEvents };
+}
+__name(publicSession, "publicSession");
+export {
+  INTERNAL_METADATA_PREFIX,
+  RESTORED_EVENT_KEY,
+  internalMetadata,
+  markRestored,
+  publicEvent,
+  publicMetadata,
+  publicSession,
+  withoutInternalMetadata
+};

package/dist/esm/examples/example_util.js

@@ -7,11 +7,30 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { z } from "zod";
+import { InputValidationError } from "../errors/input_validation_error.js";
 import { getFunctionResponses } from "../events/event.js";
 import { logger } from "../utils/logger.js";
 import {
   isBaseExampleProvider
 } from "./base_example_provider.js";
+const contentSchema = z.object({
+  role: z.string().optional(),
+  parts: z.array(z.object({}).loose()).optional()
+}).loose();
+const examplesSchema = z.array(
+  z.object({ input: contentSchema, output: z.array(contentSchema) })
+);
+function validateExamples(examples) {
+  const result = examplesSchema.safeParse(examples);
+  if (!result.success) {
+    throw new InputValidationError(
+      `Invalid few-shot examples:
+${z.prettifyError(result.error)}`
+    );
+  }
+}
+__name(validateExamples, "validateExamples");
 const EXAMPLES_INTRO = "<EXAMPLES>\nBegin few-shot\nThe following are examples of user queries and model responses using the available tools.\n\n";
 const EXAMPLES_END = "End few-shot\n<EXAMPLES>";
 const EXAMPLE_START = "EXAMPLE {}:\nBegin example\n";
@@ -102,5 +121,6 @@ export {
   _getLatestMessageFromUser,
   buildExampleSi,
   convertExamplesToText,
-  getLatestMessageFromUser
+  getLatestMessageFromUser,
+  validateExamples
 };

package/dist/esm/flows/llm_flows/audio_transcriber.js

@@ -0,0 +1,142 @@
+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
+ */
+var AudioEncoding = /* @__PURE__ */ ((AudioEncoding2) => {
+  AudioEncoding2[AudioEncoding2["ENCODING_UNSPECIFIED"] = 0] = "ENCODING_UNSPECIFIED";
+  AudioEncoding2[AudioEncoding2["LINEAR16"] = 1] = "LINEAR16";
+  return AudioEncoding2;
+})(AudioEncoding || {});
+function isSpeechClientLike(value) {
+  return typeof value === "object" && value !== null && typeof value.recognize === "function";
+}
+__name(isSpeechClientLike, "isSpeechClientLike");
+function isContentEntry(data) {
+  return "parts" in data || !("data" in data) && !("mimeType" in data);
+}
+__name(isContentEntry, "isContentEntry");
+function blobDataToBytes(data) {
+  if (typeof data !== "string") {
+    return data;
+  }
+  if (data.length > 0 && data.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(data)) {
+    const atobFn = globalThis.atob;
+    if (typeof Buffer === "undefined" && typeof atobFn === "function") {
+      const binary = atobFn(data);
+      return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    }
+    return new Uint8Array(Buffer.from(data, "base64"));
+  }
+  return new TextEncoder().encode(data);
+}
+__name(blobDataToBytes, "blobDataToBytes");
+function concatBytes(first, second) {
+  const merged = new Uint8Array(first.length + second.length);
+  merged.set(first, 0);
+  merged.set(second, first.length);
+  return merged;
+}
+__name(concatBytes, "concatBytes");
+const _AudioTranscriber = class _AudioTranscriber {
+  constructor(optionsOrClient) {
+    if (isSpeechClientLike(optionsOrClient)) {
+      this.client = optionsOrClient;
+    } else if (optionsOrClient == null ? void 0 : optionsOrClient.client) {
+      this.client = optionsOrClient.client;
+    } else {
+      this.client = {
+        recognize() {
+          throw new Error(
+            "SpeechClient is not configured on AudioTranscriber. Pass a SpeechClientLike implementation to new AudioTranscriber({client})."
+          );
+        }
+      };
+    }
+  }
+  /**
+   * Bundles consecutive audio blobs from the same speaker in
+   * `invocationContext.transcriptionCache`, transcribes user audio bundles into
+   * text `Content` entries, preserves already-transcribed `Content`
+   * entries in order, clears `invocationContext.transcriptionCache`, and
+   * returns the resulting content list.
+   *
+   * @param invocationContext The invocation context holding `transcriptionCache`.
+   * @returns Ordered list of transcribed `Content` objects.
+   */
+  async transcribeFile(invocationContext) {
+    var _a, _b, _c, _d;
+    const bundledAudio = [];
+    const transcriptionHistory = [];
+    let currentSpeaker = void 0;
+    let currentAudioData = new Uint8Array(0);
+    for (const transcriptionEntry of (_a = invocationContext.transcriptionCache) != null ? _a : []) {
+      const speaker = transcriptionEntry.role;
+      const audioData = transcriptionEntry.data;
+      if (isContentEntry(audioData)) {
+        if (currentSpeaker !== void 0) {
+          bundledAudio.push([currentSpeaker, currentAudioData]);
+          currentSpeaker = void 0;
+          currentAudioData = new Uint8Array(0);
+        }
+        bundledAudio.push([speaker, audioData]);
+        continue;
+      }
+      const rawData = audioData.data;
+      if (!rawData) {
+        continue;
+      }
+      const chunkBytes = blobDataToBytes(rawData);
+      if (chunkBytes.length === 0) {
+        continue;
+      }
+      if (speaker === currentSpeaker) {
+        currentAudioData = concatBytes(currentAudioData, chunkBytes);
+      } else {
+        if (currentSpeaker !== void 0) {
+          bundledAudio.push([currentSpeaker, currentAudioData]);
+        }
+        currentSpeaker = speaker;
+        currentAudioData = chunkBytes;
+      }
+    }
+    if (currentSpeaker !== void 0) {
+      bundledAudio.push([currentSpeaker, currentAudioData]);
+    }
+    invocationContext.transcriptionCache = [];
+    for (const [speaker, data] of bundledAudio) {
+      if (ArrayBuffer.isView(data)) {
+        const audio = { content: data };
+        const config = {
+          encoding: 1 /* LINEAR16 */,
+          sampleRateHertz: 16e3,
+          languageCode: "en-US"
+        };
+        const rawResponse = await this.client.recognize({ config, audio });
+        const response = Array.isArray(rawResponse) ? rawResponse[0] : rawResponse;
+        for (const result of (_b = response.results) != null ? _b : []) {
+          const transcript = (_d = (_c = result.alternatives) == null ? void 0 : _c[0]) == null ? void 0 : _d.transcript;
+          if (transcript !== void 0 && transcript !== null) {
+            transcriptionHistory.push({
+              role: speaker ? speaker.toLowerCase() : "user",
+              parts: [{ text: transcript }]
+            });
+          }
+        }
+      } else {
+        transcriptionHistory.push(data);
+      }
+    }
+    return transcriptionHistory;
+  }
+};
+__name(_AudioTranscriber, "AudioTranscriber");
+let AudioTranscriber = _AudioTranscriber;
+export {
+  AudioEncoding,
+  AudioTranscriber
+};

package/dist/esm/index.js

@@ -26,6 +26,10 @@ export * from "./common.js";
 import { LocalEnvironment } from "./environment/local_environment.js";
 import { VertexAiMemoryBankService } from "./memory/vertex_ai_memory_bank_service.js";
 import { VertexAiRagMemoryService } from "./memory/vertex_ai_rag_memory_service.js";
+import {
+  DebugLoggingPlugin,
+  isDebugLoggingPlugin
+} from "./plugins/debug_logging_plugin.js";
 import { DatabaseSessionService } from "./sessions/database_session_service.js";
 import { getSessionServiceFromUri } from "./sessions/registry.js";
 import { VertexAiSessionService } from "./sessions/vertex_ai_session_service.js";
@@ -36,6 +40,40 @@ import {
   loadSkillFromZipBuffer,
   validateSkillDir
 } from "./skills/loader.js";
+import {
+  APIHubToolset
+} from "./tools/apihub_tool/apihub_toolset.js";
+import {
+  APIHubClient
+} from "./tools/apihub_tool/clients/apihub_client.js";
+import {
+  SecretManagerClient
+} from "./tools/apihub_tool/clients/secret_client.js";
+import {
+  ApplicationIntegrationToolset
+} from "./tools/application_integration_tool/application_integration_toolset.js";
+import {
+  actionRequest,
+  actionResponse,
+  ConnectionsClient,
+  CONNECTOR_BASE_SPEC,
+  connectorPayload,
+  createOperation,
+  createOperationRequest,
+  deleteOperation,
+  deleteOperationRequest,
+  executeCustomQueryRequest,
+  getActionOperation,
+  getOperation,
+  getOperationRequest,
+  listOperation,
+  listOperationRequest,
+  updateOperation,
+  updateOperationRequest
+} from "./tools/application_integration_tool/clients/connections_client.js";
+import {
+  IntegrationClient
+} from "./tools/application_integration_tool/clients/integration_client.js";
 import { LOAD_WEB_PAGE, loadWebPage } from "./tools/load_web_page.js";
 import {
   credentialToParam,
@@ -54,6 +92,7 @@ import {
 } from "./tools/openapi_tool/auth/credential_exchangers/base_auth_credential_exchanger.js";
 import {
   exchangeCredential,
+  generateAuthToken,
   OAuth2BearerExchanger
 } from "./tools/openapi_tool/auth/credential_exchangers/oauth2_exchanger.js";
 import { ServiceAccountCredentialExchanger } from "./tools/openapi_tool/auth/credential_exchangers/service_account_exchanger.js";
@@ -86,59 +125,118 @@ import { SkillToolset } from "./tools/skill/skill_toolset.js";
 export * from "./integrations/agent_registry/agent_registry.js";
 export * from "./telemetry/google_cloud.js";
 export * from "./telemetry/setup.js";
+export * from "./tools/google_api_tool/index.js";
+import {
+  DEFAULT_CRITERIA,
+  EVAL_SESSION_ID_PREFIX,
+  EvalStatus,
+  getEvaluationCriteriaOrDefault,
+  getRootAgent,
+  MISSING_EVAL_DEPENDENCIES_MESSAGE,
+  parseAndGetEvalsToRun,
+  RESPONSE_EVALUATION_SCORE_KEY,
+  RESPONSE_MATCH_SCORE_KEY,
+  runEvals,
+  TOOL_TRAJECTORY_SCORE_KEY,
+  tryGetResetFunc
+} from "./cli/cli_eval.js";
+import { loadDotenvForAgent, walkToRootUntilFound } from "./cli/utils/envs.js";
+import { LOGGING_FORMAT, logToStderr, logToTmpFolder } from "./cli/utils/logs.js";
 export * from "./tools/mcp/index.js";
 export {
+  APIHubClient,
+  APIHubToolset,
   AgentEngineSandboxCodeExecutor,
+  ApplicationIntegrationToolset,
   AuthCredentialMissingError,
   AutoAuthCredentialExchanger,
   BaseAuthCredentialExchanger,
+  CONNECTOR_BASE_SPEC,
   CodeExecutionLanguage,
+  ConnectionsClient,
   ContainerCodeExecutor,
+  DEFAULT_CRITERIA,
   DatabaseSessionService,
+  DebugLoggingPlugin,
+  EVAL_SESSION_ID_PREFIX,
+  EvalStatus,
   FileArtifactService,
   FilesRetrieval,
   GCPSkillRegistry,
   GcsArtifactService,
   INTERNAL_AUTH_PREFIX,
+  IntegrationClient,
   InvocationContext,
   LOAD_WEB_PAGE,
+  LOGGING_FORMAT,
   LoadSkillResourceTool,
   LocalEnvironment,
+  MISSING_EVAL_DEPENDENCIES_MESSAGE,
   OAuth2BearerExchanger,
   OpenAPIToolset,
   OpenApiSpecParser,
   OperationParser,
+  RESPONSE_EVALUATION_SCORE_KEY,
+  RESPONSE_MATCH_SCORE_KEY,
   RestApiTool,
   RunSkillInlineScriptErrorCode,
   RunSkillInlineScriptTool,
   RunSkillScriptTool,
+  SecretManagerClient,
   ServiceAccountCredentialExchanger,
   SkillToolset,
+  TOOL_TRAJECTORY_SCORE_KEY,
   ToolAuthHandler,
   ToolContextCredentialStore,
   UnsafeLocalCodeExecutor,
   VertexAiMemoryBankService,
   VertexAiRagMemoryService,
   VertexAiSessionService,
+  actionRequest,
+  actionResponse,
+  connectorPayload,
   createApiParameter,
+  createOperation,
+  createOperationRequest,
   createRestApiTool,
   createRestApiToolFromJson,
   credentialToParam,
+  deleteOperation,
+  deleteOperationRequest,
   dictToAuthScheme,
   exchangeCredential,
+  executeCustomQueryRequest,
+  generateAuthToken,
   generateParamDoc,
   generateReturnDoc,
+  getActionOperation,
   getArtifactServiceFromUri,
+  getEvaluationCriteriaOrDefault,
+  getOperation,
+  getOperationRequest,
+  getRootAgent,
   getSessionServiceFromUri,
   getTypeHint,
+  isDebugLoggingPlugin,
+  listOperation,
+  listOperationRequest,
   loadAllSkillsInDir,
+  loadDotenvForAgent,
   loadSkillFromDir,
   loadSkillFromZipBuffer,
   loadWebPage,
+  logToStderr,
+  logToTmpFolder,
   openidDictToSchemeCredential,
   openidUrlToSchemeCredential,
+  parseAndGetEvalsToRun,
+  runEvals,
   serviceAccountDictToSchemeCredential,
   serviceAccountSchemeCredential,
   tokenToSchemeCredential,
-  validateSkillDir
+  tryGetResetFunc,
+  updateOperation,
+  updateOperationRequest,
+  validateSkillDir,
+  walkToRootUntilFound
 };

package/dist/esm/integrations/agent_registry/helpers.js

@@ -10,7 +10,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 function isGoogleApi(url) {
   try {
     const parsed = new URL(url);
-    return parsed.hostname === "googleapis.com" || parsed.hostname.endsWith(".googleapis.com");
+    return parsed.protocol === "https:" && (parsed.hostname === "googleapis.com" || parsed.hostname.endsWith(".googleapis.com"));
   } catch {
     return false;
   }

package/dist/esm/models/gemini_llm_connection.js

@@ -114,26 +114,34 @@ const _GeminiLlmConnection = class _GeminiLlmConnection {
     this.geminiSession.sendRealtimeInput({ activityEnd: {} });
   }
   /**
-   * Builds a full text response.
+   * Receives the model responses for one model turn.
    *
-   * The text should not be partial and the returned LlmResponse is not be
-   * partial.
+   * The generator ends after the message that completes the turn has been
+   * processed, or when the server closes the connection. Call `receive()`
+   * again to read the next turn; it continues from the next server message.
    *
-   * @param text The text to be included in the response.
-   * @param isThought Whether the text is a thought.
-   * @param groundingMetadata The grounding metadata to include.
-   * @returns An LlmResponse containing the full text.
+   * @returns A generator of the LlmResponses of one model turn.
    */
   async *receive() {
+    var _a, _b;
     if (!this.messageQueue) {
       throw new Error("Message queue is not initialized.");
     }
+    (_a = this.messageIterator) != null ? _a : this.messageIterator = this.messageQueue[Symbol.asyncIterator]();
     const aggregator = new LiveResponseAggregator(this.modelVersion);
-    for await (const message of this.messageQueue) {
+    while (true) {
+      const next = await this.messageIterator.next();
+      if (next.done) {
+        break;
+      }
+      const message = next.value;
       logger.debug("Got LLM Live message:", message);
       for (const response of aggregator.processMessage(message)) {
         yield response;
       }
+      if ((_b = message.serverContent) == null ? void 0 : _b.turnComplete) {
+        return;
+      }
     }
     for (const response of aggregator.close()) {
       yield response;