@happyvertical/smrt-agents 0.30.0

package/dist/index.js

@@ -0,0 +1,1477 @@
+import { ObjectRegistry, smrt, SmrtObject, createDispatchBus, resolveDispatchTenantScope, field, SmrtCollection } from "@happyvertical/smrt-core";
+import { getClassConfigResolvers, getConfigResolver, isLazyConfigSentinel, listConfigResolvers, registerConfigResolver, resetConfigResolvers, resolveLazyConfig, unregisterConfigResolver } from "@happyvertical/smrt-core";
+import { createLogger } from "@happyvertical/logger";
+import { sanitizeConfig } from "@happyvertical/smrt-config";
+import { getCurrentTenant, withTenant, tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+import { SecretService } from "@happyvertical/smrt-secrets";
+import { TenantCollection } from "@happyvertical/smrt-users";
+import { g as getAgentTypeName, a as getAgentClassName, A as AgentConfig, b as getAgentTypeAliases } from "./chunks/config-BYbOxt24.js";
+import { c } from "./chunks/config-BYbOxt24.js";
+import { AgentUIRegistry, createUIRegistry } from "./ui.js";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+const DEFAULT_SECRET_NAMES = {
+  anthropic: "ANTHROPIC_API_KEY",
+  gemini: "GEMINI_API_KEY",
+  openai: "OPENAI_API_KEY"
+};
+const DEFAULT_SECRET_FALLBACK = "ancestors";
+const secretServiceCache = /* @__PURE__ */ new WeakMap();
+const tenantCollectionCache = /* @__PURE__ */ new WeakMap();
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function normalizeSecretFallback(value) {
+  return value === "none" ? "none" : DEFAULT_SECRET_FALLBACK;
+}
+function getDefaultSecretName(aiConfig) {
+  const provider = asNonEmptyString(aiConfig.type)?.toLowerCase();
+  if (!provider) {
+    return void 0;
+  }
+  return DEFAULT_SECRET_NAMES[provider];
+}
+function stripAgentAISecretFields(aiConfig) {
+  const {
+    apiKeySecretName: _apiKeySecretName,
+    apiKeySecretFallback: _apiKeySecretFallback,
+    ...rest
+  } = aiConfig;
+  return rest;
+}
+async function getSecretService(db) {
+  const existing = secretServiceCache.get(db);
+  if (existing) {
+    return await existing;
+  }
+  const created = SecretService.create({ db });
+  secretServiceCache.set(db, created);
+  return await created;
+}
+async function getTenantCollection(db) {
+  const existing = tenantCollectionCache.get(db);
+  if (existing) {
+    return await existing;
+  }
+  const created = TenantCollection.create({ db });
+  tenantCollectionCache.set(db, created);
+  return await created;
+}
+async function getTenantSearchOrder(db, tenantId2, fallback) {
+  const tenantIds = [tenantId2];
+  if (fallback !== "ancestors") {
+    return tenantIds;
+  }
+  const tenants = await getTenantCollection(db);
+  const ancestors = await tenants.getAncestors(tenantId2);
+  for (const tenant of ancestors) {
+    if (tenant.id) {
+      tenantIds.push(tenant.id);
+    }
+  }
+  return tenantIds;
+}
+async function resolveSecretValue(service, tenantIds, secretName) {
+  for (const tenantId2 of tenantIds) {
+    const value = await withTenant({ tenantId: tenantId2 }, async () => {
+      try {
+        return (await service.retrieve(secretName)).value;
+      } catch (error) {
+        if (isMissingSecretError(error, secretName)) {
+          return void 0;
+        }
+        throw error;
+      }
+    });
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function isMissingSecretError(error, secretName) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message === `Secret '${secretName}' not found` || error.message === "Secret not found";
+}
+async function resolveAgentAIOptions(input) {
+  const { aiConfig, db } = input;
+  if (!aiConfig) {
+    return void 0;
+  }
+  const normalized = { ...aiConfig };
+  if (asNonEmptyString(normalized.apiKey)) {
+    return stripAgentAISecretFields(normalized);
+  }
+  const secretName = asNonEmptyString(normalized.apiKeySecretName) ?? getDefaultSecretName(normalized);
+  if (!secretName || !db) {
+    return stripAgentAISecretFields(normalized);
+  }
+  const tenantId2 = asNonEmptyString(input.tenantId) ?? asNonEmptyString(getCurrentTenant()?.tenantId);
+  if (!tenantId2) {
+    return stripAgentAISecretFields(normalized);
+  }
+  const fallback = normalizeSecretFallback(normalized.apiKeySecretFallback);
+  const tenantIds = await getTenantSearchOrder(db, tenantId2, fallback);
+  const service = await getSecretService(db);
+  const apiKey = await resolveSecretValue(service, tenantIds, secretName);
+  if (!apiKey) {
+    return stripAgentAISecretFields(normalized);
+  }
+  return {
+    ...stripAgentAISecretFields(normalized),
+    apiKey
+  };
+}
+function mergeFilters(globalFilter, objectFilter) {
+  if (!globalFilter && !objectFilter) return {};
+  if (!globalFilter) return { ...objectFilter };
+  if (!objectFilter) return { ...globalFilter };
+  return { ...globalFilter, ...objectFilter };
+}
+function normalizeSort(sort) {
+  if (!sort) return [];
+  return Array.isArray(sort) ? sort : [sort];
+}
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(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$2(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+let Agent = class extends SmrtObject {
+  tenantId = null;
+  /**
+   * Current agent status
+   */
+  status = "idle";
+  /**
+   * Structured logger instance
+   * Created with agent's class name as context
+   */
+  logger;
+  /**
+   * Signal handlers for graceful shutdown
+   */
+  signalHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Cached DispatchBus instance for inter-agent communication
+   */
+  _dispatch = null;
+  /**
+   * Creates a new Agent instance
+   *
+   * @param options - Configuration options including identifiers and metadata
+   */
+  constructor(options = {}) {
+    super(options);
+    this.logger = createLogger(options.silent ? false : { level: "info" });
+  }
+  /**
+   * Interest configuration for this agent
+   * Lazily accessed from options on first interesting() call
+   */
+  get interests() {
+    return this.options.interests;
+  }
+  /**
+   * Canonical agent type for persistence and dispatch routing.
+   */
+  getAgentTypeName() {
+    const metaType = this._meta_type;
+    if (typeof metaType === "string" && metaType.length > 0) {
+      return getAgentTypeName(metaType);
+    }
+    return getAgentTypeName(this.constructor.name);
+  }
+  /**
+   * Human-readable class name for logs and UI.
+   */
+  getAgentClassName() {
+    return getAgentClassName(this.getAgentTypeName());
+  }
+  /**
+   * Get UI slot definitions for this agent instance
+   *
+   * Returns the static uiSlots defined on the agent's class.
+   * Used by host applications to discover available admin panels.
+   *
+   * @example
+   * ```typescript
+   * const slots = agent.getUISlots();
+   * for (const [slotId, slot] of Object.entries(slots)) {
+   *   console.log(`${slot.label}: ${slot.description}`);
+   * }
+   * ```
+   */
+  getUISlots() {
+    return this.constructor.uiSlots;
+  }
+  // ============================================================================
+  // Configuration Management
+  // ============================================================================
+  /**
+   * Load all database-persisted configs for this agent
+   *
+   * Returns a Map of slotId → configData for all saved configurations.
+   * Use getMergedConfig() to get file + db merged config for a slot.
+   *
+   * @returns Map of slotId to config data
+   *
+   * @example
+   * ```typescript
+   * const configs = await agent.loadConfigs();
+   * const sources = configs.get('sources');
+   * ```
+   */
+  async loadConfigs() {
+    if (!this.id) {
+      throw new Error("Agent must be saved before loading configs");
+    }
+    return AgentConfig.forAgent(this.id, this.options);
+  }
+  /**
+   * Save config for a specific UI slot to the database
+   *
+   * Persists configuration data that can be modified by admin panels.
+   * Use this when the user saves changes in an admin UI.
+   *
+   * @param slotId - The UI slot ID (e.g., 'sources', 'settings')
+   * @param data - Configuration data to save
+   *
+   * @example
+   * ```typescript
+   * await agent.saveSlotConfig('sources', {
+   *   scrapers: ['civicweb', 'govstack'],
+   *   refreshInterval: 3600
+   * });
+   * ```
+   */
+  async saveSlotConfig(slotId, data) {
+    if (!this.id) {
+      throw new Error("Agent must be saved before saving slot config");
+    }
+    await AgentConfig.saveSlot(
+      {
+        agentId: this.id,
+        agentClass: this.getAgentTypeName(),
+        slotId,
+        configData: data
+      },
+      this.options
+    );
+  }
+  /**
+   * Get merged config for a slot (file-based + database)
+   *
+   * Priority order (highest to lowest):
+   * 1. Database-persisted config (from saveSlotConfig)
+   * 2. File-based config (from getModuleConfig)
+   * 3. Agent class defaults
+   *
+   * @param slotId - The UI slot ID
+   * @returns Merged configuration object
+   *
+   * @example
+   * ```typescript
+   * const sourcesConfig = await agent.getMergedConfig('sources');
+   * // Returns file config merged with any db overrides
+   * ```
+   */
+  async getMergedConfig(slotId) {
+    const fileConfig = this.config?.[slotId] ?? {};
+    if (!this.id) {
+      return fileConfig;
+    }
+    const dbConfig = await AgentConfig.forSlot(this.id, slotId, this.options);
+    return { ...fileConfig, ...dbConfig ?? {} };
+  }
+  /**
+   * Export all config for this agent (for static site generation)
+   *
+   * Merges file-based and database configs, then optionally sanitizes
+   * to remove secrets. Use this before building a static site.
+   *
+   * @param options - Export options
+   * @param options.includeSecrets - If true, includes API keys and secrets (default: false)
+   * @returns Merged configuration object
+   *
+   * @example
+   * ```typescript
+   * // Export for static build (secrets filtered)
+   * const config = await agent.exportConfig();
+   *
+   * // Export with secrets (for secure environments)
+   * const fullConfig = await agent.exportConfig({ includeSecrets: true });
+   * ```
+   */
+  async exportConfig(options) {
+    const dbConfigs = await this.loadConfigs();
+    const fileConfig = this.config ?? {};
+    const merged = { ...fileConfig };
+    for (const [slotId, data] of dbConfigs) {
+      merged[slotId] = { ...merged[slotId], ...data };
+    }
+    if (!options?.includeSecrets) {
+      return sanitizeConfig(merged);
+    }
+    return merged;
+  }
+  /**
+   * Get the DispatchBus for inter-agent communication
+   *
+   * Creates a DispatchBus lazily on first access. Requires database configuration.
+   *
+   * @example
+   * ```typescript
+   * // Emit a dispatch to other agents
+   * await this.dispatch.emit('campaign.completed', {
+   *   campaignId: '123',
+   *   revenue: 5000
+   * }, { source: this.constructor.name });
+   *
+   * // Subscribe to dispatches
+   * await this.dispatch.subscribe({
+   *   signalType: 'campaign.*',
+   *   subscriber: this.constructor.name
+   * });
+   * ```
+   *
+   * @throws Error if database is not configured
+   */
+  async getDispatch() {
+    if (!this._dispatch) {
+      if (!this._db) {
+        throw new Error(
+          `Agent ${this.constructor.name} requires database configuration for dispatch. Ensure the agent is initialized with a db option.`
+        );
+      }
+      this._dispatch = await createDispatchBus({
+        db: this._db
+      });
+    }
+    return this._dispatch;
+  }
+  /**
+   * Handle incoming dispatches
+   *
+   * Override this method to process dispatches targeted at this agent.
+   * Called when process() is invoked for this agent's subscriber name.
+   *
+   * @param payload - Dispatch payload data
+   * @param metadata - Dispatch metadata including type, source, and timing
+   *
+   * @example
+   * ```typescript
+   * async handleDispatch(payload: unknown, metadata: DispatchMetadata): Promise<void> {
+   *   if (metadata.type === 'campaign.completed') {
+   *     const data = payload as { campaignId: string; revenue: number };
+   *     await this.recordRevenue(data.campaignId, data.revenue);
+   *   }
+   * }
+   * ```
+   */
+  async handleDispatch(_payload, _metadata) {
+  }
+  /**
+   * Process pending dispatches for this agent
+   *
+   * Finds and processes all pending dispatches that match this agent's subscriptions.
+   * Uses handleDispatch() to process each dispatch.
+   *
+   * @returns Number of dispatches processed
+   *
+   * @example
+   * ```typescript
+   * // In your run() method
+   * const processed = await this.processDispatches();
+   * this.logger.info(`Processed ${processed} dispatches`);
+   * ```
+   */
+  async processDispatches() {
+    const dispatch = await this.getDispatch();
+    return dispatch.process(
+      this.getAgentTypeName(),
+      this.handleDispatch.bind(this)
+    );
+  }
+  /**
+   * Initialize the agent
+   * Sets status to 'initializing' and sets up signal handlers
+   *
+   * Override to perform setup after construction, but always call super.initialize()
+   *
+   * @example
+   * ```typescript
+   * async initialize(): Promise<void> {
+   *   await super.initialize();
+   *   // Custom initialization logic
+   * }
+   * ```
+   */
+  async initialize() {
+    await super.initialize();
+    this.status = "initializing";
+    this.logger.info("Agent initializing");
+    const fileAiConfig = typeof this.config === "object" && this.config !== null && "ai" in this.config && typeof this.config.ai === "object" && this.config.ai !== null ? this.config.ai : void 0;
+    const configuredAi = this.options.ai ?? fileAiConfig;
+    if (configuredAi && this._db) {
+      const resolvedAi = await resolveAgentAIOptions({
+        aiConfig: configuredAi,
+        db: this._db,
+        tenantId: getCurrentTenant()?.tenantId || (typeof this.tenantId === "string" ? this.tenantId : void 0)
+      });
+      if (resolvedAi) {
+        this.options.ai = resolvedAi;
+      }
+    }
+    if (this.options.manageProcessSignals) {
+      this.setupSignalHandlers();
+    }
+    if (this._db) {
+      const dispatch = await this.getDispatch();
+      await this.migrateLegacyDispatchSubscriptions(dispatch);
+      const subs = this.constructor.signalSubscriptions;
+      if (subs.length > 0) {
+        const subscriber = this.getAgentTypeName();
+        const existing = await dispatch.listSubscriptions(subscriber);
+        const existingTypes = new Set(existing.map((s) => s.signalType));
+        for (const signalType of subs) {
+          if (!existingTypes.has(signalType)) {
+            await dispatch.subscribe({
+              signalType,
+              subscriber
+            });
+          }
+        }
+      }
+    }
+    return this;
+  }
+  /**
+   * Set up signal handlers for graceful shutdown
+   * Handles SIGTERM and SIGINT for single-agent processes that explicitly opt in.
+   */
+  setupSignalHandlers() {
+    const signals = ["SIGTERM", "SIGINT"];
+    for (const signal of signals) {
+      const handler = () => {
+        this.logger.info(`Received ${signal}, shutting down gracefully`);
+        this.shutdown().then(() => {
+          process.exit(0);
+        }).catch((error) => {
+          this.logger.error("Error during shutdown", { error });
+          process.exit(1);
+        });
+      };
+      this.signalHandlers.set(signal, handler);
+      process.on(signal, handler);
+    }
+  }
+  /**
+   * Migrate legacy simple-name dispatch subscribers to the canonical agent type.
+   *
+   * Older releases used `this.constructor.name` directly for subscriber IDs.
+   * That collides across packages and leaves fan-out dispatches targeted at the
+   * wrong subscriber once qualified names are available.
+   */
+  async migrateLegacyDispatchSubscriptions(dispatch) {
+    if (!this._db) {
+      return;
+    }
+    const legacySubscriber = this.constructor.name;
+    const canonicalSubscriber = this.getAgentTypeName();
+    if (legacySubscriber === canonicalSubscriber) {
+      return;
+    }
+    const legacySubscriptions = await dispatch.listSubscriptions(legacySubscriber);
+    if (legacySubscriptions.length === 0) {
+      return;
+    }
+    const currentSubscriptions = await dispatch.listSubscriptions(canonicalSubscriber);
+    const currentSignalTypes = new Set(
+      currentSubscriptions.map((sub) => sub.signalType)
+    );
+    for (const subscription of legacySubscriptions) {
+      if (!currentSignalTypes.has(subscription.signalType)) {
+        await dispatch.subscribe({
+          signalType: subscription.signalType,
+          subscriber: canonicalSubscriber,
+          handler: subscription.handler,
+          delivery: subscription.delivery,
+          enabled: subscription.enabled
+        });
+      }
+      await dispatch.unsubscribe(subscription.signalType, legacySubscriber);
+    }
+    const [tenantClause, tenantParams] = buildDispatchTenantUpdatePredicate(
+      resolveDispatchTenantScope()
+    );
+    await this._db.query(
+      `UPDATE _smrt_dispatch
+       SET target_subscriber = CASE
+             WHEN target_subscriber = ? THEN ?
+             ELSE target_subscriber
+           END,
+           processed_by = CASE
+             WHEN processed_by = ? THEN ?
+             ELSE processed_by
+           END
+       WHERE (target_subscriber = ? OR processed_by = ?)${tenantClause}`,
+      legacySubscriber,
+      canonicalSubscriber,
+      legacySubscriber,
+      canonicalSubscriber,
+      legacySubscriber,
+      legacySubscriber,
+      ...tenantParams
+    );
+  }
+  /**
+   * Clean up signal handlers
+   */
+  cleanupSignalHandlers() {
+    for (const [signal, handler] of this.signalHandlers.entries()) {
+      process.removeListener(signal, handler);
+    }
+    this.signalHandlers.clear();
+  }
+  /**
+   * Validate configuration and dependencies
+   * Override to check agent-specific requirements
+   *
+   * @throws Error if validation fails
+   *
+   * @example
+   * ```typescript
+   * async validate(): Promise<void> {
+   *   if (!this.config.apiKey) {
+   *     throw new Error('API key is required');
+   *   }
+   * }
+   * ```
+   */
+  async validate() {
+    this.logger.info("Validating agent configuration");
+  }
+  /**
+   * Cleanup and shutdown
+   * Override to perform graceful shutdown
+   *
+   * Always call super.shutdown() to clean up signal handlers
+   *
+   * @example
+   * ```typescript
+   * async shutdown(): Promise<void> {
+   *   this.logger.info('Cleaning up resources');
+   *   await this.cleanup();
+   *   await super.shutdown();
+   * }
+   * ```
+   */
+  async shutdown() {
+    this.status = "shutdown";
+    this.logger.info("Agent shutting down");
+    this.cleanupSignalHandlers();
+  }
+  /**
+   * Execute agent with lifecycle management
+   *
+   * Runs the full lifecycle:
+   * 1. initialize() — seeds signal subscriptions if declared
+   * 2. validate()
+   * 3. processDispatches() — auto-processes pending dispatches if subscriptions exist
+   * 4. run()
+   *
+   * Note: handleDispatch() callbacks may fire before run() is entered.
+   *
+   * On error:
+   * 1. Sets status to 'error'
+   * 2. Logs error
+   * 3. Re-throws error
+   *
+   * @example
+   * ```typescript
+   * const agent = new MyAgent({ name: 'my-agent' });
+   *
+   * try {
+   *   await agent.execute();
+   *   console.log('Agent completed successfully');
+   * } catch (error) {
+   *   console.error('Agent failed:', error);
+   * }
+   * ```
+   */
+  async execute() {
+    try {
+      await this.initialize();
+      await this.validate();
+      this.status = "running";
+      if (this._db) {
+        const dispatch = await this.getDispatch();
+        const subs = await dispatch.listSubscriptions(this.getAgentTypeName());
+        if (subs.length > 0) {
+          const count = await this.processDispatches();
+          if (count > 0) {
+            this.logger.info(`Processed ${count} pending dispatches`);
+          }
+        }
+      }
+      await this.run();
+      this.status = "idle";
+      this.logger.info("Agent execution completed");
+    } catch (error) {
+      this.status = "error";
+      this.logger.error("Agent execution failed", { error });
+      throw error;
+    }
+  }
+  /**
+   * Query objects this agent is interested in
+   *
+   * Returns items from all configured object types, filtered and sorted
+   * according to interest configuration. If handlers are defined on filters,
+   * they are called for each matched item and the result is included.
+   *
+   * @returns Array of { type, data, name?, handled? } results
+   * @throws Error if no interests are configured
+   *
+   * @example
+   * ```typescript
+   * const items = await this.interesting();
+   * for (const { type, data, name, handled } of items) {
+   *   console.log(`Processing ${type} from "${name}": action=${handled?.action}`);
+   * }
+   * ```
+   */
+  async interesting() {
+    if (!this.interests) {
+      throw new Error(
+        `Agent ${this.constructor.name} has no interests configured. Set interests in constructor options to use interesting().`
+      );
+    }
+    if (!this.interests.objects || Object.keys(this.interests.objects).length === 0) {
+      this.logger.warn("Agent has empty interests.objects configuration");
+      return [];
+    }
+    const results = [];
+    for (const [className, config] of Object.entries(this.interests.objects)) {
+      try {
+        const items = await this.queryInterestingObjects(className, config);
+        results.push(...items);
+      } catch (error) {
+        this.logger.warn(`Failed to query ${className} for interests`, {
+          error
+        });
+      }
+    }
+    if (this.interests.qualify) {
+      const allItems = results.map((r) => r.data);
+      const qualified = await this.interests.qualify(allItems);
+      const qualifiedSet = new Set(qualified);
+      const filteredResults = results.filter((r) => qualifiedSet.has(r.data));
+      if (this.interests.sort) {
+        return this.sortResults(filteredResults, this.interests.sort);
+      }
+      return filteredResults;
+    }
+    if (this.interests.sort) {
+      return this.sortResults(results, this.interests.sort);
+    }
+    return results;
+  }
+  /**
+   * Query a single object type based on interest config
+   *
+   * Supports both single filter and array of filters.
+   * Each filter can use standard SDK filters OR custom query function.
+   * Returns InterestResult[] with handler results included.
+   */
+  async queryInterestingObjects(className, config) {
+    if (!ObjectRegistry.hasClass(className)) {
+      this.logger.warn(
+        `Object type "${className}" not found in ObjectRegistry. Skipping in interests query.`
+      );
+      return [];
+    }
+    const collection = await ObjectRegistry.getCollection(
+      className,
+      this.options
+    );
+    const filters = this.normalizeInterestConfig(config);
+    const allResults = [];
+    for (const filter of filters) {
+      const items = await this.queryInterestFilter(
+        className,
+        filter,
+        collection
+      );
+      for (const item of items) {
+        const result = {
+          type: className,
+          data: item,
+          name: filter.name
+        };
+        if (filter.handler) {
+          result.handled = await filter.handler(item, this);
+        }
+        allResults.push(result);
+      }
+    }
+    return allResults;
+  }
+  /**
+   * Normalize ObjectInterestConfig to array format
+   */
+  normalizeInterestConfig(config) {
+    return Array.isArray(config) ? config : [config];
+  }
+  /**
+   * Query a single interest filter
+   *
+   * Uses collection.query() for custom query functions,
+   * or collection.list() for standard SDK filters.
+   */
+  async queryInterestFilter(_className, filter, collection) {
+    if (filter.query) {
+      let [whereClause, params] = filter.query(collection.tableName);
+      await ObjectRegistry.ensureManifestLoaded(_className);
+      let currentClass = ObjectRegistry.getClass(_className);
+      while (currentClass?.extends) {
+        const parentName = currentClass.extends;
+        if (parentName === "SmrtObject" || parentName === "SmrtClass" || parentName === "SmrtCollection") {
+          break;
+        }
+        try {
+          await ObjectRegistry.ensureManifestLoaded(parentName);
+        } catch {
+        }
+        currentClass = ObjectRegistry.getClass(parentName);
+      }
+      ObjectRegistry.invalidateInheritanceCache(_className);
+      const tableStrategy = ObjectRegistry.getTableStrategy(_className);
+      if (tableStrategy === "sti") {
+        const stiBase = ObjectRegistry.getSTIBase(_className);
+        const classInfo = ObjectRegistry.getClass(_className);
+        const qualifiedClassName = classInfo?.qualifiedName ?? classInfo?.name ?? _className;
+        if (stiBase && stiBase !== qualifiedClassName && stiBase !== _className) {
+          const metaTypeValue = classInfo?.qualifiedName || _className;
+          whereClause = `_meta_type = ? AND (${whereClause})`;
+          params = [metaTypeValue, ...params];
+        }
+      }
+      let sql = `SELECT * FROM ${collection.tableName} WHERE ${whereClause}`;
+      if (filter.sort) {
+        const sorts = Array.isArray(filter.sort) ? filter.sort : [filter.sort];
+        sql += ` ORDER BY ${sorts.join(", ")}`;
+      }
+      if (filter.limit) {
+        sql += ` LIMIT ?`;
+        params.push(filter.limit);
+      }
+      let items2 = await collection.query(sql, params);
+      if (filter.qualify) {
+        items2 = await filter.qualify(items2);
+      }
+      return items2;
+    }
+    const mergedFilter = mergeFilters(this.interests?.filter, filter.filter);
+    const queryOptions = {};
+    if (Object.keys(mergedFilter).length > 0) {
+      queryOptions.where = mergedFilter;
+    }
+    if (filter.sort) {
+      queryOptions.orderBy = filter.sort;
+    }
+    if (filter.limit) {
+      queryOptions.limit = filter.limit;
+    }
+    let items = await collection.list(queryOptions);
+    if (filter.qualify) {
+      items = await filter.qualify(items);
+    }
+    return items;
+  }
+  /**
+   * Sort results by field(s) across all types
+   */
+  sortResults(results, sort) {
+    const sortFields = normalizeSort(sort);
+    if (sortFields.length === 0) return results;
+    return [...results].sort((a, b) => {
+      for (const sortField of sortFields) {
+        const [field2, direction = "ASC"] = sortField.trim().split(/\s+/);
+        const aValue = a.data[field2];
+        const bValue = b.data[field2];
+        let comparison = 0;
+        if (aValue < bValue) comparison = -1;
+        else if (aValue > bValue) comparison = 1;
+        if (comparison !== 0) {
+          return direction.toUpperCase() === "DESC" ? -comparison : comparison;
+        }
+      }
+      return 0;
+    });
+  }
+};
+__publicField(Agent, "uiSlots", {});
+__publicField(Agent, "adminRoutes", []);
+__publicField(Agent, "signalSubscriptions", []);
+__publicField(Agent, "configResolvers", {});
+__decorateClass$2([
+  tenantId({ nullable: true })
+], Agent.prototype, "tenantId", 2);
+Agent = __decorateClass$2([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    // Abstract class - no direct CLI/API/MCP exposure
+    // But must be registered for inheritance chain to work (issue #523)
+    cli: false,
+    api: false,
+    mcp: false,
+    // STI: All agents share 'agents' table for polymorphic queries
+    tableStrategy: "sti"
+  })
+], Agent);
+function buildDispatchTenantUpdatePredicate(scope) {
+  if (!scope.enforced) {
+    return ["", []];
+  }
+  if (scope.tenantId !== null) {
+    return [" AND (tenant_id = ? OR tenant_id IS NULL)", [scope.tenantId]];
+  }
+  return [" AND tenant_id IS NULL", []];
+}
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(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$1(target, key, result);
+  return result;
+};
+let AgentSchedule = class extends SmrtObject {
+  tenantId = null;
+  agentType = "";
+  agentId = null;
+  agentConfig = {};
+  cron = "";
+  timezone = "UTC";
+  enabled = true;
+  status = "active";
+  lastRun = null;
+  nextRun = null;
+  lastStatus = null;
+  lastError = null;
+  runCount = 0;
+  successCount = 0;
+  failureCount = 0;
+  maxConcurrent = 1;
+  runningCount = 0;
+  timeout = 36e5;
+  method = "run";
+  methodArgs = {};
+  /**
+   * Enable the schedule
+   */
+  async enable() {
+    this.enabled = true;
+    this.status = "active";
+    this.calculateNextRun();
+    await this.save();
+  }
+  /**
+   * Disable the schedule
+   */
+  async disable() {
+    this.enabled = false;
+    this.status = "disabled";
+    await this.save();
+  }
+  /**
+   * Pause the schedule temporarily
+   */
+  async pause() {
+    this.status = "paused";
+    await this.save();
+  }
+  /**
+   * Resume a paused schedule
+   */
+  async resume() {
+    if (this.enabled) {
+      this.status = "active";
+      this.calculateNextRun();
+    }
+    await this.save();
+  }
+  /**
+   * Record a successful run
+   */
+  async recordSuccess() {
+    this.lastRun = /* @__PURE__ */ new Date();
+    this.lastStatus = "success";
+    this.lastError = null;
+    this.runCount++;
+    this.successCount++;
+    this.runningCount = Math.max(0, this.runningCount - 1);
+    this.calculateNextRun();
+    await this.save();
+  }
+  /**
+   * Record a failed run
+   */
+  async recordFailure(error) {
+    this.lastRun = /* @__PURE__ */ new Date();
+    this.lastStatus = "failed";
+    this.lastError = error;
+    this.runCount++;
+    this.failureCount++;
+    this.runningCount = Math.max(0, this.runningCount - 1);
+    this.calculateNextRun();
+    await this.save();
+  }
+  /**
+   * Check if the schedule is due to run
+   */
+  isDue() {
+    if (!this.enabled || this.status !== "active") {
+      return false;
+    }
+    if (!this.nextRun) {
+      return false;
+    }
+    if (this.runningCount >= this.maxConcurrent) {
+      return false;
+    }
+    return /* @__PURE__ */ new Date() >= this.nextRun;
+  }
+  /**
+   * Calculate the next run time based on cron expression
+   */
+  calculateNextRun() {
+    if (!this.cron || !this.enabled) {
+      this.nextRun = null;
+      return;
+    }
+    try {
+      const next = getNextCronDate(this.cron, this.timezone);
+      this.nextRun = next;
+    } catch {
+      this.nextRun = null;
+      this.status = "error";
+      this.lastError = `Invalid cron expression: ${this.cron}`;
+    }
+  }
+  /**
+   * Get a human-readable description of the schedule
+   */
+  getDescription() {
+    const displayAgentType = getAgentClassName(this.agentType);
+    const agent = this.agentId ? `${displayAgentType}#${this.agentId}` : displayAgentType;
+    return `${agent}.${this.method}() @ ${this.cron}`;
+  }
+  /**
+   * Lifecycle hook - calculate next run on save
+   */
+  async beforeSave() {
+    if (this.agentType) {
+      this.agentType = getAgentTypeName(this.agentType);
+    }
+    if (!this.nextRun && this.enabled) {
+      this.calculateNextRun();
+    }
+  }
+};
+__decorateClass$1([
+  tenantId({ nullable: true })
+], AgentSchedule.prototype, "tenantId", 2);
+__decorateClass$1([
+  field({ type: "text" })
+], AgentSchedule.prototype, "agentType", 2);
+__decorateClass$1([
+  field({ type: "text", nullable: true })
+], AgentSchedule.prototype, "agentId", 2);
+__decorateClass$1([
+  field({ type: "json", sqlType: "TEXT", sensitive: true })
+], AgentSchedule.prototype, "agentConfig", 2);
+__decorateClass$1([
+  field({ type: "text" })
+], AgentSchedule.prototype, "cron", 2);
+__decorateClass$1([
+  field({ type: "text" })
+], AgentSchedule.prototype, "timezone", 2);
+__decorateClass$1([
+  field({ type: "boolean" })
+], AgentSchedule.prototype, "enabled", 2);
+__decorateClass$1([
+  field({ type: "text" })
+], AgentSchedule.prototype, "status", 2);
+__decorateClass$1([
+  field({ type: "datetime", nullable: true })
+], AgentSchedule.prototype, "lastRun", 2);
+__decorateClass$1([
+  field({ type: "datetime", nullable: true })
+], AgentSchedule.prototype, "nextRun", 2);
+__decorateClass$1([
+  field({ type: "text", nullable: true })
+], AgentSchedule.prototype, "lastStatus", 2);
+__decorateClass$1([
+  field({ type: "text", nullable: true })
+], AgentSchedule.prototype, "lastError", 2);
+__decorateClass$1([
+  field({ type: "integer" })
+], AgentSchedule.prototype, "runCount", 2);
+__decorateClass$1([
+  field({ type: "integer" })
+], AgentSchedule.prototype, "successCount", 2);
+__decorateClass$1([
+  field({ type: "integer" })
+], AgentSchedule.prototype, "failureCount", 2);
+__decorateClass$1([
+  field({ type: "integer" })
+], AgentSchedule.prototype, "maxConcurrent", 2);
+__decorateClass$1([
+  field({ type: "integer" })
+], AgentSchedule.prototype, "runningCount", 2);
+__decorateClass$1([
+  field({ type: "integer" })
+], AgentSchedule.prototype, "timeout", 2);
+__decorateClass$1([
+  field({ type: "text" })
+], AgentSchedule.prototype, "method", 2);
+__decorateClass$1([
+  field({ type: "json", sqlType: "TEXT" })
+], AgentSchedule.prototype, "methodArgs", 2);
+AgentSchedule = __decorateClass$1([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableName: "_smrt_agent_schedules",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    cli: {
+      include: ["list", "get", "create", "update", "delete", "enable", "disable"],
+      // enable/disable are operator commands invoked in-process via the CLI;
+      // they intentionally aren't exposed over HTTP.
+      skipApiCheck: true
+    },
+    mcp: { include: ["list", "get"] }
+  })
+], AgentSchedule);
+class AgentScheduleCollection extends SmrtCollection {
+  static _itemClass = AgentSchedule;
+  /**
+   * Find all schedules for a specific tenant
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of AgentSchedule objects for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global schedules (not associated with any tenant)
+   * @returns Array of global AgentSchedule objects
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find schedules for a tenant including global schedules
+   * @param tenantId - Tenant ID to include
+   * @returns Array of AgentSchedule objects for the tenant and global schedules
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+  /**
+   * List schedules by status
+   */
+  async listByStatus(status, options = {}) {
+    return this.list({
+      where: {
+        status: Array.isArray(status) ? status : [status]
+      },
+      orderBy: "next_run ASC",
+      limit: options.limit
+    });
+  }
+  /**
+   * List schedules that are due to run
+   */
+  async listDue(options = {}) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return this.query(
+      `SELECT * FROM _smrt_agent_schedules
+       WHERE enabled = 1
+       AND status = 'active'
+       AND next_run <= ?
+       AND running_count < max_concurrent
+       ORDER BY next_run ASC
+       LIMIT ?`,
+      [now, options.limit || 100]
+    );
+  }
+  /**
+   * List schedules for a specific agent type
+   */
+  async listByAgentType(agentType, options = {}) {
+    const aliases = getAgentTypeAliases(agentType);
+    const where = aliases.length > 1 ? { "agentType in": aliases } : { agentType: getAgentTypeName(agentType) };
+    if (!options.includeDisabled) {
+      where.enabled = true;
+    }
+    return this.list({
+      where,
+      orderBy: "next_run ASC",
+      limit: options.limit
+    });
+  }
+  /**
+   * Get schedule statistics
+   */
+  async stats() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = await this._db.query(
+      `SELECT
+        COUNT(*) as total,
+        SUM(CASE WHEN status = 'active' THEN 1 ELSE 0 END) as active,
+        SUM(CASE WHEN status = 'paused' THEN 1 ELSE 0 END) as paused,
+        SUM(CASE WHEN status = 'disabled' THEN 1 ELSE 0 END) as disabled,
+        SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as error,
+        SUM(CASE WHEN enabled = 1 AND status = 'active' AND next_run <= ? THEN 1 ELSE 0 END) as due_now
+       FROM _smrt_agent_schedules`,
+      [now]
+    );
+    const row = result.rows[0] || {};
+    return {
+      total: row.total ?? 0,
+      active: row.active ?? 0,
+      paused: row.paused ?? 0,
+      disabled: row.disabled ?? 0,
+      error: row.error ?? 0,
+      dueNow: row.due_now ?? 0
+    };
+  }
+}
+function getNextCronDate(cron, _timezone = "UTC") {
+  const parts = cron.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(
+      `Invalid cron expression: expected 5 fields, got ${parts.length}`
+    );
+  }
+  const [minuteExpr, hourExpr, dayExpr, monthExpr, dowExpr] = parts;
+  const now = /* @__PURE__ */ new Date();
+  const candidate = new Date(now);
+  candidate.setSeconds(0);
+  candidate.setMilliseconds(0);
+  candidate.setMinutes(candidate.getMinutes() + 1);
+  const maxIterations = 525600;
+  for (let i = 0; i < maxIterations; i++) {
+    if (matchesCronField(candidate.getMonth() + 1, monthExpr) && matchesCronField(candidate.getDate(), dayExpr) && matchesCronField(candidate.getDay(), dowExpr) && matchesCronField(candidate.getHours(), hourExpr) && matchesCronField(candidate.getMinutes(), minuteExpr)) {
+      return candidate;
+    }
+    candidate.setMinutes(candidate.getMinutes() + 1);
+  }
+  throw new Error(`Could not find next run date for cron: ${cron}`);
+}
+function matchesCronField(value, expr) {
+  if (expr === "*") {
+    return true;
+  }
+  if (expr.includes("/")) {
+    const [range, stepStr] = expr.split("/");
+    const step = parseInt(stepStr, 10);
+    if (range === "*") {
+      return value % step === 0;
+    }
+    if (range.includes("-")) {
+      const [startStr, endStr] = range.split("-");
+      const start = parseInt(startStr, 10);
+      const end = parseInt(endStr, 10);
+      if (value < start || value > end) return false;
+      return (value - start) % step === 0;
+    }
+  }
+  if (expr.includes("-")) {
+    const [startStr, endStr] = expr.split("-");
+    const start = parseInt(startStr, 10);
+    const end = parseInt(endStr, 10);
+    return value >= start && value <= end;
+  }
+  if (expr.includes(",")) {
+    const values = expr.split(",").map((v) => parseInt(v.trim(), 10));
+    return values.includes(value);
+  }
+  return value === parseInt(expr, 10);
+}
+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 TenantAgent = class extends SmrtObject {
+  tenantId = "";
+  agentClass = "";
+  status = "active";
+  permissions = null;
+  config = null;
+};
+__decorateClass([
+  tenantId()
+], TenantAgent.prototype, "tenantId", 2);
+__decorateClass([
+  field({ type: "text" })
+], TenantAgent.prototype, "agentClass", 2);
+__decorateClass([
+  field({ type: "text" })
+], TenantAgent.prototype, "status", 2);
+__decorateClass([
+  field({ type: "json", nullable: true })
+], TenantAgent.prototype, "permissions", 2);
+__decorateClass([
+  field({ type: "json", nullable: true, sensitive: true })
+], TenantAgent.prototype, "config", 2);
+TenantAgent = __decorateClass([
+  TenantScoped({ mode: "required" }),
+  smrt({
+    tableName: "tenant_agents",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    cli: { include: ["list", "get"] },
+    mcp: { include: ["list", "get"] },
+    conflictColumns: ["tenant_id", "agent_class"]
+  })
+], TenantAgent);
+class TenantAgentCollection extends SmrtCollection {
+  static _itemClass = TenantAgent;
+  /**
+   * Resolve agent availability for a tenant, walking up the hierarchy.
+   *
+   * Algorithm:
+   * 1. Load explicit entries for this tenant
+   * 2. Build result map from explicit entries (source = 'explicit')
+   * 3. Merge permissions: manifest defaults overridden by explicit permissions
+   * 4. Get tenant's ancestors via hierarchyPath (immediate parent → root)
+   * 5. For each ancestor, add inherited agents not already resolved
+   * 6. Return only agents that appear somewhere in the hierarchy
+   *
+   * @param tenantId - The tenant to resolve for
+   * @param getAncestorIds - Function that returns ancestor tenant IDs (parent → root order)
+   * @param manifests - Map of agent class name to AgentManifestInfo
+   */
+  async resolveForTenant(tenantId2, getAncestorIds, manifests) {
+    const result = /* @__PURE__ */ new Map();
+    const explicitEntries = await this.list({
+      where: { tenantId: tenantId2 }
+    });
+    for (const entry of explicitEntries) {
+      const agentType = await this.normalizeStoredAgentClass(entry);
+      const manifest = getManifestForAgent(manifests, agentType);
+      const mergedPermissions = mergePermissions(
+        manifest?.permissions,
+        entry.permissions
+      );
+      result.set(agentType, {
+        agentClass: getAgentClassName(agentType),
+        agentType,
+        status: entry.status,
+        source: "explicit",
+        sourceTenantId: tenantId2,
+        permissions: mergedPermissions,
+        manifest,
+        config: entry.config ?? void 0
+      });
+    }
+    const ancestorIds = await getAncestorIds(tenantId2);
+    for (const ancestorId of ancestorIds) {
+      const ancestorEntries = await this.list({
+        where: { tenantId: ancestorId }
+      });
+      for (const entry of ancestorEntries) {
+        const agentType = await this.normalizeStoredAgentClass(entry);
+        if (result.has(agentType)) continue;
+        const manifest = getManifestForAgent(manifests, agentType);
+        const mergedPermissions = mergePermissions(
+          manifest?.permissions,
+          entry.permissions
+        );
+        result.set(agentType, {
+          agentClass: getAgentClassName(agentType),
+          agentType,
+          status: entry.status,
+          source: "inherited",
+          sourceTenantId: ancestorId,
+          permissions: mergedPermissions,
+          manifest,
+          config: entry.config ?? void 0
+        });
+      }
+    }
+    return Array.from(result.values());
+  }
+  /**
+   * Enable an agent for a tenant (creates or updates binding)
+   */
+  async enableAgent(tenantId2, agentClass) {
+    const canonicalAgentClass = getAgentTypeName(agentClass);
+    const existing = await this.findByTenantAndClass(tenantId2, agentClass);
+    if (existing) {
+      existing.status = "active";
+      await existing.save();
+      return existing;
+    }
+    const entry = await this.create({
+      tenantId: tenantId2,
+      agentClass: canonicalAgentClass,
+      status: "active"
+    });
+    await entry.save();
+    return entry;
+  }
+  /**
+   * Disable an agent for a tenant
+   */
+  async disableAgent(tenantId2, agentClass) {
+    const canonicalAgentClass = getAgentTypeName(agentClass);
+    const existing = await this.findByTenantAndClass(tenantId2, agentClass);
+    if (existing) {
+      existing.status = "disabled";
+      await existing.save();
+      return existing;
+    }
+    const entry = await this.create({
+      tenantId: tenantId2,
+      agentClass: canonicalAgentClass,
+      status: "disabled"
+    });
+    await entry.save();
+    return entry;
+  }
+  /**
+   * Remove explicit override, falling back to inheritance
+   */
+  async clearOverride(tenantId2, agentClass) {
+    const existing = await this.findByTenantAndClass(tenantId2, agentClass);
+    if (existing) {
+      await existing.delete();
+    }
+  }
+  /**
+   * Set permission overrides for a tenant's agent binding
+   */
+  async setPermissions(tenantId2, agentClass, permissions) {
+    const canonicalAgentClass = getAgentTypeName(agentClass);
+    const existing = await this.findByTenantAndClass(tenantId2, agentClass);
+    if (existing) {
+      existing.permissions = permissions;
+      await existing.save();
+      return existing;
+    }
+    const entry = await this.create({
+      tenantId: tenantId2,
+      agentClass: canonicalAgentClass,
+      status: "active",
+      permissions
+    });
+    await entry.save();
+    return entry;
+  }
+  /**
+   * Find a tenant-agent binding by tenant and agent class
+   */
+  async findByTenantAndClass(tenantId2, agentClass) {
+    const aliases = getAgentTypeAliases(agentClass);
+    const results = await this.list({
+      where: aliases.length > 1 ? { tenantId: tenantId2, "agentClass in": aliases } : { tenantId: tenantId2, agentClass: aliases[0] }
+    });
+    const canonicalAgentClass = getAgentTypeName(agentClass);
+    const found = results.find((entry) => entry.agentClass === canonicalAgentClass) || results[0] || null;
+    if (found && found.agentClass !== canonicalAgentClass) {
+      await this.persistCanonicalAgentClass(found, canonicalAgentClass);
+    }
+    return found;
+  }
+  async normalizeStoredAgentClass(entry) {
+    const canonicalAgentClass = getAgentTypeName(entry.agentClass);
+    if (entry.agentClass !== canonicalAgentClass) {
+      await this.persistCanonicalAgentClass(entry, canonicalAgentClass);
+    }
+    return canonicalAgentClass;
+  }
+  async persistCanonicalAgentClass(entry, canonicalAgentClass) {
+    if (!entry.id || entry.agentClass === canonicalAgentClass) {
+      entry.agentClass = canonicalAgentClass;
+      return;
+    }
+    await this._db.query(
+      `UPDATE ${this.tableName}
+       SET agent_class = ?,
+           updated_at = ?
+       WHERE id = ?`,
+      canonicalAgentClass,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      entry.id
+    );
+    entry.agentClass = canonicalAgentClass;
+  }
+}
+function mergePermissions(manifestPermissions, overrides) {
+  const result = {};
+  if (manifestPermissions) {
+    for (const perm of manifestPermissions) {
+      result[perm.id] = perm.defaultGranted !== false;
+    }
+  }
+  if (overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function getManifestForAgent(manifests, agentTypeOrIdentifier) {
+  if (!manifests) {
+    return void 0;
+  }
+  return manifests.get(agentTypeOrIdentifier) || manifests.get(getAgentClassName(agentTypeOrIdentifier));
+}
+export {
+  Agent,
+  AgentConfig,
+  c as AgentConfigCollection,
+  AgentSchedule,
+  AgentScheduleCollection,
+  AgentUIRegistry,
+  TenantAgent,
+  TenantAgentCollection,
+  createUIRegistry,
+  getClassConfigResolvers,
+  getConfigResolver,
+  isLazyConfigSentinel,
+  listConfigResolvers,
+  mergeFilters,
+  normalizeSort,
+  registerConfigResolver,
+  resetConfigResolvers,
+  resolveAgentAIOptions,
+  resolveLazyConfig,
+  unregisterConfigResolver
+};
+//# sourceMappingURL=index.js.map