@xopcai/xopc 0.0.250 → 0.0.252

package/dist/src/platform/contracts.js

@@ -0,0 +1,150 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region src/platform/contracts.ts
+var identifier, sha256, exactVersion, PlatformCapabilitySchema, PlatformDiscoverySchema, PlatformConfigSchema, agentDependency, AgentManifestSchema, PlatformEventSchema;
+var init_contracts = __esmMin((() => {
+	identifier = z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+	sha256 = z.string().regex(/^[a-f0-9]{64}$/);
+	exactVersion = z.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/);
+	PlatformCapabilitySchema = z.enum([
+		"models",
+		"connectors",
+		"tunnels",
+		"shares",
+		"managedRuntime",
+		"runtimeFleet",
+		"traceUpload",
+		"a2a"
+	]);
+	PlatformDiscoverySchema = z.object({
+		schemaVersion: z.literal("1"),
+		platformId: identifier,
+		displayName: z.string().min(1).max(120),
+		deploymentMode: z.enum([
+			"cloud",
+			"private",
+			"development"
+		]),
+		region: identifier,
+		endpoints: z.object({
+			authorizationServer: z.string().url(),
+			controlApi: z.string().url(),
+			modelApi: z.string().url().optional(),
+			storeApi: z.string().url().optional(),
+			tunnelApi: z.string().url().optional(),
+			shareApi: z.string().url().optional(),
+			agentApi: z.string().url().optional(),
+			a2aApi: z.string().url().optional(),
+			realtime: z.string().url().optional()
+		}).strict(),
+		capabilities: z.record(PlatformCapabilitySchema, z.boolean()),
+		protocols: z.object({
+			xopc: z.object({
+				min: z.string().min(1),
+				max: z.string().min(1)
+			}).strict(),
+			mcp: z.array(z.string().min(1)).default([]),
+			a2a: z.array(z.string().min(1)).default([])
+		}).strict()
+	}).strict();
+	PlatformConfigSchema = z.discriminatedUnion("mode", [z.object({ mode: z.literal("standalone") }).strict(), z.object({
+		mode: z.literal("connected"),
+		url: z.string().url(),
+		workspaceId: identifier.optional(),
+		discovery: PlatformDiscoverySchema
+	}).strict()]).default({ mode: "standalone" });
+	agentDependency = z.object({
+		id: identifier,
+		version: exactVersion,
+		sha256: sha256.optional()
+	}).strict();
+	AgentManifestSchema = z.object({
+		schemaVersion: z.literal("1"),
+		agentId: identifier,
+		version: exactVersion,
+		runtime: z.object({
+			engine: z.literal("xopc"),
+			requires: z.string().min(1),
+			execution: z.array(z.enum([
+				"local",
+				"managed",
+				"enterprise"
+			])).min(1)
+		}).strict(),
+		entry: z.object({
+			instructions: z.string().min(1),
+			workflow: z.string().min(1).optional()
+		}).strict(),
+		models: z.object({
+			intents: z.array(z.enum([
+				"fast",
+				"reasoning",
+				"coding",
+				"review",
+				"vision",
+				"understanding"
+			])),
+			allow: z.array(z.string().min(1))
+		}).strict(),
+		dependencies: z.object({
+			skills: z.array(agentDependency),
+			connectors: z.array(agentDependency),
+			extensions: z.array(agentDependency).default([])
+		}).strict(),
+		permissions: z.object({
+			tools: z.array(z.string().min(1)),
+			networkDomains: z.array(z.string().min(1)),
+			filesystem: z.array(z.string().min(1)),
+			effects: z.array(z.enum([
+				"read",
+				"write",
+				"send",
+				"execute",
+				"delete",
+				"purchase",
+				"publish",
+				"admin"
+			]))
+		}).strict(),
+		data: z.object({
+			classification: z.enum([
+				"public",
+				"internal",
+				"confidential",
+				"restricted"
+			]),
+			memory: z.enum([
+				"none",
+				"local",
+				"workspace"
+			]),
+			retentionPolicy: identifier
+		}).strict(),
+		quality: z.object({
+			evaluationSuite: identifier.optional(),
+			releaseGate: identifier.optional()
+		}).strict()
+	}).strict();
+	PlatformEventSchema = z.object({
+		schemaVersion: z.literal("1"),
+		eventId: identifier,
+		type: z.string().min(1).max(160).regex(/^xopc\.[a-z0-9_.-]+$/),
+		time: z.string().datetime(),
+		organizationId: identifier,
+		workspaceId: identifier,
+		runId: identifier.optional(),
+		traceId: identifier.optional(),
+		sequence: z.number().int().nonnegative().optional(),
+		producer: identifier,
+		payload: z.record(z.string(), z.unknown())
+	}).strict().superRefine((event, context) => {
+		if (event.runId && event.sequence === void 0) context.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Run events require a sequence",
+			path: ["sequence"]
+		});
+	});
+}));
+//#endregion
+init_contracts();
+export { AgentManifestSchema, PlatformCapabilitySchema, PlatformConfigSchema, PlatformDiscoverySchema, PlatformEventSchema, init_contracts };

package/dist/src/platform/index.d.ts

@@ -0,0 +1,4 @@
+export * from './contracts.js';
+export * from './client.js';
+export * from './worker.js';
+export * from './resolution.js';

package/dist/src/platform/index.js

@@ -0,0 +1,9 @@
+import { AgentManifestSchema, PlatformCapabilitySchema, PlatformConfigSchema, PlatformDiscoverySchema, PlatformEventSchema, init_contracts } from "./contracts.js";
+import { init_resolution, resolveConnectedPlatformDiscovery, resolveConnectedPlatformEndpoint, setActivePlatformDiscovery } from "./resolution.js";
+import { PLATFORM_RUNTIME_PROFILE, PLATFORM_RUNTIME_PROVIDER, PlatformRuntimeClient, RuntimeCommandSchema, discoverPlatform } from "./client.js";
+import { processRuntimeCommand } from "./worker.js";
+//#region src/platform/index.ts
+init_contracts();
+init_resolution();
+//#endregion
+export { AgentManifestSchema, PLATFORM_RUNTIME_PROFILE, PLATFORM_RUNTIME_PROVIDER, PlatformCapabilitySchema, PlatformConfigSchema, PlatformDiscoverySchema, PlatformEventSchema, PlatformRuntimeClient, RuntimeCommandSchema, discoverPlatform, processRuntimeCommand, resolveConnectedPlatformDiscovery, resolveConnectedPlatformEndpoint, setActivePlatformDiscovery };

package/dist/src/platform/resolution.d.ts

@@ -0,0 +1,4 @@
+import type { PlatformDiscovery } from './contracts.js';
+export declare function setActivePlatformDiscovery(discovery: PlatformDiscovery | undefined): void;
+export declare function resolveConnectedPlatformDiscovery(): PlatformDiscovery | undefined;
+export declare function resolveConnectedPlatformEndpoint(endpoint: keyof PlatformDiscovery['endpoints']): string | undefined;

package/dist/src/platform/resolution.js

@@ -0,0 +1,16 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+//#region src/platform/resolution.ts
+function setActivePlatformDiscovery(discovery) {
+	activeDiscovery = discovery;
+}
+function resolveConnectedPlatformDiscovery() {
+	return activeDiscovery;
+}
+function resolveConnectedPlatformEndpoint(endpoint) {
+	return resolveConnectedPlatformDiscovery()?.endpoints[endpoint];
+}
+var activeDiscovery;
+var init_resolution = __esmMin((() => {}));
+//#endregion
+init_resolution();
+export { init_resolution, resolveConnectedPlatformDiscovery, resolveConnectedPlatformEndpoint, setActivePlatformDiscovery };

package/dist/src/platform/worker.d.ts

@@ -0,0 +1,6 @@
+import { PlatformRuntimeClient, type RuntimeCommand } from './client.js';
+export interface RuntimeExecutionResult {
+    output?: unknown;
+}
+export type RuntimeCommandHandler = (command: RuntimeCommand, signal: AbortSignal) => Promise<RuntimeExecutionResult>;
+export declare function processRuntimeCommand(client: PlatformRuntimeClient, handler: RuntimeCommandHandler): Promise<'idle' | 'completed' | 'failed' | 'cancelled'>;

package/dist/src/platform/worker.js

@@ -0,0 +1,75 @@
+import { randomUUID } from "node:crypto";
+//#region src/platform/worker.ts
+var RuntimeCancellation = class extends Error {
+	constructor() {
+		super("Run cancellation requested by platform");
+		this.name = "RuntimeCancellation";
+	}
+};
+function commandIdentity(command) {
+	const { organizationId, workspaceId, traceId, runtimeId } = command.payload;
+	if ([
+		organizationId,
+		workspaceId,
+		traceId,
+		runtimeId
+	].some((value) => typeof value !== "string" || value.length === 0)) throw new Error("Runtime command is missing tenant or trace identity");
+	return {
+		organizationId,
+		workspaceId,
+		traceId,
+		runtimeId
+	};
+}
+function event(command, type, sequence, payload) {
+	const identity = commandIdentity(command);
+	return {
+		schemaVersion: "1",
+		eventId: `event_${randomUUID()}`,
+		type,
+		time: (/* @__PURE__ */ new Date()).toISOString(),
+		organizationId: identity.organizationId,
+		workspaceId: identity.workspaceId,
+		runId: command.runId,
+		traceId: identity.traceId,
+		sequence,
+		producer: identity.runtimeId,
+		payload
+	};
+}
+async function processRuntimeCommand(client, handler) {
+	const command = await client.lease();
+	if (!command) return "idle";
+	await client.report(event(command, "xopc.run.started", 1, {}), command.leaseToken);
+	const controller = new AbortController();
+	let renewing = false;
+	let renewalInFlight = Promise.resolve();
+	const renewalIntervalMs = Math.max(1e3, Math.min(3e4, Math.floor((command.leaseExpiresAt - Date.now()) / 3)));
+	const renewal = setInterval(() => {
+		if (renewing || controller.signal.aborted) return;
+		renewing = true;
+		renewalInFlight = client.renew(command.id, command.leaseToken).then((result) => {
+			if (result.cancelRequested) controller.abort(new RuntimeCancellation());
+		}).catch((error) => controller.abort(error)).finally(() => {
+			renewing = false;
+		});
+	}, renewalIntervalMs);
+	renewal.unref?.();
+	try {
+		const result = await handler(command, controller.signal);
+		await renewalInFlight;
+		if (controller.signal.aborted) throw controller.signal.reason;
+		await client.report(event(command, "xopc.run.succeeded", 2, { output: result.output }), command.leaseToken);
+		return "completed";
+	} catch (error) {
+		const effectiveError = controller.signal.aborted ? controller.signal.reason : error;
+		const cancelled = effectiveError instanceof RuntimeCancellation;
+		await client.report(event(command, cancelled ? "xopc.run.cancelled" : "xopc.run.failed", 2, cancelled ? {} : { error: effectiveError instanceof Error ? effectiveError.message : "Runtime command failed" }), command.leaseToken);
+		return cancelled ? "cancelled" : "failed";
+	} finally {
+		clearInterval(renewal);
+		await renewalInFlight;
+	}
+}
+//#endregion
+export { processRuntimeCommand };

package/dist/src/providers/xopc-cloud-config.js

@@ -1,10 +1,12 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_resolution, resolveConnectedPlatformEndpoint } from "../platform/resolution.js";
 //#region src/providers/xopc-cloud-config.ts
 function resolveXopcModelRouterUrl(override) {
-	return (override ?? process.env.XOPC_MODEL_ROUTER_URL ?? "https://router.xopc.ai/v1").replace(/\/+$/, "");
+	return (override ?? process.env.XOPC_MODEL_ROUTER_URL ?? resolveConnectedPlatformEndpoint("modelApi") ?? "https://router.xopc.ai/v1").replace(/\/+$/, "");
 }
 var XOPC_CLOUD_PROVIDER_ID, DEFAULT_XOPC_MODEL_ROUTER_URL;
 var init_xopc_cloud_config = __esmMin((() => {
+	init_resolution();
 	XOPC_CLOUD_PROVIDER_ID = "xopc-cloud";
 	DEFAULT_XOPC_MODEL_ROUTER_URL = "https://router.xopc.ai/v1";
 }));

package/dist/src/session/session-context-for-llm.js

@@ -127,6 +127,46 @@ function toolCallIds(message) {
 	}
 	return ids;
 }
+function browserToolCallIds(messages) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		const content = message.content;
+		if (!Array.isArray(content)) continue;
+		for (const block of content) {
+			const record = asRecord(block);
+			if (!record || stringValue(record.name) !== "browser_use") continue;
+			const id = toolCallIdFromBlock(record);
+			if (id) ids.add(id);
+		}
+	}
+	return ids;
+}
+/** Keep semantic browser text throughout history, but only the newest browser screenshot. */
+function projectBrowserVisualContext(messages) {
+	const browserIds = browserToolCallIds(messages);
+	let latestVisualIndex = -1;
+	for (let index = 0; index < messages.length; index += 1) {
+		const message = messages[index];
+		if (!browserIds.has(toolResultId(message) ?? "")) continue;
+		const content = message.content;
+		if (Array.isArray(content) && content.some((block) => asRecord(block)?.type === "image")) latestVisualIndex = index;
+	}
+	if (latestVisualIndex < 0) return messages;
+	return messages.map((message, index) => {
+		if (index === latestVisualIndex || !browserIds.has(toolResultId(message) ?? "")) return message;
+		const record = message;
+		if (!Array.isArray(record.content)) return message;
+		const content = record.content.map((block) => asRecord(block)?.type === "image" ? {
+			type: "text",
+			text: "[Earlier browser screenshot omitted; semantic observation retained.]"
+		} : block);
+		return {
+			...record,
+			content
+		};
+	});
+}
 function filterAssistantToolCalls(message, pairedIds) {
 	const record = message;
 	const content = record.content;
@@ -257,7 +297,7 @@ function buildSessionContextForLlm(rows) {
 		}
 		if (isLikelyAgentMessage(r)) out.push(r);
 	}
-	return sanitizeToolPairs(out);
+	return projectBrowserVisualContext(sanitizeToolPairs(out));
 }
 /** Visible chat messages only - no LLM-only audit/context expansion. */
 function buildSessionDisplayMessages(rows) {

package/dist/src/share/hosted-session-share.js

@@ -1,5 +1,6 @@
 import { requireXopcDatabase } from "../storage/sqlite/connection.js";
 import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { init_resolution, resolveConnectedPlatformEndpoint } from "../platform/resolution.js";
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { DurableState } from "../storage/sqlite/durable-state.js";
 import { resolveMediaReference } from "../media/media-reference.js";
@@ -11,6 +12,7 @@ import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 //#region src/share/hosted-session-share.ts
 init_credentials();
+init_resolution();
 const DEFAULT_SHARE_URL = "https://share.xopc.ai";
 const MAX_MESSAGES = 1e4;
 const MAX_ATTACHMENTS = 20;
@@ -105,7 +107,7 @@ var HostedSessionShareBuilder = class {
 };
 var HostedSessionSharePublisher = class {
 	baseUrl;
-	constructor(baseUrl = process.env.XOPC_SHARE_URL ?? DEFAULT_SHARE_URL, credentials = new CredentialResolver(), fetchImpl = fetch) {
+	constructor(baseUrl = process.env.XOPC_SHARE_URL ?? resolveConnectedPlatformEndpoint("shareApi") ?? DEFAULT_SHARE_URL, credentials = new CredentialResolver(), fetchImpl = fetch) {
 		this.credentials = credentials;
 		this.fetchImpl = fetchImpl;
 		this.baseUrl = baseUrl.replace(/\/+$/, "");

package/dist/src/share/share-thumbnail.js

@@ -14,7 +14,7 @@ import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
 * Responsibilities:
 *  - Render a 1200x630 jpeg preview for shareable artefacts.
 *  - HTML / sites: launch its own Playwright browser (does NOT share the user
-*    BrowserManager — the user-facing browser is for the agent and we mustn't
+*    Browser Control runtime — the user-facing browser is for the agent and we mustn't
 *    pollute its context).
 *  - Images: pass through with size cap; downscale only if oversized.
 *  - Anything else: emit an SVG placeholder card with the file name + icon.

package/dist/src/storage/sqlite/migrations/153_browser_control_v2.sql

@@ -0,0 +1,45 @@
+DROP TABLE IF EXISTS browser_recipe_run_events;
+DROP TABLE IF EXISTS browser_recipe_runs;
+DROP TABLE IF EXISTS browser_recipes;
+
+CREATE TABLE IF NOT EXISTS browser_automations (
+  automation_id TEXT PRIMARY KEY,
+  revision INTEGER NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('enabled', 'disabled')),
+  definition_json TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  updated_at_ms INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS browser_automation_runs (
+  run_id TEXT PRIMARY KEY,
+  automation_id TEXT NOT NULL,
+  automation_revision INTEGER NOT NULL,
+  definition_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'succeeded', 'failed', 'cancelled')),
+  inputs_json TEXT NOT NULL,
+  result_json TEXT,
+  error TEXT,
+  created_at_ms INTEGER NOT NULL,
+  started_at_ms INTEGER,
+  ended_at_ms INTEGER,
+  duration_ms INTEGER,
+  FOREIGN KEY (automation_id) REFERENCES browser_automations(automation_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_browser_automation_runs_automation_created
+  ON browser_automation_runs(automation_id, created_at_ms DESC);
+
+CREATE TABLE IF NOT EXISTS browser_action_audit (
+  event_id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  seq INTEGER NOT NULL,
+  type TEXT NOT NULL,
+  data_json TEXT,
+  created_at_ms INTEGER NOT NULL,
+  UNIQUE(run_id, seq),
+  FOREIGN KEY (run_id) REFERENCES browser_automation_runs(run_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_browser_action_audit_run_seq
+  ON browser_action_audit(run_id, seq ASC);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 152;
+export declare const XOPC_DB_SCHEMA_VERSION = 153;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -12,7 +12,7 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 152;
+const XOPC_DB_SCHEMA_VERSION = 153;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function backupBeforeTaskCutover(db, databasePath) {
 	db.exec("PRAGMA wal_checkpoint(FULL)");
@@ -57,7 +57,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 152;
+	const targetVersion = options.targetVersion ?? 153;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -94,7 +94,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 152;
+	const appVersion = options.targetVersion ?? 153;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,

package/dist/src/storage/sqlite/migrations/runner.ts

@@ -19,7 +19,7 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 152;
+export const XOPC_DB_SCHEMA_VERSION = 153;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/schema.js

@@ -32,7 +32,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 11;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 152,
+		targetVersion: 153,
 		databasePath: options.databasePath
 	});
 }

package/dist/src/storage/sqlite/schema.sql

@@ -756,39 +756,35 @@ CREATE TABLE IF NOT EXISTS goal_session_links (
 CREATE INDEX IF NOT EXISTS idx_goal_session_links_session
   ON goal_session_links(session_key, linked_at DESC);
 
-CREATE TABLE IF NOT EXISTS browser_recipes (
-  recipe_id TEXT PRIMARY KEY,
+CREATE TABLE IF NOT EXISTS browser_automations (
+  automation_id TEXT PRIMARY KEY,
   revision INTEGER NOT NULL,
-  name TEXT NOT NULL,
-  description TEXT,
-  status TEXT NOT NULL CHECK (status IN ('published', 'disabled')),
-  yaml_source TEXT NOT NULL,
-  risk_level TEXT NOT NULL CHECK (risk_level IN ('read_only', 'account_write', 'sensitive')),
-  domains_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('enabled', 'disabled')),
+  definition_json TEXT NOT NULL,
   created_at_ms INTEGER NOT NULL,
   updated_at_ms INTEGER NOT NULL
 );
 
-CREATE TABLE IF NOT EXISTS browser_recipe_runs (
+CREATE TABLE IF NOT EXISTS browser_automation_runs (
   run_id TEXT PRIMARY KEY,
-  recipe_id TEXT NOT NULL,
-  recipe_revision INTEGER NOT NULL,
-  recipe_yaml TEXT NOT NULL,
+  automation_id TEXT NOT NULL,
+  automation_revision INTEGER NOT NULL,
+  definition_json TEXT NOT NULL,
   status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'succeeded', 'failed', 'cancelled')),
-  args_json TEXT NOT NULL,
+  inputs_json TEXT NOT NULL,
   result_json TEXT,
   error TEXT,
   created_at_ms INTEGER NOT NULL,
   started_at_ms INTEGER,
   ended_at_ms INTEGER,
   duration_ms INTEGER,
-  FOREIGN KEY (recipe_id) REFERENCES browser_recipes(recipe_id) ON DELETE CASCADE
+  FOREIGN KEY (automation_id) REFERENCES browser_automations(automation_id) ON DELETE CASCADE
 );
 
-CREATE INDEX IF NOT EXISTS idx_browser_recipe_runs_recipe_created
-  ON browser_recipe_runs(recipe_id, created_at_ms DESC);
+CREATE INDEX IF NOT EXISTS idx_browser_automation_runs_automation_created
+  ON browser_automation_runs(automation_id, created_at_ms DESC);
 
-CREATE TABLE IF NOT EXISTS browser_recipe_run_events (
+CREATE TABLE IF NOT EXISTS browser_action_audit (
   event_id TEXT PRIMARY KEY,
   run_id TEXT NOT NULL,
   seq INTEGER NOT NULL,
@@ -796,8 +792,8 @@ CREATE TABLE IF NOT EXISTS browser_recipe_run_events (
   data_json TEXT,
   created_at_ms INTEGER NOT NULL,
   UNIQUE(run_id, seq),
-  FOREIGN KEY (run_id) REFERENCES browser_recipe_runs(run_id) ON DELETE CASCADE
+  FOREIGN KEY (run_id) REFERENCES browser_automation_runs(run_id) ON DELETE CASCADE
 );
 
-CREATE INDEX IF NOT EXISTS idx_browser_recipe_run_events_run_seq
-  ON browser_recipe_run_events(run_id, seq ASC);
+CREATE INDEX IF NOT EXISTS idx_browser_action_audit_run_seq
+  ON browser_action_audit(run_id, seq ASC);

package/dist/src/tasks/home-query-service.js

@@ -34,7 +34,7 @@ function triggerLabel(automation) {
 }
 function actionLabel(automation) {
 	if (automation.action.kind === "workflow") return `workflow:${automation.action.workflowId}`;
-	if (automation.action.kind === "browser_recipe") return `browser-workflow:${automation.action.recipeId}`;
+	if (automation.action.kind === "browser_automation") return `browser-automation:${automation.action.automationId}`;
 	if (automation.action.kind === "task_command") return `task:${automation.action.command.type}`;
 	return automation.action.agentId ? `agent:${automation.action.agentId}` : "agent";
 }

package/dist/src/tunnel/env.js

@@ -1,4 +1,6 @@
+import { init_resolution, resolveConnectedPlatformEndpoint } from "../platform/resolution.js";
 //#region src/tunnel/env.ts
+init_resolution();
 const DEV_REGISTRATION_SECRET = "dev-registration-secret";
 const TUNNEL_REGISTRATION_SECRET_REQUIRED_CODE = "TUNNEL_REGISTRATION_SECRET_REQUIRED";
 var TunnelRegistrationSecretError = class extends Error {
@@ -75,7 +77,7 @@ function resolveTunnelRegistrationSecret(brokerUrl, configSecret) {
 	throw new TunnelRegistrationSecretError(brokerUrl);
 }
 function resolveTunnelBrokerUrl(configBrokerUrl, env = process.env) {
-	return env.XOPC_TUNNEL_BROKER_URL ?? configBrokerUrl ?? "https://frp.xopc.ai/api";
+	return env.XOPC_TUNNEL_BROKER_URL ?? resolveConnectedPlatformEndpoint("tunnelApi") ?? configBrokerUrl ?? "https://frp.xopc.ai/api";
 }
 //#endregion
 export { TUNNEL_REGISTRATION_SECRET_REQUIRED_CODE, TunnelRegistrationSecretError, getTunnelRegistrationSecretMeta, isLocalDevelopmentTunnelBroker, isMaskedTunnelSecretPatchValue, maskTunnelSecretForWeb, readTunnelRegistrationSecretFromConfigOnly, resolveOptionalTunnelRegistrationSecret, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret, tunnelRegistrationSecretRequiredMessage };

package/dist/src/voice/realtime/agentEngine.js

@@ -305,7 +305,6 @@ function createAgentVoiceEngine(options) {
 				}
 				turn.start(event.utteranceId);
 			}
-			if (claim.request.purpose === "conversation" && claim.config.voice?.realtime?.bargeIn && !activeResponse?.awaitingClarification) cancelActiveResponse("barge_in");
 			send("input.speech_started", { utteranceId: event.utteranceId });
 		}
 		if (event.type === "speech_stopped") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xopcai/xopc",
-  "version": "0.0.250",
+  "version": "0.0.252",
   "description": "Local-first personal AI assistant with reviewable user understanding, durable tasks, workflows, automations, and local or cloud models.",
   "type": "module",
   "main": "dist/src/index.js",
@@ -62,11 +62,10 @@
   },
   "homepage": "https://xopc.ai",
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=22.22.3"
   },
   "dependencies": {
-    "@composio/core": "0.14.1",
-    "@composio/experimental": "0.2.0",
+    "@composio/core": "0.18.1",
     "@earendil-works/pi-agent-core": "0.85.1",
     "@earendil-works/pi-ai": "0.85.1",
     "@earendil-works/pi-coding-agent": "0.85.1",
@@ -149,8 +148,8 @@
     "esbuild": "^0.28.1",
     "eslint": "^10.4.0",
     "jsdom": "^29.1.1",
-    "onnxruntime-common": "1.21.0",
     "node-pty": "1.1.0",
+    "onnxruntime-common": "1.21.0",
     "playwright-core": "^1.60.0",
     "sherpa-onnx-node": "1.13.4",
     "svgo": "4.0.2",
@@ -163,10 +162,11 @@
     "vitepress": "^1.6.4",
     "vitest": "4.1.5",
     "vue": "^3.5.35",
+    "@xopcai/browser-control-contract": "0.1.0",
     "@xopcai/endpoint-tools-protocol": "0.0.0",
-    "@xopcai/realtime-client": "0.0.0",
     "@xopcai/realtime-protocol": "0.0.0",
-    "@xopcai/gateway-contract": "0.0.0"
+    "@xopcai/gateway-contract": "0.0.0",
+    "@xopcai/realtime-client": "0.0.0"
   },
   "scripts": {
     "assets:brand": "node scripts/generate-brand-assets.mjs",