@cairnvibe/sdk 0.2.7 → 0.2.8

package/dist/index.js

@@ -6,9 +6,11 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const navigation_1 = require("next/navigation");
 const lucide_react_1 = require("lucide-react");
+const core_1 = require("@cairnvibe/core");
 const context_collector_1 = require("./context-collector");
 const element_ladder_1 = require("./element-ladder");
 const runtime_scan_1 = require("./runtime-scan");
+const webmcp_client_1 = require("./webmcp-client");
 const verb_executor_1 = require("./verb-executor");
 function Copilot({ endpoint = "/api/copilot", registeredActions = [], onDo, reportMissesEndpoint, transcribeEndpoint, speakEndpoint, realtimeUrl, persona = "Cairn", }) {
     const pathname = (0, navigation_1.usePathname)() ?? "/";
@@ -20,7 +22,7 @@ function Copilot({ endpoint = "/api/copilot", registeredActions = [], onDo, repo
     const pathnameRef = (0, react_1.useRef)(pathname);
     (0, react_1.useEffect)(() => {
         pathnameRef.current = pathname;
-        sendFreshContext(); // no-op if no realtime session is open
+        void sendFreshContext(); // no-op if no realtime session is open
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [pathname]);
     const router = (0, navigation_1.useRouter)();
@@ -194,13 +196,22 @@ function Copilot({ endpoint = "/api/copilot", registeredActions = [], onDo, repo
      * `pathname`, so it's correct even called from a handler created once at
      * connection-open time.
      */
-    function sendFreshContext() {
+    async function sendFreshContext() {
         const ws = rtSocketRef.current;
         if (!ws || ws.readyState !== WebSocket.OPEN)
             return;
         const liveScan = liveRegistryRef.current.getSnapshot();
         liveMapRef.current = liveScan.byId;
-        ws.send(JSON.stringify({ type: "context", route: pathnameRef.current, visible: (0, context_collector_1.collectVisible)(), liveElements: liveScan.elements }));
+        const webMcpTools = await (0, webmcp_client_1.discoverWebMcpTools)();
+        if (ws.readyState !== WebSocket.OPEN)
+            return; // may have closed while awaiting discovery
+        ws.send(JSON.stringify({
+            type: "context",
+            route: pathnameRef.current,
+            visible: (0, context_collector_1.collectVisible)(),
+            liveElements: liveScan.elements,
+            webMcpTools,
+        }));
     }
     function reportMiss(context) {
         (0, element_ladder_1.logMiss)(context);
@@ -346,6 +357,33 @@ function Copilot({ endpoint = "/api/copilot", registeredActions = [], onDo, repo
         setLastQuestion(q);
         setQuestion("");
         try {
+            await runTypedAgentLoop(q);
+        }
+        catch {
+            setAnswer("Something went wrong reaching the help service — try again in a moment.");
+        }
+        finally {
+            setStatus("idle");
+        }
+    }
+    const MAX_LOOP_ITERATIONS = 6; // a hard cap, not a target — see runTypedAgentLoop
+    /**
+     * Drives the agent loop over the stateless HTTP path: ask the server,
+     * and if it comes back with a continuing step (click/fill/read/
+     * call_tool — TERMINAL_VERBS in @cairnvibe/core says which verbs end a
+     * turn), execute that step for real, fold the real result into this
+     * turn's own working history, and ask again — repeat until a terminal
+     * verb or the iteration cap, instead of the old one-call-one-answer
+     * shape. `question` stays the original ask on every call; only
+     * `history` grows with each step's real trace, so the model always
+     * still knows what it was actually asked. `historyRef` (the
+     * conversation's real memory) is only ever committed once, at the end —
+     * a turn that hits the cap mid-loop doesn't leave partial noise in it.
+     */
+    async function runTypedAgentLoop(q) {
+        let loopHistory = historyRef.current;
+        const webMcpTools = await (0, webmcp_client_1.discoverWebMcpTools)();
+        for (let i = 0; i < MAX_LOOP_ITERATIONS; i++) {
             const liveScan = liveRegistryRef.current.getSnapshot();
             liveMapRef.current = liveScan.byId;
             const res = await fetch(endpoint, {
@@ -355,28 +393,45 @@ function Copilot({ endpoint = "/api/copilot", registeredActions = [], onDo, repo
                     route: pathname,
                     question: q,
                     visible: (0, context_collector_1.collectVisible)(),
-                    history: historyRef.current,
+                    history: loopHistory,
                     liveElements: liveScan.elements,
+                    webMcpTools,
                 }),
             });
             const data = await res.json().catch(() => null);
-            handleVerb(data);
-            // Unlike the realtime relay (one persistent connection, memory lives
-            // server-side), each of these POSTs is stateless — the widget itself
-            // is what remembers, and resends it above so the model has context
-            // for "the first one" / "do that instead" on the next question.
-            historyRef.current = [
-                ...historyRef.current,
-                { role: "user", text: q },
-                { role: "assistant", text: summarizeVerbForHistory(data) },
+            const parsed = (0, core_1.safeParseVerbResponse)(data);
+            if (!parsed || core_1.TERMINAL_VERBS.has(parsed.verb)) {
+                handleVerb(data);
+                // Unlike the realtime relay (one persistent connection, memory
+                // lives server-side), each of these POSTs is stateless — the
+                // widget itself is what remembers, and resends it above so the
+                // model has context for "the first one" / "do that instead" on
+                // the next question.
+                historyRef.current = [
+                    ...loopHistory,
+                    { role: "user", text: q },
+                    { role: "assistant", text: summarizeVerbForHistory(data) },
+                ].slice(-MAX_HISTORY_TURNS);
+                return;
+            }
+            // A continuing step — show it happening, execute it for real, and
+            // go around again with the real result instead of ending the turn.
+            setAnswer(summarizeVerbForHistory(data));
+            const stepResult = await (0, verb_executor_1.executeToolStep)(data, pathname, liveMapRef.current);
+            loopHistory = [
+                ...loopHistory,
+                {
+                    role: "assistant",
+                    text: `${summarizeVerbForHistory(data)}. Result: ${stepResult?.observation ?? "no result"}`,
+                },
             ].slice(-MAX_HISTORY_TURNS);
         }
-        catch {
-            setAnswer("Something went wrong reaching the help service — try again in a moment.");
-        }
-        finally {
-            setStatus("idle");
-        }
+        setAnswer("I wasn't able to finish that — try asking again or breaking it into smaller steps.");
+        historyRef.current = [
+            ...loopHistory,
+            { role: "user", text: q },
+            { role: "assistant", text: "(gave up after too many steps)" },
+        ].slice(-MAX_HISTORY_TURNS);
     }
     /**
      * The one place that starts audio playback for a spoken response — stops
@@ -641,7 +696,7 @@ function Copilot({ endpoint = "/api/copilot", registeredActions = [], onDo, repo
                 }
                 setRtStatus("rt-listening");
                 setCaption("");
-                sendFreshContext(); // refresh before the user starts talking again, not after
+                void sendFreshContext(); // refresh before the user starts talking again, not after
             }
             function disarmThinkingWatchdog() {
                 if (rtThinkingWatchdogRef.current) {
@@ -717,6 +772,25 @@ function Copilot({ endpoint = "/api/copilot", registeredActions = [], onDo, repo
                     armThinkingWatchdog();
                 }
                 else if (msg.type === "verb") {
+                    const parsedStep = (0, core_1.safeParseVerbResponse)(msg.verb);
+                    if (parsedStep && !core_1.TERMINAL_VERBS.has(parsedStep.verb)) {
+                        // A continuing agent-loop step (click/fill/read/call_tool) —
+                        // the turn isn't over: execute it for real and report the
+                        // result back so the server can decide the next step, instead
+                        // of treating this like a normal answer (no
+                        // disarmThinkingWatchdog/handleVerb — those are for when a
+                        // turn actually ends). Shown visually so a multi-step turn
+                        // reads as visible progress, not a silent pause; never spoken
+                        // — the server's loop stays quiet between steps on purpose,
+                        // to keep it fast.
+                        setAnswer(summarizeVerbForHistory(msg.verb));
+                        void (0, verb_executor_1.executeToolStep)(msg.verb, pathnameRef.current, liveMapRef.current).then((result) => {
+                            if (ws.readyState === WebSocket.OPEN) {
+                                ws.send(JSON.stringify({ type: "tool_result", observation: result?.observation ?? "no result" }));
+                            }
+                        });
+                        return;
+                    }
                     disarmThinkingWatchdog();
                     handleVerb(msg.verb);
                 }
@@ -884,6 +958,14 @@ function summarizeVerbForHistory(raw) {
             return `(ran ${String(v.action)}${v.target ? ` on ${String(v.target)}` : ""})`;
         case "tour":
             return Array.isArray(v.steps) ? v.steps.map((s) => s.text ?? "").join(" ") : "(tour)";
+        case "click":
+            return `(clicked ${String(v.target)})`;
+        case "fill":
+            return `(typed "${String(v.value)}" into ${String(v.target)})`;
+        case "read":
+            return `(read ${String(v.target)})`;
+        case "call_tool":
+            return `(called ${String(v.name)})`;
         default:
             return "(no response)";
     }

package/dist/realtime-server.d.ts

@@ -1,6 +1,6 @@
 import http from "node:http";
 import { WebSocket } from "ws";
-import type { HistoryTurn, LiveElement, Manifest } from "@cairnvibe/core";
+import { type HistoryTurn, type LiveElement, type Manifest, type WebMcpTool } from "@cairnvibe/core";
 import { createVerbLLM, type CapabilityTier, type CreateCopilotHandlerOptions } from "./server";
 export interface CreateRealtimeServerOptions extends CreateCopilotHandlerOptions {
     manifest: Manifest;
@@ -23,6 +23,7 @@ export declare function handleDeepgramMessage(raw: string, client: WebSocket, de
     route: string;
     visible: string[];
     liveElements: LiveElement[];
+    webMcpTools: WebMcpTool[];
 }, speakStreamed: (text: string) => Promise<void>, history: HistoryTurn[], turnState: {
     buffer: string;
-}, getGeneration: () => number): Promise<void>;
+}, getGeneration: () => number, waitForToolResult: () => Promise<string>): Promise<void>;

package/dist/realtime-server.js

@@ -33,6 +33,7 @@ exports.createRealtimeServer = createRealtimeServer;
 exports.handleDeepgramMessage = handleDeepgramMessage;
 const node_http_1 = __importDefault(require("node:http"));
 const ws_1 = require("ws");
+const core_1 = require("@cairnvibe/core");
 const server_1 = require("./server");
 const tts_stream_1 = require("./tts-stream");
 const DEEPGRAM_LIVE_URL = "wss://api.deepgram.com/v1/listen";
@@ -73,16 +74,28 @@ function createRealtimeServer(options) {
     return httpServer;
 }
 const MAX_HISTORY_TURNS = 8; // 4 exchanges — enough for "the first one"/"do that instead" without growing the prompt unbounded over a long call
+const MAX_LOOP_ITERATIONS = 6; // a hard cap on one turn's agent-loop steps, not a target — see finalizeTurn
 async function handleConnection(client, deps) {
-    // liveElements refreshes on every "context" resend (the client sends one
-    // on route changes and each time it's about to start listening again),
-    // so a live scan from several turns ago never lingers into a later one.
-    let context = { route: "/", visible: [], liveElements: [] };
+    // liveElements/webMcpTools refresh on every "context" resend (the client
+    // sends one on route changes and each time it's about to start listening
+    // again), so a live scan from several turns ago never lingers into a
+    // later one.
+    let context = {
+        route: "/",
+        visible: [],
+        liveElements: [],
+        webMcpTools: [],
+    };
     // Unlike the stateless HTTP path (which needs the client to resend
     // history every request), a realtime connection is already stateful —
     // one WebSocket per call — so this is accumulated here directly rather
     // than round-tripped through the client.
     const history = [];
+    // Resolves the agent loop's in-flight waitForToolResult() call once the
+    // client reports back what a click/fill/read/call_tool step actually
+    // did — same "a mutable pending-callback slot, resolved when the right
+    // message arrives" pattern onCurrentTurnFlushed already uses below.
+    let pendingToolResultResolve = null;
     const dgUrl = `${DEEPGRAM_LIVE_URL}?model=${encodeURIComponent(deps.sttModel)}` +
         `&encoding=linear16&sample_rate=16000&channels=1&interim_results=true&endpointing=300&utterance_end_ms=1000`;
     const dg = new ws_1.WebSocket(dgUrl, { headers: { Authorization: `Token ${deps.deepgramApiKey}` } });
@@ -159,12 +172,31 @@ async function handleConnection(client, deps) {
             stream.flush();
         });
     }
+    /**
+     * Pauses the agent loop (finalizeTurn, below) until the client reports
+     * back the real result of a click/fill/read/call_tool step it just sent
+     * out — the server can't execute a DOM action itself, so every
+     * continuing step needs a real round trip to the browser and back. A
+     * real timeout, not a hang: a client that never answers (closed tab,
+     * dropped connection) can't leave a turn stuck forever.
+     */
+    function waitForToolResult() {
+        return new Promise((resolve) => {
+            pendingToolResultResolve = resolve;
+            setTimeout(() => {
+                if (pendingToolResultResolve === resolve) {
+                    pendingToolResultResolve = null;
+                    resolve("(no result — timed out waiting for the browser)");
+                }
+            }, 15000);
+        });
+    }
     // Accumulates Deepgram "Results" transcript segments across one utterance
     // — see handleDeepgramMessage for why this can't just react to every
     // is_final.
     const turnState = { buffer: "" };
     dg.on("message", (data) => {
-        void handleDeepgramMessage(data.toString(), client, deps, () => context, speakStreamed, history, turnState, () => generation);
+        void handleDeepgramMessage(data.toString(), client, deps, () => context, speakStreamed, history, turnState, () => generation, waitForToolResult);
     });
     dg.on("error", (err) => {
         console.error("[cairn realtime] Deepgram STT connection error:", err);
@@ -186,8 +218,16 @@ async function handleConnection(client, deps) {
                     route: String(msg.route ?? "/"),
                     visible: Array.isArray(msg.visible) ? msg.visible : [],
                     liveElements: parseLiveElements(msg.liveElements),
+                    webMcpTools: parseWebMcpTools(msg.webMcpTools),
                 };
             }
+            else if (msg.type === "tool_result" && typeof msg.observation === "string") {
+                // The client finished executing a click/fill/read/call_tool step
+                // the agent loop sent it — this is what finalizeTurn's
+                // waitForToolResult() below is paused on.
+                pendingToolResultResolve?.(msg.observation);
+                pendingToolResultResolve = null;
+            }
             else if (msg.type === "end") {
                 client.close();
             }
@@ -231,7 +271,7 @@ async function handleConnection(client, deps) {
         speakStream?.close();
     });
 }
-async function handleDeepgramMessage(raw, client, deps, getContext, speakStreamed, history, turnState, getGeneration) {
+async function handleDeepgramMessage(raw, client, deps, getContext, speakStreamed, history, turnState, getGeneration, waitForToolResult) {
     let msg;
     try {
         msg = JSON.parse(raw);
@@ -245,7 +285,7 @@ async function handleDeepgramMessage(raw, client, deps, getContext, speakStreame
         // Results message never carries speech_final:true, so a turn can't get
         // permanently stuck with real transcript sitting in the buffer forever.
         if (turnState.buffer)
-            await finalizeTurn(turnState, client, deps, getContext, speakStreamed, history, getGeneration);
+            await finalizeTurn(turnState, client, deps, getContext, speakStreamed, history, getGeneration, waitForToolResult);
         return;
     }
     if (msg.type !== "Results")
@@ -272,7 +312,7 @@ async function handleDeepgramMessage(raw, client, deps, getContext, speakStreame
         safeSend(client, { type: "interim", text: turnState.buffer });
         return;
     }
-    await finalizeTurn(turnState, client, deps, getContext, speakStreamed, history, getGeneration);
+    await finalizeTurn(turnState, client, deps, getContext, speakStreamed, history, getGeneration, waitForToolResult);
 }
 /**
  * Everything from here on (the LLM call, TTS streaming) can fail in ways
@@ -290,39 +330,74 @@ async function handleDeepgramMessage(raw, client, deps, getContext, speakStreame
  * happens while this turn is still "thinking" bumps the generation, and
  * without this check the now-stale response would still land on the
  * client after the user had already moved on to a new question.
+ *
+ * A continuing verb (click/fill/read/call_tool — TERMINAL_VERBS says which
+ * ones aren't) doesn't end the turn here: the server can't execute a DOM
+ * action itself, so it sends the step to the client, awaits its real
+ * result over waitForToolResult(), folds that into a *local* working copy
+ * of history, and calls resolveVerb again — repeat up to
+ * MAX_LOOP_ITERATIONS. The connection's real `history` only gets the
+ * user's real question plus the turn's final answer, committed once at
+ * the end — a turn that hits the cap mid-loop doesn't leave partial tool
+ * noise in the conversation's real memory, same discipline the HTTP
+ * path's runTypedAgentLoop (index.tsx) follows.
  */
-async function finalizeTurn(turnState, client, deps, getContext, speakStreamed, history, getGeneration) {
+async function finalizeTurn(turnState, client, deps, getContext, speakStreamed, history, getGeneration, waitForToolResult) {
     const transcript = turnState.buffer;
     turnState.buffer = "";
     const myGeneration = getGeneration();
     safeSend(client, { type: "final", text: transcript });
+    let loopHistory = history;
     try {
-        const { route, visible, liveElements } = getContext();
-        const verb = await (0, server_1.resolveVerb)(deps.llm, deps.systemPrompt, deps.manifest, deps.registeredActions, deps.capability, {
-            route,
-            question: transcript,
-            visible,
-            liveElements,
-            history,
-        });
-        if (myGeneration !== getGeneration())
-            return; // superseded by a barge-in while this turn was resolving
-        // Sent immediately — before speech synthesis even starts — so
-        // highlight/navigate/do execute in the browser right away instead of
-        // waiting on audio. The agent visibly acts while it's still about to
-        // speak, not after.
-        safeSend(client, { type: "verb", verb });
-        history.push({ role: "user", text: transcript }, { role: "assistant", text: summarizeVerbForHistory(verb) });
-        history.splice(0, Math.max(0, history.length - MAX_HISTORY_TURNS));
-        // A verb with no spoken text (highlight/navigate/do often have none)
-        // still needs to unstick the client's "thinking" state and let the mic
-        // resume — turn_complete covers that with no audio path involved.
-        if ("text" in verb && verb.text) {
-            await speakStreamed(verb.text);
-        }
-        else {
-            safeSend(client, { type: "turn_complete" });
+        for (let i = 0; i < MAX_LOOP_ITERATIONS; i++) {
+            const { route, visible, liveElements, webMcpTools } = getContext();
+            const verb = await (0, server_1.resolveVerb)(deps.llm, deps.systemPrompt, deps.manifest, deps.registeredActions, deps.capability, {
+                route,
+                question: transcript,
+                visible,
+                liveElements,
+                webMcpTools,
+                history: loopHistory,
+            });
+            if (myGeneration !== getGeneration())
+                return; // superseded by a barge-in while this turn was resolving
+            // Sent immediately — before speech synthesis even starts — so
+            // highlight/navigate/do execute in the browser right away instead of
+            // waiting on audio. The agent visibly acts while it's still about to
+            // speak, not after.
+            safeSend(client, { type: "verb", verb });
+            if (!core_1.TERMINAL_VERBS.has(verb.verb)) {
+                // A continuing step — no speech for it (keeps the loop fast;
+                // the client still shows it visually) — wait for its real result
+                // and go around again instead of ending the turn.
+                const observation = await waitForToolResult();
+                if (myGeneration !== getGeneration())
+                    return;
+                loopHistory = [
+                    ...loopHistory,
+                    { role: "assistant", text: `${summarizeVerbForHistory(verb)}. Result: ${observation}` },
+                ].slice(-MAX_HISTORY_TURNS);
+                continue;
+            }
+            history.push({ role: "user", text: transcript }, { role: "assistant", text: summarizeVerbForHistory(verb) });
+            history.splice(0, Math.max(0, history.length - MAX_HISTORY_TURNS));
+            // A verb with no spoken text (highlight/navigate/do often have none)
+            // still needs to unstick the client's "thinking" state and let the mic
+            // resume — turn_complete covers that with no audio path involved.
+            if ("text" in verb && verb.text) {
+                await speakStreamed(verb.text);
+            }
+            else {
+                safeSend(client, { type: "turn_complete" });
+            }
+            return;
         }
+        // Iteration cap hit with no terminal verb — degrade honestly instead
+        // of leaving the client waiting forever.
+        history.push({ role: "user", text: transcript }, { role: "assistant", text: "(gave up after too many steps)" });
+        history.splice(0, Math.max(0, history.length - MAX_HISTORY_TURNS));
+        safeSend(client, { type: "verb", verb: { verb: "explain", text: "I wasn't able to finish that — try asking again or breaking it into smaller steps." } });
+        await speakStreamed("I wasn't able to finish that — try asking again or breaking it into smaller steps.");
     }
     catch (err) {
         console.error("[cairn realtime] failed to resolve/speak this turn:", err);
@@ -358,6 +433,21 @@ function parseLiveElements(raw) {
     }
     return elements;
 }
+/** Same defensive shape-check as parseLiveElements, for the client's
+ * self-reported WebMCP tool list. */
+function parseWebMcpTools(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const tools = [];
+    for (const entry of raw) {
+        if (entry && typeof entry === "object" && typeof entry.name === "string" && typeof entry.description === "string") {
+            tools.push({ name: entry.name, description: entry.description, inputSchema: entry.inputSchema });
+        }
+        if (tools.length >= 30)
+            break;
+    }
+    return tools;
+}
 /** A short text form of any verb for the history log — not shown to the
  * user, just fed back to the model on later turns so it knows what it
  * already did/said. */
@@ -374,6 +464,14 @@ function summarizeVerbForHistory(verb) {
             return `(ran ${verb.action}${verb.target ? ` on ${verb.target}` : ""})`;
         case "tour":
             return verb.steps.map((s) => s.text).join(" ");
+        case "click":
+            return `(clicked ${verb.target})`;
+        case "fill":
+            return `(typed "${verb.value}" into ${verb.target})`;
+        case "read":
+            return `(read ${verb.target})`;
+        case "call_tool":
+            return `(called ${verb.name})`;
         default:
             return "(no response)";
     }

package/dist/runtime-scan.js

@@ -11,7 +11,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanInteractiveElements = scanInteractiveElements;
 exports.createLiveElementRegistry = createLiveElementRegistry;
-const CANDIDATE_SELECTOR = "[data-ai], button, a, [role='button'], input[type='submit'], input[type='button']";
+// Clickable elements, plus real fillable form fields (text/email/number/etc
+// inputs, textarea, select — NOT submit/button inputs, already covered by
+// the plain "button" role below) — the agent loop's fill/read steps need
+// these to be discoverable the same way a click target already is.
+const CANDIDATE_SELECTOR = "[data-ai], button, a, [role='button'], input[type='submit'], input[type='button'], " +
+    "input:not([type='submit']):not([type='button']):not([type='hidden']), textarea, select";
 const MAX_ELEMENTS = 40;
 const MAX_LABEL_LENGTH = 80;
 const RESCAN_DEBOUNCE_MS = 250;
@@ -19,13 +24,38 @@ function isInViewport(el) {
     const rect = el.getBoundingClientRect();
     return rect.bottom > 0 && rect.top < window.innerHeight && rect.right > 0 && rect.left < window.innerWidth;
 }
+/** A form field's own text content is always empty — its identity comes
+ * from an associated <label>, a placeholder, or its name attribute
+ * instead, in that order of how a real user would recognize the field. */
+function formFieldLabel(el) {
+    if (el.id) {
+        const labelled = el.ownerDocument?.querySelector(`label[for="${cssEscapeId(el.id)}"]`);
+        if (labelled?.textContent?.trim())
+            return labelled.textContent;
+    }
+    const wrappingLabel = el.closest("label");
+    if (wrappingLabel?.textContent?.trim())
+        return wrappingLabel.textContent;
+    return el.getAttribute("placeholder") || el.getAttribute("name") || "";
+}
+function cssEscapeId(id) {
+    return id.replace(/["\\]/g, "\\$&");
+}
+// tagName, not instanceof — see element-ladder.ts's isFormField for why.
+function isFormField(el) {
+    return el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT";
+}
 function labelFor(el) {
-    const raw = el.getAttribute("aria-label") || el.textContent || "";
+    const raw = el.getAttribute("aria-label") || (isFormField(el) ? formFieldLabel(el) : el.textContent) || "";
     const trimmed = raw.replace(/\s+/g, " ").trim();
     return trimmed.length > MAX_LABEL_LENGTH ? `${trimmed.slice(0, MAX_LABEL_LENGTH - 1)}…` : trimmed;
 }
 function roleFor(el) {
-    return el.getAttribute("role") || el.tagName.toLowerCase();
+    if (el.getAttribute("role"))
+        return el.getAttribute("role");
+    if (isFormField(el))
+        return "input";
+    return el.tagName.toLowerCase();
 }
 /**
  * Scans the live DOM for interactive elements currently in the viewport.

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { type HistoryTurn, type LiveElement, type Manifest, type VerbResponse } from "@cairnvibe/core";
+import { type HistoryTurn, type LiveElement, type Manifest, type VerbResponse, type WebMcpTool } from "@cairnvibe/core";
 import { KeyRotator } from "./key-rotator";
 /**
  * What the agent is allowed to do, independent of which specific "do"
@@ -65,6 +65,7 @@ export declare function resolveVerb(llm: VerbLLM, systemPrompt: string, manifest
     visible: string[];
     history?: HistoryTurn[];
     liveElements?: LiveElement[];
+    webMcpTools?: WebMcpTool[];
 }): Promise<VerbResponse>;
 /** Builds the provider-appropriate VerbLLM from the same options createCopilotHandler accepts — reused by the realtime relay. */
 export declare function createVerbLLM(options?: CreateCopilotHandlerOptions): VerbLLM;