@softactivate/adk 1.1.0

package/dist/cjs/sessions/in_memory_session_service.js

@@ -0,0 +1,210 @@
+/**
+  * @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 in_memory_session_service_exports = {};
+__export(in_memory_session_service_exports, {
+  InMemorySessionService: () => InMemorySessionService,
+  isInMemoryConnectionString: () => isInMemoryConnectionString
+});
+module.exports = __toCommonJS(in_memory_session_service_exports);
+var import_lodash_es = require("lodash-es");
+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
+ */
+function isInMemoryConnectionString(uri) {
+  return uri === "memory://";
+}
+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 = {};
+  }
+  async createSession({
+    appName,
+    userId,
+    state,
+    sessionId
+  }) {
+    var _a;
+    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;
+    const copiedSession = (0, import_lodash_es.cloneDeep)(session);
+    copiedSession.state = (0, import_base_session_service.mergeStates)(
+      this.appState[appName],
+      (_a = this.userState[appName]) == null ? void 0 : _a[userId],
+      copiedSession.state
+    );
+    return copiedSession;
+  }
+  async getSession({
+    appName,
+    userId,
+    sessionId,
+    config
+  }) {
+    var _a;
+    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_lodash_es.cloneDeep)(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);
+        }
+      }
+    }
+    copiedSession.state = (0, import_base_session_service.mergeStates)(
+      this.appState[appName],
+      (_a = this.userState[appName]) == null ? void 0 : _a[userId],
+      copiedSession.state
+    );
+    return 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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemorySessionService,
+  isInMemoryConnectionString
+});

package/dist/cjs/sessions/registry.js

@@ -0,0 +1,49 @@
+/**
+  * @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 registry_exports = {};
+__export(registry_exports, {
+  getSessionServiceFromUri: () => getSessionServiceFromUri
+});
+module.exports = __toCommonJS(registry_exports);
+var import_database_session_service = require("./database_session_service.js");
+var import_in_memory_session_service = require("./in_memory_session_service.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function getSessionServiceFromUri(uri) {
+  if ((0, import_in_memory_session_service.isInMemoryConnectionString)(uri)) {
+    return new import_in_memory_session_service.InMemorySessionService();
+  }
+  if ((0, import_database_session_service.isDatabaseConnectionString)(uri)) {
+    return new import_database_session_service.DatabaseSessionService(uri);
+  }
+  throw new Error(`Unsupported session service URI: ${uri}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSessionServiceFromUri
+});

package/dist/cjs/sessions/session.js

@@ -0,0 +1,48 @@
+/**
+  * @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 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 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 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) {
+    Object.assign(this.delta, delta);
+    Object.assign(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/skills/loader.js

@@ -0,0 +1,283 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loader_exports = {};
+__export(loader_exports, {
+  loadAllSkillsInDir: () => loadAllSkillsInDir,
+  loadSkillFromDir: () => loadSkillFromDir,
+  parseSkillMdContent: () => parseSkillMdContent,
+  validateSkillDir: () => validateSkillDir
+});
+module.exports = __toCommonJS(loader_exports);
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+var fs = __toESM(require("node:fs/promises"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_logger = require("../utils/logger.js");
+var import_skill = require("./skill.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const ALLOWED_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "license",
+  "allowed-tools",
+  "metadata",
+  "compatibility"
+]);
+const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  "node_modules",
+  "coverage",
+  "venv",
+  ".venv",
+  "env",
+  ".env",
+  ".git",
+  ".vscode",
+  ".idea"
+]);
+const IGNORED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pyc",
+  ".pyo",
+  ".pyd",
+  ".tsbuildinfo",
+  ".DS_Store"
+]);
+async function loadDir(directoryPath) {
+  const files = {};
+  async function walk(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRECTORIES.has(entry.name)) {
+          continue;
+        }
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        const relativePath = path.relative(directoryPath, fullPath);
+        if (IGNORED_EXTENSIONS.has(path.extname(entry.name))) {
+          continue;
+        }
+        const fileData = await fs.readFile(fullPath);
+        try {
+          files[relativePath] = fileData.toString("utf-8");
+        } catch (_e) {
+          files[relativePath] = fileData;
+        }
+      }
+    }
+  }
+  try {
+    const stats = await fs.stat(directoryPath);
+    if (stats.isDirectory()) {
+      await walk(directoryPath);
+    }
+  } catch (e) {
+    import_logger.logger.warn(
+      `Failed to load directory '${directoryPath}': ${e.message}`
+    );
+  }
+  return files;
+}
+function parseSkillMdContent(content) {
+  if (!content.startsWith("---")) {
+    throw new Error("SKILL.md must start with YAML frontmatter (---)");
+  }
+  const parts = content.split("---", 3);
+  if (parts.length < 3) {
+    throw new Error("SKILL.md frontmatter not properly closed with ---");
+  }
+  const frontmatterStr = parts[1];
+  const body = parts[2].trim();
+  try {
+    const parsed = import_js_yaml.default.load(frontmatterStr);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error("SKILL.md frontmatter must be a YAML mapping");
+    }
+    const frontmatter = import_skill.FrontmatterSchema.parse(parsed);
+    return { frontmatter, body };
+  } catch (e) {
+    throw new Error(`Invalid YAML in frontmatter: ${e.message}`);
+  }
+}
+async function loadSkillFromDir(skillDir) {
+  const resolvedDir = path.resolve(skillDir);
+  const skill = await loadSkillFile(skillDir);
+  const referencesDir = path.join(resolvedDir, "references");
+  const assetsDir = path.join(resolvedDir, "assets");
+  const scriptsDir = path.join(resolvedDir, "scripts");
+  const [references, assets, rawScripts] = await Promise.all([
+    loadDir(referencesDir),
+    loadDir(assetsDir),
+    loadDir(scriptsDir)
+  ]);
+  const scripts = {};
+  for (const [name, src] of Object.entries(rawScripts)) {
+    if (typeof src === "string") {
+      scripts[name] = { src };
+    }
+  }
+  const resources = { references, assets, scripts };
+  return {
+    ...skill,
+    resources
+  };
+}
+async function validateSkillDir(skillDir) {
+  const problems = [];
+  const resolvedDir = path.resolve(skillDir);
+  let skill;
+  try {
+    skill = await loadSkillFile(resolvedDir);
+  } catch (e) {
+    return [e.message];
+  }
+  try {
+    const keys = Object.keys(skill.frontmatter);
+    const unknown = keys.filter((k) => !ALLOWED_FRONTMATTER_KEYS.has(k));
+    if (unknown.length > 0) {
+      problems.push(
+        `Unknown frontmatter fields: [${unknown.sort().join(", ")}]`
+      );
+    }
+    const dirName = path.basename(resolvedDir);
+    if (dirName !== skill.frontmatter.name) {
+      problems.push(
+        `Skill name '${skill.frontmatter.name}' does not match directory name '${dirName}'.`
+      );
+    }
+  } catch (e) {
+    problems.push(e.message);
+  }
+  return problems;
+}
+async function loadSkillFile(skillDir) {
+  const resolvedDir = path.resolve(skillDir);
+  let skillMdPath = "";
+  let content = "";
+  try {
+    const entries = await fs.readdir(resolvedDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.toLowerCase() === "skill.md") {
+        const p = path.join(resolvedDir, entry.name);
+        try {
+          content = await fs.readFile(p, "utf-8");
+          skillMdPath = p;
+          break;
+        } catch (_e) {
+        }
+      }
+    }
+  } catch (e) {
+    import_logger.logger.warn(
+      `Failed to load directory '${skillDir}': ${e.message}`
+    );
+  }
+  if (!skillMdPath) {
+    throw new Error(
+      `SKILL.md (or any case variation like skill.md) not found in '${skillDir}'.`
+    );
+  }
+  const { frontmatter: parsed, body } = parseSkillMdContent(content);
+  const frontmatter = import_skill.FrontmatterSchema.parse(parsed);
+  const dirName = path.basename(resolvedDir);
+  if (dirName !== frontmatter.name) {
+    throw new Error(
+      `Skill name '${frontmatter.name}' does not match directory name '${dirName}'.`
+    );
+  }
+  return {
+    frontmatter,
+    instructions: body
+  };
+}
+async function loadAllSkillsInDir(skillsBasePath) {
+  const resolvedPath = path.resolve(skillsBasePath);
+  const skills = {};
+  async function scanDir(currentDir) {
+    let entries;
+    try {
+      entries = await fs.readdir(currentDir, { withFileTypes: true });
+    } catch (_e) {
+      return;
+    }
+    let isSkillDir = false;
+    if (currentDir !== resolvedPath) {
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.toLowerCase() === "skill.md") {
+          isSkillDir = true;
+          break;
+        }
+      }
+    }
+    if (isSkillDir) {
+      try {
+        const skill = await loadSkillFromDir(currentDir);
+        skills[skill.frontmatter.name] = skill;
+      } catch (e) {
+        import_logger.logger.warn(`Skipping invalid skill in '${currentDir}':`, e);
+      }
+    } else {
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (IGNORED_DIRECTORIES.has(entry.name)) {
+            continue;
+          }
+          await scanDir(path.join(currentDir, entry.name));
+        }
+      }
+    }
+  }
+  try {
+    await fs.readdir(resolvedPath);
+    await scanDir(resolvedPath);
+  } catch (e) {
+    import_logger.logger.warn(`Skills base path '${skillsBasePath}' is not a directory.`, e);
+  }
+  return skills;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadAllSkillsInDir,
+  loadSkillFromDir,
+  parseSkillMdContent,
+  validateSkillDir
+});