@google/adk 0.1.0

package/dist/cjs/sessions/in_memory_session_service.js

@@ -0,0 +1,184 @@
+/**
+  * @license
+  * Copyright 2025 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_session_service_exports = {};
+__export(in_memory_session_service_exports, {
+  InMemorySessionService: () => InMemorySessionService
+});
+module.exports = __toCommonJS(in_memory_session_service_exports);
+var import_deep_clone = require("../utils/deep_clone.js");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_logger = require("../utils/logger.js");
+var import_base_session_service = require("./base_session_service.js");
+var import_session = require("./session.js");
+var import_state = require("./state.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class InMemorySessionService extends import_base_session_service.BaseSessionService {
+  constructor() {
+    super(...arguments);
+    /**
+     * A map from app name to a map from user ID to a map from session ID to
+     * session.
+     */
+    this.sessions = {};
+    /**
+     * A map from app name to a map from user ID to a map from key to the value.
+     */
+    this.userState = {};
+    /**
+     * A map from app name to a map from key to the value.
+     */
+    this.appState = {};
+  }
+  createSession({ appName, userId, state, sessionId }) {
+    const session = (0, import_session.createSession)({
+      id: sessionId || (0, import_env_aware_utils.randomUUID)(),
+      appName,
+      userId,
+      state,
+      events: [],
+      lastUpdateTime: Date.now()
+    });
+    if (!this.sessions[appName]) {
+      this.sessions[appName] = {};
+    }
+    if (!this.sessions[appName][userId]) {
+      this.sessions[appName][userId] = {};
+    }
+    this.sessions[appName][userId][session.id] = session;
+    return Promise.resolve(
+      this.mergeState(appName, userId, (0, import_deep_clone.deepClone)(session))
+    );
+  }
+  getSession({ appName, userId, sessionId, config }) {
+    if (!this.sessions[appName] || !this.sessions[appName][userId] || !this.sessions[appName][userId][sessionId]) {
+      return Promise.resolve(void 0);
+    }
+    const session = this.sessions[appName][userId][sessionId];
+    const copiedSession = (0, import_deep_clone.deepClone)(session);
+    if (config) {
+      if (config.numRecentEvents) {
+        copiedSession.events = copiedSession.events.slice(-config.numRecentEvents);
+      }
+      if (config.afterTimestamp) {
+        let i = copiedSession.events.length - 1;
+        while (i >= 0) {
+          if (copiedSession.events[i].timestamp < config.afterTimestamp) {
+            break;
+          }
+          i--;
+        }
+        if (i >= 0) {
+          copiedSession.events = copiedSession.events.slice(i + 1);
+        }
+      }
+    }
+    return Promise.resolve(this.mergeState(appName, userId, copiedSession));
+  }
+  listSessions({ appName, userId }) {
+    if (!this.sessions[appName] || !this.sessions[appName][userId]) {
+      return Promise.resolve({ sessions: [] });
+    }
+    const sessionsWithoutEvents = [];
+    for (const session of Object.values(this.sessions[appName][userId])) {
+      sessionsWithoutEvents.push((0, import_session.createSession)({
+        id: session.id,
+        appName: session.appName,
+        userId: session.userId,
+        state: {},
+        events: [],
+        lastUpdateTime: session.lastUpdateTime
+      }));
+    }
+    return Promise.resolve({ sessions: sessionsWithoutEvents });
+  }
+  async deleteSession({ appName, userId, sessionId }) {
+    const session = await this.getSession({ appName, userId, sessionId });
+    if (!session) {
+      return;
+    }
+    delete this.sessions[appName][userId][sessionId];
+  }
+  async appendEvent({ session, event }) {
+    await super.appendEvent({ session, event });
+    session.lastUpdateTime = event.timestamp;
+    const appName = session.appName;
+    const userId = session.userId;
+    const sessionId = session.id;
+    const warning = (message) => {
+      import_logger.logger.warn(`Failed to append event to session ${sessionId}: ${message}`);
+    };
+    if (!this.sessions[appName]) {
+      warning(`appName ${appName} not in sessions`);
+      return event;
+    }
+    if (!this.sessions[appName][userId]) {
+      warning(`userId ${userId} not in sessions[appName]`);
+      return event;
+    }
+    if (!this.sessions[appName][userId][sessionId]) {
+      warning(`sessionId ${sessionId} not in sessions[appName][userId]`);
+      return event;
+    }
+    if (event.actions && event.actions.stateDelta) {
+      for (const key of Object.keys(event.actions.stateDelta)) {
+        if (key.startsWith(import_state.State.APP_PREFIX)) {
+          this.appState[appName] = this.appState[appName] || {};
+          this.appState[appName][key.replace(import_state.State.APP_PREFIX, "")] = event.actions.stateDelta[key];
+        }
+        if (key.startsWith(import_state.State.USER_PREFIX)) {
+          this.userState[appName] = this.userState[appName] || {};
+          this.userState[appName][userId] = this.userState[appName][userId] || {};
+          this.userState[appName][userId][key.replace(import_state.State.USER_PREFIX, "")] = event.actions.stateDelta[key];
+        }
+      }
+    }
+    const storageSession = this.sessions[appName][userId][sessionId];
+    await super.appendEvent({ session: storageSession, event });
+    storageSession.lastUpdateTime = event.timestamp;
+    return event;
+  }
+  mergeState(appName, userId, copiedSession) {
+    if (this.appState[appName]) {
+      for (const key of Object.keys(this.appState[appName])) {
+        copiedSession.state[import_state.State.APP_PREFIX + key] = this.appState[appName][key];
+      }
+    }
+    if (!this.userState[appName] || !this.userState[appName][userId]) {
+      return copiedSession;
+    }
+    for (const key of Object.keys(this.userState[appName][userId])) {
+      copiedSession.state[import_state.State.USER_PREFIX + key] = this.userState[appName][userId][key];
+    }
+    return copiedSession;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemorySessionService
+});

package/dist/cjs/sessions/session.js

@@ -0,0 +1,48 @@
+/**
+  * @license
+  * Copyright 2025 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_exports = {};
+__export(session_exports, {
+  createSession: () => createSession
+});
+module.exports = __toCommonJS(session_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createSession(params) {
+  return {
+    id: params.id,
+    appName: params.appName,
+    userId: params.userId || "",
+    state: params.state || {},
+    events: params.events || [],
+    lastUpdateTime: params.lastUpdateTime || 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSession
+});

package/dist/cjs/sessions/state.js

@@ -0,0 +1,101 @@
+/**
+  * @license
+  * Copyright 2025 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 state_exports = {};
+__export(state_exports, {
+  State: () => State
+});
+module.exports = __toCommonJS(state_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class State {
+  constructor(value, delta) {
+    this.value = value;
+    this.delta = delta;
+  }
+  /**
+   * Returns the value of the state dict for the given key.
+   *
+   * @param key The key to get the value for.
+   * @param defaultValue The default value to return if the key is not found.
+   * @return The value of the state for the given key, or the default value if
+   *     not found.
+   */
+  get(key, defaultValue) {
+    if (key in this.delta) {
+      return this.delta[key];
+    }
+    if (key in this.value) {
+      return this.value[key];
+    }
+    return defaultValue;
+  }
+  /**
+   * Sets the value of the state dict for the given key.
+   *
+   * @param key The key to set the value for.
+   * @param value The value to set.
+   */
+  set(key, value) {
+    this.value[key] = value;
+    this.delta[key] = value;
+  }
+  /**
+   * Whether the state has pending delta.
+   */
+  has(key) {
+    return key in this.value || key in this.delta;
+  }
+  /**
+   * Whether the state has pending delta.
+   */
+  hasDelta() {
+    return Object.keys(this.delta).length > 0;
+  }
+  /**
+   * Updates the state dict with the given delta.
+   *
+   * @param delta The delta to update the state with.
+   */
+  update(delta) {
+    this.delta = { ...this.delta, ...delta };
+    this.value = { ...this.value, ...delta };
+  }
+  /**
+   * Returns the state as a plain JSON object.
+   */
+  toRecord() {
+    return { ...this.value, ...this.delta };
+  }
+}
+State.APP_PREFIX = "app:";
+State.USER_PREFIX = "user:";
+State.TEMP_PREFIX = "temp:";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  State
+});

package/dist/cjs/tools/agent_tool.js

@@ -0,0 +1,134 @@
+/**
+  * @license
+  * Copyright 2025 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_tool_exports = {};
+__export(agent_tool_exports, {
+  AgentTool: () => AgentTool
+});
+module.exports = __toCommonJS(agent_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_agent = require("../agents/llm_agent.js");
+var import_in_memory_memory_service = require("../memory/in_memory_memory_service.js");
+var import_runner = require("../runner/runner.js");
+var import_in_memory_session_service = require("../sessions/in_memory_session_service.js");
+var import_variant_utils = require("../utils/variant_utils.js");
+var import_base_tool = require("./base_tool.js");
+var import_forwarding_artifact_service = require("./forwarding_artifact_service.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class AgentTool extends import_base_tool.BaseTool {
+  constructor(config) {
+    super(
+      { name: config.agent.name, description: config.agent.description || "" }
+    );
+    this.agent = config.agent;
+    this.skipSummarization = config.skipSummarization || false;
+  }
+  _getDeclaration() {
+    let declaration;
+    if (this.agent instanceof import_llm_agent.LlmAgent && this.agent.inputSchema) {
+      declaration = {
+        name: this.name,
+        description: this.description,
+        // TODO(b/425992518): We should not use the agent's input schema as is.
+        // It should be validated and possibly transformed. Consider similar
+        // logic to one we have in Python ADK.
+        parameters: this.agent.inputSchema
+      };
+    } else {
+      declaration = {
+        name: this.name,
+        description: this.description,
+        parameters: {
+          type: import_genai.Type.OBJECT,
+          properties: {
+            "request": {
+              type: import_genai.Type.STRING
+            }
+          },
+          required: ["request"]
+        }
+      };
+    }
+    if (this.apiVariant !== import_variant_utils.GoogleLLMVariant.GEMINI_API) {
+      const hasOutputSchema = this.agent instanceof import_llm_agent.LlmAgent && this.agent.outputSchema;
+      declaration.response = hasOutputSchema ? { type: import_genai.Type.OBJECT } : { type: import_genai.Type.STRING };
+    }
+    return declaration;
+  }
+  async runAsync({ args, toolContext }) {
+    var _a, _b;
+    if (this.skipSummarization) {
+      toolContext.actions.skipSummarization = true;
+    }
+    const hasInputSchema = this.agent instanceof import_llm_agent.LlmAgent && this.agent.inputSchema;
+    const content = {
+      role: "user",
+      parts: [
+        {
+          // TODO(b/425992518): Should be validated. Consider similar
+          // logic to one we have in Python ADK.
+          text: hasInputSchema ? JSON.stringify(args) : args["request"]
+        }
+      ]
+    };
+    const runner = new import_runner.Runner({
+      appName: this.agent.name,
+      agent: this.agent,
+      artifactService: new import_forwarding_artifact_service.ForwardingArtifactService(toolContext),
+      sessionService: new import_in_memory_session_service.InMemorySessionService(),
+      memoryService: new import_in_memory_memory_service.InMemoryMemoryService(),
+      credentialService: toolContext.invocationContext.credentialService
+    });
+    const session = await runner.sessionService.createSession({
+      appName: this.agent.name,
+      userId: "tmp_user",
+      state: toolContext.state.toRecord()
+    });
+    let lastEvent;
+    for await (const event of runner.runAsync({
+      userId: session.userId,
+      sessionId: session.id,
+      newMessage: content
+    })) {
+      if (event.actions.stateDelta) {
+        toolContext.state.update(event.actions.stateDelta);
+      }
+      lastEvent = event;
+    }
+    if (!((_b = (_a = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+      return "";
+    }
+    const hasOutputSchema = this.agent instanceof import_llm_agent.LlmAgent && this.agent.outputSchema;
+    const mergetText = lastEvent.content.parts.map((part) => part.text).filter((text) => text).join("\n");
+    return hasOutputSchema ? JSON.parse(mergetText) : mergetText;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentTool
+});

package/dist/cjs/tools/base_tool.js

@@ -0,0 +1,107 @@
+/**
+  * @license
+  * Copyright 2025 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_tool_exports = {};
+__export(base_tool_exports, {
+  BaseTool: () => BaseTool
+});
+module.exports = __toCommonJS(base_tool_exports);
+var import_variant_utils = require("../utils/variant_utils.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BaseTool {
+  /**
+   * Base constructor for a tool.
+   *
+   * @param params The parameters for `BaseTool`.
+   */
+  constructor(params) {
+    var _a;
+    this.name = params.name;
+    this.description = params.description;
+    this.isLongRunning = (_a = params.isLongRunning) != null ? _a : false;
+  }
+  /**
+   * Gets the OpenAPI specification of this tool in the form of a
+   * FunctionDeclaration.
+   *
+   * NOTE
+   * - Required if subclass uses the default implementation of
+   *   `processLlmRequest` to add function declaration to LLM request.
+   * - Otherwise, can be skipped, e.g. for a built-in GoogleSearch tool for
+   *   Gemini.
+   *
+   * @return The FunctionDeclaration of this tool, or undefined if it doesn't
+   *     need to be added to LlmRequest.config.
+   */
+  _getDeclaration() {
+    return void 0;
+  }
+  /**
+   * Processes the outgoing LLM request for this tool.
+   *
+   * Use cases:
+   * - Most common use case is adding this tool to the LLM request.
+   * - Some tools may just preprocess the LLM request before it's sent out.
+   *
+   * @param request The request to process the LLM request.
+   */
+  async processLlmRequest({ toolContext, llmRequest }) {
+    const functionDeclaration = this._getDeclaration();
+    if (!functionDeclaration) {
+      return;
+    }
+    llmRequest.toolsDict[this.name] = this;
+    const tool = findToolWithFunctionDeclarations(llmRequest);
+    if (tool) {
+      if (!tool.functionDeclarations) {
+        tool.functionDeclarations = [];
+      }
+      tool.functionDeclarations.push(functionDeclaration);
+    } else {
+      llmRequest.config = llmRequest.config || {};
+      llmRequest.config.tools = llmRequest.config.tools || [];
+      llmRequest.config.tools.push({
+        functionDeclarations: [functionDeclaration]
+      });
+    }
+  }
+  /**
+   * The Google API LLM variant to use.
+   */
+  get apiVariant() {
+    return (0, import_variant_utils.getGoogleLlmVariant)();
+  }
+}
+function findToolWithFunctionDeclarations(llmRequest) {
+  var _a;
+  return (((_a = llmRequest.config) == null ? void 0 : _a.tools) || []).find((tool) => "functionDeclarations" in tool);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseTool
+});

package/dist/cjs/tools/base_toolset.js

@@ -0,0 +1,76 @@
+/**
+  * @license
+  * Copyright 2025 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_toolset_exports = {};
+__export(base_toolset_exports, {
+  BaseToolset: () => BaseToolset
+});
+module.exports = __toCommonJS(base_toolset_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BaseToolset {
+  constructor(toolFilter) {
+    this.toolFilter = toolFilter;
+  }
+  /**
+   * Returns whether the tool should be exposed to LLM.
+   *
+   * @param tool The tool to check.
+   * @param context Context used to filter tools available to the agent.
+   * @return Whether the tool should be exposed to LLM.
+   */
+  isToolSelected(tool, context) {
+    if (!this.toolFilter) {
+      return true;
+    }
+    if (typeof this.toolFilter === "function") {
+      return this.toolFilter(tool, context);
+    }
+    if (Array.isArray(this.toolFilter)) {
+      return this.toolFilter.includes(tool.name);
+    }
+    return false;
+  }
+  /**
+   * Processes the outgoing LLM request for this toolset. This method will be
+   * called before each tool processes the llm request.
+   *
+   * Use cases:
+   * - Instead of let each tool process the llm request, we can let the toolset
+   *   process the llm request. e.g. ComputerUseToolset can add computer use
+   *   tool to the llm request.
+   *
+   * @param toolContext The context of the tool.
+   * @param llmRequest The outgoing LLM request, mutable this method.
+   */
+  async processLlmRequest(toolContext, llmRequest) {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseToolset
+});