@antelopejs/dms-ai 0.1.5 → 0.2.0

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

@@ -1,50 +1,132 @@
 import { type Ref, ref } from "vue";
-import { CLIENT_MESSAGE_TYPES } from "../constants/protocol";
-import type { QuestionRequestData } from "../types/question";
+import {
+	CLIENT_MESSAGE_TYPES,
+	SERVER_EVENT_TYPES,
+} from "../constants/protocol";
+import type { QuestionAnswerRecord } from "../types/protocol";
+import type {
+	QuestionData,
+	QuestionReply,
+	QuestionRequestData,
+} from "../types/question";
 
 export interface UseQuestionQueueOptions {
-	send: (msg: object) => void;
+	activeId: Ref<string>;
+	send: (msg: object) => boolean;
+	onMessage: (handler: (msg: unknown) => void) => () => void;
 }
 
 export interface UseQuestionQueueResult {
 	queue: Ref<QuestionRequestData[]>;
-	enqueue: (req: QuestionRequestData) => void;
-	respond: (requestId: string, answers: string[]) => void;
+	/**
+	 * Sends the replies, one per question. Answers what the transcript keeps of
+	 * them, or null when nothing was sent.
+	 */
+	respond: (
+		requestId: string,
+		replies: QuestionReply[],
+	) => QuestionAnswerRecord[] | null;
 	clear: () => void;
 }
 
-function buildResponseMessage(
+interface AskQuestionWire {
+	conversationId: string;
+	requestId: string;
+	questions: QuestionData[];
+	createdAtMs: number;
+	expiresAtMs: number;
+}
+
+interface RequestIdWire {
+	requestId: string;
+}
+
+function toRequest(wire: AskQuestionWire): QuestionRequestData {
+	return {
+		requestId: wire.requestId,
+		conversationId: wire.conversationId,
+		questions: wire.questions,
+		createdAtMs: wire.createdAtMs,
+		expiresAtMs: wire.expiresAtMs,
+	};
+}
+
+/** What the transcript keeps of each answer. */
+function toAnswerRecords(
+	questions: readonly QuestionData[],
+	replies: readonly QuestionReply[],
+): QuestionAnswerRecord[] {
+	return questions.map((question, index) => {
+		const reply = replies[index];
+		const isSkipped = reply === undefined || reply.skipped;
+		return {
+			header: question.header,
+			question: question.question,
+			answer: isSkipped ? null : reply.answer,
+			skipped: isSkipped,
+			isCustom: !isSkipped && reply.isCustom,
+		};
+	});
+}
+
+function responseMessage(
 	req: QuestionRequestData,
-	answers: string[],
+	replies: readonly QuestionReply[],
 ): object {
+	const skipped = req.questions.map(
+		(_, index) => replies[index]?.skipped ?? true,
+	);
 	return {
 		type: CLIENT_MESSAGE_TYPES.QUESTION_RESPONSE,
 		conversationId: req.conversationId,
 		requestId: req.requestId,
-		answers,
+		answers: req.questions.map((_, index) =>
+			skipped[index] ? "" : (replies[index]?.answer ?? ""),
+		),
+		...(skipped.some(Boolean) ? { skipped } : {}),
 	};
 }
 
+function isForActive(msg: Record<string, unknown>, activeId: string): boolean {
+	const id = msg.conversationId;
+	return typeof id !== "string" || id === activeId;
+}
+
+/**
+ * The questions the agent waits on in the active chat. Answering sends the
+ * replies and gives back what the transcript keeps of them; a question the
+ * sidecar timed out simply leaves.
+ */
 export function useQuestionQueue(
 	options: UseQuestionQueueOptions,
 ): UseQuestionQueueResult {
 	const queue = ref<QuestionRequestData[]>([]);
-
-	const enqueue = (req: QuestionRequestData): void => {
-		if (queue.value.some((q) => q.requestId === req.requestId)) return;
-		queue.value = [...queue.value, req];
+	const drop = (requestId: string): void => {
+		queue.value = queue.value.filter((req) => req.requestId !== requestId);
 	};
 
-	const respond = (requestId: string, answers: string[]): void => {
-		const target = queue.value.find((q) => q.requestId === requestId);
-		if (target === undefined) return;
-		options.send(buildResponseMessage(target, answers));
-		queue.value = queue.value.filter((q) => q.requestId !== requestId);
-	};
+	options.onMessage((msg) => {
+		if (msg === null || typeof msg !== "object") return;
+		const event = msg as Record<string, unknown>;
+		if (!isForActive(event, options.activeId.value)) return;
+		if (event.type === SERVER_EVENT_TYPES.QUESTION_EXPIRED)
+			drop((msg as RequestIdWire).requestId);
+		if (event.type !== SERVER_EVENT_TYPES.ASK_QUESTION) return;
+		const wire = msg as AskQuestionWire;
+		if (queue.value.some((req) => req.requestId === wire.requestId)) return;
+		queue.value = [...queue.value, toRequest(wire)];
+	});
 
-	const clear = (): void => {
-		queue.value = [];
+	const respond = (
+		requestId: string,
+		replies: QuestionReply[],
+	): QuestionAnswerRecord[] | null => {
+		const target = queue.value.find((req) => req.requestId === requestId);
+		if (target === undefined) return null;
+		if (!options.send(responseMessage(target, replies))) return null;
+		drop(requestId);
+		return toAnswerRecords(target.questions, replies);
 	};
 
-	return { queue, enqueue, respond, clear };
+	return { queue, respond, clear: () => (queue.value = []) };
 }

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

@@ -0,0 +1,55 @@
+import type { Ref } from "vue";
+import { CLIENT_MESSAGE_TYPES } from "../constants/protocol";
+import type { QueuedMessage } from "../types/conversation";
+import { moveItem } from "../utils/queue";
+
+export interface UseQueueActionsOptions {
+	activeId: Ref<string>;
+	queued: Ref<QueuedMessage[]>;
+	send: (msg: object) => boolean;
+}
+
+export interface UseQueueActionsResult {
+	cancel: (id: string) => void;
+	update: (id: string, content: string) => void;
+	move: (id: string, toIndex: number) => void;
+	clear: () => void;
+}
+
+/**
+ * Edits to the follow-up queue. The sidecar owns it and answers each change
+ * with the new `queue_state`; the chat shows the change at once meanwhile.
+ */
+export function useQueueActions(
+	options: UseQueueActionsOptions,
+): UseQueueActionsResult {
+	const send = (type: string, fields: Record<string, unknown>): boolean =>
+		options.send({
+			type,
+			conversationId: options.activeId.value,
+			...fields,
+		});
+
+	return {
+		cancel: (id) => {
+			if (!send(CLIENT_MESSAGE_TYPES.QUEUE_CANCEL, { id })) return;
+			options.queued.value = options.queued.value.filter(
+				(item) => item.id !== id,
+			);
+		},
+		update: (id, content) => {
+			if (!send(CLIENT_MESSAGE_TYPES.QUEUE_UPDATE, { id, content })) return;
+			options.queued.value = options.queued.value.map((item) =>
+				item.id === id ? { ...item, content } : item,
+			);
+		},
+		move: (id, toIndex) => {
+			if (!send(CLIENT_MESSAGE_TYPES.QUEUE_MOVE, { id, toIndex })) return;
+			options.queued.value = moveItem(options.queued.value, id, toIndex);
+		},
+		clear: () => {
+			if (!send(CLIENT_MESSAGE_TYPES.QUEUE_CLEAR, {})) return;
+			options.queued.value = [];
+		},
+	};
+}

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

@@ -1,9 +1,6 @@
 import { type Ref, ref } from "vue";
 import { DEFAULT_SETTINGS } from "../constants/settings";
-import {
-	CLIENT_MESSAGE_TYPES,
-	SERVER_EVENT_TYPES,
-} from "../constants/protocol";
+import { SERVER_EVENT_TYPES } from "../constants/protocol";
 import type {
 	AppSettings,
 	ProviderAvailability,
@@ -11,57 +8,43 @@ import type {
 } from "../types/settings";
 
 export interface UseSettingsOptions {
-	send: (msg: object) => void;
 	onMessage: (handler: (msg: unknown) => void) => () => void;
 }
 
 export interface UseSettingsResult {
 	settings: Ref<AppSettings>;
-	update: (next: Partial<AppSettings>) => void;
 }
 
 interface SettingsUpdateEvent {
 	type: typeof SERVER_EVENT_TYPES.SETTINGS_UPDATE;
-	settings: AppSettings;
+	settings?: Partial<AppSettings>;
 	builderAvailable?: boolean;
 	providers?: Record<ProviderName, ProviderAvailability>;
 }
 
-function isObject(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object";
+function isSettingsUpdate(msg: unknown): msg is SettingsUpdateEvent {
+	if (msg === null || typeof msg !== "object") return false;
+	return Reflect.get(msg, "type") === SERVER_EVENT_TYPES.SETTINGS_UPDATE;
 }
 
-function getEventType(msg: unknown): string | null {
-	if (!isObject(msg)) return null;
-	const t = msg.type;
-	return typeof t === "string" ? t : null;
+/** The pushed settings over the defaults. */
+function readSettings(event: SettingsUpdateEvent): AppSettings {
+	return {
+		...DEFAULT_SETTINGS,
+		...event.settings,
+		builderAvailable: event.builderAvailable ?? false,
+		providers: event.providers ?? DEFAULT_SETTINGS.providers,
+	};
 }
 
+/** The sidecar's settings, as it pushes them; the Settings page edits them. */
 export function useSettings(options: UseSettingsOptions): UseSettingsResult {
 	const settings = ref<AppSettings>({ ...DEFAULT_SETTINGS });
 
 	options.onMessage((msg: unknown): void => {
-		if (getEventType(msg) !== SERVER_EVENT_TYPES.SETTINGS_UPDATE) return;
-		const event = msg as SettingsUpdateEvent;
-		settings.value = {
-			...event.settings,
-			builderAvailable: event.builderAvailable ?? false,
-			providers: event.providers ?? DEFAULT_SETTINGS.providers,
-		};
+		if (!isSettingsUpdate(msg)) return;
+		settings.value = readSettings(msg);
 	});
 
-	const update = (partial: Partial<AppSettings>): void => {
-		const next: AppSettings = { ...settings.value, ...partial };
-		settings.value = next;
-		options.send({
-			type: CLIENT_MESSAGE_TYPES.SET_SETTINGS,
-			provider: next.provider,
-			mode: next.mode,
-			thinking: next.thinking,
-			generationMode: next.generationMode,
-			allowLocalSkills: next.allowLocalSkills,
-		});
-	};
-
-	return { settings, update };
+	return { settings };
 }

package/frontend-vue/app/chat/constants/attachments.ts

@@ -13,4 +13,5 @@ export const INLINE_IMAGE_MIME_TYPES = [
 	"image/webp",
 ] as const;
 
-export const ATTACH_LABEL = "Attach files";
+/** The size limit as the composer states it. */
+export const MAX_ATTACHMENT_MEGABYTES = 25;

package/frontend-vue/app/chat/constants/conversation.ts

@@ -3,6 +3,9 @@ export const MESSAGE_ROLES = {
 	ASSISTANT: "assistant",
 	TOOL: "tool",
 	ERROR: "error",
+	NOTICE: "notice",
+	CHANGE_SET: "change_set",
+	QUESTION_ANSWER: "question_answer",
 } as const;
 
 export const STORED_TOOL_USE_ROLE = "tool_use";
@@ -16,6 +19,13 @@ export const TOOL_STATUS = {
 } as const;
 
 export const TODO_WRITE_TOOL_NAME = "TodoWrite";
+export const EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
+/** A question asked from the command palette is answered read-only. */
+export const PALETTE_TURN_MODE = {
+	mode: "plan",
+	generationMode: "safe",
+} as const;
+export const PLAN_ARG_KEY = "plan";
 
 export const TODO_STATUS = {
 	PENDING: "pending",
@@ -23,45 +33,18 @@ export const TODO_STATUS = {
 	COMPLETED: "completed",
 } as const;
 
-export const TODO_PANEL_TITLE = "Plan";
-
 export const STORAGE_CONVERSATION_ID_KEY = "dms-ai-conversation-id";
 
 export const SEND_HOTKEY = "Enter";
 export const NEWLINE_HOTKEY_MODIFIER = "shiftKey";
 
-export const ROLE_LABELS = {
-	USER: "You",
-	ASSISTANT: "Assistant",
-	TOOL: "Tool",
-	ERROR: "The run did not finish",
+/** Translation keys of the errors the chat itself raises. */
+export const LOCAL_ERROR_KEYS = {
+	NOT_SENT: "dms_ai.panel.errors.not_sent",
+	RETRY_NEEDS_FILES: "dms_ai.panel.errors.retry_needs_files",
+	STOP_NOT_DELIVERED: "dms_ai.panel.errors.stop_not_delivered",
 } as const;
 
-export const STATUS_LABELS = {
-	PENDING: "running",
-	SUCCESS: "success",
-	ERROR: "error",
-} as const;
-
-/** Shown when a message could not even leave the chat. */
-export const NOT_SENT_MESSAGE =
-	"Your message was not sent: the assistant is not connected. Reconnect, then retry.";
-
-/** Shown when a retry needs files that only the original message still had. */
-export const RETRY_NEEDS_FILES_MESSAGE =
-	"Attach the files again to retry: they are no longer available after a reload.";
-
-/** Shown when Stop could not reach the sidecar, so the run is let go locally. */
-export const STOP_NOT_DELIVERED_MESSAGE =
-	"The assistant could not be reached to stop the run. Reconnect to see where it stands.";
-
-/** Result given to a tool that was still running when its run ended. */
-export const TOOL_CUT_SHORT_RESULT = "The run ended before this tool finished.";
-
-export const RETRY_LABEL = "Retry";
-
-export const TOOL_CLUSTER_LABEL = "Used";
-
 /**
  * A live cluster peeks only its most recent rows; the rest hide behind a
  * reveal.
@@ -73,3 +56,6 @@ export const TOOL_CLUSTER_VISIBLE_LIMIT = 3;
  * a fast hand-off to the next cluster doesn't flash.
  */
 export const TOOL_CLUSTER_COLLAPSE_LINGER_MS = 600;
+
+/** How long a deleted conversation can be brought back before it is deleted. */
+export const DELETE_UNDO_MS = 8_000;

package/frontend-vue/app/chat/constants/protocol.ts

@@ -9,13 +9,25 @@ export const CLIENT_MESSAGE_TYPES = {
 	INTERRUPT_TURN: "interrupt_turn",
 	QUEUE_ENQUEUE: "queue_enqueue",
 	QUEUE_CANCEL: "queue_cancel",
+	QUEUE_UPDATE: "queue_update",
+	QUEUE_MOVE: "queue_move",
+	QUEUE_CLEAR: "queue_clear",
+	REVOKE_RULE: "revoke_rule",
+	SET_CONVERSATION_MODE: "set_conversation_mode",
+	LEAVE_CONVERSATION: "leave_conversation",
+	STOP_AUTOFIX: "stop_autofix",
+	RETRY_TURN: "retry_turn",
+	CHANGE_SET_ACTION: "change_set_action",
 } as const;
 
 /**
- * Route of the dms-ai Settings page, reached from the chat's cogwheel. Module
- * pages live under `/modules/<moduleId>/<slug>`.
+ * Pages of the dms-ai module the chat links to. Module pages live under
+ * `/modules/<moduleId>/<slug>`.
  */
 export const SETTINGS_PAGE_PATH = "/modules/ai/settings";
+export const CHANGES_PAGE_PATH = "/modules/ai/changes";
+export const ACTIVITY_PAGE_PATH = "/modules/ai/activity";
+export const CHANGE_SET_QUERY_KEY = "set";
 
 export const SERVER_EVENT_TYPES = {
 	ASSISTANT_MESSAGE_CHUNK: "assistant_message_chunk",
@@ -28,10 +40,18 @@ export const SERVER_EVENT_TYPES = {
 	CONVERSATION_LIST: "conversation_list",
 	SETTINGS_UPDATE: "settings_update",
 	PERMISSION_REQUEST: "permission_request",
+	PERMISSION_EXPIRED: "permission_expired",
+	PERMISSION_RESOLVED: "permission_resolved",
+	RULES_STATE: "rules_state",
 	ASK_QUESTION: "ask_question",
+	QUESTION_EXPIRED: "question_expired",
 	QUEUE_STATE: "queue_state",
 	USER_MESSAGE_ECHO: "user_message_echo",
 	RUN_PROGRESS: "run_progress",
+	CONVERSATION_MODE: "conversation_mode",
+	NOTICE: "notice",
+	CHANGE_SET: "change_set",
+	USAGE: "usage",
 } as const;
 
 /** The role the chat says hello with. */
@@ -46,3 +66,6 @@ export const CONNECTION_STATUSES = {
 
 export type ConnectionStatus =
 	(typeof CONNECTION_STATUSES)[keyof typeof CONNECTION_STATUSES];
+
+/** The wire's most a "Suggest a change" text may carry. */
+export const FEEDBACK_MAX_CHARS = 2000;

package/frontend-vue/app/chat/constants/run-status.ts

@@ -10,14 +10,14 @@ export const ACTIVITY_KINDS = {
 	RETRYING: "retrying",
 } as const;
 
-/** What a running turn shows while the agent works, by reported activity. */
-export const ACTIVITY_LABELS: Record<ActivityKind, string> = {
-	[ACTIVITY_KINDS.THINKING]: "Thinking",
-	[ACTIVITY_KINDS.RESPONDING]: "Writing the answer",
-	[ACTIVITY_KINDS.WRITING]: "Preparing",
-	[ACTIVITY_KINDS.TOOL]: "Running",
-	[ACTIVITY_KINDS.COMPACTING]: "Compacting the conversation",
-	[ACTIVITY_KINDS.RETRYING]: "The model is busy, retrying",
+/** Translation key of what a running turn shows, by reported activity. */
+export const ACTIVITY_LABEL_KEYS: Record<ActivityKind, string> = {
+	[ACTIVITY_KINDS.THINKING]: "dms_ai.panel.activity.thinking",
+	[ACTIVITY_KINDS.RESPONDING]: "dms_ai.panel.activity.responding",
+	[ACTIVITY_KINDS.WRITING]: "dms_ai.panel.activity.writing",
+	[ACTIVITY_KINDS.TOOL]: "dms_ai.panel.activity.tool",
+	[ACTIVITY_KINDS.COMPACTING]: "dms_ai.panel.activity.compacting",
+	[ACTIVITY_KINDS.RETRYING]: "dms_ai.panel.activity.retrying",
 };
 
 /** Activities whose detail names a tool, shown with the tool's own label. */
@@ -29,7 +29,6 @@ export const TOOL_DETAIL_ACTIVITIES: readonly ActivityKind[] = [
 /** Activities during which a silent agent is expected, so never called quiet. */
 export const SILENT_ACTIVITIES: readonly ActivityKind[] = [ACTIVITY_KINDS.TOOL];
 
-export const DEFAULT_ACTIVITY_LABEL = "Thinking";
 export const ACTIVITY_ELLIPSIS = "…";
 
 /**
@@ -43,8 +42,3 @@ export const STALL_AFTER_MS = 20_000;
 export const QUIET_NOTICE_AFTER_MS = 60_000;
 
 export const RUN_CLOCK_TICK_MS = 1_000;
-
-export const STALLED_LABEL = "No news from the assistant for";
-export const QUIET_LABEL = "no activity for";
-export const RECONNECT_LABEL = "Reconnect";
-export const STOP_LABEL = "Stop";

package/frontend-vue/app/chat/constants/settings.ts

@@ -1,4 +1,6 @@
-import type { AppSettings, ChatMode, ProviderName } from "../types/settings";
+import type { AppSettings } from "../types/settings";
+
+const DEFAULT_REQUEST_TIMEOUT_MINUTES = 5;
 
 export const DEFAULT_SETTINGS: AppSettings = {
 	provider: "claude",
@@ -6,55 +8,11 @@ export const DEFAULT_SETTINGS: AppSettings = {
 	thinking: "medium",
 	generationMode: "safe",
 	allowLocalSkills: false,
+	notifyRequests: true,
+	requestTimeoutMinutes: DEFAULT_REQUEST_TIMEOUT_MINUTES,
 	builderAvailable: false,
 	providers: {
 		claude: { available: true },
 		codex: { available: false },
 	},
 };
-
-export const OPEN_SETTINGS_LABEL = "Settings";
-
-export const MODE_SECTION_LABEL = "Mode";
-export const PROVIDER_SECTION_LABEL = "Agent";
-
-export const PROVIDER_OPTIONS: { value: ProviderName; label: string }[] = [
-	{ value: "claude", label: "Claude" },
-	{ value: "codex", label: "Codex" },
-];
-
-/**
- * Shown in place of the hint when the sidecar reports the provider as
- * unavailable, so the reason travels with the greyed-out option.
- */
-export const PROVIDER_UNAVAILABLE_PREFIX = "Unavailable: ";
-
-/**
- * Sessions belong to the backend that opened them, so a switch tears them down.
- * The transcript survives; what the agent remembers of it does not — and that
- * is not something to discover after the fact.
- */
-export const PROVIDER_SWITCH_WARNING =
-	"Switching agent starts a new session: open conversations lose what the agent remembers of them. Transcripts are kept.";
-export const PROVIDER_SWITCH_CONFIRM = `${PROVIDER_SWITCH_WARNING}\n\nSwitch now?`;
-export const PROVIDER_BUSY_HINT =
-	"Stop the current turn before switching agent.";
-
-export const MODE_OPTIONS: { value: ChatMode; label: string }[] = [
-	{ value: "normal", label: "Normal" },
-	{ value: "acceptEdits", label: "Accept edits" },
-	{ value: "plan", label: "Plan" },
-	{ value: "auto", label: "Auto" },
-];
-
-export const MODE_HINTS: Record<ChatMode, string> = {
-	normal: "Ask before each tool action",
-	acceptEdits: "Auto-accept file edits, ask for the rest",
-	plan: "Plan only — propose without making changes",
-	auto: "Auto-approve every tool action",
-};
-
-// Safe mode refuses raw edits whatever the mode, and Auto stops short of
-// approving everything there, so the mode hint says so while it is active.
-export const SAFE_MODE_MODE_NOTE =
-	"Safe mode: raw edits and shell commands stay blocked, and Auto still asks before other actions.";

package/frontend-vue/app/chat/types/conversation.ts

@@ -1,10 +1,31 @@
 import type { ACTIVITY_KINDS } from "../constants/run-status";
 import type { PendingAttachment } from "../utils/attachments";
+import type {
+	AllowedBy,
+	Notice,
+	ProviderName,
+	QuestionAnswerRecord,
+	Scope,
+	ToolOutcome,
+} from "./protocol";
 
-export type MessageRole = "user" | "assistant" | "tool" | "error";
 export type ToolStatus = "pending" | "success" | "error";
 export type ActivityKind = (typeof ACTIVITY_KINDS)[keyof typeof ACTIVITY_KINDS];
 
+/**
+ * What a tool row shows. `waiting` and `running` are derived by the chat (an
+ * open call, with or without a pending request); the rest come from the
+ * sidecar's `outcome`.
+ */
+export type ToolRowState =
+	| "done"
+	| "running"
+	| "waiting"
+	| "denied"
+	| "blocked"
+	| "failed"
+	| "stopped";
+
 /**
  * A file attached to a user message. `dataUrl` is only present for messages
  * sent in this session (drives the image thumbnail); after a reload the
@@ -23,6 +44,8 @@ export interface UserMessage {
 	content: string;
 	attachments?: MessageAttachment[];
 	isUnsent?: boolean;
+	/** The page the message was sent from, known for messages of this session. */
+	pagePath?: string;
 	timestampMs: number;
 }
 
@@ -38,7 +61,33 @@ export interface ErrorMessage {
 	id: string;
 	role: "error";
 	content: string;
+	/** Set for the chat's own errors: translated at render time. */
+	contentKey?: string;
 	isRetryable: boolean;
+	/** True when only this tab knows of it: a retry resends locally. */
+	isLocal?: boolean;
+	timestampMs: number;
+}
+
+export interface NoticeMessage {
+	id: string;
+	role: "notice";
+	notice: Notice;
+	timestampMs: number;
+}
+
+/** Where a turn's change set is drawn: its summary lives in the change set map. */
+export interface ChangeSetMessage {
+	id: string;
+	role: "change_set";
+	changeSetId: string;
+	timestampMs: number;
+}
+
+export interface QuestionAnswerMessage {
+	id: string;
+	role: "question_answer";
+	answers: QuestionAnswerRecord[];
 	timestampMs: number;
 }
 
@@ -63,14 +112,21 @@ export interface ToolCallMessage {
 	args: unknown;
 	result?: unknown;
 	status: ToolStatus;
+	outcome?: ToolOutcome;
+	allowedBy?: AllowedBy;
+	changeSetId?: string;
 	timestampMs: number;
+	endedAtMs?: number;
 }
 
 export type ConversationMessage =
 	| UserMessage
 	| AssistantMessage
 	| ToolCallMessage
-	| ErrorMessage;
+	| ErrorMessage
+	| NoticeMessage
+	| ChangeSetMessage
+	| QuestionAnswerMessage;
 
 export interface QueuedMessage {
 	id: string;
@@ -84,4 +140,18 @@ export interface ConversationSummary {
 	createdAtMs: number;
 	updatedAtMs: number;
 	messageCount: number;
+	provider?: ProviderName;
+	totalTokens?: number;
+	filesChanged?: number;
+	filesUndone?: number;
+	isRunning?: boolean;
+	pendingApprovals?: number;
+	pendingQuestions?: number;
+	generationMode?: Scope;
+}
+
+/** The page the dashboard shows, which the composer's chip names. */
+export interface CurrentPage {
+	path: string;
+	title?: string;
 }