@prompteryx/sdk 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prompteryx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,336 @@
+# @prompteryx/sdk
+
+Official TypeScript SDK for [Prompteryx](https://prompteryx.com).
+
+```bash
+npm install @prompteryx/sdk
+```
+
+Optional peers for the most-used features:
+
+```bash
+npm install zod playwright-core
+```
+
+Works on Node 18+ (global `fetch`), ESM **and** CommonJS.
+
+## Authentication — two key families
+
+| Key | Format | Used by | Sent as | Rate limits |
+|---|---|---|---|---|
+| Platform API key | `px_live_…` | everything except `cloudBrowser` | `Authorization: Bearer` | 60 req/min, 10,000 req/day |
+| Cloud Browser key | `pcb_live_…` | `px.cloudBrowser.*` (sessions / fetch / search) | `x-api-key` | per-plan session quotas |
+
+Create the `px_live_` key in Settings → API Keys, and the `pcb_live_` key in
+Cloud Platform → API Keys. `px.cloudBrowser.*` throws a descriptive
+`AuthError` if you call it without `cloudBrowserKey`.
+
+```ts
+const px = new Prompteryx({
+  apiKey: process.env.PROMPTERYX_API_KEY!,                    // px_live_…
+  cloudBrowserKey: process.env.PROMPTERYX_CLOUD_BROWSER_KEY,  // pcb_live_… (only for cloudBrowser)
+})
+```
+
+## Two AI surfaces — Copilot and Autopilot
+
+Prompteryx has two distinct ways AI helps you automate the browser:
+
+- **Copilot** — you drive Playwright; copilot helps with ONE step.
+  You're in control, AI is the assistant.
+- **Autopilot** — you give a goal in plain English; autopilot drives
+  the whole task end-to-end.
+
+```ts
+import { Prompteryx } from '@prompteryx/sdk'
+import { chromium } from 'playwright-core'
+import { z } from 'zod'
+
+const px = new Prompteryx({
+  apiKey: process.env.PROMPTERYX_API_KEY!,
+  cloudBrowserKey: process.env.PROMPTERYX_CLOUD_BROWSER_KEY,
+})
+
+// — Copilot: assisted single steps —
+const session = await px.cloudBrowser.sessions.create({
+  useProxy: true, proxyLocation: 'us',
+})
+const browser = await chromium.connectOverCDP(session.connectUrl)
+const page = browser.contexts()[0].pages()[0]
+await page.goto('https://example.com/signup')
+
+await px.copilot.do(page, 'click the Sign up button')
+await px.copilot.do(page, 'fill the email field with hello@example.com')
+
+const plan = await px.copilot.read(page, z.object({
+  name: z.string(),
+  pricePerMonth: z.number(),
+  features: z.array(z.string()),
+}))
+
+const actions = await px.copilot.scan(page, 'checkout flow')
+
+// — Autopilot: hand it a goal, it runs end-to-end —
+const result = await px.autopilot.run({
+  goal: 'Find the cheapest direct flight from London to Lisbon next Tuesday and screenshot the booking page',
+  maxSteps: 30,                     // default is 30
+  saveAsWorkflow: true,             // ← key superpower, see below
+})
+// result.usage → { aiCredits, tokensIn, tokensOut, costUSD, turns }
+```
+
+## Action caching = saved workflows
+
+This is Prompteryx's killer feature for cost-conscious users. Set
+`saveAsWorkflow: true` on any `autopilot.run` call and the discovered
+action sequence is captured as a permanent Visual Studio workflow:
+
+```ts
+const result = await px.autopilot.run({
+  goal: 'Apply for the Senior Engineer role at OpenAI',
+  saveAsWorkflow: true,
+  savedWorkflowName: 'apply-openai-senior',
+})
+
+// Replay forever at ZERO AI cost:
+await px.workflows.run(result.savedWorkflowId!)
+```
+
+The saved workflow is a first-class platform object — schedulable,
+editable in Visual Studio, shareable, API-triggerable. It uses
+multi-option ranked selectors so it stays resilient to UI changes.
+
+## Structured output + final-step vision
+
+```ts
+const result = await px.autopilot.run({
+  goal: 'Get the top 3 HN stories',
+  outputSchema: {                       // finalAnswer becomes JSON matching this
+    type: 'object',
+    properties: {
+      stories: {
+        type: 'array',
+        items: { type: 'object', properties: { title: { type: 'string' }, url: { type: 'string' } } },
+      },
+    },
+  },
+  finalStepVision: 'precision',         // one extra high-quality look before answering
+})
+const data = JSON.parse(result.finalAnswer!)
+```
+
+## The SDK surface (verified against the live API)
+
+| Resource | What it does |
+|---|---|
+| `px.workflows.{list,get,run,runAndWait}` | Visual Studio workflows. |
+| `px.executions.{get,wait,logs,stream,getNodeOutput}` | Execution status + logs. |
+| `px.cloudBrowser.sessions.{create,get,list,close}` | Cloud browser sessions for your own Playwright code (`pcb_live_` key). |
+| `px.cloudBrowser.{fetch,search}` | One-shot page fetch + web search via the cloud browser, no session management (`pcb_live_` key). |
+| `px.copilot.{do,read,scan}` | Assisted single-step primitives on a Playwright page. |
+| `px.autopilot.{run,stream,stop}` | Autonomous multi-step agent with `saveAsWorkflow` action caching. |
+| `px.schedules.{list,get,create,update,delete}` | Server-side cron schedules — the platform fires them even when no client is connected. |
+| `px.profiles.{list,get,create,delete}` | Cloud and local Chrome profiles. |
+| `px.subscription.get` | Plan, balances, top-ups. |
+
+> Removed in 0.4.0 after a live-API audit: `connectHub`, `customNodes`,
+> `templates`, `apiKeys`, `recordings`, `subscription.usage`, and
+> `sessions.getDownloads/getRecording` — their routes don't exist on the
+> live API today (or, for `apiKeys`, can never accept API-key auth). A
+> smaller honest SDK beats a 404ing surface; they return when their
+> endpoints ship.
+
+## Models
+
+`autopilot.run({ model })` defaults to **`gemini-3.5-flash`** (recommended —
+fast and cheap). The full catalog of 32 ids is exported as
+`AUTOPILOT_MODELS` (type `AutopilotModel`), mirrored from the platform's
+canonical list — highlights:
+
+- `gemini-3.5-flash` (default), `gemini-3.7-flash` (newest GA Flash),
+  `gemini-3.6-flash`, `gemini-default` (legacy 2.5)
+- `claude-sonnet-4-6`, `claude-opus-4-8` (native computer use)
+- `gpt-5.6-terra`, `gpt-5.6-sol`, `gpt-5.5`
+- Vision-loop variants (`claude-fable-5-vision`, `gpt-5.6-luna-vision`, …)
+  and experimental harness engines (`model-h`, `modelc`, …)
+
+Unknown ids are forwarded for forward-compatibility but hard-400 with
+`UNSUPPORTED_MODEL` under strict validation — stick to the catalog.
+
+## One-shot fetch and search
+
+No Playwright, no session management — a real cloud Chromium loads the page
+(so JS-rendered sites work) and returns token-efficient content:
+
+```ts
+const pageData = await px.cloudBrowser.fetch({
+  url: 'https://example.com/pricing',
+  format: 'markdown',                  // 'text' (default) | 'markdown' | 'html' | 'links'
+  waitForSelector: '.pricing-table',   // wait for JS-rendered content
+  selectors: ['.pricing-table .plan'], // deterministic CSS extraction (count + text + html)
+  screenshot: true,                    // base64 JPEG in .screenshotBase64
+})
+
+// Web search — DuckDuckGo in a real browser, structured results:
+const results = await px.cloudBrowser.search({ query: 'best CDP libraries', limit: 5 })
+// [{ title, url, snippet }, …]
+```
+
+## Local mode — use your own Chrome, zero cloud minutes
+
+If you want to skip cloud-browser minutes entirely, you can point the SDK at
+your own local Chrome via the **Prompteryx plugin + Electron runner**. Two
+paths connect your own Playwright over CDP (autopilot local mode is a third —
+covered just below):
+
+**1. `px.cloudBrowser.sessions.create({ target: 'local' })`** — returns a
+session whose `connectUrl` points at `http://127.0.0.1:9222`. Hand that to
+Playwright and drive your own Chrome:
+
+```ts
+const s = await px.cloudBrowser.sessions.create({ target: 'local' })
+// s.connectUrl === 'http://127.0.0.1:9222'
+const browser = await chromium.connectOverCDP(s.connectUrl)
+// …drive it. No cloud minutes billed.
+await px.cloudBrowser.sessions.close(s.id)  // no-op for local sessions
+```
+
+**2. `px.workflows.run(id, { execution: { target: 'local' } })`** — runs
+a saved workflow against your local Chrome instead of the cloud browser:
+
+```ts
+await px.workflows.run('wf_abc123', {
+  execution: { target: 'local', chromeProfile: 'Work' },
+})
+```
+
+**Prereqs (both paths):**
+- The **Prompteryx plugin** is installed in your Chrome.
+- The **Electron runner** is running on the same machine as the SDK consumer
+  (the SDK talks to `localhost`, so they must co-locate).
+- Chrome is launched with remote debugging on port 9222. The plugin manages
+  this for you when it's connected.
+
+### Autopilot in local mode
+
+`px.autopilot.run({ target: 'local' })` runs the autonomous agent against
+your own local Chrome. Unlike the two CDP paths above, it talks **directly to
+the Prompteryx desktop app** at `http://localhost:61337` (override with
+`runnerUrl`):
+
+```ts
+const result = await px.autopilot.run({
+  target: 'local',
+  goal: 'Open my Gmail and tell me how many unread emails I have',
+  aiVision: 'balanced',   // quality preset — lower = cheaper/faster, higher = more accurate
+  maxSteps: 30,
+})
+```
+
+**Requirements:** the **Prompteryx desktop app** must be **running and signed
+in** on this machine, and your code must run on the **same machine** (the SDK
+talks to `localhost`). Zero cloud-browser minutes are billed — AI Credits
+still apply — and the browser tab stays open after the run for inspection or
+follow-ups. It supports the same knobs as cloud: `model`, `aiVision` preset,
+`maxSteps`, `maxCredits`, `costSaving`.
+
+> `px.autopilot.stream({ target: 'local' })` throws a clear message —
+> use the blocking `autopilot.run` for local runs.
+
+## Streaming an autopilot run
+
+`autopilot.stream()` runs the task over the keep-alive stream endpoint
+(`/api/v1/ai-browser/execute-stream`). Note the protocol: the server sends
+heartbeats while the run executes and the full result at the end — so steps
+arrive together when the run finishes (not one-by-one live), ending with a
+`{ step: -1, action: 'done' }` sentinel whose `result` carries the full
+`AutopilotRunResult`. Prefer `run()` unless you want the keep-alive
+transport for a long single-request run.
+
+```ts
+for await (const step of px.autopilot.stream({ goal: 'Buy a ticket' })) {
+  if (step.action === 'done') break
+  console.log('Step', step.step, '→', step.action)
+}
+```
+
+## Stopping a job
+
+```ts
+await px.autopilot.stop(jobId)   // POST { jobId, mode: 'stop' } — stops at the next step boundary
+```
+
+## Configuration
+
+```ts
+new Prompteryx({
+  apiKey: '…',                          // required — px_live_…
+  cloudBrowserKey: '…',                 // optional — pcb_live_…, for px.cloudBrowser.*
+  baseUrl: 'https://prompteryx.com',   // override for self-hosted
+  timeoutMs: 60_000,                    // default per-request timeout
+  maxRetries: 2,                        // retries for transient 5xx/network errors
+  defaultHeaders: { 'X-Project-Id': '…' },
+  fetch: customFetch,                   // for tests / non-default runtimes
+})
+```
+
+## Typed error handling
+
+```ts
+import {
+  AuthError, QuotaError, RateLimitError, NotFoundError,
+  ValidationError, ServerError, NetworkError, TimeoutError, ParseError,
+} from '@prompteryx/sdk'
+
+try {
+  await px.workflows.run('wf_abc')
+} catch (err) {
+  if (err instanceof QuotaError) {
+    // Out of AI Credits / cloud minutes / proxy data / etc.
+    console.log('Exhausted resources:', err.resources)
+  } else if (err instanceof RateLimitError) {
+    // Back off — err.retryAfterSeconds is set when the server provided one
+  } else {
+    throw err
+  }
+}
+```
+
+## Streaming log events
+
+```ts
+const exec = await px.workflows.run('wf_abc')
+for await (const ev of px.executions.stream(exec.executionId)) {
+  console.log(`[${ev.level || 'info'}]`, ev.message)
+  if (ev.type === 'done') break
+}
+```
+
+## Future-proof customisation
+
+`autopilot.run` exposes every option the in-app AI Browser Agent UI
+exposes — model, AI Vision quality preset, final-step vision, structured
+output, max steps, credit cap, cost-saving batching, system-prompt
+override, allowed tools, viewport, proxy, recording, profile id, etc. New
+options added server-side ride through the `passthrough` field without an
+SDK release:
+
+```ts
+await px.autopilot.run({
+  goal: '...',
+  model: 'gemini-3.7-flash',           // catalog in AUTOPILOT_MODELS; default gemini-3.5-flash
+  aiVision: 'balanced',                // quality preset: lower = cheaper/faster, higher = more accurate
+  maxCredits: 50,                      // hard AI-Credit cap (cost guardrail)
+  costSaving: true,                    // batch several safe actions per screenshot
+  allowedTools: ['click', 'extract'],  // restrict capabilities for read-only tasks
+  systemPromptOverride: 'Always confirm before submitting any form.',
+  passthrough: { newServerOption: true },
+})
+```
+
+Same passthrough pattern on `workflows.run` and
+`cloudBrowser.sessions.create`.
+
+## License
+
+MIT

package/dist/chunk-ODLNHNQT.mjs

@@ -0,0 +1,272 @@
+// src/errors.ts
+var PrompteryxError = class extends Error {
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "PrompteryxError";
+    this.status = opts.status;
+    this.code = opts.code;
+    this.requestId = opts.requestId;
+    this.raw = opts.raw;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AuthError = class _AuthError extends PrompteryxError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "AuthError";
+    Object.setPrototypeOf(this, _AuthError.prototype);
+  }
+};
+var QuotaError = class _QuotaError extends PrompteryxError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "QuotaError";
+    this.resources = opts.resources;
+    Object.setPrototypeOf(this, _QuotaError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends PrompteryxError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends PrompteryxError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends PrompteryxError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "RateLimitError";
+    this.retryAfterSeconds = opts.retryAfterSeconds;
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var ServerError = class _ServerError extends PrompteryxError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends PrompteryxError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var ParseError = class _ParseError extends PrompteryxError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "ParseError";
+    Object.setPrototypeOf(this, _ParseError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends PrompteryxError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+
+// src/page.ts
+var CopilotHelpers = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Execute a single natural-language action against the page.
+   *
+   * ```ts
+   * await px.copilot.do(page, 'click the Sign up button')
+   * await px.copilot.do(page, 'fill the email field with hello@example.com')
+   * ```
+   *
+   * Internally: snapshot the page → POST `/api/v1/copilot/do` → server
+   * returns a structured action plan (ranked selector + alternatives +
+   * value + a normalised vision point) → SDK executes locally, trying the
+   * ranked selectors in order, and ONLY if every selector fails, falling
+   * back to an AI-vision coordinate click. Costs 1 AI Credit per call.
+   *
+   * This is the key resilience advantage over a pure-LLM `act()`: the cheap,
+   * deterministic ranked selectors are tried first (no flakiness, no re-asking
+   * the model); the vision fallback is a safety net, not the default path. Pass
+   * `{ visionFallback: false }` to disable the fallback (selectors-only).
+   */
+  async do(page, instruction, opts = {}) {
+    const start = Date.now();
+    const snapshot = await this.snapshotPage(page);
+    const plan = await this.http.request("/api/v1/copilot/do", {
+      method: "POST",
+      body: { instruction, snapshot },
+      timeoutMs: 45e3
+    });
+    const allowVision = opts.visionFallback !== false;
+    try {
+      const usedVisionFallback = await this.runAction(page, plan, opts.timeout ?? 15e3, allowVision);
+      return {
+        success: true,
+        action: plan.description,
+        selector: plan.selector,
+        usedVisionFallback,
+        durationMs: Date.now() - start
+      };
+    } catch (err) {
+      return {
+        success: false,
+        action: plan.description,
+        selector: plan.selector,
+        durationMs: Date.now() - start,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * Pull typed structured data from the page conforming to a schema.
+   *
+   * ```ts
+   * import { z } from 'zod'
+   * const product = await px.copilot.read(page, z.object({
+   *   name: z.string(),
+   *   pricePerMonth: z.number(),
+   *   features: z.array(z.string()),
+   * }))
+   * // product is fully typed; ValidationError is thrown if the model
+   * // returns data that doesn't match the schema.
+   * ```
+   *
+   * Accepts a Zod schema (preferred — gives you compile-time types)
+   * OR a raw JSON Schema via `{ jsonSchema: ... }` if you don't want
+   * a `zod` peer dep.
+   */
+  async read(page, schema) {
+    const snapshot = await this.snapshotPage(page);
+    const jsonSchema = "jsonSchema" in schema ? schema.jsonSchema : this.zodToJsonSchema(schema);
+    const raw = await this.http.request(
+      "/api/v1/copilot/read",
+      { method: "POST", body: { snapshot, jsonSchema }, timeoutMs: 6e4 }
+    );
+    if ("parse" in schema && typeof schema.parse === "function") {
+      try {
+        return schema.parse(raw.data);
+      } catch (e) {
+        throw new ValidationError(
+          `Extracted data didn't match the schema: ${e instanceof Error ? e.message : String(e)}`,
+          { raw: raw.data }
+        );
+      }
+    }
+    return raw.data;
+  }
+  /**
+   * Scan the page for available actions. Returns a ranked list of
+   * actions a user / agent could take next, with selectors + multi-
+   * option fallbacks + human-readable descriptions.
+   *
+   * Useful as a pre-step to `do()` for resilient automations:
+   *   const actions = await px.copilot.scan(page, 'sign up flow')
+   *   const target = actions.find(a => a.description.includes('Sign up'))
+   *   if (target) await px.copilot.do(page, target.example ?? `click ${target.description}`)
+   */
+  async scan(page, hint) {
+    const snapshot = await this.snapshotPage(page);
+    const res = await this.http.request(
+      "/api/v1/copilot/scan",
+      { method: "POST", body: { snapshot, hint }, timeoutMs: 45e3 }
+    );
+    return res.actions ?? [];
+  }
+  // ── internals ────────────────────────────────────────────────────────
+  async snapshotPage(page) {
+    const buf = await page.screenshot({ type: "jpeg", quality: 60, fullPage: false });
+    const screenshot = bufferToBase64(buf);
+    return {
+      url: page.url(),
+      title: await page.title().catch(() => ""),
+      screenshot
+    };
+  }
+  /** Execute the plan. Returns true if the AI-vision fallback was used. */
+  async runAction(page, plan, timeout, allowVision) {
+    if (plan.type === "press_key" && plan.value) {
+      await page.keyboard.press(plan.value);
+      return false;
+    }
+    if (plan.type === "goto" && plan.url) {
+      await page.goto(plan.url, { timeout });
+      return false;
+    }
+    const candidates = [plan.selector, ...plan.alternativeSelectors ?? []].filter(
+      (s) => typeof s === "string" && s.length > 0
+    );
+    let lastErr;
+    for (const sel of candidates) {
+      try {
+        switch (plan.type) {
+          case "click":
+            await page.click(sel, { timeout });
+            return false;
+          case "fill":
+            await page.fill(sel, plan.value ?? "", { timeout });
+            return false;
+          case "select":
+            await page.selectOption(sel, plan.value ?? "", { timeout });
+            return false;
+          case "hover":
+            await page.hover(sel, { timeout });
+            return false;
+          default:
+            throw new Error(`Unsupported action type: ${plan.type}`);
+        }
+      } catch (e) {
+        lastErr = e;
+      }
+    }
+    if (allowVision && plan.point && plan.type !== "select" && page.mouse) {
+      const vp = page.viewportSize?.() || { width: 1280, height: 800 };
+      const x = Math.round(plan.point.x / 1e3 * vp.width);
+      const y = Math.round(plan.point.y / 1e3 * vp.height);
+      await page.mouse.click(x, y);
+      if (plan.type === "fill" && plan.value) await page.keyboard.type(plan.value, { delay: 20 });
+      if (plan.type === "hover" && page.mouse.move) await page.mouse.move(x, y);
+      return true;
+    }
+    if (candidates.length === 0) throw new Error(`No selector or vision point returned for action ${plan.type}`);
+    throw lastErr ?? new Error(`No selector worked for ${plan.type} (and vision fallback unavailable)`);
+  }
+  zodToJsonSchema(schema) {
+    return { type: "object", _zodHint: String(schema) };
+  }
+};
+function bufferToBase64(buf) {
+  if (typeof Buffer !== "undefined" && buf instanceof Buffer) {
+    return buf.toString("base64");
+  }
+  let binary = "";
+  const bytes = buf;
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  const g = globalThis;
+  return g.btoa ? g.btoa(binary) : Buffer.from(binary, "binary").toString("base64");
+}
+
+export {
+  PrompteryxError,
+  AuthError,
+  QuotaError,
+  NotFoundError,
+  ValidationError,
+  RateLimitError,
+  ServerError,
+  NetworkError,
+  ParseError,
+  TimeoutError,
+  CopilotHelpers
+};
+//# sourceMappingURL=chunk-ODLNHNQT.mjs.map

package/dist/chunk-ODLNHNQT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/page.ts"],"sourcesContent":["/**\r\n * Typed error hierarchy for the Prompteryx SDK.\r\n *\r\n * Every error from the SDK is an instance of `PrompteryxError`. Subclass\r\n * by HTTP status family so callers can `if (err instanceof QuotaError)`\r\n * without parsing strings. Network/parse errors get their own classes\r\n * too so retries can fork on category.\r\n */\r\n\r\n/** Base class — every SDK error inherits from this. */\r\nexport class PrompteryxError extends Error {\r\n  public readonly status?: number\r\n  public readonly code?: string\r\n  public readonly requestId?: string\r\n  public readonly raw?: unknown\r\n\r\n  constructor(message: string, opts: { status?: number; code?: string; requestId?: string; raw?: unknown } = {}) {\r\n    super(message)\r\n    this.name = 'PrompteryxError'\r\n    this.status = opts.status\r\n    this.code = opts.code\r\n    this.requestId = opts.requestId\r\n    this.raw = opts.raw\r\n    // Restore prototype chain for `instanceof` checks across realms.\r\n    Object.setPrototypeOf(this, new.target.prototype)\r\n  }\r\n}\r\n\r\n/** 401 / 403 — bad or revoked API key, or insufficient scope. */\r\nexport class AuthError extends PrompteryxError {\r\n  constructor(message: string, opts: ConstructorParameters<typeof PrompteryxError>[1] = {}) {\r\n    super(message, opts)\r\n    this.name = 'AuthError'\r\n    Object.setPrototypeOf(this, AuthError.prototype)\r\n  }\r\n}\r\n\r\n/** 402 — plan allowance exhausted (AI Credits, cloud minutes, etc.). */\r\nexport class QuotaError extends PrompteryxError {\r\n  /** Which resources are exhausted, when known. */\r\n  public readonly resources?: string[]\r\n  constructor(message: string, opts: ConstructorParameters<typeof PrompteryxError>[1] & { resources?: string[] } = {}) {\r\n    super(message, opts)\r\n    this.name = 'QuotaError'\r\n    this.resources = opts.resources\r\n    Object.setPrototypeOf(this, QuotaError.prototype)\r\n  }\r\n}\r\n\r\n/** 404 — resource doesn't exist (workflow id, execution id, session id). */\r\nexport class NotFoundError extends PrompteryxError {\r\n  constructor(message: string, opts: ConstructorParameters<typeof PrompteryxError>[1] = {}) {\r\n    super(message, opts)\r\n    this.name = 'NotFoundError'\r\n    Object.setPrototypeOf(this, NotFoundError.prototype)\r\n  }\r\n}\r\n\r\n/** 422 — request body shape was wrong. */\r\nexport class ValidationError extends PrompteryxError {\r\n  constructor(message: string, opts: ConstructorParameters<typeof PrompteryxError>[1] = {}) {\r\n    super(message, opts)\r\n    this.name = 'ValidationError'\r\n    Object.setPrototypeOf(this, ValidationError.prototype)\r\n  }\r\n}\r\n\r\n/** 429 — rate-limited. Caller can retry after `retryAfterSeconds`. */\r\nexport class RateLimitError extends PrompteryxError {\r\n  public readonly retryAfterSeconds?: number\r\n  constructor(message: string, opts: ConstructorParameters<typeof PrompteryxError>[1] & { retryAfterSeconds?: number } = {}) {\r\n    super(message, opts)\r\n    this.name = 'RateLimitError'\r\n    this.retryAfterSeconds = opts.retryAfterSeconds\r\n    Object.setPrototypeOf(this, RateLimitError.prototype)\r\n  }\r\n}\r\n\r\n/** 5xx — server-side failure. SDK retries these by default for idempotent ops. */\r\nexport class ServerError extends PrompteryxError {\r\n  constructor(message: string, opts: ConstructorParameters<typeof PrompteryxError>[1] = {}) {\r\n    super(message, opts)\r\n    this.name = 'ServerError'\r\n    Object.setPrototypeOf(this, ServerError.prototype)\r\n  }\r\n}\r\n\r\n/** Network / DNS / socket / aborted — never reached the server. */\r\nexport class NetworkError extends PrompteryxError {\r\n  constructor(message: string, opts: ConstructorParameters<typeof PrompteryxError>[1] = {}) {\r\n    super(message, opts)\r\n    this.name = 'NetworkError'\r\n    Object.setPrototypeOf(this, NetworkError.prototype)\r\n  }\r\n}\r\n\r\n/** Response body parse failure (server returned a non-JSON 500 page, etc.). */\r\nexport class ParseError extends PrompteryxError {\r\n  constructor(message: string, opts: ConstructorParameters<typeof PrompteryxError>[1] = {}) {\r\n    super(message, opts)\r\n    this.name = 'ParseError'\r\n    Object.setPrototypeOf(this, ParseError.prototype)\r\n  }\r\n}\r\n\r\n/** Timed-out waiting for a long-running op (execution polling, agent run). */\r\nexport class TimeoutError extends PrompteryxError {\r\n  constructor(message: string, opts: ConstructorParameters<typeof PrompteryxError>[1] = {}) {\r\n    super(message, opts)\r\n    this.name = 'TimeoutError'\r\n    Object.setPrototypeOf(this, TimeoutError.prototype)\r\n  }\r\n}\r\n","/**\r\n * Copilot primitives — `do`, `read`, `scan` — operating on a Playwright\r\n * page.\r\n *\r\n * Two namespaces in the Prompteryx SDK:\r\n *   • Copilot  → SDK helps with ONE step you describe in plain English.\r\n *                Your code drives Playwright; copilot just figures out\r\n *                which selector to click / what data to pull / what's\r\n *                discoverable on the current page.\r\n *   • Autopilot → SDK runs an autonomous multi-step task with no per-\r\n *                 action involvement from you. See ./resources/autopilot.ts.\r\n *\r\n * The copilot primitives:\r\n *   • `do(page, instruction)` — execute a single natural-language\r\n *     action (\"click the Sign up button\", \"fill the email field with\r\n *     hello@example.com\"). Returns a structured result describing\r\n *     what was done.\r\n *   • `read(page, schema)` — pull typed data from the page. Pass a\r\n *     Zod schema or a raw JSON Schema; the SDK returns the populated\r\n *     object validated against your schema.\r\n *   • `scan(page, hint?)` — list discoverable actions on the page.\r\n *     Useful as a pre-step to `do()` for resilient automations:\r\n *     scan → pick the action whose description matches your intent →\r\n *     do() against it.\r\n *\r\n * Architecturally the SDK never drives the browser server-side. The\r\n * server returns a structured plan and the SDK executes it locally\r\n * against your Playwright page, so your trace, debugger, and any\r\n * custom event handlers continue to work normally.\r\n */\r\n\r\nimport type { HttpClient } from './client'\r\nimport { ValidationError } from './errors'\r\nimport type { CopilotDoResult, DiscoveredAction } from './types'\r\n\r\n/** Minimal Page surface — anything satisfying this works (Playwright's\r\n *  Page does, by structural typing, without an explicit import). */\r\nexport interface PageLike {\r\n  url(): string\r\n  title(): Promise<string>\r\n  screenshot(opts?: { type?: 'png' | 'jpeg'; quality?: number; fullPage?: boolean }): Promise<Buffer | Uint8Array>\r\n  evaluate<T>(fn: (...args: unknown[]) => T): Promise<T>\r\n  click(selector: string, opts?: { timeout?: number }): Promise<void>\r\n  fill(selector: string, value: string, opts?: { timeout?: number }): Promise<void>\r\n  selectOption(selector: string, value: string | string[], opts?: { timeout?: number }): Promise<unknown>\r\n  goto(url: string, opts?: { timeout?: number }): Promise<unknown>\r\n  hover(selector: string, opts?: { timeout?: number }): Promise<void>\r\n  keyboard: { press(key: string): Promise<void>; type(text: string, opts?: { delay?: number }): Promise<void> }\r\n  // Used by the AI-vision fallback (when all ranked selectors fail). Playwright's\r\n  // Page provides both; optional so a minimal page can still satisfy PageLike.\r\n  mouse?: { click(x: number, y: number): Promise<void>; move?(x: number, y: number): Promise<void> }\r\n  viewportSize?(): { width: number; height: number } | null\r\n  locator(selector: string): {\r\n    first(): { isVisible(opts?: { timeout?: number }): Promise<boolean>; textContent(opts?: { timeout?: number }): Promise<string | null> }\r\n  }\r\n}\r\n\r\ninterface ZodLikeSchema<T> {\r\n  parse(input: unknown): T\r\n  _def?: unknown\r\n}\r\n\r\nexport class CopilotHelpers {\r\n  constructor(private readonly http: HttpClient) {}\r\n\r\n  /**\r\n   * Execute a single natural-language action against the page.\r\n   *\r\n   * ```ts\r\n   * await px.copilot.do(page, 'click the Sign up button')\r\n   * await px.copilot.do(page, 'fill the email field with hello@example.com')\r\n   * ```\r\n   *\r\n   * Internally: snapshot the page → POST `/api/v1/copilot/do` → server\r\n   * returns a structured action plan (ranked selector + alternatives +\r\n   * value + a normalised vision point) → SDK executes locally, trying the\r\n   * ranked selectors in order, and ONLY if every selector fails, falling\r\n   * back to an AI-vision coordinate click. Costs 1 AI Credit per call.\r\n   *\r\n   * This is the key resilience advantage over a pure-LLM `act()`: the cheap,\r\n   * deterministic ranked selectors are tried first (no flakiness, no re-asking\r\n   * the model); the vision fallback is a safety net, not the default path. Pass\r\n   * `{ visionFallback: false }` to disable the fallback (selectors-only).\r\n   */\r\n  async do(page: PageLike, instruction: string, opts: { timeout?: number; visionFallback?: boolean } = {}): Promise<CopilotDoResult> {\r\n    const start = Date.now()\r\n    const snapshot = await this.snapshotPage(page)\r\n    const plan = await this.http.request<{\r\n      type: 'click' | 'fill' | 'select' | 'hover' | 'press_key' | 'goto'\r\n      selector?: string\r\n      alternativeSelectors?: string[]\r\n      point?: { x: number; y: number }\r\n      value?: string\r\n      url?: string\r\n      description: string\r\n    }>('/api/v1/copilot/do', {\r\n      method: 'POST',\r\n      body: { instruction, snapshot },\r\n      timeoutMs: 45_000,\r\n    })\r\n    const allowVision = opts.visionFallback !== false\r\n    try {\r\n      const usedVisionFallback = await this.runAction(page, plan, opts.timeout ?? 15_000, allowVision)\r\n      return {\r\n        success: true,\r\n        action: plan.description,\r\n        selector: plan.selector,\r\n        usedVisionFallback,\r\n        durationMs: Date.now() - start,\r\n      }\r\n    } catch (err) {\r\n      return {\r\n        success: false,\r\n        action: plan.description,\r\n        selector: plan.selector,\r\n        durationMs: Date.now() - start,\r\n        error: err instanceof Error ? err.message : String(err),\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Pull typed structured data from the page conforming to a schema.\r\n   *\r\n   * ```ts\r\n   * import { z } from 'zod'\r\n   * const product = await px.copilot.read(page, z.object({\r\n   *   name: z.string(),\r\n   *   pricePerMonth: z.number(),\r\n   *   features: z.array(z.string()),\r\n   * }))\r\n   * // product is fully typed; ValidationError is thrown if the model\r\n   * // returns data that doesn't match the schema.\r\n   * ```\r\n   *\r\n   * Accepts a Zod schema (preferred — gives you compile-time types)\r\n   * OR a raw JSON Schema via `{ jsonSchema: ... }` if you don't want\r\n   * a `zod` peer dep.\r\n   */\r\n  async read<T>(page: PageLike, schema: ZodLikeSchema<T> | { jsonSchema: unknown }): Promise<T> {\r\n    const snapshot = await this.snapshotPage(page)\r\n    const jsonSchema = 'jsonSchema' in schema\r\n      ? (schema as { jsonSchema: unknown }).jsonSchema\r\n      : this.zodToJsonSchema(schema as ZodLikeSchema<T>)\r\n    const raw = await this.http.request<{ data: unknown }>(\r\n      '/api/v1/copilot/read',\r\n      { method: 'POST', body: { snapshot, jsonSchema }, timeoutMs: 60_000 },\r\n    )\r\n    if ('parse' in (schema as object) && typeof (schema as ZodLikeSchema<T>).parse === 'function') {\r\n      try {\r\n        return (schema as ZodLikeSchema<T>).parse(raw.data)\r\n      } catch (e) {\r\n        throw new ValidationError(\r\n          `Extracted data didn't match the schema: ${e instanceof Error ? e.message : String(e)}`,\r\n          { raw: raw.data },\r\n        )\r\n      }\r\n    }\r\n    return raw.data as T\r\n  }\r\n\r\n  /**\r\n   * Scan the page for available actions. Returns a ranked list of\r\n   * actions a user / agent could take next, with selectors + multi-\r\n   * option fallbacks + human-readable descriptions.\r\n   *\r\n   * Useful as a pre-step to `do()` for resilient automations:\r\n   *   const actions = await px.copilot.scan(page, 'sign up flow')\r\n   *   const target = actions.find(a => a.description.includes('Sign up'))\r\n   *   if (target) await px.copilot.do(page, target.example ?? `click ${target.description}`)\r\n   */\r\n  async scan(page: PageLike, hint?: string): Promise<DiscoveredAction[]> {\r\n    const snapshot = await this.snapshotPage(page)\r\n    const res = await this.http.request<{ actions: DiscoveredAction[] }>(\r\n      '/api/v1/copilot/scan',\r\n      { method: 'POST', body: { snapshot, hint }, timeoutMs: 45_000 },\r\n    )\r\n    return res.actions ?? []\r\n  }\r\n\r\n  // ── internals ────────────────────────────────────────────────────────\r\n\r\n  private async snapshotPage(page: PageLike): Promise<{ url: string; title: string; screenshot: string }> {\r\n    const buf = await page.screenshot({ type: 'jpeg', quality: 60, fullPage: false })\r\n    const screenshot = bufferToBase64(buf)\r\n    return {\r\n      url: page.url(),\r\n      title: await page.title().catch(() => ''),\r\n      screenshot,\r\n    }\r\n  }\r\n\r\n  /** Execute the plan. Returns true if the AI-vision fallback was used. */\r\n  private async runAction(\r\n    page: PageLike,\r\n    plan: {\r\n      type: 'click' | 'fill' | 'select' | 'hover' | 'press_key' | 'goto'\r\n      selector?: string\r\n      alternativeSelectors?: string[]\r\n      point?: { x: number; y: number }\r\n      value?: string\r\n      url?: string\r\n    },\r\n    timeout: number,\r\n    allowVision: boolean,\r\n  ): Promise<boolean> {\r\n    if (plan.type === 'press_key' && plan.value) {\r\n      await page.keyboard.press(plan.value)\r\n      return false\r\n    }\r\n    if (plan.type === 'goto' && plan.url) {\r\n      await page.goto(plan.url, { timeout })\r\n      return false\r\n    }\r\n    const candidates = [plan.selector, ...(plan.alternativeSelectors ?? [])].filter(\r\n      (s): s is string => typeof s === 'string' && s.length > 0,\r\n    )\r\n    // 1) Try the ranked selectors in order (cheap + deterministic).\r\n    let lastErr: unknown\r\n    for (const sel of candidates) {\r\n      try {\r\n        switch (plan.type) {\r\n          case 'click': await page.click(sel, { timeout }); return false\r\n          case 'fill': await page.fill(sel, plan.value ?? '', { timeout }); return false\r\n          case 'select': await page.selectOption(sel, plan.value ?? '', { timeout }); return false\r\n          case 'hover': await page.hover(sel, { timeout }); return false\r\n          default: throw new Error(`Unsupported action type: ${plan.type}`)\r\n        }\r\n      } catch (e) {\r\n        lastErr = e\r\n      }\r\n    }\r\n    // 2) AI-vision fallback: every selector failed → click the model's\r\n    //    normalised point. <select> can't be operated by a coordinate, so it's\r\n    //    selectors-only. Requires page.mouse (Playwright provides it).\r\n    if (allowVision && plan.point && plan.type !== 'select' && page.mouse) {\r\n      const vp = page.viewportSize?.() || { width: 1280, height: 800 }\r\n      const x = Math.round((plan.point.x / 1000) * vp.width)\r\n      const y = Math.round((plan.point.y / 1000) * vp.height)\r\n      await page.mouse.click(x, y)\r\n      if (plan.type === 'fill' && plan.value) await page.keyboard.type(plan.value, { delay: 20 })\r\n      // hover via mouse.move when available, else the click above is close enough.\r\n      if (plan.type === 'hover' && page.mouse.move) await page.mouse.move(x, y)\r\n      return true\r\n    }\r\n    if (candidates.length === 0) throw new Error(`No selector or vision point returned for action ${plan.type}`)\r\n    throw lastErr ?? new Error(`No selector worked for ${plan.type} (and vision fallback unavailable)`)\r\n  }\r\n\r\n  private zodToJsonSchema<T>(schema: ZodLikeSchema<T>): unknown {\r\n    return { type: 'object', _zodHint: String(schema) }\r\n  }\r\n}\r\n\r\nfunction bufferToBase64(buf: Buffer | Uint8Array): string {\r\n  if (typeof Buffer !== 'undefined' && buf instanceof Buffer) {\r\n    return buf.toString('base64')\r\n  }\r\n  let binary = ''\r\n  const bytes = buf as Uint8Array\r\n  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i])\r\n  const g = globalThis as any\r\n  return g.btoa ? g.btoa(binary) : Buffer.from(binary, 'binary').toString('base64')\r\n}\r\n"],"mappings":"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","names":[]}