Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat: add page-agent DOM ref autocomplete (#19702)
p0nya5f01f1b3a55
diff --git a/docs/plans/2026-03-12-page-agent-design.md b/docs/plans/2026-03-12-page-agent-design.mdindex f465921d62..1e7abe79bd 100644--- a/docs/plans/2026-03-12-page-agent-design.md+++ b/docs/plans/2026-03-12-page-agent-design.md@@ -111,7 +111,7 @@ The prompt instructs the model to list routes first when unsure instead of guessCurrent modes:- default `semantic` mode returns route information plus structured context when available,-- `mode: "dom"` returns the same base page state plus indexed DOM information.+- `mode: "dom"` returns the same base page state plus DOM snapshot information, including snapshot-local element refs such as `e1` and `e2`.There is no standalone `get_dom_tree` tool. DOM inspection is part of `get_page_state(mode="dom")`.@@ -126,13 +126,15 @@ Those values are populated from route-aware store lookups in `frontend/src/plugi### `dom_action`-`dom_action` is the browser-side UI interaction tool. It supports the implemented action types used by the agent runtime, including reading indexed DOM elements and performing interactions such as click, input, select, and scroll.+`dom_action` is the browser-side UI interaction tool. It supports the implemented action types used by the agent runtime, including reading DOM elements from the current snapshot and performing interactions such as click, input, select, and scroll.The intended workflow is:1. call `get_page_state(mode="dom")`,-2. inspect element indices,-3. call `dom_action(...)`.+2. inspect snapshot-local element refs such as `[e1]`,+3. call `dom_action(ref="e1", action="click")` or another action using that ref.++These refs are derived from the current DOM snapshot. They are not durable IDs and should be treated as valid only for the snapshot that returned them.### `get_skill`diff --git a/frontend/src/plugins/agent/AGENT.md b/frontend/src/plugins/agent/AGENT.mdindex ae16f0e3ca..2d00b10f5e 100644--- a/frontend/src/plugins/agent/AGENT.md+++ b/frontend/src/plugins/agent/AGENT.md@@ -9,7 +9,7 @@ frontend/src/plugins/agent/├── components/ # Vue UI (AgentWindow, message rendering)├── dom/ # DOM interaction layer│ ├── actions.ts # Execute DOM actions (click, input, select, scroll)-│ └── domTree.ts # Extract and index interactive DOM elements+│ └── domTree.ts # Extract interactive DOM elements and snapshot-local eN refs├── logic/│ ├── agentLoop.ts # Main agent loop: tool calls, retries, message history│ ├── context.ts # Extract page context from Pinia stores@@ -50,6 +50,15 @@ The agent chooses between DOM and API based on page context:- **API-first** for data queries, bulk operations, or when the relevant page is not open- **Either** for mutations on persisted resources — DOM if the user benefits from seeing it, API for speed+## Maintaining DOM Snapshot Refs++When updating prompt text, examples, or maintenance docs for the page agent DOM tools:++- Describe DOM elements with snapshot-local refs such as `[e1]`, not numeric indices.+- Use `dom_action(ref="e1", ...)` in examples.+- State clearly that refs come from the current `get_page_state(mode="dom")` snapshot and must be refreshed after the DOM changes or the page is re-read.+- Do not describe refs as durable IDs across snapshots, rerenders, or navigation.+## Maintaining the Service Directory**What:** A compact, feature-grouped summary of API services. It is embedded directly in `logic/prompt.ts` so the agent can choose the right service quickly before using `search_api` for exact endpoint details.diff --git a/frontend/src/plugins/agent/components/AgentInput.test.ts b/frontend/src/plugins/agent/components/AgentInput.test.tsindex 7f150a3159..88ecd25173 100644--- a/frontend/src/plugins/agent/components/AgentInput.test.ts+++ b/frontend/src/plugins/agent/components/AgentInput.test.ts@@ -2,6 +2,7 @@ import { mount } from "@vue/test-utils";import { createPinia, setActivePinia } from "pinia";import { beforeEach, describe, expect, test, vi } from "vitest";import { createI18n } from "vue-i18n";+import type { DomRefSuggestion } from "../dom";import type { AgentLoopOutcome } from "../logic/types";import { useAgentStore } from "../store/agent";import AgentInput from "./AgentInput.vue";@@ -11,6 +12,7 @@ const {mockBuildSystemPrompt,mockCreateToolExecutor,mockGetToolDefinitions,+ mockLazyExtractDomRefSuggestions,mockRoute,} = vi.hoisted(() => ({mockRunAgentLoop: vi.fn(),@@ -19,9 +21,16 @@ const {vi.fn()),mockGetToolDefinitions: vi.fn(() => []),+ mockLazyExtractDomRefSuggestions: vi.fn<() => Promise<DomRefSuggestion[]>>(+ async () => []+ ),mockRoute: { fullPath: "/projects/demo" },}));+vi.mock("../dom", () => ({+ lazyExtractDomRefSuggestions: mockLazyExtractDomRefSuggestions,+}));+vi.mock("../logic/agentLoop", () => ({runAgentLoop: mockRunAgentLoop,}));@@ -87,6 +96,15 @@ const i18n = createI18n({},});+const createDomRefSuggestion = (+ overrides: Partial<DomRefSuggestion> = {}+): DomRefSuggestion => ({+ ref: "e1",+ tag: "BUTTON",+ label: "Suggestion",+ ...overrides,+});+describe("AgentInput", () => {let pinia: ReturnType<typeof createPinia>;@@ -100,6 +118,11 @@ describe("AgentInput", () => {mockGetToolDefinitions.mockClear();});+ beforeEach(() => {+ mockLazyExtractDomRefSuggestions.mockReset();+ mockLazyExtractDomRefSuggestions.mockResolvedValue([]);+ });+beforeEach(() => {mockRoute.fullPath = "/projects/demo";document.title = "Demo Page";@@ -141,7 +164,6 @@ describe("AgentInput", () => {kind: "completed",text: "Using project demo.",success: true,- explicit: true,};});@@ -201,7 +223,6 @@ describe("AgentInput", () => {kind: "completed",text: "Using project demo.",success: true,- explicit: true,});const wrapper = mount(AgentInput, {@@ -232,7 +253,6 @@ describe("AgentInput", () => {kind: "completed",text: "Done",success: true,- explicit: true,totalTokensUsed: 123,});@@ -327,7 +347,6 @@ describe("AgentInput", () => {kind: "completed",text: "Done",success: true,- explicit: true,};});@@ -413,7 +432,6 @@ describe("AgentInput", () => {kind: "completed",text: "Done",success: true,- explicit: true,});const wrapper = mount(AgentInput, {@@ -633,7 +651,6 @@ describe("AgentInput", () => {kind: "completed",text: "Done",success: true,- explicit: true,});await flushPromises();@@ -699,6 +716,123 @@ describe("AgentInput", () => {expect(getTextareaValue(wrapper)).toBe("demo-project");});+ test("shows filtered DOM ref suggestions and inserts the selected ref", async () => {+ mockLazyExtractDomRefSuggestions.mockResolvedValue([+ createDomRefSuggestion({+ ref: "e1",+ tag: "BUTTON",+ role: "button",+ label: "Save changes",+ }),+ createDomRefSuggestion({+ ref: "e2",+ tag: "A",+ role: "link",+ label: "Cancel",+ }),+ ]);++ const wrapper = mount(AgentInput, {+ global: {+ plugins: [pinia, i18n],+ },+ });++ const textarea = wrapper.find("textarea");+ await textarea.setValue("Click @sav");+ (textarea.element as HTMLTextAreaElement).setSelectionRange(10, 10);+ await textarea.trigger("select");+ await flushPromises();++ expect(mockLazyExtractDomRefSuggestions).toHaveBeenCalled();+ const items = wrapper.findAll('[data-testid="dom-ref-autocomplete-item"]');+ expect(items).toHaveLength(1);+ expect(items[0].text()).toContain("[e1]");+ expect(items[0].text()).toContain("Save changes");++ await textarea.trigger("keydown", { key: "Enter" });+ await flushPromises();++ expect(getTextareaValue(wrapper)).toBe("Click [e1] ");+ expect(wrapper.find('[data-testid="dom-ref-autocomplete"]').exists()).toBe(+ false+ );+ });++ test("uses arrow keys to change the active DOM ref suggestion before selecting", async () => {+ mockLazyExtractDomRefSuggestions.mockResolvedValue([+ createDomRefSuggestion({+ ref: "e1",+ tag: "BUTTON",+ role: "button",+ label: "Save changes",+ }),+ createDomRefSuggestion({+ ref: "e2",+ tag: "BUTTON",+ role: "button",+ label: "Delete changes",+ }),+ ]);++ const wrapper = mount(AgentInput, {+ global: {+ plugins: [pinia, i18n],+ },+ });++ const textarea = wrapper.find("textarea");+ await textarea.setValue("Use @");+ (textarea.element as HTMLTextAreaElement).setSelectionRange(5, 5);+ await textarea.trigger("select");+ await flushPromises();++ await textarea.trigger("keydown", { key: "ArrowDown" });+ await textarea.trigger("keydown", { key: "Enter" });+ await flushPromises();++ expect(getTextareaValue(wrapper)).toBe("Use [e2] ");+ });++ test("does not send while the DOM ref menu is open and escape closes it", async () => {+ mockRunAgentLoop.mockResolvedValue({+ kind: "completed",+ text: "Done",+ success: true,+ });+ mockLazyExtractDomRefSuggestions.mockResolvedValue([+ createDomRefSuggestion({+ ref: "e1",+ tag: "BUTTON",+ role: "button",+ label: "Save changes",+ }),+ ]);++ const wrapper = mount(AgentInput, {+ global: {+ plugins: [pinia, i18n],+ },+ });++ const textarea = wrapper.find("textarea");+ await textarea.setValue("Inspect @save");+ (textarea.element as HTMLTextAreaElement).setSelectionRange(13, 13);+ await textarea.trigger("select");+ await flushPromises();++ await textarea.trigger("keydown", { key: "Escape" });+ await flushPromises();+ expect(wrapper.find('[data-testid="dom-ref-autocomplete"]').exists()).toBe(+ false+ );++ await textarea.trigger("keydown", { key: "Enter" });+ await flushPromises();++ expect(mockRunAgentLoop).toHaveBeenCalledTimes(1);+ });+test("uses choose buttons to answer pending choose prompts", async () => {const store = useAgentStore();const threadId = store.currentThreadId!;@@ -749,7 +883,6 @@ describe("AgentInput", () => {kind: "completed",text: "Using production.",success: true,- explicit: true,});const wrapper = mount(AgentInput, {@@ -808,7 +941,6 @@ describe("AgentInput", () => {kind: "completed",text: "Canceled.",success: true,- explicit: true,});const wrapper = mount(AgentInput, {diff --git a/frontend/src/plugins/agent/components/AgentInput.vue b/frontend/src/plugins/agent/components/AgentInput.vueindex 1b12b9752e..d9b8c3afb1 100644--- a/frontend/src/plugins/agent/components/AgentInput.vue+++ b/frontend/src/plugins/agent/components/AgentInput.vue@@ -1,8 +1,10 @@<script setup lang="ts">import { v4 as uuidv4 } from "uuid";-import { computed, ref, watch } from "vue";+import { computed, nextTick, ref, watch } from "vue";import { useI18n } from "vue-i18n";import { useRoute, useRouter } from "vue-router";+import type { DomRefSuggestion } from "../dom";+import { lazyExtractDomRefSuggestions } from "../dom";import { runAgentLoop } from "../logic/agentLoop";import { buildSystemPrompt } from "../logic/prompt";import { createToolExecutor, getToolDefinitions } from "../logic/tools";@@ -60,6 +62,179 @@ const isSendDisabled = computed(() => {return !input.value.trim();});+const inputRef = ref<HTMLTextAreaElement>();+const domRefSuggestions = ref<DomRefSuggestion[]>([]);+const isDomRefMenuOpen = ref(false);+const activeDomRefIndex = ref(0);+const selectionStart = ref(0);+const selectionEnd = ref(0);+let domRefRequestToken = 0;++const DOM_REF_SUGGESTION_LIMIT = 8;++const normalizeSearchText = (value?: string) =>+ value?.toLowerCase().trim() ?? "";++const matchDomRefSuggestion = (suggestion: DomRefSuggestion, query: string) => {+ if (!query) {+ return true;+ }+ const normalizedQuery = normalizeSearchText(query);+ return [+ suggestion.ref,+ suggestion.tag,+ suggestion.role,+ suggestion.label,+ suggestion.value,+ ].some((value) => normalizeSearchText(value).includes(normalizedQuery));+};++const getDomRefQuery = (+ text: string,+ start: number,+ end: number+): { query: string; start: number; end: number } | null => {+ if (start !== end) {+ return null;+ }+ const prefix = text.slice(0, start);+ const matches = prefix.match(/(^|\s)@([^\s@]*)$/);+ if (!matches) {+ return null;+ }+ return {+ query: matches[2] ?? "",+ start: start - matches[2].length - 1,+ end,+ };+};++const activeDomRefQuery = computed(() =>+ getDomRefQuery(input.value, selectionStart.value, selectionEnd.value)+);++const filteredDomRefSuggestions = computed(() => {+ const query = activeDomRefQuery.value?.query ?? "";+ return domRefSuggestions.value+ .filter((suggestion: DomRefSuggestion) =>+ matchDomRefSuggestion(suggestion, query)+ )+ .slice(0, DOM_REF_SUGGESTION_LIMIT);+});++const updateSelection = () => {+ const textarea = inputRef.value;+ if (!textarea) {+ return;+ }+ selectionStart.value = textarea.selectionStart ?? 0;+ selectionEnd.value = textarea.selectionEnd ?? selectionStart.value;+};++const closeDomRefMenu = () => {+ isDomRefMenuOpen.value = false;+ activeDomRefIndex.value = 0;+};++const openDomRefMenu = () => {+ isDomRefMenuOpen.value = true;+ activeDomRefIndex.value = 0;+};++const loadDomRefSuggestions = async () => {+ const query = activeDomRefQuery.value;+ if (!query) {+ closeDomRefMenu();+ domRefSuggestions.value = [];+ return;+ }++ const requestToken = ++domRefRequestToken;+ const suggestions = await lazyExtractDomRefSuggestions();+ if (requestToken !== domRefRequestToken || !activeDomRefQuery.value) {+ return;+ }++ domRefSuggestions.value = suggestions;+ if (filteredDomRefSuggestions.value.length > 0) {+ openDomRefMenu();+ return;+ }+ closeDomRefMenu();+};++const selectDomRefSuggestion = async (suggestion: DomRefSuggestion) => {+ const query = activeDomRefQuery.value;+ const textarea = inputRef.value;+ if (!query || !textarea) {+ return;+ }++ const before = input.value.slice(0, query.start);+ const after = input.value.slice(query.end);+ const token = `[${suggestion.ref}]`;+ const suffix = after.startsWith(" ") ? "" : " ";+ const nextValue = `${before}${token}${suffix}${after}`;+ const caret = before.length + token.length + suffix.length;++ input.value = nextValue;+ closeDomRefMenu();+ await nextTick();+ textarea.focus();+ textarea.setSelectionRange(caret, caret);+ updateSelection();+};++const moveDomRefSelection = (offset: number) => {+ const total = filteredDomRefSuggestions.value.length;+ if (total === 0) {+ return;+ }+ activeDomRefIndex.value = (activeDomRefIndex.value + offset + total) % total;+};++const handleTextareaKeydown = async (event: KeyboardEvent) => {+ if (isDomRefMenuOpen.value) {+ if (event.key === "ArrowDown") {+ event.preventDefault();+ moveDomRefSelection(1);+ return;+ }+ if (event.key === "ArrowUp") {+ event.preventDefault();+ moveDomRefSelection(-1);+ return;+ }+ if (event.key === "Escape") {+ event.preventDefault();+ closeDomRefMenu();+ return;+ }+ if (event.key === "Enter") {+ event.preventDefault();+ const suggestion =+ filteredDomRefSuggestions.value[activeDomRefIndex.value];+ if (suggestion) {+ await selectDomRefSuggestion(suggestion);+ } else {+ closeDomRefMenu();+ }+ return;+ }+ }++ if (event.key === "Enter" && !event.shiftKey) {+ event.preventDefault();+ await send();+ }+};++const formatDomRefSuggestionMeta = (suggestion: DomRefSuggestion) => {+ return [suggestion.tag.toLowerCase(), suggestion.role]+ .filter((value): value is string => Boolean(value))+ .join(" · ");+};+const getThreadPageSnapshot = (threadId: string) => {return agentStore.getThread(threadId)?.page;};@@ -399,6 +574,21 @@ watch(},{ immediate: true });+watch(+ () => [input.value, selectionStart.value, selectionEnd.value],+ () => {+ void loadDomRefSuggestions();+ }+);++watch(+ () => agentStore.hasRunningThread,+ (running) => {+ if (running) {+ closeDomRefMenu();+ }+ }+);</script><template>@@ -476,14 +666,48 @@ watch(</div><div v-else class="flex items-end gap-x-2">- <textarea- v-model="input"- rows="1"- :placeholder="inputPlaceholder"- class="flex-1 resize-none rounded-md border px-3 py-2 text-sm focus:outline-none focus:ring-1 focus:ring-blue-500 disabled:bg-gray-50"- :disabled="agentStore.hasRunningThread"- @keydown.enter.exact.prevent="send"- />+ <div class="relative min-w-0 flex-1">+ <textarea+ ref="inputRef"+ v-model="input"+ rows="1"+ :placeholder="inputPlaceholder"+ class="block w-full resize-none rounded-md border px-3 py-2 text-sm focus:outline-none focus:ring-1 focus:ring-blue-500 disabled:bg-gray-50"+ :disabled="agentStore.hasRunningThread"+ @click="updateSelection"+ @blur="closeDomRefMenu"+ @input="updateSelection"+ @keyup="updateSelection"+ @select="updateSelection"+ @keydown.exact="handleTextareaKeydown"+ />+ <div+ v-if="isDomRefMenuOpen"+ data-testid="dom-ref-autocomplete"+ class="absolute bottom-full left-0 z-10 mb-2 w-full overflow-hidden rounded-md border bg-white shadow-lg"+ >+ <button+ v-for="(suggestion, index) in filteredDomRefSuggestions"+ :key="suggestion.ref"+ type="button"+ data-testid="dom-ref-autocomplete-item"+ class="flex w-full flex-col px-3 py-2 text-left text-sm hover:bg-gray-50"+ :class="index === activeDomRefIndex ? 'bg-blue-50' : 'bg-white'"+ @mousedown.prevent="selectDomRefSuggestion(suggestion)"+ >+ <div class="flex items-center gap-x-2 text-gray-800">+ <span class="font-medium">[{{ suggestion.ref }}]</span>+ <span class="truncate">{{ suggestion.label }}</span>+ </div>+ <div+ v-if="formatDomRefSuggestionMeta(suggestion)"+ class="mt-1 text-xs text-gray-500"+ >+ {{ formatDomRefSuggestionMeta(suggestion) }}+ </div>+ </button>+ </div>+ </div><buttonv-if="agentStore.loading"class="rounded-md bg-red-500 px-3 py-2 text-sm text-white hover:bg-red-600"diff --git a/frontend/src/plugins/agent/dom/actions.ts b/frontend/src/plugins/agent/dom/actions.tsindex a5a09f766f..998d3544c7 100644--- a/frontend/src/plugins/agent/dom/actions.ts+++ b/frontend/src/plugins/agent/dom/actions.ts@@ -1,10 +1,15 @@-export { extractDomTree, getElementByIndex } from "./domTree";+export type { DomRefSuggestion } from "./domTree";+export {+ extractDomRefSuggestions,+ extractDomTree,+ getElementByRef,+} from "./domTree";export type DomActionType = "click" | "input" | "select" | "scroll" | "read";export interface DomActionParams {type: DomActionType;- index: number;+ ref: string;value?: string;}@@ -73,9 +78,20 @@ function findInnerInput();}+function isMonacoCandidate(el: Element): boolean {+ return (+ el.classList.contains("monaco-editor") ||+ el.closest(".monaco-editor") !== null+ );+}+async function findMonacoEditor(el: Element): Promise<{ getValue(): string; setValue(v: string): void } | null> {+ if (!isMonacoCandidate(el)) {+ return null;+ }+try {const { isMonacoLoaded, getMonacoEditor } = await import("@/components/MonacoEditor/lazy-editor"diff --git a/frontend/src/plugins/agent/dom/domTree.test.ts b/frontend/src/plugins/agent/dom/domTree.test.tsnew file mode 100644index 0000000000..9f9a7f4e1b--- /dev/null+++ b/frontend/src/plugins/agent/dom/domTree.test.ts@@ -0,0 +1,104 @@+import { afterEach, describe, expect, test } from "vitest";+import {+ extractDomRefSuggestions,+ extractDomTree,+ getElementByRef,+} from "./domTree";++afterEach(() => {+ document.body.innerHTML = "";+});++describe("extractDomTree", () => {+ test("emits eN refs for interactive elements and Monaco editors", () => {+ document.body.innerHTML = `+ <main>+ <button aria-label="Run query">Run</button>+ <input placeholder="Project name" value="Test Project" />+ <div class="monaco-editor">+ <div class="view-lines">+ <div class="view-line">SELECT *</div>+ <div class="view-line">FROM projects;</div>+ </div>+ </div>+ </main>+ `;++ const { tree, count } = extractDomTree();++ expect(count).toBe(3);+ expect(tree).toContain("[e1]<button>Run query</button>");+ expect(tree).toContain(+ '[e2]<input value="Test Project">Project name</input>'+ );+ expect(tree).toContain(+ "[e3]<editor>SQL: SELECT *\nFROM projects;</editor>"+ );+ expect(getElementByRef("e1")?.tag).toBe("button");+ expect(getElementByRef("e3")?.tag).toBe("editor");+ expect(getElementByRef("e9")).toBeUndefined();+ });++ test("returns structured DOM ref suggestions for visible interactive elements", () => {+ document.body.innerHTML = `+ <main>+ <button aria-label="Run query">Run</button>+ <div role="button" aria-labelledby="publish-label">Publish now</div>+ <span id="publish-label">Publish</span>+ <input placeholder="Project name" value="Test Project" />+ <div class="monaco-editor">+ <div class="view-lines">+ <div class="view-line">SELECT *</div>+ <div class="view-line">FROM projects;</div>+ </div>+ </div>+ <button style="display: none">Hidden</button>+ </main>+ `;++ expect(extractDomRefSuggestions()).toEqual([+ {+ ref: "e1",+ tag: "button",+ role: undefined,+ label: "Run query",+ value: undefined,+ },+ {+ ref: "e2",+ tag: "div",+ role: "button",+ label: "Publish",+ value: undefined,+ },+ {+ ref: "e3",+ tag: "input",+ role: undefined,+ label: "Project name",+ value: "Test Project",+ },+ {+ ref: "e4",+ tag: "editor",+ role: undefined,+ label: "SQL: SELECT *\nFROM projects;",+ value: "SELECT *\nFROM projects;",+ },+ ]);++ expect(getElementByRef("e2")?.label).toBe("Publish");+ });++ test("resets refs on each extraction", () => {+ document.body.innerHTML = `<button>First</button>`;+ expect(extractDomTree().tree).toContain("[e1]<button>First</button>");++ document.body.innerHTML = `<button>Second</button>`;+ const { tree, count } = extractDomTree();++ expect(count).toBe(1);+ expect(tree).toContain("[e1]<button>Second</button>");+ expect(tree).not.toContain("[e2]");+ });+});diff --git a/frontend/src/plugins/agent/dom/domTree.ts b/frontend/src/plugins/agent/dom/domTree.tsindex 4a137a11a1..a94ffa56f0 100644--- a/frontend/src/plugins/agent/dom/domTree.ts+++ b/frontend/src/plugins/agent/dom/domTree.ts@@ -1,9 +1,12 @@-export interface IndexedElement {- index: number;+export interface DomRefSuggestion {+ ref: string;tag: string;role?: string;label: string;value?: string;+}++export interface IndexedElement extends DomRefSuggestion {element: Element;}@@ -62,10 +65,21 @@ function isLandmark(el: Element): boolean {return false;}-let elementRegistry: IndexedElement[] = [];+const elementRegistry = new Map<string, IndexedElement>();+let nextElementRef = 1;++function createElementRef(): string {+ return `e${nextElementRef++}`;+}++function registerElement(entry: Omit<IndexedElement, "ref">): IndexedElement {+ const registered = { ref: createElementRef(), ...entry };+ elementRegistry.set(registered.ref, registered);+ return registered;+}-export function getElementByIndex(index: number): IndexedElement | undefined {- return elementRegistry[index];+export function getElementByRef(ref: string): IndexedElement | undefined {+ return elementRegistry.get(ref);}function isVisible(el: Element): boolean {@@ -178,6 +192,22 @@ function extractValue(el: Element): string | undefined {return undefined;}+function toDomRefSuggestion({+ ref,+ tag,+ role,+ label,+ value,+}: IndexedElement): DomRefSuggestion {+ return {+ ref,+ tag,+ role,+ label,+ value,+ };+}+function walkDom(node: Element, depth: number, lines: string[]): void {if (SKIP_TAGS.has(node.tagName)) return;if (node.hasAttribute("data-agent-window")) return;@@ -185,14 +215,11 @@ function walkDom(node: Element, depth: number, lines: string[]): void {// Monaco editor — register as a single interactive elementif (isMonacoEditor(node)) {- const index = elementRegistry.length;const content = getMonacoContent(node) ?? "";const preview =content.length > 200 ? content.slice(0, 200) + "..." : content;const label = content ? `SQL: ${preview}` : "empty editor";-- elementRegistry.push({- index,+ const entry = registerElement({tag: "editor",label,value: content,@@ -200,22 +227,20 @@ function walkDom(node: Element, depth: number, lines: string[]): void {});const indent = " ".repeat(depth);- lines.push(`${indent}[${index}]<editor>${label}</editor>`);+ lines.push(`${indent}[${entry.ref}]<editor>${label}</editor>`);return;}if (isInteractive(node)) {- const index = elementRegistry.length;const tag = node.tagName.toLowerCase();const label = extractLabel(node);const value = extractValue(node);const role = node.getAttribute("role") ?? undefined;-- elementRegistry.push({ index, tag, role, label, value, element: node });+ const entry = registerElement({ tag, role, label, value, element: node });const indent = " ".repeat(depth);const valueAttr = value ? ` value="${value}"` : "";- lines.push(`${indent}[${index}]<${tag}${valueAttr}>${label}</${tag}>`);+ lines.push(`${indent}[${entry.ref}]<${tag}${valueAttr}>${label}</${tag}>`);// Don't recurse into interactive elementsreturn;@@ -228,11 +253,13 @@ function walkDom(node: Element, depth: number, lines: string[]): void {}}-export function extractDomTree(root?: Element): {+function extractDomState(root?: Element): {tree: string;count: number;+ refs: DomRefSuggestion[];} {- elementRegistry = [];+ elementRegistry.clear();+ nextElementRef = 1;const lines: string[] = [];const rootEl = root ?? document.body;@@ -242,6 +269,19 @@ export function extractDomTree(root?: Element): {return {tree: lines.join("\n"),- count: elementRegistry.length,+ count: elementRegistry.size,+ refs: Array.from(elementRegistry.values(), toDomRefSuggestion),};}++export function extractDomTree(root?: Element): {+ tree: string;+ count: number;+} {+ const { tree, count } = extractDomState(root);+ return { tree, count };+}++export function extractDomRefSuggestions(root?: Element): DomRefSuggestion[] {+ return extractDomState(root).refs;+}diff --git a/frontend/src/plugins/agent/dom/index.test.ts b/frontend/src/plugins/agent/dom/index.test.tsnew file mode 100644index 0000000000..590e51b41c--- /dev/null+++ b/frontend/src/plugins/agent/dom/index.test.ts@@ -0,0 +1,103 @@+import { afterEach, describe, expect, test, vi } from "vitest";+import type { Router } from "vue-router";+import {+ lazyExecuteDomAction,+ lazyExtractDomRefSuggestions,+ lazyExtractDomTree,+} from "./index";++afterEach(() => {+ document.body.innerHTML = "";+ vi.restoreAllMocks();+});++describe("lazyExtractDomRefSuggestions", () => {+ test("returns structured suggestions from the shared DOM registry", async () => {+ document.body.innerHTML = `<button aria-label="Run query">Run</button>`;++ await expect(lazyExtractDomRefSuggestions()).resolves.toEqual([+ {+ ref: "e1",+ tag: "button",+ role: undefined,+ label: "Run query",+ value: undefined,+ },+ ]);++ await expect(+ lazyExecuteDomAction({ type: "read", ref: "e1" })+ ).resolves.toEqual({ success: true, message: "Run" });+ });+});++describe("lazyExecuteDomAction", () => {+ test("looks up actions by ref", async () => {+ document.body.innerHTML = `<input value="hello" />`;+ await lazyExtractDomTree();++ const result = await lazyExecuteDomAction({ type: "read", ref: "e1" });++ expect(result).toEqual({ success: true, message: "hello" });+ });++ test("returns refresh guidance for malformed, missing, and stale refs", async () => {+ document.body.innerHTML = `<button>Save</button>`;+ await lazyExtractDomTree();++ await expect(+ lazyExecuteDomAction({ type: "click", ref: 1 } as never)+ ).resolves.toEqual({+ success: false,+ message:+ 'Invalid element ref: 1. Use refs like [e1] from the DOM tree. Run get_page_state(mode="dom") to refresh the DOM tree.',+ });++ await expect(+ lazyExecuteDomAction({ type: "click", ref: "1" })+ ).resolves.toEqual({+ success: false,+ message:+ 'Malformed element ref [1]. Use refs like [e1] from the DOM tree. Run get_page_state(mode="dom") to refresh the DOM tree.',+ });++ await expect(+ lazyExecuteDomAction({ type: "click", ref: "e9" })+ ).resolves.toEqual({+ success: false,+ message:+ 'Element [e9] was not found. Run get_page_state(mode="dom") to refresh the DOM tree.',+ });++ document.querySelector("button")?.remove();+ await expect(+ lazyExecuteDomAction({ type: "click", ref: "e1" })+ ).resolves.toEqual({+ success: false,+ message:+ 'Element [e1] is stale. Run get_page_state(mode="dom") to refresh the DOM tree.',+ });+ });++ test("uses vue router for same-origin link clicks", async () => {+ window.history.pushState({}, "", "/current");+ document.body.innerHTML =+ '<a href="/settings?tab=general#profile">Settings</a>';+ await lazyExtractDomTree();++ const router = {+ push: vi.fn().mockResolvedValue(undefined),+ } as unknown as Router;++ const result = await lazyExecuteDomAction(+ { type: "click", ref: "e1" },+ router+ );++ expect(router.push).toHaveBeenCalledWith("/settings?tab=general#profile");+ expect(result).toEqual({+ success: true,+ message: "Navigated to /settings?tab=general#profile",+ });+ });+});diff --git a/frontend/src/plugins/agent/dom/index.ts b/frontend/src/plugins/agent/dom/index.tsindex ee5e17377d..8aed96d48d 100644--- a/frontend/src/plugins/agent/dom/index.ts+++ b/frontend/src/plugins/agent/dom/index.ts@@ -1,9 +1,13 @@import type { Router } from "vue-router";-import type { DomActionParams, DomActionResult } from "./actions";+import type {+ DomActionParams,+ DomActionResult,+ DomRefSuggestion,+} from "./actions";// Single dynamic import path. actions.ts re-exports extractDomTree and-// getElementByIndex from domTree.ts, ensuring one module instance so the-// element registry populated by extractDomTree is readable by getElementByIndex.+// getElementByRef from domTree.ts, ensuring one module instance so the+// element registry populated by extractDomTree is readable by getElementByRef.let module: typeof import("./actions") | undefined;async function ensureLoaded(): Promise<typeof import("./actions")> {@@ -20,6 +24,13 @@ export async function lazyExtractDomTree(): Promise<{return m.extractDomTree();}+export async function lazyExtractDomRefSuggestions(): Promise<+ import("./actions").DomRefSuggestion[]+> {+ const m = await ensureLoaded();+ return m.extractDomRefSuggestions();+}+function isSameOriginLink(el: Element): string | undefined {if (!(el instanceof HTMLAnchorElement)) return undefined;const href = el.getAttribute("href");@@ -28,25 +39,49 @@ function isSameOriginLink(el: Element): string | undefined {if (href.startsWith("/")) return href;try {const url = new URL(href);- if (url.origin === window.location.origin)+ if (url.origin === window.location.origin) {return url.pathname + url.search + url.hash;+ }} catch {// Not a valid URL}return undefined;}+function formatRefreshError(message: string): DomActionResult {+ return {+ success: false,+ message: `${message} Run get_page_state(mode="dom") to refresh the DOM tree.`,+ };+}++function getElementRef(params: DomActionParams): string | undefined {+ return typeof params.ref === "string" ? params.ref.trim() : undefined;+}+export async function lazyExecuteDomAction(params: DomActionParams,router?: Router): Promise<DomActionResult> {+ const elementRef = getElementRef(params);+ if (!elementRef) {+ return formatRefreshError(+ `Invalid element ref: ${JSON.stringify(params.ref)}. Use refs like [e1] from the DOM tree.`+ );+ }+ if (!/^e\d+$/.test(elementRef)) {+ return formatRefreshError(+ `Malformed element ref [${elementRef}]. Use refs like [e1] from the DOM tree.`+ );+ }+const m = await ensureLoaded();- const entry = m.getElementByIndex(params.index);+ const entry = m.getElementByRef(elementRef);if (!entry) {- return {- success: false,- message: `Element [${params.index}] not found. Run get_page_state(mode="dom") to refresh the DOM tree.`,- };+ return formatRefreshError(`Element [${elementRef}] was not found.`);+ }+ if (!entry.element.isConnected) {+ return formatRefreshError(`Element [${elementRef}] is stale.`);}// For <a> clicks, use Vue Router to avoid full page reload@@ -64,4 +99,4 @@ export async function lazyExecuteDomAction(return m.executeDomAction(params, entry.element);}-export type { DomActionParams, DomActionResult };+export type { DomActionParams, DomActionResult, DomRefSuggestion };diff --git a/frontend/src/plugins/agent/logic/agentLoop.test.ts b/frontend/src/plugins/agent/logic/agentLoop.test.tsindex 8b12f0b5fc..1635e46c8f 100644--- a/frontend/src/plugins/agent/logic/agentLoop.test.ts+++ b/frontend/src/plugins/agent/logic/agentLoop.test.ts@@ -53,7 +53,6 @@ describe("runAgentLoop", () => {kind: "completed",text: "Finished successfully",success: true,- explicit: true,totalTokensUsed: 0,});expect(onToolResult).toHaveBeenCalledWith(@@ -98,17 +97,36 @@ describe("runAgentLoop", () => {},} as never).mockResolvedValueOnce({- content: "Final answer",- toolCalls: [],+ content: "",+ toolCalls: [+ {+ id: "tool-2",+ name: "done",+ arguments: JSON.stringify({+ text: "Final answer",+ success: true,+ }),+ metadata: "",+ },+ ],usage: {totalTokens: 7,},} as never);- const executeTool: ToolExecutor = vi.fn(async () => ({- kind: "tool_result" as const,- result: JSON.stringify({ ok: true }),- }));+ const executeTool: ToolExecutor = vi.fn(async (name, args) => {+ if (name === "done") {+ return {+ kind: "done" as const,+ text: String(args.text),+ success: args.success !== false,+ };+ }+ return {+ kind: "tool_result" as const,+ result: JSON.stringify({ ok: true }),+ };+ });const outcome = await runAgentLoop([{ role: "system", content: "system" }],@@ -120,7 +138,6 @@ describe("runAgentLoop", () => {kind: "completed",text: "Final answer",success: true,- explicit: false,totalTokensUsed: 18,});});@@ -219,7 +236,7 @@ describe("runAgentLoop", () => {]));});- test("keeps plain assistant text as a compatibility fallback", async () => {+ test("returns an error when the assistant replies with plain text instead of done", async () => {vi.mocked(aiServiceClientConnect.chat).mockResolvedValue({content: "Here is the answer",toolCalls: [],@@ -227,22 +244,25 @@ describe("runAgentLoop", () => {const executeTool: ToolExecutor = vi.fn();const onText = vi.fn();+ const onError = vi.fn();const outcome = await runAgentLoop([{ role: "system", content: "system" }],[],executeTool,- { onText }+ { onText, onError });- expect(outcome).toEqual({- kind: "completed",- text: "Here is the answer",- success: true,- explicit: false,- totalTokensUsed: 0,- });- expect(onText).toHaveBeenCalledWith("Here is the answer");+ expect(outcome.kind).toBe("error");+ if (outcome.kind !== "error") {+ throw new Error(`Expected error outcome, got ${outcome.kind}`);+ }+ expect(outcome.error.message).toBe(+ "Agent must finish with done({ text, success }) or ask_user(...), not plain assistant text."+ );+ expect(outcome.totalTokensUsed).toBe(0);+ expect(onError).toHaveBeenCalledWith(outcome.error);+ expect(onText).not.toHaveBeenCalled();expect(executeTool).not.toHaveBeenCalled();});@@ -431,7 +451,6 @@ describe("runAgentLoop", () => {kind: "completed",text: "Finished successfully",success: true,- explicit: true,totalTokensUsed: 0,});expect(executeTool).toHaveBeenCalledTimes(1);diff --git a/frontend/src/plugins/agent/logic/agentLoop.ts b/frontend/src/plugins/agent/logic/agentLoop.tsindex d3d15379e9..97ecf9b839 100644--- a/frontend/src/plugins/agent/logic/agentLoop.ts+++ b/frontend/src/plugins/agent/logic/agentLoop.ts@@ -234,7 +234,6 @@ export async function runAgentLoop(kind: "completed",text: executionResult.text,success: executionResult.success,- explicit: true,totalTokensUsed,},blockedBy: {@@ -254,13 +253,13 @@ export async function runAgentLoop(continue;}- const text = response.content ?? "";- callbacks?.onText?.(text);+ const error = new Error(+ "Agent must finish with done({ text, success }) or ask_user(...), not plain assistant text."+ );+ callbacks?.onError?.(error);return {- kind: "completed",- text,- success: true,- explicit: false,+ kind: "error",+ error,totalTokensUsed,};}diff --git a/frontend/src/plugins/agent/logic/prompt.test.ts b/frontend/src/plugins/agent/logic/prompt.test.tsnew file mode 100644index 0000000000..f3e0e7e981--- /dev/null+++ b/frontend/src/plugins/agent/logic/prompt.test.ts@@ -0,0 +1,18 @@+import { describe, expect, test } from "vitest";+import { buildSystemPrompt } from "./prompt";++describe("buildSystemPrompt", () => {+ test("teaches the ref-based DOM workflow", () => {+ const prompt = buildSystemPrompt({+ path: "/issues/123",+ title: "Issue 123",+ role: "DBA",+ });++ expect(prompt).toContain(+ 'DOM interaction workflow: get_page_state(mode="dom") → read element refs like [e1] in the DOM tree → dom_action(type, ref, value).'+ );+ expect(prompt).not.toContain("read element indices");+ expect(prompt).not.toContain("dom_action(type, index, value)");+ });+});diff --git a/frontend/src/plugins/agent/logic/prompt.ts b/frontend/src/plugins/agent/logic/prompt.tsindex 005a0654fc..b62b064cbb 100644--- a/frontend/src/plugins/agent/logic/prompt.ts+++ b/frontend/src/plugins/agent/logic/prompt.ts@@ -65,7 +65,7 @@ Rules:- Use get_skill to load step-by-step workflow guides before multi-step tasks (SQL queries, schema changes, permission grants).- Always confirm destructive actions before executing them. When you need confirmation or missing input from the user, call ask_user instead of guessing.- Use ask_user(kind="input") for free-form answers, ask_user(kind="confirm") for confirm/cancel decisions, and ask_user(kind="choose") when the user must pick from explicit options.-- Call done({ text, success }) when you are ready to finish. Plain assistant text without done is allowed only as a fallback.+- Call done({ text, success }) when you are ready to finish. Do not reply with plain assistant text.- Do not call ask_user and done in the same response.Tool selection — choose based on context, not a fixed preference:@@ -73,7 +73,7 @@ Tool selection — choose based on context, not a fixed preference:- API-first when fetching data not visible on the current page, querying across resources, or performing bulk operations on persisted resources.- Either works for mutations on persisted resources. Use DOM if the user is already on the relevant page and would benefit from seeing the interaction. Use API for speed or when the relevant page is not open.-DOM interaction workflow: get_page_state(mode="dom") → read element indices → dom_action(type, index, value).+DOM interaction workflow: get_page_state(mode="dom") → read element refs like [e1] in the DOM tree → dom_action(type, ref, value).API interaction workflow: Use the API Directory below to choose the right service first. Browse with search_api(service="..."), inspect the exact endpoint with search_api(operationId="..."), then call call_api(...). Do not guess operationIds or request body fields.${serviceDirectory}diff --git a/frontend/src/plugins/agent/logic/tools/domAction.test.ts b/frontend/src/plugins/agent/logic/tools/domAction.test.tsnew file mode 100644index 0000000000..1f25ad5db0--- /dev/null+++ b/frontend/src/plugins/agent/logic/tools/domAction.test.ts@@ -0,0 +1,24 @@+import { describe, expect, test, vi } from "vitest";+import type { Router } from "vue-router";++vi.mock("../../dom", () => ({+ lazyExecuteDomAction: vi.fn(async () => ({ success: true, message: "done" })),+}));++import { lazyExecuteDomAction } from "../../dom";+import { createDomActionTool } from "./domAction";++describe("createDomActionTool", () => {+ test("forwards read actions with ref-based args", async () => {+ const router = { push: vi.fn() } as unknown as Router;+ const tool = createDomActionTool(router);++ const result = await tool({ type: "read", ref: "e3" });++ expect(lazyExecuteDomAction).toHaveBeenCalledWith(+ { type: "read", ref: "e3" },+ router+ );+ expect(result).toBe(JSON.stringify({ success: true, message: "done" }));+ });+});diff --git a/frontend/src/plugins/agent/logic/tools/domAction.ts b/frontend/src/plugins/agent/logic/tools/domAction.tsindex 87be421e6e..d8d044712d 100644--- a/frontend/src/plugins/agent/logic/tools/domAction.ts+++ b/frontend/src/plugins/agent/logic/tools/domAction.ts@@ -2,8 +2,8 @@ import type { Router } from "vue-router";import { lazyExecuteDomAction } from "../../dom";export interface DomActionArgs {- type: "click" | "input" | "select" | "scroll";- index: number;+ type: "click" | "input" | "select" | "read" | "scroll";+ ref: string;value?: string;}diff --git a/frontend/src/plugins/agent/logic/tools/index.test.ts b/frontend/src/plugins/agent/logic/tools/index.test.tsindex c0b789ceee..dc85c89af5 100644--- a/frontend/src/plugins/agent/logic/tools/index.test.ts+++ b/frontend/src/plugins/agent/logic/tools/index.test.ts@@ -54,6 +54,61 @@ describe("agent tools navigate", () => {});});+describe("agent tools get_page_state", () => {+ test("describes a ref-labeled DOM tree", () => {+ const pageState = getToolDefinitions().find(+ (tool) => tool.name === "get_page_state"+ );++ expect(pageState).toBeDefined();+ expect(pageState?.description).toContain("ref-labeled DOM tree");+ expect(pageState?.description).toContain("element refs like [e1]");+ expect(pageState?.description).not.toContain("element indices");+ expect(pageState?.parametersSchema).toEqual(+ expect.objectContaining({+ properties: expect.objectContaining({+ mode: expect.objectContaining({+ description: expect.stringContaining("ref-labeled tree"),+ }),+ }),+ })+ );+ });+});++describe("agent tools dom_action", () => {+ test("exposes ref-based dom_action schema", () => {+ const domAction = getToolDefinitions().find(+ (tool) => tool.name === "dom_action"+ );++ expect(domAction).toBeDefined();+ expect(domAction?.description).toContain(+ '**Always call get_page_state(mode="dom") first** to get the element ref, such as [e1].'+ );+ expect(domAction?.parametersSchema).toEqual(+ expect.objectContaining({+ properties: expect.objectContaining({+ type: expect.objectContaining({+ enum: ["click", "input", "select", "read", "scroll"],+ }),+ ref: expect.objectContaining({+ type: "string",+ }),+ }),+ required: ["type", "ref"],+ })+ );+ expect(domAction?.parametersSchema).not.toEqual(+ expect.objectContaining({+ properties: expect.objectContaining({+ index: expect.anything(),+ }),+ })+ );+ });+});+describe("agent tools ask_user", () => {test("exposes choose in the ask_user schema", () => {const askUser = getToolDefinitions().find(diff --git a/frontend/src/plugins/agent/logic/tools/index.ts b/frontend/src/plugins/agent/logic/tools/index.tsindex ae69398a07..099ddd61ae 100644--- a/frontend/src/plugins/agent/logic/tools/index.ts+++ b/frontend/src/plugins/agent/logic/tools/index.ts@@ -214,9 +214,9 @@ call_api(operationId="SQLService/Query", body={"name": "instances/i/databases/db| Mode | Result ||------|--------|| semantic (default) | Route path, params, title + context from Pinia stores (project, database, issue, user info when available) |-| dom | Above + indexed DOM tree of interactive elements |+| dom | Above + ref-labeled DOM tree of interactive elements |-Use mode="dom" before dom_action to get element indices. Use semantic mode (default) to understand the current page context.`,+Use mode="dom" before dom_action to get element refs like [e1]. Use semantic mode (default) to understand the current page context.`,parametersSchema: {type: "object",properties: {@@ -224,7 +224,7 @@ Use mode="dom" before dom_action to get element indices. Use semantic mode (defatype: "string",enum: ["semantic", "dom"],description:- 'Default "semantic" returns route info + store context. "dom" adds an indexed tree of interactive elements for use with dom_action.',+ 'Default "semantic" returns route info + store context. "dom" adds a ref-labeled tree of interactive elements for use with dom_action.',},},},@@ -232,7 +232,7 @@ Use mode="dom" before dom_action to get element indices. Use semantic mode (defa{name: "dom_action",description: `Last-resort DOM interaction — use only when no API endpoint covers the action.-**Always call get_page_state(mode="dom") first** to get the element index.+**Always call get_page_state(mode="dom") first** to get the element ref, such as [e1].| Action | When to use | value param ||--------|-------------|-------------|@@ -249,17 +249,17 @@ Use mode="dom" before dom_action to get element indices. Use semantic mode (defaenum: ["click", "input", "select", "read", "scroll"],description: "The action to perform",},- index: {- type: "number",+ ref: {+ type: "string",description:- "Element index from DOM tree (from get_page_state with mode='dom')",+ "Element ref from DOM tree (from get_page_state with mode='dom'), such as 'e1'",},value: {type: "string",description: "Value for input/select actions",},},- required: ["type", "index"],+ required: ["type", "ref"],},},{diff --git a/frontend/src/plugins/agent/logic/tools/pageState.test.ts b/frontend/src/plugins/agent/logic/tools/pageState.test.tsnew file mode 100644index 0000000000..3ca017877a--- /dev/null+++ b/frontend/src/plugins/agent/logic/tools/pageState.test.ts@@ -0,0 +1,87 @@+import { describe, expect, test, vi } from "vitest";+import type { Router } from "vue-router";++vi.mock("../../dom", () => ({+ lazyExtractDomTree: vi.fn(async () => ({+ count: 2,+ tree: ['[e1] button "Create"', '[e2] textbox "Name"'],+ })),+}));++vi.mock("../context", () => ({+ extractRouteContext: vi.fn(async () => ({+ project: {+ name: "projects/demo",+ },+ })),+}));++import { createPageStateTool } from "./pageState";++describe("createPageStateTool", () => {+ test("returns semantic state by default", async () => {+ const router = {+ currentRoute: {+ value: {+ fullPath: "/projects/demo",+ name: "project",+ params: { projectId: "demo" },+ query: { view: "overview" },+ },+ },+ } as unknown as Router;++ document.title = "Project Demo";++ const tool = createPageStateTool(router);+ const result = JSON.parse(await tool());++ expect(result).toEqual({+ path: "/projects/demo",+ name: "project",+ params: { projectId: "demo" },+ query: { view: "overview" },+ title: "Project Demo",+ context: {+ project: {+ name: "projects/demo",+ },+ },+ });+ expect(result).not.toHaveProperty("domTree");+ expect(result).not.toHaveProperty("interactiveElements");+ });++ test("returns DOM state with ref-labeled tree when requested", async () => {+ const router = {+ currentRoute: {+ value: {+ fullPath: "/projects/demo/issues/123",+ name: "issue",+ params: { projectId: "demo", issueId: "123" },+ query: {},+ },+ },+ } as unknown as Router;++ document.title = "Issue 123";++ const tool = createPageStateTool(router);+ const result = JSON.parse(await tool({ mode: "dom" }));++ expect(result).toEqual({+ path: "/projects/demo/issues/123",+ name: "issue",+ params: { projectId: "demo", issueId: "123" },+ query: {},+ title: "Issue 123",+ context: {+ project: {+ name: "projects/demo",+ },+ },+ interactiveElements: 2,+ domTree: ['[e1] button "Create"', '[e2] textbox "Name"'],+ });+ });+});diff --git a/frontend/src/plugins/agent/logic/types.ts b/frontend/src/plugins/agent/logic/types.tsindex 6e44dc716d..9991a58948 100644--- a/frontend/src/plugins/agent/logic/types.ts+++ b/frontend/src/plugins/agent/logic/types.ts@@ -111,7 +111,6 @@ export type AgentLoopOutcome =kind: "completed";text: string;success: boolean;- explicit: boolean;} & AgentLoopUsage)| ({kind: "awaiting_user";diff --git a/frontend/src/plugins/agent/store/agent.test.ts b/frontend/src/plugins/agent/store/agent.test.tsindex 60ce94e72a..a689d23b13 100644--- a/frontend/src/plugins/agent/store/agent.test.ts+++ b/frontend/src/plugins/agent/store/agent.test.ts@@ -1,11 +1,7 @@import { createPinia, setActivePinia } from "pinia";import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";import { nextTick } from "vue";-import {- AGENT_STATE_KEY,- LEGACY_AGENT_MESSAGES_KEY,- useAgentStore,-} from "./agent";+import { AGENT_STATE_KEY, AGENT_WINDOW_KEY, useAgentStore } from "./agent";function createMockStorage(): Storage {let store: Record<string, string> = {};@@ -57,25 +53,22 @@ describe("useAgentStore", () => {expect(store.threads[0].totalTokensUsed).toBe(0);});- test("migrates legacy flat messages into a thread-aware state", () => {+ test("loads persisted window state", () => {localStorage.setItem(- LEGACY_AGENT_MESSAGES_KEY,- JSON.stringify([- { role: "user", content: "Help me inspect this page" },- { role: "assistant", content: "Sure" },- ])+ AGENT_WINDOW_KEY,+ JSON.stringify({+ position: { x: 120, y: 240 },+ size: { width: 480, height: 640 },+ }));const store = createStore();+ store.loadWindowState();- expect(store.threads).toHaveLength(1);- expect(store.currentThreadId).toBe(store.threads[0].id);- expect(store.messages).toHaveLength(2);- expect(store.messages[0].id).toBeTruthy();- expect(store.messages[0].threadId).toBe(store.currentThreadId);- expect(store.messages[0].createdTs).toBeTypeOf("number");- expect(store.threads[0].title).toContain("Help me inspect this page");- expect(localStorage.getItem(LEGACY_AGENT_MESSAGES_KEY)).toBeNull();+ expect(store.position).toEqual({ x: 120, y: 240 });+ expect(store.size).toEqual({ width: 480, height: 640 });+ expect(localStorage.getItem(AGENT_WINDOW_KEY)).toContain('"width":480');+ expect(localStorage.getItem(AGENT_STATE_KEY)).toBeNull();});test("normalizes stale running threads on load", () => {diff --git a/frontend/src/plugins/agent/store/agent.ts b/frontend/src/plugins/agent/store/agent.tsindex ec2e2d6086..4198ac54bc 100644--- a/frontend/src/plugins/agent/store/agent.ts+++ b/frontend/src/plugins/agent/store/agent.ts@@ -13,9 +13,8 @@ import type {ToolCall,} from "../logic/types";-export const AGENT_STATE_KEY = "bb-agent-state";+export const AGENT_STATE_KEY = "bb-agent-state-v2";export const AGENT_WINDOW_KEY = "bb-agent-window";-export const LEGACY_AGENT_MESSAGES_KEY = "bb-agent-messages";interface PersistedAgentState {currentThreadId: string | null;@@ -206,30 +205,6 @@ const sortMessages = (messages: AgentMessage[]) => {return messages;};-const migrateLegacyState = (legacyMessages: unknown[]): PersistedAgentState => {- const thread = createThreadRecord();- const startTs = Date.now();- const messages = sortMessages(- legacyMessages.map((message, index) =>- normalizeMessage(message, thread.id, startTs + index)- )- );- const firstUserMessage = messages.find((message) => message.role === "user");- const lastMessage = messages.at(-1);- thread.title = getThreadTitleFromMessage(firstUserMessage?.content);- if (lastMessage) {- thread.updatedTs = lastMessage.createdTs;- }- return {- currentThreadId: thread.id,- threads: [thread],- messagesByThreadId: {- [thread.id]: messages,- },- pendingAskByThreadId: {},- };-};-const normalizePersistedState = (raw: unknown): PersistedAgentState => {if (!isRecord(raw)) {return {@@ -675,23 +650,6 @@ export const useAgentStore = defineStore("agent", () => {} catch {localStorage.removeItem(AGENT_STATE_KEY);}- } else {- const legacySaved = localStorage.getItem(LEGACY_AGENT_MESSAGES_KEY);- if (legacySaved) {- try {- const parsed = JSON.parse(legacySaved);- if (Array.isArray(parsed)) {- const state = migrateLegacyState(parsed);- threads.value = state.threads;- messagesByThreadId.value = state.messagesByThreadId;- pendingAskByThreadId.value = state.pendingAskByThreadId;- currentThreadId.value = state.currentThreadId;- }- } catch {- localStorage.removeItem(LEGACY_AGENT_MESSAGES_KEY);- }- localStorage.removeItem(LEGACY_AGENT_MESSAGES_KEY);- }}if (!currentThreadId.value || !getThread(currentThreadId.value)) {