@softactivate/adk 1.1.0

package/dist/cjs/agents/loop_agent.js

@@ -0,0 +1,84 @@
+/**
+  * @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 loop_agent_exports = {};
+__export(loop_agent_exports, {
+  LoopAgent: () => LoopAgent,
+  isLoopAgent: () => isLoopAgent
+});
+module.exports = __toCommonJS(loop_agent_exports);
+var import_base_agent = require("./base_agent.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const LOOP_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.loopAgent");
+function isLoopAgent(obj) {
+  return typeof obj === "object" && obj !== null && LOOP_AGENT_SIGNATURE_SYMBOL in obj && obj[LOOP_AGENT_SIGNATURE_SYMBOL] === true;
+}
+class LoopAgent extends (_b = import_base_agent.BaseAgent, _a = LOOP_AGENT_SIGNATURE_SYMBOL, _b) {
+  constructor(config) {
+    var _a2;
+    super(config);
+    /**
+     * A unique symbol to identify ADK loop agent class.
+     */
+    this[_a] = true;
+    this.maxIterations = (_a2 = config.maxIterations) != null ? _a2 : Number.MAX_SAFE_INTEGER;
+  }
+  async *runAsyncImpl(context) {
+    var _a2;
+    let iteration = 0;
+    while (iteration < this.maxIterations) {
+      for (const subAgent of this.subAgents) {
+        let shouldExit = false;
+        for await (const event of subAgent.runAsync(context)) {
+          if ((_a2 = context.abortSignal) == null ? void 0 : _a2.aborted) {
+            return;
+          }
+          yield event;
+          if (event.actions.escalate) {
+            shouldExit = true;
+          }
+        }
+        if (shouldExit) {
+          return;
+        }
+      }
+      iteration++;
+    }
+    return;
+  }
+  // eslint-disable-next-line require-yield
+  async *runLiveImpl(_context) {
+    throw new Error("This is not supported yet for LoopAgent.");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoopAgent,
+  isLoopAgent
+});

package/dist/cjs/agents/parallel_agent.js

@@ -0,0 +1,95 @@
+/**
+  * @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 parallel_agent_exports = {};
+__export(parallel_agent_exports, {
+  ParallelAgent: () => ParallelAgent,
+  isParallelAgent: () => isParallelAgent
+});
+module.exports = __toCommonJS(parallel_agent_exports);
+var import_base_agent = require("./base_agent.js");
+var import_invocation_context = require("./invocation_context.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const PARALLEL_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.parallelAgent");
+function isParallelAgent(obj) {
+  return typeof obj === "object" && obj !== null && PARALLEL_AGENT_SIGNATURE_SYMBOL in obj && obj[PARALLEL_AGENT_SIGNATURE_SYMBOL] === true;
+}
+class ParallelAgent extends (_b = import_base_agent.BaseAgent, _a = PARALLEL_AGENT_SIGNATURE_SYMBOL, _b) {
+  constructor() {
+    super(...arguments);
+    /**
+     * A unique symbol to identify ADK parallel agent class.
+     */
+    this[_a] = true;
+  }
+  async *runAsyncImpl(context) {
+    var _a2;
+    const agentRuns = this.subAgents.map(
+      (subAgent) => subAgent.runAsync(createBranchCtxForSubAgent(this, subAgent, context))
+    );
+    for await (const event of mergeAgentRuns(agentRuns)) {
+      if ((_a2 = context.abortSignal) == null ? void 0 : _a2.aborted) {
+        return;
+      }
+      yield event;
+    }
+  }
+  // eslint-disable-next-line require-yield
+  async *runLiveImpl(_context) {
+    throw new Error("This is not supported yet for ParallelAgent.");
+  }
+}
+function createBranchCtxForSubAgent(agent, subAgent, originalContext) {
+  const invocationContext = new import_invocation_context.InvocationContext(originalContext);
+  const branchSuffix = `${agent.name}.${subAgent.name}`;
+  invocationContext.branch = invocationContext.branch ? `${invocationContext.branch}.${branchSuffix}` : branchSuffix;
+  return invocationContext;
+}
+async function* mergeAgentRuns(agentRuns) {
+  const pendingPromises = /* @__PURE__ */ new Map();
+  for (const [index, generator] of agentRuns.entries()) {
+    const promise = generator.next().then((result) => ({ result, index }));
+    pendingPromises.set(index, promise);
+  }
+  while (pendingPromises.size > 0) {
+    const { result, index } = await Promise.race(pendingPromises.values());
+    if (result.done) {
+      pendingPromises.delete(index);
+      continue;
+    }
+    yield result.value;
+    const nextPromise = agentRuns[index].next().then((result2) => ({ result: result2, index }));
+    pendingPromises.set(index, nextPromise);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParallelAgent,
+  isParallelAgent
+});

package/dist/cjs/agents/processors/agent_transfer_llm_request_processor.js

@@ -0,0 +1,132 @@
+/**
+  * @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 agent_transfer_llm_request_processor_exports = {};
+__export(agent_transfer_llm_request_processor_exports, {
+  AGENT_TRANSFER_LLM_REQUEST_PROCESSOR: () => AGENT_TRANSFER_LLM_REQUEST_PROCESSOR,
+  AgentTransferLlmRequestProcessor: () => AgentTransferLlmRequestProcessor
+});
+module.exports = __toCommonJS(agent_transfer_llm_request_processor_exports);
+var import_zod = require("zod");
+var import_llm_request = require("../../models/llm_request.js");
+var import_function_tool = require("../../tools/function_tool.js");
+var import_context = require("../context.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class AgentTransferLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  constructor() {
+    super(...arguments);
+    this.toolName = "transfer_to_agent";
+    this.tool = new import_function_tool.FunctionTool({
+      name: this.toolName,
+      description: "Transfer the question to another agent. This tool hands off control to another agent when it is more suitable to answer the user question according to the agent description.",
+      parameters: import_zod.z.object({
+        agentName: import_zod.z.string().describe("the agent name to transfer to.")
+      }),
+      execute: function(args, toolContext) {
+        if (!toolContext) {
+          throw new Error("toolContext is required.");
+        }
+        toolContext.actions.transferToAgent = args.agentName;
+        return "Transfer queued";
+      }
+    });
+  }
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    if (!(0, import_llm_agent.isLlmAgent)(invocationContext.agent)) {
+      return;
+    }
+    const transferTargets = this.getTransferTargets(invocationContext.agent);
+    if (!transferTargets.length) {
+      return;
+    }
+    (0, import_llm_request.appendInstructions)(llmRequest, [
+      this.buildTargetAgentsInstructions(
+        invocationContext.agent,
+        transferTargets
+      )
+    ]);
+    const toolContext = new import_context.Context({ invocationContext });
+    await this.tool.processLlmRequest({ toolContext, llmRequest });
+  }
+  buildTargetAgentsInfo(targetAgent) {
+    return `
+Agent name: ${targetAgent.name}
+Agent description: ${targetAgent.description}
+`;
+  }
+  buildTargetAgentsInstructions(agent, targetAgents) {
+    let instructions = `
+You have a list of other agents to transfer to:
+
+${targetAgents.map((t) => this.buildTargetAgentsInfo(t)).join("\n")}
+
+If you are the best to answer the question according to your description, you
+can answer it.
+
+If another agent is better for answering the question according to its
+description, call \`${this.toolName}\` function to transfer the
+question to that agent. When transferring, do not generate any text other than
+the function call.
+`;
+    if (agent.parentAgent && !agent.disallowTransferToParent) {
+      instructions += `
+Your parent agent is ${agent.parentAgent.name}. If neither the other agents nor
+you are best for answering the question according to the descriptions, transfer
+to your parent agent.
+`;
+    }
+    return instructions;
+  }
+  getTransferTargets(agent) {
+    const targets = [];
+    targets.push(...agent.subAgents);
+    if (!agent.parentAgent || !(0, import_llm_agent.isLlmAgent)(agent.parentAgent)) {
+      return targets;
+    }
+    if (!agent.disallowTransferToParent) {
+      targets.push(agent.parentAgent);
+    }
+    if (!agent.disallowTransferToPeers) {
+      targets.push(
+        ...agent.parentAgent.subAgents.filter(
+          (peerAgent) => peerAgent.name !== agent.name
+        )
+      );
+    }
+    return targets;
+  }
+}
+const AGENT_TRANSFER_LLM_REQUEST_PROCESSOR = new AgentTransferLlmRequestProcessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_TRANSFER_LLM_REQUEST_PROCESSOR,
+  AgentTransferLlmRequestProcessor
+});

package/dist/cjs/agents/processors/base_llm_processor.js

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

package/dist/cjs/agents/processors/basic_llm_request_processor.js

@@ -0,0 +1,68 @@
+/**
+  * @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 basic_llm_request_processor_exports = {};
+__export(basic_llm_request_processor_exports, {
+  BASIC_LLM_REQUEST_PROCESSOR: () => BASIC_LLM_REQUEST_PROCESSOR,
+  BasicLlmRequestProcessor: () => BasicLlmRequestProcessor
+});
+module.exports = __toCommonJS(basic_llm_request_processor_exports);
+var import_llm_request = require("../../models/llm_request.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BasicLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    var _a;
+    const agent = invocationContext.agent;
+    if (!(0, import_llm_agent.isLlmAgent)(agent)) {
+      return;
+    }
+    llmRequest.model = agent.canonicalModel.model;
+    llmRequest.config = { ...(_a = agent.generateContentConfig) != null ? _a : {} };
+    if (agent.outputSchema) {
+      (0, import_llm_request.setOutputSchema)(llmRequest, agent.outputSchema);
+    }
+    if (invocationContext.runConfig) {
+      llmRequest.liveConnectConfig.responseModalities = invocationContext.runConfig.responseModalities;
+      llmRequest.liveConnectConfig.speechConfig = invocationContext.runConfig.speechConfig;
+      llmRequest.liveConnectConfig.outputAudioTranscription = invocationContext.runConfig.outputAudioTranscription;
+      llmRequest.liveConnectConfig.inputAudioTranscription = invocationContext.runConfig.inputAudioTranscription;
+      llmRequest.liveConnectConfig.realtimeInputConfig = invocationContext.runConfig.realtimeInputConfig;
+      llmRequest.liveConnectConfig.enableAffectiveDialog = invocationContext.runConfig.enableAffectiveDialog;
+      llmRequest.liveConnectConfig.proactivity = invocationContext.runConfig.proactivity;
+    }
+  }
+}
+const BASIC_LLM_REQUEST_PROCESSOR = new BasicLlmRequestProcessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASIC_LLM_REQUEST_PROCESSOR,
+  BasicLlmRequestProcessor
+});