@google/adk 0.1.0

package/dist/web/agents/base_agent.js

@@ -0,0 +1,265 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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
+ */
+import { trace } from "@opentelemetry/api";
+import { createEvent } from "../events/event.js";
+import { CallbackContext } from "./callback_context.js";
+import { InvocationContext } from "./invocation_context.js";
+class BaseAgent {
+  constructor(config) {
+    this.name = validateAgentName(config.name);
+    this.description = config.description;
+    this.parentAgent = config.parentAgent;
+    this.subAgents = config.subAgents || [];
+    this.rootAgent = getRootAgent(this);
+    this.beforeAgentCallback = getCannonicalCallback(config.beforeAgentCallback);
+    this.afterAgentCallback = getCannonicalCallback(config.afterAgentCallback);
+    this.setParentAgentForSubAgents();
+  }
+  /**
+   * Entry method to run an agent via text-based conversation.
+   *
+   * @param parentContext The invocation context of the parent agent.
+   * @yields The events generated by the agent.
+   * @returns An AsyncGenerator that yields the events generated by the agent.
+   */
+  runAsync(parentContext) {
+    return __asyncGenerator(this, null, function* () {
+      const span = trace.getTracer("gcp.vertex.agent").startSpan("agent_run [".concat(this.name, "]"));
+      try {
+        const context = this.createInvocationContext(parentContext);
+        const beforeAgentCallbackEvent = yield new __await(this.handleBeforeAgentCallback(context));
+        if (beforeAgentCallbackEvent) {
+          yield beforeAgentCallbackEvent;
+        }
+        if (context.endInvocation) {
+          return;
+        }
+        try {
+          for (var iter = __forAwait(this.runAsyncImpl(context)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const event = temp.value;
+            yield event;
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+        if (context.endInvocation) {
+          return;
+        }
+        const afterAgentCallbackEvent = yield new __await(this.handleAfterAgentCallback(context));
+        if (afterAgentCallbackEvent) {
+          yield afterAgentCallbackEvent;
+        }
+      } finally {
+        span.end();
+      }
+    });
+  }
+  /**
+   * Entry method to run an agent via video/audio-based conversation.
+   *
+   * @param parentContext The invocation context of the parent agent.
+   * @yields The events generated by the agent.
+   * @returns An AsyncGenerator that yields the events generated by the agent.
+   */
+  runLive(parentContext) {
+    return __asyncGenerator(this, null, function* () {
+      const span = trace.getTracer("gcp.vertex.agent").startSpan("agent_run [".concat(this.name, "]"));
+      try {
+        throw new Error("Live mode is not implemented yet.");
+      } finally {
+        span.end();
+      }
+    });
+  }
+  /**
+   * Finds the agent with the given name in this agent and its descendants.
+   *
+   * @param name The name of the agent to find.
+   * @return The agent with the given name, or undefined if not found.
+   */
+  findAgent(name) {
+    if (this.name === name) {
+      return this;
+    }
+    return this.findSubAgent(name);
+  }
+  /**
+   * Finds the agent with the given name in this agent's descendants.
+   *
+   * @param name The name of the agent to find.
+   * @return The agent with the given name, or undefined if not found.
+   */
+  findSubAgent(name) {
+    for (const subAgent of this.subAgents) {
+      const result = subAgent.findAgent(name);
+      if (result) {
+        return result;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Creates an invocation context for this agent.
+   *
+   * @param parentContext The invocation context of the parent agent.
+   * @return The invocation context for this agent.
+   */
+  createInvocationContext(parentContext) {
+    return new InvocationContext(__spreadProps(__spreadValues({}, parentContext), {
+      agent: this
+    }));
+  }
+  /**
+   * Runs the before agent callback if it exists.
+   *
+   * @param invocationContext The invocation context of the agent.
+   * @return The event to return to the user, or undefined if no event is
+   *     generated.
+   */
+  async handleBeforeAgentCallback(invocationContext) {
+    if (this.beforeAgentCallback.length === 0) {
+      return void 0;
+    }
+    const callbackContext = new CallbackContext({ invocationContext });
+    for (const callback of this.beforeAgentCallback) {
+      const content = await callback(callbackContext);
+      if (content) {
+        invocationContext.endInvocation = true;
+        return createEvent({
+          invocationId: invocationContext.invocationId,
+          author: this.name,
+          branch: invocationContext.branch,
+          content,
+          actions: callbackContext.eventActions
+        });
+      }
+    }
+    if (callbackContext.state.hasDelta()) {
+      return createEvent({
+        invocationId: invocationContext.invocationId,
+        author: this.name,
+        branch: invocationContext.branch,
+        actions: callbackContext.eventActions
+      });
+    }
+    return void 0;
+  }
+  /**
+   * Runs the after agent callback if it exists.
+   *
+   * @param invocationContext The invocation context of the agent.
+   * @return The event to return to the user, or undefined if no event is
+   *     generated.
+   */
+  async handleAfterAgentCallback(invocationContext) {
+    if (this.afterAgentCallback.length === 0) {
+      return void 0;
+    }
+    const callbackContext = new CallbackContext({ invocationContext });
+    for (const callback of this.afterAgentCallback) {
+      const content = await callback(callbackContext);
+      if (content) {
+        return createEvent({
+          invocationId: invocationContext.invocationId,
+          author: this.name,
+          branch: invocationContext.branch,
+          content,
+          actions: callbackContext.eventActions
+        });
+      }
+    }
+    if (callbackContext.state.hasDelta()) {
+      return createEvent({
+        invocationId: invocationContext.invocationId,
+        author: this.name,
+        branch: invocationContext.branch,
+        actions: callbackContext.eventActions
+      });
+    }
+    return void 0;
+  }
+  setParentAgentForSubAgents() {
+    for (const subAgent of this.subAgents) {
+      if (subAgent.parentAgent) {
+        throw new Error('Agent "'.concat(subAgent.name, '" already has a parent agent, current parent: "').concat(subAgent.parentAgent.name, '", trying to add: "').concat(this.name, '"'));
+      }
+      subAgent.parentAgent = this;
+    }
+  }
+}
+function validateAgentName(name) {
+  if (!isIdentifier(name)) {
+    throw new Error('Found invalid agent name: "'.concat(name, '". Agent name must be a valid identifier. It should start with a letter (a-z, A-Z) or an underscore (_), and can only contain letters, digits (0-9), and underscores.'));
+  }
+  if (name === "user") {
+    throw new Error(
+      "Agent name cannot be 'user'. 'user' is reserved for end-user's input."
+    );
+  }
+  return name;
+}
+function isIdentifier(str) {
+  return new RegExp("^[\\p{ID_Start}$_][\\p{ID_Continue}$_]*$", "u").test(str);
+}
+function getRootAgent(rootAgent) {
+  while (rootAgent.parentAgent) {
+    rootAgent = rootAgent.parentAgent;
+  }
+  return rootAgent;
+}
+function getCannonicalCallback(callbacks) {
+  if (!callbacks) {
+    return [];
+  }
+  return Array.isArray(callbacks) ? callbacks : [callbacks];
+}
+export {
+  BaseAgent,
+  getCannonicalCallback
+};

package/dist/web/agents/base_llm_processor.js

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BaseLlmRequestProcessor {
+}
+class BaseLlmResponseProcessor {
+}
+export {
+  BaseLlmRequestProcessor,
+  BaseLlmResponseProcessor
+};

package/dist/web/agents/callback_context.js

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEventActions } from "../events/event_actions.js";
+import { State } from "../sessions/state.js";
+import { ReadonlyContext } from "./readonly_context.js";
+class CallbackContext extends ReadonlyContext {
+  constructor({ invocationContext, eventActions }) {
+    super(invocationContext);
+    this.eventActions = eventActions || createEventActions();
+    this._state = new State(
+      invocationContext.session.state,
+      this.eventActions.stateDelta
+    );
+  }
+  /**
+   * The delta-aware state of the current session.
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Loads an artifact attached to the current session.
+   *
+   * @param filename The filename of the artifact.
+   * @param version The version of the artifact. If not provided, the latest
+   *     version will be used.
+   * @return A promise that resolves to the loaded artifact.
+   */
+  loadArtifact(filename, version) {
+    if (!this.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.invocationContext.artifactService.loadArtifact({
+      appName: this.invocationContext.appName,
+      userId: this.invocationContext.userId,
+      sessionId: this.invocationContext.session.id,
+      filename,
+      version
+    });
+  }
+  /**
+   * Saves an artifact attached to the current session.
+   *
+   * @param filename The filename of the artifact.
+   * @param artifact The artifact to save.
+   * @return A promise that resolves to the version of the saved artifact.
+   */
+  async saveArtifact(filename, artifact) {
+    if (!this.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    const version = await this.invocationContext.artifactService.saveArtifact({
+      appName: this.invocationContext.appName,
+      userId: this.invocationContext.userId,
+      sessionId: this.invocationContext.session.id,
+      filename,
+      artifact
+    });
+    this.eventActions.artifactDelta[filename] = version;
+    return version;
+  }
+}
+export {
+  CallbackContext
+};

package/dist/web/agents/content_processor_utils.js

@@ -0,0 +1,268 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEvent, getFunctionCalls, getFunctionResponses } from "../events/event.js";
+import { deepClone } from "../utils/deep_clone.js";
+import { removeClientFunctionCallId, REQUEST_CONFIRMATION_FUNCTION_CALL_NAME, REQUEST_EUC_FUNCTION_CALL_NAME } from "./functions.js";
+function getContents(events, agentName, currentBranch) {
+  var _a, _b, _c;
+  const filteredEvents = [];
+  for (const event of events) {
+    if (!((_a = event.content) == null ? void 0 : _a.role) || ((_c = (_b = event.content.parts) == null ? void 0 : _b[0]) == null ? void 0 : _c.text) === "") {
+      continue;
+    }
+    if (currentBranch && event.branch && !currentBranch.startsWith(event.branch)) {
+      continue;
+    }
+    if (isAuthEvent(event)) {
+      continue;
+    }
+    if (isToolConfirmationEvent(event)) {
+      continue;
+    }
+    filteredEvents.push(
+      isEventFromAnotherAgent(agentName, event) ? convertForeignEvent(event) : event
+    );
+  }
+  let resultEvents = rearrangeEventsForLatestFunctionResponse(filteredEvents);
+  resultEvents = rearrangeEventsForAsyncFunctionResponsesInHistory(resultEvents);
+  const contents = [];
+  for (const event of resultEvents) {
+    const content = deepClone(event.content);
+    removeClientFunctionCallId(content);
+    contents.push(content);
+  }
+  return contents;
+}
+function getCurrentTurnContents(events, agentName, currentBranch) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.author === "user" || isEventFromAnotherAgent(agentName, event)) {
+      return getContents(events.slice(i), agentName, currentBranch);
+    }
+  }
+  return [];
+}
+function isAuthEvent(event) {
+  var _a, _b, _c;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return false;
+  }
+  for (const part of event.content.parts) {
+    if (((_b = part.functionCall) == null ? void 0 : _b.name) === REQUEST_EUC_FUNCTION_CALL_NAME || ((_c = part.functionResponse) == null ? void 0 : _c.name) === REQUEST_EUC_FUNCTION_CALL_NAME) {
+      return true;
+    }
+  }
+  return false;
+}
+function isToolConfirmationEvent(event) {
+  var _a, _b, _c;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return false;
+  }
+  for (const part of event.content.parts) {
+    if (((_b = part.functionCall) == null ? void 0 : _b.name) === REQUEST_CONFIRMATION_FUNCTION_CALL_NAME || ((_c = part.functionResponse) == null ? void 0 : _c.name) === REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+      return true;
+    }
+  }
+  return false;
+}
+function isEventFromAnotherAgent(agentName, event) {
+  return !!agentName && event.author !== agentName && event.author !== "user";
+}
+function convertForeignEvent(event) {
+  var _a, _b, _c, _d, _e;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return event;
+  }
+  const content = {
+    role: "user",
+    parts: [{
+      text: "For context:"
+    }]
+  };
+  for (const part of event.content.parts) {
+    if (part.text && !part.thought) {
+      (_b = content.parts) == null ? void 0 : _b.push({
+        text: "[".concat(event.author, "] said: ").concat(part.text)
+      });
+    } else if (part.functionCall) {
+      (_c = content.parts) == null ? void 0 : _c.push({
+        text: "[".concat(event.author, "] called tool `").concat(part.functionCall.name, "` with parameters: ").concat(part.functionCall.args)
+      });
+    } else if (part.functionResponse) {
+      (_d = content.parts) == null ? void 0 : _d.push({
+        text: "[".concat(event.author, "] tool `").concat(part.functionResponse.name, "` returned result: ").concat(part.functionResponse.response)
+      });
+    } else {
+      (_e = content.parts) == null ? void 0 : _e.push(part);
+    }
+  }
+  return createEvent({
+    invocationId: event.invocationId,
+    author: "user",
+    content,
+    branch: event.branch,
+    timestamp: event.timestamp
+  });
+}
+function mergeFunctionResponseEvents(events) {
+  var _a;
+  if (events.length === 0) {
+    throw new Error("Cannot merge an empty list of events.");
+  }
+  const mergedEvent = createEvent(events[0]);
+  const partsInMergedEvent = ((_a = mergedEvent.content) == null ? void 0 : _a.parts) || [];
+  if (partsInMergedEvent.length === 0) {
+    throw new Error("There should be at least one function_response part.");
+  }
+  const partIndicesInMergedEvent = {};
+  for (let i = 0; i < partsInMergedEvent.length; i++) {
+    const part = partsInMergedEvent[i];
+    if (part.functionResponse && part.functionResponse.id) {
+      partIndicesInMergedEvent[part.functionResponse.id] = i;
+    }
+  }
+  for (const event of events.slice(1)) {
+    if (!event.content || !event.content.parts) {
+      throw new Error("There should be at least one function_response part.");
+    }
+    for (const part of event.content.parts) {
+      if (part.functionResponse && part.functionResponse.id) {
+        const functionCallId = part.functionResponse.id;
+        if (functionCallId in partIndicesInMergedEvent) {
+          partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = part;
+        } else {
+          partsInMergedEvent.push(part);
+          partIndicesInMergedEvent[functionCallId] = partsInMergedEvent.length - 1;
+        }
+      } else {
+        partsInMergedEvent.push(part);
+      }
+    }
+  }
+  return mergedEvent;
+}
+function rearrangeEventsForLatestFunctionResponse(events) {
+  if (events.length === 0) {
+    return events;
+  }
+  const latestEvent = events[events.length - 1];
+  const functionResponses = getFunctionResponses(latestEvent);
+  if (!(functionResponses == null ? void 0 : functionResponses.length)) {
+    return events;
+  }
+  let functionResponsesIds = new Set(
+    functionResponses.filter((response) => !!response.id).map((response) => response.id)
+  );
+  const secondLatestEvent = events.at(-2);
+  if (secondLatestEvent) {
+    const functionCallsFromSecondLatest = getFunctionCalls(secondLatestEvent);
+    if (functionCallsFromSecondLatest) {
+      for (const functionCall of functionCallsFromSecondLatest) {
+        if (functionCall.id && functionResponsesIds.has(functionCall.id)) {
+          return events;
+        }
+      }
+    }
+  }
+  let functionCallEventIdx = -1;
+  for (let idx = events.length - 2; idx >= 0; idx--) {
+    const event = events[idx];
+    const functionCalls = getFunctionCalls(event);
+    if (!(functionCalls == null ? void 0 : functionCalls.length)) {
+      continue;
+    }
+    for (const functionCall of functionCalls) {
+      if (functionCall.id && functionResponsesIds.has(functionCall.id)) {
+        functionCallEventIdx = idx;
+        const functionCallIds = new Set(
+          functionCalls.map((fc) => fc.id).filter((id) => !!id)
+        );
+        const isSubset = Array.from(functionResponsesIds).every((id) => functionCallIds.has(id));
+        if (!isSubset) {
+          throw new Error(
+            "Last response event should only contain the responses for the function calls in the same function call event. Function" + " call ids found : ".concat(Array.from(functionCallIds).join(", "), ", function response") + " ids provided: ".concat(Array.from(functionResponsesIds).join(", "))
+          );
+        }
+        functionResponsesIds = functionCallIds;
+        break;
+      }
+    }
+  }
+  if (functionCallEventIdx === -1) {
+    throw new Error(
+      "No function call event found for function responses ids: ".concat(Array.from(
+        functionResponsesIds
+      ).join(", "))
+    );
+  }
+  const functionResponseEvents = [];
+  for (let idx = functionCallEventIdx + 1; idx < events.length - 1; idx++) {
+    const event = events[idx];
+    const responses = getFunctionResponses(event);
+    if (responses && responses.some(
+      (response) => response.id && functionResponsesIds.has(response.id)
+    )) {
+      functionResponseEvents.push(event);
+    }
+  }
+  functionResponseEvents.push(events[events.length - 1]);
+  const resultEvents = events.slice(0, functionCallEventIdx + 1);
+  resultEvents.push(mergeFunctionResponseEvents(functionResponseEvents));
+  return resultEvents;
+}
+function rearrangeEventsForAsyncFunctionResponsesInHistory(events) {
+  const functionCallIdToResponseEventIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i];
+    const functionResponses = getFunctionResponses(event);
+    if (functionResponses == null ? void 0 : functionResponses.length) {
+      for (const functionResponse of functionResponses) {
+        if (!functionResponse.id) {
+          continue;
+        }
+        functionCallIdToResponseEventIndex.set(functionResponse.id, i);
+      }
+    }
+  }
+  const resultEvents = [];
+  for (const event of events) {
+    if (getFunctionResponses(event).length > 0) {
+      continue;
+    }
+    const functionCalls = getFunctionCalls(event);
+    if (functionCalls == null ? void 0 : functionCalls.length) {
+      const functionResponseEventsIndices = /* @__PURE__ */ new Set();
+      for (const functionCall of functionCalls) {
+        const functionCallId = functionCall.id;
+        if (functionCallId && functionCallIdToResponseEventIndex.has(functionCallId)) {
+          functionResponseEventsIndices.add(
+            functionCallIdToResponseEventIndex.get(functionCallId)
+          );
+        }
+      }
+      resultEvents.push(event);
+      if (functionResponseEventsIndices.size === 0) {
+        continue;
+      }
+      if (functionResponseEventsIndices.size === 1) {
+        const [responseIndex] = [...functionResponseEventsIndices];
+        resultEvents.push(events[responseIndex]);
+      } else {
+        const indicesArray = Array.from(functionResponseEventsIndices).sort((a, b) => a - b);
+        const eventsToMerge = indicesArray.map((index) => events[index]);
+        resultEvents.push(mergeFunctionResponseEvents(eventsToMerge));
+      }
+    } else {
+      resultEvents.push(event);
+    }
+  }
+  return resultEvents;
+}
+export {
+  getContents,
+  getCurrentTurnContents
+};