agent-vision-mcp 0.1.0

package/dist/browser/cdp/cdp-websocket-session.js

@@ -0,0 +1,99 @@
+import WebSocket from "ws";
+const CDP_COMMAND_TIMEOUT_MS = 10_000;
+const isCdpCommandFailure = (response) => "error" in response;
+const waitForOpen = (socket) => new Promise((resolve, reject) => {
+    if (socket.readyState === WebSocket.OPEN) {
+        resolve();
+        return;
+    }
+    const onOpen = () => {
+        cleanup();
+        resolve();
+    };
+    const onError = (error) => {
+        cleanup();
+        reject(error);
+    };
+    const cleanup = () => {
+        socket.off("open", onOpen);
+        socket.off("error", onError);
+    };
+    socket.on("open", onOpen);
+    socket.on("error", onError);
+});
+const withTimeout = async (promise, timeoutMs, message) => {
+    let timeoutId;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
+            })
+        ]);
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+};
+export class CdpWebSocketSession {
+    socket;
+    nextCommandId = 1;
+    constructor(socket) {
+        this.socket = socket;
+    }
+    async sendCommand(method, params, timeoutMs = CDP_COMMAND_TIMEOUT_MS) {
+        const id = this.nextCommandId++;
+        return await withTimeout(new Promise((resolve, reject) => {
+            const onMessage = (raw) => {
+                try {
+                    const parsed = JSON.parse(raw.toString());
+                    if (parsed.id !== id) {
+                        return;
+                    }
+                    cleanup();
+                    if (isCdpCommandFailure(parsed) && parsed.error) {
+                        reject(new Error(parsed.error.message ?? `CDP command failed: ${method}`));
+                        return;
+                    }
+                    resolve("result" in parsed ? parsed.result ?? {} : {});
+                }
+                catch (error) {
+                    cleanup();
+                    reject(error);
+                }
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const onClose = () => {
+                cleanup();
+                reject(new Error(`CDP socket closed before ${method} completed`));
+            };
+            const cleanup = () => {
+                this.socket.off("message", onMessage);
+                this.socket.off("error", onError);
+                this.socket.off("close", onClose);
+            };
+            this.socket.on("message", onMessage);
+            this.socket.on("error", onError);
+            this.socket.on("close", onClose);
+            this.socket.send(JSON.stringify({ id, method, params }));
+        }), timeoutMs, `Timed out waiting for CDP response to ${method}`);
+    }
+}
+export const withCdpTabSession = async (tab, run) => {
+    if (!tab.webSocketDebuggerUrl) {
+        throw new Error(`Live browser tab ${tab.targetId} is missing webSocketDebuggerUrl`);
+    }
+    const socket = new WebSocket(tab.webSocketDebuggerUrl);
+    try {
+        await withTimeout(waitForOpen(socket), CDP_COMMAND_TIMEOUT_MS, "Timed out opening CDP tab websocket");
+        return await run(new CdpWebSocketSession(socket));
+    }
+    finally {
+        socket.close();
+    }
+};

package/dist/browser/cdp/chrome-cdp-client.d.ts

@@ -0,0 +1,12 @@
+import type { Logger } from "../../logging/logger.js";
+import type { CdpConnectionStatus, CdpTabDiscoveryResult } from "./types.js";
+export declare class ChromeCdpClient {
+    private readonly logger;
+    private readonly defaultEndpoint;
+    private readonly timeoutMs;
+    constructor(logger: Logger, defaultEndpoint?: string, timeoutMs?: number);
+    resolveEndpoint(override?: string): string;
+    getConnectionStatus(endpointOverride?: string): Promise<CdpConnectionStatus>;
+    discoverTabs(endpointOverride?: string): Promise<CdpTabDiscoveryResult>;
+    private fetchJson;
+}

package/dist/browser/cdp/chrome-cdp-client.js

@@ -0,0 +1,141 @@
+const DEFAULT_CDP_ENDPOINT = "http://127.0.0.1:9222";
+const DEFAULT_TIMEOUT_MS = 5_000;
+const nowIso = () => new Date().toISOString();
+const trimTrailingSlash = (value) => value.replace(/\/+$/, "");
+const normalizeEndpoint = (endpoint) => {
+    const candidate = (endpoint ?? process.env.CHROME_CDP_ENDPOINT ?? DEFAULT_CDP_ENDPOINT).trim();
+    if (candidate === "") {
+        return DEFAULT_CDP_ENDPOINT;
+    }
+    return trimTrailingSlash(candidate);
+};
+const readBrowserName = (browser) => {
+    if (!browser) {
+        return undefined;
+    }
+    const [name] = browser.split("/");
+    return name || browser;
+};
+const toErrorMessage = (error, endpoint) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const lowered = message.toLowerCase();
+    if (lowered.includes("timed out")) {
+        return {
+            errorMessage: message,
+            errorHint: `Chrome did not respond in time. Check that a debug-enabled browser is running at ${endpoint}.`
+        };
+    }
+    if (lowered.includes("econnrefused") ||
+        lowered.includes("fetch failed") ||
+        lowered.includes("failed to fetch") ||
+        lowered.includes("networkerror")) {
+        return {
+            errorMessage: message,
+            errorHint: `Could not reach the CDP endpoint at ${endpoint}. Start Chrome with --remote-debugging-port=9222 or set CHROME_CDP_ENDPOINT.`
+        };
+    }
+    if (lowered.includes("404") || lowered.includes("status 404")) {
+        return {
+            errorMessage: message,
+            errorHint: `The endpoint ${endpoint} responded, but it does not look like a Chrome DevTools Protocol server.`
+        };
+    }
+    return { errorMessage: message };
+};
+export class ChromeCdpClient {
+    logger;
+    defaultEndpoint;
+    timeoutMs;
+    constructor(logger, defaultEndpoint = normalizeEndpoint(), timeoutMs = DEFAULT_TIMEOUT_MS) {
+        this.logger = logger;
+        this.defaultEndpoint = defaultEndpoint;
+        this.timeoutMs = timeoutMs;
+    }
+    resolveEndpoint(override) {
+        return normalizeEndpoint(override ?? this.defaultEndpoint);
+    }
+    async getConnectionStatus(endpointOverride) {
+        const endpoint = this.resolveEndpoint(endpointOverride);
+        const checkedAt = nowIso();
+        try {
+            const version = await this.fetchJson(`${endpoint}/json/version`);
+            return {
+                endpoint,
+                connected: true,
+                checkedAt,
+                browser: version.Browser,
+                browserName: readBrowserName(version.Browser),
+                protocolVersion: version.ProtocolVersion,
+                userAgent: version.UserAgent,
+                webSocketDebuggerUrl: version.webSocketDebuggerUrl
+            };
+        }
+        catch (error) {
+            const diagnostic = toErrorMessage(error, endpoint);
+            this.logger.error("Failed CDP connection check", {
+                endpoint,
+                errorMessage: diagnostic.errorMessage,
+                errorHint: diagnostic.errorHint
+            });
+            return {
+                endpoint,
+                connected: false,
+                checkedAt,
+                errorMessage: diagnostic.errorMessage,
+                errorHint: diagnostic.errorHint
+            };
+        }
+    }
+    async discoverTabs(endpointOverride) {
+        const endpoint = this.resolveEndpoint(endpointOverride);
+        const discoveredAt = nowIso();
+        const version = await this.fetchJson(`${endpoint}/json/version`);
+        const rawTargets = await this.fetchJson(`${endpoint}/json/list`);
+        const browserName = readBrowserName(version.Browser);
+        const tabs = rawTargets
+            .filter((target) => target.type === "page" || target.type === "tab")
+            .map((target) => ({
+            id: target.id ?? "unknown-target",
+            type: target.type ?? "page",
+            title: target.title ?? target.url ?? "Untitled tab",
+            url: target.url,
+            attached: target.attached ?? false,
+            browserName,
+            discoveredAt,
+            webSocketDebuggerUrl: target.webSocketDebuggerUrl,
+            devtoolsFrontendUrl: target.devtoolsFrontendUrl
+        }));
+        this.logger.debug("Discovered browser tabs over CDP", {
+            endpoint,
+            tabCount: tabs.length,
+            browser: version.Browser
+        });
+        return {
+            endpoint,
+            discoveredAt,
+            browser: version.Browser,
+            browserName,
+            protocolVersion: version.ProtocolVersion,
+            tabs
+        };
+    }
+    async fetchJson(url) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(new Error(`Timed out fetching CDP endpoint ${url}`)), this.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    accept: "application/json"
+                },
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                throw new Error(`CDP request failed for ${url} with status ${response.status}`);
+            }
+            return (await response.json());
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist/browser/cdp/live-browser-tab-registry.d.ts

@@ -0,0 +1,12 @@
+import type { Logger } from "../../logging/logger.js";
+import { type LiveBrowserTab, type UpsertLiveBrowserTabsInput } from "./tab-model.js";
+export declare class LiveBrowserTabRegistry {
+    private readonly logger;
+    private readonly tabs;
+    constructor(logger: Logger);
+    upsertDiscovery(input: UpsertLiveBrowserTabsInput): LiveBrowserTab[];
+    pruneStale(maxAgeMs?: number, now?: Date): LiveBrowserTab[];
+    list(): LiveBrowserTab[];
+    get(targetId: string): LiveBrowserTab | undefined;
+    private toLiveTab;
+}

package/dist/browser/cdp/live-browser-tab-registry.js

@@ -0,0 +1,96 @@
+import { toActiveHeuristic, toOrderHint } from "./tab-model.js";
+const DEFAULT_STALE_TAB_MAX_AGE_MS = 5 * 60 * 1000;
+const toMs = (value) => Date.parse(value);
+export class LiveBrowserTabRegistry {
+    logger;
+    tabs = new Map();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    upsertDiscovery(input) {
+        const seenIds = new Set();
+        for (const [index, target] of input.tabs.entries()) {
+            seenIds.add(target.id);
+            this.tabs.set(target.id, this.toLiveTab(target, index, input));
+        }
+        const removedTargetIds = [];
+        for (const existing of this.tabs.values()) {
+            if (existing.lastDiscoveryEndpoint !== input.endpoint) {
+                continue;
+            }
+            if (seenIds.has(existing.targetId)) {
+                continue;
+            }
+            this.tabs.delete(existing.targetId);
+            removedTargetIds.push(existing.targetId);
+        }
+        const ordered = this.list().map((tab, index) => ({
+            ...tab,
+            recencyRank: index + 1
+        }));
+        for (const tab of ordered) {
+            this.tabs.set(tab.targetId, tab);
+        }
+        this.logger.debug("Updated live browser tab registry", {
+            endpoint: input.endpoint,
+            discoveredAt: input.discoveredAt,
+            tabCount: ordered.length,
+            seenIds: [...seenIds],
+            removedTargetIds
+        });
+        return ordered;
+    }
+    pruneStale(maxAgeMs = DEFAULT_STALE_TAB_MAX_AGE_MS, now = new Date()) {
+        const cutoffMs = now.getTime() - maxAgeMs;
+        const removed = [];
+        for (const tab of this.tabs.values()) {
+            const lastSeenMs = toMs(tab.lastSeenAt);
+            if (!Number.isFinite(lastSeenMs) || lastSeenMs >= cutoffMs) {
+                continue;
+            }
+            this.tabs.delete(tab.targetId);
+            removed.push(tab);
+        }
+        if (removed.length > 0) {
+            this.logger.info("Pruned stale live browser tabs", {
+                maxAgeMs,
+                removedTargetIds: removed.map((tab) => tab.targetId),
+                removedCount: removed.length
+            });
+        }
+        return removed;
+    }
+    list() {
+        return [...this.tabs.values()].sort((left, right) => {
+            if (left.activeHeuristic !== right.activeHeuristic) {
+                return left.activeHeuristic ? -1 : 1;
+            }
+            if (left.orderHint !== right.orderHint) {
+                return left.orderHint - right.orderHint;
+            }
+            return right.lastSeenAt.localeCompare(left.lastSeenAt);
+        });
+    }
+    get(targetId) {
+        return this.tabs.get(targetId);
+    }
+    toLiveTab(target, index, input) {
+        const existing = this.tabs.get(target.id);
+        return {
+            targetId: target.id,
+            type: target.type,
+            title: target.title,
+            url: target.url,
+            browserName: target.browserName,
+            attached: target.attached,
+            webSocketDebuggerUrl: target.webSocketDebuggerUrl,
+            devtoolsFrontendUrl: target.devtoolsFrontendUrl,
+            firstSeenAt: existing?.firstSeenAt ?? input.discoveredAt,
+            lastSeenAt: input.discoveredAt,
+            lastDiscoveryEndpoint: input.endpoint,
+            activeHeuristic: toActiveHeuristic(target, index),
+            recencyRank: existing?.recencyRank ?? index + 1,
+            orderHint: toOrderHint(target, index)
+        };
+    }
+}

package/dist/browser/cdp/png-metadata.d.ts

@@ -0,0 +1,5 @@
+export type PngDimensions = {
+    width: number;
+    height: number;
+};
+export declare const readPngDimensions: (buffer: Buffer) => PngDimensions;

package/dist/browser/cdp/png-metadata.js

@@ -0,0 +1,16 @@
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+export const readPngDimensions = (buffer) => {
+    if (buffer.byteLength < 24) {
+        throw new Error("PNG buffer is too small to contain dimensions");
+    }
+    if (!buffer.subarray(0, PNG_SIGNATURE.byteLength).equals(PNG_SIGNATURE)) {
+        throw new Error("Expected PNG signature in screenshot payload");
+    }
+    if (buffer.subarray(12, 16).toString("ascii") !== "IHDR") {
+        throw new Error("Expected IHDR chunk in screenshot payload");
+    }
+    return {
+        width: buffer.readUInt32BE(16),
+        height: buffer.readUInt32BE(20)
+    };
+};

package/dist/browser/cdp/tab-model.d.ts

@@ -0,0 +1,33 @@
+import type { CdpDiscoveredTarget, CdpTabDiscoveryResult } from "./types.js";
+export type LiveBrowserTab = {
+    targetId: string;
+    type: string;
+    title: string;
+    url?: string;
+    browserName?: string;
+    attached: boolean;
+    webSocketDebuggerUrl?: string;
+    devtoolsFrontendUrl?: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    lastDiscoveryEndpoint: string;
+    activeHeuristic: boolean;
+    recencyRank: number;
+    orderHint: number;
+};
+export type LiveBrowserTabDiscoveryResult = {
+    endpoint: string;
+    discoveredAt: string;
+    browser?: string;
+    browserName?: string;
+    protocolVersion?: string;
+    tabs: LiveBrowserTab[];
+};
+export type UpsertLiveBrowserTabsInput = {
+    endpoint: string;
+    discoveredAt: string;
+    tabs: CdpDiscoveredTarget[];
+};
+export declare const toActiveHeuristic: (target: CdpDiscoveredTarget, index: number) => boolean;
+export declare const toOrderHint: (target: CdpDiscoveredTarget, index: number) => number;
+export declare const toDiscoveryResult: (source: CdpTabDiscoveryResult, tabs: LiveBrowserTab[]) => LiveBrowserTabDiscoveryResult;

package/dist/browser/cdp/tab-model.js

@@ -0,0 +1,15 @@
+export const toActiveHeuristic = (target, index) => target.attached || index === 0;
+export const toOrderHint = (target, index) => {
+    if (target.attached) {
+        return index;
+    }
+    return index + 100;
+};
+export const toDiscoveryResult = (source, tabs) => ({
+    endpoint: source.endpoint,
+    discoveredAt: source.discoveredAt,
+    browser: source.browser,
+    browserName: source.browserName,
+    protocolVersion: source.protocolVersion,
+    tabs
+});

package/dist/browser/cdp/tab-resolution.d.ts

@@ -0,0 +1,27 @@
+import type { LiveBrowserTab } from "./tab-model.js";
+export type LiveBrowserTabCandidate = {
+    targetId: string;
+    title: string;
+    url?: string;
+    browserName?: string;
+    attached: boolean;
+    activeHeuristic: boolean;
+    recencyRank: number;
+    matchScore: number;
+    matchReason: string;
+};
+export type LiveBrowserTabResolution = {
+    status: "resolved";
+    query?: string;
+    tab: LiveBrowserTab;
+    matchedCandidate: LiveBrowserTabCandidate;
+    candidateCount: number;
+} | {
+    status: "ambiguous" | "not_found";
+    query?: string;
+    candidates: LiveBrowserTabCandidate[];
+    message: string;
+};
+export declare const toCandidate: (tab: LiveBrowserTab, matchScore: number, matchReason: string) => LiveBrowserTabCandidate;
+export declare const scoreLiveTab: (tab: LiveBrowserTab, query?: string) => LiveBrowserTabCandidate | undefined;
+export declare const sortCandidates: (left: LiveBrowserTabCandidate, right: LiveBrowserTabCandidate) => number;

package/dist/browser/cdp/tab-resolution.js

@@ -0,0 +1,48 @@
+const normalize = (value) => (value ?? "").trim().toLowerCase();
+export const toCandidate = (tab, matchScore, matchReason) => ({
+    targetId: tab.targetId,
+    title: tab.title,
+    url: tab.url,
+    browserName: tab.browserName,
+    attached: tab.attached,
+    activeHeuristic: tab.activeHeuristic,
+    recencyRank: tab.recencyRank,
+    matchScore,
+    matchReason
+});
+export const scoreLiveTab = (tab, query) => {
+    const normalizedQuery = normalize(query);
+    if (normalizedQuery === "") {
+        if (tab.activeHeuristic) {
+            return toCandidate(tab, tab.attached ? 130 : 120, tab.attached ? "attached-tab" : "active-tab");
+        }
+        return toCandidate(tab, Math.max(1, 20 - tab.recencyRank), "recent-tab");
+    }
+    const title = normalize(tab.title);
+    const url = normalize(tab.url);
+    if (title === normalizedQuery) {
+        return toCandidate(tab, tab.activeHeuristic ? 140 : 130, "exact-title");
+    }
+    if (url !== "" && url === normalizedQuery) {
+        return toCandidate(tab, tab.activeHeuristic ? 138 : 128, "exact-url");
+    }
+    if (title.startsWith(normalizedQuery)) {
+        return toCandidate(tab, tab.activeHeuristic ? 115 : 105, "title-prefix");
+    }
+    if (title.includes(normalizedQuery)) {
+        return toCandidate(tab, tab.activeHeuristic ? 95 : 85, "title-substring");
+    }
+    if (url !== "" && url.includes(normalizedQuery)) {
+        return toCandidate(tab, tab.activeHeuristic ? 90 : 80, "url-substring");
+    }
+    return undefined;
+};
+export const sortCandidates = (left, right) => {
+    if (left.matchScore !== right.matchScore) {
+        return right.matchScore - left.matchScore;
+    }
+    if (left.activeHeuristic !== right.activeHeuristic) {
+        return left.activeHeuristic ? -1 : 1;
+    }
+    return left.recencyRank - right.recencyRank;
+};

package/dist/browser/cdp/types.d.ts

@@ -0,0 +1,71 @@
+export type CdpBrowserVersion = {
+    Browser?: string;
+    ProtocolVersion?: string;
+    UserAgent?: string;
+    V8Version?: string;
+    WebKitVersion?: string;
+    webSocketDebuggerUrl?: string;
+};
+export type CdpConnectionStatus = {
+    endpoint: string;
+    connected: boolean;
+    checkedAt: string;
+    browser?: string;
+    browserName?: string;
+    protocolVersion?: string;
+    userAgent?: string;
+    webSocketDebuggerUrl?: string;
+    errorMessage?: string;
+    errorHint?: string;
+};
+export type CdpDiscoveredTarget = {
+    id: string;
+    type: string;
+    title: string;
+    url?: string;
+    attached: boolean;
+    browserName?: string;
+    discoveredAt: string;
+    webSocketDebuggerUrl?: string;
+    devtoolsFrontendUrl?: string;
+};
+export type CdpTabDiscoveryResult = {
+    endpoint: string;
+    discoveredAt: string;
+    browser?: string;
+    browserName?: string;
+    protocolVersion?: string;
+    tabs: CdpDiscoveredTarget[];
+};
+export type BrowserTabScreenshot = {
+    targetId: string;
+    title: string;
+    url?: string;
+    browserName?: string;
+    mimeType: "image/png";
+    bytesBase64: string;
+    width: number;
+    height: number;
+    byteLength: number;
+    capturedAt: string;
+    backend: "cdp-page-capture";
+};
+export type BrowserTabStructuredContext = {
+    targetId: string;
+    title: string;
+    url?: string;
+    browserName?: string;
+    pageTitle?: string;
+    pageUrl?: string;
+    documentLanguage?: string;
+    contentType?: string;
+    visibleText: string;
+    visibleTextLength: number;
+    viewport?: {
+        width?: number;
+        height?: number;
+        devicePixelRatio?: number;
+    };
+    collectedAt: string;
+    backend: "cdp-runtime-evaluate";
+};

package/dist/browser/cdp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/capture/capture-pipeline.d.ts

@@ -0,0 +1,5 @@
+import type { CaptureBundle } from "../types/capture.js";
+import type { CapturePipelineInput } from "./types.js";
+export interface CapturePipeline {
+    createBundle(input: CapturePipelineInput): Promise<CaptureBundle>;
+}

package/dist/capture/capture-pipeline.js

@@ -0,0 +1 @@
+export {};

package/dist/capture/create-screen-capture-provider.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "../logging/logger.js";
+import type { ScreenCaptureProvider } from "./screen-capture-provider.js";
+export declare const createScreenCaptureProvider: (logger: Logger) => ScreenCaptureProvider;

package/dist/capture/create-screen-capture-provider.js

@@ -0,0 +1,8 @@
+import { LinuxPortalScreenshotProvider } from "./linux-portal-screenshot-provider.js";
+import { MockScreenCaptureProvider } from "./mock-screen-capture-provider.js";
+export const createScreenCaptureProvider = (logger) => {
+    if (process.platform === "linux") {
+        return new LinuxPortalScreenshotProvider(logger);
+    }
+    return new MockScreenCaptureProvider();
+};

package/dist/capture/in-memory-capture-pipeline.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from "../logging/logger.js";
+import type { CaptureBundle } from "../types/capture.js";
+import type { CapturePipeline } from "./capture-pipeline.js";
+import { InMemoryImageCompositor } from "./in-memory-image-compositor.js";
+import type { ScreenCaptureProvider } from "./screen-capture-provider.js";
+import type { CapturePipelineInput } from "./types.js";
+export declare class InMemoryCapturePipeline implements CapturePipeline {
+    private readonly provider;
+    private readonly compositor;
+    private readonly logger;
+    constructor(provider: ScreenCaptureProvider, compositor: InMemoryImageCompositor, logger: Logger);
+    createBundle(input: CapturePipelineInput): Promise<CaptureBundle>;
+}

package/dist/capture/in-memory-capture-pipeline.js

@@ -0,0 +1,52 @@
+export class InMemoryCapturePipeline {
+    provider;
+    compositor;
+    logger;
+    constructor(provider, compositor, logger) {
+        this.provider = provider;
+        this.compositor = compositor;
+        this.logger = logger;
+    }
+    async createBundle(input) {
+        const source = await this.provider.capture({
+            sessionId: input.sessionId,
+            command: input.command,
+            displayId: input.context?.displayId,
+            activeAppName: input.context?.activeAppName,
+            activeWindowTitle: input.context?.activeWindowTitle
+        });
+        const manifest = {
+            sessionId: input.sessionId,
+            command: input.command,
+            sourceImage: {
+                width: source.width,
+                height: source.height,
+                displayId: source.displayId,
+                backend: source.backend
+            },
+            crop: input.selection,
+            annotations: input.annotations,
+            context: input.context
+        };
+        const image = this.compositor.compose(source, manifest);
+        this.logger.debug("Created in-memory capture bundle", {
+            sessionId: input.sessionId,
+            backend: image.backend,
+            width: image.width,
+            height: image.height,
+            annotationCount: input.annotations.length
+        });
+        return {
+            sessionId: input.sessionId,
+            command: input.command,
+            image,
+            selection: input.selection,
+            annotations: input.annotations,
+            context: {
+                ...input.context,
+                capturedAt: source.capturedAt,
+                displayId: input.context?.displayId ?? source.displayId
+            }
+        };
+    }
+}