@parallelworks/ui 0.19.0 → 0.20.0

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

@@ -0,0 +1,108 @@
+//#region src/ai/adapter/openai/responses.ts
+function contentString(content) {
+	return typeof content === "string" ? content : "";
+}
+function buildResponsesRequestBody(model, messages) {
+	const input = [];
+	let attachmentIds;
+	for (const m of messages) switch (m.role) {
+		case "system":
+			input.push({
+				type: "message",
+				role: "system",
+				content: contentString(m.content)
+			});
+			break;
+		case "user":
+			if (m.attachment_ids?.length) attachmentIds = m.attachment_ids;
+			input.push({
+				type: "message",
+				role: "user",
+				content: contentString(m.content)
+			});
+			break;
+		case "assistant": {
+			const replayed = Array.isArray(m.responses_output) ? replayableOutput(m.responses_output) : [];
+			if (replayed.length > 0) {
+				for (const item of replayed) input.push(item);
+				break;
+			}
+			const text = contentString(m.content);
+			const toolCalls = m.tool_calls ?? [];
+			if (text || toolCalls.length === 0) input.push({
+				type: "message",
+				role: "assistant",
+				content: text
+			});
+			for (const tc of toolCalls) input.push({
+				type: "function_call",
+				call_id: tc.id ?? "",
+				name: tc.function.name,
+				arguments: tc.function.arguments
+			});
+			break;
+		}
+		case "tool": input.push({
+			type: "function_call_output",
+			call_id: m.tool_call_id ?? "",
+			output: contentString(m.content)
+		});
+	}
+	const body = {
+		model,
+		input,
+		stream: true,
+		store: false,
+		include: ["reasoning.encrypted_content"]
+	};
+	if (attachmentIds?.length) body["attachment_ids"] = attachmentIds;
+	return body;
+}
+var REPLAYABLE_ITEM_TYPES = /* @__PURE__ */ new Set([
+	"reasoning",
+	"message",
+	"function_call"
+]);
+function replayableOutput(output) {
+	if (!output?.length) return [];
+	return output.filter((item) => {
+		if (typeof item !== "object" || item === null) return false;
+		const itemType = item.type;
+		return typeof itemType === "string" && REPLAYABLE_ITEM_TYPES.has(itemType);
+	});
+}
+function parseResponsesSSELine(line) {
+	if (!line.startsWith("data: ")) return null;
+	const data = line.slice(6);
+	if (data === "[DONE]" || data === "\"[DONE]\"") return null;
+	let event;
+	try {
+		event = JSON.parse(data);
+	} catch {
+		return null;
+	}
+	if (event.error) return { error: event.error.message || "Unknown error" };
+	const model = event.response?.model;
+	switch (event.type) {
+		case "pw.message_id": return event.messageId ? { messageId: event.messageId } : null;
+		case "response.output_text.delta":
+		case "response.refusal.delta": return typeof event.delta === "string" ? { content: event.delta } : null;
+		case "response.reasoning_summary_text.delta": return typeof event.delta === "string" ? { reasoningContent: event.delta } : null;
+		case "response.created": return model ? { model } : null;
+		case "response.completed": return {
+			...model && { model },
+			finishReason: "stop",
+			responsesOutput: replayableOutput(event.response?.output)
+		};
+		case "response.incomplete": return {
+			...model && { model },
+			finishReason: "length",
+			responsesOutput: replayableOutput(event.response?.output)
+		};
+		case "response.failed": return { error: event.response?.error?.message || "Response failed" };
+		case "error": return { error: event.message || "Stream error" };
+		default: return null;
+	}
+}
+//#endregion
+export { buildResponsesRequestBody, parseResponsesSSELine };

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/{chunks/types-Yy0NrerF.js → ai/adapter/types.js}

@@ -8,4 +8,4 @@ var ChatAdapterError = class extends Error {
 	}
 };
 //#endregion
-export { ChatAdapterError as t };
+export { ChatAdapterError };

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.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.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/permissions.js

@@ -0,0 +1,29 @@
+//#region src/ai/agent/permissions.ts
+var REQUESTABLE_PERMISSION_MODES = [
+	"read-only",
+	"accept-edits",
+	"bypass-permissions"
+];
+var NAMED_PERMISSION_MODES = [...REQUESTABLE_PERMISSION_MODES, "plan"];
+var DEFAULT_PERMISSION_MODE = "accept-edits";
+var PERMISSION_RANK = {
+	"read-only": 0,
+	plan: 1,
+	"accept-edits": 2,
+	"bypass-permissions": 3
+};
+function isNamedPermissionMode(mode) {
+	return NAMED_PERMISSION_MODES.some((m) => m === mode);
+}
+/** The daemon clamps a remote request to its owner's remoteMaxPermissionMode,
+*  so a menu offers only what that machine will honour. */
+function permissionModesUpTo(ceiling) {
+	const max = isNamedPermissionMode(ceiling) ? PERMISSION_RANK[ceiling] : PERMISSION_RANK[DEFAULT_PERMISSION_MODE];
+	return REQUESTABLE_PERMISSION_MODES.filter((m) => PERMISSION_RANK[m] <= max);
+}
+function clampPermissionMode(mode, ceiling) {
+	const offered = permissionModesUpTo(ceiling);
+	return offered.includes(mode) ? mode : offered[offered.length - 1] ?? "read-only";
+}
+//#endregion
+export { DEFAULT_PERMISSION_MODE, NAMED_PERMISSION_MODES, clampPermissionMode, isNamedPermissionMode, permissionModesUpTo };