@method-ai-hq/sdk 0.0.0-stage → 0.14.2

package/dist/packages/sdk/src/authoring.js

@@ -0,0 +1,287 @@
+import { preflight } from "@withmethod/runtime/preflight.js";
+import { configSchema, methodSchema } from "@withmethod/runtime/schema.js";
+import { isModelId } from "@withmethod/runtime/semantics.js";
+import { localSetup } from "./local-setup.js";
+/** Deterministic local authoring. No model calls, network calls, or workflow execution. */
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { renameSync, writeFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { CurrentCheckSchema, CurrentStepSchema } from "../../workflow-language/src/schema.js";
+import { loadWorkflow, parseDocumentValue, serializeWorkflow } from "../../workflow-language/src/validate.js";
+export function writeDocument(path, value) { const tmp = `${path}.${process.pid}.tmp`; try {
+    writeFileSync(tmp, serializeWorkflow(value), { mode: 0o600, flag: "wx" });
+    renameSync(tmp, path);
+}
+finally {
+    if (existsSync(tmp))
+        unlinkSync(tmp);
+} }
+import { authoringGuide, methodHelp } from "./method-help.js";
+export const authoringHelp = authoringGuide();
+export function authoringPath(path) {
+    return resolve(path);
+}
+export const readDocument = (file) => parseDocumentValue(readFileSync(authoringPath(file), "utf8"));
+const own = (v, k) => v !== null && typeof v === "object" && Object.hasOwn(v, k);
+function keys(path) {
+    if (!/^(?:\/(?:[^~]|~[01])*)*$/.test(path))
+        throw Error("Use a valid JSON Pointer, for example /steps/0/name.");
+    return path === "" ? [] : path.slice(1).split("/").map(k => k.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+export function at(document, path) {
+    let node = document;
+    for (const key of keys(path)) {
+        if (!own(node, key))
+            throw Error(`No value at ${path}.`);
+        node = node[key];
+    }
+    return node;
+}
+export function change(document, path, value, remove = false) {
+    const parts = keys(path), key = parts.pop();
+    if (key === undefined) {
+        if (remove)
+            throw Error("Cannot remove the whole document.");
+        return value;
+    }
+    const parent = at(document, parts.length ? "/" + parts.map(k => k.replaceAll("~", "~0").replaceAll("/", "~1")).join("/") : "");
+    if (!parent || typeof parent !== "object")
+        throw Error("The parent must be an object or array.");
+    if (Array.isArray(parent)) {
+        const index = key === "-" && !remove ? parent.length : /^(0|[1-9][0-9]*)$/.test(key) ? Number(key) : -1;
+        if (index < 0 || index > parent.length || remove && index === parent.length)
+            throw Error("Invalid array position.");
+        if (remove)
+            parent.splice(index, 1);
+        else
+            parent[index] = value;
+    }
+    else {
+        if (remove) {
+            if (!own(parent, key))
+                throw Error(`No value at ${path}.`);
+            delete parent[key];
+        }
+        else
+            Object.defineProperty(parent, key, { value, enumerable: true, writable: true, configurable: true });
+    }
+    return document;
+}
+/** Read, change, and replace the file in one rename. */
+export function editDocument(file, edit) {
+    const path = authoringPath(file);
+    const result = edit(readDocument(path));
+    writeDocument(path, result);
+    return result;
+}
+export function differences(a, b, path = "") {
+    if (JSON.stringify(a) === JSON.stringify(b))
+        return [];
+    if (a && b && typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b))
+        return [...new Set([...Object.keys(a), ...Object.keys(b)])].flatMap(k => differences(a[k], b[k], path + "/" + k.replaceAll("~", "~0").replaceAll("/", "~1")));
+    return [{ path, ...(a !== undefined ? { before: a } : {}), ...(b !== undefined ? { after: b } : {}) }];
+}
+export async function localAuthoring(args) {
+    const command = args[0];
+    const stepEdit = command === "step" && ["add", "update", "remove", "move"].includes(args[1] ?? "");
+    if (!stepEdit && !["authoring", "init", "show", "set", "remove", "check", "validate", "diff", "schema"].includes(command ?? ""))
+        return false;
+    if (args.includes("--help")) {
+        process.stdout.write(methodHelp(args));
+        return true;
+    }
+    if (command === "authoring") {
+        if (args.length > 3 || args.length === 3 && args[1] !== 'example')
+            throw Error("Use method authoring [TOPIC] or method authoring example EXAMPLE_ID.");
+        process.stdout.write(authoringGuide(args[1], args[2]));
+        return true;
+    }
+    const { values: v, positionals: p } = parseArgs({ args: args.slice(1), allowPositionals: true, options: Object.fromEntries([...["name", "goal", "id", "instructions-file", "json", "value-file", "text", "text-file", "path", "before", "model", "purpose", "kind", "runtime", "entrypoint", "workspace"].map(k => [k, { type: "string" }]),
+            // validate and check read these two flags from args.
+            ["notes", { type: "boolean" }], ["all", { type: "boolean" }]]) });
+    const print = (value) => process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+    const value = () => {
+        const sources = ["json", "value-file", "text", "text-file"].filter(k => v[k] !== undefined);
+        if (sources.length !== 1)
+            throw Error("Supply exactly one of --json, --value-file, --text, or --text-file.");
+        return v.json !== undefined ? JSON.parse(v.json) : v["value-file"] ? readDocument(v["value-file"]) : v.text !== undefined ? v.text : readFileSync(authoringPath(v["text-file"]), "utf8");
+    };
+    if (command === "schema") {
+        // The short reference is enough to write a Method; the JSON schemas are for tools.
+        if (!p[0]) {
+            process.stdout.write((await import("./authoring-instructions.js")).fieldReference);
+            return true;
+        }
+        if (["method", "config"].includes(p[0])) {
+            print(p[0] === "config" ? configSchema : methodSchema);
+            return true;
+        }
+        const schemas = { method: methodSchema, config: configSchema,
+            ...Object.fromEntries(["step", "check", "data"].map(name => [name, { $schema: methodSchema.$schema, $defs: methodSchema.$defs, $ref: `#/$defs/${name}` }])),
+            environment: { ...methodSchema.properties.environment.additionalProperties } };
+        const schema = schemas[p[0] ?? "method"];
+        if (!schema)
+            throw Error("Unknown schema. See method authoring.");
+        print(schema);
+        return true;
+    }
+    const file = stepEdit || command === "check" && ["set", "remove"].includes(p[0] ?? "") ? p[1] : p[0];
+    if (!file)
+        throw Error(`Supply a Method file. Read method ${command} --help.`);
+    if (command === "init") {
+        if (!v.name || !v.goal)
+            throw Error("Supply --name and --goal.");
+        const path = authoringPath(file);
+        if (existsSync(path))
+            throw Error("Choose a new draft file.");
+        const draft = { format: "method/3.4", name: v.name, goal: v.goal, steps: {}, result: {} };
+        // Exclusive creation prevents simultaneous init from replacing a draft.
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        const fd = openSync(path, "wx", 0o600);
+        closeSync(fd);
+        writeDocument(path, draft);
+        print({ file: path, workflow: draft });
+        return true;
+    }
+    if (command === "validate") {
+        let definition = "invalid";
+        const { collectIssues, shownIssues } = await import("./method-issues.js");
+        const flags = { notes: args.includes("--notes"), all: args.includes("--all") };
+        try {
+            const report = await collectIssues(file);
+            const shown = shownIssues(report, flags);
+            if (report.issues.some(issue => issue.level === "error")) {
+                print({ valid: false, definition: report.invalid ? "invalid" : "valid", executed: false, ...shown });
+                process.exitCode = 1;
+                return true;
+            }
+            const workflow = loadWorkflow((await import("./versions.js")).methodContent(readDocument(file)));
+            definition = "valid";
+            const { config, sourceRoot, agent } = await localSetup(file, v);
+            const declared = Object.keys(workflow.secrets ?? {});
+            const secrets = (await import('./secrets.js')).resolveSecrets(declared);
+            const { MethodClient } = await import("./method-client.js");
+            const client = new MethodClient();
+            const signedIn = (() => { try {
+                return !!client.token();
+            }
+            catch {
+                return false;
+            } })();
+            // A missing secret is the missing_secret issue, so preflight gets a stand-in for it. With a saved sign-in,
+            // classification and hosted models use the account, as in method run.
+            const signedInOptions = signedIn ? { classification: (await import("./classification-client.js")).managedClassification(client), hostedModels: (await import("./hosted-models.js")).managedModels(client) } : {};
+            // The run resolves the account's classifier version; validate checks only that it can.
+            if (signedIn && !config.classification)
+                config.classification = { provider: "typesafe", model: (await import("@withmethod/runtime/classification.js")).typesafeModel };
+            const { files, missingSetup } = await preflight(workflow, config, sourceRoot, { allowMissingSetup: true, secrets: { ...Object.fromEntries(declared.map(name => [name, "missing"])), ...secrets }, ...signedInOptions });
+            // What each step executes, and what it still needs on this computer.
+            const missingSecrets = declared.filter(name => !secrets[name]);
+            const ownKey = (await import("./own-model-key.js")).ownKeyEnv();
+            const steps = Object.entries(workflow.steps).map(([id, step]) => {
+                const exec = step.do, named = workflow.models?.[exec?.model] ?? (isModelId(exec?.model) ? exec.model : undefined);
+                const profile = named?.agent ? { backend: named.agent, model: named.model } : named ? { backend: "method", model: typeof named === "string" ? named : named.model } : config.models?.[exec?.model] ?? (exec?.model === "default" ? undefined : config.models?.default);
+                const runs = step.ask ? "asks the user"
+                    : exec.kind === "run" ? `${exec.runtime} ${exec.entrypoint}`
+                        : exec.kind === "classify" ? (config.classification?.api_key_env || ownKey ? "Jev through OpenRouter with your own key" : "Method's classifier")
+                            : profile?.backend === "method" ? (ownKey && !agent ? `${profile.model} through OpenRouter with your own key` : `the hosted model ${profile.model}`)
+                                : profile ? `${profile.backend}${profile.model ? ` ${profile.model}` : ""}`
+                                    : signedIn ? (ownKey && !agent ? "the account's default model through OpenRouter with your own key" : "the account's hosted model") : "a local Codex or Claude agent";
+                const needs = [...(exec?.kind === "run" ? missingSecrets.map(name => `secret ${name}`) : []),
+                    ...(!signedIn && (exec?.kind === "classify" && !config.classification?.api_key_env && !ownKey || ["call", "agent"].includes(exec?.kind) && !profile) ? [`method login (for ${exec.kind === "classify" ? "classification" : "hosted models"})`] : [])];
+                return { id, runs, ...(needs.length ? { needs } : {}) };
+            });
+            print({ valid: true, definition, local_setup: missingSetup.length ? "needs_preparation" : "valid", ...(missingSetup.length ? { missing_setup: [...new Set(missingSetup)] } : {}), workspace: sourceRoot, files: files.length, steps, executed: false, ...shown });
+        }
+        catch (error) {
+            // A setup error from preflight is an error issue too.
+            const issue = { level: "error", code: error?.code ?? "invalid_method", message: error instanceof Error ? error.message : String(error), fix: "Fix what the message names, then validate again." };
+            print({ valid: false, definition, local_setup: definition === "valid" ? "invalid" : "not_checked", executed: false, error: issue.message, issues: [issue], issue_counts: { errors: 1, warnings: 0, notes: 0, accepted: 0 } });
+            process.exitCode = 1;
+        }
+        return true;
+    }
+    if (command === "check" && /\.(method|json)$/i.test(file) && !p[2]) {
+        // method check FILE: only the issues, without the local setup.
+        const { collectIssues, shownIssues } = await import("./method-issues.js");
+        const report = await collectIssues(file);
+        const errors = report.issues.some(issue => issue.level === "error");
+        print({ valid: !errors, ...shownIssues(report, { notes: args.includes("--notes"), all: args.includes("--all") }) });
+        if (errors)
+            process.exitCode = 1;
+        return true;
+    }
+    if (command === "show") {
+        print(at(readDocument(file), v.path ?? ""));
+        return true;
+    }
+    if (command === "diff") {
+        if (!p[1])
+            throw Error("Supply two files.");
+        print(differences(readDocument(file), readDocument(p[1])));
+        return true;
+    }
+    const result = editDocument(file, doc => {
+        if (command === "set" || command === "remove") {
+            if (p[1] === undefined)
+                throw Error("Supply a JSON Pointer.");
+            return change(doc, p[1], command === "set" ? value() : undefined, command === "remove");
+        }
+        if (!doc.steps || Array.isArray(doc.steps) || typeof doc.steps !== "object")
+            throw Error("The draft needs a steps map.");
+        const action = p[0], id = p[2];
+        if (stepEdit) {
+            if (action === "add") {
+                if (!v.id)
+                    throw Error("Supply --id.");
+                if (Object.hasOwn(doc.steps, v.id))
+                    throw Error("That step already exists.");
+                {
+                    if (v["value-file"] || v.json)
+                        doc.steps[v.id] = CurrentStepSchema.parse(value());
+                    else {
+                        const kind = v.kind ?? "agent";
+                        const execution = kind === "run" ? { kind, runtime: v.runtime, entrypoint: v.entrypoint } : { kind, model: v.model ?? "default", prompt: v["instructions-file"] ? readFileSync(authoringPath(v["instructions-file"]), "utf8") : undefined, ...(kind === "agent" ? { tools: [] } : {}) };
+                        doc.steps[v.id] = CurrentStepSchema.parse({ ...(v.name ? { name: v.name } : {}), ...(v.purpose ? { purpose: v.purpose } : {}), do: execution });
+                    }
+                }
+            }
+            else {
+                if (!id || !Object.hasOwn(doc.steps, id))
+                    throw Error("Step not found.");
+                if (action === "remove")
+                    delete doc.steps[id];
+                else if (action === "update") {
+                    const patch = value();
+                    if (!patch || Array.isArray(patch) || typeof patch !== "object")
+                        throw Error("Supply step fields.");
+                    doc.steps[id] = CurrentStepSchema.parse({ ...doc.steps[id], ...patch });
+                }
+                else {
+                    if (!v.before || !Object.hasOwn(doc.steps, v.before))
+                        throw Error("Supply --before with a step ID.");
+                    if (v.before !== id) {
+                        const entries = Object.entries(doc.steps).filter(([key]) => key !== id);
+                        const at = entries.findIndex(([key]) => key === v.before);
+                        entries.splice(at, 0, [id, doc.steps[id]]);
+                        doc.steps = Object.fromEntries(entries);
+                    }
+                }
+            }
+        }
+        else {
+            if (!id || !Object.hasOwn(doc.steps, id))
+                throw Error("Step not found.");
+            if (action === "remove")
+                delete doc.steps[id].check;
+            else if (action === "set")
+                doc.steps[id].check = CurrentCheckSchema.parse(value());
+            else
+                throw Error("Use check set or check remove.");
+        }
+        return doc;
+    });
+    print({ file: resolve(file), workflow: result });
+    return true;
+}

package/dist/packages/sdk/src/bindings.d.ts

@@ -0,0 +1,4 @@
+import type { MethodClient } from './method-client.js';
+export declare function bindInput(client: MethodClient, idOrFile: string, name: string, path: string, upload?: boolean): Promise<any>;
+export declare function bindConnection(client: MethodClient, idOrFile: string, name: string, value: string, upload?: boolean): Promise<any>;
+export declare function resolveBindings(client: MethodClient, id: string, method: any, config: any, root: string, runDirectory: string): Promise<any>;

package/dist/packages/sdk/src/bindings.js

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync, readdirSync, lstatSync, realpathSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve, dirname, relative, isAbsolute } from 'node:path';
+import { packagePath } from '../../contracts/src/method-package.js';
+import { fileHash } from './method-files.js';
+import { writePrivateJson } from './files.js';
+import { bindConnectionValue, readComputerSettings } from './computer-settings.js';
+import { ensureMethodId } from './versions.js';
+import { readDocument } from './authoring.js';
+/** A Method by ID (its saved definition) or by local FILE (its id: line is written when it has none). */
+async function target(client, idOrFile) {
+    if (/\.method$/i.test(idOrFile) && existsSync(idOrFile)) {
+        const id = ensureMethodId(idOrFile);
+        return { id, workflow: readDocument(idOrFile) };
+    }
+    if (!client.token())
+        throw Error('Use the Method FILE, or sign in with method login to bind a saved Method by ID.');
+    return { id: idOrFile, workflow: (await client.request(`/api/cli/methods/${encodeURIComponent(idOrFile)}`)).workflow };
+}
+export async function bindInput(client, idOrFile, name, path, upload = false) {
+    if (!/^[a-z][a-z0-9_]*$/.test(name))
+        throw Error('Use the environment binding name.');
+    const { id, workflow } = await target(client, idOrFile);
+    if (workflow.environment?.[name]?.type !== 'files')
+        throw Error('Use the name of a declared files binding.');
+    const root = realpathSync(resolve(path));
+    if (!upload) {
+        bindConnectionValue(id, name, root);
+        return { saved: true, scope: 'this computer', method_id: id, name };
+    }
+    const files = [];
+    async function walk(dir, prefix = '') {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            // Do not enumerate protected trees. The upload is only the explicitly chosen folder.
+            if (['.git', '.codex', '.claude', 'node_modules', '.venv'].includes(entry.name) || entry.name.startsWith('.env') || entry.name === 'secrets.env')
+                continue;
+            const name = prefix + entry.name;
+            packagePath(name);
+            const path = join(dir, entry.name);
+            if (entry.isSymbolicLink())
+                throw Error(`Input contains a symbolic link: ${name}`);
+            if (entry.isDirectory())
+                await walk(path, name + '/');
+            else if (entry.isFile()) {
+                const bytes = readFileSync(path);
+                if (bytes.length > 20_000_000)
+                    throw Error(`Input file exceeds 20 MB: ${name}`);
+                const hash = fileHash(bytes);
+                await client.transfer(`/api/cli/files/${hash}`, bytes);
+                files.push({ path: name, sha256: hash, size: bytes.length });
+            }
+        }
+    }
+    await walk(root);
+    return client.request(`/api/cli/methods/${encodeURIComponent(id)}/bindings/${name}`, 'PUT', { kind: 'files', files });
+}
+export async function bindConnection(client, idOrFile, name, value, upload = false) {
+    const { id, workflow } = await target(client, idOrFile);
+    if (!workflow.environment?.[name] || workflow.environment[name].type === 'files')
+        throw Error('Use a declared service, browser, desktop, or tool binding.');
+    // Values identify a connection. Credentials remain in the service's existing login store.
+    if (workflow.environment[name].type === 'browser' && /^method-browser:[a-z][a-z0-9_-]*$/.test(value)) {
+        if (upload)
+            throw Error('Browser selection is private to this computer.');
+        bindConnectionValue(id, name, value);
+        return { saved: true, scope: 'this computer', method_id: id, name };
+    }
+    const url = new URL(value);
+    if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+        throw Error('Use a connection URL without credentials, query parameters, or a fragment.');
+    if (upload)
+        return client.request(`/api/cli/methods/${encodeURIComponent(id)}/bindings/${name}`, 'PUT', { kind: 'connection', value: url.href });
+    bindConnectionValue(id, name, url.href);
+    return { saved: true, scope: 'this computer', method_id: id, name };
+}
+export async function resolveBindings(client, id, method, config, root, runDirectory) {
+    const local = readComputerSettings().bindings[id] ?? {};
+    const snapshot = join(runDirectory, 'input-bindings.json');
+    const remote = existsSync(snapshot) ? JSON.parse(readFileSync(snapshot, 'utf8')) : await client.request(`/api/cli/methods/${encodeURIComponent(id)}/bindings`);
+    const environment = { ...config.environment }, missing = [];
+    for (const [name, definition] of Object.entries(method.environment ?? {})) {
+        if (definition.type === 'browser' && !local[name] && !remote[name] && !environment[name]) {
+            environment[name] = 'method-browser:default';
+            continue;
+        }
+        if (local[name] && (definition.type !== 'files' || existsSync(local[name]))) {
+            environment[name] = local[name];
+            continue;
+        }
+        if (environment[name]) {
+            if (definition.type === 'files')
+                environment[name] = resolve(root, environment[name]);
+            continue;
+        }
+        if (remote[name]?.kind === 'connection') {
+            environment[name] = remote[name].value;
+            continue;
+        }
+        if (remote[name]?.kind === 'files') {
+            const folder = join(runDirectory, 'inputs', name);
+            mkdirSync(folder, { recursive: true, mode: 0o700 });
+            for (const f of remote[name].files) {
+                const target = join(folder, packagePath(f.path));
+                mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+                const parent = relative(realpathSync(folder), realpathSync(dirname(target)));
+                if (parent.startsWith('..') || isAbsolute(parent) || existsSync(target) && lstatSync(target).isSymbolicLink())
+                    throw Error('Input destination leaves the run folder.');
+                if (existsSync(target) && fileHash(readFileSync(target)) === f.sha256)
+                    continue;
+                const bytes = await client.transfer(`/api/cli/methods/${encodeURIComponent(id)}/bindings/${name}/files/${f.sha256}`);
+                if (fileHash(bytes) !== f.sha256 || bytes.length !== f.size)
+                    throw Error(`Input checksum failed: ${f.path}`);
+                writeFileSync(target, bytes, { mode: 0o600 });
+            }
+            environment[name] = folder;
+            continue;
+        }
+        missing.push({ name, description: definition.description, command: definition.type === 'files' ? `method bind ${id} ${name} --file PATH` : `method bind ${id} ${name} --connection URL`, ...(definition.type === 'files' ? { account_copy: `Add --upload only to save this selected input folder privately in your Method account.` } : {}) });
+    }
+    if (missing.length)
+        throw Object.assign(new Error('Supply the missing Method inputs or connections.'), { code: 'needs_input', missing });
+    if (!existsSync(snapshot))
+        writePrivateJson(snapshot, remote);
+    return { ...config, environment };
+}

package/dist/packages/sdk/src/bridge.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/packages/sdk/src/bridge.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/** Python calls the same current runtime; no callback executor or second interpreter. */
+import { createInterface } from "node:readline";
+import { z } from "zod";
+import { runMethod } from "./run-method.js";
+import { authoringPath } from "./authoring.js";
+import { loadWorkflow } from "../../workflow-language/src/validate.js";
+import { renderPrompt } from "../../method-document/src/conversion-report.js";
+const lines = createInterface({ input: process.stdin, terminal: false });
+const send = (value) => process.stdout.write(JSON.stringify(value) + "\n");
+async function main() {
+    const first = await lines[Symbol.asyncIterator]().next();
+    if (first.done)
+        throw Error("The bridge needs one JSON request.");
+    const message = z.object({ op: z.enum(["load", "prompt", "run_method"]), workflow: z.unknown().optional() }).passthrough().parse(JSON.parse(first.value));
+    if (message.op === "load")
+        return loadWorkflow(message.workflow);
+    if (message.op === "prompt")
+        return renderPrompt(loadWorkflow(message.workflow));
+    const data = z.object({ file: z.string(), config: z.record(z.unknown()), options: z.record(z.unknown()).default({}) }).parse(message);
+    return runMethod(authoringPath(data.file), data.config, { ...data.options, onEvent: (event) => { send({ type: "event", event }); } });
+}
+main().then(result => send({ type: "result", result }), error => { send({ type: "error", error: error instanceof Error ? error.message : String(error) }); process.exitCode = 1; }).finally(() => lines.close());

package/dist/packages/sdk/src/browser-runtime/pyproject.toml

@@ -0,0 +1,5 @@
+[project]
+name = "method-browser"
+version = "0.1.0"
+requires-python = ">=3.12,<3.13"
+dependencies = ["browser-use==0.13.10", "mcp==2.1.1"]

package/dist/packages/sdk/src/browser-runtime/tools.json

@@ -0,0 +1,189 @@
+[
+  {
+    "name": "browser_navigate",
+    "description": "Navigate to a URL in the browser",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "url": {
+          "type": "string",
+          "description": "The URL to navigate to"
+        },
+        "new_tab": {
+          "type": "boolean",
+          "description": "Whether to open in a new tab",
+          "default": false
+        }
+      },
+      "required": [
+        "url"
+      ]
+    }
+  },
+  {
+    "name": "browser_click",
+    "description": "Click an element by index or at specific viewport coordinates. Use index for elements from browser_get_state, or coordinate_x/coordinate_y for pixel-precise clicking.",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "index": {
+          "type": "integer",
+          "description": "The index of the element to click (from browser_get_state). Provide this OR coordinate_x+coordinate_y."
+        },
+        "coordinate_x": {
+          "type": "integer",
+          "description": "X coordinate in pixels from the left edge of the viewport. Must be used together with coordinate_y. Provide this OR index."
+        },
+        "coordinate_y": {
+          "type": "integer",
+          "description": "Y coordinate in pixels from the top edge of the viewport. Must be used together with coordinate_x. Provide this OR index."
+        },
+        "new_tab": {
+          "type": "boolean",
+          "description": "Whether to open any resulting navigation in a new tab",
+          "default": false
+        }
+      }
+    }
+  },
+  {
+    "name": "browser_type",
+    "description": "Type text into an input field. Clears existing text by default; pass text=\"\" to clear only.",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "index": {
+          "type": "integer",
+          "description": "The index of the input element (from browser_get_state)"
+        },
+        "text": {
+          "type": "string",
+          "description": "The text to type. Pass an empty string (\"\") to clear the field without typing."
+        }
+      },
+      "required": [
+        "index",
+        "text"
+      ]
+    }
+  },
+  {
+    "name": "browser_get_state",
+    "description": "Get the current state of the page including all interactive elements",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "include_screenshot": {
+          "type": "boolean",
+          "description": "Whether to include a screenshot of the current page",
+          "default": false
+        }
+      }
+    },
+    "annotations": {
+      "readOnlyHint": true
+    }
+  },
+  {
+    "name": "browser_get_html",
+    "description": "Get the raw HTML of the current page or a specific element by CSS selector",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "selector": {
+          "type": "string",
+          "description": "Optional CSS selector to get HTML of a specific element. If omitted, returns full page HTML."
+        }
+      }
+    },
+    "annotations": {
+      "readOnlyHint": true
+    }
+  },
+  {
+    "name": "browser_screenshot",
+    "description": "Take a screenshot of the current page. Returns viewport metadata as text and the screenshot as an image.",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "full_page": {
+          "type": "boolean",
+          "description": "Whether to capture the full scrollable page or just the visible viewport",
+          "default": false
+        }
+      }
+    },
+    "annotations": {
+      "readOnlyHint": true
+    }
+  },
+  {
+    "name": "browser_scroll",
+    "description": "Scroll the page",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "direction": {
+          "type": "string",
+          "enum": [
+            "up",
+            "down"
+          ],
+          "description": "Direction to scroll",
+          "default": "down"
+        }
+      }
+    }
+  },
+  {
+    "name": "browser_go_back",
+    "description": "Go back to the previous page",
+    "inputSchema": {
+      "type": "object",
+      "properties": {}
+    }
+  },
+  {
+    "name": "browser_list_tabs",
+    "description": "List all open tabs",
+    "inputSchema": {
+      "type": "object",
+      "properties": {}
+    },
+    "annotations": {
+      "readOnlyHint": true
+    }
+  },
+  {
+    "name": "browser_switch_tab",
+    "description": "Switch to a different tab",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "tab_id": {
+          "type": "string",
+          "description": "4 Character Tab ID of the tab to switch to"
+        }
+      },
+      "required": [
+        "tab_id"
+      ]
+    }
+  },
+  {
+    "name": "browser_close_tab",
+    "description": "Close a tab",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "tab_id": {
+          "type": "string",
+          "description": "4 Character Tab ID of the tab to close"
+        }
+      },
+      "required": [
+        "tab_id"
+      ]
+    }
+  }
+]