@happyvertical/smrt-agents 0.30.0

package/dist/chunks/config-BYbOxt24.js

@@ -0,0 +1,179 @@
+import { ObjectRegistry, getClassName, field, smrt, SmrtObject, SmrtCollection } from "@happyvertical/smrt-core";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+function getAgentTypeName(name) {
+  const registered = ObjectRegistry.getClass(name);
+  return registered?.qualifiedName || registered?.name || name;
+}
+function getAgentClassName(name) {
+  const registered = ObjectRegistry.getClass(name);
+  return registered?.name || getClassName(name);
+}
+function getAgentTypeAliases(name) {
+  return Array.from(
+    new Set([getAgentTypeName(name), getAgentClassName(name)].filter(Boolean))
+  );
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let AgentConfig = class extends SmrtObject {
+  tenantId = null;
+  agentId = "";
+  agentClass = "";
+  slotId = "";
+  configData = {};
+  schemaVersion = 1;
+  /**
+   * Load all configs for a specific agent
+   *
+   * @param agentId - Agent instance ID
+   * @param options - Database options
+   * @returns Map of slotId → configData
+   */
+  static async forAgent(agentId, options) {
+    const configsByAgent = await AgentConfig.forAgents([agentId], options);
+    return configsByAgent.get(agentId) ?? /* @__PURE__ */ new Map();
+  }
+  /**
+   * Load configs for multiple agents in a single query.
+   *
+   * @param agentIds - Agent instance IDs
+   * @param options - Database options
+   * @returns Map of agentId -> (slotId -> configData)
+   */
+  static async forAgents(agentIds, options) {
+    const configsByAgent = /* @__PURE__ */ new Map();
+    if (agentIds.length === 0) {
+      return configsByAgent;
+    }
+    const collection = await AgentConfigCollection.create(options);
+    const configs = await collection.list({
+      where: { "agentId in": agentIds }
+    });
+    for (const config of configs) {
+      if (!configsByAgent.has(config.agentId)) {
+        configsByAgent.set(config.agentId, /* @__PURE__ */ new Map());
+      }
+      configsByAgent.get(config.agentId)?.set(config.slotId, config.configData);
+    }
+    return configsByAgent;
+  }
+  /**
+   * Load config for a specific agent and slot
+   *
+   * @param agentId - Agent instance ID
+   * @param slotId - UI slot ID
+   * @param options - Database options
+   * @returns Config data or undefined if not found
+   */
+  static async forSlot(agentId, slotId, options) {
+    const collection = await AgentConfigCollection.create(options);
+    const configs = await collection.list({
+      where: { agentId, slotId },
+      limit: 1
+    });
+    return configs[0]?.configData;
+  }
+  /**
+   * Save or update config for an agent slot
+   *
+   * @param data - Config data including agentId, agentClass, slotId, configData
+   * @param options - Database options
+   * @returns Saved AgentConfig instance
+   */
+  static async saveSlot(data, options) {
+    const normalizedAgentClass = getAgentTypeName(data.agentClass);
+    const collection = await AgentConfigCollection.create(options);
+    const existingConfigs = await collection.list({
+      where: { agentId: data.agentId, slotId: data.slotId },
+      limit: 1
+    });
+    if (existingConfigs.length > 0) {
+      const existing = existingConfigs[0];
+      existing.configData = data.configData;
+      existing.agentClass = normalizedAgentClass;
+      await existing.save();
+      return existing;
+    }
+    const config = await collection.create({
+      agentId: data.agentId,
+      agentClass: normalizedAgentClass,
+      slotId: data.slotId,
+      configData: data.configData,
+      slug: `${data.agentId}-${data.slotId}`
+    });
+    await config.save();
+    return config;
+  }
+};
+__decorateClass([
+  tenantId({ nullable: true })
+], AgentConfig.prototype, "tenantId", 2);
+__decorateClass([
+  field({ type: "text" })
+], AgentConfig.prototype, "agentId", 2);
+__decorateClass([
+  field({ type: "text" })
+], AgentConfig.prototype, "agentClass", 2);
+__decorateClass([
+  field({ type: "text" })
+], AgentConfig.prototype, "slotId", 2);
+__decorateClass([
+  field({ type: "json", sensitive: true })
+], AgentConfig.prototype, "configData", 2);
+__decorateClass([
+  field({ type: "integer" })
+], AgentConfig.prototype, "schemaVersion", 2);
+AgentConfig = __decorateClass([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableName: "agent_configs",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], AgentConfig);
+class AgentConfigCollection extends SmrtCollection {
+  static _itemClass = AgentConfig;
+  /**
+   * Find all configs for a specific tenant
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of AgentConfig objects for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global configs (not associated with any tenant)
+   * @returns Array of global AgentConfig objects
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find configs for a tenant including global configs
+   * @param tenantId - Tenant ID to include
+   * @returns Array of AgentConfig objects for the tenant and global configs
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+export {
+  AgentConfig as A,
+  getAgentClassName as a,
+  getAgentTypeAliases as b,
+  AgentConfigCollection as c,
+  getAgentTypeName as g
+};
+//# sourceMappingURL=config-BYbOxt24.js.map

package/dist/chunks/config-BYbOxt24.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-BYbOxt24.js","sources":["../../src/identity.ts","../../src/config.ts"],"sourcesContent":["import { getClassName, ObjectRegistry } from '@happyvertical/smrt-core';\n\n/**\n * Return the canonical agent type identifier for storage and dispatch routing.\n *\n * Uses the registry's qualified name when available and falls back to the input\n * name for dynamically defined or unregistered classes.\n */\nexport function getAgentTypeName(name: string): string {\n  const registered = ObjectRegistry.getClass(name);\n  return registered?.qualifiedName || registered?.name || name;\n}\n\n/**\n * Return the human-readable class name for UI and logs.\n */\nexport function getAgentClassName(name: string): string {\n  const registered = ObjectRegistry.getClass(name);\n  return registered?.name || getClassName(name);\n}\n\n/**\n * Return all meaningful aliases for an agent type.\n *\n * The qualified name is first so persistence lookups prefer canonical rows,\n * while the simple class name keeps legacy rows discoverable during migration.\n */\nexport function getAgentTypeAliases(name: string): string[] {\n  return Array.from(\n    new Set([getAgentTypeName(name), getAgentClassName(name)].filter(Boolean)),\n  );\n}\n","/**\n * AgentConfig - Persistent configuration storage for agents\n *\n * This module provides database-backed configuration for agents,\n * enabling consuming apps to persist agent settings.\n *\n * @module\n */\n\nimport {\n  field,\n  type SmrtClassOptions,\n  SmrtCollection,\n  SmrtObject,\n  smrt,\n} from '@happyvertical/smrt-core';\nimport { TenantScoped, tenantId } from '@happyvertical/smrt-tenancy';\nimport { getAgentTypeName } from './identity.js';\n\n/**\n * AgentConfig stores agent configuration in the database\n *\n * Each config record maps to a UI slot for an agent instance:\n * - agentId: The agent instance's ID\n * - agentClass: The canonical agent type (qualified name when available)\n * - slotId: The configuration slot (e.g., 'sources', 'settings')\n * - configData: JSON object containing the configuration\n *\n * @example\n * ```typescript\n * // Save config for an agent slot\n * const config = new AgentConfig({\n *   agentId: agent.id,\n *   agentClass: 'Praeco',\n *   slotId: 'sources',\n *   configData: { scrapers: ['civicweb', 'govstack'] },\n *   db: options.db\n * });\n * await config.initialize();\n * await config.save();\n * ```\n */\n@TenantScoped({ mode: 'optional' })\n@smrt({\n  tableName: 'agent_configs',\n  api: { include: ['list', 'get', 'create', 'update', 'delete'] },\n  mcp: { include: ['list', 'get'] },\n  cli: true,\n})\nexport class AgentConfig extends SmrtObject {\n  /**\n   * Tenant ID for multi-tenant isolation\n   * Nullable to support both tenant-scoped and global agent configs\n   */\n  @tenantId({ nullable: true })\n  tenantId: string | null = null;\n\n  /**\n   * ID of the agent instance this config belongs to\n   */\n  @field({ type: 'text' })\n  agentId: string = '';\n\n  /**\n   * Canonical agent type for this config (qualified name when available)\n   */\n  @field({ type: 'text' })\n  agentClass: string = '';\n\n  /**\n   * UI slot ID (e.g., 'sources', 'settings', 'reports')\n   */\n  @field({ type: 'text' })\n  slotId: string = '';\n\n  /**\n   * Configuration data stored as JSON\n   *\n   * Sensitive (#1540): agent config blobs routinely carry API keys/credentials,\n   * so this is excluded from generated API/MCP responses and rejected as a\n   * `where` filter key.\n   */\n  @field({ type: 'json', sensitive: true })\n  configData: Record<string, any> = {};\n\n  /**\n   * Schema version for future migrations\n   */\n  @field({ type: 'integer' })\n  schemaVersion: number = 1;\n\n  /**\n   * Load all configs for a specific agent\n   *\n   * @param agentId - Agent instance ID\n   * @param options - Database options\n   * @returns Map of slotId → configData\n   */\n  static async forAgent(\n    agentId: string,\n    options: SmrtClassOptions,\n  ): Promise<Map<string, any>> {\n    const configsByAgent = await AgentConfig.forAgents([agentId], options);\n    return configsByAgent.get(agentId) ?? new Map();\n  }\n\n  /**\n   * Load configs for multiple agents in a single query.\n   *\n   * @param agentIds - Agent instance IDs\n   * @param options - Database options\n   * @returns Map of agentId -> (slotId -> configData)\n   */\n  static async forAgents(\n    agentIds: string[],\n    options: SmrtClassOptions,\n  ): Promise<Map<string, Map<string, any>>> {\n    const configsByAgent = new Map<string, Map<string, any>>();\n    if (agentIds.length === 0) {\n      return configsByAgent;\n    }\n\n    const collection = await AgentConfigCollection.create(options);\n    const configs = await collection.list({\n      where: { 'agentId in': agentIds },\n    });\n\n    for (const config of configs) {\n      if (!configsByAgent.has(config.agentId)) {\n        configsByAgent.set(config.agentId, new Map());\n      }\n      configsByAgent.get(config.agentId)?.set(config.slotId, config.configData);\n    }\n\n    return configsByAgent;\n  }\n\n  /**\n   * Load config for a specific agent and slot\n   *\n   * @param agentId - Agent instance ID\n   * @param slotId - UI slot ID\n   * @param options - Database options\n   * @returns Config data or undefined if not found\n   */\n  static async forSlot(\n    agentId: string,\n    slotId: string,\n    options: SmrtClassOptions,\n  ): Promise<any | undefined> {\n    const collection = await AgentConfigCollection.create(options);\n    const configs = await collection.list({\n      where: { agentId, slotId },\n      limit: 1,\n    });\n    return configs[0]?.configData;\n  }\n\n  /**\n   * Save or update config for an agent slot\n   *\n   * @param data - Config data including agentId, agentClass, slotId, configData\n   * @param options - Database options\n   * @returns Saved AgentConfig instance\n   */\n  static async saveSlot(\n    data: {\n      agentId: string;\n      agentClass: string;\n      slotId: string;\n      configData: Record<string, any>;\n    },\n    options: SmrtClassOptions,\n  ): Promise<AgentConfig> {\n    const normalizedAgentClass = getAgentTypeName(data.agentClass);\n    const collection = await AgentConfigCollection.create(options);\n\n    // Check for existing config using list with where clause\n    const existingConfigs = await collection.list({\n      where: { agentId: data.agentId, slotId: data.slotId },\n      limit: 1,\n    });\n\n    if (existingConfigs.length > 0) {\n      // Update existing\n      const existing = existingConfigs[0];\n      existing.configData = data.configData;\n      existing.agentClass = normalizedAgentClass;\n      await existing.save();\n      return existing;\n    }\n\n    // Create new\n    const config = await collection.create({\n      agentId: data.agentId,\n      agentClass: normalizedAgentClass,\n      slotId: data.slotId,\n      configData: data.configData,\n      slug: `${data.agentId}-${data.slotId}`,\n    });\n    await config.save();\n    return config;\n  }\n}\n\n/**\n * Collection for AgentConfig objects\n */\nexport class AgentConfigCollection extends SmrtCollection<AgentConfig> {\n  static readonly _itemClass = AgentConfig;\n\n  /**\n   * Find all configs for a specific tenant\n   * @param tenantId - Tenant ID to filter by\n   * @returns Array of AgentConfig objects for the tenant\n   */\n  async findByTenant(tenantId: string): Promise<AgentConfig[]> {\n    return this.list({ where: { tenantId } });\n  }\n\n  /**\n   * Find all global configs (not associated with any tenant)\n   * @returns Array of global AgentConfig objects\n   */\n  async findGlobal(): Promise<AgentConfig[]> {\n    return this.list({ where: { tenantId: null } });\n  }\n\n  /**\n   * Find configs for a tenant including global configs\n   * @param tenantId - Tenant ID to include\n   * @returns Array of AgentConfig objects for the tenant and global configs\n   */\n  async findWithGlobals(tenantId: string): Promise<AgentConfig[]> {\n    return this.query(\n      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,\n      [tenantId],\n    );\n  }\n}\n"],"names":["tenantId"],"mappings":"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"}

package/dist/chunks/manifest-utils-DLXfTOq0.js

@@ -0,0 +1,69 @@
+import { readFileSync, existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { AgentUIRegistry } from "../ui.js";
+function extractAgentManifest(manifest, agentClass) {
+  for (const obj of Object.values(manifest.objects)) {
+    if (obj.className === agentClass && obj.agent) {
+      return obj.agent;
+    }
+  }
+  return null;
+}
+function loadManifestsFromPackages(packages, projectRoot) {
+  const result = /* @__PURE__ */ new Map();
+  const localRequire = createRequire(resolve(projectRoot, "package.json"));
+  for (const pkg of packages) {
+    try {
+      const manifestPath = localRequire.resolve(`${pkg}/manifest`);
+      const manifestContent = readFileSync(manifestPath, "utf-8");
+      const manifest = JSON.parse(manifestContent);
+      for (const obj of Object.values(manifest.objects)) {
+        if (obj.agent) {
+          const agentClass = obj.className;
+          AgentUIRegistry.registerManifest(agentClass, obj.agent);
+          result.set(agentClass, obj.agent);
+          break;
+        }
+      }
+    } catch {
+      console.warn(
+        `[smrt-agents/server] Could not load manifest for ${pkg} — skipping`
+      );
+    }
+  }
+  return result;
+}
+function extractAgentPackagesFromConfig(configPath) {
+  const configContent = readFileSync(configPath, "utf-8");
+  const agentMatches = configContent.match(/agents\s*:\s*\[([^\]]*)\]/s);
+  if (!agentMatches) return [];
+  const agentsBlock = agentMatches[1];
+  const withoutComments = agentsBlock.replace(/\/\/.*$/gm, "");
+  return [...withoutComments.matchAll(/['"]([^'"]+)['"]/g)].map((m) => m[1]);
+}
+function loadManifestsFromConfig(configPath, projectRoot) {
+  const root = projectRoot || process.cwd();
+  const resolvedConfigPath = configPath || resolve(root, "smrt.config.js");
+  if (!existsSync(resolvedConfigPath)) {
+    console.warn(
+      `[smrt-agents/server] Config file not found: ${resolvedConfigPath}`
+    );
+    return /* @__PURE__ */ new Map();
+  }
+  const packages = extractAgentPackagesFromConfig(resolvedConfigPath);
+  if (packages.length === 0) {
+    console.warn(
+      `[smrt-agents/server] No agents found in config: ${resolvedConfigPath}`
+    );
+    return /* @__PURE__ */ new Map();
+  }
+  return loadManifestsFromPackages(packages, root);
+}
+export {
+  extractAgentManifest as a,
+  loadManifestsFromPackages as b,
+  extractAgentPackagesFromConfig as e,
+  loadManifestsFromConfig as l
+};
+//# sourceMappingURL=manifest-utils-DLXfTOq0.js.map

package/dist/chunks/manifest-utils-DLXfTOq0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-utils-DLXfTOq0.js","sources":["../../src/server/manifest-utils.ts"],"sourcesContent":["/**\n * Server-side manifest utilities for SMRT agents\n *\n * Provides functions to extract and register agent manifests on the server,\n * where the Vite virtual module (`virtual:smrt-agent-registrations`) doesn't run.\n *\n * @module @happyvertical/smrt-agents/server\n */\n\nimport { existsSync, readFileSync } from 'node:fs';\nimport { createRequire } from 'node:module';\nimport { resolve } from 'node:path';\nimport { type AgentManifestInfo, AgentUIRegistry } from '../ui.js';\n\n/**\n * Shape of a package manifest's `objects` entry\n */\ninterface ManifestObject {\n  className: string;\n  agent?: AgentManifestInfo;\n  [key: string]: unknown;\n}\n\n/**\n * Shape of a package manifest JSON file\n */\nexport interface PackageManifest {\n  objects: Record<string, ManifestObject>;\n  [key: string]: unknown;\n}\n\n/**\n * Extract the AgentManifestInfo from a package manifest by class name.\n *\n * Iterates `manifest.objects` looking for the entry whose `className` matches\n * and has an `agent` metadata block.\n *\n * @param manifest - Parsed manifest JSON from a package\n * @param agentClass - Agent class name to search for (e.g., 'Praeco')\n * @returns The agent manifest info, or null if not found\n */\nexport function extractAgentManifest(\n  manifest: PackageManifest,\n  agentClass: string,\n): AgentManifestInfo | null {\n  for (const obj of Object.values(manifest.objects)) {\n    if (obj.className === agentClass && obj.agent) {\n      return obj.agent;\n    }\n  }\n  return null;\n}\n\n/**\n * Load and register agent manifests from a list of package names.\n *\n * For each package, resolves its `<package>/manifest` export via `createRequire`,\n * reads the manifest JSON, extracts the agent class and metadata, and registers\n * with `AgentUIRegistry`.\n *\n * @param packages - Array of package names (e.g., ['@happyvertical/praeco'])\n * @param projectRoot - Absolute path to the project root (for require resolution)\n * @returns Map of agentClass -> AgentManifestInfo for successfully loaded agents\n */\nexport function loadManifestsFromPackages(\n  packages: string[],\n  projectRoot: string,\n): Map<string, AgentManifestInfo> {\n  const result = new Map<string, AgentManifestInfo>();\n  const localRequire = createRequire(resolve(projectRoot, 'package.json'));\n\n  for (const pkg of packages) {\n    try {\n      const manifestPath = localRequire.resolve(`${pkg}/manifest`);\n      const manifestContent = readFileSync(manifestPath, 'utf-8');\n      const manifest: PackageManifest = JSON.parse(manifestContent);\n\n      // Find the agent object (one with agent metadata)\n      for (const obj of Object.values(manifest.objects)) {\n        if (obj.agent) {\n          const agentClass = obj.className;\n          AgentUIRegistry.registerManifest(agentClass, obj.agent);\n          result.set(agentClass, obj.agent);\n          break;\n        }\n      }\n    } catch {\n      console.warn(\n        `[smrt-agents/server] Could not load manifest for ${pkg} — skipping`,\n      );\n    }\n  }\n\n  return result;\n}\n\n/**\n * Extract agent package names from a smrt.config.js file.\n *\n * Reads the file, finds the `agents: [...]` array, strips comments,\n * and extracts quoted package names. Same logic as the Vite plugin.\n *\n * @param configPath - Absolute path to smrt.config.js\n * @returns Array of package name strings\n */\nexport function extractAgentPackagesFromConfig(configPath: string): string[] {\n  const configContent = readFileSync(configPath, 'utf-8');\n  const agentMatches = configContent.match(/agents\\s*:\\s*\\[([^\\]]*)\\]/s);\n  if (!agentMatches) return [];\n\n  const agentsBlock = agentMatches[1];\n  const withoutComments = agentsBlock.replace(/\\/\\/.*$/gm, '');\n  return [...withoutComments.matchAll(/['\"]([^'\"]+)['\"]/g)].map((m) => m[1]);\n}\n\n/**\n * Load and register agent manifests by reading smrt.config.js.\n *\n * One-call setup: reads the config file to discover agent packages,\n * then loads and registers manifests for each. Idempotent — safe to\n * call from multiple server load functions.\n *\n * @param configPath - Path to smrt.config.js (default: `<projectRoot>/smrt.config.js`)\n * @param projectRoot - Project root for require resolution (default: `process.cwd()`)\n * @returns Map of agentClass -> AgentManifestInfo\n */\nexport function loadManifestsFromConfig(\n  configPath?: string,\n  projectRoot?: string,\n): Map<string, AgentManifestInfo> {\n  const root = projectRoot || process.cwd();\n  const resolvedConfigPath = configPath || resolve(root, 'smrt.config.js');\n\n  if (!existsSync(resolvedConfigPath)) {\n    console.warn(\n      `[smrt-agents/server] Config file not found: ${resolvedConfigPath}`,\n    );\n    return new Map();\n  }\n\n  const packages = extractAgentPackagesFromConfig(resolvedConfigPath);\n  if (packages.length === 0) {\n    console.warn(\n      `[smrt-agents/server] No agents found in config: ${resolvedConfigPath}`,\n    );\n    return new Map();\n  }\n\n  return loadManifestsFromPackages(packages, root);\n}\n"],"names":[],"mappings":";;;;AAyCO,SAAS,qBACd,UACA,YAC0B;AAC1B,aAAW,OAAO,OAAO,OAAO,SAAS,OAAO,GAAG;AACjD,QAAI,IAAI,cAAc,cAAc,IAAI,OAAO;AAC7C,aAAO,IAAI;AAAA,IACb;AAAA,EACF;AACA,SAAO;AACT;AAaO,SAAS,0BACd,UACA,aACgC;AAChC,QAAM,6BAAa,IAAA;AACnB,QAAM,eAAe,cAAc,QAAQ,aAAa,cAAc,CAAC;AAEvE,aAAW,OAAO,UAAU;AAC1B,QAAI;AACF,YAAM,eAAe,aAAa,QAAQ,GAAG,GAAG,WAAW;AAC3D,YAAM,kBAAkB,aAAa,cAAc,OAAO;AAC1D,YAAM,WAA4B,KAAK,MAAM,eAAe;AAG5D,iBAAW,OAAO,OAAO,OAAO,SAAS,OAAO,GAAG;AACjD,YAAI,IAAI,OAAO;AACb,gBAAM,aAAa,IAAI;AACvB,0BAAgB,iBAAiB,YAAY,IAAI,KAAK;AACtD,iBAAO,IAAI,YAAY,IAAI,KAAK;AAChC;AAAA,QACF;AAAA,MACF;AAAA,IACF,QAAQ;AACN,cAAQ;AAAA,QACN,oDAAoD,GAAG;AAAA,MAAA;AAAA,IAE3D;AAAA,EACF;AAEA,SAAO;AACT;AAWO,SAAS,+BAA+B,YAA8B;AAC3E,QAAM,gBAAgB,aAAa,YAAY,OAAO;AACtD,QAAM,eAAe,cAAc,MAAM,4BAA4B;AACrE,MAAI,CAAC,aAAc,QAAO,CAAA;AAE1B,QAAM,cAAc,aAAa,CAAC;AAClC,QAAM,kBAAkB,YAAY,QAAQ,aAAa,EAAE;AAC3D,SAAO,CAAC,GAAG,gBAAgB,SAAS,mBAAmB,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AAC3E;AAaO,SAAS,wBACd,YACA,aACgC;AAChC,QAAM,OAAO,eAAe,QAAQ,IAAA;AACpC,QAAM,qBAAqB,cAAc,QAAQ,MAAM,gBAAgB;AAEvE,MAAI,CAAC,WAAW,kBAAkB,GAAG;AACnC,YAAQ;AAAA,MACN,+CAA+C,kBAAkB;AAAA,IAAA;AAEnE,+BAAW,IAAA;AAAA,EACb;AAEA,QAAM,WAAW,+BAA+B,kBAAkB;AAClE,MAAI,SAAS,WAAW,GAAG;AACzB,YAAQ;AAAA,MACN,mDAAmD,kBAAkB;AAAA,IAAA;AAEvE,+BAAW,IAAA;AAAA,EACb;AAEA,SAAO,0BAA0B,UAAU,IAAI;AACjD;"}

package/dist/config.d.ts

@@ -0,0 +1,117 @@
+import { SmrtClassOptions, SmrtCollection, SmrtObject } from '@happyvertical/smrt-core';
+/**
+ * AgentConfig stores agent configuration in the database
+ *
+ * Each config record maps to a UI slot for an agent instance:
+ * - agentId: The agent instance's ID
+ * - agentClass: The canonical agent type (qualified name when available)
+ * - slotId: The configuration slot (e.g., 'sources', 'settings')
+ * - configData: JSON object containing the configuration
+ *
+ * @example
+ * ```typescript
+ * // Save config for an agent slot
+ * const config = new AgentConfig({
+ *   agentId: agent.id,
+ *   agentClass: 'Praeco',
+ *   slotId: 'sources',
+ *   configData: { scrapers: ['civicweb', 'govstack'] },
+ *   db: options.db
+ * });
+ * await config.initialize();
+ * await config.save();
+ * ```
+ */
+export declare class AgentConfig extends SmrtObject {
+    /**
+     * Tenant ID for multi-tenant isolation
+     * Nullable to support both tenant-scoped and global agent configs
+     */
+    tenantId: string | null;
+    /**
+     * ID of the agent instance this config belongs to
+     */
+    agentId: string;
+    /**
+     * Canonical agent type for this config (qualified name when available)
+     */
+    agentClass: string;
+    /**
+     * UI slot ID (e.g., 'sources', 'settings', 'reports')
+     */
+    slotId: string;
+    /**
+     * Configuration data stored as JSON
+     *
+     * Sensitive (#1540): agent config blobs routinely carry API keys/credentials,
+     * so this is excluded from generated API/MCP responses and rejected as a
+     * `where` filter key.
+     */
+    configData: Record<string, any>;
+    /**
+     * Schema version for future migrations
+     */
+    schemaVersion: number;
+    /**
+     * Load all configs for a specific agent
+     *
+     * @param agentId - Agent instance ID
+     * @param options - Database options
+     * @returns Map of slotId → configData
+     */
+    static forAgent(agentId: string, options: SmrtClassOptions): Promise<Map<string, any>>;
+    /**
+     * Load configs for multiple agents in a single query.
+     *
+     * @param agentIds - Agent instance IDs
+     * @param options - Database options
+     * @returns Map of agentId -> (slotId -> configData)
+     */
+    static forAgents(agentIds: string[], options: SmrtClassOptions): Promise<Map<string, Map<string, any>>>;
+    /**
+     * Load config for a specific agent and slot
+     *
+     * @param agentId - Agent instance ID
+     * @param slotId - UI slot ID
+     * @param options - Database options
+     * @returns Config data or undefined if not found
+     */
+    static forSlot(agentId: string, slotId: string, options: SmrtClassOptions): Promise<any | undefined>;
+    /**
+     * Save or update config for an agent slot
+     *
+     * @param data - Config data including agentId, agentClass, slotId, configData
+     * @param options - Database options
+     * @returns Saved AgentConfig instance
+     */
+    static saveSlot(data: {
+        agentId: string;
+        agentClass: string;
+        slotId: string;
+        configData: Record<string, any>;
+    }, options: SmrtClassOptions): Promise<AgentConfig>;
+}
+/**
+ * Collection for AgentConfig objects
+ */
+export declare class AgentConfigCollection extends SmrtCollection<AgentConfig> {
+    static readonly _itemClass: typeof AgentConfig;
+    /**
+     * Find all configs for a specific tenant
+     * @param tenantId - Tenant ID to filter by
+     * @returns Array of AgentConfig objects for the tenant
+     */
+    findByTenant(tenantId: string): Promise<AgentConfig[]>;
+    /**
+     * Find all global configs (not associated with any tenant)
+     * @returns Array of global AgentConfig objects
+     */
+    findGlobal(): Promise<AgentConfig[]>;
+    /**
+     * Find configs for a tenant including global configs
+     * @param tenantId - Tenant ID to include
+     * @returns Array of AgentConfig objects for the tenant and global configs
+     */
+    findWithGlobals(tenantId: string): Promise<AgentConfig[]>;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAEL,KAAK,gBAAgB,EACrB,cAAc,EACd,UAAU,EAEX,MAAM,0BAA0B,CAAC;AAIlC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAOa,WAAY,SAAQ,UAAU;IACzC;;;OAGG;IAEH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE/B;;OAEG;IAEH,OAAO,EAAE,MAAM,CAAM;IAErB;;OAEG;IAEH,UAAU,EAAE,MAAM,CAAM;IAExB;;OAEG;IAEH,MAAM,EAAE,MAAM,CAAM;IAEpB;;;;;;OAMG;IAEH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM;IAErC;;OAEG;IAEH,aAAa,EAAE,MAAM,CAAK;IAE1B;;;;;;OAMG;WACU,QAAQ,CACnB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAK5B;;;;;;OAMG;WACU,SAAS,CACpB,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAqBzC;;;;;;;OAOG;WACU,OAAO,CAClB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,GAAG,GAAG,SAAS,CAAC;IAS3B;;;;;;OAMG;WACU,QAAQ,CACnB,IAAI,EAAE;QACJ,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KACjC,EACD,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,WAAW,CAAC;CA8BxB;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,cAAc,CAAC,WAAW,CAAC;IACpE,MAAM,CAAC,QAAQ,CAAC,UAAU,qBAAe;IAEzC;;;;OAIG;IACG,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAI5D;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAI1C;;;;OAIG;IACG,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;CAMhE"}

package/dist/identity.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Return the canonical agent type identifier for storage and dispatch routing.
+ *
+ * Uses the registry's qualified name when available and falls back to the input
+ * name for dynamically defined or unregistered classes.
+ */
+export declare function getAgentTypeName(name: string): string;
+/**
+ * Return the human-readable class name for UI and logs.
+ */
+export declare function getAgentClassName(name: string): string;
+/**
+ * Return all meaningful aliases for an agent type.
+ *
+ * The qualified name is first so persistence lookups prefer canonical rows,
+ * while the simple class name keeps legacy rows discoverable during migration.
+ */
+export declare function getAgentTypeAliases(name: string): string[];
+//# sourceMappingURL=identity.d.ts.map

package/dist/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAI1D"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export type { ConfigResolver, LazyConfigSentinel, ResolveLazyConfigOptions, } from '@happyvertical/smrt-core';
+export { getClassConfigResolvers, getConfigResolver, isLazyConfigSentinel, listConfigResolvers, registerConfigResolver, resetConfigResolvers, resolveLazyConfig, unregisterConfigResolver, } from '@happyvertical/smrt-core';
+export { Agent, type AgentOptions } from './agent.js';
+export { type AgentAIOptions, type AgentAISecretFallback, resolveAgentAIOptions, } from './ai-config.js';
+export { AgentConfig, AgentConfigCollection } from './config.js';
+export type { AgentWithInterestsOptions, AsyncQualifierFn, InterestFilter, InterestHandlerFn, InterestOptions, InterestResult, ObjectFilter, ObjectInterestConfig, QueryFn, } from './interests.js';
+export { mergeFilters, normalizeSort } from './interests.js';
+export { AgentSchedule, AgentScheduleCollection, type ScheduleStatus, } from './schedule.js';
+export type { SummaryArticleImage, SummaryArticleOptions, SummaryArticleResult, } from './summary-article.js';
+export { type ResolvedAgentAvailability, TenantAgent, TenantAgentCollection, type TenantAgentStatus, } from './tenant-agent.js';
+export type { AgentStatusType } from './types.js';
+export { type AdminPanelBaseProps, type AgentAdminExport, type AgentAdminNavItem, type AgentAdminRootProps, type AgentAdminRoute, type AgentManifestInfo, type AgentRouteLoadContext, type AgentRouteLoadFn, type AgentUIComponentRegistry, AgentUIRegistry, type AgentUISlot, type AgentUISlots, type ComponentType, createUIRegistry, } from './ui.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAKH,OAAO,wBAAwB,CAAC;AAIhC,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACjE,YAAY,EACV,yBAAyB,EACzB,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,OAAO,GACR,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,KAAK,cAAc,GACpB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,yBAAyB,EAC9B,WAAW,EACX,qBAAqB,EACrB,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,gBAAgB,GACjB,MAAM,SAAS,CAAC"}