@xopcai/xopc 0.0.424 → 0.0.426

package/dist/src/computer/native-timing.js

@@ -0,0 +1,49 @@
+//#region src/computer/native-timing.ts
+/** Monotonic, non-overlapping input stages. SDK time includes the native RPC. */
+var ComputerInputTimer = class {
+	startedAt;
+	stages = {
+		identityCheckMs: 0,
+		actionValidationMs: 0,
+		windowsInputGuardMs: 0,
+		sdkCallMs: 0,
+		resultValidationMs: 0,
+		renderGraceMs: 0
+	};
+	sdkCalls = 0;
+	constructor(windows, now = () => performance.now()) {
+		this.windows = windows;
+		this.now = now;
+		this.startedAt = now();
+	}
+	async measure(stage, operation) {
+		const start = this.now();
+		if (stage === "sdkCallMs") this.sdkCalls++;
+		try {
+			return await operation();
+		} finally {
+			this.stages[stage] += Math.max(0, this.now() - start);
+		}
+	}
+	measureSync(stage, operation) {
+		const start = this.now();
+		try {
+			return operation();
+		} finally {
+			this.stages[stage] += Math.max(0, this.now() - start);
+		}
+	}
+	finish(completed) {
+		const wallMs = Math.max(0, this.now() - this.startedAt);
+		return {
+			wallMs,
+			...this.stages,
+			windowsInputGuardMs: this.windows ? this.stages.windowsInputGuardMs : null,
+			unattributedMs: Math.max(0, wallMs - Object.values(this.stages).reduce((a, b) => a + b, 0)),
+			sdkCalls: this.sdkCalls,
+			completed
+		};
+	}
+};
+//#endregion
+export { ComputerInputTimer };

package/dist/src/computer/program-runtime.d.ts

@@ -0,0 +1,22 @@
+export type ComputerProgramMethod = 'observe' | 'resolve' | 'act' | 'waitFor' | 'verify' | 'emitScreenshot';
+export type ComputerProgramHost = (method: ComputerProgramMethod, args: unknown, signal: AbortSignal) => Promise<unknown>;
+/** UI-only capability table; no general tool discovery, disk store, or output spill. */
+export declare function executeComputerProgram(code: string, host: ComputerProgramHost, store: Record<string, unknown>, signal: AbortSignal, timeoutMs?: number): Promise<{
+    status: "program_error";
+    output: string;
+    errorCode: string;
+    scriptError: string;
+    scriptErrorMessage?: undefined;
+} | {
+    status: "program_error";
+    output: string;
+    errorCode: string;
+    scriptError: import("@earendil-works/pi-codemode").CodemodeErrorKind;
+    scriptErrorMessage: string;
+} | {
+    status: "program_completed";
+    output: string;
+    errorCode?: undefined;
+    scriptError?: undefined;
+    scriptErrorMessage?: undefined;
+}>;

package/dist/src/computer/program-runtime.js

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync } from "node:fs";
+import { z } from "zod";
+import { CodemodeSandbox } from "@earendil-works/pi-codemode";
+//#region src/computer/program-runtime.ts
+let workerUrl;
+function computerWorkerUrl() {
+	if (workerUrl) return workerUrl;
+	const bundled = new URL("./codemode-worker.js", import.meta.url);
+	const source = existsSync(bundled) ? bundled : new URL("./bundle/chunks/codemode-worker.js", import.meta.resolve("@earendil-works/pi-coding-agent"));
+	workerUrl = new URL(`data:text/javascript;base64,${readFileSync(source).toString("base64")}`);
+	return workerUrl;
+}
+/** UI-only capability table; no general tool discovery, disk store, or output spill. */
+async function executeComputerProgram(code, host, store, signal, timeoutMs = 12e4) {
+	if (Buffer.byteLength(code) > 64 * 1024) throw new Error("COMPUTER_INPUT_LIMIT");
+	let busy = false;
+	let calls = 0;
+	let ended = false;
+	let hostErrorCode;
+	let cancelledHostCall = false;
+	const lifetime = new AbortController();
+	const combined = AbortSignal.any([signal, lifetime.signal]);
+	const inFlight = /* @__PURE__ */ new Set();
+	const sandbox = new CodemodeSandbox({
+		timeoutMs,
+		memoryLimitBytes: 64 * 1024 * 1024,
+		workerUrl: computerWorkerUrl(),
+		globals: [
+			"observe",
+			"resolve",
+			"act",
+			"waitFor",
+			"verify",
+			"emitScreenshot"
+		].map((method) => ({
+			name: `ui.${method}`,
+			async execute(args, context) {
+				if (ended || ++calls > 64) {
+					lifetime.abort();
+					throw new Error("COMPUTER_PROGRAM_BUDGET");
+				}
+				if (busy) {
+					lifetime.abort();
+					throw new Error("COMPUTER_BUSY");
+				}
+				busy = true;
+				const operation = host(method, args, AbortSignal.any([combined, context.signal]));
+				inFlight.add(operation);
+				try {
+					return await operation;
+				} catch (error) {
+					if (error instanceof Error && /^COMPUTER_[A-Z_0-9]{1,80}$/.test(error.message)) hostErrorCode = error.message;
+					lifetime.abort();
+					throw error;
+				} finally {
+					cancelledHostCall ||= context.signal.aborted || combined.aborted;
+					inFlight.delete(operation);
+					busy = false;
+				}
+			}
+		}))
+	});
+	try {
+		const result = await sandbox.execute(code, {
+			store,
+			signal: combined
+		});
+		const unawaited = inFlight.size > 0;
+		ended = true;
+		lifetime.abort();
+		await Promise.allSettled([...inFlight]);
+		const text = result.output.filter((item) => item.type === "text").map((item) => item.text).join("\n").slice(0, 16e3);
+		if (unawaited || cancelledHostCall || hostErrorCode) return {
+			status: "program_error",
+			output: text,
+			errorCode: hostErrorCode ?? "COMPUTER_PROGRAM_UNAWAITED_CALL",
+			scriptError: "aborted"
+		};
+		if (result.ok === false) return {
+			status: "program_error",
+			output: text,
+			errorCode: hostErrorCode ?? "COMPUTER_PROGRAM_FAILED",
+			scriptError: result.error.kind,
+			scriptErrorMessage: result.error.message.slice(0, 1e3)
+		};
+		const next = { ...store };
+		for (const key of result.storeWrites.delete) delete next[key];
+		Object.assign(next, result.storeWrites.set);
+		if (Object.keys(next).length > 64 || Buffer.byteLength(JSON.stringify(next)) > 64 * 1024) throw new Error("COMPUTER_PROGRAM_STORE_LIMIT");
+		z.record(z.string(), z.json()).parse(next);
+		for (const key of Object.keys(store)) delete store[key];
+		Object.assign(store, next);
+		return {
+			status: "program_completed",
+			output: text
+		};
+	} finally {
+		ended = true;
+		lifetime.abort();
+		await sandbox.close();
+		await Promise.allSettled([...inFlight]);
+	}
+}
+//#endregion
+export { executeComputerProgram };

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

@@ -45,14 +45,32 @@ declare const Reply: z.ZodObject<{
         precheckMs: z.ZodNumber;
         inputMs: z.ZodNumber;
         postObserveMs: z.ZodNumber;
+        inputDetail: z.ZodOptional<z.ZodObject<{
+            wallMs: z.ZodNumber;
+            identityCheckMs: z.ZodNumber;
+            actionValidationMs: z.ZodNumber;
+            windowsInputGuardMs: z.ZodNullable<z.ZodNumber>;
+            sdkCallMs: z.ZodNumber;
+            resultValidationMs: z.ZodNumber;
+            renderGraceMs: z.ZodNumber;
+            unattributedMs: z.ZodNumber;
+            sdkCalls: z.ZodNumber;
+            completed: z.ZodBoolean;
+        }, z.core.$strict>>;
+        precheckSamples: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    transportTiming: z.ZodOptional<z.ZodObject<{
+        brokerWallMs: z.ZodNumber;
+        frameUploadMs: z.ZodNullable<z.ZodNumber>;
+        commandWallMs: z.ZodNumber;
     }, z.core.$strict>>;
     errorCode: z.ZodOptional<z.ZodString>;
     diagnostic: z.ZodOptional<z.ZodObject<{
         errorCode: z.ZodString;
         phase: z.ZodEnum<{
             model: "model";
-            observe: "observe";
             dispatch: "dispatch";
+            observe: "observe";
             frame_upload: "frame_upload";
         }>;
         diagnosticId: z.ZodUUID;
@@ -122,6 +140,10 @@ export declare const ComputerUseInputSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
         observe: "observe";
     }>;
     prepare: z.ZodBoolean;
+    planner: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        gui: "gui";
+    }>>;
 }, z.core.$strict>, z.ZodObject<{
     op: z.ZodLiteral<"observe">;
     question: z.ZodOptional<z.ZodString>;
@@ -151,6 +173,11 @@ export declare const ComputerUseInputSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
         label: z.ZodString;
     }, z.core.$strict>], "kind">>;
     flowId: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"exec">;
+    code: z.ZodString;
+    maxActions: z.ZodOptional<z.ZodNumber>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
     op: z.ZodLiteral<"run">;
     goal: z.ZodString;
@@ -181,6 +208,10 @@ export type ComputerUseInput = z.infer<typeof ComputerUseInputSchema>;
 export interface ComputerPublicResult {
     status: string;
     sessionId: string;
+    output?: string;
+    scriptError?: string;
+    scriptErrorMessage?: string;
+    imageRef?: string;
     pending?: boolean;
     summary?: string;
     receipt?: z.infer<typeof Reply>['receipt'];
@@ -238,8 +269,11 @@ export declare class ComputerRuntime {
     private readonly reports;
     private readonly openingReports;
     constructor(endpoints: EndpointToolRuntime, getConfig: () => Config, getTurnEndpoint?: (owner: string) => string | undefined, flowStore?: ComputerFlowRepository);
-    execute(owner: string, input: ComputerUseInput, signal?: AbortSignal): Promise<ComputerPublicResult>;
+    execute(owner: string, input: ComputerUseInput, signal?: AbortSignal, execution?: {
+        toolCallId: string;
+    }): Promise<ComputerPublicResult>;
     private flowScope;
+    private executeProgram;
     private executeGoal;
     private executeInput;
     private isUndispatchedChange;