@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

package/dist/packages/agent/src/services/character-history.js

@@ -0,0 +1,280 @@
+import { MemoryType } from "@elizaos/core";
+export const CHARACTER_HISTORY_TABLE = "character_modifications";
+export const MAX_CHARACTER_HISTORY_LIMIT = 100;
+const CHARACTER_HISTORY_FIELDS = [
+    "name",
+    "username",
+    "bio",
+    "system",
+    "adjectives",
+    "topics",
+    "style",
+    "messageExamples",
+    "postExamples",
+];
+const CHARACTER_HISTORY_FIELD_LABELS = {
+    name: "name",
+    username: "username",
+    bio: "bio",
+    system: "system prompt",
+    adjectives: "adjectives",
+    topics: "topics",
+    style: "style",
+    messageExamples: "message examples",
+    postExamples: "post examples",
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function cloneIfDefined(value) {
+    return value === undefined ? value : cloneJson(value);
+}
+function normalizeForCompare(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeForCompare(entry));
+    }
+    if (isRecord(value)) {
+        const normalized = {};
+        for (const key of Object.keys(value).sort()) {
+            normalized[key] = normalizeForCompare(value[key]);
+        }
+        return normalized;
+    }
+    return value;
+}
+function areEqualForHistory(previous, next) {
+    return (JSON.stringify(normalizeForCompare(previous)) ===
+        JSON.stringify(normalizeForCompare(next)));
+}
+function hasOwnField(snapshot, field) {
+    return Object.hasOwn(snapshot, field);
+}
+function coerceHistorySource(value) {
+    return value === "manual" || value === "agent" || value === "restore"
+        ? value
+        : "agent";
+}
+function buildHistorySummary(source, fieldsChanged) {
+    const sourceLabel = source === "manual"
+        ? "Manual edit"
+        : source === "restore"
+            ? "Restore"
+            : "Agent update";
+    const fieldLabels = fieldsChanged.map((field) => CHARACTER_HISTORY_FIELD_LABELS[field]);
+    if (fieldLabels.length === 0) {
+        return `${sourceLabel} saved`;
+    }
+    if (fieldLabels.length === 1) {
+        return `${sourceLabel} changed ${fieldLabels[0]}`;
+    }
+    return `${sourceLabel} changed ${fieldLabels.join(", ")}`;
+}
+function toCharacterHistoryValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => toCharacterHistoryValue(entry) ?? null);
+    }
+    if (isRecord(value)) {
+        const normalized = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const normalizedEntry = toCharacterHistoryValue(entry);
+            if (normalizedEntry !== undefined) {
+                normalized[key] = normalizedEntry;
+            }
+        }
+        return normalized;
+    }
+    return undefined;
+}
+export function buildCharacterHistorySnapshot(character) {
+    const snapshot = {};
+    if (typeof character.name === "string" && character.name.trim()) {
+        snapshot.name = character.name.trim();
+    }
+    if (typeof character.username === "string" && character.username.trim()) {
+        snapshot.username = character.username.trim();
+    }
+    if (Array.isArray(character.bio)) {
+        snapshot.bio = [...character.bio];
+    }
+    else if (typeof character.bio === "string" && character.bio.trim()) {
+        snapshot.bio = [character.bio];
+    }
+    if (typeof character.system === "string") {
+        snapshot.system = character.system;
+    }
+    if (Array.isArray(character.adjectives)) {
+        snapshot.adjectives = [...character.adjectives];
+    }
+    if (Array.isArray(character.topics)) {
+        snapshot.topics = [...character.topics];
+    }
+    if (character.style) {
+        const style = {
+            ...(Array.isArray(character.style.all)
+                ? { all: [...character.style.all] }
+                : {}),
+            ...(Array.isArray(character.style.chat)
+                ? { chat: [...character.style.chat] }
+                : {}),
+            ...(Array.isArray(character.style.post)
+                ? { post: [...character.style.post] }
+                : {}),
+        };
+        if (Object.keys(style).length > 0) {
+            snapshot.style = style;
+        }
+    }
+    if (Array.isArray(character.messageExamples)) {
+        const messageExamples = toCharacterHistoryValue(character.messageExamples);
+        if (Array.isArray(messageExamples)) {
+            snapshot.messageExamples = messageExamples;
+        }
+    }
+    if (Array.isArray(character.postExamples)) {
+        snapshot.postExamples = [...character.postExamples];
+    }
+    return snapshot;
+}
+export function diffCharacterHistorySnapshots(previous, next) {
+    const changes = [];
+    for (const field of CHARACTER_HISTORY_FIELDS) {
+        const previousHasField = hasOwnField(previous, field);
+        const nextHasField = hasOwnField(next, field);
+        const previousValue = previous[field];
+        const nextValue = next[field];
+        if (!previousHasField && !nextHasField) {
+            continue;
+        }
+        if (areEqualForHistory(previousValue, nextValue)) {
+            continue;
+        }
+        changes.push({
+            field,
+            ...(previousHasField ? { before: cloneIfDefined(previousValue) } : {}),
+            ...(nextHasField ? { after: cloneIfDefined(nextValue) } : {}),
+        });
+    }
+    return changes;
+}
+export async function recordCharacterHistory(runtime, params) {
+    const previousSnapshot = buildCharacterHistorySnapshot(params.previousCharacter ?? {});
+    const nextSnapshot = buildCharacterHistorySnapshot(params.nextCharacter);
+    const changes = diffCharacterHistorySnapshots(previousSnapshot, nextSnapshot);
+    if (changes.length === 0) {
+        return null;
+    }
+    const timestamp = params.timestamp ?? Date.now();
+    const source = params.source;
+    const fieldsChanged = changes.map((change) => change.field);
+    const summary = buildHistorySummary(source, fieldsChanged);
+    await runtime.createMemory({
+        entityId: runtime.agentId,
+        roomId: params.roomId ?? runtime.agentId,
+        content: {
+            text: summary,
+            source: "character_history",
+        },
+        metadata: {
+            type: MemoryType.CUSTOM,
+            service: "character_history",
+            action: source === "restore" ? "character_restored" : "character_updated",
+            timestamp,
+            historySource: source,
+            fieldsChanged,
+            changes,
+            before: previousSnapshot,
+            after: nextSnapshot,
+        },
+    }, CHARACTER_HISTORY_TABLE);
+    return {
+        timestamp,
+        source,
+        summary,
+        fieldsChanged,
+        changes,
+        before: previousSnapshot,
+        after: nextSnapshot,
+    };
+}
+export function parseCharacterHistoryEntry(memory) {
+    const metadata = isRecord(memory.metadata) ? memory.metadata : null;
+    if (!metadata) {
+        return null;
+    }
+    const action = metadata.action;
+    if (action !== "character_updated" && action !== "character_restored") {
+        return null;
+    }
+    const rawChanges = metadata.changes;
+    if (!Array.isArray(rawChanges) || rawChanges.length === 0) {
+        return null;
+    }
+    const changes = [];
+    for (const rawChange of rawChanges) {
+        if (!isRecord(rawChange)) {
+            return null;
+        }
+        const field = rawChange.field;
+        if (typeof field !== "string" ||
+            !CHARACTER_HISTORY_FIELDS.includes(field)) {
+            return null;
+        }
+        const before = Object.hasOwn(rawChange, "before")
+            ? toCharacterHistoryValue(rawChange.before)
+            : undefined;
+        const after = Object.hasOwn(rawChange, "after")
+            ? toCharacterHistoryValue(rawChange.after)
+            : undefined;
+        changes.push({
+            field: field,
+            ...(before !== undefined ? { before } : {}),
+            ...(after !== undefined ? { after } : {}),
+        });
+    }
+    const fieldsChanged = changes.map((change) => change.field);
+    const timestamp = typeof metadata.timestamp === "number"
+        ? metadata.timestamp
+        : typeof memory.createdAt === "number"
+            ? memory.createdAt
+            : 0;
+    return {
+        id: typeof memory.id === "string" ? memory.id : undefined,
+        timestamp,
+        source: coerceHistorySource(metadata.historySource),
+        summary: typeof memory.content.text === "string" && memory.content.text.trim()
+            ? memory.content.text
+            : buildHistorySummary(coerceHistorySource(metadata.historySource), fieldsChanged),
+        fieldsChanged,
+        changes,
+        before: isRecord(metadata.before)
+            ? cloneJson(metadata.before)
+            : {},
+        after: isRecord(metadata.after)
+            ? cloneJson(metadata.after)
+            : {},
+    };
+}
+export async function listCharacterHistory(runtime, limit = 20) {
+    const safeLimit = Math.min(Math.max(Math.trunc(limit) || 20, 1), MAX_CHARACTER_HISTORY_LIMIT);
+    const memories = await runtime.getMemories({
+        entityId: runtime.agentId,
+        count: Math.max(safeLimit * 4, safeLimit),
+        tableName: CHARACTER_HISTORY_TABLE,
+    });
+    return memories
+        .map((memory) => parseCharacterHistoryEntry(memory))
+        .filter((entry) => entry !== null)
+        .sort((left, right) => right.timestamp - left.timestamp)
+        .slice(0, safeLimit);
+}

package/dist/packages/agent/src/services/character-persistence.d.ts

@@ -0,0 +1,25 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import { type ElizaConfig } from "../config/config.ts";
+import { type CharacterHistorySource, type RuntimeCharacterLike } from "./character-history.ts";
+export declare const CHARACTER_PERSISTENCE_SERVICE = "eliza_character_persistence";
+type PersistCharacterParams = {
+    character?: RuntimeCharacterLike;
+    previousCharacter?: RuntimeCharacterLike;
+    previousName?: string;
+    source?: CharacterHistorySource;
+};
+type PersistCharacterResult = {
+    success: boolean;
+    error?: string;
+};
+type AgentConfigLike = NonNullable<ElizaConfig["agents"]>["list"] extends Array<infer T> | undefined ? T : never;
+export declare function syncCharacterIntoConfig(config: ElizaConfig, character: RuntimeCharacterLike): AgentConfigLike;
+export declare class ElizaCharacterPersistenceService extends Service {
+    static serviceType: string;
+    static start(runtime: IAgentRuntime): Promise<ElizaCharacterPersistenceService>;
+    capabilityDescription: string;
+    persistCharacter(params?: PersistCharacterParams): Promise<PersistCharacterResult>;
+    stop(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=character-persistence.d.ts.map

package/dist/packages/agent/src/services/character-persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-persistence.d.ts","sourceRoot":"","sources":["../../../../../src/services/character-persistence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAU,OAAO,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EACL,KAAK,WAAW,EAGjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAE1B,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,6BAA6B,gCAAgC,CAAC;AAE3E,KAAK,sBAAsB,GAAG;IAC5B,SAAS,CAAC,EAAE,oBAAoB,CAAC;IACjC,iBAAiB,CAAC,EAAE,oBAAoB,CAAC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,sBAAsB,CAAC;CACjC,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,eAAe,GAAG,WAAW,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,SAC7D,KAAK,CAAC,MAAM,CAAC,CAAC,GACd,SAAS,GACT,CAAC,GACD,KAAK,CAAC;AAcV,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,oBAAoB,GAC9B,eAAe,CAoEjB;AA+CD,qBAAa,gCAAiC,SAAQ,OAAO;IAC3D,MAAM,CAAC,WAAW,SAAiC;WAEtC,KAAK,CAChB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,gCAAgC,CAAC;IAI5C,qBAAqB,SAC8D;IAE7E,gBAAgB,CACpB,MAAM,GAAE,sBAA2B,GAClC,OAAO,CAAC,sBAAsB,CAAC;IA0D5B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAC5B"}

package/dist/packages/agent/src/services/character-persistence.js

@@ -0,0 +1,167 @@
+import { logger, Service } from "@elizaos/core";
+import { loadElizaConfig, saveElizaConfig, } from "../config/config.js";
+import { recordCharacterHistory, } from "./character-history.js";
+export const CHARACTER_PERSISTENCE_SERVICE = "eliza_character_persistence";
+function cloneStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const strings = value.filter((entry) => typeof entry === "string" && entry.length > 0);
+    return strings.length > 0 ? [...strings] : [];
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function syncCharacterIntoConfig(config, character) {
+    if (!config.agents)
+        config.agents = {};
+    const existingList = config.agents.list ?? [];
+    const primaryAgent = existingList[0] ?? {
+        id: "main",
+        default: true,
+    };
+    const nextAgent = {
+        ...primaryAgent,
+        ...(typeof character.name === "string" && character.name.trim()
+            ? { name: character.name.trim() }
+            : {}),
+        ...(typeof character.username === "string" && character.username.trim()
+            ? { username: character.username.trim() }
+            : {}),
+        ...(Array.isArray(character.bio)
+            ? { bio: cloneStringArray(character.bio) }
+            : typeof character.bio === "string" && character.bio.trim()
+                ? { bio: [character.bio] }
+                : {}),
+        ...(typeof character.system === "string"
+            ? { system: character.system }
+            : {}),
+        ...(Array.isArray(character.adjectives)
+            ? { adjectives: cloneStringArray(character.adjectives) }
+            : {}),
+        ...(Array.isArray(character.topics)
+            ? { topics: cloneStringArray(character.topics) }
+            : {}),
+        ...(character.style
+            ? {
+                style: {
+                    ...(Array.isArray(character.style.all)
+                        ? { all: [...character.style.all] }
+                        : {}),
+                    ...(Array.isArray(character.style.chat)
+                        ? { chat: [...character.style.chat] }
+                        : {}),
+                    ...(Array.isArray(character.style.post)
+                        ? { post: [...character.style.post] }
+                        : {}),
+                },
+            }
+            : {}),
+        ...(Array.isArray(character.postExamples)
+            ? { postExamples: cloneStringArray(character.postExamples) }
+            : {}),
+        ...(Array.isArray(character.messageExamples)
+            ? { messageExamples: cloneJson(character.messageExamples) }
+            : {}),
+    };
+    config.agents.list = [nextAgent, ...existingList.slice(1)];
+    config.ui ??= {};
+    const uiConfig = config.ui;
+    if (typeof nextAgent.name === "string" && nextAgent.name.trim()) {
+        uiConfig.assistant = {
+            ...(uiConfig.assistant ?? {}),
+            name: nextAgent.name,
+        };
+    }
+    return nextAgent;
+}
+function buildPersistedCharacterData(character) {
+    const persisted = {};
+    if (typeof character.name === "string" && character.name.trim()) {
+        persisted.name = character.name.trim();
+    }
+    if (typeof character.username === "string" && character.username.trim()) {
+        persisted.username = character.username.trim();
+    }
+    if (Array.isArray(character.bio)) {
+        persisted.bio = [...character.bio];
+    }
+    else if (typeof character.bio === "string" && character.bio.trim()) {
+        persisted.bio = [character.bio];
+    }
+    if (typeof character.system === "string") {
+        persisted.system = character.system;
+    }
+    if (Array.isArray(character.adjectives)) {
+        persisted.adjectives = [...character.adjectives];
+    }
+    if (Array.isArray(character.topics)) {
+        persisted.topics = [...character.topics];
+    }
+    if (character.style) {
+        persisted.style = cloneJson(character.style);
+    }
+    if (Array.isArray(character.messageExamples)) {
+        persisted.messageExamples = cloneJson(character.messageExamples);
+    }
+    if (Array.isArray(character.postExamples)) {
+        persisted.postExamples = [...character.postExamples];
+    }
+    if (character.settings &&
+        typeof character.settings === "object" &&
+        !Array.isArray(character.settings)) {
+        persisted.settings = cloneJson(character.settings);
+    }
+    return persisted;
+}
+export class ElizaCharacterPersistenceService extends Service {
+    static serviceType = CHARACTER_PERSISTENCE_SERVICE;
+    static async start(runtime) {
+        return new ElizaCharacterPersistenceService(runtime);
+    }
+    capabilityDescription = "Persists runtime character changes to Eliza config, agent storage, and history";
+    async persistCharacter(params = {}) {
+        const runtimeCharacter = (params.character ??
+            this.runtime.character);
+        const previousCharacter = (params.previousCharacter ??
+            this.runtime.character);
+        try {
+            const config = loadElizaConfig();
+            const nextAgent = syncCharacterIntoConfig(config, runtimeCharacter);
+            saveElizaConfig(config);
+            const persistedCharacter = buildPersistedCharacterData(runtimeCharacter);
+            const runtimeMetadata = runtimeCharacter.metadata &&
+                typeof runtimeCharacter.metadata === "object" &&
+                !Array.isArray(runtimeCharacter.metadata)
+                ? runtimeCharacter.metadata
+                : {};
+            await this.runtime.updateAgent(this.runtime.agentId, {
+                name: (typeof nextAgent.name === "string" && nextAgent.name.trim()) ||
+                    this.runtime.character.name,
+                metadata: {
+                    ...runtimeMetadata,
+                    character: persistedCharacter,
+                },
+            });
+            await recordCharacterHistory(this.runtime, {
+                previousCharacter,
+                nextCharacter: runtimeCharacter,
+                source: params.source ?? "agent",
+            });
+            logger.info({
+                agentId: this.runtime.agentId,
+                fields: Object.keys(persistedCharacter),
+            }, "Persisted runtime character changes");
+            return { success: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({
+                agentId: this.runtime.agentId,
+                previousName: params.previousName,
+                error: message,
+            }, "Failed to persist runtime character changes");
+            return { success: false, error: message };
+        }
+    }
+    async stop() { }
+}

package/dist/packages/agent/src/services/client-chat-sender.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Registers a send handler for the "client_chat" source so the agent can
+ * proactively push messages to connected Eliza app clients.
+ *
+ * The handler persists the message to the DB and broadcasts it over
+ * WebSocket so the UI updates in real time. If no WS clients are
+ * connected, the message is still persisted and will appear when the
+ * app reconnects.
+ */
+import { type IAgentRuntime } from "@elizaos/core";
+import type { ServerState } from "../api/server-types.ts";
+/**
+ * Register the `client_chat` send handler on the given runtime.
+ *
+ * Must be called after the WebSocket server is set up (so that
+ * `state.broadcastWs` is available).
+ */
+export declare function registerClientChatSendHandler(runtime: IAgentRuntime, state: ServerState): void;
+//# sourceMappingURL=client-chat-sender.d.ts.map

package/dist/packages/agent/src/services/client-chat-sender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-chat-sender.d.ts","sourceRoot":"","sources":["../../../../../src/services/client-chat-sender.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,wBAAwB,CAAC;AA4C5E;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,WAAW,GACjB,IAAI,CAyCN"}

package/dist/packages/agent/src/services/client-chat-sender.js

@@ -0,0 +1,88 @@
+/**
+ * Registers a send handler for the "client_chat" source so the agent can
+ * proactively push messages to connected Eliza app clients.
+ *
+ * The handler persists the message to the DB and broadcasts it over
+ * WebSocket so the UI updates in real time. If no WS clients are
+ * connected, the message is still persisted and will appear when the
+ * app reconnects.
+ */
+import crypto from "node:crypto";
+import { createMessageMemory, } from "@elizaos/core";
+/**
+ * Resolve the best conversation for a given roomId by scanning the
+ * server-side conversation map. Returns undefined when no match exists.
+ */
+function findConversationByRoomId(state, roomId) {
+    for (const conv of state.conversations.values()) {
+        if (conv.roomId === roomId)
+            return conv;
+    }
+    return undefined;
+}
+/**
+ * Resolve the target conversation using the same priority chain as
+ * {@link routeAutonomyTextToUser}: explicit roomId -> active conversation
+ * -> most-recently-updated conversation.
+ */
+function resolveConversation(state, roomId) {
+    // 1. Explicit room
+    if (roomId) {
+        const conv = findConversationByRoomId(state, roomId);
+        if (conv)
+            return conv;
+    }
+    // 2. Active conversation (set by the UI via WS "active-conversation" msg)
+    if (state.activeConversationId) {
+        const conv = state.conversations.get(state.activeConversationId);
+        if (conv)
+            return conv;
+    }
+    // 3. Most recently updated conversation
+    const sorted = Array.from(state.conversations.values()).sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    return sorted[0];
+}
+/**
+ * Register the `client_chat` send handler on the given runtime.
+ *
+ * Must be called after the WebSocket server is set up (so that
+ * `state.broadcastWs` is available).
+ */
+export function registerClientChatSendHandler(runtime, state) {
+    if (typeof runtime.registerSendHandler !== "function") {
+        return;
+    }
+    runtime.registerSendHandler("client_chat", async (_rt, target, content) => {
+        const conv = resolveConversation(state, target.roomId);
+        if (!conv) {
+            // No conversations exist yet — persist nothing, but don't throw.
+            // The message will be lost; this is acceptable during early boot
+            // before the user has opened the app.
+            return;
+        }
+        const messageId = crypto.randomUUID();
+        const agentMessage = createMessageMemory({
+            id: messageId,
+            entityId: runtime.agentId,
+            roomId: conv.roomId,
+            content: {
+                ...content,
+                text: content.text ?? "",
+                source: "client_chat",
+            },
+        });
+        await runtime.createMemory(agentMessage, "messages");
+        conv.updatedAt = new Date().toISOString();
+        state.broadcastWs?.({
+            type: "proactive-message",
+            conversationId: conv.id,
+            message: {
+                id: messageId,
+                role: "assistant",
+                text: content.text ?? "",
+                timestamp: Date.now(),
+                source: "client_chat",
+            },
+        });
+    });
+}

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

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

package/dist/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/dist/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");
+        },
+    };
+}