@softactivate/adk 1.1.0

package/dist/web/agents/loop_agent.js

@@ -0,0 +1,88 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import { BaseAgent } from "./base_agent.js";
+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 = 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;
+  }
+  runAsyncImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      var _a2;
+      let iteration = 0;
+      while (iteration < this.maxIterations) {
+        for (const subAgent of this.subAgents) {
+          let shouldExit = false;
+          try {
+            for (var iter = __forAwait(subAgent.runAsync(context)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+              const event = temp.value;
+              if ((_a2 = context.abortSignal) == null ? void 0 : _a2.aborted) {
+                return;
+              }
+              yield event;
+              if (event.actions.escalate) {
+                shouldExit = true;
+              }
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+          if (shouldExit) {
+            return;
+          }
+        }
+        iteration++;
+      }
+      return;
+    });
+  }
+  // eslint-disable-next-line require-yield
+  runLiveImpl(_context) {
+    return __asyncGenerator(this, null, function* () {
+      throw new Error("This is not supported yet for LoopAgent.");
+    });
+  }
+}
+export {
+  LoopAgent,
+  isLoopAgent
+};

package/dist/web/agents/parallel_agent.js

@@ -0,0 +1,101 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import { BaseAgent } from "./base_agent.js";
+import { InvocationContext } from "./invocation_context.js";
+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 = BaseAgent, _a = PARALLEL_AGENT_SIGNATURE_SYMBOL, _b) {
+  constructor() {
+    super(...arguments);
+    /**
+     * A unique symbol to identify ADK parallel agent class.
+     */
+    this[_a] = true;
+  }
+  runAsyncImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      var _a2;
+      const agentRuns = this.subAgents.map(
+        (subAgent) => subAgent.runAsync(createBranchCtxForSubAgent(this, subAgent, context))
+      );
+      try {
+        for (var iter = __forAwait(mergeAgentRuns(agentRuns)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const event = temp.value;
+          if ((_a2 = context.abortSignal) == null ? void 0 : _a2.aborted) {
+            return;
+          }
+          yield event;
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+  // eslint-disable-next-line require-yield
+  runLiveImpl(_context) {
+    return __asyncGenerator(this, null, function* () {
+      throw new Error("This is not supported yet for ParallelAgent.");
+    });
+  }
+}
+function createBranchCtxForSubAgent(agent, subAgent, originalContext) {
+  const invocationContext = new InvocationContext(originalContext);
+  const branchSuffix = "".concat(agent.name, ".").concat(subAgent.name);
+  invocationContext.branch = invocationContext.branch ? "".concat(invocationContext.branch, ".").concat(branchSuffix) : branchSuffix;
+  return invocationContext;
+}
+function mergeAgentRuns(agentRuns) {
+  return __asyncGenerator(this, null, function* () {
+    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 } = yield new __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);
+    }
+  });
+}
+export {
+  ParallelAgent,
+  isParallelAgent
+};

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

@@ -0,0 +1,102 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from "zod";
+import { appendInstructions } from "../../models/llm_request.js";
+import { FunctionTool } from "../../tools/function_tool.js";
+import { Context } from "../context.js";
+import { isLlmAgent } from "../llm_agent.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+class AgentTransferLlmRequestProcessor extends BaseLlmRequestProcessor {
+  constructor() {
+    super(...arguments);
+    this.toolName = "transfer_to_agent";
+    this.tool = new 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: z.object({
+        agentName: 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
+  runAsync(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      if (!isLlmAgent(invocationContext.agent)) {
+        return;
+      }
+      const transferTargets = this.getTransferTargets(invocationContext.agent);
+      if (!transferTargets.length) {
+        return;
+      }
+      appendInstructions(llmRequest, [
+        this.buildTargetAgentsInstructions(
+          invocationContext.agent,
+          transferTargets
+        )
+      ]);
+      const toolContext = new Context({ invocationContext });
+      yield new __await(this.tool.processLlmRequest({ toolContext, llmRequest }));
+    });
+  }
+  buildTargetAgentsInfo(targetAgent) {
+    return "\nAgent name: ".concat(targetAgent.name, "\nAgent description: ").concat(targetAgent.description, "\n");
+  }
+  buildTargetAgentsInstructions(agent, targetAgents) {
+    let instructions = "\nYou have a list of other agents to transfer to:\n\n".concat(targetAgents.map((t) => this.buildTargetAgentsInfo(t)).join("\n"), "\n\nIf you are the best to answer the question according to your description, you\ncan answer it.\n\nIf another agent is better for answering the question according to its\ndescription, call `").concat(this.toolName, "` function to transfer the\nquestion to that agent. When transferring, do not generate any text other than\nthe function call.\n");
+    if (agent.parentAgent && !agent.disallowTransferToParent) {
+      instructions += "\nYour parent agent is ".concat(agent.parentAgent.name, ". If neither the other agents nor\nyou are best for answering the question according to the descriptions, transfer\nto your parent agent.\n");
+    }
+    return instructions;
+  }
+  getTransferTargets(agent) {
+    const targets = [];
+    targets.push(...agent.subAgents);
+    if (!agent.parentAgent || !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();
+export {
+  AGENT_TRANSFER_LLM_REQUEST_PROCESSOR,
+  AgentTransferLlmRequestProcessor
+};

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

@@ -0,0 +1,15 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BaseLlmRequestProcessor {
+}
+class BaseLlmResponseProcessor {
+}
+export {
+  BaseLlmRequestProcessor,
+  BaseLlmResponseProcessor
+};

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

@@ -0,0 +1,73 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { setOutputSchema } from "../../models/llm_request.js";
+import { isLlmAgent } from "../llm_agent.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+class BasicLlmRequestProcessor extends BaseLlmRequestProcessor {
+  // eslint-disable-next-line require-yield
+  runAsync(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      var _a;
+      const agent = invocationContext.agent;
+      if (!isLlmAgent(agent)) {
+        return;
+      }
+      llmRequest.model = agent.canonicalModel.model;
+      llmRequest.config = __spreadValues({}, (_a = agent.generateContentConfig) != null ? _a : {});
+      if (agent.outputSchema) {
+        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();
+export {
+  BASIC_LLM_REQUEST_PROCESSOR,
+  BasicLlmRequestProcessor
+};