@xopcai/xopc 0.0.312 → 0.0.314

package/dist/src/capabilities/runtime/product.js

@@ -0,0 +1,69 @@
+import { CapabilityError } from "./errors.js";
+import { CapabilityDispatcher } from "./dispatcher.js";
+import { registerLocalAppReadCapabilities } from "../../local-apps/capabilities/read.js";
+import { registerNoteReadCapabilities } from "../../notes/capabilities/read.js";
+import { registerNoteWriteCapabilities } from "../../notes/capabilities/write.js";
+import { registerTaskReadCapabilities } from "../../tasks/capabilities/read.js";
+import { registerLocalAppWriteCapabilities } from "../../local-apps/capabilities/write.js";
+import { registerProjectReadCapabilities } from "../../projects/capabilities/read.js";
+import { registerProjectWriteCapabilities } from "../../projects/capabilities/write.js";
+import { registerTaskRelationCapabilities } from "../../tasks/capabilities/relations.js";
+import { registerTaskManagementCapabilities } from "../../tasks/capabilities/management.js";
+import { registerTaskRunWriteCapabilities } from "../../tasks/capabilities/runs.js";
+import { registerAutomationReadCapabilities } from "../../automations/capabilities/read.js";
+import { registerAutomationWriteCapabilities } from "../../automations/capabilities/write.js";
+import { registerAutomationDraftCapabilities } from "../../automations/capabilities/drafts.js";
+import { registerTaskWriteCapabilities } from "../../tasks/capabilities/write.js";
+import { registerSceneReadCapabilities } from "../../scenes/capabilities/read.js";
+import { registerSceneWriteCapabilities } from "../../scenes/capabilities/write.js";
+import { registerSettingsCapability } from "./settings.js";
+import { registerAppContextCapability } from "./app-context.js";
+//#region src/capabilities/runtime/product.ts
+function createProductDispatcher(getNotes, taskWrites) {
+	const dispatcher = new CapabilityDispatcher();
+	registerSettingsCapability(dispatcher);
+	registerAppContextCapability(dispatcher);
+	if (taskWrites?.getSceneAccess) {
+		registerSceneReadCapabilities(dispatcher, taskWrites.getSceneAccess);
+		registerSceneWriteCapabilities(dispatcher, taskWrites.getSceneAccess);
+	}
+	const localApps = taskWrites?.getLocalApps?.();
+	if (localApps) {
+		registerLocalAppReadCapabilities(dispatcher, localApps);
+		registerLocalAppWriteCapabilities(dispatcher, localApps);
+	}
+	registerNoteReadCapabilities(dispatcher, () => {
+		const notes = getNotes?.();
+		if (!notes) throw new CapabilityError("UNAVAILABLE", "Notes service is unavailable");
+		return notes;
+	});
+	registerTaskReadCapabilities(dispatcher);
+	const projects = taskWrites?.getProjects?.();
+	if (projects) {
+		registerProjectReadCapabilities(dispatcher, projects);
+		registerProjectWriteCapabilities(dispatcher, projects, taskWrites);
+	}
+	const automations = taskWrites?.getAutomations?.();
+	if (automations) {
+		registerAutomationReadCapabilities(dispatcher, automations, projects);
+		registerAutomationWriteCapabilities(dispatcher, automations, projects);
+		registerAutomationDraftCapabilities(dispatcher, automations, taskWrites?.getConfig);
+	}
+	if (taskWrites) {
+		registerTaskWriteCapabilities(dispatcher, taskWrites);
+		registerTaskRelationCapabilities(dispatcher, taskWrites.wake);
+		registerTaskManagementCapabilities(dispatcher, taskWrites.wake);
+		registerTaskRunWriteCapabilities(dispatcher, taskWrites.wake);
+	}
+	if (getNotes) registerNoteWriteCapabilities(dispatcher, {
+		getNotes: () => {
+			const notes = getNotes();
+			if (!notes) throw new CapabilityError("UNAVAILABLE", "Notes service is unavailable");
+			return notes;
+		},
+		getProjects: taskWrites?.getProjects
+	});
+	return dispatcher;
+}
+//#endregion
+export { createProductDispatcher };

package/dist/src/capabilities/runtime/settings.d.ts

@@ -0,0 +1,3 @@
+import { type CapabilityDispatcher } from './dispatcher.js';
+/** A navigation suggestion, not configuration access or authority to move a client tab. */
+export declare function registerSettingsCapability(dispatcher: CapabilityDispatcher): void;

package/dist/src/capabilities/runtime/settings.js

@@ -0,0 +1,27 @@
+import { ProductReadContracts } from "../../../packages/gateway-contract/src/capabilities.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { defineReadCapability } from "./dispatcher.js";
+//#region src/capabilities/runtime/settings.ts
+init_src();
+/** A navigation suggestion, not configuration access or authority to move a client tab. */
+function registerSettingsCapability(dispatcher) {
+	dispatcher.register(defineReadCapability({
+		id: "xopc.settings.open",
+		majorVersion: 1,
+		description: "Suggest a relative settings target without reading or changing configuration.",
+		effect: "read",
+		surfaces: [
+			"http",
+			"agent",
+			"cli"
+		],
+		scopes: ["gateway.status"],
+		...ProductReadContracts["xopc.settings.open"],
+		execute: (input) => ({
+			ok: true,
+			settings: input
+		})
+	}));
+}
+//#endregion
+export { registerSettingsCapability };

package/dist/src/channels/index.js

@@ -1,14 +1,14 @@
 import { parseFrontmatterBlock } from "../markdown/frontmatter.js";
 import { getChannelPlugin, getChannelRegistryVersion, listChannelPlugins, syncChannelPluginsFromManager } from "./plugins/registry.js";
-import { compileAllowlist, evaluateAccess, hasBotMention, removeBotMention, resolveAllowlistMatch, resolveAllowlistMatchSimple, resolveDmPolicy, resolveGroupPolicy } from "./security.js";
 import { findFenceSpanAt, isSafeFenceBreak, parseFenceSpans } from "../markdown/fences.js";
 import { chunkText } from "../markdown/chunk.js";
 import { chunkMarkdownIR, markdownToIR, markdownToIRWithMeta } from "../markdown/ir.js";
+import { compileAllowlist, evaluateAccess, hasBotMention, removeBotMention, resolveAllowlistMatch, resolveAllowlistMatchSimple, resolveDmPolicy, resolveGroupPolicy } from "./security.js";
 import { renderMarkdownWithMarkers } from "../markdown/render.js";
 import { convertMarkdownTables } from "../markdown/tables.js";
 import { buildCodeSpanIndex, createInlineCodeState } from "../markdown/code-spans.js";
+import { ChannelManager, createChannelManager } from "./manager.js";
 import "./format.js";
 import { MessagePipeline, createEnvelopeTimestampHandler, createFilterCommandsHandler, createFilterEmptyHandler, createFilterSelfHandler, createPipeline, standardPreflightHandlers, standardProcessHandlers } from "./pipeline.js";
-import { ChannelManager, createChannelManager } from "./manager.js";
 import { collectSetupWizardChannels } from "./setup-wizard-discovery.js";
 export { ChannelManager, MessagePipeline, buildCodeSpanIndex, chunkMarkdownIR, chunkText, collectSetupWizardChannels, compileAllowlist, convertMarkdownTables, createChannelManager, createEnvelopeTimestampHandler, createFilterCommandsHandler, createFilterEmptyHandler, createFilterSelfHandler, createInlineCodeState, createPipeline, evaluateAccess, findFenceSpanAt, getChannelPlugin, getChannelRegistryVersion, hasBotMention, isSafeFenceBreak, listChannelPlugins, markdownToIR, markdownToIRWithMeta, parseFenceSpans, parseFrontmatterBlock, removeBotMention, renderMarkdownWithMarkers, resolveAllowlistMatch, resolveAllowlistMatchSimple, resolveDmPolicy, resolveGroupPolicy, standardPreflightHandlers, standardProcessHandlers, syncChannelPluginsFromManager };

package/dist/src/channels/manager.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { ChannelHealthMonitor } from "./health-monitor.js";
-import { ChannelHeartbeatScheduler } from "./heartbeat-scheduler.js";
 import { ChannelPluginRegistry } from "./plugin-registry.js";
+import { ChannelHeartbeatScheduler } from "./heartbeat-scheduler.js";
 import { ChannelOutboundSender } from "./outbound-sender.js";
 import { ChannelLifecycleSupervisor } from "./lifecycle-supervisor.js";
 //#region src/channels/manager.ts

package/dist/src/cli/cli-log-level-preset.d.ts

@@ -5,3 +5,5 @@
  * This module must load before any import of `../utils/logger.js`.
  */
 declare const env: NodeJS.ProcessEnv;
+declare const cliArgs: string[];
+declare let commandIndex: number;

package/dist/src/cli/cli-log-level-preset.js

@@ -6,6 +6,10 @@
 * This module must load before any import of `../utils/logger.js`.
 */
 const env = process.env;
+const cliArgs = process.argv.slice(2);
+let commandIndex = 0;
+while (cliArgs[commandIndex]?.startsWith("-")) commandIndex += ["--config", "--workspace"].includes(cliArgs[commandIndex]) ? 2 : 1;
+if (cliArgs[commandIndex] === "mcp" && cliArgs[commandIndex + 1] === "capabilities") env.XOPC_LOG_CONSOLE = "false";
 if (!env.VITEST && !env.TEST && !env.XOPC_LOG_LEVEL && !process.argv.includes("--verbose") && !process.argv.includes("-v")) env.XOPC_LOG_LEVEL = "warn";
 //#endregion
 export {};

package/dist/src/cli/command-catalog.js

@@ -1,5 +1,9 @@
 //#region src/cli/command-catalog.ts
 const cliCommandCatalog = [
+	{
+		commandPath: ["mcp"],
+		policy: { loadExtensions: "never" }
+	},
 	{
 		commandPath: ["init"],
 		policy: { loadExtensions: "never" }

package/dist/src/cli/command-loaders.js

@@ -18,6 +18,7 @@ const REGISTRY_COMMAND_MODULES = {
 	doctor: () => import("./commands/doctor/index.js"),
 	support: () => import("./commands/support.js"),
 	runtime: () => import("./commands/runtime.js"),
+	mcp: () => import("./commands/mcp.js"),
 	platform: () => import("./commands/platform.js"),
 	image: () => import("./commands/image.js"),
 	channels: () => import("./commands/channels.js"),

package/dist/src/cli/command-manifest.js

@@ -91,6 +91,10 @@ const ROOT_HELP_COMMANDS = [
 		name: "runtime",
 		description: "Manage Node.js and Python tool runtimes used by agents"
 	},
+	{
+		name: "mcp",
+		description: "Expose selected Gateway capabilities over MCP"
+	},
 	{
 		name: "platform",
 		description: "Connect to XOPC Cloud or an enterprise platform"

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

@@ -1,8 +1,8 @@
 import { buildChannelCatalogForConfig, init_channel_catalog_service } from "../../channels/catalog/channel-catalog-service.js";
 import { init_loader, loadConfig, saveConfig } from "../../config/loader.js";
+import { formatExamples, register } from "../registry.js";
 import { listChannelPairingState } from "../../channels/pairing/pairing-service.js";
 import { approveChannelPairingFromCli } from "../../channels/pairing/approve-cli.js";
-import { formatExamples, register } from "../registry.js";
 import { colors } from "../utils/colors.js";
 import { Command } from "commander";
 //#region src/cli/commands/channels.ts

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

@@ -1,8 +1,8 @@
 import { init_loader, loadConfig, saveConfig } from "../../config/loader.js";
 import { getStoreConnectorInstallPlan, installStoreConnector, listStoreConnectors } from "../../capabilities/store-connector.js";
 import { register } from "../registry.js";
-import { confirm } from "@inquirer/prompts";
 import { Command } from "commander";
+import { confirm } from "@inquirer/prompts";
 //#region src/cli/commands/connectors.ts
 init_loader();
 function parsePairs(values, option) {

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

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

package/dist/src/cli/commands/extension-marketplace.js

@@ -13,8 +13,8 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { execSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import semver from "semver";
-import { confirm } from "@inquirer/prompts";
 import { Command } from "commander";
+import { confirm } from "@inquirer/prompts";
 //#region src/cli/commands/extension-marketplace.ts
 init_loader();
 init_paths();

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

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

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

@@ -0,0 +1,51 @@
+import { init_loader, loadConfig } from "../../config/loader.js";
+import { register } from "../registry.js";
+import { createGatewayHttpClientFromConfig } from "../../mcp/gateway-http-client.js";
+import { createCapabilityMcpServer } from "../../mcp/capability-server.js";
+import { Command } from "commander";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/cli/commands/mcp.ts
+init_loader();
+function createMcpCommand(ctx) {
+	const command = new Command("mcp").description("Expose selected Gateway capabilities over MCP");
+	command.command("capabilities").description("Run an opt-in stdio MCP proxy for an explicit capability allowlist").requiredOption("--allow-capability <ids...>", "Exact capability IDs; no wildcards").action(async (options) => {
+		const server = createCapabilityMcpServer(createGatewayHttpClientFromConfig({ config: loadConfig(ctx.configPath) }), options.allowCapability);
+		const transport = new StdioServerTransport();
+		let resolveClosed;
+		const closed = new Promise((resolve) => {
+			resolveClosed = resolve;
+		});
+		let closing = false;
+		const shutdown = () => {
+			if (closing) return;
+			closing = true;
+			server.close().then(resolveClosed, resolveClosed);
+		};
+		server.onclose = resolveClosed;
+		process.once("SIGINT", shutdown);
+		process.once("SIGTERM", shutdown);
+		process.stdin.once("end", shutdown);
+		try {
+			await server.connect(transport);
+			await closed;
+		} finally {
+			process.off("SIGINT", shutdown);
+			process.off("SIGTERM", shutdown);
+			process.stdin.off("end", shutdown);
+			await server.close();
+		}
+	});
+	return command;
+}
+register({
+	id: "mcp",
+	name: "mcp",
+	description: "Expose selected Gateway capabilities over MCP",
+	factory: createMcpCommand,
+	metadata: {
+		category: "utility",
+		examples: ["xopc mcp capabilities --allow-capability xopc.notes.list"]
+	}
+});
+//#endregion
+export {};

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

@@ -9,8 +9,8 @@ import { prepareUpdateGlobalDefaults } from "../../gateway/global-defaults-admin
 import { disconnectProvider } from "../../providers/provider-disconnect.js";
 import { colors } from "../utils/colors.js";
 import { runCliOAuthLogin } from "../utils/oauth-login.js";
-import { input } from "@inquirer/prompts";
 import { Command } from "commander";
+import { input } from "@inquirer/prompts";
 //#region src/cli/commands/models.ts
 init_credentials();
 init_schema();

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

@@ -10,8 +10,8 @@ import { initWorkspace } from "../utils/init-workspace.js";
 import { setupModel } from "./onboard/model.js";
 import { getChannelConfigurators } from "./onboard/channels/registry.js";
 import { setupChannels } from "./onboard/channels/index.js";
-import { select } from "@inquirer/prompts";
 import { Command } from "commander";
+import { select } from "@inquirer/prompts";
 //#region src/cli/commands/onboard.ts
 init_schema();
 init_paths_state();

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

@@ -1,8 +1,8 @@
 import { closeXopcDatabase, isXopcDatabaseOpen, openXopcDatabase } from "../../storage/sqlite/connection.js";
+import { TaskRepository } from "../../tasks/task-repository.js";
 import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
 import "../../storage/sqlite/index.js";
 import { init_loader, loadConfig } from "../../config/loader.js";
-import { TaskRepository } from "../../tasks/task-repository.js";
 import { ProjectService } from "../../projects/project-service.js";
 import { isValidProjectAgentId, normalizeProjectAgentId } from "../../projects/project-agent.js";
 import "../../projects/index.js";

package/dist/src/computer/broker.d.ts

@@ -43,7 +43,6 @@ export type ComputerApproval = {
 export interface ComputerBrokerHost {
     requestApproval(request: ComputerApproval, signal: AbortSignal): Promise<boolean>;
     isVisible(): boolean;
-    hasFullControl?(): boolean;
     onStateChange?(): void;
 }
 type Status = 'pending_authorization' | 'ready' | 'running' | 'pending_action' | 'paused' | 'stopped';

package/dist/src/computer/broker.js

@@ -150,8 +150,7 @@ var ComputerBroker = class {
 			actions: 0
 		};
 		this.session = s;
-		const fullControl = this.host.hasFullControl?.() === true;
-		const authorization = (fullControl ? Promise.resolve(true) : this.host.requestApproval({
+		this.host.requestApproval({
 			kind: "session",
 			id: s.id,
 			appId: s.appId,
@@ -159,7 +158,7 @@ var ComputerBroker = class {
 			mode: s.mode,
 			prepare: s.prepare,
 			model: s.model
-		}, s.controller.signal)).then(async (approved) => {
+		}, s.controller.signal).then(async (approved) => {
 			this.active(s);
 			if (!approved) {
 				await this.stop();
@@ -179,7 +178,6 @@ var ComputerBroker = class {
 			if (error instanceof ComputerTargetError) s.windows = error.windows;
 			return this.stop().catch(() => {});
 		}).finally(() => this.host.onStateChange?.());
-		if (fullControl) await authorization;
 		return this.result(s);
 	}
 	async observe(s) {
@@ -232,10 +230,10 @@ var ComputerBroker = class {
 		const observed = s.observation;
 		if (!observed || e.observationId !== observed.id || this.now() - observed.capturedAt > 12e4) throw new Error("COMPUTER_STALE_OBSERVATION");
 		if (s.actions >= this.config.maxActionsPerSession) throw new Error("COMPUTER_ACTION_BUDGET");
-		if ("point" in e.action && e.action.point && (e.action.point.x >= observed.imageWidth || e.action.point.y >= observed.imageHeight)) throw new Error("COMPUTER_COORDINATE_OUTSIDE_WINDOW");
+		if ((e.action.kind === "drag" ? [e.action.from, e.action.to] : "point" in e.action && e.action.point ? [e.action.point] : []).some((point) => point.x >= observed.imageWidth || point.y >= observed.imageHeight)) throw new Error("COMPUTER_COORDINATE_OUTSIDE_WINDOW");
 		if (e.action.kind === "typeText" && !e.action.point && !observed.focusedEditableRef) throw new Error("COMPUTER_EDITABLE_TARGET_REQUIRED");
 		this.driver.validateAction?.(e.action);
-		if (e.action.kind !== "wait" && !this.host.hasFullControl?.()) {
+		if (e.action.kind !== "wait") {
 			if (!s.pending) {
 				s.pending = {
 					envelope: e,

package/dist/src/computer/evaluation-harness.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { ComputerEvaluationPlanSchema, type ComputerEvaluationRun } from './evaluation.js';
+declare const CommandSchema: z.ZodObject<{
+    command: z.ZodArray<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const ComputerEvaluationHarnessManifestSchema: z.ZodObject<{
+    plan: z.ZodObject<{
+        taskIds: z.ZodArray<z.ZodString>;
+        repetitions: z.ZodNumber;
+        modelRef: z.ZodString;
+        environment: z.ZodString;
+        evidence: z.ZodEnum<{
+            native: "native";
+            fixture: "fixture";
+            "real-app": "real-app";
+        }>;
+    }, z.core.$strict>;
+    executor: z.ZodObject<{
+        command: z.ZodArray<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    oracle: z.ZodObject<{
+        command: z.ZodArray<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ComputerEvaluationHarnessManifest = z.infer<typeof ComputerEvaluationHarnessManifestSchema>;
+type ExecuteCommand = (spec: z.infer<typeof CommandSchema>, input: unknown, signal?: AbortSignal) => Promise<unknown>;
+/** Run one JSON-in/JSON-out harness process without a shell or inherited stdin. */
+export declare function executeEvaluationCommand(spec: z.infer<typeof CommandSchema>, input: unknown, signal?: AbortSignal): Promise<unknown>;
+/** Executor and oracle are deliberately separate processes; the oracle alone grades success. */
+export declare function runComputerEvaluationManifest(raw: unknown, options?: {
+    execute?: ExecuteCommand;
+    signal?: AbortSignal;
+    onRun?: (run: ComputerEvaluationRun, evidenceRef: string) => void | Promise<void>;
+}): Promise<{
+    plan: z.infer<typeof ComputerEvaluationPlanSchema>;
+    runs: ComputerEvaluationRun[];
+    evidence: Record<string, string>;
+}>;
+export {};

package/dist/src/computer/evaluation-harness.js

@@ -0,0 +1,108 @@
+import { spawnProcess } from "../process/run-process.js";
+import { ComputerEvaluationPlanSchema, ComputerEvaluationRunSchema } from "./evaluation.js";
+import { z } from "zod";
+//#region src/computer/evaluation-harness.ts
+const CommandSchema = z.object({
+	command: z.array(z.string().min(1)).min(1).max(100),
+	cwd: z.string().min(1).optional(),
+	timeoutMs: z.number().int().min(1e3).max(36e5).default(3e5)
+}).strict();
+const ComputerEvaluationHarnessManifestSchema = z.object({
+	plan: ComputerEvaluationPlanSchema,
+	executor: CommandSchema,
+	oracle: CommandSchema
+}).strict();
+const ExecutorResultSchema = ComputerEvaluationRunSchema.pick({
+	claimedSuccess: true,
+	takeover: true,
+	duplicateInputs: true,
+	scopeViolations: true,
+	postStopInputs: true,
+	durationMs: true,
+	modelRequests: true,
+	inputTokens: true,
+	outputTokens: true,
+	cost: true
+}).extend({ runId: z.string().min(1).max(500) }).strict();
+const OracleResultSchema = ComputerEvaluationRunSchema.pick({
+	outcome: true,
+	oracle: true
+}).extend({ evidenceRef: z.string().min(1).max(2e3) }).strict();
+/** Run one JSON-in/JSON-out harness process without a shell or inherited stdin. */
+async function executeEvaluationCommand(spec, input, signal) {
+	const [file, ...args] = spec.command;
+	const maxOutputBytes = 1048576;
+	let outputBytes = 0;
+	let outputLimitExceeded = false;
+	const handle = spawnProcess({
+		program: file,
+		args,
+		cwd: spec.cwd,
+		env: process.env,
+		input: JSON.stringify(input),
+		shell: false,
+		signal,
+		timeoutMs: spec.timeoutMs,
+		maxOutputBytes,
+		terminationPolicy: "tree",
+		onOutput: (_stream, chunk) => {
+			outputBytes += chunk.length;
+			if (outputBytes > maxOutputBytes && !outputLimitExceeded) {
+				outputLimitExceeded = true;
+				handle.terminate();
+			}
+		}
+	});
+	const result = await handle.completion;
+	if (outputLimitExceeded) throw new Error("COMPUTER_EVALUATION_OUTPUT_LIMIT");
+	if (result.timedOut) throw new Error("COMPUTER_EVALUATION_TIMEOUT");
+	if (result.aborted) {
+		signal?.throwIfAborted();
+		throw new Error("COMPUTER_EVALUATION_ABORTED");
+	}
+	if (result.exitCode !== 0) throw new Error(`COMPUTER_EVALUATION_PROCESS_FAILED:${result.spawnErrorCode ?? result.exitCode}:${result.stderr.slice(0, 1e3)}`);
+	try {
+		return JSON.parse(result.stdout);
+	} catch {
+		throw new Error("COMPUTER_EVALUATION_INVALID_JSON");
+	}
+}
+/** Executor and oracle are deliberately separate processes; the oracle alone grades success. */
+async function runComputerEvaluationManifest(raw, options = {}) {
+	const manifest = ComputerEvaluationHarnessManifestSchema.parse(raw);
+	const execute = options.execute ?? executeEvaluationCommand;
+	const runs = [];
+	const evidence = {};
+	for (const taskId of manifest.plan.taskIds) for (let repetition = 0; repetition < manifest.plan.repetitions; repetition++) {
+		options.signal?.throwIfAborted();
+		const request = {
+			taskId,
+			repetition,
+			modelRef: manifest.plan.modelRef,
+			environment: manifest.plan.environment,
+			evidence: manifest.plan.evidence
+		};
+		const execution = ExecutorResultSchema.parse(await execute(manifest.executor, request, options.signal));
+		const oracle = OracleResultSchema.parse(await execute(manifest.oracle, {
+			...request,
+			execution
+		}, options.signal));
+		const { runId: _runId, ...measurements } = execution;
+		const { evidenceRef, ...grade } = oracle;
+		const run = ComputerEvaluationRunSchema.parse({
+			...request,
+			...measurements,
+			...grade
+		});
+		runs.push(run);
+		evidence[`${taskId}:${repetition}`] = evidenceRef;
+		await options.onRun?.(run, evidenceRef);
+	}
+	return {
+		plan: manifest.plan,
+		runs,
+		evidence
+	};
+}
+//#endregion
+export { ComputerEvaluationHarnessManifestSchema, executeEvaluationCommand, runComputerEvaluationManifest };

package/dist/src/computer/model-adapter.d.ts

@@ -15,6 +15,16 @@ export declare const ComputerProposalSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
             right: "right";
         }>;
         count: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"drag">;
+        from: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"setValue">;
         ref: z.ZodString;
@@ -72,6 +82,7 @@ export interface ComputerPredictionInput {
     width: number;
     height: number;
     summary: string;
+    stateDigest?: string;
     formatCorrection?: boolean;
     validationReason?: ValidationReason;
     correctionReply?: string;
@@ -79,14 +90,38 @@ export interface ComputerPredictionInput {
     history?: readonly ComputerHistoryEntry[];
     expectation?: ComputerExpectation;
 }
+export interface ComputerStepAdapter {
+    readonly supportsFormatRetry?: boolean;
+    predict(input: ComputerPredictionInput, signal?: AbortSignal): Promise<ComputerProposal>;
+    reset?(): void;
+}
 /** One format-only re-prediction is safe before any input has been proposed or dispatched. */
-export declare function predictComputerStep(adapter: ComputerModelAdapter, input: ComputerPredictionInput, reserveAttempt: () => void, signal?: AbortSignal): Promise<ComputerProposal>;
+export declare function predictComputerStep(adapter: ComputerStepAdapter, input: ComputerPredictionInput, reserveAttempt: () => void, signal?: AbortSignal): Promise<ComputerProposal>;
 export declare function readComputerJson(response: Response, maxBytes: number): Promise<unknown>;
 /** A frozen single-recipient connection; never retries, redirects or changes billing sources. */
-export declare class ComputerModelAdapter {
+export declare class ChatCompletionsComputerAdapter implements ComputerStepAdapter {
+    private readonly fetchImpl;
+    private readonly connection;
+    constructor(connection: ComputerModelConnection, fetchImpl?: typeof fetch);
+    predict(input: ComputerPredictionInput, signal?: AbortSignal): Promise<ComputerProposal>;
+}
+/** Native Responses Computer tool adapter. Execution remains exclusively in the local broker. */
+export declare class OpenAIResponsesComputerAdapter implements ComputerStepAdapter {
     private readonly fetchImpl;
+    readonly supportsFormatRetry = false;
     private readonly connection;
+    private responseId?;
+    private callId?;
+    private queued;
+    private awaitingAction?;
+    private batchGoal?;
     constructor(connection: ComputerModelConnection, fetchImpl?: typeof fetch);
     predict(input: ComputerPredictionInput, signal?: AbortSignal): Promise<ComputerProposal>;
+    private observe;
+    private nextQueued;
+    private mapActions;
+    reset(): void;
+    private resetTurn;
 }
+export declare function createComputerModelAdapter(connection: ComputerModelConnection, fetchImpl?: typeof fetch): ComputerStepAdapter;
 export {};