@fromsko/chat-ui 0.0.0-stage → 0.1.6

package/lib/blocks/tool/ToolGroup.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { ChevronDown, Wrench } from "lucide-react";
+import { cn } from "../../utils/cn";
+import { toolGroupLabel } from "../../domain/message-blocks";
+const STATUS_TEXT = {
+    running: "执行中",
+    done: "",
+    error: "有失败",
+};
+function groupStatus(parts) {
+    if (parts.some((p) => p.part.state === "error"))
+        return "error";
+    if (parts.some((p) => p.part.state === "running"))
+        return "running";
+    return "done";
+}
+export function ToolGroup({ parts, renderPart }) {
+    const [open, setOpen] = useState(false);
+    const status = groupStatus(parts);
+    const names = parts.map((p) => toolGroupLabel(p.part)).join(", ");
+    return (_jsxs("div", { className: "ac-tools", "data-cmp": "ac/tool-group", "data-state": open ? "open" : "closed", "data-status": status, children: [_jsxs("button", { type: "button", className: "ac-tools__trigger", "aria-expanded": open, onClick: () => setOpen((v) => !v), children: [_jsx("span", { className: "ac-tools__dot", "data-status": status }), status !== "done" ? (_jsx("span", { className: "sr-only", children: STATUS_TEXT[status] })) : null, _jsx(Wrench, { "aria-hidden": "true", size: 12 }), _jsxs("span", { className: "ac-tools__title", children: ["\u8FDB\u884C\u4E86 ", parts.length, " \u4E2A\u64CD\u4F5C"] }), _jsx("span", { className: "ac-tools__names", title: names, children: names }), _jsx(ChevronDown, { "aria-hidden": "true", size: 12, className: cn("ac-tools__chevron", open && "rotate-180") })] }), open ? (_jsx("div", { className: "ac-tools__body", children: parts.map((item) => renderPart ? (renderPart(item)) : (_jsx("div", { className: "text-xs text-muted-foreground", children: toolGroupLabel(item.part) }, item.key))) })) : null] }));
+}

package/lib/blocks/tool/exec-envelope.d.ts

@@ -0,0 +1,7 @@
+import type { ExecEnvelope } from "../../types/message";
+export declare function parseExecResult(result: string | undefined): ExecEnvelope | null;
+export declare function prettyResult(result: string): string;
+export declare function diffStatOf(result: string | undefined): {
+    add: number;
+    del: number;
+} | null;

package/lib/blocks/tool/exec-envelope.js

@@ -0,0 +1,43 @@
+export function parseExecResult(result) {
+    if (!result)
+        return null;
+    try {
+        const parsed = JSON.parse(result);
+        if (parsed !== null &&
+            typeof parsed === "object" &&
+            typeof parsed.exit_code === "number") {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function prettyResult(result) {
+    try {
+        return JSON.stringify(JSON.parse(result), null, 2);
+    }
+    catch {
+        return result;
+    }
+}
+export function diffStatOf(result) {
+    if (!result)
+        return null;
+    let text = result;
+    const envelope = parseExecResult(result);
+    if (envelope)
+        text = envelope.stdout || envelope.stderr || "";
+    let add = 0;
+    let del = 0;
+    for (const line of text.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            add += 1;
+        else if (line.startsWith("-") && !line.startsWith("---"))
+            del += 1;
+    }
+    if (add === 0 && del === 0)
+        return null;
+    return { add, del };
+}

package/lib/blocks/tool/index.d.ts

@@ -0,0 +1,4 @@
+export { parseExecResult, prettyResult } from "./exec-envelope";
+export { ToolCard, type ToolCardProps } from "./ToolCard";
+export { ToolGroup, type ToolGroupProps } from "./ToolGroup";
+export { SandboxCard, type SandboxCardProps } from "./SandboxCard";

package/lib/blocks/tool/index.js

@@ -0,0 +1,4 @@
+export { parseExecResult, prettyResult } from "./exec-envelope";
+export { ToolCard } from "./ToolCard";
+export { ToolGroup } from "./ToolGroup";
+export { SandboxCard } from "./SandboxCard";

package/lib/domain/ask.d.ts

@@ -0,0 +1,14 @@
+import type { PendingAsk, PendingAskQuestion } from "../types/conversation";
+export declare const ASK_SKIP_SENTINEL = "\uFF08\u672C\u8F6E\u5DF2\u7ED3\u675F\uFF0C\u63D0\u95EE\u5DF2\u53D6\u6D88\uFF0C\u8BF7\u81EA\u884C\u51B3\u65AD\uFF09";
+export declare function isBatchAsk(ask: PendingAsk | null): boolean;
+export declare function askPlaceholder(ask: PendingAsk | null): string | undefined;
+export declare function mergePendingAsk(prev: PendingAsk[], ask: PendingAsk): PendingAsk[];
+export declare function dropPendingAsk(prev: PendingAsk[], callId: string): PendingAsk[];
+export declare function firstPendingAsk(prev: PendingAsk[]): PendingAsk | null;
+export declare function clampAskIndex(index: number, count: number): number;
+export declare function stashAnswer(answers: Readonly<Record<string, string>>, questionId: string, text: string): Record<string, string>;
+export declare function batchAnswersOf(questions: readonly PendingAskQuestion[], answers: Readonly<Record<string, string>>): string;
+export declare function defaultAnswersOf(questions: readonly PendingAskQuestion[]): Record<string, string>;
+export declare function canDefaultAll(questions: readonly PendingAskQuestion[]): boolean;
+export declare function answeredCount(questions: readonly PendingAskQuestion[], answers: Readonly<Record<string, string>>): number;
+export declare const MAX_ASK_QUESTIONS = 3;

package/lib/domain/ask.js

@@ -0,0 +1,50 @@
+export const ASK_SKIP_SENTINEL = "（本轮已结束，提问已取消，请自行决断）";
+export function isBatchAsk(ask) {
+    return ask != null && ask.questions.length > 0;
+}
+export function askPlaceholder(ask) {
+    if (!ask || ask.questions.length > 0)
+        return undefined;
+    return `回答：${ask.prompt.slice(0, 24)}`;
+}
+export function mergePendingAsk(prev, ask) {
+    const without = prev.filter((a) => a.callId !== ask.callId);
+    return [...without, ask];
+}
+export function dropPendingAsk(prev, callId) {
+    return prev.filter((a) => a.callId !== callId);
+}
+export function firstPendingAsk(prev) {
+    return prev[0] ?? null;
+}
+export function clampAskIndex(index, count) {
+    if (count === 0)
+        return 0;
+    return Math.max(0, Math.min(index, count - 1));
+}
+export function stashAnswer(answers, questionId, text) {
+    return { ...answers, [questionId]: text };
+}
+export function batchAnswersOf(questions, answers) {
+    return JSON.stringify(questions.map((q) => ({
+        id: q.id,
+        answer: (answers[q.id] ?? "").trim(),
+    })));
+}
+export function defaultAnswersOf(questions) {
+    const out = {};
+    for (const q of questions) {
+        const pick = q.default ?? q.choices[0] ?? "";
+        if (pick)
+            out[q.id] = pick;
+    }
+    return out;
+}
+export function canDefaultAll(questions) {
+    return (questions.length > 0 &&
+        questions.every((q) => Boolean(q.default ?? q.choices[0])));
+}
+export function answeredCount(questions, answers) {
+    return questions.filter((q) => (answers[q.id] ?? "").trim().length > 0).length;
+}
+export const MAX_ASK_QUESTIONS = 3;

package/lib/domain/attachments.d.ts

@@ -0,0 +1,16 @@
+import type { Attachment } from "../types/message";
+import type { IncomingPlan, PickedFile } from "../types/composer";
+export declare const MAX_ATTACHMENT_BYTES: number;
+export declare const MAX_ATTACHMENTS = 9;
+export declare const MAX_VIDEO_BYTES: number;
+export declare const MAX_VIDEOS = 3;
+export declare const MAX_TEXT_BYTES: number;
+export declare const MAX_TEXT_FILES = 3;
+export declare function isTextFile(file: PickedFile): boolean;
+export declare function formatBytes(bytes: number): string;
+export declare function planIncoming<T extends PickedFile>(existingImages: number, existingVideos: number, files: readonly T[]): IncomingPlan<T>;
+export declare function attachmentColumns(count: number): 1 | 2 | 3;
+export declare function attachmentSrc(attachment: Attachment): string;
+export declare function attachmentFromDataUrl(filename: string, fallbackType: string, dataUrl: string): Attachment | null;
+export declare function readAttachment(file: File): Promise<Attachment>;
+export declare function textFileToFence(name: string, content: string): string;

package/lib/domain/attachments.js

@@ -0,0 +1,126 @@
+export const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+export const MAX_ATTACHMENTS = 9;
+export const MAX_VIDEO_BYTES = 25 * 1024 * 1024;
+export const MAX_VIDEOS = 3;
+export const MAX_TEXT_BYTES = 256 * 1024;
+export const MAX_TEXT_FILES = 3;
+const TEXT_EXTENSIONS = new Set([
+    "txt", "md", "markdown", "json", "rs", "ts", "tsx", "js", "jsx", "py",
+    "toml", "yaml", "yml", "csv", "log", "css", "html", "sql", "sh", "ini",
+]);
+export function isTextFile(file) {
+    if (file.type.startsWith("text/"))
+        return true;
+    const dot = file.name.lastIndexOf(".");
+    return dot >= 0 && TEXT_EXTENSIONS.has(file.name.slice(dot + 1).toLowerCase());
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function planIncoming(existingImages, existingVideos, files) {
+    const plan = {
+        images: [],
+        videos: [],
+        texts: [],
+        rejected: [],
+    };
+    let images = existingImages;
+    let videos = existingVideos;
+    let texts = 0;
+    for (const file of files) {
+        if (file.type.startsWith("image/")) {
+            if (images >= MAX_ATTACHMENTS) {
+                plan.rejected.push({ name: file.name, reason: `图片最多 ${MAX_ATTACHMENTS} 张` });
+            }
+            else if (file.size > MAX_ATTACHMENT_BYTES) {
+                plan.rejected.push({
+                    name: file.name,
+                    reason: `图片过大（${formatBytes(file.size)}），上限 ${formatBytes(MAX_ATTACHMENT_BYTES)}`,
+                });
+            }
+            else {
+                plan.images.push(file);
+                images += 1;
+            }
+            continue;
+        }
+        if (file.type.startsWith("video/")) {
+            if (videos >= MAX_VIDEOS) {
+                plan.rejected.push({ name: file.name, reason: `视频最多 ${MAX_VIDEOS} 个` });
+            }
+            else if (file.size > MAX_VIDEO_BYTES) {
+                plan.rejected.push({
+                    name: file.name,
+                    reason: `视频过大（${formatBytes(file.size)}），上限 ${formatBytes(MAX_VIDEO_BYTES)}`,
+                });
+            }
+            else {
+                plan.videos.push(file);
+                videos += 1;
+            }
+            continue;
+        }
+        if (isTextFile(file)) {
+            if (texts >= MAX_TEXT_FILES) {
+                plan.rejected.push({ name: file.name, reason: `文本文件最多 ${MAX_TEXT_FILES} 个` });
+            }
+            else if (file.size > MAX_TEXT_BYTES) {
+                plan.rejected.push({
+                    name: file.name,
+                    reason: `文本过大（${formatBytes(file.size)}），请分段粘贴`,
+                });
+            }
+            else {
+                plan.texts.push(file);
+                texts += 1;
+            }
+            continue;
+        }
+        plan.rejected.push({ name: file.name, reason: `不支持的类型（${file.type || "未知"}）` });
+    }
+    return plan;
+}
+export function attachmentColumns(count) {
+    if (count <= 1)
+        return 1;
+    if (count <= 4)
+        return 2;
+    return 3;
+}
+export function attachmentSrc(attachment) {
+    return `data:${attachment.media_type};base64,${attachment.data_base64}`;
+}
+export function attachmentFromDataUrl(filename, fallbackType, dataUrl) {
+    const m = /^data:([^;,]*);base64,(.*)$/.exec(dataUrl);
+    if (!m)
+        return null;
+    return {
+        media_type: m[1] || fallbackType,
+        data_base64: m[2],
+        filename: filename.trim().length > 0 ? filename.trim() : null,
+    };
+}
+export function readAttachment(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const result = typeof reader.result === "string" ? reader.result : "";
+            const parsed = attachmentFromDataUrl(file.name, file.type, result);
+            if (parsed)
+                resolve(parsed);
+            else
+                reject(new Error(`读取附件失败：${file.name}`));
+        };
+        reader.onerror = () => reject(new Error(`读取附件失败：${file.name}`));
+        reader.readAsDataURL(file);
+    });
+}
+export function textFileToFence(name, content) {
+    const normalized = content.replace(/\r\n?/g, "\n");
+    const fenced = normalized.replace(/`{3,}/g, "``");
+    return `#### 📄 ${name}\n\`\`\`\n${fenced}\n\`\`\`\n`;
+}

package/lib/domain/attribution.d.ts

@@ -0,0 +1,4 @@
+import type { Agent } from "../types/agent";
+import type { SenderAttribution } from "../types/agent";
+import type { ChatMessage } from "../types/message";
+export declare function attributionOf(message: Pick<ChatMessage, "agentId">, agentById: Record<string, Agent>): SenderAttribution;

package/lib/domain/attribution.js

@@ -0,0 +1,11 @@
+export function attributionOf(message, agentById) {
+    const id = message.agentId;
+    if (!id) {
+        return { name: "Agent", badge: "?" };
+    }
+    const agent = agentById[id];
+    if (agent) {
+        return { name: agent.name, badge: agent.badge, agent };
+    }
+    return { name: "未知成员", badge: id.slice(0, 1).toUpperCase() };
+}

package/lib/domain/composer-palette.d.ts

@@ -0,0 +1,15 @@
+import type { Agent } from "../types/agent";
+import type { PaletteFileEntry, PaletteItem, PaletteKeyAction, PaletteSource, SlashCommand, TriggerToken } from "../types/composer";
+export declare function detectTriggerToken(text: string, caret: number): TriggerToken | null;
+export declare function buildMentionItems(members: Agent[], rawQuery: string): PaletteItem[];
+export declare const SKILL_COMMAND_ID_PREFIX = "skill:";
+export declare function skillNameOfCommand(command: SlashCommand): string | null;
+export declare function buildAgentSkillItems(agent: Agent, skillCommands: readonly SlashCommand[], rawQuery?: string): PaletteItem[];
+export declare const FILE_CANDIDATE_LIMIT = 8;
+export declare function filterFileCandidates(entries: readonly PaletteFileEntry[], rawQuery: string, limit?: number): PaletteItem[];
+export declare function buildPaletteItems(token: TriggerToken, source: PaletteSource): PaletteItem[];
+export declare function moveIndex(index: number, delta: number, length: number): number;
+export declare function paletteKeyDownAction(key: string, shift: boolean): PaletteKeyAction | null;
+export type PaletteRecencyId = string;
+export declare function paletteRecencyId(item: PaletteItem): PaletteRecencyId;
+export declare function rankByRecency(items: PaletteItem[], recent: readonly string[]): PaletteItem[];

package/lib/domain/composer-palette.js

@@ -0,0 +1,131 @@
+import { filterSlashCommands } from "./slash-commands";
+const MENTION_RE = /(?:^|\s)@([^\s@]*)$/;
+const SLASH_RE = /(?:^|\s)\/([^\s/]*)$/;
+export function detectTriggerToken(text, caret) {
+    const before = text.slice(0, caret);
+    const slash = SLASH_RE.exec(before);
+    const mention = MENTION_RE.exec(before);
+    if (!slash && !mention)
+        return null;
+    let m;
+    let trigger;
+    if (slash && mention) {
+        if (slash.index >= mention.index) {
+            m = slash;
+            trigger = "/";
+        }
+        else {
+            m = mention;
+            trigger = "@";
+        }
+    }
+    else if (slash) {
+        m = slash;
+        trigger = "/";
+    }
+    else {
+        m = mention;
+        trigger = "@";
+    }
+    return {
+        trigger,
+        start: m.index + (m[0].startsWith(" ") ? 1 : 0),
+        query: m[1] ?? "",
+    };
+}
+export function buildMentionItems(members, rawQuery) {
+    const q = rawQuery.trim().toLowerCase();
+    const includeAll = q.length === 0 || "所有人".includes(q) || "all".startsWith(q);
+    const items = [];
+    if (includeAll)
+        items.push({ kind: "all" });
+    for (const agent of members) {
+        if (q.length === 0 ||
+            agent.name.toLowerCase().includes(q) ||
+            agent.role.toLowerCase().includes(q) ||
+            agent.badge === rawQuery) {
+            items.push({ kind: "agent", agent });
+        }
+    }
+    return items;
+}
+export const SKILL_COMMAND_ID_PREFIX = "skill:";
+export function skillNameOfCommand(command) {
+    return command.source === "skill" && command.id.startsWith(SKILL_COMMAND_ID_PREFIX)
+        ? command.id.slice(SKILL_COMMAND_ID_PREFIX.length)
+        : null;
+}
+export function buildAgentSkillItems(agent, skillCommands, rawQuery = "") {
+    const disabled = new Set(agent.disabledSkills);
+    const available = skillCommands.filter((c) => {
+        const name = skillNameOfCommand(c);
+        return name != null && !disabled.has(name);
+    });
+    return filterSlashCommands(available, rawQuery).map((command) => ({
+        kind: "command",
+        command,
+    }));
+}
+export const FILE_CANDIDATE_LIMIT = 8;
+export function filterFileCandidates(entries, rawQuery, limit = FILE_CANDIDATE_LIMIT) {
+    const q = rawQuery.trim().toLowerCase();
+    return entries
+        .filter((e) => e.path.toLowerCase().includes(q))
+        .sort((a, b) => {
+        const da = a.path.split("/").length;
+        const db = b.path.split("/").length;
+        return da !== db ? da - db : a.path.localeCompare(b.path);
+    })
+        .slice(0, limit)
+        .map((e) => ({ kind: "file", path: e.path, entryKind: e.entryKind }));
+}
+export function buildPaletteItems(token, source) {
+    if (token.trigger === "@") {
+        return [
+            ...buildMentionItems(source.members, token.query),
+            ...(source.files ? filterFileCandidates(source.files, token.query) : []),
+        ];
+    }
+    return filterSlashCommands(source.commands, token.query).map((command) => ({
+        kind: "command",
+        command,
+    }));
+}
+export function moveIndex(index, delta, length) {
+    if (length === 0)
+        return 0;
+    return ((index + delta) % length + length) % length;
+}
+export function paletteKeyDownAction(key, shift) {
+    switch (key) {
+        case "ArrowDown":
+            return "move-next";
+        case "ArrowUp":
+            return "move-prev";
+        case "Tab":
+            return "accept";
+        case "Enter":
+            return shift ? "newline" : "accept";
+        case "Escape":
+            return "close";
+        default:
+            return null;
+    }
+}
+export function paletteRecencyId(item) {
+    switch (item.kind) {
+        case "all":
+            return "all";
+        case "agent":
+            return `agent:${item.agent.id}`;
+        case "command":
+            return `command:${item.command.id}`;
+        case "file":
+            return `file:${item.path}`;
+    }
+}
+export function rankByRecency(items, recent) {
+    const order = new Map(recent.map((id, i) => [id, i]));
+    const rank = (item) => item.kind === "file" ? Number.MAX_SAFE_INTEGER : (order.get(paletteRecencyId(item)) ?? Number.MAX_SAFE_INTEGER - 1);
+    return [...items].sort((a, b) => rank(a) - rank(b));
+}

package/lib/domain/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./message-blocks";
+export * from "./attribution";
+export * from "./composer-palette";
+export * from "./slash-commands";
+export * from "./selection-actions";
+export * from "./selection-gates";
+export * from "./attachments";
+export * from "./message-menu";
+export * from "./reducer";
+export * from "./queue";
+export * from "./ask";
+export * from "./mention";

package/lib/domain/index.js

@@ -0,0 +1,12 @@
+export * from "./message-blocks";
+export * from "./attribution";
+export * from "./composer-palette";
+export * from "./slash-commands";
+export * from "./selection-actions";
+export * from "./selection-gates";
+export * from "./attachments";
+export * from "./message-menu";
+export * from "./reducer";
+export * from "./queue";
+export * from "./ask";
+export * from "./mention";

package/lib/domain/mention.d.ts

@@ -0,0 +1,17 @@
+import type { Agent } from "../types/agent";
+export interface MentionTarget {
+    id: string;
+    name: string;
+}
+export declare function mentionTargetsFromAgents(agents: readonly Agent[]): MentionTarget[];
+type MdastNode = {
+    type: string;
+    value?: string;
+    children?: MdastNode[];
+    data?: {
+        hName?: string;
+        hProperties?: Record<string, unknown>;
+    };
+};
+export declare function remarkMentions(targets: readonly MentionTarget[]): () => (tree: MdastNode) => void;
+export {};

package/lib/domain/mention.js

@@ -0,0 +1,95 @@
+export function mentionTargetsFromAgents(agents) {
+    return agents.map((a) => ({ id: a.id, name: a.name }));
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function remarkMentions(targets) {
+    return () => (tree) => {
+        if (targets.length === 0)
+            return;
+        const names = targets
+            .map((t) => t.name)
+            .filter((n) => n.length > 0)
+            .sort((a, b) => b.length - a.length);
+        if (names.length === 0)
+            return;
+        const re = new RegExp(`@(${names.map(escapeRegExp).join("|")})`, "g");
+        const walk = (node, inCode) => {
+            if (node.type === "code" || node.type === "inlineCode")
+                return;
+            if (node.type === "text" && typeof node.value === "string") {
+                const text = node.value;
+                if (!re.test(text))
+                    return;
+                re.lastIndex = 0;
+                const parts = [];
+                let last = 0;
+                let m;
+                while ((m = re.exec(text)) !== null) {
+                    if (m.index > last) {
+                        parts.push({ type: "text", value: text.slice(last, m.index) });
+                    }
+                    const name = m[1];
+                    const target = targets.find((t) => t.name === name);
+                    parts.push({
+                        type: "text",
+                        value: m[0],
+                        data: {
+                            hName: "mention",
+                            hProperties: { agent: target?.id, name },
+                        },
+                    });
+                    last = m.index + m[0].length;
+                }
+                if (last < text.length)
+                    parts.push({ type: "text", value: text.slice(last) });
+                const parent = node;
+                if (parts.length > 0) {
+                    const first = parts[0];
+                    node.value = first.value ?? "";
+                    if (first.data)
+                        node.data = first.data;
+                }
+                void parent;
+                void inCode;
+                return;
+            }
+            if (Array.isArray(node.children)) {
+                const next = [];
+                for (const child of node.children) {
+                    if (child.type === "text" && typeof child.value === "string" && re.test(child.value)) {
+                        re.lastIndex = 0;
+                        const text = child.value;
+                        let last = 0;
+                        let m;
+                        while ((m = re.exec(text)) !== null) {
+                            if (m.index > last) {
+                                next.push({ type: "text", value: text.slice(last, m.index) });
+                            }
+                            const name = m[1];
+                            const target = targets.find((t) => t.name === name);
+                            next.push({
+                                type: "text",
+                                value: m[0],
+                                data: {
+                                    hName: "mention",
+                                    hProperties: { agent: target?.id, name },
+                                },
+                            });
+                            last = m.index + m[0].length;
+                        }
+                        if (last < text.length)
+                            next.push({ type: "text", value: text.slice(last) });
+                    }
+                    else {
+                        walk(child, inCode);
+                        next.push(child);
+                    }
+                }
+                node.children = next;
+            }
+        };
+        walk(tree, false);
+    };
+}

package/lib/domain/message-blocks.d.ts

@@ -0,0 +1,29 @@
+import type { ChatMessage, MessagePart, SandboxPart, ToolCallPart } from "../types/message";
+export interface KeyedPart {
+    key: string;
+    part: MessagePart;
+}
+export type ToolGroupPart = ToolCallPart | SandboxPart;
+export interface KeyedToolPart {
+    key: string;
+    part: ToolGroupPart;
+}
+export type MessageBlock = {
+    type: "part";
+    key: string;
+    part: MessagePart;
+} | {
+    type: "tool-group";
+    key: string;
+    parts: KeyedToolPart[];
+} | {
+    type: "text";
+    key: string;
+};
+export declare const TOOL_GROUP_MIN = 2;
+export declare function isToolGroupPart(part: MessagePart): part is ToolGroupPart;
+export declare function toolGroupLabel(part: ToolGroupPart): string;
+export declare function keyMessageParts(message: ChatMessage): KeyedPart[];
+export declare function orderMessageBlocks(message: ChatMessage, showBubble: boolean): MessageBlock[];
+export declare function promoteMemoryFirst(blocks: MessageBlock[]): MessageBlock[];
+export declare function blockKind(block: MessageBlock): MessagePart["kind"] | "text" | "tool-group";