@openpalm/ui 0.12.52 → 0.13.0-beta.1

package/build/server/chunks/IconStop-DFbhUtaJ.js

@@ -0,0 +1,1122 @@
+import { p as derived, d as attr, e as attr_class, a9 as stringify, s as escape_html, q as ensure_array_like } from './dev-D85DamNs.js';
+import 'node:module';
+import { v as voiceState, s as speakText, i as stopSpeaking } from './voice-state.svelte-bOoc1Vo0.js';
+import { S as SvelteMap, v as isUserFacingTool, J as subscribeSessionEvents, y as notifyAssistantReply, A as partSnapshotType, l as extractTextDelta, m as extractToolUpdate, k as extractStepUpdate, i as extractPermissionAsk, j as extractQuestionAsk, t as isSessionError, u as isTurnEnd, w as listSessions, s as getSessionMessages, f as createSession, H as startChatMessageTurn, G as sendChatMessage, x as notifyAssistantError, e as abortChatTurn, E as replyChatPermission, F as replyChatQuestion, C as rejectChatQuestion, p as formatDateTime, q as formatRelativeTime, h as endpointsService, B as registerActivationGuard, z as onConnectionActivated } from './format-date-gcou_Av8.js';
+import { S as Spinner } from './IconMic-BbjkE_nG.js';
+
+//#region src/lib/advanced-mode-state.svelte.ts
+var ADVANCED_MODE_STORAGE_KEY = "openpalm.chat.advanced";
+var AdvancedModeService = class {
+	enabled = false;
+	initialized = false;
+	init() {
+		if (typeof window === "undefined" || this.initialized) return;
+		this.enabled = this.#readStoredPreference();
+		this.initialized = true;
+	}
+	setEnabled(value) {
+		this.enabled = value;
+		this.#writeStoredPreference(value);
+	}
+	toggle() {
+		const next = !this.enabled;
+		this.setEnabled(next);
+		return next;
+	}
+	preferredChatPath() {
+		return this.enabled ? "/advanced" : "/chat";
+	}
+	#readStoredPreference() {
+		if (typeof window === "undefined") return false;
+		try {
+			return window.localStorage.getItem(ADVANCED_MODE_STORAGE_KEY) === "1";
+		} catch {
+			return false;
+		}
+	}
+	#writeStoredPreference(value) {
+		if (typeof window === "undefined") return;
+		try {
+			window.localStorage.setItem(ADVANCED_MODE_STORAGE_KEY, value ? "1" : "0");
+		} catch {}
+	}
+};
+var advancedModeService = new AdvancedModeService();
+//#endregion
+//#region src/lib/voice/earcon.ts
+/**
+* Earcon feedback — a short two-tone blip acknowledging a sent message,
+* replacing the old spoken ack phrases. Pure WebAudio: no asset files and
+* no TTS engine required, so the ack works wherever audio output exists.
+*
+* playAck runs inside the send-click user gesture, which also primes the
+* browser's autoplay policy for the TTS audio that follows.
+*
+* Only access browser APIs (window, AudioContext) from playAck — never at
+* module top level — for SSR safety.
+*/
+var ctx = null;
+/** One sine tone with a fast-attack / fast-decay gain envelope. */
+function tone(context, frequency, startAt, durationS) {
+	const osc = context.createOscillator();
+	const gain = context.createGain();
+	osc.type = "sine";
+	osc.frequency.value = frequency;
+	gain.gain.setValueAtTime(0, startAt);
+	gain.gain.linearRampToValueAtTime(.08, startAt + .005);
+	gain.gain.linearRampToValueAtTime(0, startAt + durationS);
+	osc.connect(gain);
+	gain.connect(context.destination);
+	osc.start(startAt);
+	osc.stop(startAt + durationS + .01);
+}
+/**
+* Play the "message sent" ack: two quick ascending sine tones, total under
+* 200ms. All failures are swallowed — the ack is best-effort feedback and
+* must never surface an error or block the send path.
+*/
+function playAck() {
+	if (typeof window === "undefined") return;
+	try {
+		if (!ctx) {
+			const Ctor = window.AudioContext ?? window.webkitAudioContext;
+			if (!Ctor) return;
+			ctx = new Ctor();
+		}
+		if (ctx.state === "suspended") ctx.resume().catch(() => {});
+		const now = ctx.currentTime;
+		tone(ctx, 880, now, .06);
+		tone(ctx, 1320, now + .07, .08);
+	} catch {}
+}
+//#endregion
+//#region src/lib/voice/sentence-stream.ts
+/**
+* Incremental sentence chunker for streamed TTS. As the assistant reply
+* streams in, the chat layer calls `extractSpeakableChunks` with the whole
+* accumulated buffer plus the offset it has already spoken up to; each
+* returned chunk is a complete sentence (or merged run of short sentences)
+* that can be handed to the speak queue immediately, so audio starts within
+* one sentence of the reply instead of after the full turn.
+*
+* Pure and dependency-free like speakable-text.ts — markdown stripping is
+* NOT done here (playOne applies toSpeakableText per chunk).
+*
+* Known limitations (accepted for v1): abbreviations outside the short
+* guard list below and initials cut early because they look like sentence
+* ends; a decimal split across two deltas ("3." then "14") cuts mid-number
+* when whitespace happens to follow the dot. Both cost a short pause in the
+* audio, never lost text.
+*/
+/**
+* Chunks shorter than this merge forward into the following sentence — a
+* one-word utterance per TTS request wastes a round trip and sounds choppy.
+*/
+var MIN_CHUNK_CHARS = 25;
+/**
+* Best-effort abbreviation guard: a period straight after one of these
+* tokens is almost never a sentence end ("Dr. Smith", "e.g. this"), so the
+* chunker skips the cut. Deliberately short — a missing abbreviation only
+* costs an early cut (short audio pause), a false positive only merges two
+* sentences into one chunk. Matched case-insensitively.
+*/
+var ABBREVIATIONS = new Set([
+	"dr",
+	"mr",
+	"mrs",
+	"ms",
+	"prof",
+	"st",
+	"vs",
+	"etc",
+	"e.g",
+	"i.e",
+	"approx"
+]);
+/**
+* Abbreviations matched case-SENSITIVELY: lowercase "no" is an ordinary word
+* that legitimately ends sentences ("the answer is no."), while "No. 5" is
+* the numero abbreviation.
+*/
+var CASED_ABBREVIATIONS = new Set(["No"]);
+/**
+* True when the token immediately before the period at `periodIndex` is a
+* known abbreviation. The token is scanned back over letters and interior
+* periods so multi-part abbreviations ("e.g.", "i.e.") match at their final
+* period (their interior periods are never cut candidates — no whitespace
+* follows them).
+*/
+function endsWithAbbreviation(buffer, periodIndex) {
+	let start = periodIndex;
+	while (start > 0 && /[a-zA-Z.]/.test(buffer[start - 1])) start -= 1;
+	const token = buffer.slice(start, periodIndex);
+	if (!token) return false;
+	return ABBREVIATIONS.has(token.toLowerCase()) || CASED_ABBREVIATIONS.has(token);
+}
+function extractSpeakableChunks(buffer, offset) {
+	const chunks = [];
+	let nextOffset = offset;
+	let chunkStart = offset;
+	let inFence = false;
+	let i = 0;
+	while (i < buffer.length) {
+		if (buffer.startsWith("```", i)) {
+			inFence = !inFence;
+			i += 3;
+			continue;
+		}
+		if (i < offset || inFence) {
+			i += 1;
+			continue;
+		}
+		let cut = -1;
+		const ch = buffer[i];
+		if ((ch === "." || ch === "!" || ch === "?") && i + 1 < buffer.length && /\s/.test(buffer[i + 1])) {
+			if (ch !== "." || !endsWithAbbreviation(buffer, i)) cut = i + 1;
+		} else if (ch === "\n" && buffer[i + 1] === "\n") cut = i + 2;
+		if (cut !== -1) {
+			const candidate = buffer.slice(chunkStart, cut).trim();
+			if (candidate.length >= MIN_CHUNK_CHARS) {
+				chunks.push(candidate);
+				chunkStart = cut;
+				nextOffset = cut;
+			}
+		}
+		i += 1;
+	}
+	return {
+		chunks,
+		nextOffset
+	};
+}
+//#endregion
+//#region src/lib/chat/assistant-error.ts
+/**
+* Map an unknown thrown value to a user-facing string.
+*
+* - 503 / 502 -> "Assistant is not reachable." (+ " Try reconnecting." when
+*   `reconnectHint` is set).
+* - 401 -> "Sign-in required."
+* - otherwise -> the error's own `message`, falling back to `fallback`.
+*/
+function mapAssistantError(e, opts = {}) {
+	const { fallback = "Something went wrong.", reconnectHint = false } = opts;
+	const err = e ?? {};
+	if (err.status === 503 || err.status === 502) return reconnectHint ? "Assistant is not reachable. Try reconnecting." : "Assistant is not reachable.";
+	if (err.status === 401) return "Sign-in required.";
+	return err.message ?? fallback;
+}
+//#endregion
+//#region src/lib/chat/chat-state.svelte.ts
+var STREAM_TURN_TIMEOUT_MS = 15e4;
+function emptyEndpointState() {
+	return {
+		sessions: [],
+		sessionsLoaded: false,
+		sessionsLoading: false,
+		sessionsError: "",
+		activeSessionId: null
+	};
+}
+var ChatService = class {
+	/**
+	* Per-endpoint session cache. Reassigned on every mutation so Svelte 5
+	* picks up the change. Never mutate the existing Map in place.
+	*/
+	byEndpoint = new SvelteMap();
+	/**
+	* Mirrored from `endpointsService.activeId` via `onEndpointChanged()`
+	* so the chat layer doesn't have to import the endpoint store.
+	*/
+	activeEndpointId = "default";
+	/** Messages for the currently rendered session only. */
+	entries = [];
+	entriesLoading = false;
+	sending = false;
+	error = "";
+	/**
+	* Text of the most recent send() call that failed before reaching the
+	* assistant. Cleared at the start of every send() (success or not) so it
+	* only ever reflects the latest failure. Drives the error banner's retry
+	* button.
+	*/
+	lastFailedText = "";
+	pendingAssistantText = "";
+	pendingToolStates = [];
+	pendingPermission = null;
+	pendingQuestion = null;
+	/**
+	* Set true while the SSE event stream is connected. Surfaced by the
+	* SessionPicker as a tiny green/gray dot so the operator can see at a
+	* glance whether live updates are flowing.
+	*/
+	liveConnected = false;
+	/**
+	* Active SSE subscription handle. Reassigned on every endpoint switch.
+	* Plain field (not `$state`) — only the chat service touches it.
+	*/
+	_unsubscribeEvents = null;
+	_pendingTurn = null;
+	#activeSessionId = derived(() => this.byEndpoint.get(this.activeEndpointId)?.activeSessionId ?? null);
+	get activeSessionId() {
+		return this.#activeSessionId();
+	}
+	set activeSessionId($$value) {
+		return this.#activeSessionId($$value);
+	}
+	#toolLog = derived(() => {
+		const seen = {};
+		const out = [];
+		const push = (states, turnKey) => {
+			if (!states) return;
+			for (const tool of states) {
+				if (seen[tool.id]) continue;
+				if (!isUserFacingTool(tool)) continue;
+				seen[tool.id] = true;
+				out.push({
+					...tool,
+					turnKey
+				});
+			}
+		};
+		for (const entry of this.entries) push(entry.toolStates, entry.id);
+		push(this.pendingToolStates, "pending");
+		return out;
+	});
+	get toolLog() {
+		return this.#toolLog();
+	}
+	set toolLog($$value) {
+		return this.#toolLog($$value);
+	}
+	setEndpointState(id, patch) {
+		const next = {
+			...this.byEndpoint.get(id) ?? emptyEndpointState(),
+			...patch
+		};
+		this.byEndpoint = new SvelteMap(this.byEndpoint).set(id, next);
+		return next;
+	}
+	/**
+	* Handle an endpoint switch: load sessions, restore prior or pick
+	* newest, fetch messages. Mid-generation switches are blocked.
+	*/
+	async onEndpointChanged(id) {
+		if (this.sending) {
+			this.error = "Wait for the current reply to finish before switching.";
+			return;
+		}
+		this.activeEndpointId = id;
+		this.entries = [];
+		this.error = "";
+		await this.loadSessions();
+		const state = this.byEndpoint.get(id) ?? emptyEndpointState();
+		const sessions = state.sessions ?? [];
+		const previous = state.activeSessionId;
+		let nextSessionId = null;
+		if (previous && sessions.some((s) => s.id === previous)) nextSessionId = previous;
+		else if (sessions.length > 0) nextSessionId = sessions[0].id;
+		if (nextSessionId !== state.activeSessionId) this.setEndpointState(id, { activeSessionId: nextSessionId });
+		if (nextSessionId) await this.openSession(nextSessionId);
+		this._resubscribeEvents();
+	}
+	/**
+	* Tear down any prior SSE subscription and open a new one. Handlers
+	* dispatch session.created / updated / deleted into the per-endpoint
+	* cache, mirroring out-of-band changes (CLI, other clients).
+	*/
+	_resubscribeEvents() {
+		if (this._unsubscribeEvents) {
+			try {
+				this._unsubscribeEvents();
+			} catch (err) {
+				console.warn("[chat] failed to unsubscribe from previous event stream", err);
+			}
+			this._unsubscribeEvents = null;
+		}
+		this.liveConnected = false;
+		this._unsubscribeEvents = subscribeSessionEvents({
+			onCreated: (id) => {
+				this._onSessionCreated(id);
+			},
+			onUpdated: (id, info) => {
+				this._onSessionUpdated(id, info);
+			},
+			onDeleted: (id) => {
+				this._onSessionDeleted(id);
+			},
+			onEvent: (event) => {
+				this._onLiveEvent(event);
+			},
+			onConnect: () => {
+				this.liveConnected = true;
+			},
+			onDisconnect: () => {
+				this.liveConnected = false;
+				if (this._pendingTurn) this._failPendingTurn(/* @__PURE__ */ new Error("Assistant event stream disconnected."));
+			}
+		});
+	}
+	_toRawEvent(event) {
+		return {
+			type: event.type,
+			properties: event.properties ?? {}
+		};
+	}
+	_upsertPendingToolState(update) {
+		const id = update.callID || `${update.tool}:${this.pendingToolStates.length}`;
+		const next = {
+			id,
+			kind: "tool",
+			tool: update.tool,
+			status: update.status,
+			title: update.title ?? update.tool,
+			detail: update.detail ?? "",
+			output: update.output ?? "",
+			error: update.error ?? "",
+			updatedAt: Date.now()
+		};
+		if (!this.pendingToolStates.find((item) => item.id === id)) {
+			this.pendingToolStates = [...this.pendingToolStates, next];
+			return;
+		}
+		this.pendingToolStates = this.pendingToolStates.map((item) => item.id === id ? {
+			...item,
+			...next
+		} : item);
+	}
+	_upsertPendingStepState(update) {
+		const next = {
+			id: update.id,
+			kind: "step",
+			tool: "step",
+			status: update.status,
+			title: update.title,
+			detail: update.detail ?? "",
+			output: "",
+			error: "",
+			updatedAt: Date.now()
+		};
+		if (!this.pendingToolStates.find((item) => item.id === update.id)) {
+			this.pendingToolStates = [...this.pendingToolStates, next];
+			return;
+		}
+		this.pendingToolStates = this.pendingToolStates.map((item) => item.id === update.id ? {
+			...item,
+			...next
+		} : item);
+	}
+	_resetPendingRenderState() {
+		this.pendingAssistantText = "";
+		this.pendingToolStates = [];
+		this.pendingPermission = null;
+		this.pendingQuestion = null;
+	}
+	_appendAssistantReply(text, toolStates) {
+		const assistantEntry = {
+			id: crypto.randomUUID(),
+			role: "assistant",
+			text,
+			timestamp: Date.now(),
+			...toolStates && toolStates.length > 0 ? { toolStates: [...toolStates] } : {}
+		};
+		this.entries = [...this.entries, assistantEntry];
+	}
+	_clearPendingTurn() {
+		const pending = this._pendingTurn;
+		if (!pending) return null;
+		clearTimeout(pending.timeout);
+		this._pendingTurn = null;
+		return pending;
+	}
+	/**
+	* Speak `text` via auto-TTS iff the browser supports it and the operator
+	* has enabled auto-speak. Single guard for spoken replies so the
+	* `ttsSupported && ttsAutoEnabled` check lives in one place.
+	*/
+	maybeSpeak(text) {
+		if (!voiceState.ttsSupported || !voiceState.ttsAutoEnabled) return;
+		speakText(text);
+	}
+	/**
+	* Finalize a completed turn: append the assistant reply (with any captured
+	* tool activity), clear the pending render state, bump the session to the
+	* top, auto-speak the reply, and fire the reply notification. Shared by the
+	* streaming (`_finishPendingTurn`) and non-streaming (`send`) paths so the
+	* sequence — including the answered-question note preservation — exists once.
+	*/
+	finalizeTurn(args) {
+		const raw = args.replyText ?? this.pendingAssistantText;
+		const text = raw.trim() || "(no response)";
+		if (this.pendingQuestion?.status === "answered" && this.pendingQuestion.message) {
+			const questionNote = {
+				id: crypto.randomUUID(),
+				type: "note",
+				label: "Question answered",
+				text: this.pendingQuestion.message,
+				timestamp: Date.now()
+			};
+			this.entries = [...this.entries, questionNote];
+		}
+		const capturedToolStates = this.pendingToolStates.length > 0 ? [...this.pendingToolStates] : void 0;
+		this._appendAssistantReply(text, capturedToolStates);
+		this._resetPendingRenderState();
+		this._bumpSession(args.sessionId);
+		if (text !== "(no response)" && !args.suppressSpeech) {
+			const remainder = raw.slice(args.spokenOffset ?? 0).trim();
+			if (remainder) this.maybeSpeak(remainder);
+		}
+		notifyAssistantReply(text === "(no response)" ? "" : text);
+	}
+	_finishPendingTurn(replyText) {
+		const pending = this._clearPendingTurn();
+		if (!pending) return;
+		this.finalizeTurn({
+			sessionId: pending.sessionId,
+			replyText,
+			spokenOffset: pending.spokenOffset
+		});
+		pending.resolve();
+	}
+	_failPendingTurn(error) {
+		const pending = this._clearPendingTurn();
+		if (!pending) return;
+		this._resetPendingRenderState();
+		pending.reject(error);
+	}
+	_bumpSession(sessionId) {
+		const endpointId = this.activeEndpointId;
+		const prev = this.byEndpoint.get(endpointId);
+		if (!prev) return;
+		const now = Date.now();
+		const existing = prev.sessions.find((s) => s.id === sessionId);
+		const updated = existing ? {
+			...existing,
+			updatedAt: now
+		} : {
+			id: sessionId,
+			title: "",
+			createdAt: now,
+			updatedAt: now
+		};
+		const rest = prev.sessions.filter((s) => s.id !== sessionId);
+		this.setEndpointState(endpointId, { sessions: [updated, ...rest] });
+	}
+	_onLiveEvent(event) {
+		const pending = this._pendingTurn;
+		if (!pending) return;
+		const raw = this._toRawEvent(event);
+		if (pending.endpointId !== this.activeEndpointId) return;
+		const snapshot = partSnapshotType(raw);
+		if (snapshot?.type === "reasoning") pending.reasoningPartIds.add(snapshot.partID);
+		const textDelta = extractTextDelta(raw, pending.sessionId, pending.reasoningPartIds);
+		if (textDelta) {
+			this.pendingAssistantText += textDelta;
+			if (voiceState.ttsSupported && voiceState.ttsAutoEnabled) {
+				const { chunks, nextOffset } = extractSpeakableChunks(this.pendingAssistantText, pending.spokenOffset);
+				for (const chunk of chunks) speakText(chunk);
+				pending.spokenOffset = nextOffset;
+			}
+		}
+		const toolUpdate = extractToolUpdate(raw, pending.sessionId);
+		if (toolUpdate) this._upsertPendingToolState(toolUpdate);
+		const stepUpdate = extractStepUpdate(raw, pending.sessionId);
+		if (stepUpdate) this._upsertPendingStepState(stepUpdate);
+		const permissionAsk = extractPermissionAsk(raw, pending.sessionId);
+		if (permissionAsk) this.pendingPermission = {
+			...permissionAsk,
+			status: "pending",
+			decision: "",
+			message: ""
+		};
+		const questionAsk = extractQuestionAsk(raw, pending.sessionId);
+		if (questionAsk) this.pendingQuestion = {
+			...questionAsk,
+			status: "pending",
+			answers: questionAsk.questions.map(() => ""),
+			message: ""
+		};
+		if (isSessionError(raw, pending.sessionId)) {
+			this._failPendingTurn(/* @__PURE__ */ new Error("Assistant session ended unexpectedly."));
+			return;
+		}
+		if (isTurnEnd(raw, pending.sessionId)) this._finishPendingTurn();
+	}
+	/**
+	* A session was created out-of-band — prepend to the active endpoint's
+	* list if not already known. Do not auto-switch to it: the user owns
+	* navigation.
+	*/
+	_onSessionCreated(sessionId) {
+		const endpointId = this.activeEndpointId;
+		const prev = this.byEndpoint.get(endpointId) ?? emptyEndpointState();
+		if (prev.sessions.some((s) => s.id === sessionId)) return;
+		const now = Date.now();
+		const summary = {
+			id: sessionId,
+			title: "",
+			createdAt: now,
+			updatedAt: now
+		};
+		this.setEndpointState(endpointId, {
+			sessions: [summary, ...prev.sessions],
+			sessionsLoaded: true
+		});
+	}
+	/**
+	* A session was touched out-of-band — patch its updatedAt (and title if
+	* the event carries one) and re-sort. Do NOT refetch messages: if the
+	* user is viewing this session, leave the in-memory entries alone for
+	* v1. A follow-up phase can reconcile message deltas via the assistant
+	* event stream.
+	*/
+	_onSessionUpdated(sessionId, info) {
+		const endpointId = this.activeEndpointId;
+		const prev = this.byEndpoint.get(endpointId);
+		if (!prev) return;
+		const idx = prev.sessions.findIndex((s) => s.id === sessionId);
+		if (idx === -1) {
+			this._onSessionCreated(sessionId);
+			return;
+		}
+		const existing = prev.sessions[idx];
+		const sessions = [{
+			...existing,
+			title: info?.title ?? existing.title,
+			updatedAt: info?.updatedAt ?? Date.now()
+		}, ...prev.sessions.filter((s) => s.id !== sessionId)];
+		sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+		this.setEndpointState(endpointId, { sessions });
+	}
+	/**
+	* A session was deleted out-of-band. Remove it from the list; if it was
+	* the active session, fall back to the newest remaining session (or
+	* null) and reload its messages.
+	*/
+	async _onSessionDeleted(sessionId) {
+		const endpointId = this.activeEndpointId;
+		const prev = this.byEndpoint.get(endpointId);
+		if (!prev) return;
+		if (!prev.sessions.some((s) => s.id === sessionId)) return;
+		const sessions = prev.sessions.filter((s) => s.id !== sessionId);
+		const wasActive = prev.activeSessionId === sessionId;
+		const nextActive = wasActive ? sessions[0]?.id ?? null : prev.activeSessionId;
+		this.setEndpointState(endpointId, {
+			sessions,
+			activeSessionId: nextActive
+		});
+		if (wasActive) {
+			this.entries = [];
+			if (nextActive) await this.openSession(nextActive);
+		}
+	}
+	/** Mark sessions as stale so the next onEndpointChanged call re-fetches. */
+	invalidateSessions(id) {
+		this.setEndpointState(id, { sessionsLoaded: false });
+	}
+	/**
+	* Sync the active session cursor without loading messages. Used by the
+	* advanced-mode page to keep the chat layer's cursor in step with what is
+	* displayed in the embedded OpenCode iframe.
+	*/
+	setActiveSessionId(sessionId) {
+		this.setEndpointState(this.activeEndpointId, { activeSessionId: sessionId });
+	}
+	/** Fetch the session list for the active endpoint. */
+	async loadSessions() {
+		const id = this.activeEndpointId;
+		this.setEndpointState(id, {
+			sessionsLoading: true,
+			sessionsError: ""
+		});
+		try {
+			const sessions = await listSessions();
+			this.setEndpointState(id, {
+				sessions,
+				sessionsLoaded: true,
+				sessionsLoading: false,
+				sessionsError: ""
+			});
+		} catch (e) {
+			this.setEndpointState(id, {
+				sessionsLoading: false,
+				sessionsError: mapAssistantError(e, { fallback: "Failed to load sessions." })
+			});
+		}
+	}
+	/** Select a session and render its messages. */
+	async openSession(sessionId) {
+		if (this.sending) {
+			this.error = "Wait for the current reply to finish before switching.";
+			return;
+		}
+		const endpointId = this.activeEndpointId;
+		this.setEndpointState(endpointId, { activeSessionId: sessionId });
+		this.entries = [];
+		this._resetPendingRenderState();
+		this.entriesLoading = true;
+		this.error = "";
+		try {
+			const messages = await getSessionMessages(sessionId);
+			if (this.activeEndpointId === endpointId && this.byEndpoint.get(endpointId)?.activeSessionId === sessionId) this.entries = messages;
+		} catch (e) {
+			this.error = mapAssistantError(e, {
+				fallback: "Failed to load messages.",
+				reconnectHint: true
+			});
+		} finally {
+			this.entriesLoading = false;
+		}
+	}
+	/** Create a new session on the active endpoint and select it. */
+	async startNewSession() {
+		if (this.sending) {
+			this.error = "Wait for the current reply to finish before switching.";
+			return null;
+		}
+		const endpointId = this.activeEndpointId;
+		this.error = "";
+		try {
+			const { id } = await createSession();
+			const now = Date.now();
+			const summary = {
+				id,
+				title: "",
+				createdAt: now,
+				updatedAt: now
+			};
+			const prev = this.byEndpoint.get(endpointId) ?? emptyEndpointState();
+			this.setEndpointState(endpointId, {
+				sessions: [summary, ...prev.sessions.filter((s) => s.id !== id)],
+				sessionsLoaded: true,
+				activeSessionId: id
+			});
+			this.entries = [];
+			this._resetPendingRenderState();
+			return id;
+		} catch (e) {
+			const err = e;
+			this.error = `Failed to start session: ${err.message ?? "unknown error"}`;
+			return null;
+		}
+	}
+	/**
+	* Send a message in the active session. If none is active, create one
+	* first (matches the "zero sessions" empty-state flow).
+	*/
+	async send(text) {
+		const trimmed = text.trim();
+		if (!trimmed) return;
+		this.lastFailedText = "";
+		if (this.pendingQuestion && this.pendingQuestion.questions.length === 1 && this.sending) {
+			await this.answerQuestion(trimmed);
+			return;
+		}
+		if (this.pendingQuestion && this.sending) {
+			this.pendingQuestion = {
+				...this.pendingQuestion,
+				status: "error",
+				message: "This question has multiple parts and must be answered with the provided controls."
+			};
+			return;
+		}
+		if (this.sending) return;
+		let sessionId = this.activeSessionId;
+		if (!sessionId) {
+			sessionId = await this.startNewSession();
+			if (!sessionId) return;
+		}
+		const userEntry = {
+			id: crypto.randomUUID(),
+			role: "user",
+			text: trimmed,
+			timestamp: Date.now()
+		};
+		this.entries = [...this.entries, userEntry];
+		this._resetPendingRenderState();
+		this.error = "";
+		this.sending = true;
+		if (voiceState.ttsAutoEnabled) playAck();
+		try {
+			if (this._unsubscribeEvents && this.liveConnected) await new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					this._failPendingTurn(/* @__PURE__ */ new Error("Timed out waiting for the assistant response."));
+				}, STREAM_TURN_TIMEOUT_MS);
+				this._pendingTurn = {
+					endpointId: this.activeEndpointId,
+					sessionId,
+					spokenOffset: 0,
+					reasoningPartIds: /* @__PURE__ */ new Set(),
+					resolve,
+					reject,
+					timeout
+				};
+				startChatMessageTurn(sessionId, trimmed).catch((error) => {
+					this._failPendingTurn(error instanceof Error ? error : new Error(String(error)));
+				});
+			});
+			else {
+				const replyText = (await sendChatMessage(sessionId, trimmed)).parts.filter((p) => p.type === "text" && p.text).map((p) => p.text ?? "").join("");
+				this.finalizeTurn({
+					sessionId,
+					replyText
+				});
+			}
+		} catch (e) {
+			this._resetPendingRenderState();
+			this.entries = this.entries.filter((entry) => entry.id !== userEntry.id);
+			this.lastFailedText = trimmed;
+			const status = e?.status;
+			if (status === 503 || status === 502) this.setEndpointState(this.activeEndpointId, { activeSessionId: null });
+			this.error = mapAssistantError(e, {
+				fallback: "Message failed.",
+				reconnectHint: true
+			});
+			notifyAssistantError();
+		} finally {
+			this.sending = false;
+		}
+	}
+	/**
+	* Conversation-mode entry point — barge-in aware. The composer's submit
+	* path keeps calling send() directly (no-op while sending unless a
+	* question is pending); a spoken utterance must never be silently dropped
+	* by that guard. If a reply is mid-generation, stop it first — stopTurn()
+	* halts TTS and finalizes the partial text unspoken — then send the
+	* utterance. When a question is pending, send() already routes the text
+	* as the answer, so no stop is needed.
+	*/
+	async sendUtterance(text) {
+		const trimmed = text.trim();
+		if (!trimmed) return;
+		if (this.sending && !this.pendingQuestion) {
+			await this.stopTurn();
+			for (let i = 0; this.sending && i < 20; i++) await new Promise((resolve) => setTimeout(resolve, 10));
+			if (this.sending) {
+				this.lastFailedText = trimmed;
+				this.error = "The assistant is still finishing the previous reply — use retry to send your message.";
+				return;
+			}
+		}
+		await this.send(trimmed);
+	}
+	/**
+	* Stop the in-flight turn. No-op if nothing is sending. The upstream abort
+	* is best-effort — OpenCode may have already finished or the endpoint may
+	* be unreachable — the turn is always finished locally regardless so the
+	* UI never gets stuck waiting on `sending`.
+	*
+	* Clearing `_pendingTurn` before resolving is what makes a late SSE
+	* turn-end for the aborted turn a no-op: `_onLiveEvent` bails out as soon
+	* as `_pendingTurn` is null.
+	*/
+	async stopTurn() {
+		if (!this.sending) return;
+		const sessionId = this.activeSessionId;
+		if (sessionId) try {
+			await abortChatTurn(sessionId);
+		} catch {}
+		stopSpeaking();
+		const pending = this._clearPendingTurn();
+		if (this.pendingAssistantText) this.finalizeTurn({
+			sessionId: pending?.sessionId ?? sessionId ?? "",
+			suppressSpeech: true
+		});
+		else {
+			this._resetPendingRenderState();
+			const stoppedNote = {
+				id: crypto.randomUUID(),
+				type: "note",
+				label: "Stopped",
+				text: "Stopped.",
+				timestamp: Date.now()
+			};
+			this.entries = [...this.entries, stoppedNote];
+		}
+		pending?.resolve();
+	}
+	async answerPermission(reply) {
+		if (!this.pendingPermission || this.pendingPermission.status === "submitting") return;
+		const current = this.pendingPermission;
+		this.pendingPermission = {
+			...current,
+			status: "submitting",
+			decision: reply,
+			message: ""
+		};
+		try {
+			await replyChatPermission(current.requestID, reply);
+			this.pendingPermission = {
+				...current,
+				status: "resolved",
+				decision: reply,
+				message: reply === "once" ? `Allowed ${current.permission} once. Waiting for the assistant to continue...` : reply === "always" ? `Always allowed future matching ${current.permission} requests.` : `Denied ${current.permission}. Waiting for the assistant to continue...`
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Failed to record permission reply.";
+			this.pendingPermission = {
+				...current,
+				status: "error",
+				decision: reply,
+				message
+			};
+		}
+	}
+	setQuestionAnswer(index, answer) {
+		if (!this.pendingQuestion) return;
+		if (index < 0 || index >= this.pendingQuestion.questions.length) return;
+		const answers = [...this.pendingQuestion.answers];
+		answers[index] = answer;
+		this.pendingQuestion = {
+			...this.pendingQuestion,
+			answers,
+			message: ""
+		};
+	}
+	async answerQuestion(answer) {
+		if (!this.pendingQuestion || this.pendingQuestion.status === "submitting") return;
+		const current = this.pendingQuestion;
+		const answers = current.questions.length === 1 && typeof answer === "string" ? [answer.trim()] : current.answers.map((item) => item.trim());
+		if (answers.some((item) => !item)) {
+			this.pendingQuestion = {
+				...current,
+				status: "error",
+				message: "Answer every question before submitting."
+			};
+			return;
+		}
+		this.pendingQuestion = {
+			...current,
+			status: "submitting",
+			answers,
+			message: ""
+		};
+		try {
+			await replyChatQuestion(current.requestID, answers.map((item) => [item]));
+			this.pendingQuestion = {
+				...current,
+				status: "answered",
+				answers,
+				message: "Answer sent."
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Failed to send answer.";
+			this.pendingQuestion = {
+				...current,
+				status: "error",
+				answers,
+				message
+			};
+		}
+	}
+	async rejectQuestion() {
+		if (!this.pendingQuestion || this.pendingQuestion.status === "submitting") return;
+		const current = this.pendingQuestion;
+		this.pendingQuestion = {
+			...current,
+			status: "submitting",
+			message: ""
+		};
+		try {
+			await rejectChatQuestion(current.requestID);
+			this.pendingQuestion = {
+				...current,
+				status: "rejected",
+				message: "Question declined."
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Failed to reject question.";
+			this.pendingQuestion = {
+				...current,
+				status: "error",
+				message
+			};
+		}
+	}
+	reset() {
+		stopSpeaking();
+		this._clearPendingTurn();
+		this.entries = [];
+		this.error = "";
+		this.lastFailedText = "";
+		this._resetPendingRenderState();
+		this.byEndpoint = new SvelteMap();
+		if (this._unsubscribeEvents) {
+			try {
+				this._unsubscribeEvents();
+			} catch (err) {
+				console.warn("[chat] failed to unsubscribe from event stream during reset", err);
+			}
+			this._unsubscribeEvents = null;
+		}
+		this.liveConnected = false;
+	}
+};
+var chat = new ChatService();
+registerActivationGuard(() => chat.sending ? "Wait for the current reply to finish before switching." : null);
+onConnectionActivated((id) => chat.onEndpointChanged(id));
+//#endregion
+//#region src/lib/chat/navigation.ts
+function encodeWorkspacePath(path) {
+	const bytes = new TextEncoder().encode(path);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/=+$/g, "");
+}
+function currentChatSessionId() {
+	return chat.activeSessionId;
+}
+function buildAdvancedPath(sessionId) {
+	const params = new URLSearchParams();
+	if (sessionId) params.set("session", sessionId);
+	const query = params.toString();
+	return query ? `/advanced?${query}` : "/advanced";
+}
+function buildChatPath(sessionId, options) {
+	const params = new URLSearchParams();
+	if (sessionId) params.set("session", sessionId);
+	const query = params.toString();
+	return query ? `/chat?${query}` : "/chat";
+}
+/**
+* Build the OpenCode web-UI deep link to a specific session. OpenCode scopes its
+* session list by directory, so the route is `/<base64(directory)>/session/<id>`
+* and the `directory` MUST be the workspace the session actually lives in —
+* resolve it from the session record (`session.directory`), never hardcode it.
+* Without a session id or directory, fall back to the base URL (OpenCode opens
+* its default view) so we never deep-link a session the embedded app can't find.
+*/
+function buildAdvancedIframeUrl(baseUrl, sessionId, directory) {
+	if (!sessionId || !directory) return baseUrl;
+	return `${baseUrl.replace(/\/$/, "")}/${encodeWorkspacePath(directory)}/session/${encodeURIComponent(sessionId)}`;
+}
+//#endregion
+//#region ../ui-kit/src/lib/components/icons/IconAdvanced.svelte
+function IconAdvanced($$renderer, $$props) {
+	let { size = 20, class: className = "" } = $$props;
+	$$renderer.push(`<svg aria-hidden="true"${attr("width", size)}${attr("height", size)} viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"${attr_class(`s-icon ${stringify(className)}`)}><path d="M4 17l4-4-4-4"></path><path d="M12 17h8"></path></svg>`);
+}
+//#endregion
+//#region src/lib/assistant-endpoint.ts
+function isLocalAssistantUrl(url) {
+	if (!url) return true;
+	try {
+		const host = new URL(url).hostname;
+		return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "host.docker.internal";
+	} catch {
+		return true;
+	}
+}
+//#endregion
+//#region src/lib/session-title.ts
+var DEFAULT_TITLE_RE = /^New session - (\d{4}-\d{2}-\d{2}T[0-9:.]+Z?)$/;
+/** Resolve a session's display title. */
+function resolveSessionTitle(title) {
+	const trimmed = (title ?? "").trim();
+	if (!trimmed) return "Untitled session";
+	const match = DEFAULT_TITLE_RE.exec(trimmed);
+	if (match) {
+		const ts = Date.parse(match[1]);
+		if (!Number.isNaN(ts)) return formatDateTime(ts);
+	}
+	return trimmed;
+}
+//#endregion
+//#region src/lib/components/chat/SessionTitle.svelte
+function SessionTitle($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { title } = $$props;
+		const display = derived(() => resolveSessionTitle(title));
+		$$renderer.push(`<!---->${escape_html(display())}`);
+	});
+}
+//#endregion
+//#region src/lib/components/chat/SessionList.svelte
+function SessionList($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		/** Called after a session is opened or started (e.g. to close the drawer). */
+		/** Hide the internal new-session button (use when the parent already provides one). */
+		let { onChosen, hideNewBtn = false } = $$props;
+		const SESSION_LIST_CAP = 50;
+		const active = derived(() => endpointsService.active);
+		const endpointState = derived(() => active() ? chat.byEndpoint.get(active().id) ?? null : null);
+		const sessions = derived(() => endpointState()?.sessions ?? []);
+		const loading = derived(() => endpointState()?.sessionsLoading ?? false);
+		const error = derived(() => endpointState()?.sessionsError ?? "");
+		const activeSessionId = derived(() => chat.activeSessionId);
+		const visibleSessions = derived(() => sessions().slice(0, SESSION_LIST_CAP));
+		const overflowCount = derived(() => Math.max(0, sessions().length - SESSION_LIST_CAP));
+		$$renderer.push(`<div class="session-body svelte-1o6rxhb">`);
+		if (chat.sending) {
+			$$renderer.push("<!--[0-->");
+			$$renderer.push(`<div class="notice svelte-1o6rxhb">Wait for the current reply to finish before switching.</div>`);
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]--> `);
+		if (!endpointState() || loading()) {
+			$$renderer.push("<!--[0-->");
+			$$renderer.push(`<div class="empty svelte-1o6rxhb">`);
+			Spinner($$renderer, { size: 12 });
+			$$renderer.push(`<!----><span>Loading sessions…</span></div>`);
+		} else if (error()) {
+			$$renderer.push("<!--[1-->");
+			$$renderer.push(`<div class="list-error svelte-1o6rxhb"><span class="svelte-1o6rxhb">${escape_html(error())}</span> <button type="button" class="retry-btn svelte-1o6rxhb">Retry</button></div>`);
+		} else if (sessions().length === 0) {
+			$$renderer.push("<!--[2-->");
+			$$renderer.push(`<div class="empty svelte-1o6rxhb">No sessions yet. Start the first one.</div>`);
+		} else {
+			$$renderer.push("<!--[-1-->");
+			$$renderer.push(`<div class="session-list svelte-1o6rxhb" role="group" aria-label="Sessions"><!--[-->`);
+			const each_array = ensure_array_like(visibleSessions());
+			for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
+				let s = each_array[$$index];
+				$$renderer.push(`<button type="button"${attr_class("list-item session-item svelte-1o6rxhb", void 0, { "active": s.id === activeSessionId() })}${attr("aria-current", s.id === activeSessionId() ? "true" : void 0)}${attr("disabled", chat.sending, true)}${attr("title", formatDateTime(s.updatedAt))}><span class="item-text svelte-1o6rxhb"><span class="item-label svelte-1o6rxhb">`);
+				SessionTitle($$renderer, { title: s.title });
+				$$renderer.push(`<!---->`);
+				if (s.id === activeSessionId()) {
+					$$renderer.push("<!--[0-->");
+					$$renderer.push(`<span class="sr-only svelte-1o6rxhb">(current)</span>`);
+				} else $$renderer.push("<!--[-1-->");
+				$$renderer.push(`<!--]--></span> <span class="item-meta svelte-1o6rxhb">${escape_html(formatRelativeTime(s.updatedAt))}</span></span></button>`);
+			}
+			$$renderer.push(`<!--]--></div> `);
+			if (overflowCount() > 0) {
+				$$renderer.push("<!--[0-->");
+				$$renderer.push(`<button type="button" class="show-all svelte-1o6rxhb">Show all (${escape_html(overflowCount())} more)</button>`);
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]-->`);
+		}
+		$$renderer.push(`<!--]--> `);
+		if (!hideNewBtn) {
+			$$renderer.push("<!--[0-->");
+			$$renderer.push(`<div class="divider svelte-1o6rxhb"></div> <button type="button" class="list-item new-btn svelte-1o6rxhb"${attr("disabled", chat.sending, true)}><span class="check svelte-1o6rxhb" aria-hidden="true">+</span> <span class="item-text svelte-1o6rxhb"><span class="item-label svelte-1o6rxhb">New session</span></span></button>`);
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]--></div>`);
+	});
+}
+//#endregion
+//#region ../ui-kit/src/lib/components/icons/IconConversations.svelte
+function IconConversations($$renderer, $$props) {
+	let { size = 20, class: className = "" } = $$props;
+	$$renderer.push(`<svg aria-hidden="true"${attr("width", size)}${attr("height", size)} viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"${attr_class(`s-icon ${stringify(className)}`)}><path d="M4 7h16" opacity="0.9"></path><path d="M4 12h11" opacity="0.65"></path><path d="M4 17h7.5" opacity="0.5"></path></svg>`);
+}
+//#endregion
+//#region ../ui-kit/src/lib/components/icons/IconSoundOff.svelte
+function IconSoundOff($$renderer, $$props) {
+	let { size = 20, class: className = "" } = $$props;
+	$$renderer.push(`<svg aria-hidden="true"${attr("width", size)}${attr("height", size)} viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"${attr_class(`s-icon ${stringify(className)}`)}><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"></polygon><line x1="23" y1="9" x2="17" y2="15"></line><line x1="17" y1="9" x2="23" y2="15"></line></svg>`);
+}
+//#endregion
+//#region ../ui-kit/src/lib/components/icons/IconSoundOn.svelte
+function IconSoundOn($$renderer, $$props) {
+	let { size = 20, class: className = "" } = $$props;
+	$$renderer.push(`<svg aria-hidden="true"${attr("width", size)}${attr("height", size)} viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"${attr_class(`s-icon ${stringify(className)}`)}><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"></polygon><path d="M15.54 8.46a5 5 0 0 1 0 7.07"></path><path d="M19.07 4.93a10 10 0 0 1 0 14.14"></path></svg>`);
+}
+//#endregion
+//#region ../ui-kit/src/lib/components/icons/IconStop.svelte
+function IconStop($$renderer, $$props) {
+	let { size = 20, class: className = "" } = $$props;
+	$$renderer.push(`<svg aria-hidden="true"${attr("width", size)}${attr("height", size)} viewBox="0 0 24 24"${attr_class(`s-icon ${stringify(className)}`)}><rect fill="currentColor" stroke="none" x="7" y="7" width="10" height="10" rx="1.4"></rect></svg>`);
+}
+
+export { IconAdvanced as I, SessionList as S, IconConversations as a, IconSoundOff as b, IconSoundOn as c, IconStop as d, advancedModeService as e, buildAdvancedIframeUrl as f, buildAdvancedPath as g, buildChatPath as h, chat as i, currentChatSessionId as j, isLocalAssistantUrl as k, resolveSessionTitle as r };
+//# sourceMappingURL=IconStop-DFbhUtaJ.js.map