@unbrowse/sdk 12.0.0 → 12.1.0

package/README.md

@@ -4,7 +4,7 @@ TypeScript client for the Unbrowse API (`https://unbrowse.ai/api/v1`). Node 18.1
 or any runtime with `fetch`. No dependencies. The `unbrowse` CLI is built on it.
 
 ```bash
-npm install https://github.com/unbrowse-ai/unbrowse-skill/releases/download/v12.0.0-alpha.1/unbrowse-sdk-12.0.0-alpha.1.tgz
+npm install https://github.com/unbrowse-ai/unbrowse/releases/download/v12.0.1/unbrowse-sdk-12.0.1.tgz
 ```
 
 ```ts

package/dist/index.d.ts

@@ -2,3 +2,5 @@ export { DEFAULT_BASE_URL, Unbrowse, UnbrowseError, normalizeHost } from "./clie
 export type { LoginView, UnbrowseOptions } from "./client.ts";
 export type * from "./types.ts";
 export { cursorInstallLink, mcpCommands, vscodeInstallLink } from "./mcp-install.ts";
+export { DEFAULT_MCP_URL, MCP_PROTOCOL_VERSION, UnbrowseMcp, parseRpcBody, resultText } from "./mcp.ts";
+export type { McpContent, McpOptions, McpTool, McpToolResult } from "./mcp.ts";

package/dist/index.js

@@ -175,12 +175,96 @@ function mcpCommands(url) {
     json: JSON.stringify({ mcpServers: { unbrowse: { url } } }, null, 2)
   };
 }
+// src/mcp.ts
+var DEFAULT_MCP_URL = "https://unbrowse.ai/mcp";
+var MCP_PROTOCOL_VERSION = "2025-11-25";
+var env2 = (name) => (typeof process !== "undefined" ? process.env?.[name] : undefined) || undefined;
+function parseRpcBody(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{"))
+    return JSON.parse(trimmed);
+  const events = trimmed.split(/\n\n+/).flatMap((block) => {
+    const data = block.split(`
+`).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart()).join(`
+`);
+    return data ? [data] : [];
+  });
+  if (!events.length)
+    throw new UnbrowseError("Empty MCP response", 502, "mcp_empty");
+  return JSON.parse(events[events.length - 1]);
+}
+function resultText(result) {
+  const text = result.content?.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join(`
+`);
+  return text || (result.structuredContent === undefined ? "" : JSON.stringify(result.structuredContent));
+}
+
+class UnbrowseMcp {
+  url;
+  apiKey;
+  endUser;
+  client;
+  fetchImpl;
+  nextId = 1;
+  constructor(opts = {}) {
+    this.url = (opts.url ?? env2("UNBROWSE_MCP_URL") ?? DEFAULT_MCP_URL).replace(/\/+$/, "");
+    this.apiKey = opts.apiKey ?? env2("UNBROWSE_API_KEY");
+    this.endUser = opts.endUser ?? env2("UNBROWSE_END_USER");
+    this.client = opts.client ?? "sdk";
+    this.fetchImpl = opts.fetch ?? ((...a) => globalThis.fetch(...a));
+  }
+  async rpc(method, params) {
+    const res = await this.fetchImpl(this.url, {
+      method: "POST",
+      headers: {
+        ...this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {},
+        ...this.endUser ? { "x-unbrowse-end-user": this.endUser } : {},
+        "content-type": "application/json",
+        accept: "application/json, text/event-stream",
+        "mcp-protocol-version": MCP_PROTOCOL_VERSION,
+        "user-agent": `unbrowse-${this.client}`
+      },
+      body: JSON.stringify({ jsonrpc: "2.0", id: this.nextId++, method, ...params ? { params } : {} })
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      let body = {};
+      try {
+        body = JSON.parse(text);
+      } catch {}
+      const err = typeof body.error === "object" ? body.error : undefined;
+      throw new UnbrowseError(err?.message ?? body.error_description ?? (res.statusText || `HTTP ${res.status}`), res.status, err?.code ?? (typeof body.error === "string" ? body.error : "http_error"), body);
+    }
+    const msg = parseRpcBody(text);
+    if (msg.error)
+      throw new UnbrowseError(msg.error.message, 200, msg.error.data?.code ?? `rpc_${msg.error.code}`, msg.error);
+    return msg.result;
+  }
+  async listTools() {
+    const tools = [];
+    let cursor;
+    do {
+      const page = await this.rpc("tools/list", cursor ? { cursor } : undefined);
+      tools.push(...page.tools);
+      cursor = page.nextCursor;
+    } while (cursor);
+    return tools;
+  }
+  callTool(name, args = {}) {
+    return this.rpc("tools/call", { name, arguments: args });
+  }
+}
 export {
   DEFAULT_BASE_URL,
+  DEFAULT_MCP_URL,
+  MCP_PROTOCOL_VERSION,
   Unbrowse,
   UnbrowseError,
+  UnbrowseMcp,
   cursorInstallLink,
   mcpCommands,
   normalizeHost,
+  parseRpcBody,
+  resultText,
   vscodeInstallLink
 };

package/dist/mcp.d.ts

@@ -0,0 +1,60 @@
+import type { Json } from "./types.ts";
+export declare const DEFAULT_MCP_URL = "https://unbrowse.ai/mcp";
+/** Sent as `Mcp-Protocol-Version`. The hosted server refuses 2025-06-18 on its streaming path. */
+export declare const MCP_PROTOCOL_VERSION = "2025-11-25";
+export type McpOptions = {
+    /** API key (`ub_live_…`) or OAuth access token. Defaults to `UNBROWSE_API_KEY`. */
+    apiKey?: string;
+    /** Defaults to `UNBROWSE_MCP_URL`, then https://unbrowse.ai/mcp. */
+    url?: string;
+    /** Org keys: the end user the call is for (`X-Unbrowse-End-User`). */
+    endUser?: string;
+    fetch?: typeof globalThis.fetch;
+    /** Client name sent on the wire (User-Agent suffix). */
+    client?: string;
+};
+export type McpTool = {
+    name: string;
+    description?: string;
+    inputSchema: {
+        type: "object";
+        properties?: Record<string, Json>;
+        required?: string[];
+    } & Record<string, unknown>;
+};
+export type McpContent = {
+    type: string;
+    text?: string;
+} & Record<string, unknown>;
+export type McpToolResult = {
+    content: McpContent[];
+    structuredContent?: Json;
+    isError?: boolean;
+};
+/** The JSON-RPC message in a response body: plain JSON, or the last `data:` event of an SSE stream. */
+export declare function parseRpcBody(text: string): {
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: {
+            code?: string;
+        } & Record<string, unknown>;
+    };
+};
+/** Plain text of a tool result: its text parts, else its structured content as JSON. */
+export declare function resultText(result: McpToolResult): string;
+export declare class UnbrowseMcp {
+    readonly url: string;
+    private apiKey?;
+    private endUser?;
+    private client;
+    private fetchImpl;
+    private nextId;
+    constructor(opts?: McpOptions);
+    /** One JSON-RPC call. MCP errors become UnbrowseError with the server's `data.code` (e.g. `browser_capacity`). */
+    rpc<T>(method: string, params?: Record<string, unknown>): Promise<T>;
+    /** Every tool this key can call: the core tools plus the workspace's learned and indexed ones. */
+    listTools(): Promise<McpTool[]>;
+    callTool(name: string, args?: Record<string, unknown>): Promise<McpToolResult>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unbrowse/sdk",
-  "version": "12.0.0",
+  "version": "12.1.0",
   "description": "TypeScript client for the Unbrowse API (unbrowse.ai/api/v1): runs, capabilities, learning, logins and the public site registry.",
   "license": "MIT",
   "type": "module",