@xopcai/xopc 0.0.250 → 0.0.252

package/dist/src/cli/commands/browser.js

@@ -1,170 +1,29 @@
 import { register } from "../registry.js";
 import { Command } from "commander";
 //#region src/cli/commands/browser.ts
-/**
-* CLI: `xopc browser` — browser automation commands.
-*
-* Shares the same action registry and pipeline runner as the `browser_use` AgentTool.
-*/
 function createBrowserCommand(_ctx) {
-	const cmd = new Command("browser").description("Browser automation commands (uses Playwright)");
-	cmd.command("open <url>").description("Open a URL in the browser").option("--headless", "Run without a visible window (default: use config; default config is headed)").action(async (url, opts) => {
-		const { executeBrowserCliAction } = await import("./browser-cli-helpers.js");
-		await executeBrowserCliAction("open", {
-			url,
-			...opts
-		});
-	});
-	cmd.command("state").description("Get current page state (URL, title, ARIA snapshot)").option("--selector <selector>", "CSS selector to scope snapshot").action(async (opts) => {
-		const { executeBrowserCliAction } = await import("./browser-cli-helpers.js");
-		await executeBrowserCliAction("state", opts);
-	});
-	cmd.command("click").description("Click an element").option("--selector <selector>", "CSS selector").option("--text <text>", "Visible text").option("--role <role>", "ARIA role:name (e.g. button:Submit)").action(async (opts) => {
-		const { executeBrowserCliAction } = await import("./browser-cli-helpers.js");
-		await executeBrowserCliAction("click", opts);
-	});
-	cmd.command("type").description("Type text into an input").option("--selector <selector>", "CSS selector").option("--label <label>", "Label text").requiredOption("--text <text>", "Text to type").option("--enter", "Press Enter after typing").action(async (opts) => {
-		const { executeBrowserCliAction } = await import("./browser-cli-helpers.js");
-		await executeBrowserCliAction("type", {
-			...opts,
-			pressEnter: opts.enter
-		});
-	});
-	cmd.command("screenshot [path]").description("Take a screenshot").option("--selector <selector>", "CSS selector").option("--full-page", "Full page screenshot").action(async (path, opts) => {
-		const { executeBrowserCliAction } = await import("./browser-cli-helpers.js");
-		await executeBrowserCliAction("screenshot", {
-			path: path ?? "./screenshot.png",
-			...opts,
-			full_page: opts.fullPage
-		});
-	});
-	cmd.command("validate <file>").description("Validate a Browser Recipe v1 YAML file without executing").action(async (file) => {
-		const { validatePipelineCli } = await import("./browser-cli-helpers.js");
-		await validatePipelineCli(file);
-	});
-	cmd.command("run <file>").description("Run a Browser Recipe v1 YAML file").option("--arg <args...>", "Recipe args (key=<JSON value>)").action(async (file, opts) => {
-		const { runPipelineCli } = await import("./browser-cli-helpers.js");
-		const args = {};
-		if (opts.arg) for (const a of opts.arg) {
-			const eq = a.indexOf("=");
-			if (eq <= 0) throw new Error(`Invalid --arg: ${a}`);
-			args[a.slice(0, eq)] = JSON.parse(a.slice(eq + 1));
-		}
-		await runPipelineCli(file, args);
-	});
-	cmd.command("doctor").description("Check browser environment (Playwright, Chromium)").action(async () => {
+	const command = new Command("browser").description("Browser Control v2 diagnostics and extension setup");
+	command.command("doctor").description("Check the configured browser driver").action(async () => {
 		const { doctorCli } = await import("./browser-cli-helpers.js");
 		await doctorCli();
 	});
-	cmd.command("close").description("Close the browser session").action(async () => {
-		const { executeBrowserCliAction } = await import("./browser-cli-helpers.js");
-		await executeBrowserCliAction("close", {});
-	});
-	const cloakCmd = cmd.command("cloakbrowser").description("CloakBrowser anti-fingerprint browser management");
-	cloakCmd.command("doctor").description("Check CloakBrowser installation status and version").action(async () => {
-		const { cloakBrowserDoctor } = await import("../../browser/providers/cloakbrowser.js");
-		const result = await cloakBrowserDoctor();
-		console.log("\n  CloakBrowser Status\n");
-		console.log(`  Installed:   ${result.installed ? "✓ yes" : "✗ no"}`);
-		console.log(`  Platform:    ${result.platform}`);
-		console.log(`  Version:     ${result.version ?? "(not installed)"}`);
-		console.log(`  Binary:      ${result.binaryPath ?? "(not found)"}`);
-		console.log(`  Cache dir:   ${result.cacheDir}`);
-		console.log("");
-		if (!result.installed) console.log("  Run \"xopc browser cloakbrowser install\" to download CloakBrowser.\n");
-	});
-	cloakCmd.command("install").description("Download and install CloakBrowser binary").option("--cache-dir <dir>", "Custom cache directory for the binary").action(async (opts) => {
-		console.log("\n  Downloading CloakBrowser...\n");
-		try {
-			const { launchCloakBrowser, cleanupCloakBrowser } = await import("../../browser/providers/cloakbrowser.js");
-			const result = await launchCloakBrowser({
-				headless: true,
-				temporaryProfile: true,
-				keepOpen: false,
-				cacheDir: opts.cacheDir
-			});
-			await result.browser.close().catch(() => {});
-			await cleanupCloakBrowser(result.childProcess, result.temporaryProfileDir);
-			console.log("  ✓ CloakBrowser installed successfully.\n");
-		} catch (e) {
-			const msg = e instanceof Error ? e.message : String(e);
-			console.error(`  ✗ Installation failed: ${msg}\n`);
-			process.exitCode = 1;
-		}
-	});
-	const extensionCmd = cmd.command("extension").description("xopc Chrome extension (browser bridge) management");
-	extensionCmd.command("doctor").description("Check bundled extension install status").option("--cache-dir <dir>", "Custom bin cache directory").action(async (opts) => {
+	const extension = command.command("extension").description("Chrome extension setup");
+	extension.command("doctor").description("Check extension artifacts").action(async () => {
 		const { browserExtDoctor } = await import("../../browser/providers/browser-ext-install.js");
-		const result = await browserExtDoctor({ cacheDir: opts.cacheDir });
-		console.log("\n  Chrome Extension Artifacts\n");
-		console.log(`  Bundled:     ${result.bundledAvailable ? "✓ yes" : "✗ no"}`);
-		console.log(`  Installed:   ${result.installed ? "✓ yes" : "✗ no"}`);
-		console.log(`  xopc ver:    ${result.xopcVersion}`);
-		console.log(`  Installed:   ${result.installedVersion ?? "(none)"}`);
-		console.log(`  Manifest:    ${result.manifestVersion ?? "(none)"}`);
-		console.log(`  Directory:   ${result.extensionDir ?? "(not installed)"}`);
-		console.log(`  Cache dir:   ${result.cacheDir}`);
-		console.log(`  Refresh:     ${result.needsRefresh ? "needed" : "up to date"}`);
-		if (result.needsChromeReload) console.log("  ⚠ Chrome reload required (extension runtime version mismatch)");
-		console.log("");
-		if (!result.installed) console.log("  Run \"xopc browser extension install\" to copy bundled artifacts.\n");
-	});
-	extensionCmd.command("install").description("Copy bundled Chrome extension to the local bin directory").option("--cache-dir <dir>", "Custom bin cache directory").option("--force", "Force reinstall even when up to date").action(async (opts) => {
-		console.log("\n  Installing Chrome extension artifacts...\n");
-		try {
-			const { ensureBrowserExtensionArtifacts } = await import("../../browser/providers/browser-ext-install.js");
-			const result = await ensureBrowserExtensionArtifacts({
-				cacheDir: opts.cacheDir,
-				force: opts.force
-			});
-			console.log(`  ✓ ${result.copied ? "Installed" : "Already up to date"}`);
-			console.log(`  Directory: ${result.extensionDir}\n`);
-			console.log("  Next steps:");
-			console.log("  1. Open chrome://extensions");
-			console.log("  2. Enable Developer mode");
-			console.log("  3. Load unpacked → select the directory above");
-			console.log("  4. Run \"xopc browser extension open\" to open Chrome and reveal the folder\n");
-		} catch (e) {
-			const msg = e instanceof Error ? e.message : String(e);
-			console.error(`  ✗ Installation failed: ${msg}\n`);
-			process.exitCode = 1;
-		}
+		console.log(JSON.stringify(await browserExtDoctor(), null, 2));
 	});
-	extensionCmd.command("open").description("Open chrome://extensions and reveal the extension folder").option("--cache-dir <dir>", "Custom bin cache directory").action(async (opts) => {
-		try {
-			const { openBrowserExtensionInstallUi } = await import("../../browser/providers/browser-ext-install.js");
-			const { extensionDir } = await openBrowserExtensionInstallUi({
-				action: "both",
-				cacheDir: opts.cacheDir
-			});
-			console.log(`Opened Chrome extensions page and folder:\n  ${extensionDir}`);
-		} catch (e) {
-			const msg = e instanceof Error ? e.message : String(e);
-			console.error(`  ✗ ${msg}\n`);
-			process.exitCode = 1;
-		}
+	extension.command("install").description("Install extension artifacts").action(async () => {
+		const { ensureBrowserExtensionArtifacts } = await import("../../browser/providers/browser-ext-install.js");
+		console.log(JSON.stringify(await ensureBrowserExtensionArtifacts(), null, 2));
 	});
-	return cmd;
+	return command;
 }
 register({
 	id: "browser",
 	name: "browser",
-	description: "Browser automation commands",
+	description: "Browser Control v2 diagnostics and extension setup",
 	factory: createBrowserCommand,
-	metadata: {
-		category: "utility",
-		examples: [
-			"xopc browser open https://example.com",
-			"xopc browser validate ./flow.yaml",
-			"xopc browser run ./flow.yaml",
-			"xopc browser doctor",
-			"xopc browser cloakbrowser doctor",
-			"xopc browser cloakbrowser install",
-			"xopc browser extension doctor",
-			"xopc browser extension install",
-			"xopc browser extension open"
-		]
-	}
+	metadata: { category: "utility" }
 });
 //#endregion
 export {};

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -52,7 +52,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v152).`,
+		message: `SQLite schema v${status.dbVersion} (current release v153).`,
 		hints: []
 	};
 }

package/dist/src/cli/commands/doctor/checks/node-version.js

@@ -1,29 +1,45 @@
 //#region src/cli/commands/doctor/checks/node-version.ts
-function parseNodeMajorVersion() {
-	const match = process.version.match(/^v(\d+)/);
-	return match ? parseInt(match[1], 10) : 0;
+const MINIMUM_NODE_VERSION = [
+	22,
+	22,
+	3
+];
+function parseNodeVersion() {
+	const match = process.version.match(/^v(\d+)\.(\d+)\.(\d+)/);
+	return match ? [
+		Number.parseInt(match[1], 10),
+		Number.parseInt(match[2], 10),
+		Number.parseInt(match[3], 10)
+	] : void 0;
+}
+function meetsMinimumVersion(version) {
+	for (const [index, minimum] of MINIMUM_NODE_VERSION.entries()) {
+		if (version[index] > minimum) return true;
+		if (version[index] < minimum) return false;
+	}
+	return true;
 }
 async function checkNodeVersion(_ctx) {
-	const major = parseNodeMajorVersion();
-	if (major === 0) return {
+	const version = parseNodeVersion();
+	if (!version) return {
 		id: "node-version",
 		label: "Host Node.js",
 		status: "warn",
 		message: "Could not parse Node.js version.",
 		hints: [`process.version=${process.version}`]
 	};
-	if (major < 22) return {
+	if (!meetsMinimumVersion(version)) return {
 		id: "node-version",
 		label: "Host Node.js",
 		status: "fail",
-		message: `Node ${major} is below the required minimum (22).`,
-		hints: ["Install Node.js 22+ from https://nodejs.org/"]
+		message: `Node.js ${process.version} is below the required minimum (22.22.3).`,
+		hints: ["Install Node.js 22.22.3+ from https://nodejs.org/"]
 	};
 	return {
 		id: "node-version",
 		label: "Host Node.js",
 		status: "pass",
-		message: `Node.js ${process.version} meets the project requirement (>= 22).`,
+		message: `Node.js ${process.version} meets the project requirement (>= 22.22.3).`,
 		hints: []
 	};
 }

package/dist/src/cli/commands/platform.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/cli/commands/platform.js

@@ -0,0 +1,111 @@
+import { loadConfig, saveConfig } from "../../config/loader.js";
+import { formatExamples, register } from "../registry.js";
+import "../../config/index.js";
+import { PLATFORM_RUNTIME_PROFILE, PLATFORM_RUNTIME_PROVIDER, PlatformRuntimeClient, discoverPlatform } from "../../platform/client.js";
+import "../../platform/index.js";
+import { getProfile, upsertAuthProfile } from "../../auth/profiles/profiles.js";
+import { Command } from "commander";
+//#region src/cli/commands/platform.ts
+async function readStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8").trim();
+}
+async function readRuntimeToken(value, fromStdin) {
+	if (value?.trim()) return value.trim();
+	if (fromStdin) return readStdin();
+	if (process.stdin.isTTY) {
+		const { password } = await import("@inquirer/prompts");
+		return (await password({
+			message: "Platform runtime token",
+			mask: "*"
+		})).trim();
+	}
+	throw new Error("Provide a runtime token, pass --stdin, or run interactively.");
+}
+function runtimeToken() {
+	const fromEnv = process.env.XOPC_PLATFORM_RUNTIME_TOKEN?.trim();
+	if (fromEnv) return fromEnv;
+	const credential = getProfile(PLATFORM_RUNTIME_PROFILE);
+	if (credential?.type === "token" && credential.provider === "xopc-platform-runtime") return credential.token;
+	throw new Error("Runtime token is not configured. Run `xopc platform runtime token set`.");
+}
+function connectedConfig(ctx) {
+	const config = loadConfig(ctx.configPath);
+	if (config.platform.mode !== "connected") throw new Error("XOPC is in standalone mode. Run `xopc platform connect <url>`.");
+	return {
+		config,
+		platform: config.platform
+	};
+}
+function createPlatformCommand(ctx) {
+	const command = new Command("platform").description("Connect to XOPC Cloud or an enterprise platform").addHelpText("after", formatExamples([
+		"xopc platform connect https://console.xopc.ai",
+		"xopc platform status --refresh",
+		"xopc platform runtime token set --stdin",
+		"xopc platform runtime heartbeat"
+	]));
+	command.command("connect").argument("<url>", "Platform base URL").option("--workspace <id>", "Default workspace ID").action(async (url, options) => {
+		const discovery = await discoverPlatform(url);
+		const config = loadConfig(ctx.configPath);
+		config.platform = {
+			mode: "connected",
+			url: new URL(url).toString().replace(/\/+$/, ""),
+			workspaceId: options.workspace,
+			discovery
+		};
+		await saveConfig(config, ctx.configPath);
+		console.log(`Connected to ${discovery.displayName} (${discovery.deploymentMode}, ${discovery.region})`);
+	});
+	command.command("disconnect").description("Return to standalone mode").action(async () => {
+		const config = loadConfig(ctx.configPath);
+		config.platform = { mode: "standalone" };
+		await saveConfig(config, ctx.configPath);
+		console.log("XOPC is now in standalone mode.");
+	});
+	command.command("status").option("--refresh", "Refresh discovery before printing status").option("--json", "Output JSON").action(async (options) => {
+		const config = loadConfig(ctx.configPath);
+		if (config.platform.mode === "standalone") {
+			console.log(options.json ? JSON.stringify(config.platform) : "Mode: standalone");
+			return;
+		}
+		if (options.refresh) {
+			config.platform.discovery = await discoverPlatform(config.platform.url);
+			await saveConfig(config, ctx.configPath);
+		}
+		if (options.json) console.log(JSON.stringify(config.platform, null, 2));
+		else console.log(`Mode: connected\nPlatform: ${config.platform.discovery.displayName}\nURL: ${config.platform.url}`);
+	});
+	const runtime = command.command("runtime").description("Manage this XOPC runtime connection");
+	runtime.command("token").description("Store the one-time runtime registration token").command("set").argument("[token]").option("--stdin", "Read token from standard input").action(async (value, options) => {
+		const runtimeTokenValue = await readRuntimeToken(value, options.stdin ?? false);
+		if (!/^xopc_rt_[A-Za-z0-9_-]{43}$/.test(runtimeTokenValue)) throw new Error("Invalid platform runtime token.");
+		upsertAuthProfile({
+			profileId: PLATFORM_RUNTIME_PROFILE,
+			credential: {
+				type: "token",
+				provider: PLATFORM_RUNTIME_PROVIDER,
+				token: runtimeTokenValue
+			}
+		});
+		console.log("Platform runtime token stored in the credential store.");
+	});
+	runtime.command("heartbeat").description("Verify the outbound runtime connection and fetch current policy snapshots").option("--json", "Output JSON").action(async (options) => {
+		const { platform } = connectedConfig(ctx);
+		const result = await new PlatformRuntimeClient(platform.discovery, runtimeToken()).heartbeat({ capabilities: { engine: "xopc" } });
+		console.log(options.json ? JSON.stringify(result, null, 2) : "Runtime heartbeat accepted.");
+	});
+	return command;
+}
+register({
+	id: "platform",
+	name: "platform",
+	description: "Connect to XOPC Cloud or an enterprise platform",
+	factory: createPlatformCommand,
+	metadata: {
+		category: "runtime",
+		examples: ["xopc platform status"]
+	}
+});
+//#endregion
+export {};

package/dist/src/config/loader.js

@@ -5,10 +5,15 @@ import { ConfigSchema, init_schema } from "./schema.js";
 import { init_paths, resolveConfigPath } from "./paths.js";
 import { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.js";
 import { assertChannelPluginConfigs, init_validate_channel_configs } from "./validate-channel-configs.js";
+import { init_resolution, setActivePlatformDiscovery } from "../platform/resolution.js";
 import { dirname } from "path";
 import { existsSync, mkdirSync, promises, readFileSync } from "fs";
 import { config } from "dotenv";
 //#region src/config/loader.ts
+function activateConfig(configValue) {
+	setActivePlatformDiscovery(configValue.platform.mode === "connected" ? configValue.platform.discovery : void 0);
+	return configValue;
+}
 /**
 * Rotate config backups before writing new config.
 * Creates a backup chain: xopc.json.bak, xopc.json.bak.1, xopc.json.bak.2, etc.
@@ -39,7 +44,7 @@ function loadConfig(configPath) {
 		const json = JSON.parse(content);
 		const cfg = ConfigSchema.parse(json);
 		assertChannelPluginConfigs(cfg);
-		return cfg;
+		return activateConfig(cfg);
 	} catch (error) {
 		log.error({
 			err: error,
@@ -47,11 +52,11 @@ function loadConfig(configPath) {
 		}, `Failed to load config`);
 		const cfg = ConfigSchema.parse(void 0);
 		assertChannelPluginConfigs(cfg);
-		return cfg;
+		return activateConfig(cfg);
 	}
 	const cfg = ConfigSchema.parse(void 0);
 	assertChannelPluginConfigs(cfg);
-	return cfg;
+	return activateConfig(cfg);
 }
 /**
 * Save configuration to file
@@ -80,6 +85,7 @@ var init_loader = __esmMin((() => {
 	init_paths();
 	init_logger();
 	init_validate_channel_configs();
+	init_resolution();
 	log = createLogger("ConfigLoader");
 	CONFIG_BACKUP_COUNT = 10;
 }));

package/dist/src/config/schema.d.ts

@@ -204,54 +204,54 @@ export declare const AgentsConfigSchema: z.ZodDefault<z.ZodObject<{
 }, z.core.$strict>>;
 export declare const BrowserConfigSchema: z.ZodDefault<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
-    backend: z.ZodDefault<z.ZodEnum<{
-        extension: "extension";
-        local: "local";
-        cdp: "cdp";
-        cloud: "cloud";
-        cloakbrowser: "cloakbrowser";
-    }>>;
-    headless: z.ZodOptional<z.ZodBoolean>;
-    allowPrivateUrls: z.ZodOptional<z.ZodBoolean>;
-    commandTimeout: z.ZodOptional<z.ZodNumber>;
-    cloudProvider: z.ZodOptional<z.ZodEnum<{
-        local: "local";
-        browserbase: "browserbase";
-        "browser-use": "browser-use";
-    }>>;
-    cloud: z.ZodOptional<z.ZodObject<{
+    driver: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"extension">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"playwright">;
+        headless: z.ZodDefault<z.ZodBoolean>;
+        executablePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"cdp">;
+        endpoint: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"remote">;
+        provider: z.ZodEnum<{
+            browserbase: "browserbase";
+            "browser-use": "browser-use";
+        }>;
         apiKey: z.ZodOptional<z.ZodString>;
         projectId: z.ZodOptional<z.ZodString>;
         region: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "kind">>;
+    observation: z.ZodDefault<z.ZodObject<{
+        maxNodes: z.ZodDefault<z.ZodNumber>;
+        maxCharacters: z.ZodDefault<z.ZodNumber>;
+        visualFallback: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
-    cdpUrl: z.ZodOptional<z.ZodString>;
-    extension: z.ZodOptional<z.ZodObject<{
-        port: z.ZodOptional<z.ZodNumber>;
-        host: z.ZodOptional<z.ZodString>;
-        connectionTimeout: z.ZodOptional<z.ZodNumber>;
+    limits: z.ZodDefault<z.ZodObject<{
+        actionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        sessionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxSequenceLength: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
-    cloakbrowser: z.ZodOptional<z.ZodObject<{
-        keepOpen: z.ZodOptional<z.ZodBoolean>;
-        temporaryProfile: z.ZodOptional<z.ZodBoolean>;
-        cacheDir: z.ZodOptional<z.ZodString>;
-        binaryPath: z.ZodOptional<z.ZodString>;
-        timezone: z.ZodOptional<z.ZodString>;
-        locale: z.ZodOptional<z.ZodString>;
-        webrtcIp: z.ZodOptional<z.ZodString>;
-        fingerprintPlatform: z.ZodOptional<z.ZodString>;
-        extraArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    security: z.ZodDefault<z.ZodObject<{
+        privateNetworks: z.ZodDefault<z.ZodLiteral<"deny">>;
+        allowedPrivateHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        crossDomainNavigation: z.ZodDefault<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        uploads: z.ZodDefault<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        consequentialActions: z.ZodDefault<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
     }, z.core.$strict>>;
-    humanize: z.ZodOptional<z.ZodBoolean>;
-    humanPreset: z.ZodOptional<z.ZodEnum<{
-        default: "default";
-        careful: "careful";
-    }>>;
-    dialogPolicy: z.ZodOptional<z.ZodEnum<{
-        must_respond: "must_respond";
-        auto_dismiss: "auto_dismiss";
-        auto_accept: "auto_accept";
-    }>>;
-    dialogTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>>;
 export { TelegramTopicConfigSchema, TelegramGroupConfigSchema, TelegramAccountConfigSchema, TelegramConfigSchema, } from '../../extensions/telegram/src/config-schema.js';
 export type { TelegramConfig } from '../../extensions/telegram/src/config-schema.js';
@@ -1915,54 +1915,54 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
     }, z.core.$strip>>;
     browser: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-        backend: z.ZodDefault<z.ZodEnum<{
-            extension: "extension";
-            local: "local";
-            cdp: "cdp";
-            cloud: "cloud";
-            cloakbrowser: "cloakbrowser";
-        }>>;
-        headless: z.ZodOptional<z.ZodBoolean>;
-        allowPrivateUrls: z.ZodOptional<z.ZodBoolean>;
-        commandTimeout: z.ZodOptional<z.ZodNumber>;
-        cloudProvider: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            browserbase: "browserbase";
-            "browser-use": "browser-use";
-        }>>;
-        cloud: z.ZodOptional<z.ZodObject<{
+        driver: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"extension">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"playwright">;
+            headless: z.ZodDefault<z.ZodBoolean>;
+            executablePath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"cdp">;
+            endpoint: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"remote">;
+            provider: z.ZodEnum<{
+                browserbase: "browserbase";
+                "browser-use": "browser-use";
+            }>;
             apiKey: z.ZodOptional<z.ZodString>;
             projectId: z.ZodOptional<z.ZodString>;
             region: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "kind">>;
+        observation: z.ZodDefault<z.ZodObject<{
+            maxNodes: z.ZodDefault<z.ZodNumber>;
+            maxCharacters: z.ZodDefault<z.ZodNumber>;
+            visualFallback: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strict>>;
-        cdpUrl: z.ZodOptional<z.ZodString>;
-        extension: z.ZodOptional<z.ZodObject<{
-            port: z.ZodOptional<z.ZodNumber>;
-            host: z.ZodOptional<z.ZodString>;
-            connectionTimeout: z.ZodOptional<z.ZodNumber>;
+        limits: z.ZodDefault<z.ZodObject<{
+            actionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            sessionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            maxSequenceLength: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
-        cloakbrowser: z.ZodOptional<z.ZodObject<{
-            keepOpen: z.ZodOptional<z.ZodBoolean>;
-            temporaryProfile: z.ZodOptional<z.ZodBoolean>;
-            cacheDir: z.ZodOptional<z.ZodString>;
-            binaryPath: z.ZodOptional<z.ZodString>;
-            timezone: z.ZodOptional<z.ZodString>;
-            locale: z.ZodOptional<z.ZodString>;
-            webrtcIp: z.ZodOptional<z.ZodString>;
-            fingerprintPlatform: z.ZodOptional<z.ZodString>;
-            extraArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        security: z.ZodDefault<z.ZodObject<{
+            privateNetworks: z.ZodDefault<z.ZodLiteral<"deny">>;
+            allowedPrivateHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            crossDomainNavigation: z.ZodDefault<z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+                ask: "ask";
+            }>>;
+            uploads: z.ZodDefault<z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+                ask: "ask";
+            }>>;
+            consequentialActions: z.ZodDefault<z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+                ask: "ask";
+            }>>;
         }, z.core.$strict>>;
-        humanize: z.ZodOptional<z.ZodBoolean>;
-        humanPreset: z.ZodOptional<z.ZodEnum<{
-            default: "default";
-            careful: "careful";
-        }>>;
-        dialogPolicy: z.ZodOptional<z.ZodEnum<{
-            must_respond: "must_respond";
-            auto_dismiss: "auto_dismiss";
-            auto_accept: "auto_accept";
-        }>>;
-        dialogTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     tunnel: z.ZodOptional<z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -2149,6 +2149,53 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
     experimental: z.ZodDefault<z.ZodObject<{
         workDiscoveryOnboarding: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
+    platform: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"standalone">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"connected">;
+        url: z.ZodString;
+        workspaceId: z.ZodOptional<z.ZodString>;
+        discovery: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1">;
+            platformId: z.ZodString;
+            displayName: z.ZodString;
+            deploymentMode: z.ZodEnum<{
+                development: "development";
+                private: "private";
+                cloud: "cloud";
+            }>;
+            region: z.ZodString;
+            endpoints: z.ZodObject<{
+                authorizationServer: z.ZodString;
+                controlApi: z.ZodString;
+                modelApi: z.ZodOptional<z.ZodString>;
+                storeApi: z.ZodOptional<z.ZodString>;
+                tunnelApi: z.ZodOptional<z.ZodString>;
+                shareApi: z.ZodOptional<z.ZodString>;
+                agentApi: z.ZodOptional<z.ZodString>;
+                a2aApi: z.ZodOptional<z.ZodString>;
+                realtime: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            capabilities: z.ZodRecord<z.ZodEnum<{
+                models: "models";
+                connectors: "connectors";
+                tunnels: "tunnels";
+                shares: "shares";
+                managedRuntime: "managedRuntime";
+                runtimeFleet: "runtimeFleet";
+                traceUpload: "traceUpload";
+                a2a: "a2a";
+            }>, z.ZodBoolean>;
+            protocols: z.ZodObject<{
+                xopc: z.ZodObject<{
+                    min: z.ZodString;
+                    max: z.ZodString;
+                }, z.core.$strict>;
+                mcp: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                a2a: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "mode">>;
     extensions: z.ZodDefault<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
     providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         baseUrl: z.ZodOptional<z.ZodString>;