@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/tts/wav.ts

@@ -0,0 +1,58 @@
+const WAV_HEADER_BYTES = 44;
+const PCM16_FORMAT = 1;
+const BITS_PER_SAMPLE = 16;
+const INT16_MAX = 32_767;
+const INT16_MIN = -32_768;
+
+/**
+ * Assemble a mono PCM16 WAV byte buffer from Float32 PCM samples (the shape
+ * transformers.js `RawAudio` emits: normalized [-1, 1] amplitudes plus a sample
+ * rate). No external encoder is involved — we write a canonical 44-byte RIFF/
+ * WAVE header followed by little-endian signed 16-bit samples. Samples are
+ * clamped before quantization so out-of-range float values do not wrap.
+ */
+export function encodeWav(samples: Float32Array, sampleRate: number): Uint8Array {
+	const channels = 1;
+	const byteRate = sampleRate * channels * (BITS_PER_SAMPLE / 8);
+	const blockAlign = channels * (BITS_PER_SAMPLE / 8);
+	const dataBytes = samples.length * (BITS_PER_SAMPLE / 8);
+	const buffer = new ArrayBuffer(WAV_HEADER_BYTES + dataBytes);
+	const view = new DataView(buffer);
+
+	// RIFF chunk descriptor
+	writeAscii(view, 0, "RIFF");
+	view.setUint32(4, WAV_HEADER_BYTES - 8 + dataBytes, true); // file size minus the first 8 bytes
+	writeAscii(view, 8, "WAVE");
+
+	// fmt sub-chunk
+	writeAscii(view, 12, "fmt ");
+	view.setUint32(16, 16, true); // PCM fmt chunk size
+	view.setUint16(20, PCM16_FORMAT, true);
+	view.setUint16(22, channels, true);
+	view.setUint32(24, sampleRate, true);
+	view.setUint32(28, byteRate, true);
+	view.setUint16(32, blockAlign, true);
+	view.setUint16(34, BITS_PER_SAMPLE, true);
+
+	// data sub-chunk
+	writeAscii(view, 36, "data");
+	view.setUint32(40, dataBytes, true);
+
+	let offset = WAV_HEADER_BYTES;
+	for (let i = 0; i < samples.length; i += 1) {
+		const sample = samples[i]!;
+		const clamped = sample > 1 ? 1 : sample < -1 ? -1 : sample;
+		const quantized =
+			clamped < 0
+				? Math.max(INT16_MIN, Math.round(clamped * -INT16_MIN))
+				: Math.min(INT16_MAX, Math.round(clamped * INT16_MAX));
+		view.setInt16(offset, quantized, true);
+		offset += 2;
+	}
+
+	return new Uint8Array(buffer);
+}
+
+function writeAscii(view: DataView, offset: number, text: string): void {
+	for (let i = 0; i < text.length; i += 1) view.setUint8(offset + i, text.charCodeAt(i));
+}

package/src/tui/code-cell.ts

@@ -32,8 +32,6 @@ export interface CodeCellOptions {
 	 */
 	codeTail?: boolean;
 	expanded?: boolean;
-	/** Animate the cell border with a sweeping segment while pending/running. */
-	animate?: boolean;
 	width: number;
 }
 
@@ -52,7 +50,7 @@ function formatHeader(options: CodeCellOptions, theme: Theme): { title: string;
 	if (status) {
 		const icon = formatStatusIcon(
 			status === "complete"
-				? "success"
+				? "done"
 				: status === "error"
 					? "error"
 					: status === "warning"
@@ -147,10 +145,7 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 		sections.push({ label: theme.fg("toolTitle", "Output"), lines: outputLines });
 	}
 
-	return renderOutputBlock(
-		{ header: title, headerMeta: meta, state, sections, width, animate: options.animate },
-		theme,
-	);
+	return renderOutputBlock({ header: title, headerMeta: meta, state, sections, width }, theme);
 }
 
 export interface MarkdownCellOptions {

package/src/tui/hyperlink.ts

@@ -5,6 +5,7 @@
  * sequences when the active terminal supports hyperlinks and the user setting
  * permits it. Falls back to plain text when disabled.
  */
+import * as url from "node:url";
 import { TERMINAL } from "@prometheus-ai/tui";
 import { settings } from "../config/settings";
 import {
@@ -17,6 +18,7 @@ import {
 
 const OSC = "\x1b]";
 const ST = "\x1b\\";
+const BEL = "\x07";
 
 /** Stable 8-char hex ID derived from a URI — hints terminals to coalesce identical adjacent links. */
 function buildLinkId(uri: string): string {
@@ -28,21 +30,12 @@ function buildLinkId(uri: string): string {
 	return (h >>> 0).toString(16).padStart(8, "0");
 }
 
-/** Build a `file://` URI for an absolute path with optional line/col query params. */
-function buildFileUri(absPath: string, opts?: { line?: number; col?: number }): string {
-	// Normalize backslashes for Windows paths before constructing the URL.
-	const normalized = absPath.replaceAll("\\", "/");
-	const prefix = normalized.startsWith("/") ? "file://" : "file:///";
-	// Split on slashes, encode each component, reassemble.
-	const encoded = normalized
-		.split("/")
-		.map(segment => encodeURIComponent(segment))
-		.join("/");
-	const params: string[] = [];
-	if (opts?.line !== undefined) params.push(`line=${opts.line}`);
-	if (opts?.col !== undefined) params.push(`col=${opts.col}`);
-	const query = params.length > 0 ? `?${params.join("&")}` : "";
-	return `${prefix}${encoded}${query}`;
+/** Build a properly encoded `file://` URI with optional line/col query params. */
+function buildFileUri(filePath: string, opts?: { line?: number; col?: number }): string {
+	const uri = url.pathToFileURL(filePath);
+	if (opts?.line !== undefined) uri.searchParams.set("line", String(opts.line));
+	if (opts?.col !== undefined) uri.searchParams.set("col", String(opts.col));
+	return uri.href;
 }
 
 /**
@@ -68,14 +61,18 @@ function safeHyperlinkUri(uri: string): string | undefined {
 	return uri;
 }
 
-function wrapHyperlink(uri: string, displayText: string): string {
-	if (!isHyperlinkEnabled()) return displayText;
+function wrapHyperlinkCore(uri: string, displayText: string, terminator: typeof ST | typeof BEL): string {
 	// Do not double-wrap if the text already embeds an OSC 8 sequence.
 	if (displayText.includes("\x1b]8;")) return displayText;
 	const safeUri = safeHyperlinkUri(uri);
 	if (!safeUri) return displayText;
 	const id = buildLinkId(safeUri);
-	return `${OSC}8;id=${id};${safeUri}${ST}${displayText}${OSC}8;;${ST}`;
+	return `${OSC}8;id=${id};${safeUri}${terminator}${displayText}${OSC}8;;${terminator}`;
+}
+
+function wrapHyperlink(uri: string, displayText: string): string {
+	if (!isHyperlinkEnabled()) return displayText;
+	return wrapHyperlinkCore(uri, displayText, ST);
 }
 
 /**
@@ -104,21 +101,38 @@ export function urlHyperlink(url: string, displayText: string): string {
 }
 
 /**
- * Wrap `displayText` in an OSC 8 hyperlink pointing at the given absolute file path.
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at an HTTP(S) URL,
+ * bypassing terminal capability auto-detection. Used for auth prompts where
+ * an inert "click" label blocks login on terminals whose capabilities are
+ * not advertised. Still returns plain text when the user has explicitly
+ * opted out via `tui.hyperlinks=off`.
+ */
+export function urlHyperlinkAlways(url: string, displayText: string): string {
+	if (settings.get("tui.hyperlinks") === "off") return displayText;
+	const normalized = url.match(/^www\./i) ? `https://${url}` : url;
+	try {
+		const parsed = new URL(normalized);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return displayText;
+		return wrapHyperlinkCore(parsed.href, displayText, BEL);
+	} catch {
+		return displayText;
+	}
+}
+
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at a filesystem path.
  *
  * Returns `displayText` unchanged when hyperlinks are disabled or when
  * the text already contains an OSC 8 sequence (prevents double-wrapping).
+ * Relative paths resolve against the current working directory before URI
+ * encoding so the OSC 8 target is always a valid `file://` URL.
  *
- * The caller is responsible for passing an absolute path. Relative paths
- * produce invalid `file://` URIs and are accepted silently to avoid runtime
- * errors in renderer hot paths.
- *
- * @param absPath - Absolute filesystem path
+ * @param filePath - Filesystem path
  * @param displayText - Text to render as the hyperlink anchor (may contain ANSI codes)
  * @param opts - Optional line/col position appended as `?line=N&col=M` query params
  */
-export function fileHyperlink(absPath: string, displayText: string, opts?: { line?: number; col?: number }): string {
-	return wrapHyperlink(buildFileUri(absPath, opts), displayText);
+export function fileHyperlink(filePath: string, displayText: string, opts?: { line?: number; col?: number }): string {
+	return wrapHyperlink(buildFileUri(filePath, opts), displayText);
 }
 
 /**

package/src/tui/output-block.ts

@@ -3,7 +3,7 @@
  */
 import type { Component } from "@prometheus-ai/tui";
 import { ImageProtocol, padding, TERMINAL, visibleWidth, wrapTextWithAnsi } from "@prometheus-ai/tui";
-import type { Theme } from "../modes/theme/theme";
+import type { Theme, ThemeColor } from "../modes/theme/theme";
 import { getSixelLineMask } from "../utils/sixel";
 import type { State } from "./types";
 import type { RenderCache } from "./utils";
@@ -13,11 +13,13 @@ export interface OutputBlockOptions {
 	header?: string;
 	headerMeta?: string;
 	state?: State;
-	sections?: Array<{ label?: string; lines: string[] }>;
+	sections?: Array<{ label?: string; lines: readonly string[]; separator?: boolean }>;
 	width: number;
 	applyBg?: boolean;
-	/** Animate the border with a sweeping dark segment (pending/running state). */
-	animate?: boolean;
+	contentPaddingLeft?: number;
+	/** Override the state-derived border color. Used for muted "legacy" tool
+	 * frames that should not visually compete with framed-output tools. */
+	borderColor?: ThemeColor;
 }
 
 const FRAMED_BLOCK_COMPONENT = Symbol("framedBlockComponent");
@@ -33,65 +35,17 @@ export function isFramedBlockComponent(component: Component): boolean {
 	return (component as FramedBlockComponent)[FRAMED_BLOCK_COMPONENT] === true;
 }
 
-const BORDER_SHIMMER_TICK_MS = 16;
-/** Duration of one full left↔right↔left bounce of the bottom-edge segment, in
- * ms. Position is derived from the wall clock against this fixed cycle so a
- * resize only nudges the segment proportionally instead of teleporting it. */
-const BORDER_BOUNCE_MS = 3000;
-/** Length, in border cells, of the moving segment. */
-const BORDER_SEGMENT_LEN = 8;
-
-/**
- * Monotonic frame counter for animated borders, quantized to the TUI's ~16ms
- * render cap so the cache key advances once per ~60fps frame — fine enough for a
- * smooth segment sweep, coarse enough to coalesce multiple render passes that
- * land inside the same frame.
- */
-export function borderShimmerTick(): number {
-	return Math.floor(Date.now() / BORDER_SHIMMER_TICK_MS);
-}
-
-/** Ease-in-out so the segment decelerates into and accelerates out of each wall. */
-function easeInOutQuad(t: number): number {
-	return t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
-}
-
-/**
- * Column of the travelling segment's center on the bottom edge for a box of
- * inner width `W` at time `now`. The segment bounces left → right → left across
- * the bottom border: a triangle wave over one full there-and-back cycle, eased
- * per leg so it slows as it nears each wall before reversing. Position is
- * derived from the wall clock against a fixed cycle, so a resize shifts the
- * center proportionally — no reset.
- */
-export function borderSegmentHeadCol(W: number, now: number): number {
-	if (W <= 1) return 0;
-	const phase = (((now % BORDER_BOUNCE_MS) + BORDER_BOUNCE_MS) % BORDER_BOUNCE_MS) / BORDER_BOUNCE_MS;
-	// Triangle: 0→1 rightward over the first half, 1→0 leftward over the second.
-	const leg = phase < 0.5 ? phase * 2 : 2 - phase * 2;
-	return easeInOutQuad(leg) * (W - 1);
-}
-
-/**
- * Scale a truecolor foreground escape toward black by `factor`. Returns
- * undefined for 256-color escapes (no RGB to scale) so callers fall back to a
- * dimmer theme color.
- */
-function darkenFgAnsi(ansi: string, factor: number): string | undefined {
-	const m = /38;2;(\d+);(\d+);(\d+)/.exec(ansi);
-	if (!m) return undefined;
-	const r = Math.round(Number(m[1]) * factor);
-	const g = Math.round(Number(m[2]) * factor);
-	const b = Math.round(Number(m[3]) * factor);
-	return `\x1b[38;2;${r};${g};${b}m`;
-}
-
 type BlockRow =
 	| { kind: "bar"; leftChar: string; rightChar: string; label?: string; meta?: string }
 	| { kind: "bottom"; leftChar: string; rightChar: string }
 	| { kind: "content"; inner: string }
 	| { kind: "sixel"; raw: string };
 
+function normalizeContentPaddingLeft(value: number | undefined): number {
+	if (value === undefined || !Number.isFinite(value)) return 1;
+	return Math.max(0, Math.floor(value));
+}
+
 export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[] {
 	const { header, headerMeta, state, sections = [], width, applyBg = true } = options;
 	const h = theme.boxSharp.horizontal;
@@ -99,14 +53,15 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 	const cap = h.repeat(3);
 	const lineWidth = Math.max(0, width);
 	// Border colors: running/pending use accent, success uses dim (gray), error/warning keep their colors
-	const borderColor: "error" | "warning" | "accent" | "dim" =
-		state === "error"
+	const borderColor: ThemeColor =
+		options.borderColor ??
+		(state === "error"
 			? "error"
 			: state === "warning"
 				? "warning"
 				: state === "running" || state === "pending"
 					? "accent"
-					: "dim";
+					: "dim");
 	const border = (text: string) => theme.fg(borderColor, text);
 	const bgFn = (() => {
 		if (!state || !applyBg) return undefined;
@@ -121,10 +76,11 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 		};
 	})();
 
-	const contentWidth = Math.max(0, lineWidth - visibleWidth(`${v} `) - visibleWidth(v));
+	const contentPaddingLeft = normalizeContentPaddingLeft(options.contentPaddingLeft);
+	const contentWidth = Math.max(0, lineWidth - visibleWidth(v) - contentPaddingLeft - visibleWidth(v));
+	const contentLeftPadding = contentPaddingLeft > 0 ? padding(contentPaddingLeft) : "";
 
-	// ── Layout pass: collect row descriptors so the border perimeter length is
-	// known before the moving segment is positioned. ──
+	// ── Layout pass: collect row descriptors before emitting the bordered lines. ──
 	const rows: BlockRow[] = [];
 	rows.push({
 		kind: "bar",
@@ -135,7 +91,11 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 	});
 
 	const normalizedSections = sections.length > 0 ? sections : [{ lines: [] as string[] }];
-	for (const section of normalizedSections) {
+	for (let sectionIndex = 0; sectionIndex < normalizedSections.length; sectionIndex++) {
+		const section = normalizedSections[sectionIndex]!;
+		// A labeled section always draws its titled separator bar. A label-less
+		// section can still request a plain divider via `separator`, but only
+		// between sections — leading with one would just double the header bar.
 		if (section.label) {
 			rows.push({
 				kind: "bar",
@@ -143,6 +103,12 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 				rightChar: theme.boxSharp.teeLeft,
 				label: section.label,
 			});
+		} else if (section.separator && sectionIndex > 0) {
+			rows.push({
+				kind: "bar",
+				leftChar: theme.boxSharp.teeRight,
+				rightChar: theme.boxSharp.teeLeft,
+			});
 		}
 		const allLines = section.lines.flatMap(l => l.split("\n"));
 		const sixelLineMask = TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(allLines) : undefined;
@@ -163,46 +129,18 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 	rows.push({ kind: "bottom", leftChar: theme.boxSharp.bottomLeft, rightChar: theme.boxSharp.bottomRight });
 
 	const H = rows.length;
-	const W = lineWidth;
-	const animate = (options.animate ?? false) && (state === "running" || state === "pending") && W >= 2 && H >= 2;
-
-	// ── Segment geometry: one dark run bounces left ↔ right along the bottom
-	// edge only. The top, interior separators, and side borders stay the flat
-	// accent color. ──
-	const segLen = animate ? Math.min(BORDER_SEGMENT_LEN, W) : 0;
-	const head = animate ? borderSegmentHeadCol(W, Date.now()) : 0;
-	const segHalf = segLen / 2;
-	const segAnsi = animate ? (darkenFgAnsi(theme.getFgAnsi(borderColor), 0.4) ?? theme.getFgAnsi("borderMuted")) : "";
-	const seg = (text: string) => `${segAnsi}${text}\x1b[39m`;
-
-	// A bottom-edge column is lit when it lies within half a segment of the
-	// travelling center.
-	const isLit = (col: number): boolean => Math.abs(col - head) < segHalf;
-	// Color a run of bottom-edge glyphs starting at column `startCol`, grouping
-	// consecutive same-state cells so each run emits a single escape pair.
-	const colorEdge = (glyphs: string, startCol: number): string => {
-		let out = "";
-		let runLit: boolean | null = null;
-		let buf = "";
-		for (let i = 0; i < glyphs.length; i++) {
-			const lit = isLit(startCol + i);
-			if (lit !== runLit) {
-				if (runLit !== null) out += (runLit ? seg : border)(buf);
-				buf = "";
-				runLit = lit;
-			}
-			buf += glyphs[i];
-		}
-		if (runLit !== null) out += (runLit ? seg : border)(buf);
-		return out;
-	};
 
 	const renderBar = (row: { leftChar: string; rightChar: string; label?: string; meta?: string }): string => {
 		const leftGlyphs = `${row.leftChar}${cap}`;
 		const rightGlyph = row.rightChar;
 		if (lineWidth <= 0) return border(leftGlyphs) + border(rightGlyph);
 		const labelText = [row.label, row.meta].filter(Boolean).join(theme.sep.dot);
-		const rawLabel = labelText ? ` ${labelText} ` : " ";
+		if (!labelText) {
+			// No header: draw a clean, continuous top/separator bar (no 1-col gap).
+			const fillCount = Math.max(0, lineWidth - visibleWidth(leftGlyphs) - visibleWidth(rightGlyph));
+			return `${border(leftGlyphs)}${border(h.repeat(fillCount))}${border(rightGlyph)}`;
+		}
+		const rawLabel = ` ${labelText} `;
 		const leftWidth = visibleWidth(leftGlyphs);
 		const rightWidth = visibleWidth(rightGlyph);
 		const maxLabelWidth = Math.max(0, lineWidth - leftWidth - rightWidth);
@@ -218,14 +156,10 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 		const rightGlyph = row.rightChar;
 		const fillCount = Math.max(0, lineWidth - visibleWidth(leftGlyphs) - visibleWidth(rightGlyph));
 		const fillGlyphs = h.repeat(fillCount);
-		if (!animate) return `${border(leftGlyphs)}${border(fillGlyphs)}${border(rightGlyph)}`;
-		const leftStr = colorEdge(leftGlyphs, 0);
-		const fillStr = colorEdge(fillGlyphs, visibleWidth(leftGlyphs));
-		const rightStr = colorEdge(rightGlyph, lineWidth - visibleWidth(rightGlyph));
-		return `${leftStr}${fillStr}${rightStr}`;
+		return `${border(leftGlyphs)}${border(fillGlyphs)}${border(rightGlyph)}`;
 	};
 
-	const renderContent = (inner: string): string => `${border(`${v} `)}${inner}${border(v)}`;
+	const renderContent = (inner: string): string => `${border(v)}${contentLeftPadding}${inner}${border(v)}`;
 
 	const lines: string[] = [];
 	for (let r = 0; r < H; r++) {
@@ -252,8 +186,8 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 export class CachedOutputBlock {
 	#cache?: RenderCache;
 
-	/** Render with caching. Returns cached result if options haven't changed. */
-	render(options: OutputBlockOptions, theme: Theme): string[] {
+	/** Render with caching. Returns the cached (shared, caller-immutable) lines if options haven't changed. */
+	render(options: OutputBlockOptions, theme: Theme): readonly string[] {
 		const key = this.#buildKey(options);
 		if (this.#cache?.key === key) return this.#cache.lines;
 		const lines = renderOutputBlock(options, theme);
@@ -269,15 +203,16 @@ export class CachedOutputBlock {
 	#buildKey(options: OutputBlockOptions): bigint {
 		const h = new Hasher();
 		h.u32(options.width);
+		h.u32(normalizeContentPaddingLeft(options.contentPaddingLeft));
 		h.optional(options.header);
 		h.optional(options.headerMeta);
 		h.optional(options.state);
+		h.optional(options.borderColor);
 		h.bool(options.applyBg ?? true);
-		h.bool(options.animate ?? false);
-		if (options.animate) h.u32(borderShimmerTick());
 		if (options.sections) {
 			for (const s of options.sections) {
 				h.optional(s.label);
+				h.bool(s.separator ?? false);
 				for (const line of s.lines) {
 					h.str(line);
 				}
@@ -286,3 +221,20 @@ export class CachedOutputBlock {
 		return h.digest();
 	}
 }
+
+/**
+ * Build a self-framing tool component backed by a cached output block. The
+ * `build` callback returns the block options for a given width; the cache
+ * dedupes re-renders. Pass `borderColor: "borderMuted"` for the dim "legacy"
+ * look that does not compete with the state-colored framed tools.
+ */
+export function framedBlock(theme: Theme, build: (width: number) => OutputBlockOptions): Component {
+	const block = new CachedOutputBlock();
+	// Marked so the tool-execution container treats it as self-framing (renders
+	// flush, no extra padding/background) the same way `markFramedBlockComponent`
+	// blocks are treated.
+	return markFramedBlockComponent({
+		render: (width: number): readonly string[] => block.render(build(width), theme),
+		invalidate: () => block.invalidate(),
+	});
+}

package/src/tui/status-line.ts

@@ -7,6 +7,9 @@ import { formatStatusIcon } from "../tools/render-utils";
 
 export interface StatusLineOptions {
 	icon?: ToolUIStatus;
+	/** Pre-rendered glyph that replaces the status icon (e.g. a magnifier for
+	 * search-family tools). Takes precedence over `icon`. */
+	iconOverride?: string;
 	spinnerFrame?: number;
 	title: string;
 	titleColor?: ThemeColor;
@@ -27,7 +30,8 @@ function flattenForHeader(text: string): string {
 }
 
 export function renderStatusLine(options: StatusLineOptions, theme: Theme): string {
-	const icon = options.icon ? formatStatusIcon(options.icon, theme, options.spinnerFrame) : "";
+	const icon =
+		options.iconOverride ?? (options.icon ? formatStatusIcon(options.icon, theme, options.spinnerFrame) : "");
 	const titleColor = options.titleColor ?? "accent";
 	const title = theme.fg(titleColor, flattenForHeader(options.title));
 	let line = icon ? `${icon} ${title}` : title;