@xopcai/xopc 0.0.313 → 0.0.315

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

@@ -1,7 +1,7 @@
 import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
 import { init_loader, loadConfig } from "../../config/loader.js";
-import { formatExamples, register } from "../registry.js";
 import { ManagedRuntimeManager } from "../../runtime-tools/manager.js";
+import { formatExamples, register } from "../registry.js";
 import { pruneRuntimeTools } from "../../runtime-tools/prune.js";
 import { Command } from "commander";
 //#region src/cli/commands/runtime.ts

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

@@ -1,14 +1,14 @@
 import { resolveStateDir } from "../../config/paths-state.js";
 import { init_paths, resolveBundledSkillsDir, resolveSkillsLockPath } from "../../config/paths.js";
 import { init_loader, loadConfig } from "../../config/loader.js";
-import { loadSkillsLock } from "../../agent/skills/hub-lock.js";
-import { register } from "../registry.js";
 import { findInstallSpec, hasBinary, installSkill } from "../../agent/skills/installer.js";
 import { createSkillConfigManager, isSkillEnabled } from "../../agent/skills/config.js";
 import { formatScanSummary, scanSkillDirectory } from "../../agent/skills/scanner.js";
 import { createSkillLoader } from "../../agent/skills/index.js";
+import { loadSkillsLock } from "../../agent/skills/hub-lock.js";
 import { pullSkillFromSource, updateSkillFromLock } from "../../agent/skills/hub-pull.js";
 import { ProjectTrustStore } from "../../project-trust/trust-store.js";
+import { register } from "../registry.js";
 import { createSkillsTestCommand } from "./skills-test.js";
 import { Command } from "commander";
 //#region src/cli/commands/skills.ts

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

@@ -2,14 +2,14 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_connection, isXopcDatabaseOpen, openXopcDatabase } from "../../storage/sqlite/connection.js";
 import { loadConfig, saveConfig } from "../../config/loader.js";
-import { formatExamples, register } from "../registry.js";
-import "../../config/index.js";
 import { resolveGatewayEffectiveHost } from "../../config/gateway-bind.js";
-import { resolveGatewayAuth } from "../../gateway/auth.js";
 import { ensureFrpcBinary } from "../../tunnel/frpc-binary.js";
 import { resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret } from "../../tunnel/env.js";
 import { loadTunnelState } from "../../tunnel/tunnel-state.js";
 import { getTunnelService } from "../../tunnel/tunnel-service.js";
+import { formatExamples, register } from "../registry.js";
+import "../../config/index.js";
+import { resolveGatewayAuth } from "../../gateway/auth.js";
 import { requireTunnelGatewayToken } from "../../tunnel/auth-policy.js";
 import { TUNNEL_RISK_SUMMARY_LINES, TunnelConsentError, assertTunnelMayStart, hasValidTunnelConsent } from "../../tunnel/consent.js";
 import { resolveFrpSubdomainHost } from "../../tunnel/frp-subdomain-host.js";

package/dist/src/cli/extension-cli-register.js

@@ -1,12 +1,12 @@
 import { loadConfig } from "../config/loader.js";
-import { createDefaultContext } from "./registry.js";
+import { collectConfiguredChannelIds } from "../extensions/activation-context.js";
+import { ExtensionLoader } from "../extensions/loader.js";
+import "../extensions/index.js";
 import { MessageBus } from "../infra/bus/queue.js";
 import "../infra/bus/index.js";
+import { createDefaultContext } from "./registry.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
-import { collectConfiguredChannelIds } from "../extensions/activation-context.js";
-import { ExtensionLoader } from "../extensions/loader.js";
-import "../extensions/index.js";
 import { registerExtensionCliProgram } from "../extensions/sdk/channel-helpers.js";
 import { join } from "path";
 //#region src/cli/extension-cli-register.ts

package/dist/src/cli/utils/gateway-client.js

@@ -2,8 +2,8 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_paths, resolveConfigPath } from "../../config/paths.js";
 import { loadConfig } from "../../config/loader.js";
-import "../../config/index.js";
 import { resolveGatewayEffectiveHost } from "../../config/gateway-bind.js";
+import "../../config/index.js";
 import { createGatewayCredential, gatewayCredentialAuthorization } from "../../gateway/credential.js";
 import { assertSecureGatewayHttpUrl } from "../../gateway/ws-security.js";
 import { addGatewayClientOptions, parseGatewayClientOptions } from "./gateway-client-options.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 {};