opencode-pair-autonomy 1.0.0

package/vendor/mcp/web-agent-mcp/src/tools/act/wheel.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { actionResultSchema, wheelInputSchema } from "../../schemas/act.js";
+import { createActionFailureResponse, createActionSuccessResult } from "./shared.js";
+
+export function registerWheelTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "act.wheel",
+    {
+      title: "Wheel Scroll",
+      description: "Scroll the viewport or a target element using wheel input.",
+      inputSchema: wheelInputSchema,
+      outputSchema: actionResultSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof wheelInputSchema>) => {
+      try {
+        const action = await services.history.startAction("act.wheel", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.wheel(input.session_id, input.page_id, {
+          selector: input.selector,
+          deltaX: input.delta_x,
+          deltaY: input.delta_y,
+          steps: input.steps,
+          stepDelayMs: input.step_delay_ms,
+          timeoutMs: input.timeout_ms
+        });
+        const data = { verificationHint: result.verificationHint };
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", data);
+        return createActionSuccessResult({
+          actionId: action.action_id,
+          sessionId: session.sessionId,
+          pageId: page.pageId,
+          appliedMode: "physical",
+          verificationHint: result.verificationHint,
+          targetSelectorKnown: Boolean(input.selector)
+        });
+      } catch (error) {
+        return createActionFailureResponse({
+          services,
+          error,
+          sessionId: input.session_id,
+          pageId: input.page_id,
+          appliedMode: "physical",
+          targetSelectorKnown: Boolean(input.selector)
+        });
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/observe/a11y.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { buildFollowUpByGoal } from "../../core/observation-flow.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { observeA11yOutputSchema, observeSessionInputSchema } from "../../schemas/observe.js";
+
+export function registerObserveA11yTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.a11y",
+    {
+      title: "Observe Accessibility Tree",
+      description: "Capture a structured accessibility snapshot for the current page.",
+      inputSchema: observeSessionInputSchema,
+      outputSchema: observeA11yOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof observeSessionInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.a11y", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.observeA11y(
+          input.session_id,
+          input.page_id
+        );
+        const artifact = await services.artifacts.writeText("a11y", JSON.stringify(result, null, 2), {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: result.url,
+          title: result.title
+        });
+        const data = {
+          snapshot_id: artifact.artifact_id,
+          format: "a11y",
+          url: result.url,
+          title: result.title,
+          tree: result,
+          follow_up_by_goal: buildFollowUpByGoal({
+            pageStateKnown: true,
+            targetSelectorKnown: false,
+            recentFailure: "none"
+          })
+        };
+        await services.history.finishAction(action, "succeeded", { snapshot_id: artifact.artifact_id });
+        return createToolSuccess({ ok: true, code: "OK", action_id: action.action_id, session_id: session.sessionId, page_id: page.pageId, artifact_ids: [artifact.artifact_id], data });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/observe/auth-state.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { buildFollowUpByGoal } from "../../core/observation-flow.js";
+import { createFailureResult } from "../../core/errors.js";
+import {
+  authStateInputSchema,
+  observeAuthStateOutputSchema
+} from "../../schemas/observe.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import type { RuntimeServices } from "../../server.js";
+
+export function registerObserveAuthStateTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.auth_state",
+    {
+      title: "Observe Auth State",
+      description: "Classify login flows using page text, frames, and recent network activity.",
+      inputSchema: authStateInputSchema,
+      outputSchema: observeAuthStateOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof authStateInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.auth_state", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.observeAuthState(
+          input.session_id,
+          input.page_id,
+          input.recent_network_limit
+        );
+
+        const followUpByGoal = buildFollowUpByGoal({
+          pageStateKnown: true,
+          targetSelectorKnown: result.suggestedSelectors.length > 0,
+          recentFailure: "none"
+        });
+
+        const artifact = await services.artifacts.writeText("dom", JSON.stringify(result, null, 2), {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: result.url,
+          title: result.title,
+          meta: {
+            state: result.state,
+            confidence: result.confidence,
+            suggested_selector_count: result.suggestedSelectors.length
+          }
+        });
+
+        const data = {
+          snapshot_id: artifact.artifact_id,
+          url: result.url,
+          title: result.title,
+          state: result.state,
+          confidence: result.confidence,
+          summary: result.summary,
+          evidence: result.evidence,
+          suggested_selectors: result.suggestedSelectors,
+          candidate_frames: result.frames,
+          recent_network: result.recentNetwork,
+          follow_up_by_goal: followUpByGoal
+        };
+
+        await services.history.finishAction(action, "succeeded", {
+          snapshot_id: artifact.artifact_id,
+          state: result.state,
+          confidence: result.confidence
+        });
+
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          action_id: action.action_id,
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          artifact_ids: [artifact.artifact_id],
+          data
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/observe/boxes.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { boxesInputSchema, observeBoxesOutputSchema } from "../../schemas/observe.js";
+
+export function registerObserveBoxesTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.boxes",
+    {
+      title: "Observe Element Boxes",
+      description: "Resolve bounding boxes for one or more CSS selectors on the current page.",
+      inputSchema: boxesInputSchema,
+      outputSchema: observeBoxesOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof boxesInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.boxes", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.observeBoxes(
+          input.session_id,
+          input.page_id,
+          input.selectors
+        );
+        const artifact = await services.artifacts.writeText("boxes", JSON.stringify(result, null, 2), {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: page.url,
+          title: page.title,
+          meta: {
+            selector_count: input.selectors.length
+          }
+        });
+        const data = {
+          element_map_id: artifact.artifact_id,
+          elements: result
+        };
+        await services.history.finishAction(action, "succeeded", {
+          element_map_id: artifact.artifact_id,
+          element_count: result.length
+        });
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          action_id: action.action_id,
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          artifact_ids: [artifact.artifact_id],
+          data
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/observe/console.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { logsInputSchema, observeLogsOutputSchema } from "../../schemas/observe.js";
+
+export function registerObserveConsoleTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.console",
+    {
+      title: "Observe Console Logs",
+      description: "Return recent browser console entries captured for the current page.",
+      inputSchema: logsInputSchema,
+      outputSchema: observeLogsOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof logsInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.console", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.observeConsole(
+          input.session_id,
+          input.page_id,
+          input.limit
+        );
+        const artifact = await services.artifacts.writeText("console", JSON.stringify(result, null, 2), {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: page.url,
+          title: page.title,
+          meta: {
+            limit: input.limit,
+            entry_count: result.length
+          }
+        });
+        const data = {
+          artifact_id: artifact.artifact_id,
+          entries: result
+        };
+        await services.history.finishAction(action, "succeeded", {
+          artifact_id: artifact.artifact_id,
+          entry_count: result.length
+        });
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          action_id: action.action_id,
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          artifact_ids: [artifact.artifact_id],
+          data
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/observe/dom.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { buildFollowUpByGoal } from "../../core/observation-flow.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { observeDomOutputSchema, observeSessionInputSchema } from "../../schemas/observe.js";
+
+export function registerObserveDomTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.dom",
+    {
+      title: "Observe DOM Summary",
+      description: "Return a lightweight DOM summary for the current page.",
+      inputSchema: observeSessionInputSchema,
+      outputSchema: observeDomOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof observeSessionInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.dom", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.observeDom(
+          input.session_id,
+          input.page_id
+        );
+        const artifact = await services.artifacts.writeText("dom", JSON.stringify(result, null, 2), {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: result.url,
+          title: result.title
+        });
+        const data = {
+          snapshot_id: artifact.artifact_id,
+          format: "dom",
+          url: result.url,
+          title: result.title,
+          dom_summary: result.summary,
+          follow_up_by_goal: buildFollowUpByGoal({
+            pageStateKnown: true,
+            targetSelectorKnown: false,
+            recentFailure: "none"
+          })
+        };
+        await services.history.finishAction(action, "succeeded", { snapshot_id: artifact.artifact_id });
+        return createToolSuccess({ ok: true, code: "OK", action_id: action.action_id, session_id: session.sessionId, page_id: page.pageId, artifact_ids: [artifact.artifact_id], data });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/observe/network.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { logsInputSchema, observeLogsOutputSchema } from "../../schemas/observe.js";
+
+export function registerObserveNetworkTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.network",
+    {
+      title: "Observe Network Logs",
+      description: "Return recent network events captured for the current page.",
+      inputSchema: logsInputSchema,
+      outputSchema: observeLogsOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof logsInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.network", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.observeNetwork(
+          input.session_id,
+          input.page_id,
+          input.limit
+        );
+        const artifact = await services.artifacts.writeText("network", JSON.stringify(result, null, 2), {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: page.url,
+          title: page.title,
+          meta: {
+            limit: input.limit,
+            entry_count: result.length
+          }
+        });
+        const data = {
+          artifact_id: artifact.artifact_id,
+          entries: result
+        };
+        await services.history.finishAction(action, "succeeded", {
+          artifact_id: artifact.artifact_id,
+          entry_count: result.length
+        });
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          action_id: action.action_id,
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          artifact_ids: [artifact.artifact_id],
+          data
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/observe/page-state.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { buildFollowUpByGoal } from "../../core/observation-flow.js";
+import { createFailureResult } from "../../core/errors.js";
+import {
+  observePageStateOutputSchema,
+  pageStateInputSchema
+} from "../../schemas/observe.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import type { RuntimeServices } from "../../server.js";
+
+export function registerObservePageStateTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.page_state",
+    {
+      title: "Observe Page State",
+      description: "Return a composite page snapshot with text, frames, controls, and recent network activity.",
+      inputSchema: pageStateInputSchema,
+      outputSchema: observePageStateOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof pageStateInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.page_state", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.observePageState(
+          input.session_id,
+          input.page_id,
+          input.recent_network_limit
+        );
+
+        const followUpByGoal = buildFollowUpByGoal({
+          pageStateKnown: true,
+          targetSelectorKnown: result.inputs.length > 0 || result.buttons.length > 0,
+          recentFailure: "none"
+        });
+
+        const artifact = await services.artifacts.writeText("dom", JSON.stringify(result, null, 2), {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: result.url,
+          title: result.title,
+          meta: {
+            frame_count: result.frames.length,
+            input_count: result.inputs.length,
+            button_count: result.buttons.length,
+            recent_network_count: result.recentNetwork.length
+          }
+        });
+
+        const data = {
+          snapshot_id: artifact.artifact_id,
+          url: result.url,
+          title: result.title,
+          text: result.text,
+          truncated: result.truncated,
+          dom_summary: result.dom,
+          inputs: result.inputs,
+          buttons: result.buttons,
+          frames: result.frames,
+          recent_network: result.recentNetwork,
+          follow_up_by_goal: followUpByGoal
+        };
+
+        await services.history.finishAction(action, "succeeded", {
+          snapshot_id: artifact.artifact_id,
+          frame_count: result.frames.length,
+          recent_network_count: result.recentNetwork.length
+        });
+
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          action_id: action.action_id,
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          artifact_ids: [artifact.artifact_id],
+          data
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/observe/screenshot.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { buildFollowUpByGoal } from "../../core/observation-flow.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { observeScreenshotOutputSchema, screenshotInputSchema } from "../../schemas/observe.js";
+
+export function registerObserveScreenshotTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.screenshot",
+    {
+      title: "Observe Screenshot",
+      description: "Capture a viewport, full-page, or element screenshot and persist it as an artifact.",
+      inputSchema: screenshotInputSchema,
+      outputSchema: observeScreenshotOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof screenshotInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.screenshot", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.takeScreenshot(
+          input.session_id,
+          input.page_id,
+          input.mode,
+          input.format,
+          input.quality,
+          input.selector
+        );
+        const artifact = await services.artifacts.writeBinary("screenshot", result.bytes, input.format, {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: result.url,
+          title: result.title,
+          meta: {
+            mode: input.mode,
+            selector: input.selector,
+            format: input.format,
+            quality: input.quality
+          }
+        });
+        const data = {
+          screenshot_id: artifact.artifact_id,
+          mode: input.mode,
+          width: result.width,
+          height: result.height,
+          bytes: artifact.bytes,
+          mime_type: result.mimeType,
+          storage_path: artifact.storage_path,
+          follow_up_by_goal: buildFollowUpByGoal({
+            pageStateKnown: true,
+            targetSelectorKnown: Boolean(input.selector),
+            needsFullPageContext: input.mode === "full",
+            recentFailure: input.mode === "viewport" ? "layout_uncertain" : "none"
+          })
+        };
+        await services.history.finishAction(action, "succeeded", { screenshot_id: artifact.artifact_id });
+        return createToolSuccess({ ok: true, code: "OK", action_id: action.action_id, session_id: session.sessionId, page_id: page.pageId, artifact_ids: [artifact.artifact_id], data });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}