@elizaos/agent 0.25.8 → 2.0.0-alpha.83

package/packages/agent/src/cloud/cloud-manager.js

@@ -0,0 +1,119 @@
+/**
+ * Top-level orchestrator for cloud integration.
+ * Manages client, proxy, backup scheduler, and connection monitor lifecycle.
+ */
+import { logger } from "@elizaos/core";
+import { BackupScheduler } from "./backup";
+import { normalizeCloudSiteUrl } from "./base-url";
+import { ElizaCloudClient } from "./bridge-client";
+import { CloudRuntimeProxy } from "./cloud-proxy";
+import { ConnectionMonitor } from "./reconnect";
+import { validateCloudBaseUrl } from "./validate-url";
+export class CloudManager {
+    cloudConfig;
+    callbacks;
+    client = null;
+    proxy = null;
+    backupScheduler = null;
+    connectionMonitor = null;
+    status = "disconnected";
+    activeAgentId = null;
+    constructor(cloudConfig, callbacks = {}) {
+        this.cloudConfig = cloudConfig;
+        this.callbacks = callbacks;
+    }
+    async init() {
+        const rawUrl = normalizeCloudSiteUrl(this.cloudConfig.baseUrl);
+        const apiKey = this.cloudConfig.apiKey;
+        if (!apiKey)
+            throw new Error("Cloud API key is not configured. Run cloud login first.");
+        const urlError = await validateCloudBaseUrl(rawUrl);
+        if (urlError) {
+            throw new Error(urlError);
+        }
+        const siteUrl = normalizeCloudSiteUrl(rawUrl);
+        this.client = new ElizaCloudClient(siteUrl, apiKey);
+        logger.info(`[cloud-manager] Client initialised (baseUrl=${siteUrl})`);
+    }
+    async connect(agentId) {
+        if (!this.client)
+            await this.init();
+        if (!this.client)
+            throw new Error("Cloud client failed to initialise");
+        this.setStatus("connecting");
+        this.activeAgentId = agentId;
+        try {
+            await this.client.provision(agentId);
+            const agent = await this.client.getAgent(agentId);
+            this.proxy = new CloudRuntimeProxy(this.client, agentId, agent.agentName);
+            this.backupScheduler = new BackupScheduler(this.client, agentId, this.cloudConfig.backup?.autoBackupIntervalMs ?? 60_000);
+            this.backupScheduler.start();
+            this.connectionMonitor = new ConnectionMonitor(this.client, agentId, {
+                onDisconnect: () => this.setStatus("reconnecting"),
+                onReconnect: () => this.setStatus("connected"),
+                onStatusChange: (s) => {
+                    if (s === "connected")
+                        this.setStatus("connected");
+                    else if (s === "reconnecting")
+                        this.setStatus("reconnecting");
+                    else
+                        this.setStatus("error");
+                },
+            }, this.cloudConfig.bridge?.heartbeatIntervalMs ?? 30_000);
+            this.connectionMonitor.start();
+            this.setStatus("connected");
+            logger.info(`[cloud-manager] Connected to cloud agent (agentId=${agentId}, agentName=${agent.agentName})`);
+            return this.proxy;
+        }
+        catch (err) {
+            this.setStatus("error");
+            if (this.backupScheduler) {
+                this.backupScheduler.stop();
+                this.backupScheduler = null;
+            }
+            if (this.connectionMonitor) {
+                this.connectionMonitor.stop();
+                this.connectionMonitor = null;
+            }
+            this.proxy = null;
+            this.activeAgentId = null;
+            this.setStatus("disconnected");
+            throw err;
+        }
+    }
+    async disconnect() {
+        if (this.backupScheduler) {
+            await this.backupScheduler.finalSnapshot();
+            this.backupScheduler.stop();
+            this.backupScheduler = null;
+        }
+        if (this.connectionMonitor) {
+            this.connectionMonitor.stop();
+            this.connectionMonitor = null;
+        }
+        this.proxy = null;
+        this.activeAgentId = null;
+        this.setStatus("disconnected");
+    }
+    getProxy() {
+        return this.proxy;
+    }
+    getClient() {
+        return this.client;
+    }
+    getActiveAgentId() {
+        return this.activeAgentId;
+    }
+    getStatus() {
+        return this.status;
+    }
+    isEnabled() {
+        return Boolean(this.cloudConfig.enabled && this.cloudConfig.apiKey);
+    }
+    setStatus(status) {
+        if (this.status === status)
+            return;
+        this.status = status;
+        this.callbacks.onStatusChange?.(status);
+    }
+}

package/packages/agent/src/cloud/cloud-proxy.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Drop-in replacement for a local AgentRuntime when running in cloud mode.
+ * Routes chat/status calls through the ElizaCloudClient to the remote sandbox.
+ */
+import type { ChatChannelType, ElizaCloudClient } from "./bridge-client";
+export declare class CloudRuntimeProxy {
+    private client;
+    private agentId;
+    private _agentName;
+    constructor(client: ElizaCloudClient, agentId: string, _agentName: string);
+    get agentName(): string;
+    handleChatMessage(text: string, roomId?: string, channelType?: ChatChannelType): Promise<string>;
+    handleChatMessageStream(text: string, roomId?: string, channelType?: ChatChannelType): AsyncGenerator<string>;
+    getStatus(): Promise<{
+        state: string;
+        agentName: string;
+    }>;
+    isAlive(): Promise<boolean>;
+}
+//# sourceMappingURL=cloud-proxy.d.ts.map

package/packages/agent/src/cloud/cloud-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-proxy.d.ts","sourceRoot":"","sources":["../../../../../src/cloud/cloud-proxy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEzE,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,UAAU;gBAFV,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM;IAG5B,IAAI,SAAS,IAAI,MAAM,CAEtB;IAEK,iBAAiB,CACrB,IAAI,EAAE,MAAM,EACZ,MAAM,SAAa,EACnB,WAAW,GAAE,eAAsB,GAClC,OAAO,CAAC,MAAM,CAAC;IAIX,uBAAuB,CAC5B,IAAI,EAAE,MAAM,EACZ,MAAM,SAAa,EACnB,WAAW,GAAE,eAAsB,GAClC,cAAc,CAAC,MAAM,CAAC;IAanB,SAAS,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAK1D,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CAGlC"}

package/packages/agent/src/cloud/cloud-proxy.js

@@ -0,0 +1,34 @@
+/**
+ * Drop-in replacement for a local AgentRuntime when running in cloud mode.
+ * Routes chat/status calls through the ElizaCloudClient to the remote sandbox.
+ */
+export class CloudRuntimeProxy {
+    client;
+    agentId;
+    _agentName;
+    constructor(client, agentId, _agentName) {
+        this.client = client;
+        this.agentId = agentId;
+        this._agentName = _agentName;
+    }
+    get agentName() {
+        return this._agentName;
+    }
+    async handleChatMessage(text, roomId = "web-chat", channelType = "DM") {
+        return this.client.sendMessage(this.agentId, text, roomId, channelType);
+    }
+    async *handleChatMessageStream(text, roomId = "web-chat", channelType = "DM") {
+        for await (const event of this.client.sendMessageStream(this.agentId, text, roomId, channelType)) {
+            if (event.type === "chunk" && typeof event.data.text === "string") {
+                yield event.data.text;
+            }
+        }
+    }
+    async getStatus() {
+        const agent = await this.client.getAgent(this.agentId);
+        return { state: agent.status, agentName: agent.agentName };
+    }
+    async isAlive() {
+        return this.client.heartbeat(this.agentId).catch(() => false);
+    }
+}

package/packages/agent/src/cloud/index.d.ts

@@ -0,0 +1,7 @@
+export { type CloudLoginOptions, type CloudLoginResult, cloudLogin, } from "./auth";
+export { BackupScheduler } from "./backup";
+export { type BackupInfo, type CloudAgent, type CloudAgentCreateParams, ElizaCloudClient, type ProvisionInfo, } from "./bridge-client";
+export { type CloudConnectionStatus, CloudManager, type CloudManagerCallbacks, } from "./cloud-manager";
+export { CloudRuntimeProxy } from "./cloud-proxy";
+export { ConnectionMonitor, type ConnectionMonitorCallbacks, } from "./reconnect";
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/src/cloud/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/cloud/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,UAAU,GACX,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,KAAK,aAAa,GACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,qBAAqB,EAC1B,YAAY,EACZ,KAAK,qBAAqB,GAC3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,iBAAiB,EACjB,KAAK,0BAA0B,GAChC,MAAM,aAAa,CAAC"}

package/packages/agent/src/cloud/index.js

@@ -0,0 +1,6 @@
+export { cloudLogin, } from "./auth";
+export { BackupScheduler } from "./backup";
+export { ElizaCloudClient, } from "./bridge-client";
+export { CloudManager, } from "./cloud-manager";
+export { CloudRuntimeProxy } from "./cloud-proxy";
+export { ConnectionMonitor, } from "./reconnect";

package/packages/agent/src/cloud/reconnect.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Heartbeat monitor with auto-reconnect via exponential backoff.
+ */
+import type { ElizaCloudClient } from "./bridge-client";
+export interface ConnectionMonitorCallbacks {
+    onDisconnect: () => void;
+    onReconnect: () => void;
+    onStatusChange?: (status: "connected" | "reconnecting" | "disconnected") => void;
+}
+export declare class ConnectionMonitor {
+    private client;
+    private agentId;
+    private callbacks;
+    private heartbeatIntervalMs;
+    private maxFailures;
+    private timer;
+    private consecutiveFailures;
+    private reconnecting;
+    constructor(client: ElizaCloudClient, agentId: string, callbacks: ConnectionMonitorCallbacks, heartbeatIntervalMs?: number, maxFailures?: number);
+    start(): void;
+    stop(): void;
+    isMonitoring(): boolean;
+    private tick;
+    private attemptReconnect;
+}
+//# sourceMappingURL=reconnect.d.ts.map

package/packages/agent/src/cloud/reconnect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconnect.d.ts","sourceRoot":"","sources":["../../../../../src/cloud/reconnect.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,WAAW,0BAA0B;IACzC,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,cAAc,CAAC,EAAE,CACf,MAAM,EAAE,WAAW,GAAG,cAAc,GAAG,cAAc,KAClD,IAAI,CAAC;CACX;AAED,qBAAa,iBAAiB;IAM1B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,WAAW;IATrB,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,YAAY,CAAS;gBAGnB,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,0BAA0B,EACrC,mBAAmB,GAAE,MAAe,EACpC,WAAW,GAAE,MAAU;IAGjC,KAAK,IAAI,IAAI;IAWb,IAAI,IAAI,IAAI;IAUZ,YAAY,IAAI,OAAO;YAIT,IAAI;YAyBJ,gBAAgB;CA6B/B"}

package/packages/agent/src/cloud/reconnect.js

@@ -0,0 +1,86 @@
+/**
+ * Heartbeat monitor with auto-reconnect via exponential backoff.
+ */
+import { logger } from "@elizaos/core";
+export class ConnectionMonitor {
+    client;
+    agentId;
+    callbacks;
+    heartbeatIntervalMs;
+    maxFailures;
+    timer = null;
+    consecutiveFailures = 0;
+    reconnecting = false;
+    constructor(client, agentId, callbacks, heartbeatIntervalMs = 30_000, maxFailures = 3) {
+        this.client = client;
+        this.agentId = agentId;
+        this.callbacks = callbacks;
+        this.heartbeatIntervalMs = heartbeatIntervalMs;
+        this.maxFailures = maxFailures;
+    }
+    start() {
+        if (this.timer)
+            return;
+        logger.info(`[cloud-monitor] Starting connection monitor (interval: ${this.heartbeatIntervalMs}ms, maxFailures: ${this.maxFailures})`);
+        this.consecutiveFailures = 0;
+        this.timer = setInterval(() => {
+            this.tick();
+        }, this.heartbeatIntervalMs);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.consecutiveFailures = 0;
+        this.reconnecting = false;
+        logger.info("[cloud-monitor] Connection monitor stopped");
+    }
+    isMonitoring() {
+        return this.timer !== null;
+    }
+    async tick() {
+        if (this.reconnecting)
+            return;
+        const alive = await this.client.heartbeat(this.agentId).catch(() => false);
+        if (alive) {
+            if (this.consecutiveFailures > 0) {
+                this.consecutiveFailures = 0;
+                this.callbacks.onStatusChange?.("connected");
+            }
+            return;
+        }
+        this.consecutiveFailures++;
+        logger.warn(`[cloud-monitor] Heartbeat failed (${this.consecutiveFailures}/${this.maxFailures})`);
+        if (this.consecutiveFailures >= this.maxFailures) {
+            this.callbacks.onStatusChange?.("disconnected");
+            this.callbacks.onDisconnect();
+            await this.attemptReconnect();
+        }
+    }
+    async attemptReconnect() {
+        this.reconnecting = true;
+        this.callbacks.onStatusChange?.("reconnecting");
+        let delay = 3_000;
+        for (let attempt = 1; attempt <= 10; attempt++) {
+            logger.info(`[cloud-monitor] Reconnect attempt ${attempt}/10...`);
+            const ok = await this.client
+                .provision(this.agentId)
+                .then(() => true)
+                .catch(() => false);
+            if (ok) {
+                logger.info("[cloud-monitor] Reconnection successful");
+                this.consecutiveFailures = 0;
+                this.reconnecting = false;
+                this.callbacks.onStatusChange?.("connected");
+                this.callbacks.onReconnect();
+                return;
+            }
+            await new Promise((r) => setTimeout(r, delay));
+            delay = Math.min(delay * 2, 60_000);
+        }
+        logger.error("[cloud-monitor] Failed to reconnect after 10 attempts");
+        this.reconnecting = false;
+        this.callbacks.onStatusChange?.("disconnected");
+    }
+}

package/packages/agent/src/cloud/validate-url.d.ts

@@ -0,0 +1,2 @@
+export declare function validateCloudBaseUrl(rawUrl: string): Promise<string | null>;
+//# sourceMappingURL=validate-url.d.ts.map

package/packages/agent/src/cloud/validate-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-url.d.ts","sourceRoot":"","sources":["../../../../../src/cloud/validate-url.ts"],"names":[],"mappings":"AA4HA,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsDxB"}

package/packages/agent/src/cloud/validate-url.js

@@ -0,0 +1,162 @@
+import dns from "node:dns";
+import net from "node:net";
+import { promisify } from "node:util";
+const dnsLookupAll = promisify(dns.lookup);
+const BLOCKED_IPV4_CIDRS = [
+    cidrV4("0.0.0.0", 8),
+    cidrV4("10.0.0.0", 8),
+    cidrV4("172.16.0.0", 12),
+    cidrV4("192.168.0.0", 16),
+    cidrV4("100.64.0.0", 10),
+    cidrV4("127.0.0.0", 8),
+    cidrV4("169.254.0.0", 16),
+    cidrV4("192.0.0.0", 24),
+    cidrV4("198.18.0.0", 15),
+    cidrV4("192.0.2.0", 24),
+    cidrV4("198.51.100.0", 24),
+    cidrV4("203.0.113.0", 24),
+    cidrV4("224.0.0.0", 4),
+    cidrV4("240.0.0.0", 4),
+];
+function normalizeHostLike(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/^\[|\]$/g, "");
+}
+function decodeIpv6MappedHex(mapped) {
+    const parts = mapped.split(":");
+    if (parts.length < 1 || parts.length > 2)
+        return null;
+    const parsed = parts.map((part) => {
+        if (!/^[0-9a-f]{1,4}$/i.test(part))
+            return Number.NaN;
+        return Number.parseInt(part, 16);
+    });
+    if (parsed.some((value) => !Number.isFinite(value)))
+        return null;
+    const [hi, lo] = parsed.length === 1 ? [0, parsed[0]] : parsed;
+    const octets = [hi >> 8, hi & 0xff, lo >> 8, lo & 0xff];
+    return octets.join(".");
+}
+function canonicalizeIpv6(ip) {
+    try {
+        return new URL(`http://[${ip}]/`).hostname.replace(/^\[|\]$/g, "");
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeIpForPolicy(ip) {
+    const base = normalizeHostLike(ip).split("%")[0];
+    if (!base)
+        return base;
+    let normalized = base;
+    if (net.isIP(normalized) === 6) {
+        normalized = canonicalizeIpv6(normalized) ?? normalized;
+    }
+    let mapped = null;
+    if (normalized.startsWith("::ffff:")) {
+        mapped = normalized.slice("::ffff:".length);
+    }
+    else if (normalized.startsWith("0:0:0:0:0:ffff:")) {
+        mapped = normalized.slice("0:0:0:0:0:ffff:".length);
+    }
+    if (!mapped)
+        return normalized;
+    if (net.isIP(mapped) === 4)
+        return mapped;
+    return decodeIpv6MappedHex(mapped) ?? normalized;
+}
+function cidrV4(base, prefix) {
+    const parsed = parseIpv4ToInt(base);
+    if (parsed === null) {
+        throw new Error(`Invalid CIDR base IPv4 address: ${base}`);
+    }
+    const shift = 32 - prefix;
+    const mask = shift === 32 ? 0 : (0xffffffff << shift) >>> 0;
+    return { base: parsed & mask, mask };
+}
+function parseIpv4ToInt(ip) {
+    const parts = ip.split(".");
+    if (parts.length !== 4)
+        return null;
+    let value = 0;
+    for (const part of parts) {
+        if (!/^\d{1,3}$/.test(part))
+            return null;
+        const octet = Number.parseInt(part, 10);
+        if (!Number.isInteger(octet) || octet < 0 || octet > 255)
+            return null;
+        value = (value << 8) | octet;
+    }
+    return value >>> 0;
+}
+function isBlockedIpv4(ip) {
+    const asInt = parseIpv4ToInt(ip);
+    if (asInt === null)
+        return true;
+    return BLOCKED_IPV4_CIDRS.some((cidr) => (asInt & cidr.mask) === cidr.base);
+}
+function isBlockedIpv6(ip) {
+    const normalized = ip.toLowerCase();
+    return (normalized === "::" ||
+        normalized === "::1" ||
+        /^fe[89ab][0-9a-f]:/.test(normalized) ||
+        /^f[cd][0-9a-f]{2}:/i.test(normalized) ||
+        normalized.startsWith("ff"));
+}
+function isBlockedIp(ip) {
+    const normalized = normalizeIpForPolicy(ip);
+    const family = net.isIP(normalized);
+    if (family === 4)
+        return isBlockedIpv4(normalized);
+    if (family === 6)
+        return isBlockedIpv6(normalized);
+    return false;
+}
+export async function validateCloudBaseUrl(rawUrl) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        return `Invalid cloud base URL: "${rawUrl}"`;
+    }
+    if (parsed.protocol !== "https:") {
+        return `Cloud base URL must use HTTPS, got "${parsed.protocol}" in "${rawUrl}"`;
+    }
+    const hostname = normalizeHostLike(parsed.hostname);
+    if (!hostname) {
+        return `Invalid cloud base URL: "${rawUrl}"`;
+    }
+    if (hostname === "localhost" ||
+        hostname.endsWith(".localhost") ||
+        hostname.endsWith(".local")) {
+        return `Cloud base URL "${rawUrl}" points to a blocked local hostname.`;
+    }
+    // Dev-mode bypass: skip IP-range blocking but keep URL format checks above.
+    if (process.env.NODE_ENV === "development" || process.env.ELIZA_DEV) {
+        return null;
+    }
+    if (isBlockedIp(hostname)) {
+        return `Cloud base URL "${rawUrl}" points to a blocked address.`;
+    }
+    try {
+        const results = await dnsLookupAll(hostname, { all: true });
+        const addresses = Array.isArray(results) ? results : [results];
+        for (const entry of addresses) {
+            const ip = typeof entry === "string"
+                ? entry
+                : entry.address;
+            if (isBlockedIp(ip)) {
+                return (`Cloud base URL "${rawUrl}" resolves to ${ip}, ` +
+                    "which is a blocked internal/metadata address.");
+            }
+        }
+    }
+    catch {
+        return `Cloud base URL "${rawUrl}" could not be resolved via DNS.`;
+    }
+    return null;
+}

package/packages/agent/src/config/character-schema.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const CharacterSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    bio: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    system: z.ZodOptional<z.ZodString>;
+    adjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    topics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    style: z.ZodOptional<z.ZodObject<{
+        all: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        chat: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        post: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    messageExamples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        examples: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            content: z.ZodObject<{
+                text: z.ZodString;
+                actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    postExamples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+//# sourceMappingURL=character-schema.d.ts.map

package/packages/agent/src/config/character-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-schema.d.ts","sourceRoot":"","sources":["../../../../../src/config/character-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+BxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;kBAYjB,CAAC"}

package/packages/agent/src/config/character-schema.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+const MessageExampleContentSchema = z
+    .object({
+    text: z.string().min(1),
+    actions: z.array(z.string()).optional(),
+})
+    .strict();
+const MessageExampleSchema = z
+    .object({
+    name: z.string().min(1),
+    content: MessageExampleContentSchema,
+})
+    .strict();
+const MessageExampleGroupSchema = z
+    .object({
+    examples: z.array(MessageExampleSchema).min(1),
+})
+    .strict();
+const CharacterStyleSchema = z
+    .object({
+    all: z.array(z.string()).optional(),
+    chat: z.array(z.string()).optional(),
+    post: z.array(z.string()).optional(),
+})
+    .strict()
+    .optional();
+export const CharacterSchema = z
+    .object({
+    name: z.string().min(1).max(100).optional(),
+    username: z.string().max(50).optional(),
+    bio: z.union([z.string(), z.array(z.string())]).optional(),
+    system: z.string().max(10000).optional(),
+    adjectives: z.array(z.string().min(1).max(100)).optional(),
+    topics: z.array(z.string().min(1).max(100)).optional(),
+    style: CharacterStyleSchema,
+    messageExamples: z.array(MessageExampleGroupSchema).optional(),
+    postExamples: z.array(z.string()).optional(),
+})
+    .strict();

package/packages/agent/src/config/config.d.ts

@@ -0,0 +1,6 @@
+import type { ElizaConfig } from "./types";
+export * from "./types";
+export declare function loadElizaConfig(): ElizaConfig;
+export declare function saveElizaConfig(config: ElizaConfig): void;
+export declare function configFileExists(): boolean;
+//# sourceMappingURL=config.d.ts.map

package/packages/agent/src/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../src/config/config.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,cAAc,SAAS,CAAC;AAExB,wBAAgB,eAAe,IAAI,WAAW,CAsF7C;AAeD,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAiCzD;AAED,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C"}