@softactivate/adk 1.1.0

package/dist/web/runner/runner.js

@@ -0,0 +1,426 @@
+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 __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && 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;
+import { createPartFromText } from "@google/genai";
+import { context, trace } from "@opentelemetry/api";
+import {
+  InvocationContext,
+  newInvocationContextId
+} from "../agents/invocation_context.js";
+import { isLlmAgent } from "../agents/llm_agent.js";
+import { createRunConfig } from "../agents/run_config.js";
+import {
+  BuiltInCodeExecutor,
+  isBuiltInCodeExecutor
+} from "../code_executors/built_in_code_executor.js";
+import { createEvent, getFunctionCalls } from "../events/event.js";
+import { createEventActions } from "../events/event_actions.js";
+import { PluginManager } from "../plugins/plugin_manager.js";
+import {
+  runAsyncGeneratorWithOtelContext,
+  tracer
+} from "../telemetry/tracing.js";
+import { logger } from "../utils/logger.js";
+import { isGemini2OrAbove } from "../utils/model_name.js";
+const RUNNER_SIGNATURE_SYMBOL = Symbol.for("google.adk.runner");
+function isRunner(obj) {
+  return typeof obj === "object" && obj !== null && RUNNER_SIGNATURE_SYMBOL in obj && obj[RUNNER_SIGNATURE_SYMBOL] === true;
+}
+_a = RUNNER_SIGNATURE_SYMBOL;
+class Runner {
+  constructor(input) {
+    this[_a] = true;
+    var _a2;
+    this.appName = input.appName;
+    this.agent = input.agent;
+    this.pluginManager = new PluginManager((_a2 = input.plugins) != null ? _a2 : []);
+    this.artifactService = input.artifactService;
+    this.sessionService = input.sessionService;
+    this.memoryService = input.memoryService;
+    this.credentialService = input.credentialService;
+  }
+  /**
+   * Runs the agent with a new, ephemeral session.
+   *
+   * @param params.userId The user ID of the session.
+   * @param params.newMessage A new message to append to the session.
+   * @param params.stateDelta An optional state delta to apply to the session.
+   * @param params.runConfig The run config for the agent.
+   * @yields The Events generated by the agent.
+   */
+  runEphemeral(params) {
+    return __asyncGenerator(this, null, function* () {
+      const session = yield new __await(this.sessionService.createSession({
+        appName: this.appName,
+        userId: params.userId
+      }));
+      const sessionId = session.id;
+      try {
+        yield* __yieldStar(this.runAsync({
+          userId: params.userId,
+          sessionId,
+          newMessage: params.newMessage,
+          stateDelta: params.stateDelta,
+          runConfig: params.runConfig
+        }));
+      } finally {
+        yield new __await(this.sessionService.deleteSession({
+          appName: this.appName,
+          userId: params.userId,
+          sessionId
+        }));
+      }
+    });
+  }
+  /**
+   * Runs the agent with the given message, and returns an async generator of
+   * events.
+   *
+   * @param params.userId The user ID of the session.
+   * @param params.sessionId The session ID of the session.
+   * @param params.newMessage A new message to append to the session.
+   * @param params.stateDelta An optional state delta to apply to the session.
+   * @param params.runConfig The run config for the agent.
+   * @yields The events generated by the agent.
+   */
+  // TODO - b/425992518: user, sessionId, and runConfig can be internalized.
+  runAsync(params) {
+    return __asyncGenerator(this, null, function* () {
+      const { userId, sessionId, stateDelta } = params;
+      const runConfig = createRunConfig(params.runConfig);
+      let newMessage = params.newMessage;
+      const span = tracer.startSpan("invocation");
+      const ctx = trace.setSpan(context.active(), span);
+      try {
+        yield* __yieldStar(runAsyncGeneratorWithOtelContext(
+          ctx,
+          this,
+          function() {
+            return __asyncGenerator(this, null, function* () {
+              var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+              const session = yield new __await(this.sessionService.getSession({
+                appName: this.appName,
+                userId,
+                sessionId
+              }));
+              if ((_a2 = params.abortSignal) == null ? void 0 : _a2.aborted) {
+                return;
+              }
+              if (!session) {
+                if (!this.appName) {
+                  throw new Error(
+                    "Session lookup failed: appName must be provided in runner constructor"
+                  );
+                }
+                throw new Error("Session not found: ".concat(sessionId));
+              }
+              if (runConfig.supportCfc && isLlmAgent(this.agent)) {
+                const modelName = this.agent.canonicalModel.model;
+                if (!isGemini2OrAbove(modelName)) {
+                  throw new Error(
+                    "CFC is not supported for model: ".concat(modelName, " in agent: ").concat(this.agent.name)
+                  );
+                }
+                if (!isBuiltInCodeExecutor(this.agent.codeExecutor)) {
+                  this.agent.codeExecutor = new BuiltInCodeExecutor();
+                }
+              }
+              const invocationContext = new InvocationContext({
+                artifactService: this.artifactService,
+                sessionService: this.sessionService,
+                memoryService: this.memoryService,
+                credentialService: this.credentialService,
+                invocationId: newInvocationContextId(),
+                agent: this.agent,
+                session,
+                userContent: newMessage,
+                runConfig,
+                pluginManager: this.pluginManager,
+                abortSignal: params.abortSignal
+              });
+              const pluginUserMessage = yield new __await(this.pluginManager.runOnUserMessageCallback({
+                userMessage: newMessage,
+                invocationContext
+              }));
+              if ((_b = params.abortSignal) == null ? void 0 : _b.aborted) {
+                return;
+              }
+              if (pluginUserMessage) {
+                newMessage = pluginUserMessage;
+              }
+              if (newMessage) {
+                if (!((_c = newMessage.parts) == null ? void 0 : _c.length)) {
+                  throw new Error("No parts in the newMessage.");
+                }
+                if (runConfig.saveInputBlobsAsArtifacts) {
+                  yield new __await(this.saveArtifacts(
+                    invocationContext.invocationId,
+                    session.userId,
+                    session.id,
+                    newMessage
+                  ));
+                  if ((_d = params.abortSignal) == null ? void 0 : _d.aborted) {
+                    return;
+                  }
+                }
+                yield new __await(this.sessionService.appendEvent({
+                  session,
+                  event: createEvent({
+                    invocationId: invocationContext.invocationId,
+                    author: "user",
+                    actions: stateDelta ? createEventActions({ stateDelta }) : void 0,
+                    content: newMessage
+                  })
+                }));
+                if ((_e = params.abortSignal) == null ? void 0 : _e.aborted) {
+                  return;
+                }
+              }
+              invocationContext.agent = this.determineAgentForResumption(
+                session,
+                this.agent
+              );
+              if (newMessage) {
+                const beforeRunCallbackResponse = yield new __await(this.pluginManager.runBeforeRunCallback({
+                  invocationContext
+                }));
+                if ((_f = params.abortSignal) == null ? void 0 : _f.aborted) {
+                  return;
+                }
+                if (beforeRunCallbackResponse) {
+                  const earlyExitEvent = createEvent({
+                    invocationId: invocationContext.invocationId,
+                    author: "model",
+                    content: beforeRunCallbackResponse
+                  });
+                  yield new __await(this.sessionService.appendEvent({
+                    session,
+                    event: earlyExitEvent
+                  }));
+                  if ((_g = params.abortSignal) == null ? void 0 : _g.aborted) {
+                    return;
+                  }
+                  yield earlyExitEvent;
+                } else {
+                  try {
+                    for (var iter = __forAwait(invocationContext.agent.runAsync(
+                      invocationContext
+                    )), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+                      const event = temp.value;
+                      if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
+                        return;
+                      }
+                      if (!event.partial) {
+                        yield new __await(this.sessionService.appendEvent({ session, event }));
+                      }
+                      const modifiedEvent = yield new __await(this.pluginManager.runOnEventCallback({
+                        invocationContext,
+                        event
+                      }));
+                      if ((_i = params.abortSignal) == null ? void 0 : _i.aborted) {
+                        return;
+                      }
+                      if (modifiedEvent) {
+                        yield modifiedEvent;
+                      } else {
+                        yield event;
+                      }
+                    }
+                  } catch (temp) {
+                    error = [temp];
+                  } finally {
+                    try {
+                      more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+                    } finally {
+                      if (error)
+                        throw error[0];
+                    }
+                  }
+                  yield new __await(this.pluginManager.runAfterRunCallback({ invocationContext }));
+                  if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
+                    return;
+                  }
+                }
+              }
+            });
+          }
+        ));
+      } finally {
+        span.end();
+      }
+    });
+  }
+  /**
+   * Saves artifacts from the message parts and replaces the inline data with
+   * a file name placeholder.
+   *
+   * @param invocationId The current invocation ID.
+   * @param userId The user ID of the session.
+   * @param sessionId The session ID of the session.
+   * @param message The message containing parts to process.
+   */
+  async saveArtifacts(invocationId, userId, sessionId, message) {
+    var _a2;
+    if (!this.artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
+      return;
+    }
+    for (let i = 0; i < message.parts.length; i++) {
+      const part = message.parts[i];
+      if (!part.inlineData) {
+        continue;
+      }
+      const fileName = "artifact_".concat(invocationId, "_").concat(i);
+      await this.artifactService.saveArtifact({
+        appName: this.appName,
+        userId,
+        sessionId,
+        filename: fileName,
+        artifact: part
+      });
+      message.parts[i] = createPartFromText(
+        "Uploaded file: ".concat(fileName, ". It is saved into artifacts")
+      );
+    }
+  }
+  /**
+   * Determines the next agent to run to continue the session. This is primarily
+   * used for session resumption.
+   */
+  // TODO - b/425992518: This is where LRO integration should happen.
+  // Needs clean up before we can generalize it.
+  determineAgentForResumption(session, rootAgent) {
+    const event = findEventByLastFunctionResponseId(session.events);
+    if (event && event.author) {
+      return rootAgent.findAgent(event.author) || rootAgent;
+    }
+    for (let i = session.events.length - 1; i >= 0; i--) {
+      logger.info("event:", JSON.stringify(session.events[i]));
+      const event2 = session.events[i];
+      if (event2.author === "user" || !event2.author) {
+        continue;
+      }
+      if (event2.author === rootAgent.name) {
+        return rootAgent;
+      }
+      const agent = rootAgent.findSubAgent(event2.author);
+      if (!agent) {
+        logger.warn(
+          "Event from an unknown agent: ".concat(event2.author, ", event id: ").concat(event2.id)
+        );
+        continue;
+      }
+      if (this.isRoutableLlmAgent(agent)) {
+        return agent;
+      }
+    }
+    return rootAgent;
+  }
+  /**
+   * Whether the agent to run can transfer to any other agent in the agent tree.
+   *
+   * An agent is transferable if:
+   *  - It is an instance of `LlmAgent`.
+   *  - All its ancestors are also transferable (i.e., they have
+   *    `disallowTransferToParent` set to false).
+   *
+   * @param agentToRun The agent to check for transferability.
+   * @returns True if the agent can transfer, False otherwise.
+   */
+  isRoutableLlmAgent(agentToRun) {
+    let agent = agentToRun;
+    while (agent) {
+      if (!isLlmAgent(agent)) {
+        return false;
+      }
+      if (agent.disallowTransferToParent) {
+        return false;
+      }
+      agent = agent.parentAgent;
+    }
+    return true;
+  }
+  // TODO - b/425992518: Implement runLive and related methods.
+}
+function findEventByLastFunctionResponseId(events) {
+  var _a2, _b, _c, _d;
+  if (!events.length) {
+    return null;
+  }
+  const lastEvent = events[events.length - 1];
+  const functionCallId = (_d = (_c = (_b = (_a2 = lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b.find(
+    (part) => part.functionResponse
+  )) == null ? void 0 : _c.functionResponse) == null ? void 0 : _d.id;
+  if (!functionCallId) {
+    return null;
+  }
+  for (let i = events.length - 2; i >= 0; i--) {
+    const event = events[i];
+    const functionCalls = getFunctionCalls(event);
+    if (!functionCalls) {
+      continue;
+    }
+    for (const functionCall of functionCalls) {
+      if (functionCall.id === functionCallId) {
+        return event;
+      }
+    }
+  }
+  return null;
+}
+export {
+  Runner,
+  isRunner
+};

package/dist/web/sessions/base_session_service.js

@@ -0,0 +1,91 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { cloneDeep } from "lodash-es";
+import { State } from "./state.js";
+class BaseSessionService {
+  /**
+   * Gets a session or creates one if it doesn't exist.
+   *
+   * @param request The request to get or create a session.
+   * @return A promise that resolves to the session instance.
+   */
+  async getOrCreateSession(request) {
+    if (!request.sessionId) {
+      return this.createSession(request);
+    }
+    const session = await this.getSession({
+      appName: request.appName,
+      userId: request.userId,
+      sessionId: request.sessionId
+    });
+    if (session) {
+      return session;
+    }
+    return this.createSession(request);
+  }
+  /**
+   * Appends an event to a session.
+   *
+   * @param request The request to append an event.
+   * @return A promise that resolves to the event that was appended.
+   */
+  async appendEvent({ session, event }) {
+    if (event.partial) {
+      return event;
+    }
+    event = trimTempDeltaState(event);
+    this.updateSessionState({ session, event });
+    session.events.push(event);
+    return event;
+  }
+  /**
+   * Updates the session state based on the event.
+   *
+   * @param request The request to update the session state.
+   */
+  updateSessionState({ session, event }) {
+    if (!event.actions || !event.actions.stateDelta) {
+      return;
+    }
+    for (const [key, value] of Object.entries(event.actions.stateDelta)) {
+      if (key.startsWith(State.TEMP_PREFIX)) {
+        continue;
+      }
+      session.state[key] = value;
+    }
+  }
+}
+function trimTempDeltaState(event) {
+  if (!event.actions || !event.actions.stateDelta) {
+    return event;
+  }
+  const stateDelta = event.actions.stateDelta;
+  const filteredStateDelta = {};
+  for (const [key, value] of Object.entries(stateDelta)) {
+    if (!key.startsWith(State.TEMP_PREFIX)) {
+      filteredStateDelta[key] = value;
+    }
+  }
+  event.actions.stateDelta = filteredStateDelta;
+  return event;
+}
+function mergeStates(appState = {}, userState = {}, sessionState = {}) {
+  const merged = cloneDeep(sessionState);
+  for (const [k, v] of Object.entries(appState)) {
+    merged[State.APP_PREFIX + k] = v;
+  }
+  for (const [k, v] of Object.entries(userState)) {
+    merged[State.USER_PREFIX + k] = v;
+  }
+  return merged;
+}
+export {
+  BaseSessionService,
+  mergeStates,
+  trimTempDeltaState
+};