@elizaos/agent 0.25.8 → 2.0.0-alpha.83

package/packages/agent/src/api/cloud-routes.js

@@ -0,0 +1,339 @@
+import { logger } from "@elizaos/core";
+import { normalizeCloudSiteUrl } from "../cloud/base-url";
+import { validateCloudBaseUrl } from "../cloud/validate-url";
+import { readJsonBody as parseJsonBody, sendJson, sendJsonError, } from "./http-helpers";
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const CLOUD_LOGIN_CREATE_TIMEOUT_MS = 10_000;
+const CLOUD_LOGIN_POLL_TIMEOUT_MS = 10_000;
+function extractAgentId(pathname) {
+    const id = pathname.split("/")[4];
+    return id && UUID_RE.test(id) ? id : null;
+}
+async function readJsonBody(req, res) {
+    return parseJsonBody(req, res, {
+        maxBytes: 1_048_576,
+        tooLargeMessage: "Request body too large",
+        destroyOnTooLarge: true,
+    });
+}
+function isRedirectResponse(response) {
+    return response.status >= 300 && response.status < 400;
+}
+function isTimeoutError(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.name === "TimeoutError" || error.name === "AbortError")
+        return true;
+    const message = error.message.toLowerCase();
+    return message.includes("timed out") || message.includes("timeout");
+}
+function createNoopTelemetrySpan() {
+    return {
+        success: () => { },
+        failure: () => { },
+    };
+}
+function getTelemetrySpan(state, meta) {
+    return state.createTelemetrySpan?.(meta) ?? createNoopTelemetrySpan();
+}
+async function fetchWithTimeout(input, init, timeoutMs) {
+    return fetch(input, {
+        ...init,
+        redirect: "manual",
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+}
+export async function handleCloudRoute(req, res, pathname, method, state) {
+    if (method === "POST" && pathname === "/api/cloud/login") {
+        const baseUrl = normalizeCloudSiteUrl(state.config.cloud?.baseUrl);
+        const urlError = await validateCloudBaseUrl(baseUrl);
+        if (urlError) {
+            sendJsonError(res, urlError);
+            return true;
+        }
+        const sessionId = crypto.randomUUID();
+        const loginCreateSpan = getTelemetrySpan(state, {
+            boundary: "cloud",
+            operation: "login_create_session",
+            timeoutMs: CLOUD_LOGIN_CREATE_TIMEOUT_MS,
+        });
+        let createRes;
+        try {
+            createRes = await fetchWithTimeout(`${baseUrl}/api/auth/cli-session`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ sessionId }),
+            }, CLOUD_LOGIN_CREATE_TIMEOUT_MS);
+        }
+        catch (fetchErr) {
+            if (isTimeoutError(fetchErr)) {
+                loginCreateSpan.failure({ error: fetchErr, statusCode: 504 });
+                sendJsonError(res, "Eliza Cloud login request timed out", 504);
+                return true;
+            }
+            loginCreateSpan.failure({ error: fetchErr, statusCode: 502 });
+            sendJsonError(res, "Failed to reach Eliza Cloud", 502);
+            return true;
+        }
+        if (isRedirectResponse(createRes)) {
+            loginCreateSpan.failure({
+                statusCode: createRes.status,
+                errorKind: "redirect_response",
+            });
+            sendJsonError(res, "Eliza Cloud login request was redirected; redirects are not allowed", 502);
+            return true;
+        }
+        if (!createRes.ok) {
+            loginCreateSpan.failure({
+                statusCode: createRes.status,
+                errorKind: "http_error",
+            });
+            sendJsonError(res, "Failed to create auth session with Eliza Cloud", 502);
+            return true;
+        }
+        loginCreateSpan.success({ statusCode: createRes.status });
+        sendJson(res, {
+            ok: true,
+            sessionId,
+            browserUrl: `${baseUrl}/auth/cli-login?session=${encodeURIComponent(sessionId)}`,
+        });
+        return true;
+    }
+    if (method === "GET" && pathname.startsWith("/api/cloud/login/status")) {
+        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        const sessionId = url.searchParams.get("sessionId");
+        if (!sessionId) {
+            sendJsonError(res, "sessionId query parameter is required");
+            return true;
+        }
+        const baseUrl = normalizeCloudSiteUrl(state.config.cloud?.baseUrl);
+        const urlError = await validateCloudBaseUrl(baseUrl);
+        if (urlError) {
+            sendJsonError(res, urlError);
+            return true;
+        }
+        const loginPollSpan = getTelemetrySpan(state, {
+            boundary: "cloud",
+            operation: "login_poll_status",
+            timeoutMs: CLOUD_LOGIN_POLL_TIMEOUT_MS,
+        });
+        let pollRes;
+        try {
+            pollRes = await fetchWithTimeout(`${baseUrl}/api/auth/cli-session/${encodeURIComponent(sessionId)}`, {}, CLOUD_LOGIN_POLL_TIMEOUT_MS);
+        }
+        catch (fetchErr) {
+            if (isTimeoutError(fetchErr)) {
+                loginPollSpan.failure({ error: fetchErr, statusCode: 504 });
+                sendJson(res, {
+                    status: "error",
+                    error: "Eliza Cloud status request timed out",
+                }, 504);
+                return true;
+            }
+            loginPollSpan.failure({ error: fetchErr, statusCode: 502 });
+            sendJson(res, {
+                status: "error",
+                error: "Failed to reach Eliza Cloud",
+            }, 502);
+            return true;
+        }
+        if (isRedirectResponse(pollRes)) {
+            loginPollSpan.failure({
+                statusCode: pollRes.status,
+                errorKind: "redirect_response",
+            });
+            sendJson(res, {
+                status: "error",
+                error: "Eliza Cloud status request was redirected; redirects are not allowed",
+            }, 502);
+            return true;
+        }
+        if (!pollRes.ok) {
+            loginPollSpan.failure({
+                statusCode: pollRes.status,
+                errorKind: "http_error",
+            });
+            sendJson(res, pollRes.status === 404
+                ? { status: "expired", error: "Session not found or expired" }
+                : {
+                    status: "error",
+                    error: `Eliza Cloud returned HTTP ${pollRes.status}`,
+                });
+            return true;
+        }
+        let data;
+        try {
+            data = (await pollRes.json());
+        }
+        catch (parseErr) {
+            loginPollSpan.failure({ error: parseErr, statusCode: pollRes.status });
+            throw parseErr;
+        }
+        loginPollSpan.success({ statusCode: pollRes.status });
+        if (data.status === "authenticated" && data.apiKey) {
+            const cloud = (state.config.cloud ?? {});
+            cloud.enabled = true;
+            cloud.apiKey = data.apiKey;
+            state.config.cloud = cloud;
+            try {
+                state.saveConfig?.(state.config);
+                logger.info("[cloud-login] API key saved to config file");
+            }
+            catch (saveErr) {
+                logger.error(`[cloud-login] Failed to save config: ${saveErr instanceof Error ? saveErr.message : saveErr}`);
+            }
+            process.env.ELIZAOS_CLOUD_API_KEY = data.apiKey;
+            process.env.ELIZAOS_CLOUD_ENABLED = "true";
+            if (state.runtime) {
+                try {
+                    if (!state.runtime.character.secrets) {
+                        state.runtime.character.secrets = {};
+                    }
+                    const secrets = state.runtime.character.secrets;
+                    secrets.ELIZAOS_CLOUD_API_KEY = data.apiKey;
+                    secrets.ELIZAOS_CLOUD_ENABLED = "true";
+                    await state.runtime.updateAgent(state.runtime.agentId, {
+                        secrets: { ...secrets },
+                    });
+                    logger.info("[cloud-login] API key persisted to agent DB record");
+                }
+                catch (dbErr) {
+                    logger.warn(`[cloud-login] DB persistence failed (non-fatal): ${dbErr instanceof Error ? dbErr.message : dbErr}`);
+                }
+            }
+            if (state.cloudManager &&
+                !state.cloudManager.getClient() &&
+                typeof state.cloudManager.init === "function") {
+                await state.cloudManager.init();
+            }
+            sendJson(res, { status: "authenticated", keyPrefix: data.keyPrefix });
+        }
+        else {
+            sendJson(res, { status: data.status });
+        }
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/cloud/agents") {
+        const client = state.cloudManager?.getClient();
+        if (!client) {
+            sendJsonError(res, "Not connected to Eliza Cloud", 401);
+            return true;
+        }
+        sendJson(res, { ok: true, agents: await client.listAgents() });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/cloud/agents") {
+        const client = state.cloudManager?.getClient();
+        if (!client) {
+            sendJsonError(res, "Not connected to Eliza Cloud", 401);
+            return true;
+        }
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        if (!body.agentName?.trim()) {
+            sendJsonError(res, "agentName is required");
+            return true;
+        }
+        const agent = await client.createAgent({
+            agentName: body.agentName,
+            agentConfig: body.agentConfig,
+            environmentVars: body.environmentVars,
+        });
+        sendJson(res, { ok: true, agent }, 201);
+        return true;
+    }
+    if (method === "POST" &&
+        pathname.startsWith("/api/cloud/agents/") &&
+        pathname.endsWith("/provision")) {
+        const agentId = extractAgentId(pathname);
+        if (!agentId || !state.cloudManager) {
+            sendJsonError(res, "Invalid agent ID or cloud not connected", 400);
+            return true;
+        }
+        const proxy = await state.cloudManager.connect(agentId);
+        sendJson(res, {
+            ok: true,
+            agentId,
+            agentName: proxy.agentName,
+            status: state.cloudManager.getStatus(),
+        });
+        return true;
+    }
+    if (method === "POST" &&
+        pathname.startsWith("/api/cloud/agents/") &&
+        pathname.endsWith("/shutdown")) {
+        const agentId = extractAgentId(pathname);
+        if (!agentId || !state.cloudManager) {
+            sendJsonError(res, "Invalid agent ID or cloud not connected", 400);
+            return true;
+        }
+        const client = state.cloudManager.getClient();
+        if (!client) {
+            sendJsonError(res, "Not connected to Eliza Cloud", 401);
+            return true;
+        }
+        if (state.cloudManager.getActiveAgentId() === agentId) {
+            await state.cloudManager.disconnect();
+        }
+        await client.deleteAgent(agentId);
+        sendJson(res, { ok: true, agentId, status: "stopped" });
+        return true;
+    }
+    if (method === "POST" &&
+        pathname.startsWith("/api/cloud/agents/") &&
+        pathname.endsWith("/connect")) {
+        const agentId = extractAgentId(pathname);
+        if (!agentId || !state.cloudManager) {
+            sendJsonError(res, "Invalid agent ID or cloud not connected", 400);
+            return true;
+        }
+        if (state.cloudManager.getActiveAgentId()) {
+            await state.cloudManager.disconnect();
+        }
+        const proxy = await state.cloudManager.connect(agentId);
+        sendJson(res, {
+            ok: true,
+            agentId,
+            agentName: proxy.agentName,
+            status: state.cloudManager.getStatus(),
+        });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/cloud/disconnect") {
+        if (state.cloudManager) {
+            await state.cloudManager.disconnect();
+        }
+        const cloud = (state.config.cloud ?? {});
+        cloud.enabled = false;
+        delete cloud.apiKey;
+        state.config.cloud = cloud;
+        try {
+            state.saveConfig?.(state.config);
+        }
+        catch (saveErr) {
+            logger.warn(`[cloud-login] Failed to save cloud disconnect state: ${saveErr instanceof Error ? saveErr.message : saveErr}`);
+        }
+        delete process.env.ELIZAOS_CLOUD_API_KEY;
+        delete process.env.ELIZAOS_CLOUD_ENABLED;
+        if (state.runtime) {
+            try {
+                if (!state.runtime.character.secrets) {
+                    state.runtime.character.secrets = {};
+                }
+                const secrets = state.runtime.character.secrets;
+                delete secrets.ELIZAOS_CLOUD_API_KEY;
+                delete secrets.ELIZAOS_CLOUD_ENABLED;
+                await state.runtime.updateAgent(state.runtime.agentId, {
+                    secrets: { ...secrets },
+                });
+            }
+            catch (dbErr) {
+                logger.warn(`[cloud-login] Failed to clear cloud secrets from agent DB: ${dbErr instanceof Error ? dbErr.message : dbErr}`);
+            }
+        }
+        sendJson(res, { ok: true, status: "disconnected" });
+        return true;
+    }
+    return false;
+}

package/packages/agent/src/api/cloud-status-routes.d.ts

@@ -0,0 +1,15 @@
+import type { AgentRuntime } from "@elizaos/core";
+import type { RouteHelpers, RouteRequestMeta } from "./route-helpers";
+export interface CloudConfigLike {
+    cloud?: {
+        enabled?: boolean;
+        apiKey?: string;
+        baseUrl?: string;
+    };
+}
+export interface CloudStatusRouteContext extends RouteRequestMeta, Pick<RouteHelpers, "json"> {
+    config: CloudConfigLike;
+    runtime: AgentRuntime | null;
+}
+export declare function handleCloudStatusRoutes(ctx: CloudStatusRouteContext): Promise<boolean>;
+//# sourceMappingURL=cloud-status-routes.d.ts.map

package/packages/agent/src/api/cloud-status-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-status-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/cloud-status-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAW,MAAM,eAAe,CAAC;AAI3D,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAiBtE,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE;QACN,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,MAAM,WAAW,uBACf,SAAQ,gBAAgB,EACtB,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC;IAC5B,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;CAC9B;AAkDD,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,uBAAuB,GAC3B,OAAO,CAAC,OAAO,CAAC,CAoJlB"}

package/packages/agent/src/api/cloud-status-routes.js

@@ -0,0 +1,165 @@
+import { logger } from "@elizaos/core";
+import { resolveCloudApiBaseUrl as resolveCanonicalCloudApiBaseUrl } from "../cloud/base-url";
+import { validateCloudBaseUrl } from "../cloud/validate-url";
+const DEFAULT_CLOUD_API_BASE_URL = "https://www.elizacloud.ai/api/v1";
+const CLOUD_BILLING_URL = "https://www.elizacloud.ai/dashboard/settings?tab=billing";
+function resolveCloudApiBaseUrl(rawBaseUrl) {
+    return resolveCanonicalCloudApiBaseUrl(rawBaseUrl ?? DEFAULT_CLOUD_API_BASE_URL);
+}
+async function fetchCloudCreditsByApiKey(baseUrl, apiKey) {
+    const response = await fetch(`${baseUrl}/credits/balance`, {
+        headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+        redirect: "manual",
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (response.status >= 300 && response.status < 400) {
+        throw new Error("Cloud credits request was redirected; redirects are not allowed");
+    }
+    const creditResponse = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        const message = typeof creditResponse.error === "string" && creditResponse.error.trim()
+            ? creditResponse.error
+            : `HTTP ${response.status}`;
+        throw new Error(message);
+    }
+    const rawBalance = typeof creditResponse.balance === "number"
+        ? creditResponse.balance
+        : typeof creditResponse.data?.balance ===
+            "number"
+            ? creditResponse.data.balance
+            : undefined;
+    return typeof rawBalance === "number" ? rawBalance : null;
+}
+export async function handleCloudStatusRoutes(ctx) {
+    const { res, method, pathname, config, runtime, json } = ctx;
+    if (method === "GET" && pathname === "/api/cloud/status") {
+        const cloudMode = config.cloud?.enabled;
+        const cloudEnabled = cloudMode === true;
+        const hasApiKey = Boolean(config.cloud?.apiKey?.trim());
+        const effectivelyEnabled = cloudEnabled;
+        const cloudAuth = runtime
+            ? runtime.getService("CLOUD_AUTH")
+            : null;
+        const authConnected = Boolean(cloudAuth?.isAuthenticated());
+        if (authConnected || hasApiKey) {
+            json(res, {
+                connected: true,
+                enabled: effectivelyEnabled,
+                hasApiKey,
+                userId: authConnected ? cloudAuth?.getUserId?.() : undefined,
+                organizationId: authConnected
+                    ? cloudAuth?.getOrganizationId?.()
+                    : undefined,
+                topUpUrl: CLOUD_BILLING_URL,
+                reason: authConnected
+                    ? undefined
+                    : runtime
+                        ? "api_key_present_not_authenticated"
+                        : "api_key_present_runtime_not_started",
+            });
+            return true;
+        }
+        if (!runtime) {
+            json(res, {
+                connected: false,
+                enabled: effectivelyEnabled,
+                hasApiKey,
+                reason: "runtime_not_started",
+            });
+            return true;
+        }
+        json(res, {
+            connected: false,
+            enabled: effectivelyEnabled,
+            hasApiKey,
+            reason: "not_authenticated",
+        });
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/cloud/credits") {
+        const cloudAuth = runtime
+            ? runtime.getService("CLOUD_AUTH")
+            : null;
+        const configApiKey = config.cloud?.apiKey?.trim();
+        if (!cloudAuth || !cloudAuth.isAuthenticated()) {
+            if (!configApiKey) {
+                json(res, { balance: null, connected: false });
+                return true;
+            }
+            const resolvedBaseUrl = resolveCloudApiBaseUrl(config.cloud?.baseUrl);
+            const baseUrlRejection = await validateCloudBaseUrl(resolvedBaseUrl);
+            if (baseUrlRejection) {
+                json(res, { balance: null, connected: true, error: baseUrlRejection });
+                return true;
+            }
+            try {
+                const balance = await fetchCloudCreditsByApiKey(resolvedBaseUrl, configApiKey);
+                if (typeof balance !== "number") {
+                    json(res, {
+                        balance: null,
+                        connected: true,
+                        error: "unexpected response",
+                    });
+                    return true;
+                }
+                const low = balance < 2.0;
+                const critical = balance < 0.5;
+                json(res, {
+                    connected: true,
+                    balance,
+                    low,
+                    critical,
+                    topUpUrl: CLOUD_BILLING_URL,
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : "cloud API unreachable";
+                logger.debug(`[cloud/credits] Failed to fetch balance via API key: ${msg}`);
+                json(res, { balance: null, connected: true, error: msg });
+            }
+            return true;
+        }
+        let balance;
+        const client = cloudAuth.getClient();
+        try {
+            const creditResponse = await client.get("/credits/balance");
+            const rawBalance = typeof creditResponse?.balance === "number"
+                ? creditResponse.balance
+                : typeof creditResponse?.data
+                    ?.balance === "number"
+                    ? creditResponse.data
+                        .balance
+                    : undefined;
+            if (typeof rawBalance !== "number") {
+                logger.debug(`[cloud/credits] Unexpected response shape: ${JSON.stringify(creditResponse)}`);
+                json(res, {
+                    balance: null,
+                    connected: true,
+                    error: "unexpected response",
+                });
+                return true;
+            }
+            balance = rawBalance;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "cloud API unreachable";
+            logger.debug(`[cloud/credits] Failed to fetch balance: ${msg}`);
+            json(res, { balance: null, connected: true, error: msg });
+            return true;
+        }
+        const low = balance < 2.0;
+        const critical = balance < 0.5;
+        json(res, {
+            connected: true,
+            balance,
+            low,
+            critical,
+            topUpUrl: CLOUD_BILLING_URL,
+        });
+        return true;
+    }
+    return false;
+}

package/packages/agent/src/api/compat-utils.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 declare function extractCompatTextContent(content: unknown): string;
+export type OpenAiChatRole = "system" | "developer" | "user" | "assistant" | "tool" | "function";
+export interface OpenAiChatMessage {
+    role: OpenAiChatRole;
+    content?: unknown;
+}
+/**
+ * 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 declare function extractOpenAiSystemAndLastUser(messages: unknown): {
+    system: string;
+    user: string;
+} | null;
+export type AnthropicRole = "user" | "assistant";
+export interface AnthropicMessage {
+    role: AnthropicRole;
+    content?: unknown;
+}
+export declare function extractAnthropicSystemAndLastUser(args: {
+    system?: unknown;
+    messages: unknown;
+}): {
+    system: string;
+    user: string;
+} | 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 declare function resolveCompatRoomKey(body: Record<string, unknown>, fallback?: string): string;
+//# sourceMappingURL=compat-utils.d.ts.map

package/packages/agent/src/api/compat-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat-utils.d.ts","sourceRoot":"","sources":["../../../../../src/api/compat-utils.ts"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAiBjE;AAED,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,WAAW,GACX,MAAM,GACN,WAAW,GACX,MAAM,GACN,UAAU,CAAC;AAEf,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,OAAO,GAChB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA0BzC;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,WAAW,CAAC;AAEjD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,iCAAiC,CAAC,IAAI,EAAE;IACtD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAkB1C;AAWD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,QAAQ,SAAY,GACnB,MAAM,CAeR"}