@softactivate/adk 1.1.0

package/dist/cjs/auth/auth_preprocessor.js

@@ -0,0 +1,178 @@
+/**
+  * @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 __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 auth_preprocessor_exports = {};
+__export(auth_preprocessor_exports, {
+  AUTH_PREPROCESSOR: () => AUTH_PREPROCESSOR,
+  AuthPreprocessor: () => AuthPreprocessor
+});
+module.exports = __toCommonJS(auth_preprocessor_exports);
+var import_functions = require("../agents/functions.js");
+var import_llm_agent = require("../agents/llm_agent.js");
+var import_base_llm_processor = require("../agents/processors/base_llm_processor.js");
+var import_readonly_context = require("../agents/readonly_context.js");
+var import_event = require("../events/event.js");
+var import_state = require("../sessions/state.js");
+var import_auth_handler = require("./auth_handler.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const TOOLSET_AUTH_CREDENTIAL_ID_PREFIX = "_adk_toolset_auth_";
+async function storeAuthAndCollectResumeTargets(events, authFcIds, authResponses, state) {
+  const requestedAuthConfigById = {};
+  for (const event of events) {
+    const eventFunctionCalls = (0, import_event.getFunctionCalls)(event);
+    for (const functionCall of eventFunctionCalls) {
+      if (functionCall.id && authFcIds.has(functionCall.id) && functionCall.name === import_functions.REQUEST_EUC_FUNCTION_CALL_NAME) {
+        const args = functionCall.args;
+        if (args && args.authConfig) {
+          requestedAuthConfigById[functionCall.id] = args.authConfig;
+        }
+      }
+    }
+  }
+  for (const fcId of authFcIds) {
+    if (!(fcId in authResponses)) {
+      continue;
+    }
+    const authConfig = authResponses[fcId];
+    const requestedAuthConfig = requestedAuthConfigById[fcId];
+    if (requestedAuthConfig && requestedAuthConfig.credentialKey) {
+      authConfig.credentialKey = requestedAuthConfig.credentialKey;
+    }
+    await new import_auth_handler.AuthHandler(authConfig).parseAndStoreAuthResponse(state);
+  }
+  const toolsToResume = /* @__PURE__ */ new Set();
+  for (const fcId of authFcIds) {
+    const requestedAuthConfig = requestedAuthConfigById[fcId];
+    if (!requestedAuthConfig) {
+      continue;
+    }
+    for (const event of events) {
+      const eventFunctionCalls = (0, import_event.getFunctionCalls)(event);
+      for (const functionCall of eventFunctionCalls) {
+        if (functionCall.id === fcId && functionCall.name === import_functions.REQUEST_EUC_FUNCTION_CALL_NAME) {
+          const args = functionCall.args;
+          if (args && args.functionCallId) {
+            if (args.functionCallId.startsWith(TOOLSET_AUTH_CREDENTIAL_ID_PREFIX)) {
+              continue;
+            }
+            toolsToResume.add(args.functionCallId);
+          }
+        }
+      }
+    }
+  }
+  return toolsToResume;
+}
+class AuthPreprocessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  async *runAsync(invocationContext) {
+    const agent = invocationContext.agent;
+    if (!(0, import_llm_agent.isLlmAgent)(agent)) {
+      return;
+    }
+    const events = invocationContext.session.events;
+    if (!events || events.length === 0) {
+      return;
+    }
+    let lastEventWithContent = null;
+    for (let i = events.length - 1; i >= 0; i--) {
+      const event = events[i];
+      if (event.content !== void 0) {
+        lastEventWithContent = event;
+        break;
+      }
+    }
+    if (!lastEventWithContent || lastEventWithContent.author !== "user") {
+      return;
+    }
+    const responses = (0, import_event.getFunctionResponses)(lastEventWithContent);
+    if (!responses || responses.length === 0) {
+      return;
+    }
+    const authFcIds = /* @__PURE__ */ new Set();
+    const authResponses = {};
+    for (const functionCallResponse of responses) {
+      if (functionCallResponse.name !== import_functions.REQUEST_EUC_FUNCTION_CALL_NAME) {
+        continue;
+      }
+      if (functionCallResponse.id) {
+        authFcIds.add(functionCallResponse.id);
+        authResponses[functionCallResponse.id] = functionCallResponse.response;
+      }
+    }
+    if (authFcIds.size === 0) {
+      return;
+    }
+    const state = new import_state.State(invocationContext.session.state);
+    const toolsToResume = await storeAuthAndCollectResumeTargets(
+      events,
+      authFcIds,
+      authResponses,
+      state
+    );
+    if (toolsToResume.size === 0) {
+      return;
+    }
+    for (let i = events.length - 2; i >= 0; i--) {
+      const event = events[i];
+      const functionCalls = (0, import_event.getFunctionCalls)(event);
+      if (!functionCalls || functionCalls.length === 0) {
+        continue;
+      }
+      const hasMatchingCall = functionCalls.some(
+        (call) => call.id ? toolsToResume.has(call.id) : false
+      );
+      if (hasMatchingCall) {
+        const canonicalTools = await agent.canonicalTools(
+          new import_readonly_context.ReadonlyContext(invocationContext)
+        );
+        const toolsDict = {};
+        for (const tool of canonicalTools) {
+          toolsDict[tool.name] = tool;
+        }
+        const functionResponseEvent = await (0, import_functions.handleFunctionCallsAsync)({
+          invocationContext,
+          functionCallEvent: event,
+          toolsDict,
+          beforeToolCallbacks: agent.canonicalBeforeToolCallbacks,
+          afterToolCallbacks: agent.canonicalAfterToolCallbacks,
+          filters: toolsToResume
+        });
+        if (functionResponseEvent) {
+          yield functionResponseEvent;
+        }
+        return;
+      }
+    }
+  }
+}
+const AUTH_PREPROCESSOR = new AuthPreprocessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTH_PREPROCESSOR,
+  AuthPreprocessor
+});

package/dist/cjs/auth/auth_provider_registry.js

@@ -0,0 +1,61 @@
+/**
+  * @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 __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 auth_provider_registry_exports = {};
+__export(auth_provider_registry_exports, {
+  AuthProviderRegistry: () => AuthProviderRegistry
+});
+module.exports = __toCommonJS(auth_provider_registry_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class AuthProviderRegistry {
+  constructor() {
+    this.providers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a provider instance for an auth scheme type.
+   *
+   * @param authSchemeType The auth scheme type (e.g., 'oauth2', 'apiKey').
+   * @param providerInstance The provider instance to register.
+   */
+  register(authSchemeType, providerInstance) {
+    this.providers.set(authSchemeType, providerInstance);
+  }
+  /**
+   * Get the provider instance for an auth scheme.
+   *
+   * @param authScheme The auth scheme to get provider for.
+   * @returns The provider instance if registered, undefined otherwise.
+   */
+  getProvider(authScheme) {
+    return this.providers.get(authScheme.type);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthProviderRegistry
+});

package/dist/cjs/auth/auth_schemes.js

@@ -0,0 +1,62 @@
+/**
+  * @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 __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 auth_schemes_exports = {};
+__export(auth_schemes_exports, {
+  OAuthGrantType: () => OAuthGrantType,
+  getOAuthGrantTypeFromFlow: () => getOAuthGrantTypeFromFlow
+});
+module.exports = __toCommonJS(auth_schemes_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var OAuthGrantType = /* @__PURE__ */ ((OAuthGrantType2) => {
+  OAuthGrantType2["CLIENT_CREDENTIALS"] = "client_credentials";
+  OAuthGrantType2["AUTHORIZATION_CODE"] = "authorization_code";
+  OAuthGrantType2["IMPLICIT"] = "implicit";
+  OAuthGrantType2["PASSWORD"] = "password";
+  return OAuthGrantType2;
+})(OAuthGrantType || {});
+function getOAuthGrantTypeFromFlow(flow) {
+  if (flow.clientCredentials) {
+    return "client_credentials" /* CLIENT_CREDENTIALS */;
+  }
+  if (flow.authorizationCode) {
+    return "authorization_code" /* AUTHORIZATION_CODE */;
+  }
+  if (flow.implicit) {
+    return "implicit" /* IMPLICIT */;
+  }
+  if (flow.password) {
+    return "password" /* PASSWORD */;
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OAuthGrantType,
+  getOAuthGrantTypeFromFlow
+});

package/dist/cjs/auth/auth_tool.js

@@ -0,0 +1,27 @@
+/**
+  * @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 __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 auth_tool_exports = {};
+module.exports = __toCommonJS(auth_tool_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/cjs/auth/base_auth_provider.js

@@ -0,0 +1,27 @@
+/**
+  * @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 __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 base_auth_provider_exports = {};
+module.exports = __toCommonJS(base_auth_provider_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/cjs/auth/credential_service/base_credential_service.js

@@ -0,0 +1,27 @@
+/**
+  * @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 __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 base_credential_service_exports = {};
+module.exports = __toCommonJS(base_credential_service_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/cjs/auth/credential_service/in_memory_credential_service.js

@@ -0,0 +1,63 @@
+/**
+  * @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 __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 in_memory_credential_service_exports = {};
+__export(in_memory_credential_service_exports, {
+  InMemoryCredentialService: () => InMemoryCredentialService
+});
+module.exports = __toCommonJS(in_memory_credential_service_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class InMemoryCredentialService {
+  constructor() {
+    this.credentials = {};
+  }
+  loadCredential(authConfig, toolContext) {
+    const credentialBucket = this.getBucketForCurrentContext(toolContext);
+    return Promise.resolve(credentialBucket[authConfig.credentialKey]);
+  }
+  async saveCredential(authConfig, toolContext) {
+    const credentialBucket = this.getBucketForCurrentContext(toolContext);
+    if (authConfig.exchangedAuthCredential) {
+      credentialBucket[authConfig.credentialKey] = authConfig.exchangedAuthCredential;
+    }
+  }
+  getBucketForCurrentContext(toolContext) {
+    const { appName, userId } = toolContext.invocationContext.session;
+    if (!this.credentials[appName]) {
+      this.credentials[appName] = {};
+    }
+    if (!this.credentials[appName][userId]) {
+      this.credentials[appName][userId] = {};
+    }
+    return this.credentials[appName][userId];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryCredentialService
+});

package/dist/cjs/auth/credential_service/session_state_credential_service.js

@@ -0,0 +1,51 @@
+/**
+  * @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 __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 session_state_credential_service_exports = {};
+__export(session_state_credential_service_exports, {
+  SessionStateCredentialService: () => SessionStateCredentialService
+});
+module.exports = __toCommonJS(session_state_credential_service_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class SessionStateCredentialService {
+  loadCredential(authConfig, toolContext) {
+    return Promise.resolve(toolContext.state.get(authConfig.credentialKey));
+  }
+  async saveCredential(authConfig, toolContext) {
+    if (authConfig.exchangedAuthCredential) {
+      toolContext.state.set(
+        authConfig.credentialKey,
+        authConfig.exchangedAuthCredential
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionStateCredentialService
+});

package/dist/cjs/auth/exchanger/base_credential_exchanger.js

@@ -0,0 +1,40 @@
+/**
+  * @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 __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 base_credential_exchanger_exports = {};
+__export(base_credential_exchanger_exports, {
+  CredentialExchangeError: () => CredentialExchangeError
+});
+module.exports = __toCommonJS(base_credential_exchanger_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class CredentialExchangeError extends Error {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CredentialExchangeError
+});

package/dist/cjs/auth/exchanger/credential_exchanger_registry.js

@@ -0,0 +1,59 @@
+/**
+  * @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 __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 credential_exchanger_registry_exports = {};
+__export(credential_exchanger_registry_exports, {
+  CredentialExchangerRegistry: () => CredentialExchangerRegistry
+});
+module.exports = __toCommonJS(credential_exchanger_registry_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class CredentialExchangerRegistry {
+  constructor() {
+    this.exchangers = {};
+  }
+  /**
+   * Register an exchanger instance for a credential type.
+   * @param credentialType - The credential type to register for.
+   * @param exchangerInstance - The exchanger instance to register.
+   */
+  register(credentialType, exchangerInstance) {
+    this.exchangers[credentialType] = exchangerInstance;
+  }
+  /**
+   * Get the exchanger instance for a credential type.
+   * @param credentialType - The credential type to get exchanger for.
+   * @returns The exchanger instance if registered, undefined otherwise.
+   */
+  getExchanger(credentialType) {
+    return this.exchangers[credentialType];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CredentialExchangerRegistry
+});