runline 0.22.0 → 0.24.0

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

@@ -114,6 +114,17 @@ export default function shiftOcr(rl) {
                 description: "Override for URLs whose extension does not reveal the type. " +
                     "Inferred from the extension otherwise.",
             })),
+            provider: t.Optional(t.String({
+                minLength: 1,
+                pattern: "\\S",
+                description: "Provider ID from ocr.providers. Defaults to the first " +
+                    "catalog provider.",
+            })),
+            model: t.Optional(t.String({
+                minLength: 1,
+                pattern: "\\S",
+                description: "Model override. Defaults to the provider's defaultModel.",
+            })),
             pages: t.Optional(t.String({
                 minLength: 1,
                 pattern: "^\\d+(-\\d+)?(,\\d+(-\\d+)?)*$",
@@ -151,6 +162,8 @@ export default function shiftOcr(rl) {
                 method: "POST",
                 body: JSON.stringify({
                     document,
+                    ...(fields.provider ? { provider: fields.provider } : {}),
+                    ...(fields.model ? { model: fields.model } : {}),
                     ...(fields.pages ? { pages: fields.pages } : {}),
                     ...(fields.schema
                         ? {

package/dist/plugins/shiftPages/src/pages.js

@@ -1,11 +1,18 @@
 import * as t from "typebox";
-import { enumSchema, idSchema, listParams, PAGE_STATUS, PAGE_VISIBILITY, pageRenderUrl, pathSegment, request, STRICT_OBJECT, timestampSchema, withQuery, } from "./shared.js";
+import { enumSchema, idSchema, listParams, PAGE_STATUS, PAGE_TYPE, PAGE_VISIBILITY, pageRenderUrl, pathSegment, request, STRICT_OBJECT, timestampSchema, withQuery, } from "./shared.js";
 const PageSlug = t.String({
     minLength: 1,
     maxLength: 120,
     pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$",
     description: "Lowercase kebab-case page slug",
 });
+const OriginUrl = t.String({
+    minLength: 1,
+    format: "uri",
+    pattern: "^https://",
+    description: "HTTPS origin to proxy behind SSO (protected_origin pages only). " +
+        "Localhost and private IP hosts are rejected.",
+});
 export function registerPageActions(rl) {
     rl.registerAction("page.list", {
         access: "read",
@@ -33,9 +40,23 @@ export function registerPageActions(rl) {
             return body.page;
         },
     });
+    rl.registerAction("page.vexArtifacts", {
+        access: "read",
+        description: "List the shareable Vex artifacts on a managed deployment, sorted by " +
+            "title, each carrying the workspace it belongs to. Pass an artifact's " +
+            "ID to page.create with type vex_artifact to publish it. The " +
+            "deployment must belong to the API key's organization.",
+        inputSchema: t.Object({ deploymentId: idSchema("Managed Vex deployment ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, withQuery("/v1/pages/vex-artifacts", listParams(input)));
+            return body.artifacts;
+        },
+    });
     rl.registerAction("page.create", {
         access: "write",
-        description: "Create a draft hosted HTML page. Agents can publish it with page.publish.",
+        description: "Create a draft page and publish it with page.publish. hosted_html " +
+            "pages carry their own HTML; vex_artifact pages render a live Vex " +
+            "artifact (pass deploymentId and artifactId from page.vexArtifacts).",
         inputSchema: t.Object({
             slug: PageSlug,
             title: t.String({
@@ -44,14 +65,19 @@ export function registerPageActions(rl) {
                 pattern: "\\S",
                 description: "Page title",
             }),
+            type: t.Optional(enumSchema("Page type", PAGE_TYPE)),
             html: t.Optional(t.String({
                 maxLength: 1_000_000,
-                description: "Hosted HTML content",
+                description: "Hosted HTML content (hosted_html pages only)",
             })),
+            originUrl: t.Optional(OriginUrl),
+            deploymentId: t.Optional(idSchema("Managed Vex deployment ID (vex_artifact pages only)")),
+            artifactId: t.Optional(idSchema("Vex artifact ID (vex_artifact pages only)")),
             visibility: t.Optional(enumSchema("Page visibility", PAGE_VISIBILITY)),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
+            assertPageContent(fields);
             const body = await request(ctx, "/v1/pages", {
                 method: "POST",
                 body: JSON.stringify({
@@ -65,7 +91,9 @@ export function registerPageActions(rl) {
     });
     rl.registerAction("page.update", {
         access: "write",
-        description: "Update a hosted HTML page's slug, title, visibility, or HTML.",
+        description: "Update a page's slug, title, visibility, HTML, or — for vex_artifact " +
+            "pages — which deployment and artifact it renders. A page's type is " +
+            "fixed at creation.",
         inputSchema: t.Object({
             id: idSchema("Page ID"),
             slug: t.Optional(PageSlug),
@@ -78,8 +106,11 @@ export function registerPageActions(rl) {
             visibility: t.Optional(enumSchema("Page visibility", PAGE_VISIBILITY)),
             html: t.Optional(t.String({
                 maxLength: 1_000_000,
-                description: "Hosted HTML content",
+                description: "Hosted HTML content (hosted_html pages only)",
             })),
+            originUrl: t.Optional(OriginUrl),
+            deploymentId: t.Optional(idSchema("Managed Vex deployment ID (vex_artifact pages only)")),
+            artifactId: t.Optional(idSchema("Vex artifact ID (vex_artifact pages only)")),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id, ...fields } = input;
@@ -92,7 +123,8 @@ export function registerPageActions(rl) {
     });
     rl.registerAction("page.publish", {
         access: "write",
-        description: "Publish a Shift Labs hosted HTML page.",
+        description: "Publish a draft page, making it reachable at its render URL by the " +
+            "organization (or by invited viewers when visibility is invited).",
         inputSchema: t.Object({ id: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id } = input;
@@ -113,10 +145,10 @@ export function registerPageActions(rl) {
     rl.registerAction("page.shares", {
         access: "read",
         description: "List shares for a Shift Labs page.",
-        inputSchema: t.Object({ pageId: idSchema("Page ID") }, STRICT_OBJECT),
+        inputSchema: t.Object({ id: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { pageId } = input;
-            const body = await request(ctx, `/v1/pages/${pathSegment(pageId)}/shares`);
+            const { id } = input;
+            const body = await request(ctx, `/v1/pages/${pathSegment(id)}/shares`);
             return body.shares;
         },
     });
@@ -124,7 +156,7 @@ export function registerPageActions(rl) {
         access: "write",
         description: "Create a viewer share for a Shift Labs page.",
         inputSchema: t.Object({
-            pageId: idSchema("Page ID"),
+            id: idSchema("Page ID"),
             email: t.String({
                 minLength: 1,
                 format: "email",
@@ -133,8 +165,8 @@ export function registerPageActions(rl) {
             expiresAt: t.Optional(timestampSchema("Optional ISO-8601 expiration")),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { pageId, ...fields } = input;
-            const body = await request(ctx, `/v1/pages/${pathSegment(String(pageId))}/shares`, {
+            const { id, ...fields } = input;
+            const body = await request(ctx, `/v1/pages/${pathSegment(String(id))}/shares`, {
                 method: "POST",
                 body: JSON.stringify(fields),
             });
@@ -156,13 +188,38 @@ export function registerPageActions(rl) {
     rl.registerAction("page.renderUrl", {
         access: "read",
         description: "Return the authenticated render URL for a page.",
-        inputSchema: t.Object({ pageId: idSchema("Page ID") }, STRICT_OBJECT),
+        inputSchema: t.Object({ id: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { pageId } = input;
-            const body = await request(ctx, `/v1/pages/${pathSegment(pageId)}`);
+            const { id } = input;
+            const body = await request(ctx, `/v1/pages/${pathSegment(id)}`);
             return {
                 url: pageRenderUrl(body.page.organizationId, body.page.slug),
             };
         },
     });
 }
+/**
+ * The content rules the API enforces per page type, checked before the
+ * round-trip so a caller gets the reason rather than a bare 400. Each
+ * type owns exactly one content field.
+ */
+function assertPageContent(fields) {
+    const type = fields.type ?? "hosted_html";
+    const referencesArtifact = fields.deploymentId !== undefined || fields.artifactId !== undefined;
+    if (type !== "vex_artifact" && referencesArtifact) {
+        throw new Error("Only vex_artifact pages may reference a deployment or artifact");
+    }
+    if (type !== "protected_origin" && fields.originUrl !== undefined) {
+        throw new Error("Only protected_origin pages may set an originUrl");
+    }
+    if (type !== "hosted_html" && fields.html !== undefined) {
+        throw new Error("Only hosted_html pages may carry html");
+    }
+    if (type === "vex_artifact" &&
+        (fields.deploymentId === undefined || fields.artifactId === undefined)) {
+        throw new Error("vex_artifact pages require both deploymentId and artifactId");
+    }
+    if (type === "protected_origin" && fields.originUrl === undefined) {
+        throw new Error("protected_origin pages require an originUrl");
+    }
+}

package/dist/plugins/shiftPages/src/shared.js

@@ -1,6 +1,11 @@
 import { baseUrl, pathSegment } from "../../_shared/shiftCloud.js";
 export { enumSchema, idSchema, listParams, pathSegment, request, STRICT_OBJECT, timestampSchema, withQuery, } from "../../_shared/shiftCloud.js";
 export const PAGE_STATUS = ["draft", "published", "archived"];
+export const PAGE_TYPE = [
+    "hosted_html",
+    "protected_origin",
+    "vex_artifact",
+];
 export const PAGE_VISIBILITY = ["org", "invited"];
 export function pageRenderUrl(organizationId, slug) {
     return new URL(`/pages/${pathSegment(organizationId)}/${pathSegment(slug)}`, baseUrl()).toString();

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

@@ -9,7 +9,7 @@ import { registerTranscriptionActions } from "./transcription.js";
  */
 export default function shiftTranscription(rl) {
     rl.setName("shiftTranscription");
-    rl.setVersion("0.1.0");
+    rl.setVersion("0.2.0");
     rl.setConnectionSchema(t.Object({
         apiKey: t.String({
             description: "Shift Labs API key",

package/dist/plugins/shiftTranscription/src/transcription.js

@@ -28,6 +28,9 @@ export function registerTranscriptionActions(rl) {
                 pattern: "\\S",
                 description: "Label shown in Shift Cloud",
             })),
+            metadata: t.Optional(t.Record(t.String(), t.Unknown(), {
+                description: "Small caller-defined metadata object stored on the job",
+            })),
             waitSeconds: t.Optional(t.Number({
                 minimum: 0,
                 maximum: 120,
@@ -55,6 +58,7 @@ export function registerTranscriptionActions(rl) {
                     language: fields.language,
                     diarize: fields.diarize,
                     name: fields.name,
+                    metadata: fields.metadata,
                 }),
             });
             if (!fields.waitSeconds)
@@ -90,13 +94,25 @@ export function registerTranscriptionActions(rl) {
             return request(ctx, `/v1/services/transcription/jobs/${pathSegment(id)}/cancel`, { method: "POST" });
         },
     });
+    rl.registerAction("transcription.job.delete", {
+        access: "write",
+        description: "Permanently delete a finished (succeeded, failed, or canceled) " +
+            "transcription job, its transcript artifacts, and its uploaded " +
+            "source media when no other job shares it. Cancel live jobs first. " +
+            "This cannot be undone.",
+        inputSchema: t.Object({ id: Id }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            return request(ctx, `/v1/services/transcription/jobs/${pathSegment(id)}`, { method: "DELETE" });
+        },
+    });
     rl.registerAction("transcription.artifact.list", {
         access: "read",
         description: "List the available transcript artifacts for a job.",
-        inputSchema: t.Object({ jobId: Id }, STRICT_OBJECT),
+        inputSchema: t.Object({ id: Id }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { jobId } = input;
-            const body = await request(ctx, `/v1/services/transcription/jobs/${pathSegment(jobId)}/artifacts`);
+            const { id } = input;
+            const body = await request(ctx, `/v1/services/transcription/jobs/${pathSegment(id)}/artifacts`);
             return body.artifacts;
         },
     });
@@ -106,14 +122,14 @@ export function registerTranscriptionActions(rl) {
             "return subtitles; json returns the full timestamped document. Set " +
             "downloadOnly=true to return the short-lived signed download grant.",
         inputSchema: t.Object({
-            jobId: Id,
+            id: Id,
             format: t.Optional(enumSchema("Transcript format", [...TRANSCRIPT_FORMAT])),
             downloadOnly: t.Optional(t.Boolean({ description: "Return a signed download grant only" })),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
             const format = fields.format ?? "txt";
-            const grant = await request(ctx, `/v1/services/transcription/jobs/${pathSegment(fields.jobId)}/artifacts/${pathSegment(format)}/download`, { method: "POST" });
+            const grant = await request(ctx, `/v1/services/transcription/jobs/${pathSegment(fields.id)}/artifacts/${pathSegment(format)}/download`, { method: "POST" });
             if (fields.downloadOnly ||
                 grant.artifact.sizeBytes > MAX_TRANSCRIPT_BYTES) {
                 return { format, ...grant };

package/dist/plugins/shiftWork/src/issues.js

@@ -1,5 +1,30 @@
 import * as t from "typebox";
 import { cursorSchema, enumSchema, ISSUE_PRIORITY, ISSUE_SOURCE, ISSUE_STATUS, idSchema, listParams, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, withQuery, } from "./shared.js";
+const issueFields = {
+    title: t.String({
+        minLength: 1,
+        maxLength: 160,
+        pattern: "\\S",
+        description: "Issue title",
+    }),
+    description: t.Optional(t.String({ maxLength: 20_000, description: "Issue description" })),
+    projectId: t.Optional(idSchema("Project ID")),
+    parentIssueId: t.Optional(idSchema("Parent Issue ID")),
+    sortOrder: t.Optional(t.Integer({ minimum: 0 })),
+    status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
+    priority: t.Optional(enumSchema("Issue priority", ISSUE_PRIORITY)),
+    assigneeUserId: t.Optional(idSchema("Assignee user ID")),
+    startAt: t.Optional(timestampSchema("ISO-8601 start timestamp")),
+    dueAt: t.Optional(timestampSchema("ISO-8601 due timestamp")),
+    deploymentId: t.Optional(idSchema("Deployment ID")),
+    workspaceId: t.Optional(idSchema("Workspace ID")),
+    sessionId: t.Optional(idSchema("Session ID")),
+    traceId: t.Optional(idSchema("Trace ID")),
+    fingerprint: t.Optional(t.String({ minLength: 1, maxLength: 512, pattern: "\\S" })),
+    labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64, pattern: "\\S" }))),
+    metadata: t.Optional(t.Record(t.String(), t.Unknown(), { description: "Issue metadata" })),
+    source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
+};
 const issueListFields = {
     status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
     projectId: t.Optional(idSchema("Project ID")),
@@ -14,6 +39,15 @@ const issueListFields = {
         description: "Max results, default 50",
     })),
 };
+const eventListFields = {
+    id: idSchema("Issue ID"),
+    cursor: t.Optional(cursorSchema()),
+    limit: t.Optional(t.Integer({
+        minimum: 1,
+        maximum: 100,
+        description: "Max results, default 50",
+    })),
+};
 export function registerIssueActions(rl) {
     rl.registerAction("issue.list", {
         access: "read",
@@ -45,38 +79,10 @@ export function registerIssueActions(rl) {
     rl.registerAction("issue.create", {
         access: "write",
         description: "Create an Issue. Leave projectId empty for inbox work; parentIssueId requires a Project.",
-        inputSchema: t.Object({
-            title: t.String({
-                minLength: 1,
-                maxLength: 160,
-                pattern: "\\S",
-                description: "Issue title",
-            }),
-            description: t.Optional(t.String({ maxLength: 20_000, description: "Issue description" })),
-            projectId: t.Optional(idSchema("Project ID")),
-            parentIssueId: t.Optional(idSchema("Parent Issue ID")),
-            sortOrder: t.Optional(t.Integer({ minimum: 0 })),
-            status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
-            priority: t.Optional(enumSchema("Issue priority", ISSUE_PRIORITY)),
-            source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
-            assigneeUserId: t.Optional(idSchema("Assignee user ID")),
-            startAt: t.Optional(timestampSchema("ISO-8601 start timestamp")),
-            dueAt: t.Optional(timestampSchema("ISO-8601 due timestamp")),
-            deploymentId: t.Optional(idSchema("Deployment ID")),
-            workspaceId: t.Optional(idSchema("Workspace ID")),
-            sessionId: t.Optional(idSchema("Session ID")),
-            traceId: t.Optional(idSchema("Trace ID")),
-            fingerprint: t.Optional(t.String({ minLength: 1, maxLength: 512, pattern: "\\S" })),
-            labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64, pattern: "\\S" }))),
-            metadata: t.Optional(t.Record(t.String(), t.Unknown(), { description: "Issue metadata" })),
-        }, STRICT_OBJECT),
+        inputSchema: t.Object(issueFields, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
-            if (fields.parentIssueId !== undefined &&
-                fields.projectId === undefined) {
-                throw new Error("projectId is required when parentIssueId is set");
-            }
-            assertDateOrder(fields.startAt, fields.dueAt, "Issue dueAt must not precede startAt");
+            assertIssueShape(fields);
             const body = await request(ctx, "/v1/issues", {
                 method: "POST",
                 body: JSON.stringify(fields),
@@ -84,6 +90,19 @@ export function registerIssueActions(rl) {
             return body.issue;
         },
     });
+    rl.registerAction("issue.report", {
+        access: "write",
+        description: "Report an Issue the way an agent should: source defaults to agent, " +
+            "and a repeated fingerprint folds into the existing Issue as a " +
+            "reported_again event instead of creating a duplicate.",
+        inputSchema: t.Object(issueFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const fields = input;
+            assertIssueShape(fields);
+            const body = await request(ctx, "/v1/issues/report", { method: "POST", body: JSON.stringify(fields) });
+            return body.issue;
+        },
+    });
     rl.registerAction("issue.update", {
         access: "write",
         description: "Update an Issue, including Project assignment, one-level parentage, ordering, status, dates, or assignee.",
@@ -127,6 +146,66 @@ export function registerIssueActions(rl) {
             return response.event;
         },
     });
+    rl.registerAction("issue.resolve", {
+        access: "write",
+        description: "Resolve an Issue, optionally with a closing comment recorded on the " +
+            "event timeline.",
+        inputSchema: t.Object({
+            id: idSchema("Issue ID"),
+            comment: t.Optional(t.String({
+                minLength: 1,
+                maxLength: 20_000,
+                pattern: "\\S",
+                description: "Resolution comment",
+            })),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}/resolve`, { method: "POST", body: JSON.stringify(fields) });
+            return body.issue;
+        },
+    });
+    rl.registerAction("issue.reopen", {
+        access: "write",
+        description: "Reopen a resolved or closed Issue.",
+        inputSchema: t.Object({ id: idSchema("Issue ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}/reopen`, { method: "POST" });
+            return body.issue;
+        },
+    });
+    rl.registerAction("issue.close", {
+        access: "write",
+        description: "Close an Issue without resolving it — the outcome for work that is " +
+            "abandoned rather than finished.",
+        inputSchema: t.Object({ id: idSchema("Issue ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}/close`, { method: "POST" });
+            return body.issue;
+        },
+    });
+    rl.registerAction("issue.event.list", {
+        access: "read",
+        description: "List the first page of an Issue's event timeline: status changes, " +
+            "comments, assignment and dependency history, newest first.",
+        inputSchema: t.Object(eventListFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...pagination } = input;
+            const body = await request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/events`, listParams(pagination)));
+            return body.events;
+        },
+    });
+    rl.registerAction("issue.event.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of an Issue's event timeline.",
+        inputSchema: t.Object(eventListFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...pagination } = input;
+            return request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/events`, listParams(pagination)));
+        },
+    });
     rl.registerAction("issue.dependency.list", {
         access: "read",
         description: "List the first page of blocking and blocked-by links.",
@@ -173,16 +252,23 @@ export function registerIssueActions(rl) {
         access: "write",
         description: "Remove an Issue dependency link.",
         inputSchema: t.Object({
-            issueId: idSchema("Issue ID"),
+            id: idSchema("Issue ID"),
             dependencyId: idSchema("Dependency ID"),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { issueId, dependencyId } = input;
-            await request(ctx, `/v1/issues/${pathSegment(issueId)}/dependencies/${pathSegment(dependencyId)}`, { method: "DELETE" });
+            const { id, dependencyId } = input;
+            await request(ctx, `/v1/issues/${pathSegment(id)}/dependencies/${pathSegment(dependencyId)}`, { method: "DELETE" });
             return { removed: true };
         },
     });
 }
+/** Shape rules the API enforces server-side, caught before the round-trip. */
+function assertIssueShape(fields) {
+    if (fields.parentIssueId !== undefined && fields.projectId === undefined) {
+        throw new Error("projectId is required when parentIssueId is set");
+    }
+    assertDateOrder(fields.startAt, fields.dueAt, "Issue dueAt must not precede startAt");
+}
 function assertDateOrder(start, end, message) {
     if (typeof start === "string" && typeof end === "string" && start > end) {
         throw new Error(message);

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { SESSION_OPTIONS_SCHEMA, api, apiKey, compactRecord } from "./shared.js";
+import { SESSION_OPTIONS_SCHEMA, api, cdpUrl, 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" })),
@@ -20,67 +20,6 @@ async function scrape(input, ctx) {
 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", {
         access: "write",
@@ -134,7 +73,7 @@ export function registerBrowserActions(rl) {
     });
     rl.registerAction("browser.run", {
         access: "write",
-        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.",
+        description: "Create a Steel session, connect with real Playwright over CDP, run an async JavaScript script, then release by default. The script receives the genuine Playwright { page, browser, context } plus session. Requires the host app to have playwright installed — this action fails rather than degrading if it is missing. For automation that works without a Playwright install, prefer the page.* actions, which drive the page semantically over CDP.",
         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)" })),
@@ -147,26 +86,19 @@ export function registerBrowserActions(rl) {
                 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.");
+                throw new Error("steel.browser.run needs playwright installed in the host project. " +
+                    "Install it, or use the steel.page.* actions, which need nothing installed.");
             }
             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))}`;
+            const endpoint = cdpUrl(ctx, 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;
-                }
+                // No fallback shim on purpose. A hand-rolled lookalike that
+                // answers to the same names but implements a fraction of the API
+                // does not fail — it returns wrong results, which is worse.
+                browser = await playwright.chromium.connectOverCDP(endpoint, { timeout: 30000 });
+                const context = browser.contexts()[0] ?? await browser.newContext();
+                const page = context.pages()[0] ?? await context.newPage();
                 const fn = new Function("page", "browser", "context", "session", `return (async () => {\n${script}\n})();`);
                 const result = await fn(page, browser, context, session);
                 return { session, result };

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

@@ -4,6 +4,7 @@ import { registerCaptchaActions } from "./captchas.js";
 import { registerCredentialActions } from "./credentials.js";
 import { registerExtensionActions } from "./extensions.js";
 import { registerFileActions } from "./files.js";
+import { registerPageActions } from "./page/tools.js";
 import { registerProfileActions } from "./profiles.js";
 import { registerSessionActions } from "./sessions.js";
 export default function steel(rl) {
@@ -17,6 +18,7 @@ export default function steel(rl) {
     }));
     registerSessionActions(rl);
     registerBrowserActions(rl);
+    registerPageActions(rl);
     registerFileActions(rl);
     registerCredentialActions(rl);
     registerProfileActions(rl);