runline 0.9.0 → 0.11.0

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

@@ -0,0 +1,19 @@
+import * as t from "typebox";
+import { api, compactRecord } from "./shared.js";
+export function registerCaptchaActions(rl) {
+    rl.registerAction("captcha.status", {
+        description: "Get CAPTCHA detection/solving status for a Steel session.",
+        inputSchema: t.Object({ sessionId: t.String() }),
+        async execute(input, ctx) { return api(ctx, `/v1/sessions/${encodeURIComponent(input.sessionId)}/captchas/status`); },
+    });
+    rl.registerAction("captcha.solve", {
+        description: "Trigger CAPTCHA solving for all detected CAPTCHAs or a specific task/url/page.",
+        inputSchema: t.Object({ sessionId: t.String(), taskId: t.Optional(t.String()), url: t.Optional(t.String()), pageId: t.Optional(t.String()) }),
+        async execute(input, ctx) { const { sessionId, ...body } = input; return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/captchas/solve`, { method: "POST", body: compactRecord(body) }); },
+    });
+    rl.registerAction("captcha.solveImage", {
+        description: "Solve an image CAPTCHA by XPath selectors.",
+        inputSchema: t.Object({ sessionId: t.String(), imageXPath: t.String(), inputXPath: t.String(), url: t.Optional(t.String()) }),
+        async execute(input, ctx) { const { sessionId, ...body } = input; return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/captchas/solve-image`, { method: "POST", body: compactRecord(body) }); },
+    });
+}

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

@@ -0,0 +1,38 @@
+import * as t from "typebox";
+import { api, compactRecord } from "./shared.js";
+const CREDENTIAL_KEY_SCHEMA = {
+    origin: t.String({ description: "Credential origin" }),
+    namespace: t.Optional(t.String({ description: "Credential namespace (defaults to Steel default)" })),
+};
+export function registerCredentialActions(rl) {
+    rl.registerAction("credential.list", {
+        description: "List Steel credentials. Filter by origin and/or namespace.",
+        inputSchema: t.Object({ namespace: t.Optional(t.String()), origin: t.Optional(t.String()) }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/credentials", { query: input });
+        },
+    });
+    rl.registerAction("credential.create", {
+        description: "Create a Steel credential for an origin/namespace. Value may include username, password, and totpSecret.",
+        inputSchema: t.Object({ ...CREDENTIAL_KEY_SCHEMA, value: t.Any({ description: "Credential payload" }) }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/credentials", { method: "POST", body: compactRecord(input) });
+        },
+    });
+    rl.registerAction("credential.get", {
+        description: "Retrieve credential metadata by origin and optional namespace.",
+        inputSchema: t.Object(CREDENTIAL_KEY_SCHEMA),
+        async execute(input, ctx) {
+            const result = await api(ctx, "/v1/credentials", { query: compactRecord(input) });
+            const credentials = result.credentials;
+            return Array.isArray(credentials) ? (credentials[0] ?? null) : null;
+        },
+    });
+    rl.registerAction("credential.delete", {
+        description: "Delete a Steel credential by origin and optional namespace.",
+        inputSchema: t.Object(CREDENTIAL_KEY_SCHEMA),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/credentials", { method: "DELETE", body: compactRecord(input) });
+        },
+    });
+}

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

@@ -0,0 +1,46 @@
+import * as t from "typebox";
+import { api } from "./shared.js";
+function extensionForm(input) {
+    const form = new FormData();
+    if (input.url !== undefined && input.url !== null)
+        form.set("url", String(input.url));
+    return form;
+}
+export function registerExtensionActions(rl) {
+    rl.registerAction("extension.list", {
+        description: "List Steel Chrome extensions installed for the organization.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/extensions");
+        },
+    });
+    rl.registerAction("extension.upload", {
+        description: "Upload an extension from a Chrome Web Store URL. Raw zip/crx uploads should use the API directly.",
+        inputSchema: t.Object({ url: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/extensions", { method: "POST", body: extensionForm(input) });
+        },
+    });
+    rl.registerAction("extension.update", {
+        description: "Update an extension from a Chrome Web Store URL.",
+        inputSchema: t.Object({ id: t.String(), url: t.String() }),
+        async execute(input, ctx) {
+            const { id, ...body } = input;
+            return api(ctx, `/v1/extensions/${encodeURIComponent(String(id))}`, { method: "PUT", body: extensionForm(body) });
+        },
+    });
+    rl.registerAction("extension.delete", {
+        description: "Delete an extension by ID.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/extensions/${encodeURIComponent(input.id)}`, { method: "DELETE" });
+        },
+    });
+    rl.registerAction("extension.deleteAll", {
+        description: "Delete all organization extensions.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/extensions", { method: "DELETE" });
+        },
+    });
+}

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

@@ -0,0 +1,96 @@
+import * as t from "typebox";
+import { api } from "./shared.js";
+function fileSchema() {
+    return {
+        file: t.String({ description: "Global/session file path or absolute URL. Raw local file upload is not supported through Runline JSON actions." }),
+        path: t.Optional(t.String({ description: "Destination path" })),
+    };
+}
+function fileForm(input) {
+    const form = new FormData();
+    form.set("file", String(input.file));
+    if (input.path !== undefined && input.path !== null && input.path !== "")
+        form.set("path", String(input.path));
+    return form;
+}
+function normalizeFilePath(path) {
+    return String(path).replace(/^\/files\/+/, "").replace(/^\/+/, "");
+}
+function encodeFilePath(path) {
+    return normalizeFilePath(path).split("/").map(encodeURIComponent).join("/");
+}
+export function registerFileActions(rl) {
+    rl.registerAction("file.list", {
+        description: "List global Steel files.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/files");
+        },
+    });
+    rl.registerAction("file.upload", {
+        description: "Upload a global file from a URL or existing path reference.",
+        inputSchema: t.Object(fileSchema()),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/files", { method: "POST", body: fileForm(input) });
+        },
+    });
+    rl.registerAction("file.download", {
+        description: "Download/read a global file by path. Binary files are returned as text by fetch when possible; use the URL/API directly for raw bytes.",
+        inputSchema: t.Object({ path: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/files/${encodeFilePath(input.path)}`);
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a global Steel file by path.",
+        inputSchema: t.Object({ path: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/files/${encodeFilePath(input.path)}`, { method: "DELETE" });
+        },
+    });
+    rl.registerAction("sessionFile.list", {
+        description: "List files in a Steel session filesystem.",
+        inputSchema: t.Object({ sessionId: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.sessionId)}/files`);
+        },
+    });
+    rl.registerAction("sessionFile.upload", {
+        description: "Upload/copy a URL or global file into a session filesystem.",
+        inputSchema: t.Object({ sessionId: t.String(), ...fileSchema() }),
+        async execute(input, ctx) {
+            const { sessionId, ...body } = input;
+            return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/files`, { method: "POST", body: fileForm(body) });
+        },
+    });
+    rl.registerAction("sessionFile.download", {
+        description: "Download/read a session file by path.",
+        inputSchema: t.Object({ sessionId: t.String(), path: t.String() }),
+        async execute(input, ctx) {
+            const { sessionId, path } = input;
+            return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/files/${encodeFilePath(path)}`);
+        },
+    });
+    rl.registerAction("sessionFile.downloadArchive", {
+        description: "Download/read the zip archive of all files in a session.",
+        inputSchema: t.Object({ sessionId: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.sessionId)}/files.zip`);
+        },
+    });
+    rl.registerAction("sessionFile.delete", {
+        description: "Delete a file from a session filesystem.",
+        inputSchema: t.Object({ sessionId: t.String(), path: t.String() }),
+        async execute(input, ctx) {
+            const { sessionId, path } = input;
+            return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/files/${encodeFilePath(path)}`, { method: "DELETE" });
+        },
+    });
+    rl.registerAction("sessionFile.deleteAll", {
+        description: "Delete all files in a session filesystem.",
+        inputSchema: t.Object({ sessionId: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.sessionId)}/files`, { method: "DELETE" });
+        },
+    });
+}

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

@@ -1,378 +1,25 @@
-const NAME = "steel";
-const DEFAULT_STEEL_BASE = "https://api.steel.dev";
-// ── Helpers ──────────────────────────────────────────────────────────
-function compactText(value) {
-    return String(value ?? "").replace(/\s+/g, " ").trim();
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function clampWait(value, fallback = 9000, max = 45000) {
-    const n = Number(value);
-    if (!Number.isFinite(n) || n <= 0)
-        return fallback;
-    return Math.min(Math.floor(n), max);
-}
-function getConnectionConfig(ctx) {
-    const cfg = (ctx?.connection?.config ?? {});
-    return {
-        steelApiKey: compactText(cfg.steelApiKey),
-        steelBaseUrl: compactText(cfg.steelBaseUrl || DEFAULT_STEEL_BASE).replace(/\/+$/, ""),
-        steelProxyUrl: compactText(cfg.steelProxyUrl),
-    };
-}
-class SteelClient {
-    apiKey;
-    baseUrl;
-    proxyUrl;
-    constructor(cfg) {
-        if (!cfg.steelApiKey) {
-            throw new Error("Missing STEEL_API_KEY. Configure it before using the steel browser plugin.");
-        }
-        this.apiKey = cfg.steelApiKey;
-        this.baseUrl = cfg.steelBaseUrl || DEFAULT_STEEL_BASE;
-        this.proxyUrl = cfg.steelProxyUrl;
-    }
-    async request(method, pathname, body) {
-        const resp = await fetch(`${this.baseUrl}${pathname}`, {
-            method,
-            headers: { "steel-api-key": this.apiKey, "content-type": "application/json" },
-            body: body ? JSON.stringify(body) : undefined,
-        });
-        const text = await resp.text();
-        if (!resp.ok) {
-            throw new Error(`Steel ${method} ${pathname} -> ${resp.status}: ${text.slice(0, 300)}`);
-        }
-        return text ? JSON.parse(text) : {};
-    }
-    async createSession({ useProxy = false, timeout = 180000 } = {}) {
-        const body = { timeout };
-        if (useProxy) {
-            if (!this.proxyUrl)
-                throw new Error("useProxy requested but STEEL_PROXY_URL is not configured.");
-            body.proxyUrl = this.proxyUrl;
-        }
-        return this.request("POST", "/v1/sessions", body);
-    }
-    async release(sessionId) {
-        try {
-            return await this.request("POST", `/v1/sessions/${sessionId}/release`);
-        }
-        catch {
-            return { success: false };
-        }
-    }
-    // Steel's hosted screenshot API stores the image on images.steel.dev and
-    // returns a PUBLIC URL (no auth) that renders inline in chat — the bytes
-    // never have to traverse the agent runtime (which strips large base64).
-    async hostedScreenshot({ url, fullPage = false, delay, useProxy = false }) {
-        const body = { url };
-        if (fullPage)
-            body.fullPage = true;
-        if (Number.isFinite(delay) && delay > 0)
-            body.delay = delay;
-        if (useProxy) {
-            if (!this.proxyUrl)
-                throw new Error("useProxy requested but STEEL_PROXY_URL is not configured.");
-            body.proxyUrl = this.proxyUrl;
-        }
-        const res = await this.request("POST", "/v1/screenshot", body);
-        return res?.url || null;
-    }
-}
-class CdpConnection {
-    wsUrl;
-    nextId = 0;
-    pending = new Map();
-    ws = null;
-    constructor(wsUrl) {
-        this.wsUrl = wsUrl;
-    }
-    connect() {
-        return new Promise((resolve, reject) => {
-            if (typeof WebSocket === "undefined") {
-                reject(new Error("Global WebSocket is not available in this runtime; the steel browser plugin needs Node 22+ / Bun."));
-                return;
-            }
-            const ws = new WebSocket(this.wsUrl);
-            this.ws = ws;
-            const onError = () => reject(new Error("Steel CDP websocket connection failed"));
-            ws.addEventListener("open", () => {
-                ws.removeEventListener("error", onError);
-                resolve();
-            });
-            ws.addEventListener("error", onError);
-            ws.addEventListener("close", () => {
-                for (const [, p] of this.pending)
-                    p.reject(new Error("Steel CDP connection closed"));
-                this.pending.clear();
-            });
-            ws.addEventListener("message", (ev) => {
-                let msg;
-                try {
-                    msg = JSON.parse(typeof ev.data === "string" ? ev.data : String(ev.data));
-                }
-                catch {
-                    return;
-                }
-                if (msg.id != null && this.pending.has(msg.id)) {
-                    const p = this.pending.get(msg.id);
-                    this.pending.delete(msg.id);
-                    if (msg.error)
-                        p.reject(new Error(msg.error.message || "CDP error"));
-                    else
-                        p.resolve(msg.result);
-                }
-            });
-        });
-    }
-    send(method, params = {}, sessionId, timeoutMs = 45000) {
-        const requestId = ++this.nextId;
-        const payload = { id: requestId, method, params };
-        if (sessionId)
-            payload.sessionId = sessionId;
-        return new Promise((resolve, reject) => {
-            this.pending.set(requestId, { resolve, reject });
-            try {
-                this.ws.send(JSON.stringify(payload));
-            }
-            catch (err) {
-                this.pending.delete(requestId);
-                reject(err);
-                return;
-            }
-            setTimeout(() => {
-                if (this.pending.has(requestId)) {
-                    this.pending.delete(requestId);
-                    reject(new Error(`CDP ${method} timed out after ${timeoutMs}ms`));
-                }
-            }, timeoutMs);
-        });
-    }
-    close() {
-        try {
-            this.ws?.close();
-        }
-        catch {
-            /* noop */
-        }
-    }
-}
-class PageDriver {
-    conn;
-    sessionId;
-    constructor(conn, sessionId) {
-        this.conn = conn;
-        this.sessionId = sessionId;
-    }
-    static async attachFirstPage(conn) {
-        const { targetInfos } = await conn.send("Target.getTargets");
-        let target = (targetInfos || []).find((t) => t.type === "page");
-        if (!target) {
-            const created = await conn.send("Target.createTarget", { url: "about:blank" });
-            target = { targetId: created.targetId };
-        }
-        const { sessionId } = await conn.send("Target.attachToTarget", { targetId: target.targetId, flatten: true });
-        const driver = new PageDriver(conn, sessionId);
-        await conn.send("Page.enable", {}, sessionId);
-        await conn.send("Runtime.enable", {}, sessionId);
-        return driver;
-    }
-    async navigate(url) {
-        await this.conn.send("Page.navigate", { url }, this.sessionId);
-    }
-    async eval(expression) {
-        const r = await this.conn.send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true }, this.sessionId);
-        if (r.exceptionDetails) {
-            throw new Error(`page eval failed: ${r.exceptionDetails.text || r.exceptionDetails.exception?.description || "exception"}`);
-        }
-        return r.result?.value;
-    }
-}
-// Render a URL in a Steel browser and run a callback with the live PageDriver.
-async function withRenderedPage(cfg, { url, useProxy = false, waitMs = 9000, waitSelector }, fn) {
-    const steel = new SteelClient(cfg);
-    const session = await steel.createSession({ useProxy });
-    const wsUrl = `${session.websocketUrl}${session.websocketUrl.includes("?") ? "&" : "?"}apiKey=${encodeURIComponent(steel.apiKey)}`;
-    const conn = new CdpConnection(wsUrl);
-    try {
-        await conn.connect();
-        const page = await PageDriver.attachFirstPage(conn);
-        await page.navigate(url);
-        await sleep(Math.min(waitMs, 6000));
-        if (waitSelector) {
-            const deadline = Date.now() + Math.max(0, waitMs - 6000);
-            while (Date.now() < deadline) {
-                const found = await page.eval(`!!document.querySelector(${JSON.stringify(waitSelector)})`);
-                if (found)
-                    break;
-                await sleep(1500);
-            }
-        }
-        else if (waitMs > 6000) {
-            await sleep(waitMs - 6000);
-        }
-        return await fn(page, { sessionId: session.id, viewer: session.sessionViewerUrl });
-    }
-    finally {
-        conn.close();
-        await steel.release(session.id);
-    }
-}
-function robotWallExpr() {
-    return `/are you a human|verify you('| a)re not a robot|not a robot|enable javascript|access denied|unusual traffic/i.test((document.body && document.body.innerText || '').slice(0, 4000))`;
-}
-// ── Plugin registration ──────────────────────────────────────────────
+import * as t from "typebox";
+import { registerBrowserActions } from "./browser.js";
+import { registerCaptchaActions } from "./captchas.js";
+import { registerCredentialActions } from "./credentials.js";
+import { registerExtensionActions } from "./extensions.js";
+import { registerFileActions } from "./files.js";
+import { registerProfileActions } from "./profiles.js";
+import { registerSessionActions } from "./sessions.js";
 export default function steel(rl) {
-    rl.setName(NAME);
+    rl.setName("steel");
     rl.setVersion("0.1.0");
-    rl.setConnectionSchema({
-        steelApiKey: {
-            type: "string",
-            required: true,
+    rl.setConnectionSchema(t.Object({
+        apiKey: t.String({
+            description: "Steel API key (https://app.steel.dev/settings/api-keys)",
             env: "STEEL_API_KEY",
-            description: "Steel.dev API key for the cloud browser. Store only in secrets.",
-        },
-        steelBaseUrl: {
-            type: "string",
-            required: false,
-            env: "STEEL_API_BASE",
-            default: DEFAULT_STEEL_BASE,
-            description: "Steel.dev API base URL.",
-        },
-        steelProxyUrl: {
-            type: "string",
-            required: false,
-            env: "STEEL_PROXY_URL",
-            description: "Residential proxy URL, used only when an action passes useProxy:true. Store only in secrets.",
-        },
-    });
-    rl.registerAction("browser.scrape", {
-        description: "Render a URL in a real Steel cloud browser (executes JavaScript, passes 'verify you're not a robot' walls) and return its content. Use this instead of plain fetch for JS-heavy or anti-bot pages. No proxy by default; set useProxy:true only for datacenter-IP-blocked surfaces.",
-        inputSchema: {
-            url: { type: "string", required: true, description: "Absolute URL to render." },
-            format: { type: "string", required: false, default: "text", description: "text (visible innerText), html (rendered outerHTML), or links (anchor list)." },
-            waitMs: { type: "number", required: false, default: 9000, description: "How long to let the page render (ms, max 45000)." },
-            waitSelector: { type: "string", required: false, description: "Optional CSS selector to wait for before extracting." },
-            maxChars: { type: "number", required: false, default: 20000, description: "Cap on returned content length." },
-            useProxy: { type: "boolean", required: false, default: false, description: "Route through the residential proxy. Only needed for datacenter-blocked sites." },
-        },
-        async execute(input, ctx) {
-            const cfg = getConnectionConfig(ctx);
-            const url = compactText(input.url);
-            if (!/^https?:\/\//i.test(url))
-                throw new Error("url must be an absolute http(s) URL");
-            const format = compactText(input.format || "text").toLowerCase();
-            const maxChars = Number(input.maxChars) > 0 ? Math.min(Number(input.maxChars), 200000) : 20000;
-            return withRenderedPage(cfg, { url, useProxy: input.useProxy === true, waitMs: clampWait(input.waitMs), waitSelector: input.waitSelector }, async (page, meta) => {
-                const title = await page.eval("document.title");
-                const finalUrl = await page.eval("location.href");
-                const robotWall = await page.eval(robotWallExpr());
-                let content;
-                if (format === "html")
-                    content = await page.eval("document.documentElement.outerHTML");
-                else if (format === "links")
-                    content = JSON.stringify(await page.eval(`Array.from(document.querySelectorAll('a[href]')).slice(0,300).map(function(a){return {text:(a.innerText||'').replace(/\\s+/g,' ').trim().slice(0,80), href:a.href};})`));
-                else
-                    content = await page.eval("document.body && document.body.innerText || ''");
-                return {
-                    url,
-                    finalUrl,
-                    title,
-                    robotWall,
-                    format,
-                    truncated: String(content).length > maxChars,
-                    content: String(content).slice(0, maxChars),
-                    viewerUrl: meta.viewer,
-                    source: "steel.browser.scrape",
-                };
-            });
-        },
-    });
-    rl.registerAction("browser.extract", {
-        description: "Render a URL in a Steel browser and extract structured data via a map of CSS selectors. Returns the first match (or all matches with all:true) of each selector as text.",
-        inputSchema: {
-            url: { type: "string", required: true, description: "Absolute URL to render." },
-            selectors: { type: "object", required: true, description: "Map of { fieldName: cssSelector }." },
-            all: { type: "boolean", required: false, default: false, description: "Return all matches per selector instead of the first." },
-            waitMs: { type: "number", required: false, default: 9000, description: "Render wait (ms)." },
-            waitSelector: { type: "string", required: false, description: "Optional CSS selector to wait for." },
-            useProxy: { type: "boolean", required: false, default: false, description: "Route through the residential proxy." },
-        },
-        async execute(input, ctx) {
-            const cfg = getConnectionConfig(ctx);
-            const url = compactText(input.url);
-            if (!/^https?:\/\//i.test(url))
-                throw new Error("url must be an absolute http(s) URL");
-            const selectors = input.selectors && typeof input.selectors === "object" ? input.selectors : null;
-            if (!selectors || !Object.keys(selectors).length)
-                throw new Error("selectors must be a non-empty object of { name: cssSelector }");
-            const all = input.all === true;
-            return withRenderedPage(cfg, { url, useProxy: input.useProxy === true, waitMs: clampWait(input.waitMs), waitSelector: input.waitSelector }, async (page, meta) => {
-                const expr = `
-            (function(){
-              var sels = ${JSON.stringify(selectors)};
-              var all = ${all};
-              function txt(el){ return el ? (el.innerText||el.textContent||'').replace(/\\s+/g,' ').trim() : null; }
-              var out = {};
-              for (var k in sels){
-                if (all){ out[k] = Array.from(document.querySelectorAll(sels[k])).slice(0,50).map(txt); }
-                else { out[k] = txt(document.querySelector(sels[k])); }
-              }
-              return out;
-            })()`;
-                return {
-                    url,
-                    finalUrl: await page.eval("location.href"),
-                    title: await page.eval("document.title"),
-                    robotWall: await page.eval(robotWallExpr()),
-                    data: await page.eval(expr),
-                    viewerUrl: meta.viewer,
-                    source: "steel.browser.extract",
-                };
-            });
-        },
-    });
-    rl.registerAction("browser.screenshot", {
-        description: "Capture a screenshot of a URL with the Steel cloud browser and return imageUrl — a PUBLIC, login-free PNG link (https://images.steel.dev/...). To 'send a screenshot', put imageUrl in your reply: WhatsApp/Slack render it inline and anyone can open it without a Steel account. base64 is opt-in and usually pointless (the agent runtime strips large base64 from action results), so prefer imageUrl.",
-        inputSchema: {
-            url: { type: "string", required: true, description: "Absolute URL to capture." },
-            fullPage: { type: "boolean", required: false, default: false, description: "Capture the full scrollable page." },
-            waitMs: { type: "number", required: false, default: 0, description: "Milliseconds to wait before capturing (for JS-heavy pages). 0 = capture as soon as loaded." },
-            useProxy: { type: "boolean", required: false, default: false, description: "Route through the BYO residential proxy (STEEL_PROXY_URL). Only for datacenter-IP-blocked surfaces." },
-            includeBase64: { type: "boolean", required: false, default: false, description: "Also fetch the hosted image and return raw PNG base64. Off by default — share imageUrl instead." },
-        },
-        async execute(input, ctx) {
-            const cfg = getConnectionConfig(ctx);
-            const url = compactText(input.url);
-            if (!/^https?:\/\//i.test(url))
-                throw new Error("url must be an absolute http(s) URL");
-            const steel = new SteelClient(cfg);
-            const imageUrl = await steel.hostedScreenshot({
-                url,
-                fullPage: input.fullPage === true,
-                delay: clampWait(input.waitMs, 0, 30000) || undefined,
-                useProxy: input.useProxy === true,
-            });
-            const out = {
-                url,
-                imageUrl,
-                mimeType: "image/png",
-                note: "Share imageUrl — it's a public, login-free screenshot link that renders inline in chat. Put it in your reply text; don't screenshot-to-base64.",
-                source: "steel.browser.screenshot",
-            };
-            if (input.includeBase64 === true && imageUrl) {
-                try {
-                    const resp = await fetch(imageUrl);
-                    const buf = Buffer.from(await resp.arrayBuffer());
-                    out.byteLength = buf.length;
-                    out.base64 = buf.toString("base64");
-                }
-                catch (e) {
-                    out.base64Error = String(e?.message || e);
-                }
-            }
-            return out;
-        },
-    });
+        }),
+    }));
+    registerSessionActions(rl);
+    registerBrowserActions(rl);
+    registerFileActions(rl);
+    registerCredentialActions(rl);
+    registerProfileActions(rl);
+    registerExtensionActions(rl);
+    registerCaptchaActions(rl);
 }

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

@@ -0,0 +1,55 @@
+import * as t from "typebox";
+import { api } from "./shared.js";
+function profileForm(input) {
+    const form = new FormData();
+    for (const [key, value] of Object.entries(input)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        form.set(key, typeof value === "string" ? value : JSON.stringify(value));
+    }
+    return form;
+}
+export function registerProfileActions(rl) {
+    rl.registerAction("profile.list", {
+        description: "List Steel browser profiles.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/profiles");
+        },
+    });
+    rl.registerAction("profile.get", {
+        description: "Get a Steel profile by ID.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/profiles/${encodeURIComponent(input.id)}`);
+        },
+    });
+    rl.registerAction("profile.create", {
+        description: "Create an empty persisted Steel profile by opening and releasing a short-lived session with persistProfile=true. For userDataDir archive imports, use the Steel API directly.",
+        inputSchema: t.Object({
+            timeout: t.Optional(t.Number({ description: "Temporary session timeout in milliseconds" })),
+            inactivityTimeout: t.Optional(t.Number({ description: "Temporary session inactivity timeout in milliseconds" })),
+        }),
+        async execute(input, ctx) {
+            const session = await api(ctx, "/v1/sessions", {
+                method: "POST",
+                body: { timeout: 60000, inactivityTimeout: 30000, ...input, persistProfile: true },
+            });
+            try {
+                await api(ctx, `/v1/sessions/${encodeURIComponent(String(session.id))}/release`, { method: "POST" });
+            }
+            catch {
+                // Profile creation is tied to session release. Return the session metadata even if release cleanup fails.
+            }
+            return { profileId: session.profileId, session };
+        },
+    });
+    rl.registerAction("profile.update", {
+        description: "Update profile metadata/settings used by later sessions.",
+        inputSchema: t.Object({ id: t.String(), userAgent: t.Optional(t.String()), proxy: t.Optional(t.Any()), metadata: t.Optional(t.Any()) }),
+        async execute(input, ctx) {
+            const { id, ...body } = input;
+            return api(ctx, `/v1/profiles/${encodeURIComponent(String(id))}`, { method: "PATCH", body: profileForm(body) });
+        },
+    });
+}