@parallelworks/ui 0.18.0 → 0.19.1

package/dist/ai/adapter/openai/sse.js

@@ -0,0 +1,112 @@
+//#region src/ai/adapter/openai/sse.ts
+function parseSSELine(line) {
+	if (!line.startsWith("data: ")) return null;
+	const data = line.slice(6);
+	if (data === "[DONE]" || data === "\"[DONE]\"") return null;
+	try {
+		const parsed = JSON.parse(data);
+		if (parsed.error) return { error: parsed.error.message || "Unknown error" };
+		const chunk = parsed;
+		const choice = chunk.choices?.[0];
+		return {
+			id: chunk.id,
+			messageId: chunk.messageId,
+			content: choice?.delta?.content,
+			reasoningContent: choice?.delta?.reasoning_content,
+			toolCalls: choice?.delta?.tool_calls ?? void 0,
+			finishReason: choice?.finish_reason,
+			model: chunk.model
+		};
+	} catch {
+		return null;
+	}
+}
+/** Process an SSE stream from a ReadableStream reader */
+async function processSSEStream(reader, onContent, onToolCall, onError, onReasoning, onMessageId, parseLine = parseSSELine) {
+	const decoder = new TextDecoder();
+	let assistantContent = "";
+	let assistantReasoning = "";
+	let assistantMessageId = "";
+	let finishReason = null;
+	let resolvedModel = null;
+	let responsesOutput = [];
+	const toolCallsMap = /* @__PURE__ */ new Map();
+	let lineBuffer = "";
+	while (true) {
+		const result = await reader.read();
+		if (result.done) break;
+		const chunk = decoder.decode(result.value, { stream: true });
+		const lines = (lineBuffer + chunk).split("\n");
+		lineBuffer = lines.pop() || "";
+		for (const line of lines) {
+			const parsed = parseLine(line);
+			if (parsed) {
+				if (parsed.error) {
+					onError?.(parsed.error);
+					throw new Error(parsed.error);
+				}
+				if (parsed.messageId && !assistantMessageId) {
+					assistantMessageId = parsed.messageId;
+					onMessageId?.(parsed.messageId);
+				} else if (parsed.id && !assistantMessageId) assistantMessageId = parsed.id;
+				if (parsed.model && !resolvedModel) resolvedModel = parsed.model;
+				if (parsed.content) {
+					assistantContent += parsed.content;
+					onContent(parsed.content);
+				}
+				if (parsed.reasoningContent) {
+					assistantReasoning += parsed.reasoningContent;
+					onReasoning?.(parsed.reasoningContent);
+				}
+				if (parsed.finishReason) finishReason = parsed.finishReason;
+				if (parsed.responsesOutput?.length) responsesOutput = parsed.responsesOutput;
+				if (parsed.toolCalls) for (const tc of parsed.toolCalls) {
+					if (tc.index === void 0) continue;
+					const existing = toolCallsMap.get(tc.index);
+					if (existing) {
+						if (tc.function?.arguments) existing.arguments += tc.function.arguments;
+					} else toolCallsMap.set(tc.index, {
+						id: tc.id || "",
+						type: tc.type || "function",
+						name: tc.function?.name || "",
+						arguments: tc.function?.arguments || ""
+					});
+				}
+			}
+		}
+	}
+	if (lineBuffer.trim()) {
+		const parsed = parseLine(lineBuffer);
+		if (parsed) {
+			if (parsed.content) {
+				assistantContent += parsed.content;
+				onContent(parsed.content);
+			}
+			if (parsed.reasoningContent) {
+				assistantReasoning += parsed.reasoningContent;
+				onReasoning?.(parsed.reasoningContent);
+			}
+			if (parsed.finishReason) finishReason = parsed.finishReason;
+		}
+	}
+	const toolCalls = Array.from(toolCallsMap.values()).map((tc) => ({
+		id: tc.id,
+		type: tc.type,
+		function: {
+			name: tc.name,
+			arguments: tc.arguments
+		}
+	}));
+	if (toolCalls.length > 0 && onToolCall) onToolCall(toolCalls);
+	return {
+		content: assistantContent,
+		messageId: assistantMessageId,
+		toolCalls,
+		finishReason,
+		model: resolvedModel,
+		reasoning: assistantReasoning,
+		responsesOutput
+	};
+}
+//#endregion
+export { parseSSELine, processSSEStream };

package/dist/ai/adapter/openai/wire.d.ts

@@ -0,0 +1,40 @@
+import type { ChatModel, TokenUsage, ToolCall, ToolCallDelta, UnreachableSession } from '../../types.js';
+export interface CompletionMessage {
+    role: string;
+    content?: unknown;
+    name?: string;
+    reasoning_content?: string;
+    responses_output?: unknown[] | null;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[] | null;
+    attachment_ids?: string[] | null | undefined;
+}
+export interface CompletionRequest {
+    model: string;
+    messages: CompletionMessage[];
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export interface CompletionChunkChoice {
+    delta?: {
+        content?: unknown;
+        reasoning_content?: string;
+        tool_calls?: ToolCallDelta[] | null;
+    };
+    finish_reason?: string | null;
+    index?: number;
+}
+export interface CompletionChunk {
+    id: string;
+    model: string;
+    object?: string;
+    created?: number;
+    messageId?: string;
+    choices?: CompletionChunkChoice[] | null;
+    usage?: TokenUsage;
+}
+export interface ModelsWireResponse {
+    object: string;
+    data: ChatModel[] | null;
+    unreachable_sessions?: UnreachableSession[] | null;
+}

package/dist/ai/adapter/types.d.ts

@@ -0,0 +1,131 @@
+import type { Allocation, ApprovalPart, AttachmentRef, ChatModel, Conversation, ConversationSummary, ProviderInfo, ShareGroup, SharePermission, SharePermissionLevel, TodoItem, ToolCall, UnreachableSession } from '../types.js';
+import type { CompletionMessage } from './openai/wire.js';
+export declare class ChatAdapterError extends Error {
+    status?: number | undefined;
+    constructor(message: string, options?: {
+        status?: number;
+        cause?: unknown;
+    });
+}
+export interface ModelsList {
+    models: ChatModel[];
+    unreachableSessions: UnreachableSession[];
+}
+export interface StreamRequest {
+    model: string;
+    messages: CompletionMessage[];
+    conversationId: string;
+    parentMessageId?: string | null;
+    userMessageId: string;
+    allocation?: string | null;
+    useResponses?: boolean;
+}
+export interface StreamHandlers {
+    onContent: (content: string) => void;
+    onReasoning?: (reasoning: string) => void;
+    onMessageId?: (messageId: string) => void;
+    onPart?: (delta: PartDelta) => void;
+}
+export type PartDelta = {
+    type: 'tool_start';
+    id: string;
+    name: string;
+    args: string;
+    startLine?: number;
+} | {
+    type: 'tool_update';
+    id: string;
+    args: string;
+} | {
+    type: 'tool_end';
+    id: string;
+    result: string;
+    isError?: boolean;
+} | {
+    type: 'subagent_start';
+    id: string;
+    agentType?: string;
+    color?: string;
+    background?: boolean;
+    description?: string;
+} | {
+    type: 'subagent_action';
+    id: string;
+    action: string;
+} | {
+    type: 'subagent_end';
+    id: string;
+    ok: boolean;
+    summary?: string;
+    report?: string;
+} | {
+    type: 'approval_request';
+    approval: ApprovalPart;
+} | {
+    type: 'approval_resolved';
+    id: string;
+    answer?: string;
+} | {
+    type: 'notice' | 'warning';
+    text: string;
+} | {
+    type: 'todo_snapshot';
+    todos: TodoItem[];
+};
+export interface StreamResult {
+    content: string;
+    messageId: string;
+    toolCalls: ToolCall[];
+    finishReason: string | null;
+    model: string | null;
+    reasoning: string;
+    responsesOutput: unknown[];
+}
+export type StreamCompletion = (req: StreamRequest, handlers: StreamHandlers, signal?: AbortSignal) => Promise<StreamResult>;
+export interface ConversationsAdapter {
+    list(): Promise<ConversationSummary[]>;
+    get(id: string): Promise<Conversation>;
+    create(title?: string): Promise<ConversationSummary>;
+    rename(id: string, title: string): Promise<void>;
+    remove(id: string): Promise<void>;
+}
+export interface ProvidersAdapter {
+    list(): Promise<ProviderInfo[]>;
+}
+export interface AttachmentPage {
+    attachments: AttachmentRef[];
+    total: number;
+    nextCursor?: string;
+    hasMore: boolean;
+}
+export interface AttachmentsAdapter {
+    list(opts: {
+        limit: number;
+        cursor?: string;
+    }): Promise<AttachmentPage>;
+    upload(file: File, conversationId?: string): Promise<AttachmentRef>;
+    remove(id: string): Promise<void>;
+    downloadUrl(id: string): string;
+    onOpen?(attachment: AttachmentRef): void;
+}
+export interface SharingAdapter {
+    listPermissions(conversationId: string): Promise<SharePermission[]>;
+    listGroups(): Promise<ShareGroup[]>;
+    addPermission(conversationId: string, permission: Omit<SharePermission, 'id' | 'teamName'>): Promise<void>;
+    updatePermission(conversationId: string, permissionId: string, permission: SharePermissionLevel): Promise<void>;
+    removePermission(conversationId: string, permissionId: string): Promise<void>;
+}
+export interface AllocationsAdapter {
+    list(): Promise<Allocation[]>;
+}
+export interface ChatAdapter {
+    conversations: ConversationsAdapter;
+    models: {
+        list(): Promise<ModelsList>;
+    };
+    streamCompletion: StreamCompletion;
+    providers?: ProvidersAdapter;
+    attachments?: AttachmentsAdapter;
+    sharing?: SharingAdapter;
+    allocations?: AllocationsAdapter;
+}

package/dist/ai/adapter/types.js

@@ -0,0 +1,11 @@
+//#region src/ai/adapter/types.ts
+var ChatAdapterError = class extends Error {
+	status;
+	constructor(message, options) {
+		super(message, options?.cause === void 0 ? {} : { cause: options.cause });
+		this.name = "ChatAdapterError";
+		this.status = options?.status;
+	}
+};
+//#endregion
+export { ChatAdapterError };

package/dist/ai/agent/classifier.d.ts

@@ -0,0 +1,2 @@
+import type { PseudoUserKind } from '../types.js';
+export declare function classifyPseudoUserMessage(role: string, content: string | null | undefined): PseudoUserKind | null;

package/dist/ai/agent/classifier.js

@@ -0,0 +1,12 @@
+//#region src/ai/agent/classifier.ts
+var COMPACTION_MARKER = "[Conversation summary from automatic compaction]";
+function classifyPseudoUserMessage(role, content) {
+	if (role !== "user" || !content) return null;
+	const t = content.trimStart();
+	if (t.startsWith("<command-input>")) return "command-input";
+	if (t.startsWith("<shell-input>")) return "shell-input";
+	if (t.startsWith(COMPACTION_MARKER)) return "compaction";
+	return null;
+}
+//#endregion
+export { classifyPseudoUserMessage };

package/dist/ai/agent/diff.d.ts

@@ -0,0 +1,35 @@
+export declare const MAX_EDIT_DIFF_LINES = 100;
+export declare const MAX_WRITE_DIFF_LINES = 50;
+export declare const DIFF_CONTEXT = 3;
+export interface EditToolArgs {
+    path?: string;
+    old_string?: string;
+    new_string?: string;
+    content?: string;
+    replace_all?: boolean;
+}
+export declare function isEditDiffTool(name: string): boolean;
+export declare function parseEditArgs(argsJSON: string): EditToolArgs | null;
+export declare function wordEmphasisRanges(oldLine: string, newLine: string): Array<[number, number]> | null;
+export declare function lineDelta(oldLines: string[], newLines: string[]): [number, number];
+export interface DiffRow {
+    kind: 'add' | 'del' | 'ctx' | 'gap';
+    oldNo?: number;
+    newNo?: number;
+    text: string;
+    emphasis?: Array<[number, number]>;
+}
+export interface EditDiffModel {
+    rows: DiffRow[];
+    added: number;
+    removed: number;
+    truncated: boolean;
+}
+export declare function computeEditDiff(oldString: string, newString: string, startLine?: number): EditDiffModel;
+export interface WriteModel {
+    rows: DiffRow[];
+    total: number;
+    truncated: boolean;
+}
+export declare function computeWriteRows(content: string): WriteModel;
+export declare function editSummary(toolName: string, argsJSON: string): string;

package/dist/ai/agent/diff.js

@@ -0,0 +1,223 @@
+import { sanitizeLabel } from "./toolfmt.js";
+//#region src/ai/agent/diff.ts
+var MAX_EDIT_DIFF_LINES = 100;
+var MAX_WRITE_DIFF_LINES = 50;
+function isEditDiffTool(name) {
+	return name === "EditFile" || name === "WriteFile";
+}
+function parseEditArgs(argsJSON) {
+	try {
+		const a = JSON.parse(argsJSON);
+		return a && typeof a === "object" ? a : null;
+	} catch {
+		return null;
+	}
+}
+function splitLines(s) {
+	const trimmed = s.endsWith("\n") ? s.slice(0, -1) : s;
+	return trimmed === "" ? [] : trimmed.split("\n");
+}
+function getOpCodes(a, b) {
+	const n = a.length;
+	const m = b.length;
+	const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+	for (let i = n - 1; i >= 0; i--) {
+		const row = lcs[i];
+		const next = lcs[i + 1];
+		if (!row || !next) continue;
+		for (let j = m - 1; j >= 0; j--) row[j] = a[i] === b[j] ? (next[j + 1] ?? 0) + 1 : Math.max(next[j] ?? 0, row[j + 1] ?? 0);
+	}
+	const ops = [];
+	let i = 0;
+	let j = 0;
+	const push = (tag, i1, i2, j1, j2) => {
+		const last = ops[ops.length - 1];
+		if (last && last.tag === tag && last.i2 === i1 && last.j2 === j1) {
+			last.i2 = i2;
+			last.j2 = j2;
+			return;
+		}
+		ops.push({
+			tag,
+			i1,
+			i2,
+			j1,
+			j2
+		});
+	};
+	while (i < n && j < m) if (a[i] === b[j]) {
+		push("e", i, i + 1, j, j + 1);
+		i++;
+		j++;
+	} else if ((lcs[i + 1]?.[j] ?? 0) >= (lcs[i]?.[j + 1] ?? 0)) {
+		push("d", i, i + 1, j, j);
+		i++;
+	} else {
+		push("i", i, i, j, j + 1);
+		j++;
+	}
+	if (i < n) push("d", i, n, j, j);
+	if (j < m) push("i", i, i, j, m);
+	const merged = [];
+	for (const op of ops) {
+		const last = merged[merged.length - 1];
+		if (last && (last.tag === "d" && op.tag === "i" || last.tag === "i" && op.tag === "d")) {
+			merged[merged.length - 1] = {
+				tag: "r",
+				i1: Math.min(last.i1, op.i1),
+				i2: Math.max(last.i2, op.i2),
+				j1: Math.min(last.j1, op.j1),
+				j2: Math.max(last.j2, op.j2)
+			};
+			continue;
+		}
+		merged.push(op);
+	}
+	return merged;
+}
+function tokenizeWords(line) {
+	return line.match(/\w+|\s+|[^\w\s]+/g) ?? [];
+}
+function wordEmphasisRanges(oldLine, newLine) {
+	const a = tokenizeWords(oldLine);
+	const b = tokenizeWords(newLine);
+	if (a.length === 0 || b.length === 0) return null;
+	const ops = getOpCodes(a, b);
+	if (!ops.some((op) => op.tag === "e" && a.slice(op.i1, op.i2).some((t) => /\w/.test(t)))) return null;
+	const starts = [];
+	let pos = 0;
+	for (const t of b) {
+		starts.push(pos);
+		pos += t.length;
+	}
+	starts.push(pos);
+	const ranges = [];
+	for (const op of ops) {
+		if (op.tag !== "i" && op.tag !== "r") continue;
+		if (op.j1 >= op.j2) continue;
+		const start = starts[op.j1] ?? 0;
+		const end = starts[op.j2] ?? pos;
+		const last = ranges[ranges.length - 1];
+		if (last && last[1] === start) last[1] = end;
+		else ranges.push([start, end]);
+	}
+	return ranges.length > 0 ? ranges : null;
+}
+function lineDelta(oldLines, newLines) {
+	let added = 0;
+	let removed = 0;
+	for (const op of getOpCodes(oldLines, newLines)) {
+		if (op.tag === "d" || op.tag === "r") removed += op.i2 - op.i1;
+		if (op.tag === "i" || op.tag === "r") added += op.j2 - op.j1;
+	}
+	return [added, removed];
+}
+function computeEditDiff(oldString, newString, startLine = 0) {
+	const oldLines = splitLines(oldString);
+	const newLines = splitLines(newString);
+	const [added, removed] = lineDelta(oldLines, newLines);
+	const ops = getOpCodes(oldLines, newLines);
+	const numbered = startLine > 0;
+	const rows = [];
+	let truncated = false;
+	const push = (row) => {
+		if (rows.length >= 100) {
+			truncated = true;
+			return false;
+		}
+		rows.push(row);
+		return true;
+	};
+	outer: for (let k = 0; k < ops.length; k++) {
+		const op = ops[k];
+		if (!op) continue;
+		if (op.tag === "e") {
+			const len = op.i2 - op.i1;
+			const leading = k > 0 ? Math.min(3, len) : 0;
+			const trailing = k < ops.length - 1 ? Math.min(3, len) : 0;
+			const showAll = len <= leading + trailing;
+			const emit = (offset) => {
+				const oldNo = op.i1 + offset + 1;
+				const newNo = op.j1 + offset + 1;
+				return push({
+					kind: "ctx",
+					text: oldLines[op.i1 + offset] ?? "",
+					...numbered ? {
+						oldNo: startLine + oldNo - 1,
+						newNo: startLine + newNo - 1
+					} : {}
+				});
+			};
+			if (showAll) {
+				for (let x = 0; x < len; x++) if (!emit(x)) break outer;
+			} else {
+				for (let x = 0; x < leading; x++) if (!emit(x)) break outer;
+				if (!push({
+					kind: "gap",
+					text: ""
+				})) break;
+				for (let x = len - trailing; x < len; x++) if (!emit(x)) break outer;
+			}
+			continue;
+		}
+		if (op.tag === "d" || op.tag === "r") {
+			for (let x = op.i1; x < op.i2; x++) if (!push({
+				kind: "del",
+				text: oldLines[x] ?? "",
+				...numbered ? { oldNo: startLine + x } : {}
+			})) break outer;
+		}
+		if (op.tag === "i" || op.tag === "r") {
+			const paired = op.tag === "r" ? Math.min(op.i2 - op.i1, op.j2 - op.j1) : 0;
+			for (let x = op.j1; x < op.j2; x++) {
+				const k = x - op.j1;
+				const emphasis = k < paired ? wordEmphasisRanges(oldLines[op.i1 + k] ?? "", newLines[x] ?? "") : null;
+				if (!push({
+					kind: "add",
+					text: newLines[x] ?? "",
+					...numbered ? { newNo: startLine + x } : {},
+					...emphasis ? { emphasis } : {}
+				})) break outer;
+			}
+		}
+	}
+	return {
+		rows,
+		added,
+		removed,
+		truncated
+	};
+}
+function computeWriteRows(content) {
+	const lines = splitLines(content);
+	return {
+		rows: lines.slice(0, 50).map((text, i) => ({
+			kind: "ctx",
+			newNo: i + 1,
+			text
+		})),
+		total: lines.length,
+		truncated: lines.length > 50
+	};
+}
+function editSummary(toolName, argsJSON) {
+	const a = parseEditArgs(argsJSON);
+	if (!a) return "";
+	const count = (n) => `${n} ${n === 1 ? "line" : "lines"}`;
+	if (toolName === "EditFile") {
+		const [added, removed] = lineDelta(splitLines(a.old_string ?? ""), splitLines(a.new_string ?? ""));
+		if (added > 0 && removed > 0) return `Added ${count(added)}, removed ${count(removed)}`;
+		if (added > 0) return `Added ${count(added)}`;
+		if (removed > 0) return `Removed ${count(removed)}`;
+		return "";
+	}
+	if (toolName === "WriteFile") {
+		if (a.content === void 0) return "";
+		let s = `Wrote ${count(splitLines(a.content).length)}`;
+		if (a.path) s += ` to ${sanitizeLabel(a.path)}`;
+		return s;
+	}
+	return "";
+}
+//#endregion
+export { MAX_EDIT_DIFF_LINES, MAX_WRITE_DIFF_LINES, computeEditDiff, computeWriteRows, editSummary, isEditDiffTool, lineDelta, parseEditArgs, wordEmphasisRanges };

package/dist/ai/agent/diffHighlight.d.ts

@@ -0,0 +1,6 @@
+export interface DiffToken {
+    content: string;
+    color?: string;
+}
+export declare function languageForPath(path: string | undefined): string | null;
+export declare function tokenizeDiffLines(lines: string[], lang: string, isDark: boolean): Promise<DiffToken[][] | null>;

package/dist/ai/agent/diffHighlight.js

@@ -0,0 +1,101 @@
+//#region src/ai/agent/diffHighlight.ts
+var EXT_LANG = {
+	ts: "typescript",
+	tsx: "tsx",
+	mts: "typescript",
+	cts: "typescript",
+	js: "javascript",
+	jsx: "jsx",
+	mjs: "javascript",
+	cjs: "javascript",
+	go: "go",
+	py: "python",
+	rb: "ruby",
+	rs: "rust",
+	java: "java",
+	c: "c",
+	h: "c",
+	cc: "cpp",
+	cpp: "cpp",
+	hpp: "cpp",
+	cs: "csharp",
+	php: "php",
+	swift: "swift",
+	kt: "kotlin",
+	scala: "scala",
+	sh: "shellscript",
+	bash: "shellscript",
+	zsh: "shellscript",
+	fish: "fish",
+	ps1: "powershell",
+	sql: "sql",
+	json: "json",
+	jsonc: "jsonc",
+	yaml: "yaml",
+	yml: "yaml",
+	toml: "toml",
+	xml: "xml",
+	html: "html",
+	css: "css",
+	scss: "scss",
+	less: "less",
+	md: "markdown",
+	mdx: "mdx",
+	vue: "vue",
+	svelte: "svelte",
+	tf: "terraform",
+	hcl: "hcl",
+	proto: "proto",
+	graphql: "graphql",
+	gql: "graphql",
+	dockerfile: "dockerfile",
+	lua: "lua",
+	r: "r",
+	pl: "perl",
+	ex: "elixir",
+	exs: "elixir",
+	zig: "zig"
+};
+function languageForPath(path) {
+	if (!path) return null;
+	const base = path.split("/").pop() ?? "";
+	if (base.toLowerCase() === "dockerfile") return "dockerfile";
+	const dot = base.lastIndexOf(".");
+	if (dot <= 0) return null;
+	return EXT_LANG[base.slice(dot + 1).toLowerCase()] ?? null;
+}
+var highlighters = /* @__PURE__ */ new Map();
+function getHighlighter(lang) {
+	let p = highlighters.get(lang);
+	if (!p) {
+		p = (async () => {
+			const [{ createHighlighter }, { createJavaScriptRegexEngine }] = await Promise.all([import("shiki"), import("shiki/engine/javascript")]);
+			return await createHighlighter({
+				langs: [lang],
+				themes: ["github-light", "github-dark"],
+				engine: createJavaScriptRegexEngine({ forgiving: true })
+			});
+		})().catch(() => null);
+		highlighters.set(lang, p);
+	}
+	return p;
+}
+async function tokenizeDiffLines(lines, lang, isDark) {
+	const highlighter = await getHighlighter(lang);
+	if (!highlighter) return null;
+	try {
+		const tokens = highlighter.codeToTokensBase(lines.join("\n"), {
+			lang,
+			theme: isDark ? "github-dark" : "github-light"
+		});
+		if (tokens.length !== lines.length) return null;
+		return tokens.map((line) => line.map((t) => ({
+			content: t.content,
+			...t.color ? { color: t.color } : {}
+		})));
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { languageForPath, tokenizeDiffLines };

package/dist/ai/agent/index.d.ts

@@ -0,0 +1,6 @@
+export { classifyPseudoUserMessage } from './classifier.js';
+export { computeEditDiff, computeWriteRows, type DiffRow, type EditDiffModel, type EditToolArgs, editSummary, isEditDiffTool, lineDelta, MAX_EDIT_DIFF_LINES, MAX_WRITE_DIFF_LINES, parseEditArgs, type WriteModel, wordEmphasisRanges, } from './diff.js';
+export { type DiffToken, languageForPath, tokenizeDiffLines, } from './diffHighlight.js';
+export { clampPermissionMode, DEFAULT_PERMISSION_MODE, isNamedPermissionMode, NAMED_PERMISSION_MODES, type NamedPermissionMode, type PermissionMode, permissionModesUpTo, } from './permissions.js';
+export { AGENT_COLOR_NAMES, agentColorHex, bashExitCode, clip, fullToolArgs, isGroupableTool, plural, resultFailed, rollupSentence, sanitizeLabel, sanitizePanelText, summarizeToolArgs, type ToolHeader, toolHeaderFor, toolSummary, } from './toolfmt.js';
+export { agentTypeLabel, askQuestionFromArgs, firstNonEmptyLine, hiddenTranscriptTool, INTERRUPTED_NOTICE, interruptionNotice, parseSubagentNotice, planFromArgs, type SubagentNotice, subagentDeliveryLine, taskCallFromArgs, thinkingHeading, } from './transcript.js';