@google/adk 2.2.1 → 2.3.0

package/dist/cjs/agents/remote_agent.js

@@ -0,0 +1,187 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __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;
+};
+var remote_agent_exports = {};
+__export(remote_agent_exports, {
+  RemoteAgent: () => RemoteAgent,
+  isRemoteAgent: () => isRemoteAgent
+});
+module.exports = __toCommonJS(remote_agent_exports);
+var import_event = require("../events/event.js");
+var import_experimental = require("../utils/experimental.js");
+var import_base_agent = require("./base_agent.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const DEFAULT_REMOTE_AGENT_TIMEOUT_MS = 12e4;
+const MILLIS_PER_SECOND = 1e3;
+const SESSION_PRESERVE_KEYS = /* @__PURE__ */ new Set(["state", "events"]);
+const EVENT_PRESERVE_KEYS = /* @__PURE__ */ new Set([
+  "actions.state_delta",
+  "actions.artifact_delta",
+  "actions.requested_auth_configs",
+  "actions.requested_tool_confirmations",
+  "actions.custom_metadata",
+  "custom_metadata",
+  "content.parts.function_call.args",
+  "content.parts.function_response.response",
+  "output",
+  "route",
+  "actions.agent_state"
+]);
+const REMOTE_AGENT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.remoteAgent");
+function isRemoteAgent(obj) {
+  return typeof obj === "object" && obj !== null && REMOTE_AGENT_SIGNATURE_SYMBOL in obj && obj[REMOTE_AGENT_SIGNATURE_SYMBOL] === true;
+}
+__name(isRemoteAgent, "isRemoteAgent");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function stripNullish(value, preserveKeys, parentKey = "") {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripNullish(item, preserveKeys, parentKey));
+  }
+  if (value !== null && typeof value === "object") {
+    return stripNullishRecord(value, preserveKeys, parentKey);
+  }
+  return value;
+}
+__name(stripNullish, "stripNullish");
+function stripNullishRecord(record, preserveKeys, parentKey = "") {
+  const result = {};
+  for (const [key, entryValue] of Object.entries(record)) {
+    if (entryValue === void 0 || entryValue === null) {
+      continue;
+    }
+    const fullPath = parentKey !== "" ? `${parentKey}.${key}` : key;
+    result[key] = preserveKeys.has(fullPath) ? entryValue : stripNullish(entryValue, preserveKeys, fullPath);
+  }
+  return result;
+}
+__name(stripNullishRecord, "stripNullishRecord");
+function serializeEventToSnakeCase(event) {
+  const snakeEvent = (0, import_event.transformToSnakeCaseEvent)(event);
+  snakeEvent["timestamp"] = event.timestamp / MILLIS_PER_SECOND;
+  return stripNullishRecord(snakeEvent, EVENT_PRESERVE_KEYS);
+}
+__name(serializeEventToSnakeCase, "serializeEventToSnakeCase");
+function serializeSessionToSnakeCase(session) {
+  return stripNullishRecord(
+    {
+      id: session.id,
+      app_name: session.appName,
+      user_id: session.userId,
+      state: session.state,
+      events: session.events.map((event) => serializeEventToSnakeCase(event)),
+      last_update_time: session.lastUpdateTime / MILLIS_PER_SECOND
+    },
+    SESSION_PRESERVE_KEYS
+  );
+}
+__name(serializeSessionToSnakeCase, "serializeSessionToSnakeCase");
+let RemoteAgent = class extends (_b = import_base_agent.BaseAgent, _a = REMOTE_AGENT_SIGNATURE_SYMBOL, _b) {
+  constructor(config) {
+    var _a2, _b2;
+    const runtimeSubAgents = config.subAgents;
+    if (Array.isArray(runtimeSubAgents) ? runtimeSubAgents.length > 0 : Boolean(runtimeSubAgents)) {
+      throw new Error("subAgents is disabled in RemoteAgent.");
+    }
+    super({ ...config, subAgents: [] });
+    this[_a] = true;
+    this.url = config.url;
+    this.timeoutMs = (_a2 = config.timeoutMs) != null ? _a2 : DEFAULT_REMOTE_AGENT_TIMEOUT_MS;
+    this.fetchImpl = (_b2 = config.fetchImpl) != null ? _b2 : globalThis.fetch;
+  }
+  async *runAsyncImpl(ctx) {
+    var _a2;
+    const data = {
+      invocation_id: ctx.invocationId,
+      session: serializeSessionToSnakeCase(ctx.session)
+    };
+    const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
+    const signal = ctx.abortSignal ? AbortSignal.any([ctx.abortSignal, timeoutSignal]) : timeoutSignal;
+    const response = await this.fetchImpl(this.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+      signal
+    });
+    if (response.status >= 400) {
+      throw new Error(
+        `RemoteAgent request to '${this.url}' failed with HTTP status ${response.status}.`
+      );
+    }
+    const rawEvents = await response.json();
+    if (!Array.isArray(rawEvents)) {
+      throw new Error(
+        `RemoteAgent expected a JSON array of events from '${this.url}'.`
+      );
+    }
+    for (const rawEvent of rawEvents) {
+      if (!isRecord(rawEvent)) {
+        throw new Error(
+          `RemoteAgent expected each item in the response from '${this.url}' to be a JSON event object.`
+        );
+      }
+      if ((_a2 = ctx.abortSignal) == null ? void 0 : _a2.aborted) {
+        return;
+      }
+      const camelEvent = (0, import_event.transformToCamelCaseEvent)(rawEvent);
+      const invocationId = camelEvent.invocationId !== void 0 && camelEvent.invocationId !== "" ? camelEvent.invocationId : ctx.invocationId;
+      const timestamp = typeof camelEvent.timestamp === "number" ? camelEvent.timestamp * MILLIS_PER_SECOND : void 0;
+      yield (0, import_event.createEvent)({
+        ...camelEvent,
+        invocationId,
+        timestamp,
+        author: this.name
+      });
+    }
+  }
+  async *runLiveImpl(_ctx) {
+    yield* [];
+    throw new Error("This is not supported yet for RemoteAgent.");
+  }
+};
+__name(RemoteAgent, "RemoteAgent");
+RemoteAgent = __decorateClass([
+  import_experimental.experimental
+], RemoteAgent);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RemoteAgent,
+  isRemoteAgent
+});

package/dist/cjs/artifacts/in_memory_artifact_service.js

@@ -63,6 +63,13 @@ const _InMemoryArtifactService = class _InMemoryArtifactService {
     const version = this.artifacts[path].length;
     const metadata = {
       version,
+      canonicalUri: getCanonicalUri(
+        appName,
+        userId,
+        sessionId,
+        filename,
+        version
+      ),
       customMetadata
     };
     if (!artifact.inlineData && artifact.text === void 0) {
@@ -189,6 +196,13 @@ function artifactPrefix(scope, ...parts) {
   return `${[scope, ...parts].map(encodeURIComponent).join("/")}/`;
 }
 __name(artifactPrefix, "artifactPrefix");
+function getCanonicalUri(appName, userId, sessionId, filename, version) {
+  if (fileHasUserNamespace(filename)) {
+    return `memory://apps/${appName}/users/${userId}/artifacts/${filename}/versions/${version}`;
+  }
+  return `memory://apps/${appName}/users/${userId}/sessions/${sessionId}/artifacts/${filename}/versions/${version}`;
+}
+__name(getCanonicalUri, "getCanonicalUri");
 function fileHasUserNamespace(filename) {
   return filename.startsWith("user:");
 }

package/dist/cjs/auth/auth_handler.js

@@ -28,6 +28,7 @@ __export(auth_handler_exports, {
   AuthHandler: () => AuthHandler
 });
 module.exports = __toCommonJS(auth_handler_exports);
+var import_lodash_es = require("lodash-es");
 var import_env_aware_utils = require("../utils/env_aware_utils.js");
 var import_oauth2_credential_exchanger = require("./oauth2/oauth2_credential_exchanger.js");
 var import_oauth2_utils = require("./oauth2/oauth2_utils.js");
@@ -38,6 +39,11 @@ var import_oauth2_utils = require("./oauth2/oauth2_utils.js");
  */
 const S256_CODE_CHALLENGE_METHOD = "S256";
 const _AuthHandler = class _AuthHandler {
+  /**
+   * @param authConfig The auth config this handler reads. It stays readable
+   *     and replaceable after construction; each method reads the current
+   *     value.
+   */
   constructor(authConfig) {
     this.authConfig = authConfig;
   }
@@ -70,14 +76,32 @@ const _AuthHandler = class _AuthHandler {
       state.set(credentialKey, exchangedCredential.credential);
     }
   }
+  /**
+   * Builds the auth request to send to the client.
+   *
+   * The result is always a new object, and its `exchangedAuthCredential` is
+   * never an object held by {@link authConfig}. A caller that fills in the
+   * response, for example `exchangedAuthCredential.oauth2.authResponseUri`,
+   * therefore leaves the handler's credentials unchanged.
+   *
+   * When the config is returned as is, because the scheme is not OAuth2 or
+   * OpenID Connect or the exchanged credential already has an auth URI, the
+   * result is a deep copy of the whole config. In the other branches only the
+   * exchanged credential is guaranteed independent: `authScheme` and
+   * `rawAuthCredential` are the handler's own objects.
+   *
+   * @return The auth config to request from the client.
+   * @throws Error: If an OAuth2 or OpenID Connect scheme has no raw
+   *     credential, no `oauth2` on it, or no client ID and secret.
+   */
   generateAuthRequest() {
     var _a, _b;
     const authSchemeType = this.authConfig.authScheme.type;
     if (!["oauth2", "openIdConnect"].includes(authSchemeType)) {
-      return this.authConfig;
+      return (0, import_lodash_es.cloneDeep)(this.authConfig);
     }
     if ((_b = (_a = this.authConfig.exchangedAuthCredential) == null ? void 0 : _a.oauth2) == null ? void 0 : _b.authUri) {
-      return this.authConfig;
+      return (0, import_lodash_es.cloneDeep)(this.authConfig);
     }
     if (!this.authConfig.rawAuthCredential) {
       throw new Error(`Auth Scheme ${authSchemeType} requires authCredential.`);
@@ -92,7 +116,7 @@ const _AuthHandler = class _AuthHandler {
         credentialKey: this.authConfig.credentialKey,
         authScheme: this.authConfig.authScheme,
         rawAuthCredential: this.authConfig.rawAuthCredential,
-        exchangedAuthCredential: this.authConfig.rawAuthCredential
+        exchangedAuthCredential: (0, import_lodash_es.cloneDeep)(this.authConfig.rawAuthCredential)
       };
     }
     if (!this.authConfig.rawAuthCredential.oauth2.clientId || !this.authConfig.rawAuthCredential.oauth2.clientSecret) {
@@ -114,6 +138,10 @@ const _AuthHandler = class _AuthHandler {
    * challenge derived from the credential's code verifier, and the returned
    * credential carries the verifier the later token exchange must send.
    *
+   * The URI leaves out `redirect_uri` when the credential has no
+   * `redirectUri`, so the provider uses the redirect registered for the
+   * client, and leaves out `scope` when the scheme lists no scopes.
+   *
    * @return An AuthCredential object containing the auth URI and state.
    * @throws Error: If the authorization endpoint is not configured in the
    *     auth scheme, or the credential requests a code challenge method other
@@ -157,9 +185,13 @@ const _AuthHandler = class _AuthHandler {
     const state = (0, import_env_aware_utils.randomUUID)();
     const url = new URL(authorizationEndpoint);
     url.searchParams.set("client_id", oauth2.clientId || "");
-    url.searchParams.set("redirect_uri", oauth2.redirectUri || "");
+    if (oauth2.redirectUri) {
+      url.searchParams.set("redirect_uri", oauth2.redirectUri);
+    }
     url.searchParams.set("response_type", "code");
-    url.searchParams.set("scope", scopes.join(" "));
+    if (scopes.length > 0) {
+      url.searchParams.set("scope", scopes.join(" "));
+    }
     url.searchParams.set("state", state);
     url.searchParams.set("access_type", "offline");
     url.searchParams.set("prompt", "consent");

package/dist/cjs/auth/auth_schemes.js

@@ -25,6 +25,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var auth_schemes_exports = {};
 __export(auth_schemes_exports, {
+  AuthSchemeType: () => AuthSchemeType,
   OAuthGrantType: () => OAuthGrantType,
   getOAuthGrantTypeFromFlow: () => getOAuthGrantTypeFromFlow
 });
@@ -34,6 +35,13 @@ module.exports = __toCommonJS(auth_schemes_exports);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var AuthSchemeType = /* @__PURE__ */ ((AuthSchemeType2) => {
+  AuthSchemeType2["API_KEY"] = "apiKey";
+  AuthSchemeType2["HTTP"] = "http";
+  AuthSchemeType2["OAUTH2"] = "oauth2";
+  AuthSchemeType2["OPEN_ID_CONNECT"] = "openIdConnect";
+  return AuthSchemeType2;
+})(AuthSchemeType || {});
 var OAuthGrantType = /* @__PURE__ */ ((OAuthGrantType2) => {
   OAuthGrantType2["CLIENT_CREDENTIALS"] = "client_credentials";
   OAuthGrantType2["AUTHORIZATION_CODE"] = "authorization_code";
@@ -59,6 +67,7 @@ function getOAuthGrantTypeFromFlow(flow) {
 __name(getOAuthGrantTypeFromFlow, "getOAuthGrantTypeFromFlow");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AuthSchemeType,
   OAuthGrantType,
   getOAuthGrantTypeFromFlow
 });