@elizaos/agent 0.25.8 → 2.0.0-alpha.83

package/packages/agent/src/api/compat-utils.js

@@ -0,0 +1,126 @@
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function readString(value) {
+    return typeof value === "string" ? value : "";
+}
+/**
+ * Extract a best-effort text string from OpenAI/Anthropic "content" fields.
+ * Supports:
+ * - string
+ * - array of parts: [{ type: "text", text: "..." }, ...]
+ * - objects with a `text` string field
+ */
+export function extractCompatTextContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const chunks = [];
+        for (const item of content) {
+            const obj = asRecord(item);
+            if (!obj)
+                continue;
+            const type = readString(obj.type);
+            if (type && type !== "text")
+                continue;
+            const text = readString(obj.text);
+            if (text)
+                chunks.push(text);
+        }
+        return chunks.join("");
+    }
+    const obj = asRecord(content);
+    if (obj)
+        return readString(obj.text);
+    return "";
+}
+/**
+ * For OpenAI-compatible requests, we intentionally reduce "messages" to:
+ * - all system/developer messages (joined)
+ * - the last user message
+ *
+ * This keeps the server-side room memory coherent (so stateless clients that
+ * resend full history do not cause runaway duplication).
+ */
+export function extractOpenAiSystemAndLastUser(messages) {
+    if (!Array.isArray(messages))
+        return null;
+    let system = "";
+    let user = "";
+    for (const item of messages) {
+        const msg = asRecord(item);
+        if (!msg)
+            continue;
+        const role = readString(msg.role);
+        const contentText = extractCompatTextContent(msg.content);
+        if (!contentText.trim())
+            continue;
+        if (role === "system" || role === "developer") {
+            system = system
+                ? `${system}\n\n${contentText.trim()}`
+                : contentText.trim();
+            continue;
+        }
+        if (role === "user") {
+            user = contentText.trim();
+        }
+    }
+    if (!user)
+        return null;
+    return { system, user };
+}
+export function extractAnthropicSystemAndLastUser(args) {
+    if (!Array.isArray(args.messages))
+        return null;
+    const system = readString(args.system).trim();
+    let user = "";
+    for (const item of args.messages) {
+        const msg = asRecord(item);
+        if (!msg)
+            continue;
+        const role = readString(msg.role);
+        if (role !== "user")
+            continue;
+        const contentText = extractCompatTextContent(msg.content);
+        if (!contentText.trim())
+            continue;
+        user = contentText.trim();
+    }
+    if (!user)
+        return null;
+    return { system, user };
+}
+function readNestedString(obj, key) {
+    const raw = obj[key];
+    if (typeof raw === "string" && raw.trim())
+        return raw.trim();
+    return null;
+}
+/**
+ * Resolve a stable room key for compatibility endpoints so manual testing can
+ * keep conversation memory when the client provides an identifier.
+ *
+ * We accept a few common fields without requiring any one client:
+ * - OpenAI: body.user (string)
+ * - OpenAI: body.metadata.conversation_id
+ * - Anthropic: body.metadata.user_id
+ * - Anthropic: body.metadata.conversation_id
+ */
+export function resolveCompatRoomKey(body, fallback = "default") {
+    const direct = readNestedString(body, "user");
+    if (direct)
+        return direct;
+    const metadata = asRecord(body.metadata);
+    if (metadata) {
+        const conv = readNestedString(metadata, "conversation_id") ??
+            readNestedString(metadata, "conversationId");
+        if (conv)
+            return conv;
+        const userId = readNestedString(metadata, "user_id");
+        if (userId)
+            return userId;
+    }
+    return fallback;
+}

package/packages/agent/src/api/connector-health.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Lightweight connector health monitor.
+ *
+ * Periodically checks whether configured connectors (Discord, Telegram, etc.)
+ * still have their corresponding plugin loaded. On status transition to
+ * "missing", broadcasts a system-warning via WebSocket.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+export type ConnectorStatus = "ok" | "missing" | "unknown";
+export interface ConnectorHealthMonitorOptions {
+    runtime: AgentRuntime;
+    config: {
+        connectors?: Record<string, unknown>;
+    };
+    broadcastWs: (payload: Record<string, unknown>) => void;
+    intervalMs?: number;
+}
+export declare class ConnectorHealthMonitor {
+    private runtime;
+    private config;
+    private broadcastWs;
+    private intervalMs;
+    private timer;
+    private statuses;
+    constructor(opts: ConnectorHealthMonitorOptions);
+    start(): void;
+    stop(): void;
+    getConnectorStatuses(): Record<string, ConnectorStatus>;
+    private resolveIntervalMs;
+    private getConfiguredConnectors;
+    private probeConnector;
+    check(): Promise<void>;
+}
+//# sourceMappingURL=connector-health.d.ts.map

package/packages/agent/src/api/connector-health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-health.d.ts","sourceRoot":"","sources":["../../../../../src/api/connector-health.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,CAAC;AAE3D,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC;IACjD,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAYD,qBAAa,sBAAsB;IACjC,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,MAAM,CAA2C;IACzD,OAAO,CAAC,WAAW,CAA6C;IAChE,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,QAAQ,CAA2C;gBAE/C,IAAI,EAAE,6BAA6B;IAO/C,KAAK,IAAI,IAAI;IAMb,IAAI,IAAI,IAAI;IAOZ,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;IAQvD,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,uBAAuB;YAiBjB,cAAc;IAsBtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAwB7B"}

package/packages/agent/src/api/connector-health.js

@@ -0,0 +1,109 @@
+/**
+ * Lightweight connector health monitor.
+ *
+ * Periodically checks whether configured connectors (Discord, Telegram, etc.)
+ * still have their corresponding plugin loaded. On status transition to
+ * "missing", broadcasts a system-warning via WebSocket.
+ */
+const DEFAULT_INTERVAL_MS = 60_000;
+const CONNECTOR_PLUGIN_MAP = {
+    discord: "discord",
+    telegram: "telegram",
+    twitter: "twitter",
+    slack: "slack",
+    farcaster: "farcaster",
+};
+export class ConnectorHealthMonitor {
+    runtime;
+    config;
+    broadcastWs;
+    intervalMs;
+    timer = null;
+    statuses = new Map();
+    constructor(opts) {
+        this.runtime = opts.runtime;
+        this.config = opts.config;
+        this.broadcastWs = opts.broadcastWs;
+        this.intervalMs = opts.intervalMs ?? this.resolveIntervalMs();
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.check();
+        this.timer = setInterval(() => this.check(), this.intervalMs);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    getConnectorStatuses() {
+        const result = {};
+        for (const [name, status] of this.statuses) {
+            result[name] = status;
+        }
+        return result;
+    }
+    resolveIntervalMs() {
+        const envVal = process.env.CONNECTOR_HEALTH_INTERVAL_MS;
+        if (!envVal)
+            return DEFAULT_INTERVAL_MS;
+        const parsed = Number.parseInt(envVal, 10);
+        if (Number.isNaN(parsed) || parsed < 10_000)
+            return DEFAULT_INTERVAL_MS;
+        return parsed;
+    }
+    getConfiguredConnectors() {
+        const connectors = this.config.connectors;
+        if (!connectors)
+            return [];
+        const result = [];
+        for (const [name, cfg] of Object.entries(connectors)) {
+            if (cfg &&
+                typeof cfg === "object" &&
+                cfg.enabled !== false) {
+                result.push(name);
+            }
+        }
+        return result;
+    }
+    async probeConnector(name) {
+        const pluginName = CONNECTOR_PLUGIN_MAP[name.toLowerCase()];
+        if (!pluginName)
+            return "unknown";
+        try {
+            const service = this.runtime.getService(pluginName);
+            if (service)
+                return "ok";
+        }
+        catch {
+            // getService may throw if runtime is shutting down
+        }
+        // Also check runtime.clients if available
+        const clients = this.runtime.clients;
+        if (clients?.[pluginName])
+            return "ok";
+        return "missing";
+    }
+    async check() {
+        const configured = this.getConfiguredConnectors();
+        for (const name of configured) {
+            const newStatus = await this.probeConnector(name);
+            const prevStatus = this.statuses.get(name);
+            if (newStatus === "missing" && prevStatus !== "missing") {
+                this.broadcastWs({
+                    type: "system-warning",
+                    message: `${name.charAt(0).toUpperCase() + name.slice(1)} connector appears disconnected`,
+                });
+            }
+            this.statuses.set(name, newStatus);
+        }
+        // Clean up connectors that are no longer configured
+        for (const name of this.statuses.keys()) {
+            if (!configured.includes(name)) {
+                this.statuses.delete(name);
+            }
+        }
+    }
+}

package/packages/agent/src/api/coordinator-wiring.d.ts

@@ -0,0 +1,46 @@
+import type { AgentRuntime } from "@elizaos/core";
+/**
+ * Minimal subset of ServerState needed for coordinator bridge wiring.
+ * Avoids importing the full ServerState interface (which is private to server.ts).
+ */
+export interface WirableState {
+    runtime: AgentRuntime | null;
+    broadcastWs?: ((data: Record<string, unknown>) => void) | null;
+}
+export interface WireCoordinatorOpts<S extends WirableState = WirableState> {
+    /** Wire the chat bridge. Returns true on success. */
+    wireChatBridge: (state: S) => boolean | Promise<boolean>;
+    /** Wire the WebSocket bridge. Returns true on success. */
+    wireWsBridge: (state: S) => boolean | Promise<boolean>;
+    /** Wire the event-routing bridge. Returns true on success. */
+    wireEventRouting: (state: S) => boolean | Promise<boolean>;
+    /** Wire the swarm-complete synthesis callback. Returns true on success. */
+    wireSwarmSynthesis?: (state: S) => boolean | Promise<boolean>;
+    /** Label for log messages (e.g. "boot", "restart"). */
+    context: string;
+    /** Logger with warn/debug methods. */
+    logger: {
+        warn: (msg: string) => void;
+        debug?: (msg: string) => void;
+    };
+}
+export interface WireResult {
+    chat: boolean;
+    ws: boolean;
+    eventRouting: boolean;
+    swarmSynthesis: boolean;
+}
+/**
+ * Wire coordinator bridges using polling-based service discovery.
+ *
+ * 1. Attempts immediate wiring (coordinator may already be available).
+ * 2. If any bridge fails, polls for the SWARM_COORDINATOR service via
+ *    `runtime.getService()` (the orchestrator plugin registers it via
+ *    direct map insertion, so `getServiceLoadPromise` never resolves).
+ * 3. Once the service appears, retries failed bridges up to MAX_RETRIES.
+ * 4. On timeout or exhaustion, broadcasts a system-warning WS event.
+ *
+ * Safe for fire-and-forget (`void wireCoordinatorBridgesWhenReady(...)`).
+ */
+export declare function wireCoordinatorBridgesWhenReady<S extends WirableState>(state: S, opts: WireCoordinatorOpts<S>): Promise<WireResult>;
+//# sourceMappingURL=coordinator-wiring.d.ts.map

package/packages/agent/src/api/coordinator-wiring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinator-wiring.d.ts","sourceRoot":"","sources":["../../../../../src/api/coordinator-wiring.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,WAAW,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;CAChE;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY;IACxE,qDAAqD;IACrD,cAAc,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACzD,0DAA0D;IAC1D,YAAY,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,8DAA8D;IAC9D,gBAAgB,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3D,2EAA2E;IAC3E,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,MAAM,EAAE;QAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;CACxE;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,OAAO,CAAC;IACZ,YAAY,EAAE,OAAO,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;CACzB;AAOD;;;;;;;;;;;GAWG;AACH,wBAAsB,+BAA+B,CAAC,CAAC,SAAS,YAAY,EAC1E,KAAK,EAAE,CAAC,EACR,IAAI,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC3B,OAAO,CAAC,UAAU,CAAC,CAyGrB"}

package/packages/agent/src/api/coordinator-wiring.js

@@ -0,0 +1,101 @@
+const POLL_INTERVAL_MS = 2_000;
+const POLL_TIMEOUT_MS = 90_000;
+const RETRY_DELAY_MS = 500;
+const MAX_RETRIES = 5;
+/**
+ * Wire coordinator bridges using polling-based service discovery.
+ *
+ * 1. Attempts immediate wiring (coordinator may already be available).
+ * 2. If any bridge fails, polls for the SWARM_COORDINATOR service via
+ *    `runtime.getService()` (the orchestrator plugin registers it via
+ *    direct map insertion, so `getServiceLoadPromise` never resolves).
+ * 3. Once the service appears, retries failed bridges up to MAX_RETRIES.
+ * 4. On timeout or exhaustion, broadcasts a system-warning WS event.
+ *
+ * Safe for fire-and-forget (`void wireCoordinatorBridgesWhenReady(...)`).
+ */
+export async function wireCoordinatorBridgesWhenReady(state, opts) {
+    const { wireChatBridge, wireWsBridge, wireEventRouting, wireSwarmSynthesis, context, logger, } = opts;
+    const result = {
+        chat: false,
+        ws: false,
+        eventRouting: false,
+        swarmSynthesis: false,
+    };
+    try {
+        // 1. Immediate attempt
+        result.chat = await wireChatBridge(state);
+        result.ws = await wireWsBridge(state);
+        result.eventRouting = await wireEventRouting(state);
+        result.swarmSynthesis = wireSwarmSynthesis
+            ? await wireSwarmSynthesis(state)
+            : false;
+        if (result.chat && result.ws && result.eventRouting) {
+            logger.debug?.(`[eliza-api] Coordinator bridges wired immediately (${context})`);
+            return result;
+        }
+        // 2. Poll for SWARM_COORDINATOR service to appear
+        const runtime = state.runtime;
+        if (!runtime) {
+            logger.warn(`[eliza-api] Coordinator wiring skipped (${context}): no runtime`);
+            return result;
+        }
+        const deadline = Date.now() + POLL_TIMEOUT_MS;
+        let serviceFound = false;
+        while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+            const svc = runtime.getService("SWARM_COORDINATOR");
+            if (svc) {
+                serviceFound = true;
+                logger.debug?.(`[eliza-api] SWARM_COORDINATOR service detected (${context})`);
+                break;
+            }
+        }
+        if (!serviceFound) {
+            // Service never appeared — log at debug level only. This is normal
+            // if the orchestrator plugin is disabled or not configured.
+            logger.debug?.(`[eliza-api] SWARM_COORDINATOR not available after ${POLL_TIMEOUT_MS / 1000}s (${context}) — coding agent features disabled`);
+            return result;
+        }
+        // 3. Service loaded — retry failed bridges
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            if (!result.chat)
+                result.chat = await wireChatBridge(state);
+            if (!result.ws)
+                result.ws = await wireWsBridge(state);
+            if (!result.eventRouting)
+                result.eventRouting = await wireEventRouting(state);
+            if (!result.swarmSynthesis && wireSwarmSynthesis)
+                result.swarmSynthesis = await wireSwarmSynthesis(state);
+            if (result.chat && result.ws && result.eventRouting) {
+                logger.debug?.(`[eliza-api] Coordinator bridges wired after service load (${context}, attempt ${attempt + 1})`);
+                return result;
+            }
+            // Brief delay before next retry
+            await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+        }
+        // 4. Exhausted retries after service load — this is a real problem
+        broadcastWarning(state, result, context, "retries exhausted after service load", !!wireSwarmSynthesis);
+        logger.warn(`[eliza-api] Coordinator wiring incomplete after ${MAX_RETRIES} retries (${context})`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.warn(`[eliza-api] Coordinator wiring error (${context}): ${message}`);
+    }
+    return result;
+}
+function broadcastWarning(state, result, context, reason, hasSwarmSynthesis) {
+    const missing = [
+        !result.chat && "chat",
+        !result.ws && "ws",
+        !result.eventRouting && "event-routing",
+        hasSwarmSynthesis && !result.swarmSynthesis && "swarm-synthesis",
+    ]
+        .filter(Boolean)
+        .join(", ");
+    state.broadcastWs?.({
+        type: "system-warning",
+        message: `Coordinator wiring incomplete (${context}): ${reason}. Missing bridges: ${missing}`,
+        ts: Date.now(),
+    });
+}

package/packages/agent/src/api/credit-detection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Credit/quota exhaustion detection for provider errors.
+ *
+ * Matches error messages, HTTP status codes (402, 429 with billing context),
+ * and structured error bodies from various AI providers.
+ */
+export declare function isInsufficientCreditsMessage(message: string): boolean;
+export declare function isInsufficientCreditsError(err: unknown): boolean;
+//# sourceMappingURL=credit-detection.d.ts.map

package/packages/agent/src/api/credit-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credit-detection.d.ts","sourceRoot":"","sources":["../../../../../src/api/credit-detection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAuBhE"}

package/packages/agent/src/api/credit-detection.js

@@ -0,0 +1,41 @@
+/**
+ * Credit/quota exhaustion detection for provider errors.
+ *
+ * Matches error messages, HTTP status codes (402, 429 with billing context),
+ * and structured error bodies from various AI providers.
+ */
+const INSUFFICIENT_CREDITS_RE = /\b(?:insufficient(?:[_\s]+(?:credits?|quota))|insufficient_quota|out of credits|max usage reached|quota(?:\s+exceeded)?|rate_limit_exceeded|billing.*disabled|payment.*required|account.*suspended|spending.*limit|budget.*exceeded|no.*api.*credits|credit.*balance.*zero)\b/i;
+const BILLING_KEYWORDS_RE = /\b(?:billing|quota|credits?|budget|spending|payment|subscription|plan limit)\b/i;
+export function isInsufficientCreditsMessage(message) {
+    return INSUFFICIENT_CREDITS_RE.test(message);
+}
+export function isInsufficientCreditsError(err) {
+    if (err == null || typeof err !== "object") {
+        if (typeof err === "string")
+            return isInsufficientCreditsMessage(err);
+        return false;
+    }
+    const msg = getErrorMessage(err, "");
+    if (isInsufficientCreditsMessage(msg))
+        return true;
+    const status = err.status;
+    if (status === 402)
+        return true;
+    if (status === 429 && BILLING_KEYWORDS_RE.test(msg))
+        return true;
+    const errorBody = err.error;
+    if (errorBody?.type === "insufficient_quota")
+        return true;
+    if (typeof errorBody?.code === "string" &&
+        INSUFFICIENT_CREDITS_RE.test(errorBody.code)) {
+        return true;
+    }
+    return false;
+}
+function getErrorMessage(err, fallback = "generation failed") {
+    if (err instanceof Error)
+        return err.message;
+    if (typeof err === "string")
+        return err;
+    return fallback;
+}

package/packages/agent/src/api/database.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Database management API handlers for the Eliza Control UI.
+ *
+ * Provides endpoints for:
+ * - Database provider configuration (PGLite vs Postgres)
+ * - Connection testing for remote Postgres
+ * - Table browsing and introspection
+ * - Row-level CRUD operations
+ * - Raw SQL query execution
+ * - Database status and health
+ *
+ * All data endpoints use the active runtime's database adapter (Drizzle ORM)
+ * so they work identically for both PGLite and Postgres.
+ */
+import type http from "node:http";
+import { type AgentRuntime } from "@elizaos/core";
+/**
+ * Route a database API request. Returns true if handled, false if not matched.
+ *
+ * Expected URL patterns:
+ *   GET    /api/database/status
+ *   GET    /api/database/config
+ *   PUT    /api/database/config
+ *   POST   /api/database/test
+ *   GET    /api/database/tables
+ *   GET    /api/database/tables/:table/rows
+ *   POST   /api/database/tables/:table/rows
+ *   PUT    /api/database/tables/:table/rows
+ *   DELETE /api/database/tables/:table/rows
+ *   POST   /api/database/query
+ */
+export declare function handleDatabaseRoute(req: http.IncomingMessage, res: http.ServerResponse, runtime: AgentRuntime | null, pathname: string): Promise<boolean>;
+//# sourceMappingURL=database.d.ts.map

package/packages/agent/src/api/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../../../src/api/database.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAGlC,OAAO,EAAE,KAAK,YAAY,EAAU,MAAM,eAAe,CAAC;AA4tC1D;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,EAAE,YAAY,GAAG,IAAI,EAC5B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAyElB"}