runline 0.9.0 → 0.11.0

package/dist/core/engine.d.ts

@@ -9,6 +9,28 @@ export interface EngineOptions {
     timeoutMs?: number;
     memoryLimitBytes?: number;
 }
+/**
+ * Whether to arm the host-side RSS watchdog for a worker run.
+ *
+ * node enforces resourceLimits.maxOldGenerationSizeMb natively, and the
+ * watchdog measures *whole-process* RSS — arming it there would risk false
+ * kills from unrelated host allocations (e.g. a concurrent execute). bun
+ * ignores resourceLimits, so the watchdog is the only memory backstop.
+ */
+export declare function shouldArmRssWatchdog(versions?: Partial<Record<string, string>>): boolean;
+/**
+ * Executes agent code in a node:worker_threads worker.
+ *
+ * The worker is an ergonomic coding surface, not a security sandbox: agent
+ * code gets the full host JS runtime (Buffer, crypto, etc.) plus injected
+ * action proxies. Isolation properties we do enforce, fail-soft:
+ *
+ * - timeout: worker.terminate() — interrupts even `while(true){}`
+ * - memory: resourceLimits.maxOldGenerationSizeMb (node) + an RSS-delta
+ *   watchdog fallback; both surface as a clean "Memory limit exceeded" error
+ * - crash containment: a dead worker never takes the host process down, and
+ *   each execute() gets a fresh worker, so the engine stays usable
+ */
 export declare class ExecutionEngine {
     private registry;
     private config;
@@ -16,6 +38,4 @@ export declare class ExecutionEngine {
     execute(code: string, options?: EngineOptions): Promise<ExecuteResult>;
     private invokeAction;
     private resolveConnection;
-    private drainAsync;
-    private drainJobs;
 }

package/dist/core/engine.js

@@ -1,7 +1,34 @@
 import { readFileSync } from "node:fs";
-import { getQuickJS, shouldInterruptAfterDeadline, } from "quickjs-emscripten";
+import { Worker } from "node:worker_threads";
 import { applyEnvOverrides, updateConnectionConfig } from "../config/loader.js";
 import { formatValidationError, helpInputs, isTypedInputSchema, validateTypedInput, } from "../plugin/schema.js";
+/**
+ * Whether to arm the host-side RSS watchdog for a worker run.
+ *
+ * node enforces resourceLimits.maxOldGenerationSizeMb natively, and the
+ * watchdog measures *whole-process* RSS — arming it there would risk false
+ * kills from unrelated host allocations (e.g. a concurrent execute). bun
+ * ignores resourceLimits, so the watchdog is the only memory backstop.
+ */
+export function shouldArmRssWatchdog(versions = process.versions) {
+    return Boolean(versions.bun);
+}
+// Extra slack on top of the configured memory limit for the RSS watchdog,
+// since whole-process RSS includes the host's own working set.
+const RSS_WATCHDOG_SLACK_BYTES = 128 * 1024 * 1024;
+/**
+ * Executes agent code in a node:worker_threads worker.
+ *
+ * The worker is an ergonomic coding surface, not a security sandbox: agent
+ * code gets the full host JS runtime (Buffer, crypto, etc.) plus injected
+ * action proxies. Isolation properties we do enforce, fail-soft:
+ *
+ * - timeout: worker.terminate() — interrupts even `while(true){}`
+ * - memory: resourceLimits.maxOldGenerationSizeMb (node) + an RSS-delta
+ *   watchdog fallback; both surface as a clean "Memory limit exceeded" error
+ * - crash containment: a dead worker never takes the host process down, and
+ *   each execute() gets a fresh worker, so the engine stays usable
+ */
 export class ExecutionEngine {
     registry;
     config;
@@ -12,119 +39,121 @@ export class ExecutionEngine {
     async execute(code, options) {
         const timeoutMs = options?.timeoutMs ?? this.config.timeoutMs;
         const memoryLimitBytes = options?.memoryLimitBytes ?? this.config.memoryLimitBytes;
-        const deadlineMs = Date.now() + timeoutMs;
         const logs = [];
-        const pendingDeferreds = new Set();
-        const QuickJS = await getQuickJS();
-        const runtime = QuickJS.newRuntime();
-        try {
-            runtime.setMemoryLimit(memoryLimitBytes);
-            runtime.setInterruptHandler(shouldInterruptAfterDeadline(deadlineMs));
-            const context = runtime.newContext();
+        const plugins = this.registry.listPlugins();
+        const source = buildWorkerSource(code, plugins.map((p) => p.name), buildHelpData(plugins));
+        return new Promise((resolve) => {
+            const memoryLimitMb = Math.max(8, Math.floor(memoryLimitBytes / (1024 * 1024)));
+            let worker;
             try {
-                // Inject log bridge
-                const logBridge = context.newFunction("__runline_log", (levelHandle, lineHandle) => {
-                    const level = context.getString(levelHandle);
-                    const line = context.getString(lineHandle);
-                    logs.push(`[${level}] ${line}`);
-                    return context.undefined;
+                worker = new Worker(source, {
+                    eval: true,
+                    resourceLimits: { maxOldGenerationSizeMb: memoryLimitMb },
                 });
-                context.setProp(context.global, "__runline_log", logBridge);
-                logBridge.dispose();
-                // Inject action bridge
-                const actionBridge = context.newFunction("__runline_invoke", (pathHandle, argsHandle) => {
-                    const path = context.getString(pathHandle);
-                    const args = argsHandle === undefined ||
-                        context.typeof(argsHandle) === "undefined"
-                        ? undefined
-                        : context.dump(argsHandle);
-                    const deferred = context.newPromise();
-                    pendingDeferreds.add(deferred);
-                    deferred.settled.finally(() => pendingDeferreds.delete(deferred));
-                    this.invokeAction(path, args).then((value) => {
-                        if (!deferred.alive)
-                            return;
-                        if (value === undefined) {
-                            deferred.resolve();
-                            return;
-                        }
-                        const serialized = JSON.stringify(value);
-                        const handle = context.newString(serialized);
-                        deferred.resolve(handle);
-                        handle.dispose();
-                    }, (err) => {
-                        if (!deferred.alive)
-                            return;
-                        const msg = err instanceof Error ? err.message : String(err);
-                        const handle = context.newError(msg);
-                        deferred.reject(handle);
-                        handle.dispose();
-                    });
-                    return deferred.handle;
+            }
+            catch (err) {
+                resolve({ result: null, error: formatError(err), logs });
+                return;
+            }
+            let settled = false;
+            const finish = (r) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeoutTimer);
+                clearInterval(rssTimer);
+                void worker.terminate();
+                resolve(r);
+            };
+            const timeoutTimer = setTimeout(() => {
+                finish({
+                    result: null,
+                    error: `Execution timed out after ${timeoutMs}ms`,
+                    logs,
                 });
-                context.setProp(context.global, "__runline_invoke", actionBridge);
-                actionBridge.dispose();
-                const plugins = this.registry.listPlugins();
-                const pluginNames = plugins.map((p) => p.name);
-                const helpData = buildHelpData(plugins);
-                const source = buildExecutionSource(code, pluginNames, helpData);
-                const evaluated = context.evalCode(source, "runline-sandbox.js");
-                if (evaluated.error) {
-                    const error = context.dump(evaluated.error);
-                    evaluated.error.dispose();
-                    return { result: null, error: formatError(error), logs };
-                }
-                // Set up promise tracking
-                context.setProp(context.global, "__runline_result", evaluated.value);
-                evaluated.value.dispose();
-                const stateResult = context.evalCode(`(function(p){ var s = { v: void 0, e: void 0, settled: false };
-           var fmtErr = function(e){ if (e && typeof e === 'object') { var m = typeof e.message === 'string' ? e.message : ''; var st = typeof e.stack === 'string' ? e.stack : ''; if (m && st) return st.indexOf(m) === -1 ? m + '\\n' + st : st; if (m) return m; if (st) return st; } return String(e); };
-           p.then(function(v){ s.v = v; s.settled = true; }, function(e){ s.e = fmtErr(e); s.settled = true; }); return s; })(__runline_result)`);
-                if (stateResult.error) {
-                    const error = context.dump(stateResult.error);
-                    stateResult.error.dispose();
-                    return { result: null, error: formatError(error), logs };
-                }
-                const stateHandle = stateResult.value;
-                try {
-                    await this.drainAsync(context, runtime, pendingDeferreds, deadlineMs, timeoutMs);
-                    const settled = readProp(context, stateHandle, "settled") === true;
-                    if (!settled) {
-                        return {
+            }, timeoutMs);
+            let rssTimer;
+            if (shouldArmRssWatchdog()) {
+                const baselineRss = process.memoryUsage().rss;
+                rssTimer = setInterval(() => {
+                    const delta = process.memoryUsage().rss - baselineRss;
+                    if (delta > memoryLimitBytes + RSS_WATCHDOG_SLACK_BYTES) {
+                        finish({
                             result: null,
-                            error: `Execution timed out after ${timeoutMs}ms`,
+                            error: `Memory limit exceeded (${memoryLimitMb}MB)`,
                             logs,
-                        };
-                    }
-                    const error = readProp(context, stateHandle, "e");
-                    if (error !== undefined) {
-                        return { result: null, error: formatError(error), logs };
+                        });
                     }
-                    return { result: readProp(context, stateHandle, "v"), logs };
-                }
-                finally {
-                    stateHandle.dispose();
-                }
+                }, 100);
+                rssTimer.unref?.();
             }
-            finally {
-                for (const d of pendingDeferreds) {
-                    if (d.alive)
-                        d.dispose();
+            // A reply can race the worker's death; losing it is fine — the run is
+            // over either way — but it must never surface as an unhandled
+            // rejection in the host.
+            const reply = (message) => {
+                if (settled)
+                    return;
+                try {
+                    worker.postMessage(message);
+                }
+                catch {
+                    // worker already gone
                 }
-                pendingDeferreds.clear();
-                context.dispose();
-            }
-        }
-        catch (err) {
-            return {
-                result: null,
-                error: formatError(err),
-                logs,
             };
-        }
-        finally {
-            runtime.dispose();
-        }
+            worker.on("message", (msg) => {
+                if (settled)
+                    return;
+                if (msg.t === "log") {
+                    logs.push(`[${msg.level}] ${msg.line}`);
+                }
+                else if (msg.t === "invoke") {
+                    this.invokeAction(msg.path, msg.args).then((value) => {
+                        let serialized;
+                        try {
+                            serialized = toPlainJson(value);
+                        }
+                        catch (err) {
+                            reply({
+                                t: "result",
+                                id: msg.id,
+                                ok: false,
+                                error: `Action result not JSON-serializable: ${err instanceof Error ? err.message : String(err)}`,
+                            });
+                            return;
+                        }
+                        reply({ t: "result", id: msg.id, ok: true, value: serialized });
+                    }, (err) => {
+                        reply({
+                            t: "result",
+                            id: msg.id,
+                            ok: false,
+                            error: err instanceof Error ? err.message : String(err),
+                        });
+                    });
+                }
+                else if (msg.t === "done") {
+                    finish(msg.ok
+                        ? { result: msg.result, logs }
+                        : { result: null, error: msg.error ?? "Unknown error", logs });
+                }
+            });
+            worker.on("error", (err) => {
+                finish({
+                    result: null,
+                    error: err.code === "ERR_WORKER_OUT_OF_MEMORY"
+                        ? `Memory limit exceeded (${memoryLimitMb}MB)`
+                        : formatError(err),
+                    logs,
+                });
+            });
+            worker.on("exit", (exitCode) => {
+                finish({
+                    result: null,
+                    error: `Worker exited unexpectedly (code ${exitCode})`,
+                    logs,
+                });
+            });
+        });
     }
     async invokeAction(path, args) {
         const resolved = this.registry.resolveAction(path);
@@ -164,53 +193,17 @@ export class ExecutionEngine {
         };
         return applyEnvOverrides(base, plugin.connectionConfigSchema);
     }
-    async drainAsync(context, runtime, pendingDeferreds, deadlineMs, timeoutMs) {
-        this.drainJobs(context, runtime, deadlineMs, timeoutMs);
-        while (pendingDeferreds.size > 0) {
-            const remainingMs = deadlineMs - Date.now();
-            if (remainingMs <= 0) {
-                throw new Error(`Execution timed out after ${timeoutMs}ms`);
-            }
-            let timer;
-            try {
-                await Promise.race([
-                    Promise.race([...pendingDeferreds].map((d) => d.settled)),
-                    new Promise((_, reject) => {
-                        timer = setTimeout(() => reject(new Error(`Execution timed out after ${timeoutMs}ms`)), remainingMs);
-                    }),
-                ]);
-            }
-            finally {
-                if (timer)
-                    clearTimeout(timer);
-            }
-            this.drainJobs(context, runtime, deadlineMs, timeoutMs);
-        }
-        this.drainJobs(context, runtime, deadlineMs, timeoutMs);
-    }
-    drainJobs(context, runtime, deadlineMs, timeoutMs) {
-        while (runtime.hasPendingJob()) {
-            if (Date.now() >= deadlineMs) {
-                throw new Error(`Execution timed out after ${timeoutMs}ms`);
-            }
-            const pending = runtime.executePendingJobs();
-            if (pending.error) {
-                const error = context.dump(pending.error);
-                pending.error.dispose();
-                throw error instanceof Error ? error : new Error(String(error));
-            }
-        }
-    }
 }
 // ── Helpers ──────────────────────────────────────────────
-function readProp(context, handle, key) {
-    const prop = context.getProp(handle, key);
-    try {
-        return context.dump(prop);
-    }
-    finally {
-        prop.dispose();
-    }
+/**
+ * JSON round-trip to (a) guarantee structured-clone compatibility and
+ * (b) preserve the previous engine's value semantics, where every action
+ * result crossed a JSON boundary (Dates → ISO strings, no Maps, etc.).
+ */
+function toPlainJson(value) {
+    if (value === undefined)
+        return undefined;
+    return JSON.parse(JSON.stringify(value));
 }
 function formatError(cause) {
     if (cause instanceof Error)
@@ -224,13 +217,13 @@ function formatError(cause) {
     return String(cause);
 }
 // MiniSearch UMD bundle, vendored at the package root and inlined into the
-// sandbox source. UMD attaches `MiniSearch` to globalThis in a non-CJS /
-// non-AMD env (QuickJS), so pasting the file is enough.
+// worker source. Inside the worker it is evaluated in a local scope with a
+// fresh `module`/`exports` pair so the UMD takes its CommonJS branch.
 //
 // `../../vendor/...` resolves identically from src/core/engine.ts (dev) and
 // dist/core/engine.js (published) because tsc preserves the `core/` subdir.
 // See vendor/README.md for the upgrade procedure.
-const __minisearchSource = readFileSync(new URL("../../vendor/minisearch.umd.js", import.meta.url), "utf8");
+const minisearchSource = readFileSync(new URL("../../vendor/minisearch.umd.js", import.meta.url), "utf8");
 function buildHelpData(plugins) {
     const data = {};
     for (const p of plugins) {
@@ -242,7 +235,7 @@ function buildHelpData(plugins) {
     }
     return data;
 }
-function buildExecutionSource(code, pluginNames = [], helpData = {}) {
+function buildWorkerSource(code, pluginNames = [], helpData = {}) {
     const trimmed = code.trim();
     const looksLikeArrow = (trimmed.startsWith("async") || trimmed.startsWith("(")) &&
         trimmed.includes("=>");
@@ -250,18 +243,68 @@ function buildExecutionSource(code, pluginNames = [], helpData = {}) {
         ? `const __fn = (${trimmed});\nif (typeof __fn !== 'function') throw new Error('Code must evaluate to a function');\nreturn await __fn();`
         : code;
     const wrapped = `"use strict";
-const __invoke = __runline_invoke;
-const __log = __runline_log;
-try { delete globalThis.__runline_invoke; } catch {}
-try { delete globalThis.__runline_log; } catch {}
+const { parentPort: __port } = require("node:worker_threads");
+
+// process.exit would be runtime-divergent here: node kills the worker
+// synchronously, bun lets the completion message race the exit and can
+// report a silent undefined success. Make it a regular, catchable error.
+process.exit = (code) => {
+  throw new Error('process.exit(' + (code ?? 0) + ') is not available in the runline sandbox; return a value instead');
+};
+
+// ── host bridge ──
+let __seq = 0;
+const __pending = new Map();
+__port.on("message", (m) => {
+  if (!m || m.t !== "result") return;
+  const p = __pending.get(m.id);
+  if (!p) return;
+  __pending.delete(m.id);
+  if (m.ok) p.resolve(m.value);
+  else p.reject(new Error(m.error));
+});
+const __invoke = (path, args) => new Promise((resolve, reject) => {
+  const id = ++__seq;
+  __pending.set(id, { resolve, reject });
+  try {
+    __port.postMessage({ t: "invoke", id, path, args });
+  } catch (e) {
+    __pending.delete(id);
+    reject(e);
+  }
+});
+const __log = (level, line) => {
+  try { __port.postMessage({ t: "log", level, line }); } catch {}
+};
 
 const __fmt = (v) => {
   if (typeof v === 'string') return v;
   try { return JSON.stringify(v); } catch { return String(v); }
 };
 
-// Inlined MiniSearch UMD — attaches MiniSearch to globalThis inside the sandbox.
-${__minisearchSource}
+const __fmtErr = (e) => {
+  if (e && typeof e === 'object') {
+    const m = typeof e.message === 'string' ? e.message : '';
+    const st = typeof e.stack === 'string' ? e.stack : '';
+    if (m && st) return st.indexOf(m) === -1 ? m + '\\n' + st : st;
+    if (m) return m;
+    if (st) return st;
+  }
+  return String(e);
+};
+
+// JSON round-trip mirrors the host's toPlainJson: keeps results
+// structured-clone-safe and preserves JSON value semantics.
+const __toJson = (v) => v === undefined ? undefined : JSON.parse(JSON.stringify(v));
+
+// Inlined MiniSearch UMD, evaluated with a local module/exports so the UMD
+// takes its CommonJS branch regardless of the worker's module scope.
+const MiniSearch = (function () {
+  const module = { exports: {} };
+  const exports = module.exports;
+  ${minisearchSource}
+  return module.exports;
+})();
 
 const __help = ${JSON.stringify(helpData)};
 
@@ -273,8 +316,7 @@ const __makeProxy = (path = []) => new Proxy(() => undefined, {
   apply(_t, _this, args) {
     const p = path.join('.');
     if (!p) throw new Error('Action path missing');
-    return Promise.resolve(__invoke(p, args[0]))
-      .then((raw) => raw === undefined ? undefined : JSON.parse(raw));
+    return __invoke(p, args[0]);
   },
 });
 
@@ -296,7 +338,7 @@ const __formatSignature = (plugin, entry) => {
   return plugin + '.' + entry.action + (fields ? '({ ' + fields + ' })' : '()');
 };
 
-// Build a MiniSearch index over every action path. Indexed at sandbox
+// Build a MiniSearch index over every action path. Indexed at worker
 // startup, queried by actions.find().
 const __search = (() => {
   const docs = [];
@@ -416,6 +458,18 @@ const fetch = () => { throw new Error('fetch is disabled in runline sandbox'); }
 
 (async () => {
 ${body}
-})()`;
+})().then(
+  (v) => {
+    try {
+      __port.postMessage({ t: "done", ok: true, result: __toJson(v) });
+    } catch (e) {
+      __port.postMessage({ t: "done", ok: false, error: __fmtErr(e) });
+    }
+  },
+  (e) => {
+    __port.postMessage({ t: "done", ok: false, error: __fmtErr(e) });
+  },
+);
+`;
     return wrapped;
 }

package/dist/plugins/steel/src/browser.js

@@ -0,0 +1,175 @@
+import * as t from "typebox";
+import { SESSION_OPTIONS_SCHEMA, api, apiKey, compactRecord } from "./shared.js";
+const SCRAPE_SCHEMA = {
+    url: t.String({ description: "URL to scrape" }),
+    format: t.Optional(t.Array(t.String(), { description: "Formats: html, cleaned_html, markdown, readability" })),
+    delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+    useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+    screenshot: t.Optional(t.Boolean({ description: "Also capture a screenshot URL" })),
+    pdf: t.Optional(t.Boolean({ description: "Also capture a PDF URL" })),
+};
+const SCREENSHOT_SCHEMA = {
+    url: t.String({ description: "URL to screenshot" }),
+    fullPage: t.Optional(t.Boolean({ description: "Capture full scrollable page" })),
+    delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+    useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+};
+async function scrape(input, ctx) {
+    return api(ctx, "/v1/scrape", { method: "POST", body: compactRecord(input) });
+}
+async function screenshot(input, ctx) {
+    return api(ctx, "/v1/screenshot", { method: "POST", body: compactRecord(input) });
+}
+async function connectMiniCdp(cdpUrl) {
+    const ws = new WebSocket(cdpUrl);
+    let nextId = 0;
+    const pending = new Map();
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("CDP websocket connection timed out")), 30000);
+        ws.addEventListener("open", () => { clearTimeout(timer); resolve(); }, { once: true });
+        ws.addEventListener("error", () => { clearTimeout(timer); reject(new Error("CDP websocket connection failed")); }, { once: true });
+    });
+    ws.addEventListener("message", (event) => {
+        let message;
+        try {
+            message = JSON.parse(String(event.data));
+        }
+        catch {
+            return;
+        }
+        if (typeof message.id !== "number")
+            return;
+        const wait = pending.get(message.id);
+        if (!wait)
+            return;
+        pending.delete(message.id);
+        if (message.error)
+            wait.reject(new Error(JSON.stringify(message.error)));
+        else
+            wait.resolve(message.result);
+    });
+    const send = (method, params = {}, sessionId) => new Promise((resolve, reject) => {
+        const id = ++nextId;
+        pending.set(id, { resolve, reject });
+        ws.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
+        setTimeout(() => {
+            if (pending.delete(id))
+                reject(new Error(`CDP ${method} timed out`));
+        }, 30000);
+    });
+    const targets = await send("Target.getTargets");
+    const target = targets.targetInfos?.find((info) => info.type === "page") ?? targets.targetInfos?.[0];
+    if (!target)
+        throw new Error("Steel CDP session has no browser target");
+    const attached = await send("Target.attachToTarget", { targetId: target.targetId, flatten: true });
+    const sid = attached.sessionId;
+    const evaluate = async (expression) => {
+        const result = await send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true }, sid);
+        return result.result?.value;
+    };
+    const page = {
+        async goto(url, _options) {
+            await send("Page.navigate", { url }, sid);
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            return null;
+        },
+        title: () => evaluate("document.title"),
+        url: () => evaluate("location.href"),
+        text: () => evaluate("document.body?.innerText ?? ''"),
+        html: () => evaluate("document.documentElement?.outerHTML ?? ''"),
+        evaluate: (expression) => evaluate(`(${expression})()`),
+    };
+    return { page, browser: { close: () => ws.close() }, context: {}, close: () => ws.close() };
+}
+export function registerBrowserActions(rl) {
+    rl.registerAction("scrape", {
+        description: "One-shot Steel scrape. Loads a URL and returns requested formats such as markdown, html, cleaned_html, or readability.",
+        inputSchema: t.Object(SCRAPE_SCHEMA),
+        execute: scrape,
+    });
+    rl.registerAction("browser.scrape", {
+        description: "Backward-compatible alias for scrape.",
+        inputSchema: t.Object(SCRAPE_SCHEMA),
+        execute: scrape,
+    });
+    rl.registerAction("screenshot", {
+        description: "One-shot Steel screenshot. Returns a hosted PNG URL.",
+        inputSchema: t.Object(SCREENSHOT_SCHEMA),
+        execute: screenshot,
+    });
+    rl.registerAction("browser.screenshot", {
+        description: "Backward-compatible alias for screenshot.",
+        inputSchema: t.Object(SCREENSHOT_SCHEMA),
+        execute: screenshot,
+    });
+    rl.registerAction("browser.extract", {
+        description: "Fetch a page through Steel scrape and return selected content fields. Use selectors with browser.run for DOM-specific extraction.",
+        inputSchema: t.Object({
+            url: t.String({ description: "URL to scrape" }),
+            format: t.Optional(t.Array(t.String(), { description: "Formats to request; defaults to markdown and html" })),
+            delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+            useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+        }),
+        async execute(input, ctx) {
+            const body = { format: ["markdown", "html"], ...input };
+            return api(ctx, "/v1/scrape", { method: "POST", body: compactRecord(body) });
+        },
+    });
+    rl.registerAction("pdf", {
+        description: "One-shot Steel PDF capture. Returns a hosted PDF URL.",
+        inputSchema: t.Object({
+            url: t.String({ description: "URL to render as PDF" }),
+            delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+            useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+        }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/pdf", { method: "POST", body: compactRecord(input) });
+        },
+    });
+    rl.registerAction("browser.run", {
+        description: "Create a Steel session, connect with Playwright over CDP, run an async JavaScript script, then release by default. The script receives { page, browser, context, session }. Requires the host app to have playwright installed.",
+        inputSchema: t.Object({
+            script: t.String({ description: "Async JavaScript body. Example: await page.goto('https://example.com'); return { title: await page.title() };" }),
+            release: t.Optional(t.Boolean({ description: "Release the Steel session after the script finishes (default true)" })),
+            ...SESSION_OPTIONS_SCHEMA,
+        }),
+        async execute(input, ctx) {
+            const { script, release, ...sessionOptions } = input;
+            let playwright;
+            try {
+                playwright = await import("playwright");
+            }
+            catch (_error) {
+                throw new Error("steel.browser.run requires the host project to install playwright. Install playwright or use session.create + session.cdpUrl instead.");
+            }
+            const session = await api(ctx, "/v1/sessions", { method: "POST", body: compactRecord(sessionOptions) });
+            const cdpUrl = `wss://connect.steel.dev?apiKey=${encodeURIComponent(apiKey(ctx))}&sessionId=${encodeURIComponent(String(session.id))}`;
+            let browser;
+            try {
+                let context;
+                let page;
+                try {
+                    const playwrightBrowser = await playwright.chromium.connectOverCDP(cdpUrl, { timeout: 30000 });
+                    browser = playwrightBrowser;
+                    context = playwrightBrowser.contexts()[0] ?? await playwrightBrowser.newContext();
+                    page = context.pages()[0] ?? await context.newPage();
+                }
+                catch {
+                    const mini = await connectMiniCdp(cdpUrl);
+                    browser = mini.browser;
+                    context = mini.context;
+                    page = mini.page;
+                }
+                const fn = new Function("page", "browser", "context", "session", `return (async () => {\n${script}\n})();`);
+                const result = await fn(page, browser, context, session);
+                return { session, result };
+            }
+            finally {
+                await browser?.close()?.catch?.(() => { });
+                if (release !== false && session.id) {
+                    await api(ctx, `/v1/sessions/${encodeURIComponent(String(session.id))}/release`, { method: "POST" }).catch(() => { });
+                }
+            }
+        },
+    });
+}