cursor-buddy 0.0.10 → 0.0.11

package/dist/{client-CliXcNch.mjs → client-D7kFGsuH.mjs}

@@ -1000,6 +1000,8 @@ var ScreenCaptureService = class {
 * Preparation is allowed to run ahead of playback so server synthesis can
 * overlap with the currently playing segment, but the returned playback tasks
 * still execute one-by-one in enqueue order.
+*
+* Supports pausing after the current segment completes (for approval flows).
 */
 var TTSPlaybackQueue = class {
 	error = null;
@@ -1009,6 +1011,10 @@ var TTSPlaybackQueue = class {
 	playbackChain = Promise.resolve();
 	prepare;
 	signal;
+	isPaused = false;
+	pausePromise = null;
+	pauseResolver = null;
+	pendingSegments = [];
 	constructor(options) {
 		this.onError = options.onError;
 		this.onPlaybackStart = options.onPlaybackStart;
@@ -1021,11 +1027,15 @@ var TTSPlaybackQueue = class {
 	enqueue(text) {
 		const normalizedText = text.trim();
 		if (!normalizedText || this.error || this.signal?.aborted) return;
+		if (this.isPaused) return;
 		const preparedPlaybackTask = this.prepare(normalizedText, this.signal);
+		this.pendingSegments.push(normalizedText);
 		preparedPlaybackTask.catch((error) => {
 			this.fail(toError(error));
 		});
 		this.playbackChain = this.playbackChain.then(async () => {
+			if (this.signal?.aborted) return;
+			if (this.pausePromise) await this.pausePromise;
 			if (this.signal?.aborted) return;
 			const play = await preparedPlaybackTask;
 			if (this.signal?.aborted) return;
@@ -1034,11 +1044,43 @@ var TTSPlaybackQueue = class {
 				this.onPlaybackStart?.();
 			}
 			await play();
+			const index = this.pendingSegments.indexOf(normalizedText);
+			if (index !== -1) this.pendingSegments.splice(index, 1);
 		}).catch((error) => {
 			this.fail(toError(error));
 		});
 	}
 	/**
+	* Pause the queue after the currently playing segment completes.
+	* New segments enqueued while paused will be discarded.
+	*/
+	pauseAfterCurrent() {
+		if (this.isPaused) return;
+		this.isPaused = true;
+		this.pausePromise = new Promise((resolve) => {
+			this.pauseResolver = resolve;
+		});
+		this.pendingSegments = [];
+	}
+	/**
+	* Resume playback after a pause.
+	*/
+	resume() {
+		if (!this.isPaused) return;
+		this.isPaused = false;
+		if (this.pauseResolver) {
+			this.pauseResolver();
+			this.pauseResolver = null;
+			this.pausePromise = null;
+		}
+	}
+	/**
+	* Check if the queue is currently paused.
+	*/
+	isPausedState() {
+		return this.isPaused;
+	}
+	/**
 	* Wait until every queued segment has either played or the queue failed.
 	*/
 	async waitForCompletion() {
@@ -1442,12 +1484,12 @@ function createStateMachine(initial = "idle") {
 	};
 }
 //#endregion
-//#region src/core/utils/ui-stream-parser.ts
+//#region src/core/stream/parser.ts
 /**
 * Parse a single line from the UI message stream.
 * The stream format is SSE with "data: " prefix followed by JSON.
 */
-function parseUIStreamLine(line) {
+function parseStreamLine(line) {
 	const trimmed = line.trim();
 	if (!trimmed) return null;
 	let jsonStr = trimmed;
@@ -1458,17 +1500,46 @@ function parseUIStreamLine(line) {
 		switch (chunk.type) {
 			case "text-delta": return {
 				type: "text-delta",
-				delta: chunk.delta ?? ""
+				delta: typeof chunk.delta === "string" ? chunk.delta : ""
 			};
-			case "tool-input-available": return {
-				type: "tool-input-available",
-				toolName: chunk.toolName ?? "",
-				input: chunk.input
+			case "tool-call": return {
+				type: "tool-call",
+				toolCallId: typeof chunk.toolCallId === "string" ? chunk.toolCallId : "",
+				toolName: typeof chunk.toolName === "string" ? chunk.toolName : "",
+				args: chunk.args
+			};
+			case "tool-approval-request": return {
+				type: "tool-approval-request",
+				approvalId: typeof chunk.approvalId === "string" ? chunk.approvalId : "",
+				toolCallId: typeof chunk.toolCallId === "string" ? chunk.toolCallId : "",
+				toolName: typeof chunk.toolName === "string" ? chunk.toolName : "",
+				args: chunk.args
+			};
+			case "tool-result": return {
+				type: "tool-result",
+				toolCallId: typeof chunk.toolCallId === "string" ? chunk.toolCallId : "",
+				result: chunk.result
+			};
+			case "tool-result-error": return {
+				type: "tool-result-error",
+				toolCallId: typeof chunk.toolCallId === "string" ? chunk.toolCallId : "",
+				error: typeof chunk.error === "string" ? chunk.error : "Unknown error"
 			};
 			case "finish": return { type: "finish" };
 			case "error": return {
 				type: "error",
-				errorText: chunk.errorText ?? "Unknown error"
+				errorText: typeof chunk.errorText === "string" ? chunk.errorText : "Unknown error"
+			};
+			case "tool-input-available": return {
+				type: "tool-call",
+				toolCallId: typeof chunk.toolCallId === "string" ? chunk.toolCallId : `legacy-${Date.now()}`,
+				toolName: typeof chunk.toolName === "string" ? chunk.toolName : "",
+				args: chunk.input
+			};
+			case "tool-output-available": return {
+				type: "tool-result",
+				toolCallId: typeof chunk.toolCallId === "string" ? chunk.toolCallId : "",
+				result: chunk.output
 			};
 			default: return { type: "unknown" };
 		}
@@ -1477,24 +1548,23 @@ function parseUIStreamLine(line) {
 	}
 }
 /**
-* Check if a tool call is a point tool call with valid input.
+* Parse multiple lines from the stream buffer
 */
-function isPointToolCall(chunk) {
-	return chunk.type === "tool-input-available" && chunk.toolName === "point" && chunk.input != null && typeof chunk.input === "object" && "elementId" in chunk.input && "label" in chunk.input;
+function parseStreamBuffer(buffer) {
+	const lines = buffer.split("\n");
+	const remainder = lines.pop() ?? "";
+	const chunks = [];
+	for (const line of lines) {
+		const chunk = parseStreamLine(line);
+		if (chunk) chunks.push(chunk);
+	}
+	return {
+		chunks,
+		remainder
+	};
 }
 //#endregion
-//#region src/core/utils/response-processor.ts
-const COMMON_ABBREVIATIONS = [
-	"mr.",
-	"mrs.",
-	"ms.",
-	"dr.",
-	"prof.",
-	"sr.",
-	"jr.",
-	"e.g.",
-	"i.e."
-];
+//#region src/core/speech/sentences.ts
 const CLOSING_PUNCTUATION = new Set([
 	"\"",
 	"'",
@@ -1512,8 +1582,6 @@ function isLikelySentenceBoundary(text, index) {
 	const previousChar = text[index - 1] ?? "";
 	const nextChar = text[index + 1] ?? "";
 	if (/\d/.test(previousChar) && /\d/.test(nextChar)) return false;
-	const lookback = text.slice(Math.max(0, index - 10), index + 1).toLowerCase();
-	if (COMMON_ABBREVIATIONS.some((abbreviation) => lookback.endsWith(abbreviation))) return false;
 	return true;
 }
 function findBoundaryEnd(text, start) {
@@ -1526,16 +1594,17 @@ function findBoundaryEnd(text, start) {
 		if (!isLikelySentenceBoundary(text, index)) continue;
 		let end = index + 1;
 		while (end < text.length && CLOSING_PUNCTUATION.has(text[end] ?? "")) end++;
-		if (end < text.length) {
-			const nextChar = text[end] ?? "";
-			if (!/\s/.test(nextChar) && !/[A-Z0-9]/.test(nextChar)) continue;
-		}
+		if (end < text.length && !/\s/.test(text[end] ?? "")) continue;
 		while (end < text.length && /\s/.test(text[end] ?? "")) end++;
 		return end;
 	}
 	return null;
 }
-function extractCompletedSegments(text) {
+/**
+* Extract completed sentences from text.
+* Returns the consumed length and extracted segments.
+*/
+function extractCompletedSentences(text) {
 	const segments = [];
 	let consumedLength = 0;
 	while (consumedLength < text.length) {
@@ -1551,59 +1620,32 @@ function extractCompletedSegments(text) {
 	};
 }
 /**
-* Processes a streaming AI SDK UI message stream response.
-* Extracts text for display/TTS and captures point tool calls.
+* Buffer that accumulates text and emits complete sentences for TTS.
+* Coalesces short segments to avoid choppy speech.
 */
-var ProgressiveResponseProcessor = class {
-	consumedTextLength = 0;
+var SentenceBuffer = class {
+	text = "";
+	consumedLength = 0;
 	pendingShortSegment = "";
-	rawText = "";
-	buffer = "";
-	pointToolCall = null;
 	/**
-	* Push raw stream data and extract text chunks and tool calls.
-	* The UI message stream format is newline-delimited JSON.
+	* Add text to the buffer and extract any complete sentences.
 	*/
-	push(chunk) {
-		this.buffer += chunk;
-		const lines = this.buffer.split("\n");
-		this.buffer = lines.pop() ?? "";
-		const newTextParts = [];
-		for (const line of lines) {
-			const parsed = parseUIStreamLine(line);
-			if (!parsed) continue;
-			if (parsed.type === "text-delta") newTextParts.push(parsed.delta);
-			else if (isPointToolCall(parsed)) {
-				if (!this.pointToolCall) this.pointToolCall = parsed.input;
-			}
-		}
-		if (newTextParts.length > 0) this.rawText += newTextParts.join("");
-		const { consumedLength, segments } = extractCompletedSegments(this.rawText.slice(this.consumedTextLength));
-		this.consumedTextLength += consumedLength;
-		return {
-			visibleText: this.rawText,
-			speechSegments: this.coalesceSegments(segments),
-			pointToolCall: this.pointToolCall
-		};
+	push(delta) {
+		this.text += delta;
+		const { consumedLength, segments } = extractCompletedSentences(this.text.slice(this.consumedLength));
+		this.consumedLength += consumedLength;
+		return this.coalesceSegments(segments);
 	}
 	/**
-	* Finalize processing and return any remaining text/tool call.
+	* Flush any remaining text as a final segment.
 	*/
-	finish() {
-		if (this.buffer) {
-			const parsed = parseUIStreamLine(this.buffer);
-			if (parsed?.type === "text-delta") this.rawText += parsed.delta;
-			else if (parsed && isPointToolCall(parsed) && !this.pointToolCall) this.pointToolCall = parsed.input;
-			this.buffer = "";
-		}
-		const trailingText = this.rawText.slice(this.consumedTextLength).trim();
-		const finalSegmentParts = [this.pendingShortSegment, trailingText].filter(Boolean);
+	flush() {
+		const trailingText = this.text.slice(this.consumedLength).trim();
+		const finalParts = [this.pendingShortSegment, trailingText].filter(Boolean);
 		this.pendingShortSegment = "";
-		return {
-			finalResponseText: this.rawText.trim(),
-			speechSegments: finalSegmentParts.length ? [finalSegmentParts.join(" ").trim()] : [],
-			pointToolCall: this.pointToolCall
-		};
+		this.text = "";
+		this.consumedLength = 0;
+		return finalParts.length ? finalParts.join(" ").trim() : "";
 	}
 	coalesceSegments(segments) {
 		const speechSegments = [];
@@ -1622,6 +1664,342 @@ var ProgressiveResponseProcessor = class {
 	}
 };
 //#endregion
+//#region src/core/stream/processor.ts
+/**
+* Processes a streaming AI SDK UI message stream.
+* Extracts text, tool calls, and speech segments.
+*/
+var StreamProcessor = class {
+	callbacks;
+	sentenceBuffer;
+	buffer = "";
+	responseText = "";
+	pendingApproval = void 0;
+	constructor(callbacks) {
+		this.callbacks = callbacks;
+		this.sentenceBuffer = new SentenceBuffer();
+	}
+	/**
+	* Process a raw chunk from the stream.
+	*/
+	processChunk(chunk) {
+		this.buffer += chunk;
+		const { chunks, remainder } = parseStreamBuffer(this.buffer);
+		this.buffer = remainder;
+		for (const parsed of chunks) this.handleParsedChunk(parsed);
+	}
+	/**
+	* Finalize processing and return turn result.
+	*/
+	finish() {
+		if (this.buffer) {
+			const { chunks } = parseStreamBuffer(this.buffer + "\n");
+			for (const parsed of chunks) this.handleParsedChunk(parsed);
+			this.buffer = "";
+		}
+		const remainingText = this.sentenceBuffer.flush();
+		if (remainingText) this.callbacks.onSpeechSegment(remainingText);
+		return {
+			responseText: this.responseText.trim(),
+			requiresApprovalContinuation: this.pendingApproval !== void 0,
+			pendingApproval: this.pendingApproval
+		};
+	}
+	/**
+	* Get the current response text.
+	*/
+	getResponseText() {
+		return this.responseText;
+	}
+	handleParsedChunk(chunk) {
+		switch (chunk.type) {
+			case "text-delta":
+				this.responseText += chunk.delta;
+				this.callbacks.onTextDelta(chunk.delta);
+				const sentences = this.sentenceBuffer.push(chunk.delta);
+				for (const sentence of sentences) this.callbacks.onSpeechSegment(sentence);
+				break;
+			case "tool-call":
+				this.callbacks.onToolCall({
+					toolCallId: chunk.toolCallId,
+					toolName: chunk.toolName,
+					args: chunk.args
+				});
+				break;
+			case "tool-approval-request":
+				this.pendingApproval = {
+					approvalId: chunk.approvalId,
+					toolCallId: chunk.toolCallId,
+					toolName: chunk.toolName,
+					args: chunk.args
+				};
+				this.callbacks.onApprovalRequest({
+					approvalId: chunk.approvalId,
+					toolCallId: chunk.toolCallId,
+					toolName: chunk.toolName,
+					args: chunk.args
+				});
+				break;
+			case "tool-result":
+				this.callbacks.onToolResult({
+					toolCallId: chunk.toolCallId,
+					result: chunk.result
+				});
+				break;
+			case "tool-result-error":
+				this.callbacks.onToolError({
+					toolCallId: chunk.toolCallId,
+					error: chunk.error
+				});
+				break;
+			case "finish":
+				this.callbacks.onFinish();
+				break;
+			case "error":
+				this.callbacks.onError(chunk.errorText);
+				break;
+			case "unknown": break;
+		}
+	}
+};
+//#endregion
+//#region src/core/tools/labels.ts
+/**
+* Capitalize the first letter of a string.
+*/
+function capitalize(str) {
+	if (!str) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+* Convert a tool name to human-readable format.
+* e.g., "web_search" -> "web search", "createNote" -> "create note"
+*/
+function humanizeToolName(toolName) {
+	return toolName.replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+}
+/**
+* Generate a default label for a tool based on its name and status.
+*/
+function generateToolLabel(toolName, status) {
+	const humanName = humanizeToolName(toolName);
+	switch (status) {
+		case "pending": return `${capitalize(humanName)}...`;
+		case "awaiting_approval": return `Approve ${humanName}?`;
+		case "approved": return `${capitalize(humanName)}...`;
+		case "denied": return "Cancelled";
+		case "completed": return capitalize(humanName);
+		case "failed": return `${capitalize(humanName)} failed`;
+	}
+}
+/**
+* Resolve the label for a tool call using the display config.
+* Falls back to auto-generated label if no config is provided.
+*/
+function resolveToolLabel(toolName, args, status, config) {
+	const toolConfig = config?.[toolName];
+	if (toolConfig?.label) {
+		if (typeof toolConfig.label === "function") return toolConfig.label(args, status);
+		return toolConfig.label;
+	}
+	const defaultConfig = config?.["*"];
+	if (defaultConfig?.label) {
+		if (typeof defaultConfig.label === "function") return defaultConfig.label(args, status);
+		return defaultConfig.label;
+	}
+	return generateToolLabel(toolName, status);
+}
+//#endregion
+//#region src/core/tools/manager.ts
+/**
+* Manages tool call state, display timing, and approval flow.
+*/
+var ToolCallManager = class {
+	toolCalls = /* @__PURE__ */ new Map();
+	displayConfig;
+	callbacks;
+	removalTimers = /* @__PURE__ */ new Map();
+	constructor(callbacks, displayConfig) {
+		this.callbacks = callbacks;
+		this.displayConfig = displayConfig ?? {};
+	}
+	/**
+	* Update the display configuration.
+	*/
+	setDisplayConfig(config) {
+		this.displayConfig = config;
+	}
+	/**
+	* Handle a new tool call from the stream.
+	*/
+	handleToolCall(event) {
+		const status = "pending";
+		const label = resolveToolLabel(event.toolName, event.args, status, this.displayConfig);
+		const toolCall = {
+			id: event.toolCallId,
+			toolName: event.toolName,
+			args: event.args,
+			status,
+			label,
+			enteredQueueAt: Date.now()
+		};
+		this.toolCalls.set(event.toolCallId, toolCall);
+		this.callbacks.onChange();
+	}
+	/**
+	* Handle an approval request for a tool call.
+	*/
+	handleApprovalRequest(event) {
+		const existing = this.toolCalls.get(event.toolCallId);
+		if (existing) {
+			existing.status = "awaiting_approval";
+			existing.approvalId = event.approvalId;
+			existing.label = resolveToolLabel(existing.toolName, existing.args, "awaiting_approval", this.displayConfig);
+		} else {
+			const label = resolveToolLabel(event.toolName, event.args, "awaiting_approval", this.displayConfig);
+			const toolCall = {
+				id: event.toolCallId,
+				toolName: event.toolName,
+				args: event.args,
+				status: "awaiting_approval",
+				label,
+				approvalId: event.approvalId,
+				enteredQueueAt: Date.now()
+			};
+			this.toolCalls.set(event.toolCallId, toolCall);
+		}
+		this.callbacks.onChange();
+	}
+	/**
+	* Handle a successful tool result.
+	*/
+	handleToolResult(event) {
+		const toolCall = this.toolCalls.get(event.toolCallId);
+		if (!toolCall) return;
+		toolCall.status = "completed";
+		toolCall.result = event.result;
+		toolCall.label = resolveToolLabel(toolCall.toolName, toolCall.args, "completed", this.displayConfig);
+		this.scheduleRemoval(toolCall);
+		this.callbacks.onChange();
+	}
+	/**
+	* Handle a tool execution error.
+	*/
+	handleToolError(event) {
+		const toolCall = this.toolCalls.get(event.toolCallId);
+		if (!toolCall) return;
+		const errorResult = this.getConfigFor(toolCall.toolName)?.onError?.(event.error, toolCall.args);
+		if (errorResult && "hide" in errorResult && errorResult.hide) {
+			this.toolCalls.delete(event.toolCallId);
+			this.callbacks.onChange();
+			return;
+		}
+		toolCall.status = "failed";
+		toolCall.error = event.error;
+		if (errorResult && "label" in errorResult) toolCall.label = errorResult.label;
+		else toolCall.label = resolveToolLabel(toolCall.toolName, toolCall.args, "failed", this.displayConfig);
+		this.scheduleRemoval(toolCall);
+		this.callbacks.onChange();
+	}
+	/**
+	* Approve a pending tool call.
+	*/
+	async approve(toolCallId) {
+		const toolCall = this.toolCalls.get(toolCallId);
+		if (!toolCall || toolCall.status !== "awaiting_approval") return;
+		if (!toolCall.approvalId) return;
+		toolCall.status = "approved";
+		toolCall.label = resolveToolLabel(toolCall.toolName, toolCall.args, "approved", this.displayConfig);
+		this.callbacks.onChange();
+		await this.callbacks.onApprovalResponse(toolCall.approvalId, true);
+	}
+	/**
+	* Deny a pending tool call.
+	*/
+	async deny(toolCallId) {
+		const toolCall = this.toolCalls.get(toolCallId);
+		if (!toolCall || toolCall.status !== "awaiting_approval") return;
+		if (!toolCall.approvalId) return;
+		toolCall.status = "denied";
+		toolCall.label = resolveToolLabel(toolCall.toolName, toolCall.args, "denied", this.displayConfig);
+		this.scheduleRemoval(toolCall);
+		this.callbacks.onChange();
+		await this.callbacks.onApprovalResponse(toolCall.approvalId, false);
+	}
+	/**
+	* Manually dismiss a tool call bubble.
+	*/
+	dismiss(toolCallId) {
+		this.clearRemovalTimer(toolCallId);
+		this.toolCalls.delete(toolCallId);
+		this.callbacks.onChange();
+	}
+	/**
+	* Get a tool call by ID.
+	*/
+	getToolCall(id) {
+		return this.toolCalls.get(id);
+	}
+	/**
+	* Get all tool calls.
+	*/
+	getToolCalls() {
+		return Array.from(this.toolCalls.values());
+	}
+	/**
+	* Get active (visible, non-expired) tool calls.
+	*/
+	getActiveToolCalls() {
+		const now = Date.now();
+		return Array.from(this.toolCalls.values()).filter((toolCall) => {
+			const config = this.getConfigFor(toolCall.toolName);
+			if (config?.mode === "hidden") return false;
+			if (toolCall.status === "awaiting_approval") return true;
+			if (toolCall.status === "pending" || toolCall.status === "approved") return true;
+			const minTime = config?.minDisplayTime ?? 1500;
+			return now - toolCall.enteredQueueAt < minTime + 300;
+		});
+	}
+	/**
+	* Get the tool call awaiting approval, if any.
+	*/
+	getPendingApproval() {
+		for (const toolCall of this.toolCalls.values()) if (toolCall.status === "awaiting_approval") return toolCall;
+		return null;
+	}
+	/**
+	* Clear all tool calls and timers.
+	*/
+	reset() {
+		for (const timer of this.removalTimers.values()) clearTimeout(timer);
+		this.removalTimers.clear();
+		this.toolCalls.clear();
+		this.callbacks.onChange();
+	}
+	getConfigFor(toolName) {
+		return this.displayConfig[toolName] ?? this.displayConfig["*"];
+	}
+	scheduleRemoval(toolCall) {
+		this.clearRemovalTimer(toolCall.id);
+		const minTime = this.getConfigFor(toolCall.toolName)?.minDisplayTime ?? 1500;
+		const elapsed = Date.now() - toolCall.enteredQueueAt;
+		const remaining = Math.max(0, minTime - elapsed) + 300;
+		const timer = setTimeout(() => {
+			this.toolCalls.delete(toolCall.id);
+			this.removalTimers.delete(toolCall.id);
+			this.callbacks.onChange();
+		}, remaining);
+		this.removalTimers.set(toolCall.id, timer);
+	}
+	clearRemovalTimer(toolCallId) {
+		const existing = this.removalTimers.get(toolCallId);
+		if (existing) {
+			clearTimeout(existing);
+			this.removalTimers.delete(toolCallId);
+		}
+	}
+};
+//#endregion
 //#region src/core/client.ts
 async function readErrorMessage(response, fallbackMessage) {
 	try {
@@ -1640,8 +2018,10 @@ async function readErrorMessage(response, fallbackMessage) {
 * Manages the complete voice interaction flow:
 * idle -> listening -> processing -> responding -> idle
 *
-* Supports interruption: pressing hotkey during any state aborts
-* in-flight work and immediately transitions to listening.
+* Supports:
+* - Interruption via hotkey
+* - Tool call display with approval flow
+* - Point tool for cursor movement
 */
 var CursorBuddyClient = class {
 	endpoint;
@@ -1653,14 +2033,17 @@ var CursorBuddyClient = class {
 	screenCapture;
 	pointerController;
 	stateMachine;
+	toolManager;
 	liveTranscript = "";
 	transcript = "";
 	response = "";
 	error = null;
 	abortController = null;
-	historyCommittedForTurn = false;
 	speechProviderForTurn = null;
 	screenshotPromise = null;
+	currentScreenshot = null;
+	pendingApprovalResolver = null;
+	playbackQueue = null;
 	cachedSnapshot;
 	listeners = /* @__PURE__ */ new Set();
 	constructor(endpoint, options = {}, services = {}) {
@@ -1673,6 +2056,10 @@ var CursorBuddyClient = class {
 		this.screenCapture = services.screenCapture ?? new ScreenCaptureService();
 		this.pointerController = services.pointerController ?? new PointerController();
 		this.stateMachine = createStateMachine();
+		this.toolManager = new ToolCallManager({
+			onChange: () => this.notify(),
+			onApprovalResponse: async () => {}
+		}, options.toolDisplay);
 		this.cachedSnapshot = this.buildSnapshot();
 		this.voiceCapture.onLevel((level) => $audioLevel.set(level));
 		this.liveTranscription.onPartial((text) => {
@@ -1686,19 +2073,16 @@ var CursorBuddyClient = class {
 		});
 		this.pointerController.subscribe(() => this.notify());
 	}
-	/**
-	* Start listening for voice input.
-	* Aborts any in-flight work from previous session.
-	*/
 	startListening() {
 		this.abort();
 		this.liveTranscript = "";
 		this.transcript = "";
 		this.response = "";
 		this.error = null;
-		this.historyCommittedForTurn = false;
 		this.speechProviderForTurn = null;
+		this.currentScreenshot = null;
 		this.pointerController.release();
+		this.toolManager.reset();
 		this.stateMachine.transition({ type: "HOTKEY_PRESSED" });
 		this.notify();
 		this.abortController = new AbortController();
@@ -1711,9 +2095,6 @@ var CursorBuddyClient = class {
 			this.handleError(toError(error, "Failed to start listening"));
 		});
 	}
-	/**
-	* Stop listening and process the voice input.
-	*/
 	async stopListening() {
 		if (this.stateMachine.getState() !== "listening") return;
 		this.stateMachine.transition({ type: "HOTKEY_RELEASED" });
@@ -1728,14 +2109,8 @@ var CursorBuddyClient = class {
 		};
 		try {
 			const [audioBlob, browserTranscript] = await Promise.all([this.voiceCapture.stop(), this.stopLiveTranscription()]);
-			let screenshot;
-			try {
-				if (!this.screenshotPromise) throw new Error("Screenshot was not started");
-				screenshot = await this.screenshotPromise;
-			} catch (screenshotError) {
-				const errorMessage = screenshotError instanceof Error ? `Failed to capture screenshot: ${screenshotError.message}` : "Failed to capture screenshot";
-				throw new Error(errorMessage);
-			}
+			if (!this.screenshotPromise) throw new Error("Screenshot was not started");
+			this.currentScreenshot = await this.screenshotPromise;
 			if (turnFailure) throw turnFailure;
 			if (signal?.aborted) return;
 			const transcript = await this.resolveTranscript(browserTranscript, audioBlob, signal);
@@ -1746,47 +2121,18 @@ var CursorBuddyClient = class {
 			this.options.onTranscript?.(transcript);
 			this.notify();
 			this.prepareSpeechMode();
-			const { cleanResponse, pointToolCall, playbackQueue } = await this.chatAndSpeak(transcript, screenshot, signal, {
-				onFailure: failTurn,
-				onPlaybackStart: () => {
-					this.stateMachine.transition({ type: "RESPONSE_STARTED" });
-				}
-			});
+			const messages = [...$conversationHistory.get(), {
+				role: "user",
+				content: transcript
+			}];
+			const { responseText, updatedMessages } = await this.processChatLoop(messages, this.currentScreenshot, signal, failTurn);
 			if (turnFailure) throw turnFailure;
 			if (signal?.aborted) return;
-			this.options.onResponse?.(cleanResponse);
-			let pointTarget = null;
-			if (pointToolCall) {
-				const element = screenshot.elementRegistry.get(pointToolCall.elementId);
-				if (element) {
-					const rect = element.getBoundingClientRect();
-					pointTarget = {
-						x: Math.round(rect.left + rect.width / 2),
-						y: Math.round(rect.top + rect.height / 2),
-						label: pointToolCall.label
-					};
-				}
-			}
-			if (pointTarget) {
-				this.options.onPoint?.(pointTarget);
-				this.pointerController.pointAt(pointTarget);
-			}
-			await playbackQueue.waitForCompletion();
+			this.options.onResponse?.(responseText);
+			if (this.playbackQueue) await this.playbackQueue.waitForCompletion();
 			if (turnFailure) throw turnFailure;
 			if (signal?.aborted) return;
-			const newHistory = [
-				...$conversationHistory.get(),
-				{
-					role: "user",
-					content: transcript
-				},
-				{
-					role: "assistant",
-					content: cleanResponse
-				}
-			];
-			$conversationHistory.set(newHistory);
-			this.historyCommittedForTurn = true;
+			$conversationHistory.set(updatedMessages);
 			this.stateMachine.transition({ type: "TTS_COMPLETE" });
 		} catch (err) {
 			if (turnFailure) {
@@ -1797,16 +2143,10 @@ var CursorBuddyClient = class {
 			this.handleError(toError(err));
 		}
 	}
-	/**
-	* Enable or disable the buddy.
-	*/
 	setEnabled(enabled) {
 		$isEnabled.set(enabled);
 		this.notify();
 	}
-	/**
-	* Manually point at coordinates.
-	*/
 	pointAt(x, y, label) {
 		this.pointerController.pointAt({
 			x,
@@ -1814,50 +2154,48 @@ var CursorBuddyClient = class {
 			label
 		});
 	}
-	/**
-	* Dismiss the current pointing target.
-	*/
 	dismissPointing() {
 		this.pointerController.release();
 	}
-	/**
-	* Reset to idle state and stop any in-progress work.
-	*/
 	reset() {
 		this.abort();
 		this.liveTranscript = "";
 		this.transcript = "";
 		this.response = "";
 		this.error = null;
-		this.historyCommittedForTurn = false;
+		this.currentScreenshot = null;
 		this.pointerController.release();
+		this.toolManager.reset();
 		this.stateMachine.reset();
 		this.notify();
 	}
-	/**
-	* Update buddy position to follow cursor.
-	* Call this on cursor position changes.
-	*/
 	updateCursorPosition() {
 		this.pointerController.updateFollowPosition();
 	}
-	/**
-	* Subscribe to state changes.
-	*/
+	async approveToolCall(id) {
+		if (this.pendingApprovalResolver) {
+			this.pendingApprovalResolver(true);
+			this.pendingApprovalResolver = null;
+		}
+		await this.toolManager.approve(id);
+	}
+	async denyToolCall(id) {
+		if (this.pendingApprovalResolver) {
+			this.pendingApprovalResolver(false);
+			this.pendingApprovalResolver = null;
+		}
+		await this.toolManager.deny(id);
+	}
+	dismissToolCall(id) {
+		this.toolManager.dismiss(id);
+	}
 	subscribe(listener) {
 		this.listeners.add(listener);
 		return () => this.listeners.delete(listener);
 	}
-	/**
-	* Get current state snapshot for React's useSyncExternalStore.
-	* Returns a cached object to ensure referential stability.
-	*/
 	getSnapshot() {
 		return this.cachedSnapshot;
 	}
-	/**
-	* Build a new snapshot object.
-	*/
 	buildSnapshot() {
 		return {
 			state: this.stateMachine.getState(),
@@ -1866,11 +2204,13 @@ var CursorBuddyClient = class {
 			response: this.response,
 			error: this.error,
 			isPointing: this.pointerController.isPointing(),
-			isEnabled: $isEnabled.get()
+			isEnabled: $isEnabled.get(),
+			toolCalls: this.toolManager.getToolCalls(),
+			activeToolCalls: this.toolManager.getActiveToolCalls(),
+			pendingApproval: this.toolManager.getPendingApproval()
 		};
 	}
 	abort() {
-		this.commitPartialHistory();
 		this.abortController?.abort();
 		this.abortController = null;
 		this.screenshotPromise = null;
@@ -1879,102 +2219,169 @@ var CursorBuddyClient = class {
 		this.audioPlayback.stop();
 		this.browserSpeech.stop();
 		this.speechProviderForTurn = null;
+		this.pendingApprovalResolver = null;
+		this.toolManager.reset();
 		$audioLevel.set(0);
 	}
 	/**
-	* Commit partial turn to history when interrupted.
-	* Only commits if we have both transcript and response,
-	* and haven't already committed for this turn.
+	* Process chat with approval loop.
+	* Returns when the turn is complete (no pending approvals).
 	*/
-	commitPartialHistory() {
-		if (this.historyCommittedForTurn) return;
-		if (!this.transcript || !this.response) return;
-		const newHistory = [
-			...$conversationHistory.get(),
-			{
-				role: "user",
-				content: this.transcript
+	async processChatLoop(messages, screenshot, signal, onFailure) {
+		let currentMessages = [...messages];
+		let fullResponseText = "";
+		let hasStartedPlayback = false;
+		this.playbackQueue = new TTSPlaybackQueue({
+			onError: onFailure,
+			onPlaybackStart: () => {
+				if (!hasStartedPlayback) {
+					hasStartedPlayback = true;
+					this.stateMachine.transition({ type: "RESPONSE_STARTED" });
+				}
 			},
-			{
-				role: "assistant",
-				content: this.response
-			}
-		];
-		$conversationHistory.set(newHistory);
-		this.historyCommittedForTurn = true;
-	}
-	async transcribe(blob, signal) {
-		const formData = new FormData();
-		formData.append("audio", blob, "recording.wav");
-		const response = await fetch(`${this.endpoint}/transcribe`, {
-			method: "POST",
-			body: formData,
+			prepare: (text, currentSignal) => this.prepareSpeechSegment(text, currentSignal),
 			signal
 		});
-		if (!response.ok) throw new Error(await readErrorMessage(response, "Transcription failed"));
-		const { text } = await response.json();
-		return text;
+		const shouldStreamSpeech = this.isSpeechStreamingEnabled();
+		while (true) {
+			if (signal?.aborted) break;
+			let currentScreenshot = screenshot;
+			if (currentMessages.length > messages.length) currentScreenshot = await this.screenCapture.capture();
+			const response = await this.fetchChatStream(currentMessages, currentScreenshot, signal);
+			const { responseText, requiresApprovalContinuation, pendingApproval } = await this.consumeStream(response, currentScreenshot, shouldStreamSpeech, signal);
+			fullResponseText = responseText;
+			this.response = responseText;
+			this.notify();
+			currentMessages = [...currentMessages, {
+				role: "assistant",
+				content: responseText
+			}];
+			if (!requiresApprovalContinuation || !pendingApproval) break;
+			this.playbackQueue.pauseAfterCurrent();
+			const approved = await this.waitForApproval();
+			this.playbackQueue.resume();
+			currentMessages = [...currentMessages, {
+				role: "tool",
+				content: [{
+					type: "tool-approval-response",
+					approvalId: pendingApproval.approvalId,
+					approved
+				}]
+			}];
+		}
+		return {
+			responseText: fullResponseText,
+			updatedMessages: currentMessages
+		};
 	}
-	/**
-	* Stream the chat response, keep the visible text updated, and feed complete
-	* speech segments into the TTS queue as soon as they are ready.
-	*/
-	async chatAndSpeak(transcript, screenshot, signal, options) {
-		const history = $conversationHistory.get();
+	async fetchChatStream(messages, screenshot, signal) {
 		const response = await fetch(`${this.endpoint}/chat`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({
+				messages,
 				screenshot: screenshot.imageData,
 				capture: {
 					width: screenshot.width,
 					height: screenshot.height
 				},
-				transcript,
-				history,
 				domSnapshot: screenshot.domSnapshot
 			}),
 			signal
 		});
-		if (!response.ok) throw new Error("Chat request failed");
+		if (!response.ok) throw new Error(await readErrorMessage(response, "Chat request failed"));
+		return response;
+	}
+	async consumeStream(response, screenshot, shouldStreamSpeech, signal) {
 		const reader = response.body?.getReader();
 		if (!reader) throw new Error("No response body");
 		const decoder = new TextDecoder();
-		const responseProcessor = new ProgressiveResponseProcessor();
-		const playbackQueue = new TTSPlaybackQueue({
-			onError: options.onFailure,
-			onPlaybackStart: options.onPlaybackStart,
-			prepare: (text, currentSignal) => this.prepareSpeechSegment(text, currentSignal),
-			signal
+		const state = { pointToolCall: null };
+		const processor = new StreamProcessor({
+			onTextDelta: () => {},
+			onSpeechSegment: (text) => {
+				if (shouldStreamSpeech && this.playbackQueue) this.playbackQueue.enqueue(text);
+			},
+			onToolCall: (event) => {
+				if (event.toolName === "point") {
+					const input = event.args;
+					if (input && typeof input.elementId === "number" && typeof input.label === "string") state.pointToolCall = {
+						elementId: input.elementId,
+						label: input.label
+					};
+				} else {
+					this.toolManager.handleToolCall(event);
+					this.options.onToolCall?.({
+						id: event.toolCallId,
+						toolName: event.toolName,
+						args: event.args
+					});
+				}
+			},
+			onApprovalRequest: (event) => {
+				this.toolManager.handleApprovalRequest(event);
+			},
+			onToolResult: (event) => {
+				const toolCall = this.toolManager.getToolCall(event.toolCallId);
+				this.toolManager.handleToolResult(event);
+				if (toolCall) this.options.onToolResult?.({
+					id: event.toolCallId,
+					toolName: toolCall.toolName,
+					result: event.result
+				});
+			},
+			onToolError: (event) => {
+				this.toolManager.handleToolError(event);
+			},
+			onFinish: () => {},
+			onError: (error) => {
+				throw new Error(error);
+			}
 		});
-		const shouldStreamSpeech = this.isSpeechStreamingEnabled();
 		while (true) {
 			const { done, value } = await reader.read();
 			if (done) break;
 			const chunk = decoder.decode(value, { stream: true });
-			const { speechSegments, visibleText } = responseProcessor.push(chunk);
-			if (shouldStreamSpeech) for (const speechSegment of speechSegments) playbackQueue.enqueue(speechSegment);
-			this.updateResponse(visibleText);
+			processor.processChunk(chunk);
+			this.response = processor.getResponseText();
+			this.notify();
 		}
 		const trailingChunk = decoder.decode();
-		if (trailingChunk) {
-			const { speechSegments, visibleText } = responseProcessor.push(trailingChunk);
-			if (shouldStreamSpeech) for (const speechSegment of speechSegments) playbackQueue.enqueue(speechSegment);
-			this.updateResponse(visibleText);
+		if (trailingChunk) processor.processChunk(trailingChunk);
+		const result = processor.finish();
+		if (state.pointToolCall !== null) {
+			const pointCall = state.pointToolCall;
+			const element = screenshot.elementRegistry.get(pointCall.elementId);
+			if (element) {
+				const rect = element.getBoundingClientRect();
+				const target = {
+					x: Math.round(rect.left + rect.width / 2),
+					y: Math.round(rect.top + rect.height / 2),
+					label: pointCall.label
+				};
+				this.options.onPoint?.(target);
+				this.pointerController.pointAt(target);
+			}
 		}
-		const finalizedResponse = responseProcessor.finish();
-		if (shouldStreamSpeech) for (const speechSegment of finalizedResponse.speechSegments) playbackQueue.enqueue(speechSegment);
-		else playbackQueue.enqueue(finalizedResponse.finalResponseText);
-		this.updateResponse(finalizedResponse.finalResponseText);
-		return {
-			cleanResponse: finalizedResponse.finalResponseText,
-			pointToolCall: finalizedResponse.pointToolCall,
-			playbackQueue
-		};
+		if (!shouldStreamSpeech && this.playbackQueue) this.playbackQueue.enqueue(result.responseText);
+		return result;
+	}
+	waitForApproval() {
+		return new Promise((resolve) => {
+			this.pendingApprovalResolver = resolve;
+		});
+	}
+	async transcribe(blob, signal) {
+		const formData = new FormData();
+		formData.append("audio", blob, "recording.wav");
+		const response = await fetch(`${this.endpoint}/transcribe`, {
+			method: "POST",
+			body: formData,
+			signal
+		});
+		if (!response.ok) throw new Error(await readErrorMessage(response, "Transcription failed"));
+		return (await response.json()).text;
 	}
-	/**
-	* Request server-side TTS audio for one text segment.
-	*/
 	async synthesizeSpeech(text, signal) {
 		const response = await fetch(`${this.endpoint}/tts`, {
 			method: "POST",
@@ -1985,16 +2392,6 @@ var CursorBuddyClient = class {
 		if (!response.ok) throw new Error(await readErrorMessage(response, "TTS request failed"));
 		return response.blob();
 	}
-	/**
-	* Resolve the initial speech provider for this turn.
-	*
-	* Decision tree:
-	* 1. In `server` mode, always synthesize on the server.
-	* 2. In `browser` mode, require browser speech support up front.
-	* 3. In `auto` mode, prefer browser speech when available and keep that
-	*    choice cached so later segments stay on the same provider unless a
-	*    browser failure forces a one-way fallback to the server.
-	*/
 	prepareSpeechMode() {
 		const speechMode = this.getSpeechMode();
 		if (speechMode === "browser" && !this.browserSpeech.isAvailable()) throw new Error("Browser speech is not supported");
@@ -2008,13 +2405,6 @@ var CursorBuddyClient = class {
 		}
 		this.speechProviderForTurn = this.browserSpeech.isAvailable() ? "browser" : "server";
 	}
-	/**
-	* Prepare a playback task for one text segment.
-	*
-	* The queue calls this eagerly so server synthesis can overlap with the
-	* currently playing segment, but the returned task is still executed in the
-	* original enqueue order.
-	*/
 	async prepareSpeechSegment(text, signal) {
 		switch (this.getSpeechMode()) {
 			case "server": return this.prepareServerSpeechTask(text, signal);
@@ -2022,27 +2412,13 @@ var CursorBuddyClient = class {
 			default: return this.prepareAutoSpeechTask(text, signal);
 		}
 	}
-	/**
-	* Synthesize server audio immediately and return a playback task that reuses
-	* the prepared blob later.
-	*/
 	async prepareServerSpeechTask(text, signal) {
 		const blob = await this.synthesizeSpeech(text, signal);
 		return () => this.audioPlayback.play(blob, signal);
 	}
-	/**
-	* Return a browser playback task for one text segment.
-	*/
-	async prepareBrowserSpeechTask(text, signal) {
-		return () => this.browserSpeech.speak(text, signal);
+	async prepareBrowserSpeechTask(_text, signal) {
+		return () => this.browserSpeech.speak(_text, signal);
 	}
-	/**
-	* Prepare a playback task for `auto` mode.
-	*
-	* We prefer the browser for low latency, but if browser speech fails for any
-	* segment we permanently switch the remainder of the turn to server TTS so
-	* later segments do not keep retrying the failing browser path.
-	*/
 	async prepareAutoSpeechTask(text, signal) {
 		if (this.getAutoSpeechProvider() === "server") return this.prepareServerSpeechTask(text, signal);
 		return async () => {
@@ -2052,17 +2428,13 @@ var CursorBuddyClient = class {
 			}
 			try {
 				await this.browserSpeech.speak(text, signal);
-			} catch (error) {
+			} catch {
 				if (signal?.aborted) return;
 				this.speechProviderForTurn = "server";
 				await (await this.prepareServerSpeechTask(text, signal))();
 			}
 		};
 	}
-	/**
-	* Read the current provider choice for `auto` mode, lazily defaulting to the
-	* browser when supported and the server otherwise.
-	*/
 	getAutoSpeechProvider() {
 		if (this.speechProviderForTurn) return this.speechProviderForTurn;
 		this.speechProviderForTurn = this.browserSpeech.isAvailable() ? "browser" : "server";
@@ -2078,42 +2450,21 @@ var CursorBuddyClient = class {
 		this.options.onError?.(err);
 		this.notify();
 	}
-	/**
-	* Resolve the effective transcription mode for the current client.
-	*/
 	getTranscriptionMode() {
 		return this.options.transcription?.mode ?? "auto";
 	}
-	/**
-	* Resolve the effective speech mode for the current client.
-	*/
 	getSpeechMode() {
 		return this.options.speech?.mode ?? "server";
 	}
-	/**
-	* Decide whether speech should start before the full chat response is ready.
-	*/
 	isSpeechStreamingEnabled() {
 		return this.options.speech?.allowStreaming ?? false;
 	}
-	/**
-	* Decide whether this turn should attempt browser speech recognition.
-	*/
 	shouldAttemptBrowserTranscription() {
 		return this.getTranscriptionMode() !== "server";
 	}
-	/**
-	* Decide whether browser speech recognition is mandatory for this turn.
-	*/
 	isBrowserTranscriptionRequired() {
 		return this.getTranscriptionMode() === "browser";
 	}
-	/**
-	* Start the recorder and browser speech recognition together.
-	*
-	* The recorder always runs so we keep waveform updates and preserve a raw
-	* audio backup for server fallback in `auto` mode.
-	*/
 	async beginListeningSession(signal) {
 		const shouldAttemptBrowser = this.shouldAttemptBrowserTranscription();
 		const isBrowserTranscriptionAvailable = shouldAttemptBrowser && this.liveTranscription.isAvailable();
@@ -2126,10 +2477,6 @@ var CursorBuddyClient = class {
 		if (browserTranscriptionResult.status === "rejected" && this.isBrowserTranscriptionRequired()) throw toError(browserTranscriptionResult.reason, "Browser transcription failed to start");
 		if (browserTranscriptionResult.status === "rejected") this.liveTranscription.dispose();
 	}
-	/**
-	* Stop browser speech recognition and return the best final transcript it
-	* produced for this turn.
-	*/
 	async stopLiveTranscription() {
 		if (!this.shouldAttemptBrowserTranscription() || !this.liveTranscription.isAvailable()) return "";
 		try {
@@ -2139,25 +2486,12 @@ var CursorBuddyClient = class {
 			return "";
 		}
 	}
-	/**
-	* Choose the transcript that should drive the turn.
-	*
-	* Decision tree:
-	* 1. Use the browser transcript when it is available.
-	* 2. In browser-only mode, fail if the browser produced nothing usable.
-	* 3. In auto/server modes, fall back to the recorded audio upload.
-	*/
 	async resolveTranscript(browserTranscript, audioBlob, signal) {
 		const normalizedBrowserTranscript = browserTranscript.trim();
 		if (normalizedBrowserTranscript) return normalizedBrowserTranscript;
 		if (this.getTranscriptionMode() === "browser") throw new Error("Browser transcription did not produce a final transcript");
 		return this.transcribe(audioBlob, signal);
 	}
-	updateResponse(text) {
-		if (this.response === text) return;
-		this.response = text;
-		this.notify();
-	}
 	notify() {
 		this.cachedSnapshot = this.buildSnapshot();
 		this.listeners.forEach((listener) => listener());
@@ -2166,4 +2500,4 @@ var CursorBuddyClient = class {
 //#endregion
 export { $buddyScale as a, $buddyRotation as i, $audioLevel as n, $cursorPosition as o, $buddyPosition as r, $pointingTarget as s, CursorBuddyClient as t };
 
-//# sourceMappingURL=client-CliXcNch.mjs.map
+//# sourceMappingURL=client-D7kFGsuH.mjs.map