@travisennis/acai 0.0.4 → 0.0.6

package/dist/api/exa/index.js

@@ -0,0 +1,439 @@
+import { isZodSchema, zodToJsonSchema } from "../../utils/zod-utils.js";
+// Prefer global fetch/Headers from Node >= 18
+const fetchImpl = globalThis.fetch;
+const HeadersImpl = globalThis.Headers;
+/**
+ * HTTP status codes
+ */
+const HttpStatusCode = {
+    badRequest: 400,
+    notFound: 404,
+    unauthorized: 401,
+    forbidden: 403,
+    tooManyRequests: 429,
+    requestTimeout: 408,
+    internalServerError: 500,
+    serviceUnavailable: 503,
+};
+/**
+ * Base error class for all Exa API errors
+ */
+class ExaError extends Error {
+    statusCode;
+    timestamp;
+    path;
+    constructor(message, statusCode, timestamp, path) {
+        super(message);
+        this.name = "ExaError";
+        this.statusCode = statusCode;
+        this.timestamp = timestamp ?? new Date().toISOString();
+        this.path = path;
+    }
+}
+export default class Exa {
+    baseUrl;
+    headers;
+    constructor(apiKey, baseUrl = "https://api.exa.ai") {
+        this.baseUrl = baseUrl;
+        let resolvedKey = apiKey;
+        if (!resolvedKey) {
+            resolvedKey = process.env["EXA_API_KEY"];
+            if (!resolvedKey) {
+                throw new ExaError("API key must be provided as an argument or as an environment variable (EXA_API_KEY)", HttpStatusCode.unauthorized);
+            }
+        }
+        // Build base headers
+        const headers = new HeadersImpl();
+        headers.set("x-api-key", resolvedKey);
+        headers.set("Content-Type", "application/json");
+        headers.set("User-Agent", "acai-exa");
+        // Store as a simple record for easier merging and type safety in this codebase
+        const headerRecord = {};
+        headers.forEach((value, key) => {
+            headerRecord[key] = value;
+        });
+        this.headers = headerRecord;
+    }
+    extractContentsOptions(options) {
+        const { text, highlights, summary, subpages, subpageTarget, extras, livecrawl, livecrawlTimeout, context, ...rest } = options;
+        const contentsOptions = {};
+        if (text === undefined &&
+            summary === undefined &&
+            highlights === undefined &&
+            extras === undefined) {
+            contentsOptions.text = true;
+        }
+        if (text !== undefined)
+            contentsOptions.text = text;
+        if (summary !== undefined) {
+            if (typeof summary === "object" &&
+                summary !== null &&
+                "schema" in summary &&
+                summary.schema &&
+                isZodSchema(summary.schema)) {
+                const { schema, ...restSummary } = summary;
+                contentsOptions.summary = {
+                    ...restSummary,
+                    schema: zodToJsonSchema(schema),
+                };
+            }
+            else {
+                contentsOptions.summary = summary;
+            }
+        }
+        if (highlights !== undefined)
+            contentsOptions.highlights = highlights;
+        if (subpages !== undefined)
+            contentsOptions.subpages = subpages;
+        if (subpageTarget !== undefined)
+            contentsOptions.subpageTarget = subpageTarget;
+        if (extras !== undefined)
+            contentsOptions.extras = extras;
+        if (livecrawl !== undefined)
+            contentsOptions.livecrawl = livecrawl;
+        if (livecrawlTimeout !== undefined)
+            contentsOptions.livecrawlTimeout = livecrawlTimeout;
+        if (context !== undefined)
+            contentsOptions.context = context;
+        return {
+            contentsOptions,
+            restOptions: rest,
+        };
+    }
+    async request(endpoint, method, body, params, headers) {
+        if (!fetchImpl) {
+            throw new ExaError("Global fetch is not available in this environment.", HttpStatusCode.internalServerError);
+        }
+        let url = this.baseUrl + endpoint;
+        if (params && Object.keys(params).length > 0) {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        searchParams.append(key, String(item));
+                    }
+                }
+                else if (value !== undefined && value !== null) {
+                    searchParams.append(key, String(value));
+                }
+            }
+            url += `?${searchParams.toString()}`;
+        }
+        const combinedHeaders = {
+            ...this.headers,
+            ...(headers ?? {}),
+        };
+        const response = await fetchImpl(url, {
+            method,
+            headers: combinedHeaders,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            let errorMessage = `HTTP ${response.status}`;
+            let errorTimestamp;
+            let errorPath = endpoint;
+            try {
+                const errorData = await response.json();
+                const message = (errorData &&
+                    (errorData.error || errorData.message));
+                if (typeof message === "string" && message.length > 0) {
+                    errorMessage = message;
+                }
+                errorTimestamp =
+                    (errorData && errorData.timestamp) ??
+                        new Date().toISOString();
+                errorPath =
+                    (errorData && errorData.path) ?? endpoint;
+            }
+            catch {
+                // ignore body parse errors
+            }
+            throw new ExaError(errorMessage, response.status, errorTimestamp, errorPath);
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("text/event-stream")) {
+            return (await this.parseSseStream(response));
+        }
+        return (await response.json());
+    }
+    async rawRequest(endpoint, method = "POST", body, queryParams) {
+        if (!fetchImpl) {
+            throw new ExaError("Global fetch is not available in this environment.", HttpStatusCode.internalServerError);
+        }
+        let url = this.baseUrl + endpoint;
+        if (queryParams) {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(queryParams)) {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        searchParams.append(key, String(item));
+                    }
+                }
+                else if (value !== undefined && value !== null) {
+                    searchParams.append(key, String(value));
+                }
+            }
+            url += `?${searchParams.toString()}`;
+        }
+        const response = await fetchImpl(url, {
+            method,
+            headers: this.headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        return response;
+    }
+    async search(query, options) {
+        return await this.request("/search", "POST", { query, ...options });
+    }
+    async searchAndContents(query, options) {
+        const { contentsOptions, restOptions } = options === undefined
+            ? {
+                contentsOptions: { text: true },
+                restOptions: {},
+            }
+            : this.extractContentsOptions(options);
+        return await this.request("/search", "POST", {
+            query,
+            contents: contentsOptions,
+            ...restOptions,
+        });
+    }
+    async findSimilar(url, options) {
+        return await this.request("/findSimilar", "POST", { url, ...options });
+    }
+    async findSimilarAndContents(url, options) {
+        const { contentsOptions, restOptions } = options === undefined
+            ? {
+                contentsOptions: { text: true },
+                restOptions: {},
+            }
+            : this.extractContentsOptions(options);
+        return await this.request("/findSimilar", "POST", {
+            url,
+            contents: contentsOptions,
+            ...restOptions,
+        });
+    }
+    async getContents(urls, options) {
+        if (!urls || (Array.isArray(urls) && urls.length === 0)) {
+            throw new ExaError("Must provide at least one URL", HttpStatusCode.badRequest);
+        }
+        let requestUrls;
+        if (typeof urls === "string") {
+            requestUrls = [urls];
+        }
+        else if (Array.isArray(urls) && typeof urls[0] === "string") {
+            requestUrls = urls;
+        }
+        else {
+            requestUrls = urls.map((result) => result.url);
+        }
+        const payload = {
+            urls: requestUrls,
+            ...(options ?? {}),
+        };
+        return await this.request("/contents", "POST", payload);
+    }
+    async answer(query, options) {
+        if (options?.stream) {
+            throw new ExaError("For streaming responses, please use streamAnswer() instead:\n\n" +
+                "for await (const chunk of exa.streamAnswer(query)) {\n" +
+                "  // Handle chunks\n" +
+                "}", HttpStatusCode.badRequest);
+        }
+        let outputSchema = options
+            ?.outputSchema;
+        if (outputSchema && isZodSchema(outputSchema)) {
+            outputSchema = zodToJsonSchema(outputSchema);
+        }
+        const requestBody = {
+            query,
+            stream: false,
+            text: options?.text ?? false,
+            model: options?.model ?? "exa",
+            systemPrompt: options
+                ?.systemPrompt,
+            outputSchema,
+            userLocation: options
+                ?.userLocation,
+        };
+        return await this.request("/answer", "POST", requestBody);
+    }
+    async *streamAnswer(query, options) {
+        if (!fetchImpl) {
+            throw new ExaError("Global fetch is not available in this environment.", HttpStatusCode.internalServerError);
+        }
+        let outputSchema = options?.outputSchema;
+        if (outputSchema && isZodSchema(outputSchema)) {
+            outputSchema = zodToJsonSchema(outputSchema);
+        }
+        const body = {
+            query,
+            text: options?.text ?? false,
+            stream: true,
+            model: options?.model ?? "exa",
+            systemPrompt: options?.systemPrompt,
+            outputSchema,
+        };
+        const response = await fetchImpl(`${this.baseUrl}/answer`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const message = await response.text();
+            throw new ExaError(message, response.status, new Date().toISOString());
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new ExaError("No response body available for streaming.", 500, new Date().toISOString());
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (!line.startsWith("data: "))
+                        continue;
+                    const jsonStr = line.replace(/^data:\s*/, "").trim();
+                    if (!jsonStr || jsonStr === "[DONE]") {
+                        continue;
+                    }
+                    let chunkData;
+                    try {
+                        chunkData = JSON.parse(jsonStr);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const chunk = this.processChunk(chunkData);
+                    if (chunk.content || chunk.citations) {
+                        yield chunk;
+                    }
+                }
+            }
+            if (buffer.startsWith("data: ")) {
+                const leftover = buffer.replace(/^data:\s*/, "").trim();
+                if (leftover && leftover !== "[DONE]") {
+                    try {
+                        const chunkData = JSON.parse(leftover);
+                        const chunk = this.processChunk(chunkData);
+                        if (chunk.content || chunk.citations) {
+                            yield chunk;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    processChunk(chunkData) {
+        let content;
+        let citations;
+        const data = chunkData;
+        const choices = data?.["choices"] ?? undefined;
+        if (choices?.[0]?.delta) {
+            const c = choices[0].delta.content;
+            if (typeof c === "string") {
+                content = c;
+            }
+        }
+        const rawCitations = data?.["citations"];
+        if (rawCitations &&
+            rawCitations !== "null" &&
+            Array.isArray(rawCitations)) {
+            citations = rawCitations.map((c) => ({
+                id: String(c["id"] ?? ""),
+                url: String(c["url"] ?? ""),
+                title: typeof c["title"] === "string"
+                    ? c["title"]
+                    : undefined,
+                publishedDate: typeof c["publishedDate"] === "string"
+                    ? c["publishedDate"]
+                    : undefined,
+                author: typeof c["author"] === "string"
+                    ? c["author"]
+                    : undefined,
+                text: typeof c["text"] === "string"
+                    ? c["text"]
+                    : undefined,
+            }));
+        }
+        return { content, citations };
+    }
+    async parseSseStream(response) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new ExaError("No response body available for streaming.", 500, new Date().toISOString());
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        return await new Promise((resolve, reject) => {
+            (async () => {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split("\n");
+                        buffer = lines.pop() ?? "";
+                        for (const line of lines) {
+                            if (!line.startsWith("data: "))
+                                continue;
+                            const jsonStr = line.replace(/^data:\s*/, "").trim();
+                            if (!jsonStr || jsonStr === "[DONE]") {
+                                continue;
+                            }
+                            let chunk;
+                            try {
+                                chunk = JSON.parse(jsonStr);
+                            }
+                            catch {
+                                continue;
+                            }
+                            const tagged = chunk;
+                            switch (tagged.tag) {
+                                case "complete":
+                                    reader.releaseLock();
+                                    resolve(tagged.data);
+                                    return;
+                                case "error": {
+                                    const message = tagged.error?.message || "Unknown error";
+                                    reader.releaseLock();
+                                    reject(new ExaError(message, HttpStatusCode.internalServerError, new Date().toISOString()));
+                                    return;
+                                }
+                                default:
+                                    break;
+                            }
+                        }
+                    }
+                    reject(new ExaError("Stream ended without a completion event.", HttpStatusCode.internalServerError, new Date().toISOString()));
+                }
+                catch (err) {
+                    reject(err);
+                }
+                finally {
+                    try {
+                        reader.releaseLock();
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            })();
+        });
+    }
+}

package/dist/cli.d.ts

@@ -1,8 +1,9 @@
+import type { WorkspaceContext } from "./index.ts";
 import type { MessageHistory } from "./messages.ts";
 import type { ModelManager } from "./models/manager.js";
 import type { PromptManager } from "./prompts/manager.ts";
-import type { TokenTracker } from "./token-tracker.ts";
-import type { TokenCounter } from "./token-utils.ts";
+import type { TokenCounter } from "./tokens/counter.ts";
+import type { TokenTracker } from "./tokens/tracker.ts";
 interface CliOptions {
     messageHistory: MessageHistory;
     promptManager: PromptManager;
@@ -10,6 +11,7 @@ interface CliOptions {
     tokenTracker: TokenTracker;
     config: Record<PropertyKey, unknown>;
     tokenCounter: TokenCounter;
+    workspace: WorkspaceContext;
 }
 export declare class Cli {
     private options;
@@ -17,3 +19,4 @@ export declare class Cli {
     run(): Promise<void>;
 }
 export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../source/cli.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AASxD,UAAU,UAAU;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACrC,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;CAC7B;AAWD,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;gBAChB,OAAO,EAAE,UAAU;IAIzB,GAAG;CAkFV"}

package/dist/cli.js

@@ -2,12 +2,21 @@ import { generateObject, generateText, NoSuchToolError, stepCountIs, } from "ai"
 import { logger } from "./logger.js";
 import { AiConfig } from "./models/ai-config.js";
 import { minSystemPrompt } from "./prompts.js";
-import { DeleteFileTool } from "./tools/delete-file.js";
+import { BashTool } from "./tools/bash.js";
+import { CodeInterpreterTool } from "./tools/code-interpreter.js";
 import { EditFileTool } from "./tools/edit-file.js";
+import { GlobTool } from "./tools/glob.js";
+import { GrepTool } from "./tools/grep.js";
 import { initCliTools } from "./tools/index.js";
-import { MoveFileTool } from "./tools/move-file.js";
-import { SaveFileTool } from "./tools/save-file.js";
-import { ThinkTool } from "./tools/think.js";
+import { ReadFileTool } from "./tools/read-file.js";
+const activeTools = [
+    EditFileTool.name,
+    ReadFileTool.name,
+    BashTool.name,
+    GrepTool.name,
+    GlobTool.name,
+    CodeInterpreterTool.name,
+];
 export class Cli {
     options;
     constructor(options) {
@@ -33,41 +42,25 @@ export class Cli {
             modelMetadata: modelConfig,
             prompt: userPrompt,
         });
-        const maxTokens = aiConfig.getMaxTokens();
-        const tools = modelConfig.supportsToolCalling
-            ? await initCliTools({ tokenCounter })
-            : undefined;
+        const tools = await initCliTools({
+            tokenCounter,
+            workspace: this.options.workspace,
+        });
         try {
             const result = await generateText({
                 model: langModel,
-                maxOutputTokens: maxTokens,
-                messages: [
-                    {
-                        role: "system",
-                        content: finalSystemPrompt,
-                        providerOptions: {
-                            anthropic: { cacheControl: { type: "ephemeral" } },
-                        },
-                    },
-                    ...messageHistory.get(),
-                ],
-                temperature: modelConfig.defaultTemperature,
+                maxOutputTokens: aiConfig.maxOutputTokens(),
+                system: finalSystemPrompt,
+                messages: messageHistory.get(),
+                temperature: aiConfig.temperature(),
+                topP: aiConfig.topP(),
                 stopWhen: stepCountIs(60),
                 maxRetries: 2,
-                providerOptions: aiConfig.getProviderOptions(),
-                tools,
-                // biome-ignore lint/style/useNamingConvention: third-party controlled
-                experimental_activeTools: [
-                    EditFileTool.name,
-                    SaveFileTool.name,
-                    MoveFileTool.name,
-                    DeleteFileTool.name,
-                    ThinkTool.name,
-                ],
+                providerOptions: aiConfig.providerOptions(),
+                tools: tools.toolDefs,
+                activeTools,
                 // biome-ignore lint/style/useNamingConvention: third-party controlled
-                experimental_repairToolCall: modelConfig.supportsToolCalling
-                    ? toolCallRepair(modelManager)
-                    : undefined,
+                experimental_repairToolCall: toolCallRepair(modelManager),
                 abortSignal: signal,
             });
             if (result.response.messages.length > 0) {
@@ -75,6 +68,7 @@ export class Cli {
             }
             // this tracks the usage of every step in the call to streamText. it's a cumulative usage.
             tokenTracker.trackUsage("cli", result.usage);
+            messageHistory.save();
             process.stdout.end(result.text.endsWith("\n") ? result.text : `${result.text}\n`);
         }
         catch (e) {

package/dist/commands/add-directory-command.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const addDirectoryCommand: ({ terminal, workspace, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=add-directory-command.d.ts.map

package/dist/commands/add-directory-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-directory-command.d.ts","sourceRoot":"","sources":["../../source/commands/add-directory-command.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,mBAAmB,GAAI,0BAGjC,cAAc,KAAG,WAkInB,CAAC"}

package/dist/commands/add-directory-command.js

@@ -0,0 +1,85 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import style from "../terminal/style.js";
+import { Text } from "../tui/index.js";
+export const addDirectoryCommand = ({ terminal, workspace, }) => {
+    return {
+        command: "/add-directory",
+        description: "Add a directory to the list of allowed working directories",
+        getSubCommands: async () => {
+            return [];
+        },
+        execute: async (args) => {
+            const directoryPath = args?.[0];
+            if (!directoryPath) {
+                terminal.error("Usage: /add-directory <path>");
+                return "continue";
+            }
+            try {
+                // Resolve and validate the directory
+                const resolvedPath = path.resolve(directoryPath);
+                const stats = await fs.stat(resolvedPath);
+                if (!stats.isDirectory()) {
+                    terminal.error(`Path is not a directory: ${resolvedPath}`);
+                    return "continue";
+                }
+                // Check if directory is already in the list
+                if (workspace.allowedDirs.includes(resolvedPath)) {
+                    terminal.warn(`Directory already in allowed list: ${resolvedPath}`);
+                    return "continue";
+                }
+                // Add the directory to the workspace
+                workspace.allowedDirs.push(resolvedPath);
+                terminal.writeln(`Added directory to allowed list: ${style.blue(resolvedPath)}`);
+                terminal.writeln(`Current allowed directories: ${style.blue(workspace.allowedDirs.join(", "))}`);
+                return "continue";
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                terminal.error(`Failed to add directory: ${errorMessage}`);
+                return "continue";
+            }
+        },
+        async handle(args, { tui, container, editor, }) {
+            const directoryPath = args?.[0];
+            if (!directoryPath) {
+                container.addChild(new Text(style.red("Usage: /add-directory <path>"), 0, 1));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            try {
+                // Resolve and validate the directory
+                const resolvedPath = path.resolve(directoryPath);
+                const stats = await fs.stat(resolvedPath);
+                if (!stats.isDirectory()) {
+                    container.addChild(new Text(style.red(`Path is not a directory: ${resolvedPath}`), 1, 0));
+                    tui.requestRender();
+                    editor.setText("");
+                    return "continue";
+                }
+                // Check if directory is already in the list
+                if (workspace.allowedDirs.includes(resolvedPath)) {
+                    container.addChild(new Text(style.yellow(`Directory already in allowed list: ${resolvedPath}`), 1, 0));
+                    tui.requestRender();
+                    editor.setText("");
+                    return "continue";
+                }
+                // Add the directory to the workspace
+                workspace.allowedDirs.push(resolvedPath);
+                container.addChild(new Text(`Added directory to allowed list: ${style.blue(resolvedPath)}`, 1, 0));
+                container.addChild(new Text(`Current allowed directories: ${style.blue(workspace.allowedDirs.join(", "))}`, 2, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                container.addChild(new Text(style.red(`Failed to add directory: ${errorMessage}`), 0, 1));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+        },
+    };
+};

package/dist/commands/application-log-command.d.ts

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
 export declare const applicationLogCommand: ({ terminal, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=application-log-command.d.ts.map

package/dist/commands/application-log-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-log-command.d.ts","sourceRoot":"","sources":["../../source/commands/application-log-command.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,qBAAqB,GAAI,eAEnC,cAAc,KAAG,WAwHnB,CAAC"}