@google/adk 2.2.0 → 2.3.0

package/dist/esm/agents/remote_agent.js

@@ -0,0 +1,164 @@
+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
+ */
+var _a, _b;
+import {
+  createEvent,
+  transformToCamelCaseEvent,
+  transformToSnakeCaseEvent
+} from "../events/event.js";
+import { experimental } from "../utils/experimental.js";
+import { BaseAgent } from "./base_agent.js";
+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 = 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 = 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 = 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 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([
+  experimental
+], RemoteAgent);
+export {
+  RemoteAgent,
+  isRemoteAgent
+};

package/dist/esm/artifacts/in_memory_artifact_service.js

@@ -36,6 +36,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) {
@@ -162,6 +169,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/esm/auth/auth_handler.js

@@ -7,6 +7,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { cloneDeep } from "lodash-es";
 import { randomUUID } from "../utils/env_aware_utils.js";
 import { OAuth2CredentialExchanger } from "./oauth2/oauth2_credential_exchanger.js";
 import {
@@ -15,6 +16,11 @@ import {
 } from "./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;
   }
@@ -47,14 +53,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 cloneDeep(this.authConfig);
     }
     if ((_b = (_a = this.authConfig.exchangedAuthCredential) == null ? void 0 : _a.oauth2) == null ? void 0 : _b.authUri) {
-      return this.authConfig;
+      return cloneDeep(this.authConfig);
     }
     if (!this.authConfig.rawAuthCredential) {
       throw new Error(`Auth Scheme ${authSchemeType} requires authCredential.`);
@@ -69,7 +93,7 @@ const _AuthHandler = class _AuthHandler {
         credentialKey: this.authConfig.credentialKey,
         authScheme: this.authConfig.authScheme,
         rawAuthCredential: this.authConfig.rawAuthCredential,
-        exchangedAuthCredential: this.authConfig.rawAuthCredential
+        exchangedAuthCredential: cloneDeep(this.authConfig.rawAuthCredential)
       };
     }
     if (!this.authConfig.rawAuthCredential.oauth2.clientId || !this.authConfig.rawAuthCredential.oauth2.clientSecret) {
@@ -91,6 +115,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
@@ -134,9 +162,13 @@ const _AuthHandler = class _AuthHandler {
     const state = 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/esm/auth/auth_schemes.js

@@ -7,6 +7,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * 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";
@@ -31,6 +38,7 @@ function getOAuthGrantTypeFromFlow(flow) {
 }
 __name(getOAuthGrantTypeFromFlow, "getOAuthGrantTypeFromFlow");
 export {
+  AuthSchemeType,
   OAuthGrantType,
   getOAuthGrantTypeFromFlow
 };