@agentshouse/mdruntime 0.1.0-cebcd51f70ed1 → 0.1.0-cedb03eaa48b6

package/dist/chat/provider.js

@@ -0,0 +1,628 @@
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, } from 'react';
+import { AssistantRuntimeProvider, createMessageQueue, generateId, useExternalStoreRuntime, } from '@assistant-ui/react';
+import { attempts } from '../attempt.js';
+import { newChat, } from '../conversation.js';
+import { expectedList } from '../expectation.js';
+import { chatDraftRevision } from '../identity.js';
+import { useObserve } from '../react.js';
+import { accepted, answeredOf, outcomeOf, sender, unanswered, } from './acts.js';
+import { CHAT_WINDOW, useEarlier } from './earlier.js';
+import { askedBefore, chatMessages, contextOf } from './messages.js';
+import { conversationChanged, conversationGone, conversationListed, optionChosen, overlay, questionAnswered, sentMessage, } from './overlay.js';
+import { commandIn, commandsOf, optionsOf } from './process.js';
+import { loneOf, questionsOf } from './questions.js';
+import { record, text } from './read.js';
+const SHARED = new WeakMap();
+const LATEST = { limit: CHAT_WINDOW };
+function sharedOf(client) {
+    const held = SHARED.get(client);
+    if (held !== undefined)
+        return held;
+    const fresh = { overlay: overlay(), created: new Map(), sends: 0 };
+    SHARED.set(client, fresh);
+    return fresh;
+}
+function ready(observed) {
+    return observed.state === 'ready' ? observed.value : null;
+}
+function turnOf(result) {
+    return accepted(result) ? text(record(result.result), 'turn') : null;
+}
+async function deliver(client, send, conversation, said, key, idle) {
+    const result = await send.numbered('conversation.send', { conversation, key }, (operation) => client.conversation.send(conversation, operation, said));
+    if (accepted(result))
+        send.expect(sentMessage(key, [conversation], said, turnOf(result)));
+    else if (!unanswered(result))
+        idle();
+    return result;
+}
+const IDLE = { busy: false, outcome: null };
+const SENDING = { state: 'sending' };
+function useActs(overlay, online) {
+    const [running, setRunning] = useState(IDLE);
+    const [tried] = useState(() => attempts());
+    const latest = useRef(0);
+    const mounted = useRef(true);
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    const clear = useCallback(() => {
+        latest.current += 1;
+        setRunning(IDLE);
+    }, []);
+    const call = useCallback((steps, expected = null, then) => {
+        latest.current += 1;
+        const mine = latest.current;
+        const act = overlay.begin();
+        const drawn = typeof expected === 'function' ? null : expected;
+        overlay.expect(act, drawn);
+        setRunning({ busy: true, outcome: expectedList(drawn).length > 0 ? null : SENDING });
+        const attempt = tried.begin(act);
+        const send = sender({
+            online,
+            identity: attempt.identity,
+            expect: (expecting) => overlay.expect(overlay.begin(), expecting),
+            draw: (expecting) => overlay.expect(act, expecting),
+        });
+        return steps(send)
+            .catch(() => ({
+            kind: 'transport-uncertainty',
+            code: 'transport-uncertainty',
+            fields: {},
+            retryable: true,
+        }))
+            .then((result) => {
+            if (accepted(result) && typeof expected === 'function') {
+                overlay.expect(act, expected(result.result));
+            }
+            attempt.settle(answeredOf(result), (one) => overlay.drop(one));
+            if (!mounted.current || latest.current !== mine)
+                return accepted(result);
+            if (accepted(result))
+                then?.(result.result);
+            if (latest.current === mine)
+                setRunning({ busy: false, outcome: outcomeOf(result) });
+            return accepted(result);
+        });
+    }, [overlay, online, tried]);
+    return { ...running, call, clear };
+}
+const ATTACHMENTS = {
+    accept: '*',
+    add: ({ file }) => Promise.resolve({
+        id: generateId(),
+        type: 'file',
+        name: file.name,
+        contentType: file.type,
+        file,
+        status: { type: 'requires-action', reason: 'composer-send' },
+    }),
+    send: (attachment) => Promise.resolve({ ...attachment, status: { type: 'complete' }, content: [] }),
+    remove: () => Promise.resolve(),
+};
+function filesOf(attachments) {
+    return attachments.flatMap((one) => one.file === undefined ? [] : [{ name: one.name, blob: one.file }]);
+}
+function fileOf(file) {
+    return file.blob instanceof File && file.blob.name === file.name
+        ? file.blob
+        : new File([file.blob], file.name, { type: file.blob.type });
+}
+function textOf(parts) {
+    return parts.map((part) => (part.type === 'text' ? (part.text ?? '') : '')).join('');
+}
+function draftOf(message) {
+    return { text: textOf(message.content), files: filesOf(message.attachments ?? []) };
+}
+function appended(draft) {
+    return {
+        role: 'user',
+        content: [{ type: 'text', text: draft.text }],
+        attachments: draft.files.map((file) => ({
+            id: generateId(),
+            type: 'file',
+            name: file.name,
+            contentType: file.blob.type,
+            file: fileOf(file),
+            status: { type: 'complete' },
+            content: [],
+        })),
+        metadata: { custom: {} },
+        createdAt: new Date(),
+        parentId: null,
+        sourceId: null,
+        runConfig: undefined,
+    };
+}
+function composed(state) {
+    return JSON.stringify([state.text, state.attachments.map((one) => one.id)]);
+}
+const ChatContext = createContext(null);
+const ScopeContext = createContext(null);
+export function useChatScope() {
+    const scope = useContext(ScopeContext);
+    if (scope === null)
+        throw new Error('useChat is called outside a ChatProvider');
+    return scope;
+}
+export function useChat() {
+    const chat = useContext(ChatContext);
+    if (chat === null)
+        throw new Error('useChat is called outside a ChatProvider');
+    return chat;
+}
+export function ChatProvider({ client, conversation = null, agent = null, onOpen, children, }) {
+    const shared = sharedOf(client);
+    const asked = JSON.stringify([conversation, agent]);
+    const [followed, setFollowed] = useState(asked);
+    const [open, setOpen] = useState({ conversation, agent });
+    if (followed !== asked) {
+        setFollowed(asked);
+        setOpen({ conversation, agent });
+    }
+    const opened = useRef(open);
+    opened.current = open;
+    const told = useRef(onOpen);
+    told.current = onOpen;
+    const go = useCallback((next) => {
+        opened.current = next;
+        setOpen(next);
+        told.current?.(next);
+    }, []);
+    const listedHeld = ready(useObserve(client, 'conversations'));
+    const agentsHeld = ready(useObserve(client, 'agents'));
+    const readiness = ready(useObserve(client, 'readiness'));
+    const refusal = ready(useObserve(client, 'connection-refusal'));
+    const online = readiness?.connection !== 'unreachable' && refusal === null;
+    const thread = open.conversation ??
+        (open.agent === null ? null : (shared.created.get(open.agent) ?? newChat(open.agent)));
+    const observed = ready(useObserve(thread === null ? null : client, 'conversation', thread ?? '', LATEST));
+    const held = observed !== null && observed.conversation === thread ? observed : null;
+    const paged = useEarlier(client, thread, held);
+    const version = useSyncExternalStore(shared.overlay.subscribe, shared.overlay.version);
+    useEffect(() => {
+        if (listedHeld !== null)
+            shared.overlay.heardList(listedHeld);
+    }, [shared, listedHeld, version]);
+    useEffect(() => {
+        if (held !== null)
+            shared.overlay.heard(held);
+    }, [shared, held, version]);
+    const conversations = useMemo(() => shared.overlay.conversations(listedHeld ?? []), [shared, listedHeld, version]);
+    const view = useMemo(() => (paged.view === null ? null : shared.overlay.conversation(paged.view)), [shared, paged.view, version]);
+    const agents = agentsHeld ?? [];
+    const known = useRef(agents);
+    known.current = agents;
+    const entry = conversations.find((one) => one.conversation === open.conversation);
+    const running = entry?.state === 'working' || view?.turn != null;
+    const questions = useMemo(() => questionsOf(view), [view]);
+    const lone = loneOf(questions);
+    const commands = useMemo(() => commandsOf(view), [view]);
+    const messages = useMemo(() => chatMessages(view), [view]);
+    const sending = useActs(shared.overlay, online);
+    const behind = useActs(shared.overlay, online);
+    const acting = useActs(shared.overlay, online);
+    const [again, setAgain] = useState(null);
+    const current = useRef(thread);
+    current.current = thread;
+    const seeding = useRef(false);
+    const mounted = useRef(true);
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    const was = useRef(null);
+    const heard = useRef('');
+    const shown = useRef('');
+    const own = useRef([]);
+    const noted = useCallback((to, revision) => {
+        own.current = [...own.current, `${to}\u0000${revision ?? ''}`];
+    }, []);
+    const keep = useCallback((to, draft) => {
+        const revision = draft.text === '' && draft.files.length === 0 ? null : chatDraftRevision();
+        noted(to, revision);
+        void (revision === null
+            ? client.chatDraft.discard(to)
+            : client.chatDraft.write(to, draft, revision));
+    }, [client, noted]);
+    useEffect(() => {
+        heard.current = '';
+        shown.current = '';
+        own.current = own.current.filter((one) => one.startsWith(`${thread}\u0000`));
+        const created = was.current === open;
+        was.current = open;
+        if (created)
+            return;
+        sending.clear();
+        acting.clear();
+        setAgain(null);
+    }, [thread, sending.clear, acting.clear]);
+    const sendTo = (to, said, key, idle, acts = sending) => acts.call((send) => deliver(client, send, to, said, key, idle), sentMessage(key, [to], said, null));
+    const first = (to, said, key, returning, idle) => {
+        const drafted = [newChat(to)];
+        return sending.call(async (send) => {
+            let conversation = shared.created.get(to);
+            if (conversation === undefined) {
+                const answer = await send.carried('conversation.create', { agent: to }, (operation) => client.conversation.create({ agent_id: to, operation_id: operation }));
+                if (!accepted(answer)) {
+                    if (!unanswered(answer)) {
+                        returning();
+                        idle();
+                    }
+                    return answer;
+                }
+                const named = text(record(answer.result), 'conversation');
+                if (named === null)
+                    return answer;
+                conversation = named;
+                shared.created.set(to, conversation);
+                const name = known.current.find((one) => one.identity === to)?.name ?? null;
+                send.expect(conversationListed({
+                    conversation,
+                    agent: { identity: to, name },
+                    name: name ?? '',
+                    created: new Date().toISOString(),
+                    finished: null,
+                    outcome: null,
+                    state: 'idle',
+                    started: null,
+                }));
+            }
+            send.draw(sentMessage(key, [...drafted, conversation], said, null));
+            const result = await deliver(client, send, conversation, said, key, idle);
+            if (!accepted(result))
+                return result;
+            shared.created.delete(to);
+            const now = opened.current;
+            if (mounted.current && now.conversation === null && now.agent === to) {
+                go({ conversation, agent: to });
+            }
+            return result;
+        }, sentMessage(key, drafted, said, null));
+    };
+    const sent = () => {
+        shared.sends += 1;
+        return `sent ${shared.sends}`;
+    };
+    const deliverDraft = (said, returning, idle) => {
+        const key = sent();
+        const { conversation: to, agent: by } = opened.current;
+        const attempt = to !== null
+            ? () => void sendTo(to, said, key, idle)
+            : by !== null
+                ? () => void first(by, said, key, returning, idle)
+                : null;
+        if (attempt === null)
+            return;
+        setAgain(() => attempt);
+        attempt();
+    };
+    const control = (name, input, expected) => acting.call((send) => send.carried(name, input, (operation) => client.call(name, { ...input, operation_id: operation })), expected);
+    const carried = (name, act) => {
+        const to = opened.current.conversation;
+        if (to === null)
+            return Promise.resolve(false);
+        return acting.call((send) => send.carried(name, { conversation: to }, () => act(to)));
+    };
+    const stop = () => carried('conversation.interrupt', (to) => client.conversation.interrupt(to));
+    const kill = () => carried('conversation.kill', (to) => client.conversation.kill(to));
+    const answer = (question, response) => {
+        const to = opened.current.conversation;
+        if (to === null || question.secret)
+            return Promise.resolve(false);
+        return acting.call((send) => send.carried('conversation.answer', { conversation: to, question: question.interaction }, () => client.conversation.answer(to, { interaction_id: question.interaction, response })), () => questionAnswered(to, question.interaction));
+    };
+    const choose = (option, value) => {
+        const to = opened.current.conversation;
+        if (to === null)
+            return Promise.resolve(false);
+        return control('conversation.setOption', { conversation_id: to, option, value }, optionChosen(to, option, value));
+    };
+    const done = (to = opened.current.conversation) => to === null
+        ? Promise.resolve(false)
+        : control('conversation.markDone', { conversation_id: to }, conversationChanged(to, { finished: new Date().toISOString() }, (one) => one.finished !== null));
+    const rename = (name, to = opened.current.conversation) => to === null
+        ? Promise.resolve(false)
+        : control('conversation.rename', { conversation_id: to, name }, conversationChanged(to, { name }, (one) => one.name === name));
+    const remove = (to = opened.current.conversation) => to === null
+        ? Promise.resolve(false)
+        : acting.call((send) => send.carried('conversation.delete', { conversation: to }, () => client.conversation.delete(to)), conversationGone(to), () => {
+            const now = opened.current;
+            if (now.conversation === to)
+                go({ conversation: null, agent: now.agent });
+        });
+    const openConversation = (id) => go({
+        conversation: id,
+        agent: conversations.find((one) => one.conversation === id)?.agent.identity ?? null,
+    });
+    const start = (by) => go({ conversation: null, agent: by });
+    const dispatch = useRef(() => undefined);
+    const queues = useRef(new Map());
+    const into = thread ?? '';
+    const laneOf = (key) => {
+        const held = queues.current.get(key);
+        if (held !== undefined)
+            return held;
+        const fresh = {
+            queue: createMessageQueue({ run: (message) => dispatch.current(message, key) }),
+            running: false,
+        };
+        queues.current.set(key, fresh);
+        return fresh;
+    };
+    const lane = laneOf(into);
+    const queue = lane.queue;
+    const [, moved] = useReducer((count) => count + 1, 0);
+    useEffect(() => queue.subscribe(moved), [queue]);
+    useEffect(() => {
+        for (const [key, one] of queues.current) {
+            const now = key === into
+                ? running
+                : conversations.some((entry) => entry.conversation === key && entry.state !== 'idle');
+            const empty = one.queue.adapter.items.length + one.queue.adapter.steerItems.length === 0;
+            if (key !== into && !now && empty) {
+                queues.current.delete(key);
+                continue;
+            }
+            if (now === one.running)
+                continue;
+            one.running = now;
+            if (now)
+                one.queue.notifyBusy();
+            else
+                one.queue.notifyIdle();
+        }
+    }, [into, running, conversations]);
+    const waiting = useRef(new Map());
+    const lanes = () => [...queue.adapter.steerItems, ...queue.adapter.items];
+    const threads = useMemo(() => {
+        const item = (one) => ({
+            id: one.conversation,
+            title: one.name,
+            custom: { agent: one.agent.identity, state: one.state, finished: one.finished },
+        });
+        return {
+            regular: conversations
+                .filter((one) => one.finished === null)
+                .map((one) => ({ ...item(one), status: 'regular' })),
+            archived: conversations
+                .filter((one) => one.finished !== null)
+                .map((one) => ({ ...item(one), status: 'archived' })),
+        };
+    }, [conversations]);
+    const aui = useExternalStoreRuntime({
+        messages,
+        isRunning: running,
+        hasEarlier: paged.hasEarlier,
+        onLoadEarlier: paged.loadEarlier,
+        convertMessage: (message) => message,
+        queue: lined(),
+        onNew: async (message) => lined().enqueue(message),
+        onCancel: async () => {
+            void stop();
+        },
+        onReload: thread === null
+            ? undefined
+            : async (parent) => {
+                const said = askedBefore(view, parent);
+                if (said === null)
+                    return;
+                const draft = { text: said, files: [] };
+                const into = thread;
+                deliverDraft(draft, () => back(draft, into), () => undefined);
+            },
+        adapters: {
+            attachments: ATTACHMENTS,
+            threadList: {
+                ...(thread === null ? {} : { threadId: thread }),
+                threads: threads.regular,
+                archivedThreads: threads.archived,
+                onSwitchToThread: (id) => openConversation(id),
+                onSwitchToNewThread: () => {
+                    const by = open.agent ?? known.current[0]?.identity;
+                    if (by !== undefined)
+                        start(by);
+                },
+                onRename: (id, name) => {
+                    void rename(name, id);
+                },
+                onArchive: (id) => {
+                    void done(id);
+                },
+                onDelete: (id) => {
+                    void remove(id);
+                },
+            },
+        },
+    });
+    function back(one, into) {
+        if (current.current !== into) {
+            void client.chatDraft.prepend(into, one);
+            return;
+        }
+        const composer = aui.thread.composer;
+        const now = composer.getState().text;
+        composer.setText(now === '' ? one.text : `${one.text}\n${now}`);
+        for (const file of one.files)
+            void composer.addAttachment(fileOf(file));
+    }
+    function taken(message) {
+        const said = textOf(message.content);
+        if (lone === null || commandIn(said, commands))
+            return false;
+        void answer(lone.question, lone.question.accept({ [lone.field.name]: said }));
+        return true;
+    }
+    function lined() {
+        const holding = (put) => (message) => {
+            if (taken(message))
+                return;
+            if (!online) {
+                const draft = draftOf(message);
+                const at = current.current;
+                deliverDraft(draft, () => {
+                    if (at !== null)
+                        back(draft, at);
+                }, () => undefined);
+                return;
+            }
+            const known = new Set(lanes().map((one) => one.id));
+            if (!lane.running)
+                queue.notifyIdle();
+            put(message);
+            const added = lanes().find((one) => !known.has(one.id));
+            if (added !== undefined)
+                waiting.current.set(added.id, message);
+        };
+        return {
+            get items() {
+                return queue.adapter.items;
+            },
+            get steerItems() {
+                return queue.adapter.steerItems;
+            },
+            enqueue: holding(queue.adapter.enqueue),
+            steer: holding(queue.adapter.steer),
+            move: queue.adapter.move,
+            edit: queue.adapter.edit,
+            remove: queue.adapter.remove,
+            __internal_setDispatchTransform: queue.adapter.__internal_setDispatchTransform,
+        };
+    }
+    dispatch.current = (message, key) => {
+        const draft = draftOf(message);
+        const idle = () => queues.current.get(key)?.queue.notifyIdle();
+        if (key !== (current.current ?? '')) {
+            void sendTo(key, draft, sent(), idle, behind);
+            return;
+        }
+        const into = current.current;
+        deliverDraft(draft, () => {
+            if (into !== null)
+                back(draft, into);
+        }, idle);
+    };
+    const unqueue = (id) => {
+        const message = waiting.current.get(id);
+        waiting.current.delete(id);
+        queue.adapter.remove(id);
+        return message;
+    };
+    const edit = (id) => {
+        const item = lanes().find((one) => one.id === id);
+        const message = unqueue(id);
+        if (thread === null || item === undefined)
+            return;
+        back(message === undefined ? { text: textOf(item.parts), files: [] } : draftOf(message), thread);
+    };
+    const reconcile = useRef(() => undefined);
+    reconcile.current = () => {
+        if (thread === null || view === null || seeding.current)
+            return;
+        const at = `${thread}\u0000`;
+        const now = `${at}${view.chatDraft?.revision ?? ''}`;
+        if (now === heard.current)
+            return;
+        const echo = own.current.indexOf(now);
+        const known = heard.current.startsWith(at);
+        heard.current = now;
+        if (known && echo >= 0) {
+            own.current = own.current.slice(echo);
+            return;
+        }
+        own.current = own.current.filter((one) => !one.startsWith(at));
+        const composer = aui.thread.composer;
+        const state = composer.getState();
+        const stored = view.chatDraft;
+        const typed = { text: state.text, files: filesOf(state.attachments) };
+        const kept = !known && (typed.text !== '' || typed.files.length > 0);
+        if (kept && stored === null) {
+            shown.current = `${at}${composed(state)}`;
+            keep(thread, typed);
+            return;
+        }
+        const draft = kept
+            ? {
+                text: [stored?.text ?? '', typed.text].filter((one) => one !== '').join('\n'),
+                files: [...(stored?.files ?? []), ...typed.files],
+            }
+            : stored;
+        if (state.text === (draft?.text ?? '') &&
+            state.attachments.length === 0 &&
+            (draft?.files.length ?? 0) === 0) {
+            shown.current = `${at}${composed(state)}`;
+            return;
+        }
+        seeding.current = true;
+        composer.setText(draft?.text ?? '');
+        void composer
+            .clearAttachments()
+            .then(() => Promise.all((draft?.files ?? []).map((file) => composer.addAttachment(fileOf(file)))))
+            .finally(() => {
+            seeding.current = false;
+            if (current.current !== thread) {
+                reconcile.current();
+                return;
+            }
+            const seeded = composer.getState();
+            shown.current = `${at}${composed(seeded)}`;
+            if (kept)
+                keep(thread, { text: seeded.text, files: filesOf(seeded.attachments) });
+            reconcile.current();
+        });
+    };
+    useEffect(() => reconcile.current(), [aui, thread, view]);
+    useEffect(() => {
+        if (thread === null)
+            return;
+        const at = `${thread}\u0000`;
+        const composer = aui.thread.composer;
+        return composer.subscribe(() => {
+            if (seeding.current || !heard.current.startsWith(at))
+                return;
+            const state = composer.getState();
+            const next = `${at}${composed(state)}`;
+            if (next === shown.current)
+                return;
+            shown.current = next;
+            keep(thread, { text: state.text, files: filesOf(state.attachments) });
+        });
+    }, [aui, thread, keep]);
+    const queued = lanes().map((item) => ({ id: item.id, text: textOf(item.parts) }));
+    const chat = {
+        ...open,
+        conversations,
+        agents,
+        view,
+        running,
+        questions,
+        lone,
+        options: optionsOf(view),
+        commands,
+        context: contextOf(view),
+        queued,
+        sending: { busy: sending.busy, outcome: sending.outcome, again },
+        acting: { busy: acting.busy, outcome: acting.outcome },
+        open: openConversation,
+        start,
+        send: (draft) => lined().enqueue(appended(draft)),
+        answer,
+        choose,
+        stop,
+        kill,
+        done: () => done(),
+        rename: (name) => rename(name),
+        remove: () => remove(),
+        edit,
+        unqueue: (id) => {
+            unqueue(id);
+        },
+    };
+    const scope = useMemo(() => ({ client, known: agentsHeld !== null }), [client, agentsHeld]);
+    return createElement(AssistantRuntimeProvider, { runtime: aui }, createElement(ScopeContext.Provider, { value: scope }, createElement(ChatContext.Provider, { value: chat }, children)));
+}

package/dist/chat/question.d.ts

@@ -0,0 +1,9 @@
+import { type ReactElement } from 'react';
+import type { MdRuntimeClient } from '../client.js';
+import type { ChatQuestion } from './questions.js';
+export declare function forgetAnswers(client: MdRuntimeClient, conversation: string, interaction?: string): Promise<void>;
+export type ChatQuestionCardProps = {
+    readonly question: ChatQuestion;
+};
+export declare function ChatQuestionCard({ question }: ChatQuestionCardProps): ReactElement;
+//# sourceMappingURL=question.d.ts.map

package/dist/chat/question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../src/chat/question.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAGhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAMpD,OAAO,KAAK,EAAa,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAO9D,wBAAsB,aAAa,CACjC,MAAM,EAAE,eAAe,EACvB,YAAY,EAAE,MAAM,EACpB,WAAW,SAAK,GACf,OAAO,CAAC,IAAI,CAAC,CAOf;AAeD,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;CACjC,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,EAAE,qBAAqB,GAAG,YAAY,CAmHlF"}