@elizaos/core 2.0.0-alpha.53 → 2.0.0-alpha.55

package/dist/provisioning.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Agent provisioning: migrations, agent/entity/room setup, embedding dimension.
+ * Runs once at deploy/daemon boot; not part of runtime.initialize().
+ * Export from node entry point only (not browser/edge).
+ *
+ * WHY this module exists:
+ * - Keeps the runtime a lean request handler; heavy one-time setup lives here.
+ * - Edge and ephemeral runtimes can skip provisioning entirely (they don't import this).
+ * - Daemon entry points call provisionAgent() once after initialize().
+ */
+import type { Character, UUID } from "./types";
+import type { IDatabaseAdapter } from "./types/database";
+import type { IAgentRuntime } from "./types/runtime";
+export interface ProvisionAgentOptions {
+    /** Run plugin schema migrations (DDL). Default true for daemon. */
+    runMigrations?: boolean;
+}
+/**
+ * Run plugin migrations (DDL) using the runtime's adapter and registered plugins.
+ * WHY standalone: Migrations are a one-time bootstrap step; not part of initialize()
+ * so ephemeral/edge runtimes never run them. process.env guards allow safe use in Node only.
+ */
+export declare function runPluginMigrations(runtime: IAgentRuntime): Promise<void>;
+/**
+ * Ensure agent row exists, then entity, self-room, and self-participant.
+ * Uses batch adapter APIs (getAgentsByIds, createEntities, getRoomsByIds, etc.).
+ * WHY: Agent must exist before the runtime can store memories/tasks; self-room and
+ * participant are required for core conversation flow.
+ */
+export declare function ensureAgentInfrastructure(runtime: IAgentRuntime): Promise<void>;
+/**
+ * Set embedding dimension on the adapter from config (no LLM call).
+ * Uses EMBEDDING_DIMENSION setting if set; otherwise skips.
+ * WHY no LLM: Avoids a model call at boot; set EMBEDDING_DIMENSION in character
+ * settings when using this path. If unset, embedding search may fail until dimension is set.
+ */
+export declare function ensureEmbeddingDimension(runtime: IAgentRuntime): Promise<void>;
+/**
+ * Orchestrator: run migrations (optional), ensure agent/entity/room/participant, set embedding dimension.
+ * Call after runtime.initialize() in daemon mode.
+ * WHY separate from initialize(): Ephemeral and edge runtimes do not call this;
+ * only long-lived daemons run it once at boot.
+ */
+export declare function provisionAgent(runtime: IAgentRuntime, options?: ProvisionAgentOptions): Promise<void>;
+/**
+ * Read agent from DB and merge settings/secrets into the given character.
+ * Returns a new Character; does not mutate the input.
+ * If no agent exists in DB, returns the character unchanged.
+ * Call before constructing the runtime so the runtime gets merged settings.
+ * WHY before runtime: The runtime constructor does not touch the DB; the host
+ * loads DB-backed config once and passes the merged character in.
+ */
+export declare function mergeDbSettings(character: Character, adapter: IDatabaseAdapter, agentId: UUID): Promise<Character>;
+//# sourceMappingURL=provisioning.d.ts.map

package/dist/provisioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisioning.d.ts","sourceRoot":"","sources":["../src/provisioning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAS,SAAS,EAAa,IAAI,EAAE,MAAM,SAAS,CAAC;AAEjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD,MAAM,WAAW,qBAAqB;IACrC,mEAAmE;IACnE,aAAa,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,IAAI,CAAC,CA2Df;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC9C,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,IAAI,CAAC,CAyDf;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC7C,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CACnC,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,qBAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACpC,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,IAAI,GACX,OAAO,CAAC,SAAS,CAAC,CAyDpB"}

package/dist/runtime-composition.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Runtime composition: building blocks for creating elizaOS runtimes.
+ *
+ * This module provides a small, composable API so hosts (daemon, cloud, serverless,
+ * milaidy, etc.) can set up runtimes without duplicating adapter creation, plugin
+ * resolution, or settings merge logic.
+ *
+ * **WHY a composition layer:** Different hosts need different flows (e.g. cloud may
+ * use its own adapter pool and skip createRuntimes), but they share the need to
+ * load characters, resolve plugins, create adapters before the runtime, and merge
+ * DB-backed settings. This module composes existing helpers so each host can use
+ * the pieces it needs.
+ *
+ * **Exports:**
+ * - loadCharacters(sources) – load from file paths or inline objects; returns Character[].
+ * - getBootstrapSettings(character) – flatten character + env for adapter factories (bootstrap only).
+ * - mergeSettingsInto(character, agentRecord) – pure merge of DB agent into character (for custom pipelines).
+ * - createRuntimes(characters, options?) – full pipeline: resolve plugins → adapters → merge DB settings → create/init runtimes; optional provision.
+ *
+ * **Settings divide:** Adapter factories receive only *bootstrap* settings (character + env).
+ * Runtime settings from the DB are merged *after* the adapter is created and used when
+ * constructing the runtime. WHY: You cannot load settings from the DB until the adapter
+ * is connected; bootstrap settings (e.g. POSTGRES_URL, PGLITE_DATA_DIR) are what you
+ * need to create the adapter in the first place.
+ */
+import type { CharacterInput } from "./character";
+import type { Character, IAgentRuntime, IDatabaseAdapter } from "./types";
+import type { Plugin } from "./types/plugin";
+/**
+ * Flatten character.settings, character.secrets, and env into a single Record<string, string>.
+ * Used when calling adapter factories (Plugin.adapter(agentId, settings)).
+ *
+ * **WHY bootstrap-only:** Adapter factories run *before* the database is connected. They
+ * cannot read runtime settings from the DB. Only settings available from character config
+ * and process.env (e.g. POSTGRES_URL, PGLITE_DATA_DIR, MONGODB_URI) are valid here. Runtime
+ * settings (API keys, model prefs, etc.) are merged later from the DB via mergeSettingsInto.
+ *
+ * **Merge order:** env first, then character.settings (excluding nested secrets object),
+ * then character.settings.secrets, then character.secrets. Later sources override earlier
+ * (character overrides env). WHY: Allows env defaults while letting character config override.
+ *
+ * @param character - Character to read settings and secrets from
+ * @param env - Environment record (defaults to process.env)
+ * @returns String-only record suitable for adapter factories
+ */
+export declare function getBootstrapSettings(character: Character, env?: NodeJS.ProcessEnv): Record<string, string>;
+/**
+ * Minimal shape of an agent record as returned from the database (e.g. getAgentsByIds).
+ * Used by mergeSettingsInto so callers can pass either a full Agent or a subset with
+ * settings/secrets. WHY loose type: Custom hosts (e.g. cloud) may have their own
+ * agent-like structures; this keeps the merge logic reusable.
+ */
+export interface AgentRecordForMerge {
+    settings?: Record<string, unknown>;
+    secrets?: Record<string, unknown>;
+}
+/**
+ * Merge DB-backed agent settings and secrets into a character (pure, no DB call).
+ * Same merge order as mergeDbSettings in provisioning.ts: DB base, character overrides.
+ *
+ * **WHY exported:** Custom hosts (e.g. cloud with its own adapter pool and caching) may
+ * load agent records themselves and need to apply the same merge semantics without
+ * calling mergeDbSettings (which takes an adapter and does the DB fetch). This function
+ * is the pure merge step only.
+ *
+ * @param character - Character to merge into (not mutated)
+ * @param agentRecord - Agent record from DB (e.g. getAgentsByIds result item), or null
+ * @returns New character with merged settings and secrets
+ */
+export declare function mergeSettingsInto(character: Character, agentRecord: AgentRecordForMerge | null): Character;
+/**
+ * Load characters from file paths and/or inline character objects.
+ * Reuses loadCharacterFile, parseCharacter, importSecretsFromEnv, ensureEncryptionSalt,
+ * syncCharacterSecretsToEnv so behavior matches the rest of the codebase.
+ *
+ * **WHY accept mixed sources:** Daemons often load from files; programmatic hosts (e.g. cloud,
+ * serverless) may build character config in code. One API supports both.
+ *
+ * @param sources - File paths (string) or CharacterInput objects
+ * @returns Validated Character[] (empty array if sources is empty)
+ * @throws If a file path fails to load or an object fails validation (message includes path/details)
+ */
+export declare function loadCharacters(sources: (string | CharacterInput)[]): Promise<Character[]>;
+/** Options for createRuntimes. */
+export interface CreateRuntimesOptions {
+    /** Override: use this adapter for all characters (skip adapter discovery). WHY: Cloud/custom hosts may manage their own adapter pool. */
+    adapter?: IDatabaseAdapter;
+    /** Extra plugins to include for all characters (merged with character.plugins). WHY: Hosts like milaidy add their own plugin without putting it in every character file. */
+    sharedPlugins?: Plugin[];
+    /** Run provisioning after init: migrations once per unique adapter, then ensureAgentInfrastructure + ensureEmbeddingDimension per runtime. Default false. WHY: Daemons need it once at boot; serverless/ephemeral usually skip. */
+    provision?: boolean;
+    /** Log level for created runtimes. */
+    logLevel?: "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+    /** Extra settings applied to each runtime (e.g. MODEL_PROVIDER override). */
+    settings?: Record<string, string | boolean | number>;
+}
+/**
+ * Create runtimes from characters: resolve plugins once (batch), create adapters from
+ * plugin adapter factory, init adapters (deduped), batch merge DB settings per unique
+ * adapter, create AgentRuntime instances, initialize them, optionally provision.
+ *
+ * **WHY batch where possible:** Resolving plugins once for all characters avoids duplicate
+ * work and keeps dependency order consistent. getAgentsByIds is called once per unique
+ * adapter with all agent IDs for that adapter (not once per character). WHY: Fewer DB
+ * round-trips when multiple characters share the same DB.
+ *
+ * **Adapter discovery:** The first resolved plugin that defines an adapter factory
+ * (Plugin.adapter) is used. If options.adapter is set, that overrides and is used for
+ * all characters. WHY: One adapter per character is the common case; shared override
+ * supports custom pooling.
+ *
+ * @param characters - Validated characters (e.g. from loadCharacters)
+ * @param options - Optional adapter override, sharedPlugins, provision, logLevel, settings
+ * @returns Initialized IAgentRuntime[] (empty if characters is empty)
+ */
+export declare function createRuntimes(characters: Character[], options?: CreateRuntimesOptions): Promise<IAgentRuntime[]>;
+//# sourceMappingURL=runtime-composition.d.ts.map

package/dist/runtime-composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-composition.d.ts","sourceRoot":"","sources":["../src/runtime-composition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAWlD,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,KAAK,EAAkB,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAQ7D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,SAAS,EACpB,GAAG,GAAE,MAAM,CAAC,UAAwB,GAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0CxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAChC,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,mBAAmB,GAAG,IAAI,GACrC,SAAS,CAuDX;AAwCD;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CACnC,OAAO,EAAE,CAAC,MAAM,GAAG,cAAc,CAAC,EAAE,GAClC,OAAO,CAAC,SAAS,EAAE,CAAC,CAkBtB;AAED,kCAAkC;AAClC,MAAM,WAAW,qBAAqB;IACrC,yIAAyI;IACzI,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,4KAA4K;IAC5K,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,mOAAmO;IACnO,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IACnE,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,CAAC;CACrD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,cAAc,CACnC,UAAU,EAAE,SAAS,EAAE,EACvB,OAAO,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,aAAa,EAAE,CAAC,CA8H1B"}

package/dist/runtime.d.ts

@@ -2,7 +2,6 @@ import { type Action, type ActionResult, type Agent, ChannelType, type Character
 import type { IMessageService } from "./types/message-service";
 import type { RetryBackoffConfig, SchemaRow, StreamEvent } from "./types/state";
 import type { ToolPolicyConfig, ToolProfileId } from "./types/tools";
-import { PromptBatcher } from "./utils/prompt-batcher";
 export declare class Semaphore {
     private permits;
     private waiting;
@@ -33,17 +32,16 @@ export declare class AgentRuntime implements IAgentRuntime {
     private characterPlugins;
     private capabilityOptions;
     private actionPlanningOption?;
-    private cachedEmbeddingDimension?;
     private llmModeOption?;
     private checkShouldRespondOption?;
     private isAnonymousCharacter;
     logger: import("./logger").Logger;
     enableAutonomy: boolean;
-    /** When true, TaskService does not start a timer; host drives via runDueTasks(). WHY: no long-lived process in serverless. */
-    serverless: boolean;
     private settings;
     private servicePromiseHandlers;
     private servicePromises;
+    /** In-flight service start promises; dedupes concurrent getService() for the same type. */
+    private startingServices;
     private serviceRegistrationStatus;
     initPromise: Promise<void>;
     private initResolver;
@@ -52,14 +50,17 @@ export declare class AgentRuntime implements IAgentRuntime {
     private currentActionContext?;
     private maxWorkingMemoryEntries;
     messageService: IMessageService | null;
-    promptBatcher: PromptBatcher;
-    constructor(opts?: {
+    companionUrl?: string;
+    /** Set when stop() has been called; prevents new service starts and use-after-stop. */
+    private stopped;
+    constructor(opts: {
         conversationLength?: number;
         agentId?: UUID;
         /** Optional character configuration. If not provided, an anonymous character is created. */
         character?: Character;
         plugins?: Plugin[];
         fetch?: typeof fetch;
+        /** Database adapter. Use InMemoryDatabaseAdapter for in-memory-only runs. WHY: Caller owns DB lifecycle; no plugin registration race; single source of truth. */
         adapter?: IDatabaseAdapter;
         settings?: RuntimeSettings;
         allAvailablePlugins?: Plugin[];
@@ -104,12 +105,8 @@ export declare class AgentRuntime implements IAgentRuntime {
          * Can be enabled at construction time or lazily via settings.
          */
         enableAutonomy?: boolean;
-        /**
-         * Serverless mode: when true, TaskService does not start its own timer.
-         * Host must call taskService.runDueTasks() from cron or on each request.
-         * WHY: serverless runtimes have no long-lived process; setInterval would be useless or harmful.
-         */
-        serverless?: boolean;
+        /** Optional URL of a long-lived companion runtime for fire-and-forget embedding/task work. WHY: Thin runtimes (e.g. serverless) delegate embeddings and task-dirty notifications without blocking. */
+        companionUrl?: string;
     });
     /**
      * Create a new run ID for tracking a sequence of model calls
@@ -130,12 +127,23 @@ export declare class AgentRuntime implements IAgentRuntime {
     getCurrentRunId(): UUID;
     registerPlugin(plugin: Plugin): Promise<void>;
     getAllServices(): Map<ServiceTypeName, Service[]>;
+    /**
+     * Stops all started services and clears runtime caches/handlers.
+     * For full teardown (including DB/adapter connection), call close() after stop().
+     */
     stop(): Promise<void>;
+    /**
+     * Slim init: register plugins, ensure adapter ready, create message service.
+     * Does NOT run migrations, agent/entity/room creation, or embedding dimension.
+     * WHY: Those belong to provisioning (once at daemon boot); edge/ephemeral skip them.
+     */
     initialize(options?: {
         skipMigrations?: boolean;
         /** Allow running without a persistent database adapter (benchmarks/tests). */
         allowNoDatabase?: boolean;
     }): Promise<void>;
+    private getBootstrapSettings;
+    registerDatabaseAdapter(adapter: IDatabaseAdapter): void;
     runPluginMigrations(): Promise<void>;
     getConnection(): Promise<object>;
     setSetting(key: string, value: string | boolean | null, secret?: boolean): void;
@@ -170,7 +178,6 @@ export declare class AgentRuntime implements IAgentRuntime {
      * Priority: constructor option > character setting CHECK_SHOULD_RESPOND > default (true)
      */
     isCheckShouldRespondEnabled(): boolean;
-    registerDatabaseAdapter(adapter: IDatabaseAdapter): void;
     /**
      * Get the messaging adapter if available
      *
@@ -196,7 +203,7 @@ export declare class AgentRuntime implements IAgentRuntime {
         providerPolicy?: ToolPolicyConfig;
         worldPolicy?: ToolPolicyConfig;
         roomPolicy?: ToolPolicyConfig;
-    }): Action[];
+    }): Promise<Action[]>;
     /**
      * Check if a specific action is allowed by tool policy.
      *
@@ -211,10 +218,10 @@ export declare class AgentRuntime implements IAgentRuntime {
         providerPolicy?: ToolPolicyConfig;
         worldPolicy?: ToolPolicyConfig;
         roomPolicy?: ToolPolicyConfig;
-    }): {
+    }): Promise<{
         allowed: boolean;
         reason: string;
-    };
+    }>;
     registerEvaluator(evaluator: Evaluator): void;
     private updateActionPlan;
     private updateActionStep;
@@ -224,10 +231,10 @@ export declare class AgentRuntime implements IAgentRuntime {
     getActionResults(messageId: UUID): ActionResult[];
     evaluate(message: Memory, state: State, didRespond?: boolean, callback?: HandlerCallback, responses?: Memory[]): Promise<Evaluator[]>;
     ensureConnections(entities: Entity[], rooms: Room[], source: string, world: World): Promise<void>;
-    ensureConnection({ entityId, roomId, worldId, worldName, userName, name, source, type, channelId, messageServerId, userId, metadata, }: {
+    ensureConnection(params: {
         entityId: UUID;
         roomId: UUID;
-        worldId: UUID;
+        worldId?: UUID;
         worldName?: string;
         userName?: string;
         name?: string;
@@ -239,18 +246,15 @@ export declare class AgentRuntime implements IAgentRuntime {
         metadata?: Record<string, JsonValue>;
     }): Promise<void>;
     ensureParticipantInRoom(entityId: UUID, roomId: UUID): Promise<void>;
-    getParticipantsForEntities(entityIds: UUID[]): Promise<Participant[]>;
-    getParticipantsForRooms(roomIds: UUID[]): Promise<Array<{
-        roomId: UUID;
-        entityIds: UUID[];
-    }>>;
     getParticipantsForEntity(entityId: UUID): Promise<Participant[]>;
+    getParticipantsForEntities(entityIds: UUID[]): Promise<Participant[]>;
     getParticipantsForRoom(roomId: UUID): Promise<UUID[]>;
+    getParticipantsForRooms(roomIds: UUID[]): Promise<import("./types/database").ParticipantsForRoomsResult>;
+    isRoomParticipant(roomId: UUID, entityId: UUID): Promise<boolean>;
     areRoomParticipants(pairs: Array<{
         roomId: UUID;
         entityId: UUID;
     }>): Promise<boolean[]>;
-    isRoomParticipant(roomId: UUID, entityId: UUID): Promise<boolean>;
     addParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
     createRoomParticipants(entityIds: UUID[], roomId: UUID): Promise<UUID[]>;
     /**
@@ -269,28 +273,34 @@ export declare class AgentRuntime implements IAgentRuntime {
      */
     ensureRoomExists({ id, name, source, type, channelId, messageServerId, worldId, metadata, }: Room): Promise<void>;
     composeState(message: Memory, includeList?: string[] | null, onlyInclude?: boolean, skipCache?: boolean): Promise<State>;
-    getService<T extends Service = Service>(serviceName: ServiceTypeName | string): T | null;
+    /** WHY lazy: Service is started on first getService() so unused features don't pay startup cost; callers must await getService(). */
+    /** Dedupes concurrent getService() for the same type via startingServices so only one start runs. */
+    private _ensureServiceStarted;
+    /** Runs one service start; used by _ensureServiceStarted with startingServices dedupe. */
+    private _runServiceStart;
+    /** Returns the service instance or null; starts the service on first call (lazy). Always await. */
+    getService<T extends Service = Service>(serviceName: ServiceTypeName | string): Promise<T | null>;
     /**
      * Type-safe service getter that ensures the correct service type is returned
      * @template T - The expected service class type
      * @param serviceName - The service type name
      * @returns The service instance with proper typing, or null if not found
      */
-    getTypedService<T extends Service = Service>(serviceName: ServiceTypeName | string): T | null;
+    getTypedService<T extends Service = Service>(serviceName: ServiceTypeName | string): Promise<T | null>;
     /**
      * Get all services of a specific type
      * @template T - The expected service class type
      * @param serviceName - The service type name
      * @returns Array of service instances with proper typing
      */
-    getServicesByType<T extends Service = Service>(serviceName: ServiceTypeName | string): T[];
+    getServicesByType<T extends Service = Service>(serviceName: ServiceTypeName | string): Promise<T[]>;
     /**
-     * Get all registered service types
+     * Get all registered service types (includes lazy-registered, not yet started)
      * @returns Array of registered service type names
      */
     getRegisteredServiceTypes(): ServiceTypeName[];
     /**
-     * Check if a service type is registered
+     * Check if a service type is registered (class registered; may not be started yet)
      * @param serviceType - The service type to check
      * @returns true if the service is registered
      */
@@ -390,6 +400,23 @@ export declare class AgentRuntime implements IAgentRuntime {
             abortSignal?: AbortSignal;
         };
     }): Promise<Record<string, unknown> | null>;
+    private flattenSchemaRows;
+    private schemaHasNestedStructure;
+    private renderXmlSchemaExample;
+    private renderJsonSchemaExample;
+    private buildJsonExampleValue;
+    private buildJsonExampleValueAtDepth;
+    private validateResponseAgainstSchema;
+    private validateSchemaValue;
+    private validateSchemaValueAtDepth;
+    private buildValidationOutputInstructions;
+    private getEffectiveSchemaValueType;
+    private collectSchemaDefinitionWarnings;
+    private collectSchemaSpecWarnings;
+    private buildSchemaMetricKey;
+    private serializeSchemaMetricRow;
+    private serializeSchemaMetricSpec;
+    private serializeSchemaMetricSpecAtDepth;
     /**
      * Calculate retry backoff delay.
      */
@@ -424,23 +451,6 @@ export declare class AgentRuntime implements IAgentRuntime {
      * This recursively unwraps them up to a reasonable depth limit.
      */
     private normalizeStructuredResponse;
-    private flattenSchemaRows;
-    private schemaHasNestedStructure;
-    private renderXmlSchemaExample;
-    private renderJsonSchemaExample;
-    private buildJsonExampleValue;
-    private buildJsonExampleValueAtDepth;
-    private validateResponseAgainstSchema;
-    private validateSchemaValue;
-    private validateSchemaValueAtDepth;
-    private buildValidationOutputInstructions;
-    private getEffectiveSchemaValueType;
-    private collectSchemaDefinitionWarnings;
-    private collectSchemaSpecWarnings;
-    private buildSchemaMetricKey;
-    private serializeSchemaMetricRow;
-    private serializeSchemaMetricSpec;
-    private serializeSchemaMetricSpecAtDepth;
     registerEvent<T extends keyof EventPayloadMap>(event: T, handler: EventHandler<T>): void;
     registerEvent<P extends EventPayload = EventPayload>(event: string, handler: (params: P) => Promise<void>): void;
     getEvent(event: string): ((params: EventPayloadMap[keyof EventPayloadMap] | EventPayload) => Promise<void>)[] | undefined;
@@ -450,6 +460,9 @@ export declare class AgentRuntime implements IAgentRuntime {
     getTaskWorker(name: string): TaskWorker | undefined;
     get db(): object;
     init(): Promise<void>;
+    /**
+     * Closes the database adapter. Call after stop() for full teardown (stops services then closes DB/connection).
+     */
     close(): Promise<void>;
     getAgent(agentId: UUID): Promise<Agent | null>;
     getAgents(): Promise<Partial<Agent>[]>;
@@ -468,17 +481,24 @@ export declare class AgentRuntime implements IAgentRuntime {
     deleteAgents(agentIds: UUID[]): Promise<boolean>;
     ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
     getEntityById(entityId: UUID): Promise<Entity | null>;
-    getEntitiesForRooms(roomIds: UUID[], includeComponents?: boolean): Promise<Array<{
-        roomId: UUID;
-        entities: Entity[];
-    }>>;
+    getEntitiesForRooms(roomIds: UUID[], includeComponents?: boolean): Promise<import("./types/database").EntitiesForRoomsResult>;
     getEntitiesForRoom(roomId: UUID, includeComponents?: boolean): Promise<Entity[]>;
     createEntity(entity: Entity): Promise<boolean>;
     createEntities(entities: Entity[]): Promise<UUID[]>;
     upsertEntities(entities: Entity[]): Promise<void>;
-    getComponentsForEntities(entityIds: UUID[], worldId?: UUID, sourceEntityId?: UUID): Promise<Component[]>;
     getComponents(entityId: UUID, worldId?: UUID, sourceEntityId?: UUID): Promise<Component[]>;
+    getComponentsByNaturalKeys(keys: Array<{
+        entityId: UUID;
+        type: string;
+        worldId?: UUID;
+        sourceEntityId?: UUID;
+    }>): Promise<(Component | null)[]>;
+    getComponentsForEntities(entityIds: UUID[], worldId?: UUID, sourceEntityId?: UUID): Promise<Component[]>;
     addEmbeddingToMemory(memory: Memory): Promise<Memory>;
+    /**
+     * Queue a memory for embedding generation. If companionUrl is set, POSTs to companion
+     * and returns without waiting (fire-and-forget). WHY: Thin runtime doesn't block on embedding.
+     */
     queueEmbeddingGeneration(memory: Memory, priority?: "high" | "normal" | "low"): Promise<void>;
     getMemories(params: {
         entityId?: UUID;
@@ -532,14 +552,14 @@ export declare class AgentRuntime implements IAgentRuntime {
     redactSecrets(text: string): string;
     clearAllAgentMemories(): Promise<void>;
     deleteAllMemories(roomIds: UUID[], tableName: string): Promise<void>;
-    countMemories(params: {
-        roomIds?: UUID[];
+    countMemories(roomIdOrParams: UUID | {
+        roomId?: UUID;
         unique?: boolean;
         tableName?: string;
         entityId?: UUID;
         agentId?: UUID;
         metadata?: Record<string, unknown>;
-    }): Promise<number>;
+    }, unique?: boolean, tableName?: string): Promise<number>;
     getLogs(params: {
         entityId?: UUID;
         roomId?: UUID;
@@ -576,34 +596,25 @@ export declare class AgentRuntime implements IAgentRuntime {
     createRoom({ id, name, source, type, channelId, messageServerId, worldId, }: Room): Promise<UUID>;
     createRooms(rooms: Room[]): Promise<UUID[]>;
     upsertRooms(rooms: Room[]): Promise<void>;
-    deleteRoomsByWorldIds(worldIds: UUID[]): Promise<void>;
-    getRoomsByWorlds(worldIds: UUID[], limit?: number, offset?: number): Promise<Room[]>;
-    getRoomsForParticipants(entityIds: UUID[]): Promise<UUID[]>;
     deleteRoomsByWorldId(worldId: UUID): Promise<void>;
-    /** Single-id convenience: returns room IDs where this entity participates. */
     getRoomsForParticipant(entityId: UUID): Promise<UUID[]>;
+    getRoomsForParticipants(entityIds: UUID[]): Promise<UUID[]>;
     getRooms(worldId: UUID): Promise<Room[]>;
     getRoomsByWorld(worldId: UUID): Promise<Room[]>;
+    getParticipantUserState(roomId: UUID, entityId: UUID): Promise<"FOLLOWED" | "MUTED" | null>;
+    updateParticipantUserState(roomId: UUID, entityId: UUID, state: "FOLLOWED" | "MUTED" | null): Promise<void>;
     getParticipantUserStates(pairs: Array<{
         roomId: UUID;
         entityId: UUID;
     }>): Promise<("FOLLOWED" | "MUTED" | null)[]>;
-    getParticipantUserState(roomId: UUID, entityId: UUID): Promise<"FOLLOWED" | "MUTED" | null>;
     updateParticipantUserStates(updates: Array<{
         roomId: UUID;
         entityId: UUID;
         state: "FOLLOWED" | "MUTED" | null;
     }>): Promise<void>;
-    updateParticipantUserState(roomId: UUID, entityId: UUID, state: "FOLLOWED" | "MUTED" | null): Promise<void>;
-    getRelationshipsByPairs(pairs: Array<{
-        sourceEntityId: UUID;
-        targetEntityId: UUID;
-    }>): Promise<(Relationship | null)[]>;
     getRelationships(params: {
-        entityIds?: UUID[];
+        entityId: UUID;
         tags?: string[];
-        limit?: number;
-        offset?: number;
     }): Promise<Relationship[]>;
     getCaches<T>(keys: string[]): Promise<Map<string, T>>;
     setCaches<T>(entries: Array<{
@@ -615,11 +626,10 @@ export declare class AgentRuntime implements IAgentRuntime {
         roomId?: UUID;
         tags?: string[];
         entityId?: UUID;
-        agentIds: UUID[];
-        limit?: number;
-        offset?: number;
     }): Promise<Task[]>;
     getTasksByName(name: string): Promise<Task[]>;
+    /** WHY fire-and-forget: Notify companion that tasks changed so it can poll/process; no need to block. */
+    private _notifyCompanionTasksDirty;
     createTask(task: Task): Promise<UUID>;
     getTask(id: UUID): Promise<Task | null>;
     updateTask(id: UUID, task: Partial<Task>): Promise<void>;
@@ -678,12 +688,6 @@ export declare class AgentRuntime implements IAgentRuntime {
     updateComponents(components: Component[]): Promise<void>;
     deleteComponents(componentIds: UUID[]): Promise<void>;
     createComponent(component: Component): Promise<boolean>;
-    getComponentsByNaturalKeys(keys: Array<{
-        entityId: UUID;
-        type: string;
-        worldId?: UUID;
-        sourceEntityId?: UUID;
-    }>): Promise<(Component | null)[]>;
     getComponent(entityId: UUID, type: string, worldId?: UUID, sourceEntityId?: UUID): Promise<Component | null>;
     updateComponent(component: Component): Promise<void>;
     deleteComponent(componentId: UUID): Promise<void>;
@@ -691,15 +695,15 @@ export declare class AgentRuntime implements IAgentRuntime {
     upsertComponents(components: Component[], options?: {
         entityContext?: UUID;
     }): Promise<void>;
+    patchComponent(componentId: UUID, ops: PatchOp[], options?: {
+        entityContext?: UUID;
+    }): Promise<void>;
     patchComponents(updates: Array<{
         componentId: UUID;
         ops: PatchOp[];
     }>, options?: {
         entityContext?: UUID;
     }): Promise<void>;
-    patchComponent(componentId: UUID, ops: PatchOp[], options?: {
-        entityContext?: UUID;
-    }): Promise<void>;
     patchComponentField(componentId: UUID, op: PatchOp, options?: {
         entityContext?: UUID;
     }): Promise<void>;
@@ -722,6 +726,10 @@ export declare class AgentRuntime implements IAgentRuntime {
         metadata?: Metadata;
     }>): Promise<UUID[]>;
     getRelationshipsByIds(relationshipIds: UUID[]): Promise<Relationship[]>;
+    getRelationshipsByPairs(pairs: Array<{
+        sourceEntityId: UUID;
+        targetEntityId: UUID;
+    }>): Promise<(Relationship | null)[]>;
     updateRelationships(relationships: Relationship[]): Promise<void>;
     deleteRelationships(relationshipIds: UUID[]): Promise<void>;
     createRelationship(params: {
@@ -777,31 +785,22 @@ export declare class AgentRuntime implements IAgentRuntime {
     registerSendHandler(source: string, handler: SendHandlerFunction): void;
     sendMessageToTarget(target: TargetInfo, content: Content): Promise<void>;
     getMemoriesByWorldId(params: {
-        worldIds?: UUID[];
+        worldId: UUID;
         count?: number;
-        limit?: number;
         tableName?: string;
     }): Promise<Memory[]>;
     runMigrations(migrationsPaths?: string[]): Promise<void>;
     isReady(): Promise<boolean>;
+    getPairingRequestsForChannel(channel: PairingChannel, agentId: UUID): Promise<PairingRequest[]>;
     getPairingRequests(queries: Array<{
         channel: PairingChannel;
         agentId: UUID;
-    }>): Promise<Array<{
-        channel: PairingChannel;
-        agentId: UUID;
-        requests: PairingRequest[];
-    }>>;
-    getPairingRequests(channel: PairingChannel, agentId: UUID): Promise<PairingRequest[]>;
+    }>): Promise<import("./types/database").PairingRequestsResult>;
+    getPairingAllowlistForChannel(channel: PairingChannel, agentId: UUID): Promise<PairingAllowlistEntry[]>;
     getPairingAllowlists(queries: Array<{
         channel: PairingChannel;
         agentId: UUID;
-    }>): Promise<Array<{
-        channel: PairingChannel;
-        agentId: UUID;
-        entries: PairingAllowlistEntry[];
-    }>>;
-    getPairingAllowlist(channel: PairingChannel, agentId: UUID): Promise<PairingAllowlistEntry[]>;
+    }>): Promise<import("./types/database").PairingAllowlistsResult>;
     createPairingRequests(requests: PairingRequest[]): Promise<UUID[]>;
     updatePairingRequests(requests: PairingRequest[]): Promise<void>;
     deletePairingRequests(ids: UUID[]): Promise<void>;
@@ -813,5 +812,7 @@ export declare class AgentRuntime implements IAgentRuntime {
     deletePairingRequest(id: UUID): Promise<void>;
     createPairingAllowlistEntry(entry: PairingAllowlistEntry): Promise<UUID>;
     deletePairingAllowlistEntry(id: UUID): Promise<void>;
+    deleteRoomsByWorldIds(worldIds: UUID[]): Promise<void>;
+    getRoomsByWorlds(worldIds: UUID[], limit?: number, offset?: number): Promise<Room[]>;
 }
 //# sourceMappingURL=runtime.d.ts.map