@antelopejs/dms-ai 0.1.5 → 0.2.0

package/frontend-vue/app/chat/composables/useConversationId.ts

@@ -9,7 +9,7 @@ function readPersisted(): string | null {
 	}
 }
 
-function persist(id: string): void {
+export function persistConversationId(id: string): void {
 	try {
 		window.localStorage.setItem(STORAGE_CONVERSATION_ID_KEY, id);
 	} catch {
@@ -21,14 +21,6 @@ export function resolveConversationId(): string {
 	const existing = readPersisted();
 	if (existing !== null && existing.length > 0) return existing;
 	const next = newUuid();
-	persist(next);
+	persistConversationId(next);
 	return next;
 }
-
-export function persistConversationId(id: string): void {
-	persist(id);
-}
-
-export function newConversationId(): string {
-	return newUuid();
-}

package/frontend-vue/app/chat/composables/useConversationList.ts

@@ -1,4 +1,11 @@
-import { type Ref, ref } from "vue";
+import {
+	computed,
+	type ComputedRef,
+	onBeforeUnmount,
+	type Ref,
+	ref,
+} from "vue";
+import { DELETE_UNDO_MS } from "../constants/conversation";
 import {
 	CLIENT_MESSAGE_TYPES,
 	SERVER_EVENT_TYPES,
@@ -6,51 +13,100 @@ import {
 import type { ConversationSummary } from "../types/conversation";
 
 export interface UseConversationListOptions {
-	send: (msg: object) => void;
+	send: (msg: object) => boolean;
 	onMessage: (handler: (msg: unknown) => void) => () => void;
 }
 
+/** A deletion still within its undo window. */
+interface PendingDelete {
+	id: string;
+	title: string;
+}
+
 export interface UseConversationListResult {
-	conversations: Ref<ConversationSummary[]>;
+	/** The sidecar's list, without the chats being deleted. */
+	conversations: ComputedRef<ConversationSummary[]>;
 	refresh: () => void;
-	remove: (id: string) => void;
+	/** Hides the chat now and deletes it once the undo window is over. */
+	remove: (conversation: ConversationSummary) => void;
+	undoRemove: (id: string) => void;
+	/** The latest deletion that can still be undone. */
+	pendingDelete: Ref<PendingDelete | null>;
 }
 
 interface ConversationListEvent {
 	type: typeof SERVER_EVENT_TYPES.CONVERSATION_LIST;
-	conversations: ConversationSummary[];
+	conversations?: ConversationSummary[];
 }
 
-function isObject(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object";
-}
-
-function getEventType(msg: unknown): string | null {
-	if (!isObject(msg)) return null;
-	const t = msg.type;
-	return typeof t === "string" ? t : null;
+function isListEvent(msg: unknown): msg is ConversationListEvent {
+	if (msg === null || typeof msg !== "object") return false;
+	return Reflect.get(msg, "type") === SERVER_EVENT_TYPES.CONVERSATION_LIST;
 }
 
+/**
+ * The conversation history. A deletion waits out its undo window on this side:
+ * the sidecar only hears of it once the window is over, or at once when the
+ * chat goes away.
+ */
 export function useConversationList(
 	options: UseConversationListOptions,
 ): UseConversationListResult {
-	const conversations = ref<ConversationSummary[]>([]);
+	const all = ref<ConversationSummary[]>([]);
+	const timers = new Map<string, ReturnType<typeof setTimeout>>();
+	const hidden = ref<ReadonlySet<string>>(new Set());
+	const pendingDelete = ref<PendingDelete | null>(null);
 
-	options.onMessage((msg: unknown): void => {
-		if (getEventType(msg) !== SERVER_EVENT_TYPES.CONVERSATION_LIST) return;
-		conversations.value = (msg as ConversationListEvent).conversations;
+	options.onMessage((msg) => {
+		if (isListEvent(msg)) all.value = msg.conversations ?? [];
 	});
 
-	const refresh = (): void => {
-		options.send({ type: CLIENT_MESSAGE_TYPES.LIST_CONVERSATIONS });
+	const setHidden = (id: string, isHidden: boolean): void => {
+		const next = new Set(hidden.value);
+		if (isHidden) next.add(id);
+		else next.delete(id);
+		hidden.value = next;
 	};
 
-	const remove = (id: string): void => {
+	const commit = (id: string): void => {
+		const timer = timers.get(id);
+		if (timer !== undefined) clearTimeout(timer);
+		timers.delete(id);
 		options.send({
 			type: CLIENT_MESSAGE_TYPES.DELETE_CONVERSATION,
 			conversationId: id,
 		});
+		if (pendingDelete.value?.id === id) pendingDelete.value = null;
 	};
 
-	return { conversations, refresh, remove };
+	const remove = (conversation: ConversationSummary): void => {
+		setHidden(conversation.id, true);
+		pendingDelete.value = { id: conversation.id, title: conversation.title };
+		timers.set(
+			conversation.id,
+			setTimeout(() => commit(conversation.id), DELETE_UNDO_MS),
+		);
+	};
+
+	const undoRemove = (id: string): void => {
+		const timer = timers.get(id);
+		if (timer !== undefined) clearTimeout(timer);
+		timers.delete(id);
+		setHidden(id, false);
+		if (pendingDelete.value?.id === id) pendingDelete.value = null;
+	};
+
+	onBeforeUnmount(() => [...timers.keys()].forEach(commit));
+
+	return {
+		conversations: computed(() =>
+			all.value.filter((item) => !hidden.value.has(item.id)),
+		),
+		refresh: () => {
+			options.send({ type: CLIENT_MESSAGE_TYPES.LIST_CONVERSATIONS });
+		},
+		remove,
+		undoRemove,
+		pendingDelete,
+	};
 }

package/frontend-vue/app/chat/composables/useConversationMode.ts

@@ -0,0 +1,73 @@
+import { computed, type ComputedRef, type Ref } from "vue";
+import { CLIENT_MESSAGE_TYPES } from "../constants/protocol";
+import type {
+	ApprovalMode,
+	ConversationModeState,
+	FullAutoDuration,
+	Scope,
+} from "../types/protocol";
+import type { AppSettings } from "../types/settings";
+
+export interface UseConversationModeOptions {
+	activeId: Ref<string>;
+	/** What the sidecar last said of this chat's mode; null before it did. */
+	mode: Ref<ConversationModeState | null>;
+	settings: Ref<AppSettings>;
+	send: (msg: object) => boolean;
+}
+
+export interface UseConversationModeResult {
+	/** The chat's mode, its scope and Full auto, defaults until the sidecar says. */
+	current: ComputedRef<ConversationModeState>;
+	setMode: (mode: ApprovalMode) => void;
+	setScope: (scope: Scope) => void;
+	startFullAuto: (duration: FullAutoDuration) => void;
+	stopFullAuto: () => void;
+}
+
+function effectiveScope(scope: Scope, builderAvailable: boolean): Scope {
+	return builderAvailable ? scope : "vibe";
+}
+
+/**
+ * The active chat's approval mode, scope and Full auto: what the sidecar says,
+ * or the defaults for new chats from the settings until it has. Changes apply
+ * at once here and are sent for the sidecar to confirm.
+ */
+export function useConversationMode(
+	options: UseConversationModeOptions,
+): UseConversationModeResult {
+	const current = computed<ConversationModeState>(() => {
+		const { settings, mode } = options;
+		const base: ConversationModeState = mode.value ?? {
+			mode: settings.value.mode,
+			generationMode: settings.value.generationMode,
+			fullAuto: null,
+		};
+		return {
+			...base,
+			generationMode: effectiveScope(
+				base.generationMode,
+				settings.value.builderAvailable,
+			),
+		};
+	});
+
+	const change = (patch: Partial<ConversationModeState>): void => {
+		const isSent = options.send({
+			type: CLIENT_MESSAGE_TYPES.SET_CONVERSATION_MODE,
+			conversationId: options.activeId.value,
+			...patch,
+		});
+		if (!isSent) return;
+		options.mode.value = { ...current.value, ...patch };
+	};
+
+	return {
+		current,
+		setMode: (mode) => change({ mode }),
+		setScope: (generationMode) => change({ generationMode }),
+		startFullAuto: (duration) => change({ fullAuto: { duration } }),
+		stopFullAuto: () => change({ fullAuto: null }),
+	};
+}

package/frontend-vue/app/chat/composables/usePaletteTurn.ts

@@ -0,0 +1,124 @@
+import { computed, type ComputedRef, ref } from "vue";
+import type { ChatTransport } from "../../runtime/chat-transport";
+import {
+	CLIENT_MESSAGE_TYPES,
+	CONNECTION_STATUSES,
+} from "../constants/protocol";
+import { PALETTE_TURN_MODE } from "../constants/conversation";
+import { createChatChannel, type UseChatChannelResult } from "./useChatChannel";
+import { useConversation, type UseConversationResult } from "./useConversation";
+import { newUuid } from "../utils/ids";
+import {
+	usePermissionQueue,
+	type UsePermissionQueueResult,
+} from "./usePermissionQueue";
+import {
+	useQuestionQueue,
+	type UseQuestionQueueResult,
+} from "./useQuestionQueue";
+
+export interface UsePaletteTurnOptions {
+	transport: ChatTransport;
+	prompt: string;
+	/** The page the question is asked on. */
+	getPagePath: () => string | undefined;
+}
+
+/**
+ * One question asked from the command palette: a read-only turn (Plan only,
+ * Safe mode) in a conversation of its own, followed over the tab's stream
+ * next to the panel's chat, and folded by the panel's own conversation logic.
+ */
+export interface PaletteTurn {
+	conversationId: string;
+	channel: UseChatChannelResult;
+	conversation: UseConversationResult;
+	permissions: UsePermissionQueueResult;
+	questions: UseQuestionQueueResult;
+	/** The agent asks something only the full assistant can answer. */
+	isWaitingForUser: ComputedRef<boolean>;
+	/** Attaches to the stream; the question leaves once it is connected. */
+	start: () => void;
+	/**
+	 * Lets the conversation go on elsewhere: stopping the palette's view of it
+	 * no longer stops its turn.
+	 */
+	handOff: () => void;
+	/** Detaches, stopping the turn unless it was handed off. */
+	stop: () => void;
+}
+
+interface TurnState {
+	isAsked: boolean;
+	isHandedOff: boolean;
+	stopListening: () => void;
+}
+
+function ask(
+	options: UsePaletteTurnOptions,
+	turn: PaletteTurn,
+	state: TurnState,
+): void {
+	if (state.isAsked) return;
+	state.isAsked = true;
+	turn.channel.send({
+		type: CLIENT_MESSAGE_TYPES.SET_CONVERSATION_MODE,
+		conversationId: turn.conversationId,
+		...PALETTE_TURN_MODE,
+	});
+	turn.conversation.sendUserMessage(options.prompt);
+}
+
+export function usePaletteTurn(options: UsePaletteTurnOptions): PaletteTurn {
+	const conversationId = newUuid();
+	const activeId = ref(conversationId);
+	const channel = createChatChannel({
+		transport: options.transport,
+		getConversationId: () => conversationId,
+		isFollowing: true,
+	});
+	const queueOptions = {
+		activeId,
+		send: channel.result.send,
+		onMessage: channel.result.onMessage,
+	};
+	const permissions = usePermissionQueue(queueOptions);
+	const questions = useQuestionQueue(queueOptions);
+	const conversation = useConversation({
+		...queueOptions,
+		getPagePath: options.getPagePath,
+	});
+	const state: TurnState = {
+		isAsked: false,
+		isHandedOff: false,
+		stopListening: () => undefined,
+	};
+	const turn: PaletteTurn = {
+		conversationId,
+		channel: channel.result,
+		conversation,
+		permissions,
+		questions,
+		isWaitingForUser: computed(
+			() =>
+				permissions.queue.value.length > 0 || questions.queue.value.length > 0,
+		),
+		start: () => {
+			channel.start();
+			state.stopListening = options.transport.onReady(() =>
+				ask(options, turn, state),
+			);
+			if (options.transport.getStatus() === CONNECTION_STATUSES.CONNECTED)
+				ask(options, turn, state);
+		},
+		handOff: () => {
+			state.isHandedOff = true;
+		},
+		stop: () => {
+			if (!state.isHandedOff) conversation.interrupt();
+			state.stopListening();
+			channel.stop();
+		},
+	};
+	return turn;
+}

package/frontend-vue/app/chat/composables/usePermissionQueue.ts

@@ -1,59 +1,236 @@
 import { type Ref, ref } from "vue";
-import type { PermissionDecision } from "../constants/permissions";
-import { CLIENT_MESSAGE_TYPES } from "../constants/protocol";
-import type { PermissionRequestData } from "../types/permission";
+import {
+	CLIENT_MESSAGE_TYPES,
+	FEEDBACK_MAX_CHARS,
+	SERVER_EVENT_TYPES,
+} from "../constants/protocol";
+import type {
+	ExpiredRequest,
+	PermissionAnswer,
+	PermissionRequestData,
+} from "../types/permission";
+import type {
+	ActiveRule,
+	PermissionKind,
+	PermissionPreview,
+	PermissionRule,
+} from "../types/protocol";
 
 export interface UsePermissionQueueOptions {
-	send: (msg: object) => void;
+	activeId: Ref<string>;
+	send: (msg: object) => boolean;
+	onMessage: (handler: (msg: unknown) => void) => () => void;
 }
 
 export interface UsePermissionQueueResult {
+	/** The active chat's pending requests, oldest first. */
 	queue: Ref<PermissionRequestData[]>;
-	enqueue: (req: PermissionRequestData) => void;
-	respond: (requestId: string, decision: PermissionDecision) => void;
-	respondAll: (decision: PermissionDecision) => void;
+	/** Requests that went unanswered, until dismissed or asked again. */
+	expired: Ref<ExpiredRequest[]>;
+	/** What the user allowed for the rest of this chat. */
+	rules: Ref<ActiveRule[]>;
+	respond: (requestId: string, answer: PermissionAnswer) => void;
+	/** Denies every pending request of the chat and stops its turn. */
+	denyAll: () => void;
+	revokeRule: (ruleId: string) => void;
+	dismissExpired: (requestId: string) => void;
 	clear: () => void;
 }
 
-function buildResponseMessage(
+interface PermissionRequestWire {
+	conversationId: string;
+	requestId: string;
+	callId?: string;
+	toolName: string;
+	args: unknown;
+	summary: string;
+	kind: PermissionKind;
+	alwaysAsk: boolean;
+	preview: PermissionPreview;
+	ruleOptions: PermissionRule[];
+	createdAtMs: number;
+	expiresAtMs: number;
+}
+
+interface PermissionExpiredWire {
+	conversationId: string;
+	requestId: string;
+	toolName?: string;
+	summary?: string;
+	expiredAtMs?: number;
+}
+
+interface RequestIdWire {
+	requestId: string;
+}
+
+interface RulesStateWire {
+	rules?: ActiveRule[];
+}
+
+interface QueueState {
+	options: UsePermissionQueueOptions;
+	queue: Ref<PermissionRequestData[]>;
+	expired: Ref<ExpiredRequest[]>;
+	rules: Ref<ActiveRule[]>;
+}
+
+type QueueHandler = (state: QueueState, event: never) => void;
+
+/** A request as the dock reads it: an always-ask one never offers a rule. */
+function toPermissionRequest(
+	wire: PermissionRequestWire,
+): PermissionRequestData {
+	return {
+		requestId: wire.requestId,
+		conversationId: wire.conversationId,
+		callId: wire.callId,
+		toolName: wire.toolName,
+		args: wire.args,
+		summary: wire.summary,
+		kind: wire.kind,
+		alwaysAsk: wire.alwaysAsk,
+		preview: wire.preview,
+		ruleOptions: wire.alwaysAsk ? [] : wire.ruleOptions,
+		createdAtMs: wire.createdAtMs,
+		expiresAtMs: wire.expiresAtMs,
+	};
+}
+
+function without(state: QueueState, requestId: string): void {
+	state.queue.value = state.queue.value.filter(
+		(req) => req.requestId !== requestId,
+	);
+}
+
+function enqueue(state: QueueState, wire: PermissionRequestWire): void {
+	if (state.queue.value.some((req) => req.requestId === wire.requestId)) return;
+	state.queue.value = [...state.queue.value, toPermissionRequest(wire)];
+}
+
+function expire(state: QueueState, wire: PermissionExpiredWire): void {
+	const pending = state.queue.value.find(
+		(req) => req.requestId === wire.requestId,
+	);
+	without(state, wire.requestId);
+	if (state.expired.value.some((req) => req.requestId === wire.requestId))
+		return;
+	state.expired.value = [
+		...state.expired.value,
+		{
+			requestId: wire.requestId,
+			conversationId: wire.conversationId,
+			toolName: wire.toolName ?? pending?.toolName ?? "",
+			summary: wire.summary ?? pending?.summary ?? "",
+			expiredAtMs: wire.expiredAtMs ?? Date.now(),
+		},
+	];
+}
+
+const HANDLERS: Record<string, QueueHandler> = {
+	[SERVER_EVENT_TYPES.PERMISSION_REQUEST]: enqueue,
+	[SERVER_EVENT_TYPES.PERMISSION_EXPIRED]: expire,
+	[SERVER_EVENT_TYPES.PERMISSION_RESOLVED]: (state, event: RequestIdWire) =>
+		without(state, event.requestId),
+	[SERVER_EVENT_TYPES.RULES_STATE]: (state, event: RulesStateWire) => {
+		state.rules.value = event.rules ?? [];
+	},
+};
+
+function dispatch(state: QueueState, msg: unknown): void {
+	if (msg === null || typeof msg !== "object") return;
+	const event = msg as Record<string, unknown>;
+	const handler = HANDLERS[String(event.type)];
+	if (handler === undefined) return;
+	const conversationId = event.conversationId;
+	if (
+		typeof conversationId === "string" &&
+		conversationId !== state.options.activeId.value
+	)
+		return;
+	handler(state, msg as never);
+}
+
+function answerMessage(
 	req: PermissionRequestData,
-	decision: PermissionDecision,
+	answer: PermissionAnswer,
 ): object {
+	const feedback = answer.feedback?.trim().slice(0, FEEDBACK_MAX_CHARS);
 	return {
 		type: CLIENT_MESSAGE_TYPES.PERMISSION_RESPONSE,
 		conversationId: req.conversationId,
 		requestId: req.requestId,
-		decision,
+		decision: answer.decision,
+		...(answer.rule === undefined ? {} : { rule: answer.rule }),
+		...(feedback ? { feedback } : {}),
+		...(answer.keepData === true ? { keepData: true } : {}),
 	};
 }
 
-export function usePermissionQueue(
-	options: UsePermissionQueueOptions,
-): UsePermissionQueueResult {
-	const queue = ref<PermissionRequestData[]>([]);
+function respond(
+	state: QueueState,
+	requestId: string,
+	answer: PermissionAnswer,
+): void {
+	const target = state.queue.value.find((req) => req.requestId === requestId);
+	if (target === undefined) return;
+	if (!state.options.send(answerMessage(target, answer))) return;
+	without(state, requestId);
+}
 
-	const enqueue = (req: PermissionRequestData): void => {
-		if (queue.value.some((q) => q.requestId === req.requestId)) return;
-		queue.value = [...queue.value, req];
-	};
+function denyAll(state: QueueState): void {
+	const first = state.queue.value[0];
+	if (first === undefined) return;
+	const isSent = state.options.send({
+		type: CLIENT_MESSAGE_TYPES.PERMISSION_RESPONSE,
+		conversationId: first.conversationId,
+		requestId: first.requestId,
+		decision: "deny_all",
+	});
+	if (isSent) state.queue.value = [];
+}
 
-	const respond = (requestId: string, decision: PermissionDecision): void => {
-		const target = queue.value.find((q) => q.requestId === requestId);
-		if (target === undefined) return;
-		options.send(buildResponseMessage(target, decision));
-		queue.value = queue.value.filter((q) => q.requestId !== requestId);
-	};
+function revokeRule(state: QueueState, ruleId: string): void {
+	const isSent = state.options.send({
+		type: CLIENT_MESSAGE_TYPES.REVOKE_RULE,
+		conversationId: state.options.activeId.value,
+		ruleId,
+	});
+	if (!isSent) return;
+	state.rules.value = state.rules.value.filter((rule) => rule.id !== ruleId);
+}
 
-	const respondAll = (decision: PermissionDecision): void => {
-		for (const req of queue.value) {
-			options.send(buildResponseMessage(req, decision));
-		}
-		queue.value = [];
+/**
+ * The approvals of the active chat: pending requests with their previews,
+ * those that expired, and the rules the user granted. Requests another tab
+ * answered leave as soon as the sidecar says so.
+ */
+export function usePermissionQueue(
+	options: UsePermissionQueueOptions,
+): UsePermissionQueueResult {
+	const state: QueueState = {
+		options,
+		queue: ref<PermissionRequestData[]>([]),
+		expired: ref<ExpiredRequest[]>([]),
+		rules: ref<ActiveRule[]>([]),
 	};
-
-	const clear = (): void => {
-		queue.value = [];
+	options.onMessage((msg) => dispatch(state, msg));
+	return {
+		queue: state.queue,
+		expired: state.expired,
+		rules: state.rules,
+		respond: (requestId, answer) => respond(state, requestId, answer),
+		denyAll: () => denyAll(state),
+		revokeRule: (ruleId) => revokeRule(state, ruleId),
+		dismissExpired: (requestId) => {
+			state.expired.value = state.expired.value.filter(
+				(req) => req.requestId !== requestId,
+			);
+		},
+		clear: () => {
+			state.queue.value = [];
+			state.expired.value = [];
+			state.rules.value = [];
+		},
 	};
-
-	return { queue, enqueue, respond, respondAll, clear };
 }