@wingman-ai/gateway 0.5.4 → 0.6.0

package/dist/agent/tools/browser_runtime.cjs

@@ -33,10 +33,11 @@ __webpack_require__.d(__webpack_exports__, {
     BrowserControlInputSchema: ()=>BrowserControlInputSchema,
     DEFAULT_ACTION_TIMEOUT_MS: ()=>DEFAULT_ACTION_TIMEOUT_MS,
     createBrowserDependencies: ()=>createBrowserDependencies,
+    BrowserSessionVideoRecordingSchema: ()=>BrowserSessionVideoRecordingSchema,
     executeBrowserSessionRuntime: ()=>executeBrowserSessionRuntime,
-    closeBrowserSessionRuntime: ()=>closeBrowserSessionRuntime,
-    BrowserActionSchema: ()=>BrowserActionSchema,
     clearStaleDevtoolsArtifacts: ()=>clearStaleDevtoolsArtifacts,
+    BrowserActionSchema: ()=>BrowserActionSchema,
+    closeBrowserSessionRuntime: ()=>closeBrowserSessionRuntime,
     BrowserTransportPreferenceSchema: ()=>BrowserTransportPreferenceSchema
 });
 const external_node_child_process_namespaceObject = require("node:child_process");
@@ -59,6 +60,7 @@ const MAX_EXTRACT_CHARS = 1000000;
 const MAX_ACTIONS = 25;
 const DEFAULT_PROFILES_ROOT = ".wingman/browser-profiles";
 const DEFAULT_EXTENSIONS_ROOT = ".wingman/browser-extensions";
+const DEFAULT_BROWSER_VIDEO_ROOT = ".wingman/browser/videos";
 const DEFAULT_BUNDLED_EXTENSION_ID = "wingman";
 const BUNDLED_EXTENSION_RELATIVE_PATH = "../../../extensions/wingman-browser-extension";
 const PERSISTENT_PROFILE_IGNORE_DEFAULT_ARGS = [
@@ -83,6 +85,17 @@ const BrowserTransportPreferenceSchema = external_zod_namespaceObject["enum"]([
     "playwright",
     "relay"
 ]);
+const BrowserVideoSizeSchema = external_zod_namespaceObject.object({
+    width: external_zod_namespaceObject.number().int().min(1).max(3840).describe("Video width in pixels"),
+    height: external_zod_namespaceObject.number().int().min(1).max(3840).describe("Video height in pixels")
+});
+const BrowserSessionVideoRecordingSchema = external_zod_namespaceObject.union([
+    external_zod_namespaceObject.boolean(),
+    external_zod_namespaceObject.object({
+        dir: external_zod_namespaceObject.string().min(1).optional().describe("Relative output directory within the workspace for videos"),
+        size: BrowserVideoSizeSchema.optional().describe("Optional recorded video dimensions")
+    })
+]);
 const NavigateActionSchema = external_zod_namespaceObject.object({
     type: external_zod_namespaceObject.literal("navigate"),
     url: external_zod_namespaceObject.string().url().describe("Destination URL")
@@ -516,14 +529,22 @@ function selectContext(contexts) {
     ].reverse();
     return reversed.find((candidate)=>candidate.pages().length > 0) || reversed[0];
 }
-async function launchPersistentContext(playwright, userDataDir, executablePath, headless, startupTimeoutMs, chromeArgs) {
+async function launchPersistentContext(playwright, userDataDir, executablePath, headless, startupTimeoutMs, chromeArgs, videoRecording) {
     if ("function" != typeof playwright.chromium.launchPersistentContext) throw new Error("playwright-core runtime does not support launchPersistentContext.");
     return playwright.chromium.launchPersistentContext(userDataDir, {
         executablePath: resolveChromeExecutablePath(executablePath),
         headless,
         timeout: startupTimeoutMs,
         args: chromeArgs,
-        ignoreDefaultArgs: PERSISTENT_PROFILE_IGNORE_DEFAULT_ARGS
+        ignoreDefaultArgs: PERSISTENT_PROFILE_IGNORE_DEFAULT_ARGS,
+        ...videoRecording ? {
+            recordVideo: {
+                dir: videoRecording.dirAbsolute,
+                ...videoRecording.size ? {
+                    size: videoRecording.size
+                } : {}
+            }
+        } : {}
     });
 }
 function validateExtensionId(extensionId) {
@@ -701,6 +722,102 @@ function resolveScreenshotPath(workspace, requestedPath, now, actionIndex) {
         relative: (0, external_node_path_namespaceObject.relative)(workspace, absoluteOutputPath).split("\\").join("/")
     };
 }
+function toGatewayFileUrl(absolutePath) {
+    return `/api/fs/file?path=${encodeURIComponent(absolutePath)}`;
+}
+function resolveVideoOutputDir(workspace, requested, now) {
+    if (!requested) return null;
+    const dir = "object" == typeof requested && requested.dir?.trim() ? requested.dir.trim() : (0, external_node_path_namespaceObject.join)(DEFAULT_BROWSER_VIDEO_ROOT, `recording-${now()}`);
+    if ((0, external_node_path_namespaceObject.isAbsolute)(dir)) throw new Error("Video recording directory must be relative to the workspace.");
+    const dirAbsolute = resolveWorkspaceRelativePath(workspace, dir);
+    (0, external_node_fs_namespaceObject.mkdirSync)(dirAbsolute, {
+        recursive: true
+    });
+    return {
+        dirAbsolute,
+        dirRelative: (0, external_node_path_namespaceObject.relative)(workspace, dirAbsolute).split("\\").join("/"),
+        ..."object" == typeof requested && requested.size ? {
+            size: requested.size
+        } : {}
+    };
+}
+function resolveVideoMimeType(pathname) {
+    const extension = (0, external_node_path_namespaceObject.extname)(pathname).trim().toLowerCase();
+    switch(extension){
+        case ".mp4":
+            return "video/mp4";
+        case ".mov":
+            return "video/quicktime";
+        case ".webm":
+        default:
+            return "video/webm";
+    }
+}
+function buildScreenshotMedia(workspace, actionResults) {
+    return actionResults.flatMap((result, index)=>{
+        if ("screenshot" !== result.type || "string" != typeof result.path || !result.path.trim()) return [];
+        const relativePath = result.path.trim();
+        const absolutePath = "string" == typeof result.absolutePath && result.absolutePath.trim() ? result.absolutePath.trim() : resolveWorkspaceRelativePath(workspace, relativePath);
+        const uri = "string" == typeof result.uri && result.uri.trim() ? result.uri.trim() : toGatewayFileUrl(absolutePath);
+        return [
+            {
+                kind: "image",
+                source: "screenshot",
+                path: absolutePath,
+                relativePath,
+                uri,
+                url: uri,
+                mimeType: "image/png",
+                name: (0, external_node_path_namespaceObject.basename)(absolutePath),
+                ..."boolean" == typeof result.fullPage ? {
+                    fullPage: result.fullPage
+                } : {},
+                actionIndex: index
+            }
+        ];
+    });
+}
+function summarizeVideoRecording(recording, state, videoCount = 0) {
+    if (!recording) return null;
+    return {
+        enabled: true,
+        state,
+        dir: recording.dirRelative,
+        size: recording.size || null,
+        videoCount
+    };
+}
+async function registerPageVideoHandle(runtime, page) {
+    if (!runtime.videoRecording || "function" != typeof page.video) return;
+    try {
+        const video = page.video();
+        if (video) runtime.videoRecording.handles.add(video);
+    } catch  {}
+}
+async function finalizeRecordedVideos(runtime) {
+    if (!runtime.videoRecording || 0 === runtime.videoRecording.handles.size) return [];
+    const seen = new Set();
+    const media = [];
+    for (const handle of runtime.videoRecording.handles)try {
+        const absolutePath = (await handle.path()).trim();
+        if (!absolutePath) continue;
+        const relativePath = (0, external_node_path_namespaceObject.relative)(runtime.workspace, absolutePath).split("\\").join("/");
+        if (!relativePath || relativePath.startsWith("..") || (0, external_node_path_namespaceObject.isAbsolute)(relativePath) || seen.has(relativePath)) continue;
+        seen.add(relativePath);
+        const uri = toGatewayFileUrl(absolutePath);
+        media.push({
+            kind: "video",
+            source: "video-recording",
+            path: absolutePath,
+            relativePath,
+            uri,
+            url: uri,
+            mimeType: resolveVideoMimeType(absolutePath),
+            name: (0, external_node_path_namespaceObject.basename)(absolutePath)
+        });
+    } catch  {}
+    return media;
+}
 function serializeEvaluation(value) {
     if ("string" == typeof value || "number" == typeof value || "boolean" == typeof value || null === value) return value;
     try {
@@ -888,6 +1005,8 @@ async function runBrowserAction(page, action, timeoutMs, workspace, now, actionI
                 return {
                     type: "screenshot",
                     path: screenshotPath.relative,
+                    absolutePath: screenshotPath.absolute,
+                    uri: toGatewayFileUrl(screenshotPath.absolute),
                     fullPage: Boolean(action.fullPage)
                 };
             }
@@ -929,6 +1048,7 @@ async function openBrowserSessionRuntime(options = {}, dependencies = {}, input
     let transportFallbackReason = null;
     let reusedExistingCdpSession = false;
     let context = null;
+    let videoRecording = null;
     try {
         userDataDirSelection = resolveUserDataDir(configWorkspace, resolvedOptions, deps);
         const selectedUserDataDir = userDataDirSelection;
@@ -940,8 +1060,15 @@ async function openBrowserSessionRuntime(options = {}, dependencies = {}, input
         const executablePath = input.executablePath || resolvedOptions.defaultExecutablePath;
         const { extensionIds, extensionDirs } = resolveEnabledExtensions(configWorkspace, resolvedOptions);
         const chromeArgs = buildChromeArgs(extensionDirs);
+        const requestedVideoRecording = resolveVideoOutputDir(workspace, input.recordVideo, deps.now);
         const usePersistentLaunch = preferPersistentLaunch(resolvedOptions, selectedUserDataDir.persistentProfile);
+        const effectivePersistentLaunch = usePersistentLaunch || Boolean(requestedVideoRecording);
         const transportRequested = resolveBrowserTransportPreference(input.transport || resolvedOptions.browserTransport);
+        if (requestedVideoRecording && "relay" === transportRequested) throw new Error("Video recording is only supported with Playwright persistent launch sessions.");
+        if (requestedVideoRecording) videoRecording = {
+            ...requestedVideoRecording,
+            handles: new Set()
+        };
         const closeTransientSessions = async ()=>{
             if (launchedContext?.close) {
                 try {
@@ -975,8 +1102,8 @@ async function openBrowserSessionRuntime(options = {}, dependencies = {}, input
             reusedExistingCdpSession = false;
         };
         const initializeViaPlaywright = async ()=>{
-            if (usePersistentLaunch) {
-                launchedContext = await launchPersistentContext(playwright, selectedUserDataDir.userDataDir, executablePath, headless, startupTimeoutMs, chromeArgs);
+            if (effectivePersistentLaunch) {
+                launchedContext = await launchPersistentContext(playwright, selectedUserDataDir.userDataDir, executablePath, headless, startupTimeoutMs, chromeArgs, videoRecording);
                 context = launchedContext;
                 browserTransport = "persistent-context";
                 return;
@@ -1057,7 +1184,7 @@ async function openBrowserSessionRuntime(options = {}, dependencies = {}, input
                             const launchPersistent = playwright.chromium.launchPersistentContext;
                             if ("function" != typeof launchPersistent) throw new Error(`CDP connection failed for persistent profile after retry. Initial error: ${cdpMessage}. Retry error: ${retryMessage}`);
                             logger.warn(`browser_control CDP retry failed for persistent profile, falling back to persistent launch: ${retryMessage}`);
-                            launchedContext = await launchPersistentContext(playwright, selectedUserDataDir.userDataDir, executablePath, headless, startupTimeoutMs, chromeArgs);
+                            launchedContext = await launchPersistentContext(playwright, selectedUserDataDir.userDataDir, executablePath, headless, startupTimeoutMs, chromeArgs, videoRecording);
                             context = launchedContext;
                             browserTransport = "persistent-context";
                         }
@@ -1065,7 +1192,7 @@ async function openBrowserSessionRuntime(options = {}, dependencies = {}, input
                         const launchPersistent = playwright.chromium.launchPersistentContext;
                         if ("function" != typeof launchPersistent) throw cdpError;
                         logger.warn(`browser_control CDP connection failed, retrying with persistent launch: ${cdpMessage}`);
-                        launchedContext = await launchPersistentContext(playwright, selectedUserDataDir.userDataDir, executablePath, headless, startupTimeoutMs, chromeArgs);
+                        launchedContext = await launchPersistentContext(playwright, selectedUserDataDir.userDataDir, executablePath, headless, startupTimeoutMs, chromeArgs, videoRecording);
                         context = launchedContext;
                         browserTransport = "persistent-context";
                     }
@@ -1076,7 +1203,7 @@ async function openBrowserSessionRuntime(options = {}, dependencies = {}, input
         else try {
             await initializeViaPlaywright();
         } catch (playwrightError) {
-            if ("auto" !== transportRequested || !relayConfig) throw playwrightError;
+            if ("auto" !== transportRequested || !relayConfig || requestedVideoRecording) throw playwrightError;
             await closeTransientSessions();
             const relayTimeoutMs = Math.min(startupTimeoutMs, DEFAULT_RELAY_CONNECT_TIMEOUT_MS);
             const playwrightMessage = playwrightError instanceof Error ? playwrightError.message : String(playwrightError);
@@ -1092,6 +1219,7 @@ async function openBrowserSessionRuntime(options = {}, dependencies = {}, input
             now: deps.now,
             headless,
             context: resolvedContext,
+            activePage: null,
             userDataDirSelection: selectedUserDataDir,
             browserTransport,
             transportRequested,
@@ -1101,6 +1229,7 @@ async function openBrowserSessionRuntime(options = {}, dependencies = {}, input
             launchedContext,
             browser,
             chromeSession,
+            videoRecording,
             closed: false
         };
     } catch (error) {
@@ -1112,16 +1241,42 @@ async function openBrowserSessionRuntime(options = {}, dependencies = {}, input
         throw error;
     }
 }
-async function selectActivePage(context) {
-    let page = context.pages().at(-1);
-    if (!page) page = await context.newPage();
+function getPageUrl(page) {
+    try {
+        return page.url().trim();
+    } catch  {
+        return "";
+    }
+}
+function isBrowserInternalPageUrl(url) {
+    const normalized = url.trim().toLowerCase();
+    if (!normalized) return true;
+    return normalized.startsWith("about:blank") || normalized.startsWith("chrome://") || normalized.startsWith("chrome-extension://") || normalized.startsWith("devtools://") || normalized.startsWith("edge://") || normalized.startsWith("extension://") || normalized.startsWith("moz-extension://");
+}
+function selectPreferredPage(pages) {
+    for(let index = pages.length - 1; index >= 0; index -= 1){
+        const candidate = pages[index];
+        if (candidate) {
+            if (!isBrowserInternalPageUrl(getPageUrl(candidate))) return candidate;
+        }
+    }
+    return pages.at(-1) || null;
+}
+async function selectActivePage(runtime) {
+    const pages = runtime.context.pages();
+    const preferredPage = selectPreferredPage(pages);
+    let page = runtime.activePage && pages.includes(runtime.activePage) ? runtime.activePage : null;
+    if (preferredPage && (!page || isBrowserInternalPageUrl(getPageUrl(page)))) page = preferredPage;
+    if (!page) page = await runtime.context.newPage();
+    runtime.activePage = page;
     if ("function" == typeof page.bringToFront) await page.bringToFront();
     return page;
 }
 async function executeBrowserSessionRuntime(runtime, input = {}) {
     if (runtime.closed) throw new Error("Browser session is already closed.");
     const timeoutMs = input.timeoutMs ?? DEFAULT_ACTION_TIMEOUT_MS;
-    const page = await selectActivePage(runtime.context);
+    const page = await selectActivePage(runtime);
+    await registerPageVideoHandle(runtime, page);
     if (input.url) await page.goto(input.url, {
         waitUntil: "domcontentloaded",
         timeout: timeoutMs
@@ -1131,6 +1286,7 @@ async function executeBrowserSessionRuntime(runtime, input = {}) {
         const result = await runBrowserAction(page, action, timeoutMs, runtime.workspace, runtime.now, index);
         actionResults.push(result);
     }
+    const media = buildScreenshotMedia(runtime.workspace, actionResults);
     return {
         browser: "cdp" === runtime.browserTransport ? "chrome-cdp" : "persistent-context" === runtime.browserTransport ? "chrome-playwright" : "chrome-relay",
         transport: runtime.browserTransport,
@@ -1147,22 +1303,34 @@ async function executeBrowserSessionRuntime(runtime, input = {}) {
         extensions: runtime.extensionIds,
         finalUrl: page.url(),
         title: await page.title(),
-        actionResults
+        actionResults,
+        media,
+        videoRecording: summarizeVideoRecording(runtime.videoRecording, runtime.videoRecording ? "recording" : "inactive", 0)
     };
 }
 async function closeBrowserSessionRuntime(runtime, dependencies = {}) {
-    if (runtime.closed) return;
+    if (runtime.closed) return {
+        media: [],
+        videoRecording: summarizeVideoRecording(runtime.videoRecording, "inactive", 0)
+    };
     runtime.closed = true;
     const deps = createBrowserDependencies(dependencies);
+    const recording = runtime.videoRecording;
     await closeOptionalHandle(runtime.launchedContext);
+    const media = await finalizeRecordedVideos(runtime);
     if (runtime.browser && !runtime.reusedExistingCdpSession) await closeHandle(runtime.browser);
     await closeHandle(runtime.chromeSession);
     if (runtime.userDataDirSelection.releaseLock) runtime.userDataDirSelection.releaseLock();
     if (!runtime.userDataDirSelection.persistentProfile) deps.removeDir(runtime.userDataDirSelection.userDataDir);
+    return {
+        media,
+        videoRecording: summarizeVideoRecording(recording, recording ? "saved" : "inactive", media.length)
+    };
 }
 exports.BrowserActionSchema = __webpack_exports__.BrowserActionSchema;
 exports.BrowserControlInputSchema = __webpack_exports__.BrowserControlInputSchema;
 exports.BrowserSessionActionInputSchema = __webpack_exports__.BrowserSessionActionInputSchema;
+exports.BrowserSessionVideoRecordingSchema = __webpack_exports__.BrowserSessionVideoRecordingSchema;
 exports.BrowserTransportPreferenceSchema = __webpack_exports__.BrowserTransportPreferenceSchema;
 exports.DEFAULT_ACTION_TIMEOUT_MS = __webpack_exports__.DEFAULT_ACTION_TIMEOUT_MS;
 exports.clearStaleDevtoolsArtifacts = __webpack_exports__.clearStaleDevtoolsArtifacts;
@@ -1175,6 +1343,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "BrowserActionSchema",
     "BrowserControlInputSchema",
     "BrowserSessionActionInputSchema",
+    "BrowserSessionVideoRecordingSchema",
     "BrowserTransportPreferenceSchema",
     "DEFAULT_ACTION_TIMEOUT_MS",
     "clearStaleDevtoolsArtifacts",

package/dist/agent/tools/browser_runtime.d.ts

@@ -5,6 +5,17 @@ export declare const BrowserTransportPreferenceSchema: z.ZodEnum<{
     playwright: "playwright";
     relay: "relay";
 }>;
+declare const BrowserVideoSizeSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BrowserSessionVideoRecordingSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    dir: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>]>;
 export declare const BrowserActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"navigate">;
     url: z.ZodString;
@@ -391,9 +402,14 @@ export declare const BrowserSessionActionInputSchema: z.ZodObject<{
     timeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, z.core.$strip>;
 export type BrowserControlInput = z.infer<typeof BrowserControlInputSchema>;
+export type BrowserSessionVideoRecordingInput = z.infer<typeof BrowserSessionVideoRecordingSchema>;
 export type BrowserSessionActionInput = z.infer<typeof BrowserSessionActionInputSchema>;
 export type BrowserAction = z.infer<typeof BrowserActionSchema>;
 export type BrowserTransportPreference = z.infer<typeof BrowserTransportPreferenceSchema>;
+export type BrowserVideoSize = z.infer<typeof BrowserVideoSizeSchema>;
+type BrowserVideoLike = {
+    path: () => Promise<string>;
+};
 export type BrowserPageLike = {
     goto: (url: string, options?: {
         waitUntil?: "domcontentloaded";
@@ -432,6 +448,7 @@ export type BrowserPageLike = {
         path: string;
         fullPage?: boolean;
     }) => Promise<unknown>;
+    video?: () => BrowserVideoLike | null;
     title: () => Promise<string>;
     url: () => string;
 };
@@ -450,6 +467,10 @@ type LaunchPersistentContextOptions = {
     timeout?: number;
     args?: string[];
     ignoreDefaultArgs?: string[];
+    recordVideo?: {
+        dir: string;
+        size?: BrowserVideoSize;
+    };
 };
 type PlaywrightLike = {
     chromium: {
@@ -514,12 +535,40 @@ export type BrowserUserDataDirSelection = {
     profileId?: string;
     releaseLock?: () => void;
 };
+type BrowserVideoRecordingSelection = {
+    dirAbsolute: string;
+    dirRelative: string;
+    size?: BrowserVideoSize;
+};
+type BrowserVideoRecordingRuntime = BrowserVideoRecordingSelection & {
+    handles: Set<BrowserVideoLike>;
+};
+export interface BrowserGeneratedMedia {
+    kind: "image" | "video";
+    source: "screenshot" | "video-recording";
+    path: string;
+    relativePath: string;
+    uri: string;
+    url: string;
+    mimeType: string;
+    name: string;
+    fullPage?: boolean;
+    actionIndex?: number | null;
+}
+export interface BrowserVideoRecordingSummary {
+    enabled: boolean;
+    state: "inactive" | "recording" | "saved";
+    dir: string | null;
+    size: BrowserVideoSize | null;
+    videoCount: number;
+}
 export interface BrowserSessionRuntime {
     workspace: string;
     configWorkspace: string;
     now: () => number;
     headless: boolean;
     context: BrowserContextLike;
+    activePage: BrowserPageLike | null;
     userDataDirSelection: BrowserUserDataDirSelection;
     browserTransport: BrowserRuntimeTransport;
     transportRequested: BrowserTransportPreference;
@@ -529,6 +578,7 @@ export interface BrowserSessionRuntime {
     launchedContext: BrowserContextLike | null;
     browser: BrowserLike | null;
     chromeSession: StartedChromeSession | null;
+    videoRecording: BrowserVideoRecordingRuntime | null;
     closed: boolean;
 }
 export interface BrowserExecutionSummary {
@@ -548,13 +598,20 @@ export interface BrowserExecutionSummary {
     finalUrl: string;
     title: string;
     actionResults: Record<string, unknown>[];
+    media: BrowserGeneratedMedia[];
+    videoRecording: BrowserVideoRecordingSummary | null;
 }
-type BrowserSessionOpenInput = Partial<Pick<BrowserControlInput, "headless" | "timeoutMs" | "executablePath" | "transport">>;
+type BrowserSessionOpenInput = Partial<Pick<BrowserControlInput, "headless" | "timeoutMs" | "executablePath" | "transport">> & {
+    recordVideo?: BrowserSessionVideoRecordingInput;
+};
 type BrowserSessionExecutionInput = Partial<Pick<BrowserControlInput, "url" | "actions" | "timeoutMs">>;
 export declare const createBrowserDependencies: (dependencies?: Partial<BrowserControlDependencies>) => BrowserControlDependencies;
 export declare function clearStaleDevtoolsArtifacts(userDataDir: string): void;
 export declare function runBrowserAction(page: BrowserPageLike, action: BrowserAction, timeoutMs: number, workspace: string, now: () => number, actionIndex: number): Promise<Record<string, unknown>>;
 export declare function openBrowserSessionRuntime(options?: BrowserControlToolOptions, dependencies?: Partial<BrowserControlDependencies>, input?: BrowserSessionOpenInput): Promise<BrowserSessionRuntime>;
 export declare function executeBrowserSessionRuntime(runtime: BrowserSessionRuntime, input?: BrowserSessionExecutionInput): Promise<BrowserExecutionSummary>;
-export declare function closeBrowserSessionRuntime(runtime: BrowserSessionRuntime, dependencies?: Partial<BrowserControlDependencies>): Promise<void>;
+export declare function closeBrowserSessionRuntime(runtime: BrowserSessionRuntime, dependencies?: Partial<BrowserControlDependencies>): Promise<{
+    media: BrowserGeneratedMedia[];
+    videoRecording: BrowserVideoRecordingSummary | null;
+}>;
 export {};