@elizaos/agent 0.25.9 → 2.0.0-alpha.151

package/packages/agent/src/services/coding-task-executor.js

@@ -0,0 +1,141 @@
+import crypto from "node:crypto";
+const CODING_PATTERNS = /\b(build|create|make|scaffold|generate|code|implement|develop|fix|debug|refactor|write)\b/i;
+function findCreateTaskAction(runtime) {
+    const actions = Array.isArray(runtime.actions)
+        ? runtime.actions
+        : [];
+    return (actions.find((action) => action.name === "CREATE_TASK") ??
+        actions.find((action) => action.name === "START_CODING_TASK") ??
+        null);
+}
+function buildSyntheticTaskMemory(runtime, spec) {
+    if (spec.message) {
+        return spec.message;
+    }
+    const roomId = (runtime.agentId || "room-default");
+    return {
+        id: crypto.randomUUID(),
+        entityId: runtime.agentId,
+        agentId: runtime.agentId,
+        roomId,
+        content: {
+            text: spec.description,
+            agentType: spec.agentType,
+        },
+        createdAt: Date.now(),
+    };
+}
+/**
+ * Wraps the existing CODE_TASK compatibility service as a TaskExecutor.
+ * Delegates entirely to the orchestrator plugin — does not reimplement
+ * any orchestration logic.
+ *
+ * The CODE_TASK service is registered by the orchestrator plugin and
+ * discovered via `runtime.getService("CODE_TASK")`. The SWARM_COORDINATOR
+ * service is checked as a secondary signal that coding infrastructure is
+ * available.
+ */
+export class CodingTaskExecutor {
+    type = "coding";
+    description = "Executes coding tasks using the orchestrator task contract";
+    canHandle(spec, runtime) {
+        const codeTaskService = runtime.getService("CODE_TASK");
+        const createTaskAction = findCreateTaskAction(runtime);
+        if (!codeTaskService && !createTaskAction)
+            return false;
+        // Explicit type match
+        if (spec.type === "coding")
+            return true;
+        // Heuristic: description matches coding-related verbs
+        return CODING_PATTERNS.test(spec.description);
+    }
+    async execute(spec, runtime) {
+        const service = runtime.getService("CODE_TASK");
+        const startTime = Date.now();
+        if (!service) {
+            const action = findCreateTaskAction(runtime);
+            if (!action) {
+                return {
+                    taskId: spec.id,
+                    success: false,
+                    error: "Task orchestrator is not available",
+                };
+            }
+            const memory = buildSyntheticTaskMemory(runtime, spec);
+            const callbackLines = [];
+            const callback = async (content) => {
+                if (typeof content.text === "string" &&
+                    content.text.trim().length > 0) {
+                    callbackLines.push(content.text);
+                }
+                return [];
+            };
+            try {
+                if (action.validate) {
+                    const valid = await action.validate(runtime, memory, undefined);
+                    if (!valid) {
+                        return {
+                            taskId: spec.id,
+                            success: false,
+                            error: "Task orchestrator rejected the coding task request",
+                            durationMs: Date.now() - startTime,
+                        };
+                    }
+                }
+                const result = (await action.handler(runtime, memory, undefined, {
+                    parameters: {
+                        task: spec.description,
+                        ...(spec.agentType ? { agentType: spec.agentType } : {}),
+                    },
+                }, callback));
+                const sessionId = result?.data?.agents?.[0]?.sessionId;
+                const output = sessionId || result?.text || callbackLines.join("\n");
+                if (result?.success === false) {
+                    return {
+                        taskId: spec.id,
+                        success: false,
+                        error: result.error || result.text || "Task creation failed",
+                        durationMs: Date.now() - startTime,
+                    };
+                }
+                return {
+                    taskId: spec.id,
+                    success: true,
+                    output,
+                    durationMs: Date.now() - startTime,
+                };
+            }
+            catch (error) {
+                return {
+                    taskId: spec.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startTime,
+                };
+            }
+        }
+        try {
+            // Delegate to the existing orchestrator task creation flow.
+            // createTask(name, description, roomId?, providerId?, capabilities?)
+            const task = await service.createTask(spec.description.slice(0, 120), spec.description, undefined, spec.agentType ?? "claude");
+            return {
+                taskId: spec.id,
+                success: true,
+                output: task.id,
+                durationMs: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                taskId: spec.id,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - startTime,
+            };
+        }
+    }
+    async abort(_taskId) {
+        // Abort is handled through the existing PTY session stop mechanism.
+        // The orchestrator service manages session lifecycle via cancelTask().
+    }
+}

package/packages/agent/src/services/config-plugin-manager.d.ts

@@ -0,0 +1,6 @@
+import type { ElizaConfig } from "../config/types.eliza.js";
+import type { PluginManagerLike } from "./plugin-manager-types.js";
+type ConfigGetter = () => ElizaConfig;
+export declare function createConfigPluginManager(getConfig: ConfigGetter): PluginManagerLike;
+export {};
+//# sourceMappingURL=config-plugin-manager.d.ts.map

package/packages/agent/src/services/config-plugin-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-plugin-manager.d.ts","sourceRoot":"","sources":["../../../../../src/services/config-plugin-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAIV,iBAAiB,EAMlB,MAAM,2BAA2B,CAAC;AAOnC,KAAK,YAAY,GAAG,MAAM,WAAW,CAAC;AAqBtC,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,YAAY,GACtB,iBAAiB,CAiDnB"}

package/packages/agent/src/services/config-plugin-manager.js

@@ -0,0 +1,53 @@
+import { getPluginInfo, refreshRegistry, searchPlugins, } from "./registry-client.js";
+function listInstalledFromConfig(config) {
+    const installs = config.plugins?.installs;
+    if (!installs || typeof installs !== "object") {
+        return [];
+    }
+    return Object.entries(installs).map(([name, record]) => ({
+        name,
+        version: record.version,
+        installedAt: record.installedAt,
+    }));
+}
+function runtimeRequiredError(operation) {
+    return new Error(`${operation} requires a running agent runtime with the plugin manager service.`);
+}
+export function createConfigPluginManager(getConfig) {
+    return {
+        async refreshRegistry() {
+            return refreshRegistry();
+        },
+        async listInstalledPlugins() {
+            return listInstalledFromConfig(getConfig());
+        },
+        async getRegistryPlugin(name) {
+            return getPluginInfo(name);
+        },
+        async searchRegistry(query, limit) {
+            return (await searchPlugins(query, limit)).map((result) => ({
+                ...result,
+                version: null,
+                npmPackage: result.name,
+            }));
+        },
+        async installPlugin() {
+            throw runtimeRequiredError("Plugin installation");
+        },
+        async uninstallPlugin() {
+            throw runtimeRequiredError("Plugin removal");
+        },
+        async listEjectedPlugins() {
+            return [];
+        },
+        async ejectPlugin() {
+            throw runtimeRequiredError("Plugin ejection");
+        },
+        async syncPlugin() {
+            throw runtimeRequiredError("Plugin sync");
+        },
+        async reinjectPlugin() {
+            throw runtimeRequiredError("Plugin reinjection");
+        },
+    };
+}

package/packages/agent/src/services/connector-setup-service.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ConnectorSetupService — a runtime service that exposes shared
+ * connector setup utilities to plugins.
+ *
+ * Plugins access this during route handlers via:
+ *   `runtime.getService("connector-setup")`
+ *
+ * Provides config persistence, escalation channel registration,
+ * owner contact management, workspace dir, and WebSocket broadcasting
+ * so connector plugins don't need to import agent internals.
+ */
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import { type OwnerContactUpdate } from "../api/owner-contact-helpers.js";
+export type { OwnerContactUpdate };
+export interface ConnectorSetupServiceInstance extends Service {
+    /** Load the current Eliza config from disk. */
+    getConfig(): Record<string, unknown>;
+    /** Save the Eliza config to disk. */
+    persistConfig(config: Record<string, unknown>): void;
+    /** Load + return; caller mutates; then persistConfig(). Convenience wrapper. */
+    updateConfig(updater: (config: Record<string, unknown>) => void): void;
+    /** Register a channel name for escalation delivery (e.g. "telegram"). */
+    registerEscalationChannel(channelName: string): boolean;
+    /** Set/update an owner contact entry in the config. */
+    setOwnerContact(update: OwnerContactUpdate): boolean;
+    /** Resolve the default agent workspace directory. */
+    getWorkspaceDir(): string;
+    /** Broadcast a WebSocket message to all connected clients. */
+    broadcastWs(data: Record<string, unknown>): void;
+    /** Set the WebSocket broadcast function (called by the server during startup). */
+    setBroadcastWs(fn: ((data: Record<string, unknown>) => void) | null): void;
+}
+export declare class ConnectorSetupService extends Service {
+    static serviceType: string;
+    capabilityDescription: string;
+    private broadcastWsFn;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    stop(): Promise<void>;
+    getConfig(): Record<string, unknown>;
+    persistConfig(config: Record<string, unknown>): void;
+    updateConfig(updater: (config: Record<string, unknown>) => void): void;
+    registerEscalationChannel(channelName: string): boolean;
+    setOwnerContact(update: OwnerContactUpdate): boolean;
+    getWorkspaceDir(): string;
+    broadcastWs(data: Record<string, unknown>): void;
+    setBroadcastWs(fn: ((data: Record<string, unknown>) => void) | null): void;
+}
+//# sourceMappingURL=connector-setup-service.d.ts.map

package/packages/agent/src/services/connector-setup-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-setup-service.d.ts","sourceRoot":"","sources":["../../../../../src/services/connector-setup-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAU,OAAO,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,iCAAiC,CAAC;AAKzC,YAAY,EAAE,kBAAkB,EAAE,CAAC;AAEnC,MAAM,WAAW,6BAA8B,SAAQ,OAAO;IAC5D,+CAA+C;IAC/C,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,qCAAqC;IACrC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACrD,gFAAgF;IAChF,YAAY,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC;IACvE,yEAAyE;IACzE,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IACxD,uDAAuD;IACvD,eAAe,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC;IACrD,qDAAqD;IACrD,eAAe,IAAI,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACjD,kFAAkF;IAClF,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;CAC5E;AAED,qBAAa,qBAAsB,SAAQ,OAAO;IAChD,MAAM,CAAC,WAAW,SAAqB;IACvC,qBAAqB,SAAkD;IAEvE,OAAO,CAAC,aAAa,CACd;WAEM,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IAMtD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIpC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIpD,YAAY,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GAAG,IAAI;IAMtE,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAIvD,eAAe,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO;IAYpD,eAAe,IAAI,MAAM;IAIzB,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIhD,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI;CAG3E"}

package/packages/agent/src/services/connector-setup-service.js

@@ -0,0 +1,60 @@
+/**
+ * ConnectorSetupService — a runtime service that exposes shared
+ * connector setup utilities to plugins.
+ *
+ * Plugins access this during route handlers via:
+ *   `runtime.getService("connector-setup")`
+ *
+ * Provides config persistence, escalation channel registration,
+ * owner contact management, workspace dir, and WebSocket broadcasting
+ * so connector plugins don't need to import agent internals.
+ */
+import { logger, Service } from "@elizaos/core";
+import { setOwnerContact, } from "../api/owner-contact-helpers.js";
+import { loadElizaConfig, saveElizaConfig } from "../config/config.js";
+import { resolveDefaultAgentWorkspaceDir } from "../providers/workspace.js";
+import { registerEscalationChannel } from "./escalation.js";
+export class ConnectorSetupService extends Service {
+    static serviceType = "connector-setup";
+    capabilityDescription = "Shared connector setup utilities for plugins";
+    broadcastWsFn = null;
+    static async start(runtime) {
+        const instance = new ConnectorSetupService(runtime);
+        logger.debug("[connector-setup] Service started");
+        return instance;
+    }
+    async stop() {
+        this.broadcastWsFn = null;
+    }
+    getConfig() {
+        return loadElizaConfig();
+    }
+    persistConfig(config) {
+        saveElizaConfig(config);
+    }
+    updateConfig(updater) {
+        const config = this.getConfig();
+        updater(config);
+        this.persistConfig(config);
+    }
+    registerEscalationChannel(channelName) {
+        return registerEscalationChannel(channelName);
+    }
+    setOwnerContact(update) {
+        const config = this.getConfig();
+        const modified = setOwnerContact(config, update);
+        if (modified) {
+            this.persistConfig(config);
+        }
+        return modified;
+    }
+    getWorkspaceDir() {
+        return resolveDefaultAgentWorkspaceDir();
+    }
+    broadcastWs(data) {
+        this.broadcastWsFn?.(data);
+    }
+    setBroadcastWs(fn) {
+        this.broadcastWsFn = fn;
+    }
+}

package/packages/agent/src/services/conversation-proximity.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Conversation proximity relationship updates.
+ *
+ * When a message arrives, look at the last N messages in the same room.
+ * For each unique sender who posted recently, create or strengthen the
+ * relationship between them and the current sender. This is deterministic
+ * (no LLM calls) and lightweight — designed to run on every message.
+ */
+import type { IAgentRuntime, Memory, UUID } from "@elizaos/core";
+interface ProximityPair {
+    entityA: UUID;
+    entityB: UUID;
+    /** Number of recent messages shared in the window. */
+    coOccurrences: number;
+}
+/**
+ * Given a new message, find co-participants in the recent conversation and
+ * return the pairs that should have their relationships updated.
+ */
+export declare function findProximityPairs(runtime: IAgentRuntime, message: Memory): Promise<ProximityPair[]>;
+/**
+ * Update relationships for all proximity pairs found from a new message.
+ * Creates new relationships or increments strength on existing ones.
+ */
+export declare function updateProximityRelationships(runtime: IAgentRuntime, message: Memory): Promise<number>;
+export {};
+//# sourceMappingURL=conversation-proximity.d.ts.map

package/packages/agent/src/services/conversation-proximity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-proximity.d.ts","sourceRoot":"","sources":["../../../../../src/services/conversation-proximity.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAiBjE,UAAU,aAAa;IACrB,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,IAAI,CAAC;IACd,sDAAsD;IACtD,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,EAAE,CAAC,CAwC1B;AAED;;;GAGG;AACH,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,CAmEjB"}

package/packages/agent/src/services/conversation-proximity.js

@@ -0,0 +1,124 @@
+/**
+ * Conversation proximity relationship updates.
+ *
+ * When a message arrives, look at the last N messages in the same room.
+ * For each unique sender who posted recently, create or strengthen the
+ * relationship between them and the current sender. This is deterministic
+ * (no LLM calls) and lightweight — designed to run on every message.
+ */
+/** How many recent messages to look back at for co-participants. */
+const PROXIMITY_WINDOW_SIZE = 10;
+/** Maximum age (ms) for a message to count as "recent" — 5 minutes. */
+const PROXIMITY_MAX_AGE_MS = 5 * 60 * 1000;
+/** Strength increment per co-occurring message pair. */
+const STRENGTH_INCREMENT = 0.02;
+/** Maximum relationship strength. */
+const STRENGTH_MAX = 1.0;
+/** Minimum strength to avoid creating noise relationships. */
+const STRENGTH_FLOOR = 0.1;
+/**
+ * Given a new message, find co-participants in the recent conversation and
+ * return the pairs that should have their relationships updated.
+ */
+export async function findProximityPairs(runtime, message) {
+    const senderEntityId = message.entityId;
+    const roomId = message.roomId;
+    const agentId = runtime.agentId;
+    if (!senderEntityId || !roomId)
+        return [];
+    // Don't create relationships for the agent talking to itself.
+    if (senderEntityId === agentId)
+        return [];
+    const recentMessages = await runtime.getMemories({
+        roomId,
+        tableName: "messages",
+        limit: PROXIMITY_WINDOW_SIZE + 1, // +1 because the current msg may be included
+    });
+    const now = message.createdAt ?? Date.now();
+    const cutoff = now - PROXIMITY_MAX_AGE_MS;
+    // Count how many recent messages each unique entity sent.
+    const entityMessageCounts = new Map();
+    for (const m of recentMessages) {
+        const eid = m.entityId;
+        if (!eid)
+            continue;
+        if (eid === senderEntityId)
+            continue; // skip the sender themselves
+        if (eid === agentId)
+            continue; // skip the agent
+        if ((m.createdAt ?? 0) < cutoff)
+            continue; // too old
+        entityMessageCounts.set(eid, (entityMessageCounts.get(eid) ?? 0) + 1);
+    }
+    const pairs = [];
+    for (const [entityId, count] of entityMessageCounts) {
+        // Normalize so entityA < entityB for consistent ordering.
+        const [entityA, entityB] = senderEntityId < entityId
+            ? [senderEntityId, entityId]
+            : [entityId, senderEntityId];
+        pairs.push({ entityA, entityB, coOccurrences: count });
+    }
+    return pairs;
+}
+/**
+ * Update relationships for all proximity pairs found from a new message.
+ * Creates new relationships or increments strength on existing ones.
+ */
+export async function updateProximityRelationships(runtime, message) {
+    const pairs = await findProximityPairs(runtime, message);
+    if (pairs.length === 0)
+        return 0;
+    let updated = 0;
+    for (const pair of pairs) {
+        const existing = await runtime.getRelationships({
+            entityIds: [pair.entityA],
+        });
+        const relationship = existing.find((r) => (r.sourceEntityId === pair.entityA &&
+            r.targetEntityId === pair.entityB) ||
+            (r.sourceEntityId === pair.entityB &&
+                r.targetEntityId === pair.entityA));
+        if (relationship) {
+            // Increment strength based on co-occurrences.
+            const meta = { ...(relationship.metadata ?? {}) };
+            const currentStrength = typeof meta.strength === "number" ? meta.strength : 0.5;
+            const increment = STRENGTH_INCREMENT * pair.coOccurrences;
+            const newStrength = Math.min(currentStrength + increment, STRENGTH_MAX);
+            const currentCount = typeof meta.interactionCount === "number" ? meta.interactionCount : 0;
+            await runtime.updateRelationship({
+                ...relationship,
+                tags: [
+                    ...new Set([
+                        ...(relationship.tags ?? []),
+                        "relationships",
+                        "conversation",
+                    ]),
+                ],
+                metadata: {
+                    ...meta,
+                    strength: newStrength,
+                    interactionCount: currentCount + 1,
+                    lastInteractionAt: new Date().toISOString(),
+                },
+            });
+            updated++;
+        }
+        else {
+            // Create a new conversation-based relationship.
+            await runtime.createRelationship({
+                sourceEntityId: pair.entityA,
+                targetEntityId: pair.entityB,
+                tags: ["relationships", "conversation", "shared_room"],
+                metadata: {
+                    sentiment: "neutral",
+                    autoDetected: true,
+                    strength: STRENGTH_FLOOR + STRENGTH_INCREMENT * pair.coOccurrences,
+                    relationshipType: "acquaintance",
+                    interactionCount: 1,
+                    lastInteractionAt: new Date().toISOString(),
+                },
+            });
+            updated++;
+        }
+    }
+    return updated;
+}

package/packages/agent/src/services/credential-words.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Credential generation utilities for game integrations (2004scape, etc.).
+ *
+ * Produces human-readable bot usernames from an agent's display name,
+ * combined with a cute random suffix to ensure uniqueness. Passwords
+ * are cryptographically random and stored as secrets.
+ *
+ * @module services/credential-words
+ */
+/**
+ * Generate a unique bot username from an agent's display name.
+ *
+ * Format: `{sanitizedName}{animal}{NN}`
+ * Example: agent "CoolBot" → "coolbotfox42"
+ *
+ * The total length is capped at 12 characters (RuneScape username limit).
+ */
+export declare function generateBotUsername(agentName: string): string;
+/**
+ * Generate a cryptographically random password.
+ *
+ * @param length - Password length (default: 16)
+ * @returns Random password string
+ */
+export declare function generateBotPassword(length?: number): string;
+//# sourceMappingURL=credential-words.d.ts.map

package/packages/agent/src/services/credential-words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-words.d.ts","sourceRoot":"","sources":["../../../../../src/services/credential-words.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAkFH;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAc7D;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,SAAK,GAAG,MAAM,CAKvD"}

package/packages/agent/src/services/credential-words.js

@@ -0,0 +1,116 @@
+/**
+ * Credential generation utilities for game integrations (2004scape, etc.).
+ *
+ * Produces human-readable bot usernames from an agent's display name,
+ * combined with a cute random suffix to ensure uniqueness. Passwords
+ * are cryptographically random and stored as secrets.
+ *
+ * @module services/credential-words
+ */
+import { randomBytes } from "node:crypto";
+/**
+ * Cute animal/nature words used to form memorable bot username suffixes.
+ * Kept short (≤ 5 chars) so the full username stays within RuneScape's
+ * 12-character limit.
+ */
+const CUTE_ANIMALS = [
+    "cat",
+    "fox",
+    "owl",
+    "elk",
+    "bee",
+    "bat",
+    "cod",
+    "eel",
+    "hen",
+    "jay",
+    "pug",
+    "ram",
+    "yak",
+    "ant",
+    "ape",
+    "cub",
+    "doe",
+    "fawn",
+    "kit",
+    "newt",
+    "orca",
+    "puma",
+    "seal",
+    "swan",
+    "toad",
+    "vole",
+    "wasp",
+    "wren",
+    "colt",
+    "crow",
+    "dove",
+    "duck",
+    "frog",
+    "goat",
+    "gull",
+    "hare",
+    "hawk",
+    "ibis",
+    "lamb",
+    "lark",
+    "lynx",
+    "mink",
+    "mole",
+    "moth",
+    "mule",
+    "pika",
+    "slug",
+    "wolf",
+    "bear",
+    "deer",
+];
+/**
+ * Characters used for random password generation.
+ * Avoids ambiguous characters (0/O, 1/l/I) for readability.
+ */
+const PASSWORD_CHARS = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789!@#$%";
+/**
+ * Sanitize a name for use as a RuneScape-style bot username.
+ * - Strips non-alphanumeric characters
+ * - Lowercases
+ * - Truncates to maxLength
+ */
+function sanitizeName(name, maxLength) {
+    return name
+        .replace(/[^a-zA-Z0-9]/g, "")
+        .toLowerCase()
+        .slice(0, maxLength);
+}
+/**
+ * Generate a unique bot username from an agent's display name.
+ *
+ * Format: `{sanitizedName}{animal}{NN}`
+ * Example: agent "CoolBot" → "coolbotfox42"
+ *
+ * The total length is capped at 12 characters (RuneScape username limit).
+ */
+export function generateBotUsername(agentName) {
+    const animal = CUTE_ANIMALS[Math.floor(Math.random() * CUTE_ANIMALS.length)];
+    const num = Math.floor(Math.random() * 100)
+        .toString()
+        .padStart(2, "0");
+    // Reserve space for animal + number suffix
+    const suffixLength = animal.length + num.length;
+    const maxNameLength = Math.max(1, 12 - suffixLength);
+    const sanitized = sanitizeName(agentName, maxNameLength);
+    const base = sanitized.length > 0 ? sanitized : "bot";
+    return `${base}${animal}${num}`;
+}
+/**
+ * Generate a cryptographically random password.
+ *
+ * @param length - Password length (default: 16)
+ * @returns Random password string
+ */
+export function generateBotPassword(length = 16) {
+    const bytes = randomBytes(length);
+    return Array.from(bytes)
+        .map((b) => PASSWORD_CHARS[b % PASSWORD_CHARS.length])
+        .join("");
+}

package/packages/agent/src/services/escalation.d.ts

@@ -0,0 +1,46 @@
+import type { IAgentRuntime } from "@elizaos/core";
+export interface EscalationState {
+    id: string;
+    reason: string;
+    text: string;
+    currentStep: number;
+    channelsSent: string[];
+    startedAt: number;
+    lastSentAt: number;
+    resolved: boolean;
+    resolvedAt?: number;
+}
+/**
+ * Register a channel in the escalation config's ordered channel list.
+ *
+ * Called after a connector pairing succeeds so that the escalation service
+ * can reach the owner on the newly connected platform without manual
+ * configuration. `client_chat` always stays first; new channels are
+ * appended in order of pairing.
+ *
+ * Persists the updated config to `eliza.json` via {@link saveElizaConfig}.
+ * Returns `true` if the channel was newly added, `false` if already present.
+ */
+export declare function registerEscalationChannel(channelName: string): boolean;
+export declare class EscalationService {
+    static startEscalation(runtime: IAgentRuntime, reason: string, text: string): Promise<EscalationState>;
+    static checkEscalation(runtime: IAgentRuntime, escalationId: string): Promise<void>;
+    static resolveEscalation(escalationId: string, runtime?: IAgentRuntime): Promise<void>;
+    static getActiveEscalationSync(): EscalationState | null;
+    static getActiveEscalation(runtime: IAgentRuntime): Promise<EscalationState | null>;
+    /**
+     * Rehydrate unresolved escalations from DB into the in-memory cache.
+     *
+     * Call during agent startup so that escalations created before a restart
+     * are visible to `getActiveEscalationSync()` and can be detected by
+     * the next `processReminders` cycle.
+     *
+     * Timers are intentionally NOT recreated -- the periodic reminder loop
+     * will pick up stale unresolved escalations and advance them.
+     */
+    static rehydrateFromDb(runtime: IAgentRuntime): Promise<void>;
+    static _reset(): void;
+    /** Clear DB state for a given agent. Use in tests alongside `_reset()`. */
+    static _resetDb(runtime: IAgentRuntime): Promise<void>;
+}
+//# sourceMappingURL=escalation.d.ts.map

package/packages/agent/src/services/escalation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalation.d.ts","sourceRoot":"","sources":["../../../../../src/services/escalation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAQ,MAAM,eAAe,CAAC;AAwBzD,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA2FD;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAsDtE;AAyLD,qBAAa,iBAAiB;WACf,eAAe,CAC1B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,eAAe,CAAC;WAoEd,eAAe,CAC1B,OAAO,EAAE,aAAa,EACtB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC;WAgEH,iBAAiB,CAC5B,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC;IAoBhB,MAAM,CAAC,uBAAuB,IAAI,eAAe,GAAG,IAAI;WAO3C,mBAAmB,CAC9B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAalC;;;;;;;;;OASG;WACU,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAUnE,MAAM,CAAC,MAAM,IAAI,IAAI;IAOrB,2EAA2E;WAC9D,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ7D"}