@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/runtime/release-plugin-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-plugin-policy.d.ts","sourceRoot":"","sources":["../../src/runtime/release-plugin-policy.ts"],"names":[],"mappings":"AAqDA,MAAM,MAAM,4BAA4B,GAAG,SAAS,GAAG,KAAK,CAAC;AAC7D,MAAM,MAAM,iCAAiC,GAAG,SAAS,GAAG,cAAc,CAAC;AAE3E,MAAM,WAAW,kCAAkC;IACjD,mBAAmB,EAAE,iCAAiC,CAAC;IACvD,cAAc,EAAE,4BAA4B,CAAC;IAC7C,sBAAsB,EAAE,OAAO,CAAC;IAChC,sBAAsB,EAAE,OAAO,CAAC;IAChC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,iCAAiC,EAAE,SAAS,MAAM,EAO9D,CAAC;AASF,wBAAgB,6BAA6B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAKzE;AAMD,wBAAgB,yBAAyB,CACvC,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,GACtC,MAAM,EAAE,CAKV;AAED,wBAAgB,0BAA0B,CACxC,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,GACtC,MAAM,EAAE,CAQV;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,kCAAkC,CAsCrC"}

package/runtime/release-plugin-policy.js

@@ -0,0 +1,115 @@
+import { CORE_PLUGINS, OPTIONAL_CORE_PLUGINS } from "./core-plugins.js";
+const BASELINE_RUNTIME_SUPPORT_PACKAGES = [
+    "@elizaos/core",
+    "@elizaos/prompts",
+    "@elizaos/plugin-remote-manifest",
+    "@elizaos/plugin-worker-runtime",
+];
+const BASELINE_PROVIDER_PLUGINS = [
+    "@elizaos/plugin-elizacloud",
+    "@elizaos/plugin-openai",
+    "@elizaos/plugin-anthropic",
+    "@elizaos/plugin-ollama",
+];
+// Desktop loads this through the legacy "agent-orchestrator" compatibility id,
+// but the implementation ships as the scoped package below.
+const BASELINE_DESKTOP_RUNTIME_PLUGINS = [
+    "@elizaos/plugin-agent-orchestrator",
+];
+// These are implementation dependencies of bundled core plugins. They need
+// to ship in the runtime bundle, but are not auto-loaded by collectPluginNames.
+const BASELINE_PLUGIN_SUPPORT_PACKAGES = [
+    "@elizaos/plugin-calendly",
+    "@elizaos/plugin-health",
+    "@elizaos/plugin-app-manager",
+    "@elizaos/plugin-registry",
+    "@elizaos/plugin-wallet-ui",
+    "@elizaos/plugin-wallet",
+    "@elizaos/plugin-imessage",
+    "@elizaos/plugin-streaming",
+    "@elizaos/ui",
+    "@elizaos/app-model-tester",
+    "@elizaos/plugin-documents",
+    "@elizaos/plugin-hyperliquid-app",
+    "@elizaos/plugin-polymarket-app",
+    "@elizaos/plugin-shopify-ui",
+    "@elizaos/plugin-steward-app",
+    "@elizaos/plugin-training",
+    "@elizaos/plugin-vincent",
+];
+// Plugins excluded from the baseline release that can only be installed on a
+// local desktop runtime after release. Desktop and local runtimes share the
+// same exclusion list, so a single source of truth drives both flags.
+const RUNTIME_ONLY_PLUGINS = new Set([
+    "@elizaos/plugin-agent-orchestrator",
+    "@elizaos/plugin-browser",
+    "@elizaos/plugin-computeruse",
+]);
+export const BASELINE_BUNDLED_RUNTIME_PACKAGES = [
+    ...BASELINE_RUNTIME_SUPPORT_PACKAGES,
+    ...BASELINE_DESKTOP_RUNTIME_PLUGINS,
+    ...CORE_PLUGINS,
+    ...OPTIONAL_CORE_PLUGINS,
+    ...BASELINE_PLUGIN_SUPPORT_PACKAGES,
+    ...BASELINE_PROVIDER_PLUGINS,
+];
+const BASELINE_REGISTRY_BUNDLED_PLUGIN_PACKAGES = [
+    ...BASELINE_DESKTOP_RUNTIME_PLUGINS,
+    ...CORE_PLUGINS,
+    ...OPTIONAL_CORE_PLUGINS,
+    ...BASELINE_PROVIDER_PLUGINS,
+];
+export function derivePluginIdFromPackageName(packageName) {
+    return packageName
+        .replace(/^@[^/]+\/plugin-/, "")
+        .replace(/^@[^/]+\//, "")
+        .replace(/^plugin-/, "");
+}
+const BASELINE_REGISTRY_BUNDLED_PLUGIN_IDS = new Set(BASELINE_REGISTRY_BUNDLED_PLUGIN_PACKAGES.map(derivePluginIdFromPackageName));
+export function getBundledRuntimePackages(availableDependencies) {
+    const available = new Set(availableDependencies);
+    return BASELINE_BUNDLED_RUNTIME_PACKAGES.filter((packageName) => available.has(packageName)).sort();
+}
+export function getBundledRuntimePluginIds(availableDependencies) {
+    const available = new Set(availableDependencies);
+    return BASELINE_REGISTRY_BUNDLED_PLUGIN_PACKAGES.filter((packageName) => available.has(packageName))
+        .map(derivePluginIdFromPackageName)
+        .filter((pluginId) => pluginId.length > 0)
+        .sort();
+}
+export function classifyRegistryPluginRelease(params) {
+    const { packageName, bundledPluginIds, kind } = params;
+    if (kind === "app") {
+        return {
+            releaseAvailability: "post-release",
+            installSurface: "app",
+            postReleaseInstallable: false,
+            requiresDesktopRuntime: false,
+            requiresLocalRuntime: false,
+            note: "Launchable apps are installed through the app catalog, not the runtime plugin installer.",
+        };
+    }
+    const pluginId = derivePluginIdFromPackageName(packageName);
+    const bundled = BASELINE_REGISTRY_BUNDLED_PLUGIN_IDS.has(pluginId) &&
+        bundledPluginIds.has(pluginId);
+    const requiresRuntimeInstall = RUNTIME_ONLY_PLUGINS.has(packageName);
+    let note;
+    if (bundled) {
+        note = "Included in the baseline Eliza runtime bundle.";
+    }
+    else if (requiresRuntimeInstall) {
+        note =
+            "Excluded from the baseline release. Install on a local desktop runtime after release.";
+    }
+    else {
+        note = "Excluded from the baseline release and installable after release.";
+    }
+    return {
+        releaseAvailability: bundled ? "bundled" : "post-release",
+        installSurface: "runtime",
+        postReleaseInstallable: !bundled,
+        requiresDesktopRuntime: requiresRuntimeInstall,
+        requiresLocalRuntime: requiresRuntimeInstall,
+        note,
+    };
+}

package/runtime/restart.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Restart infrastructure for Eliza — thin re-export of `@elizaos/shared/restart`.
+ *
+ * The single source of truth lives in `@elizaos/shared` (browser-safe inert
+ * default). This module preserves the historical import path used inside the
+ * agent package so existing imports keep working.
+ */
+export { RESTART_EXIT_CODE, type RestartHandler, requestRestart, setRestartHandler, } from "@elizaos/shared";
+//# sourceMappingURL=restart.d.ts.map

package/runtime/restart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restart.d.ts","sourceRoot":"","sources":["../../src/runtime/restart.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,iBAAiB,EACjB,KAAK,cAAc,EACnB,cAAc,EACd,iBAAiB,GAClB,MAAM,iBAAiB,CAAC"}

package/runtime/restart.js

@@ -0,0 +1,8 @@
+/**
+ * Restart infrastructure for Eliza — thin re-export of `@elizaos/shared/restart`.
+ *
+ * The single source of truth lives in `@elizaos/shared` (browser-safe inert
+ * default). This module preserves the historical import path used inside the
+ * agent package so existing imports keep working.
+ */
+export { RESTART_EXIT_CODE, requestRestart, setRestartHandler, } from "@elizaos/shared";

package/runtime/roles/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/roles/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAGL,KAAK,MAAM,EACX,UAAU,EACX,MAAM,eAAe,CAAC;AAoBvB,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,YAAY,EACV,uBAAuB,EACvB,eAAe,EACf,eAAe,EACf,QAAQ,EACR,WAAW,EACX,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,2BAA2B,EAC3B,0BAA0B,EAC1B,aAAa,EACb,2BAA2B,EAC3B,oCAAoC,EACpC,aAAa,EACb,uBAAuB,EACvB,iCAAiC,EACjC,iBAAiB,EACjB,sBAAsB,EACtB,0BAA0B,EAC1B,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,CAAC;AA8QtB,QAAA,MAAM,WAAW,EAAE,MAwElB,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/runtime/roles/src/index.js

@@ -0,0 +1,279 @@
+/**
+ * Internal runtime roles capability.
+ *
+ * Provides OWNER / ADMIN / USER / GUEST role hierarchy with:
+ * - Auto-assignment of OWNER to the app user (world owner)
+ * - Connector admin whitelisting (Discord, Telegram, etc.)
+ * - /role command for live role management
+ * - Provider that injects role context for action/provider gating
+ *
+ * Runtime config lives at:
+ *   roles.connectorAdmins = {
+ *     "discord": ["discordUserId1", "discordUserId2"],
+ *     "telegram": ["telegramUserId1"]
+ *   }
+ */
+import { logger, roleAction, } from "@elizaos/core";
+import { rolesProvider } from "./provider.js";
+import { hasConfiguredCanonicalOwner, matchEntityToConnectorAdminWhitelist, normalizeRole, resolveCanonicalOwnerId, } from "./utils.js";
+const BOOTSTRAP_RETRY_TIMERS_KEY = Symbol.for("@elizaos/runtime.roles.bootstrapRetries");
+const BOOTSTRAP_RETRY_LIMIT = 3;
+const CONNECTOR_ADMINS_SETTING_KEY = "ELIZA_ROLES_CONNECTOR_ADMINS_JSON";
+export { rolesProvider } from "./provider.js";
+export { ROLE_RANK } from "./types.js";
+export { canModifyRole, checkSenderPrivateAccess, checkSenderRole, getConfiguredOwnerEntityIds, getConnectorAdminWhitelist, getEntityRole, hasConfiguredCanonicalOwner, matchEntityToConnectorAdminWhitelist, normalizeRole, resolveCanonicalOwnerId, resolveCanonicalOwnerIdForMessage, resolveEntityRole, resolveWorldForMessage, setConnectorAdminWhitelist, setEntityRole, } from "./utils.js";
+export { roleAction };
+async function updateWorldMetadata(runtime, worldId, update) {
+    const world = await runtime.getWorld(worldId);
+    if (!world)
+        return;
+    const metadata = (world.metadata ?? {});
+    const changed = await update(metadata);
+    if (!changed)
+        return;
+    world.metadata = metadata;
+    await runtime.updateWorld(world);
+}
+function getBootstrapRetryTimers(runtime) {
+    const runtimeWithBootstrapRetries = runtime;
+    runtimeWithBootstrapRetries[BOOTSTRAP_RETRY_TIMERS_KEY] ??= new Map();
+    return runtimeWithBootstrapRetries[BOOTSTRAP_RETRY_TIMERS_KEY];
+}
+function scheduleBootstrapRetry(runtime, label, task, attempt = 1) {
+    const timers = getBootstrapRetryTimers(runtime);
+    const existingTimer = timers.get(label);
+    if (existingTimer) {
+        clearTimeout(existingTimer);
+    }
+    const delayMs = Math.min(1500 * attempt, 5000);
+    const timer = setTimeout(() => {
+        timers.delete(label);
+        void task().then((ok) => {
+            if (ok) {
+                return;
+            }
+            if (attempt >= BOOTSTRAP_RETRY_LIMIT) {
+                logger.warn(`[roles] ${label} retries exhausted because runtime state is still unavailable`);
+                return;
+            }
+            logger.info(`[roles] ${label} retry ${attempt} skipped because runtime state is still unavailable`);
+            scheduleBootstrapRetry(runtime, label, task, attempt + 1);
+        });
+    }, delayMs);
+    timers.set(label, timer);
+}
+function isExpectedRuntimeStateBootstrapError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return (/Failed query:\s*select\b.*\bfrom "worlds"/i.test(message) ||
+        /relation .*worlds.*does not exist/i.test(message) ||
+        /no such table:?\s*worlds/i.test(message));
+}
+function logRuntimeStateBootstrapDeferral(label, err) {
+    if (isExpectedRuntimeStateBootstrapError(err)) {
+        logger.info(`[roles] Deferring ${label} bootstrap until runtime worlds are available`);
+        return;
+    }
+    logger.info(`[roles] Deferring ${label} bootstrap until runtime worlds are available: ${String(err)}`);
+}
+/**
+ * Ensure the world owner has OWNER role in metadata.
+ * Called on plugin init — guarantees the app-local user is always OWNER.
+ */
+async function ensureOwnerRole(runtime, opts) {
+    try {
+        const worlds = await runtime.getAllWorlds();
+        for (const world of worlds) {
+            if (!world.id)
+                continue;
+            await updateWorldMetadata(runtime, world.id, (metadata) => {
+                const ownerId = resolveCanonicalOwnerId(runtime, metadata);
+                if (!ownerId)
+                    return false;
+                let changed = false;
+                metadata.ownership ??= {};
+                metadata.roleSources ??= {};
+                if (metadata.ownership.ownerId !== ownerId) {
+                    metadata.ownership.ownerId = ownerId;
+                    changed = true;
+                }
+                if (!metadata.roles)
+                    metadata.roles = {};
+                if (normalizeRole(metadata.roles[ownerId]) !== "OWNER") {
+                    metadata.roles[ownerId] = "OWNER";
+                    changed = true;
+                }
+                if (metadata.roleSources[ownerId] !== "owner") {
+                    metadata.roleSources[ownerId] = "owner";
+                    changed = true;
+                }
+                if (hasConfiguredCanonicalOwner(runtime)) {
+                    for (const [entityId, role] of Object.entries(metadata.roles)) {
+                        if (entityId !== ownerId && normalizeRole(role) === "OWNER") {
+                            delete metadata.roles[entityId];
+                            delete metadata.roleSources[entityId];
+                            changed = true;
+                        }
+                    }
+                }
+                if (opts?.pruneConnectorAdmins) {
+                    for (const [entityId, source] of Object.entries(metadata.roleSources)) {
+                        if (source !== "connector_admin")
+                            continue;
+                        delete metadata.roleSources[entityId];
+                        delete metadata.roles[entityId];
+                        changed = true;
+                        logger.info(`[roles] Cleared connector-admin grant ${entityId} because no whitelist is configured`);
+                    }
+                }
+                if (changed) {
+                    logger.info(`[roles] Synced canonical OWNER ${ownerId} in world ${world.id}`);
+                }
+                return changed;
+            });
+        }
+        return true;
+    }
+    catch (err) {
+        logRuntimeStateBootstrapDeferral("owner role", err);
+        return false;
+    }
+}
+/**
+ * Apply connector admin whitelists from config.
+ * Scans worlds for entities matching whitelisted IDs, promotes them to ADMIN,
+ * and removes stale connector_admin grants that no longer match.
+ */
+async function applyConnectorAdminWhitelists(runtime, whitelist) {
+    try {
+        const worlds = await runtime.getAllWorlds();
+        for (const world of worlds) {
+            if (!world.id)
+                continue;
+            const rooms = await runtime.getRooms(world.id);
+            await updateWorldMetadata(runtime, world.id, async (metadata) => {
+                if (!metadata.roles)
+                    metadata.roles = {};
+                metadata.roleSources ??= {};
+                let updated = false;
+                const matchedEntityIds = new Set();
+                for (const room of rooms) {
+                    const entities = await runtime.getEntitiesForRoom(room.id);
+                    for (const entity of entities) {
+                        if (!entity.id)
+                            continue;
+                        const entityId = entity.id;
+                        if (metadata.roles[entityId])
+                            continue;
+                        const matched = matchEntityToConnectorAdminWhitelist(entity.metadata ??
+                            undefined, whitelist);
+                        if (matched) {
+                            matchedEntityIds.add(entityId);
+                            if (metadata.roleSources[entityId] === "connector_admin" &&
+                                normalizeRole(metadata.roles[entityId]) === "ADMIN") {
+                                continue;
+                            }
+                            metadata.roles[entityId] = "ADMIN";
+                            metadata.roleSources[entityId] = "connector_admin";
+                            updated = true;
+                            logger.info(`[roles] Auto-promoted whitelisted entity ${entityId} to ADMIN`);
+                        }
+                    }
+                }
+                for (const [entityId, source] of Object.entries(metadata.roleSources)) {
+                    if (source !== "connector_admin")
+                        continue;
+                    if (matchedEntityIds.has(entityId))
+                        continue;
+                    delete metadata.roleSources[entityId];
+                    delete metadata.roles[entityId];
+                    updated = true;
+                    logger.info(`[roles] Revoked stale connector-admin role for entity ${entityId}`);
+                }
+                return updated;
+            });
+        }
+        return true;
+    }
+    catch (err) {
+        logRuntimeStateBootstrapDeferral("connector admin", err);
+        return false;
+    }
+}
+function loadConnectorAdminsConfig(pluginConfig, runtime) {
+    const directConfig = pluginConfig;
+    if (directConfig?.connectorAdmins) {
+        return directConfig;
+    }
+    const raw = typeof runtime.getSetting === "function"
+        ? runtime.getSetting(CONNECTOR_ADMINS_SETTING_KEY)
+        : undefined;
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return { connectorAdmins: parsed };
+    }
+    catch (error) {
+        logger.warn(`[roles] Failed to parse ${CONNECTOR_ADMINS_SETTING_KEY}: ${String(error)}`);
+        return {};
+    }
+}
+const rolesPlugin = {
+    name: "roles",
+    description: "Role-based access control — OWNER/ADMIN/USER/GUEST hierarchy with " +
+        "connector whitelisting and /role command.",
+    providers: [rolesProvider],
+    actions: [roleAction],
+    async init(pluginConfig, runtime) {
+        logger.info("[roles] Initializing roles");
+        const config = loadConnectorAdminsConfig(pluginConfig, runtime);
+        const connectorAdmins = config.connectorAdmins ?? {};
+        const hasConnectorAdmins = Object.values(connectorAdmins).some((ids) => ids.length > 0);
+        // Step 1: Ensure world owners have OWNER role
+        const ownerBootstrapOk = await ensureOwnerRole(runtime, {
+            pruneConnectorAdmins: !hasConnectorAdmins,
+        });
+        if (!ownerBootstrapOk) {
+            scheduleBootstrapRetry(runtime, "Owner role bootstrap", () => ensureOwnerRole(runtime, {
+                pruneConnectorAdmins: !hasConnectorAdmins,
+            }));
+        }
+        // Step 2: Apply connector admin whitelists if configured
+        if (hasConnectorAdmins) {
+            const adminBootstrapOk = await applyConnectorAdminWhitelists(runtime, connectorAdmins);
+            if (!adminBootstrapOk) {
+                scheduleBootstrapRetry(runtime, "Connector admin bootstrap", () => applyConnectorAdminWhitelists(runtime, connectorAdmins));
+            }
+        }
+        // Step 3: Re-fire the bootstrap on every world-creation event. init()
+        // runs before any connector (Discord/Telegram/etc.) has populated
+        // runtime.worlds, so ensureOwnerRole sees an empty set and the scheduled
+        // retry tail fires three times within ~10s — usually still before the
+        // connector worlds land. Without this hook the owner role never lands in
+        // world metadata, resolveStage1SenderRole forever returns USER, and
+        // every ADMIN-gated context (tasks/code/automation/connectors) stays
+        // hidden from the Stage 1 planner. Hooking WORLD_JOINED + WORLD_CONNECTED
+        // makes the bootstrap converge as soon as the first connector world
+        // appears, regardless of the initial retry-window timing.
+        const rerunOwnerBootstrap = async (label) => {
+            const ok = await ensureOwnerRole(runtime, {
+                pruneConnectorAdmins: !hasConnectorAdmins,
+            });
+            if (ok) {
+                logger.info(`[roles] Owner role re-applied after ${label}`);
+            }
+            if (hasConnectorAdmins) {
+                await applyConnectorAdminWhitelists(runtime, connectorAdmins);
+            }
+        };
+        runtime.registerEvent("WORLD_JOINED", async () => {
+            await rerunOwnerBootstrap("WORLD_JOINED");
+        });
+        runtime.registerEvent("WORLD_CONNECTED", async () => {
+            await rerunOwnerBootstrap("WORLD_CONNECTED");
+        });
+        logger.info("[roles] Roles initialized");
+    },
+};
+export default rolesPlugin;

package/runtime/roles/src/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/runtime/roles/src/provider.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIL,KAAK,QAAQ,EAId,MAAM,eAAe,CAAC;AAYvB,eAAO,MAAM,aAAa,EAAE,QA4I3B,CAAC"}

package/runtime/roles/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/runtime/roles/src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,uBAAuB,EACvB,eAAe,EACf,eAAe,EACf,QAAQ,EACR,WAAW,EACX,kBAAkB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC"}

package/runtime/roles/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/runtime/roles/src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,2BAA2B,EAC3B,0BAA0B,EAC1B,aAAa,EACb,gCAAgC,EAChC,2BAA2B,EAC3B,oCAAoC,EACpC,aAAa,EACb,uBAAuB,EACvB,iCAAiC,EACjC,iBAAiB,EACjB,sBAAsB,EACtB,0BAA0B,EAC1B,aAAa,GACd,MAAM,eAAe,CAAC"}

package/runtime/roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../src/runtime/roles.ts"],"names":[],"mappings":"AAIA,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC"}

package/runtime/sandbox-character.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Cloud sandbox character loader (Path A).
+ *
+ * A Hetzner-provisioned container is meant to boot AS its assigned character
+ * (e.g. "Nyx"), not as the generic bundled "Eliza" preset. The full character
+ * config lives in the `agent_sandboxes.agent_config` column and is injected by
+ * the provisioner as the `ELIZA_AGENT_CHARACTER_JSON` env var. Without this,
+ * `buildCharacterFromConfig` falls back to the default style preset because
+ * `config.agents.list[0]` is empty in a fresh container.
+ *
+ * This module parses that env var and merges it onto `config.agents.list[0]`
+ * so the existing `buildCharacterFromConfig` path picks up the right name,
+ * system prompt, bio, examples, topics, adjectives and style. It returns the
+ * config unchanged when the env var is absent or unparseable,
+ * so it is inert for every non-provisioned runtime.
+ */
+import type { ElizaConfig } from "../config/config.ts";
+/**
+ * Whether this container should own (connect directly to) its platform
+ * connectors. Default false: the gateway owns the connection and forwards
+ * inbound events to the container (resolves the double-connect seam). Set
+ * ELIZA_SANDBOX_OWNS_CONNECTORS=1 only when the operator has linked the
+ * connector to the container and disabled the gateway's connection row.
+ */
+export declare function sandboxOwnsConnectors(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Resolve the routing agent id for this container: the id the gateways use to
+ * resolve `agent:<id>:server` and to address `/agents/<id>/message`. This MUST
+ * be the platform `character_id` (the same value the gateway's
+ * `discord_connections.character_id` carries), not the sandbox id. The
+ * provisioner injects it as SANDBOX_ROUTE_AGENT_ID. Falls back to null when
+ * absent (non-provisioned runtime), in which case the runtime keeps its
+ * name-derived agent id.
+ */
+export declare function resolveSandboxRouteAgentId(env?: NodeJS.ProcessEnv): string | null;
+/**
+ * Apply the injected sandbox character (if any) onto the runtime config.
+ * Returns the same config object (mutated) for chaining convenience.
+ */
+export declare function applySandboxCharacterFromEnv(config: ElizaConfig, env?: NodeJS.ProcessEnv): ElizaConfig;
+/**
+ * Resolve the double-connect seam for a provisioned container.
+ *
+ * In the default (gateway-owned) mode the gateway holds the Discord/Telegram
+ * connection and forwards inbound events to this container; if the container
+ * ALSO connected with the same bot token we would get token contention and
+ * duplicate replies. So, unless the operator has explicitly made the
+ * container the connector owner (ELIZA_SANDBOX_OWNS_CONNECTORS=1), we strip
+ * the connector bot tokens from the environment AND clear the matching
+ * config.connectors blocks so the container runs purely as an inference
+ * target reached via /agents/<id>/message.
+ *
+ * IMPORTANT: callers must run this AFTER applyConnectorSecretsToEnv (which can
+ * repopulate the env tokens from config.connectors) and BEFORE plugin
+ * auto-enable / resolvePlugins.
+ *
+ * Skipped outside a provisioned container (ELIZA_CLOUD_PROVISIONED != "1"), so
+ * local dev and the in-worker path are unaffected.
+ */
+export declare function applySandboxConnectorOwnership(env?: NodeJS.ProcessEnv, config?: ElizaConfig): void;
+//# sourceMappingURL=sandbox-character.d.ts.map

package/runtime/sandbox-character.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-character.d.ts","sourceRoot":"","sources":["../../src/runtime/sandbox-character.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AA4BvD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAET;AAUD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,GAAG,IAAI,CAEf;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,WAAW,EACnB,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,WAAW,CA0Gb;AAYD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,MAAM,CAAC,EAAE,WAAW,GACnB,IAAI,CA6BN"}