@xopcai/xopc 0.0.291 → 0.0.293

package/dist/src/computer/runtime.js

@@ -1,16 +1,21 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { resolveEffectiveAgentConfigForSession } from "../config/agent-profile.js";
 import { COMPUTER_CONTROL_TOOL, ComputerAppSchema, ComputerObservationSchema, ComputerWindowSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
-import { computerModelProfile, init_model_policy } from "./model-policy.js";
+import { ComputerServiceLimitsSchema, computerModelProfile, init_model_policy } from "./model-policy.js";
 import { getApiKey, init_providers, resolveModel } from "../providers/index.js";
-import { resolveEffectiveAgentConfigForSession } from "../config/agent-profile.js";
 import { enterComputerControl, leaveComputerControl } from "./control-guard.js";
 import { ComputerModelAdapter, predictComputerStep, readComputerJson } from "./model-adapter.js";
-import { computerRecovery } from "./errors.js";
+import { ComputerDiagnosticSchema, ComputerOperationError, computerDiagnostic, computerRecovery } from "./errors.js";
+import { ComputerExpectationSchema, ComputerTaskState, verifyComputerExpectation } from "./task-state.js";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
 //#region src/computer/runtime.ts
 init_src();
 init_providers();
 init_model_policy();
+init_logger();
+const log = createLogger("ComputerRuntime");
 const Reply = z.object({
 	status: z.enum([
 		"pending_authorization",
@@ -26,6 +31,7 @@ const Reply = z.object({
 	grantId: z.string().optional(),
 	observation: ComputerObservationSchema.optional(),
 	errorCode: z.string().optional(),
+	diagnostic: ComputerDiagnosticSchema.optional(),
 	apps: z.array(ComputerAppSchema).max(100).optional(),
 	windows: z.array(ComputerWindowSchema).max(100).optional(),
 	receipt: z.object({
@@ -64,11 +70,13 @@ const ComputerUseInputSchema = z.discriminatedUnion("op", [
 	}).strict(),
 	z.object({
 		op: z.literal("observe"),
-		question: z.string().min(1).max(4e3).optional()
+		question: z.string().min(1).max(4e3).optional(),
+		expect: ComputerExpectationSchema.optional()
 	}).strict(),
 	z.object({
 		op: z.literal("step"),
-		goal: z.string().min(1).max(4e3)
+		goal: z.string().min(1).max(4e3),
+		expect: ComputerExpectationSchema.optional()
 	}).strict(),
 	z.object({ op: z.literal("close") }).strict()
 ]);
@@ -84,11 +92,25 @@ var ComputerRuntime = class {
 		input = ComputerUseInputSchema.parse(input);
 		if (!owner) throw new Error("COMPUTER_CONVERSATION_REQUIRED");
 		if (input.op === "close") {
-			const sessionId = this.sessions.get(owner)?.id ?? "none";
-			await this.close(owner);
-			return {
+			const session = this.sessions.get(owner);
+			const sessionId = session?.id ?? "none";
+			const handoff = { recentActions: (session?.task.history ?? []).map(({ goal, action, dispatch, outcome, verification }) => ({
+				goal,
+				action,
+				dispatch,
+				outcome,
+				verification
+			})) };
+			return await this.close(owner) ? {
 				status: "stopped",
-				sessionId
+				sessionId,
+				handoff,
+				nextAction: "Desktop control is released. Continue with an appropriate authorized tool; this does not permit bypassing a desktop refusal."
+			} : {
+				status: "stop_unconfirmed",
+				sessionId,
+				errorCode: "COMPUTER_RELEASE_UNCONFIRMED",
+				nextAction: computerRecovery("COMPUTER_RELEASE_UNCONFIRMED")
 			};
 		}
 		if (this.operations.has(owner)) throw new Error("COMPUTER_BUSY");
@@ -137,6 +159,7 @@ var ComputerRuntime = class {
 			});
 			if (!apiKey) throw new Error("COMPUTER_MODEL_KEY_MISSING");
 			let deployment;
+			let serviceLimits;
 			if (model.provider === "xopc-cloud") {
 				const response = await fetch(`${model.baseUrl.replace(/\/$/, "")}/models`, {
 					headers: { Authorization: `Bearer ${apiKey}` },
@@ -147,11 +170,15 @@ var ComputerRuntime = class {
 					await response.body?.cancel();
 					throw new Error("COMPUTER_DEPLOYMENT_UNAVAILABLE");
 				}
-				const body = await readComputerJson(response, 2 * 1024 * 1024);
-				deployment = z.object({
+				const metadata = (await readComputerJson(response, 2 * 1024 * 1024)).data?.find((item) => item.id === model.id)?.xopc;
+				const parsedDeployment = z.object({
 					revision: z.string().regex(/^[a-f0-9]{64}$/),
 					origin: z.string().url()
-				}).parse(body.data?.find((item) => item.id === model.id)?.xopc?.computerDeployment);
+				}).safeParse(metadata?.computerDeployment);
+				const parsedLimits = ComputerServiceLimitsSchema.optional().safeParse(metadata?.computerLimits);
+				if (!parsedDeployment.success || !parsedLimits.success) throw new Error("COMPUTER_DEPLOYMENT_UNAVAILABLE");
+				deployment = parsedDeployment.data;
+				serviceLimits = parsedLimits.data;
 			}
 			const adapter = new ComputerModelAdapter({
 				modelId: model.id,
@@ -159,7 +186,8 @@ var ComputerRuntime = class {
 				apiKey,
 				profile,
 				headers: model.headers,
-				deploymentRevision: deployment?.revision
+				deploymentRevision: deployment?.revision,
+				maxOutputTokens: Math.min(2048, model.maxTokens ?? 2048, serviceLimits?.maxOutputTokens ?? 2048)
 			});
 			signal.throwIfAborted();
 			s = {
@@ -181,10 +209,14 @@ var ComputerRuntime = class {
 				createdAt: Date.now(),
 				actions: 0,
 				modelRequests: 0,
-				controller: new AbortController()
+				controller: new AbortController(),
+				task: new ComputerTaskState(),
+				serviceLimits
 			};
 			this.sessions.set(owner, s);
-			enterComputerControl(owner, () => this.close(owner));
+			enterComputerControl(owner, async () => {
+				await this.close(owner);
+			});
 		}
 		if (!s) throw new Error("COMPUTER_OPEN_REQUIRED");
 		signal = signal ? AbortSignal.any([signal, s.controller.signal]) : s.controller.signal;
@@ -192,6 +224,7 @@ var ComputerRuntime = class {
 			await this.close(owner);
 			throw new Error("COMPUTER_SESSION_BUDGET");
 		}
+		let phase = "observe";
 		try {
 			if (input.op === "open") {
 				if (input.appRef !== s.appRef || input.windowRef !== s.windowRef || input.mode !== s.mode || input.prepare !== s.prepare) throw new Error("COMPUTER_CLOSE_BEFORE_TARGET_CHANGE");
@@ -205,8 +238,11 @@ var ComputerRuntime = class {
 					...s.windowRef ? { windowRef: s.windowRef } : {},
 					model: s.binding
 				}, signal);
-				if (reply.value.status === "stopped") await this.close(owner);
-				return this.present(reply.value);
+				if (reply.value.status === "stopped") this.forget(s);
+				return {
+					...this.present(reply.value),
+					...reply.value.status !== "stopped" ? { budget: this.budget(s) } : {}
+				};
 			}
 			const status = await this.send(s, {
 				op: "status",
@@ -214,72 +250,118 @@ var ComputerRuntime = class {
 				owner
 			}, signal);
 			if (status.value.status === "stopped") {
-				this.sessions.delete(owner);
-				leaveComputerControl(owner);
+				this.forget(s);
 				return this.present(status.value);
 			}
 			if (input.op === "step" && s.mode === "observe") throw new Error("COMPUTER_READ_ONLY");
 			if (s.pending) {
 				if (input.op === "observe") return this.present(status.value);
+				phase = "dispatch";
 				return await this.dispatchAction(s, s.pending, signal);
 			}
 			if (status.value.status !== "ready") return this.present(status.value);
-			const observed = await this.send(s, {
-				op: "observe",
-				sessionId: s.id,
-				owner
-			}, signal);
-			try {
-				if (input.op === "observe" && !input.question) return this.present(observed.value);
-				if (input.op === "step" && s.actions >= config.computer.maxActionsPerSession) throw new Error("COMPUTER_ACTION_BUDGET");
-				const o = observed.value.observation;
-				if (!o || !observed.frame || !observed.mimeType) throw new Error("COMPUTER_FRAME_REQUIRED");
-				const proposal = await predictComputerStep(s.adapter, {
-					goal: input.op === "observe" ? input.question : input.goal,
-					readOnly: input.op === "observe",
-					image: observed.frame,
-					mimeType: observed.mimeType,
-					width: o.imageWidth,
-					height: o.imageHeight,
-					summary: o.summary
-				}, () => {
-					if (++s.modelRequests > config.computer.maxModelRequests) throw new Error("COMPUTER_MODEL_BUDGET");
-				}, signal);
-				if (proposal.kind === "answer") return {
-					...this.present(observed.value),
-					summary: proposal.text,
-					verified: false
-				};
-				if (input.op === "observe") throw new Error("COMPUTER_READ_ONLY_MODEL_OUTPUT");
-				if (proposal.kind === "finished") return {
-					status: "model_finished",
+			for (let observationAttempt = 0; observationAttempt < 2; observationAttempt++) {
+				const observed = await this.send(s, {
+					op: "observe",
 					sessionId: s.id,
-					claimedSuccess: proposal.claimedSuccess,
-					verified: false
-				};
-				if (proposal.kind === "takeover") return {
-					status: "takeover",
-					sessionId: s.id,
-					pending: true,
-					summary: "The GUI model requests user assistance. Inspect the authorized window locally."
-				};
-				const e = {
-					actionId: randomUUID(),
-					sessionId: s.id,
-					observationId: o.id,
-					brokerEpoch: o.brokerEpoch,
-					generation: o.generation,
-					grantId: observed.value.grantId,
-					deadlineAt: Date.now() + 12e4,
-					action: proposal.action
-				};
-				return await this.dispatchAction(s, e, signal);
-			} finally {
-				observed.frame?.fill(0);
+					owner
+				}, signal);
+				try {
+					const verification = verifyComputerExpectation(input.expect, observed.value.observation);
+					if (input.op === "observe" && !input.question) return {
+						...this.present(observed.value),
+						verification,
+						verified: verification?.status === "satisfied",
+						budget: this.budget(s)
+					};
+					if (input.op === "step" && verification?.status === "satisfied") return {
+						status: "condition_satisfied",
+						sessionId: s.id,
+						verification,
+						verified: true,
+						budget: this.budget(s),
+						nextAction: "Only the supplied condition was verified. No input was dispatched. Check remaining task requirements before reporting completion."
+					};
+					if (input.op === "step" && s.actions >= config.computer.maxActionsPerSession) throw new Error("COMPUTER_ACTION_BUDGET");
+					const o = observed.value.observation;
+					if (!o || !observed.frame || !observed.mimeType) throw new Error("COMPUTER_FRAME_REQUIRED");
+					phase = "model";
+					const proposal = await predictComputerStep(s.adapter, {
+						goal: input.op === "observe" ? input.question : input.goal,
+						readOnly: input.op === "observe",
+						image: observed.frame,
+						mimeType: observed.mimeType,
+						width: o.imageWidth,
+						height: o.imageHeight,
+						summary: o.summary,
+						history: s.task.history,
+						expectation: input.expect
+					}, () => {
+						if (++s.modelRequests > config.computer.maxModelRequests) throw new Error("COMPUTER_MODEL_BUDGET");
+					}, signal);
+					if (proposal.kind === "answer") return {
+						...this.present(observed.value),
+						summary: proposal.text,
+						verified: false,
+						verification,
+						budget: this.budget(s)
+					};
+					if (input.op === "observe") throw new Error("COMPUTER_READ_ONLY_MODEL_OUTPUT");
+					if (proposal.kind === "finished") return {
+						status: "model_finished",
+						sessionId: s.id,
+						claimedSuccess: proposal.claimedSuccess,
+						verified: false,
+						verification,
+						budget: this.budget(s),
+						nextAction: "The model claim is not proof. Check the requested completion condition using native or artifact evidence before reporting success."
+					};
+					if (proposal.kind === "takeover") return {
+						status: "takeover",
+						sessionId: s.id,
+						pending: true,
+						budget: this.budget(s),
+						summary: "The GUI model requests user assistance. Inspect the authorized window locally."
+					};
+					const e = {
+						actionId: randomUUID(),
+						sessionId: s.id,
+						observationId: o.id,
+						brokerEpoch: o.brokerEpoch,
+						generation: o.generation,
+						grantId: observed.value.grantId,
+						deadlineAt: Date.now() + 12e4,
+						action: proposal.action
+					};
+					s.task.assertProgress(proposal.action, o);
+					s.pendingContext = {
+						goal: input.goal,
+						before: o,
+						expectation: input.expect
+					};
+					phase = "dispatch";
+					const result = await this.dispatchAction(s, e, signal);
+					if (result.status !== "ready" || result.receipt || result.errorCode !== "COMPUTER_OBSERVATION_CHANGED") return result;
+					phase = "observe";
+				} finally {
+					observed.frame?.fill(0);
+				}
 			}
+			throw new Error("COMPUTER_UI_UNSTABLE");
 		} catch (error) {
+			const failure = signal.aborted || computerDiagnostic(error) || error instanceof Error && /^COMPUTER_[A-Z_0-9]+$/.test(error.message) ? error : new ComputerOperationError({
+				errorCode: `COMPUTER_${phase.toUpperCase()}_FAILED`,
+				phase,
+				diagnosticId: randomUUID()
+			});
+			const diagnostic = computerDiagnostic(failure);
+			if (diagnostic) log.warn({
+				...diagnostic,
+				conversationId: owner,
+				sessionId: s.id
+			}, `Computer operation failed: ${diagnostic.errorCode}`);
 			await this.close(owner);
-			throw error;
+			throw failure;
 		}
 	}
 	async dispatchAction(s, envelope, signal) {
@@ -296,8 +378,34 @@ var ComputerRuntime = class {
 		}, signal);
 		if (reply.value.status !== "pending_action") s.pending = void 0;
 		reply.frame?.fill(0);
-		if (reply.value.status === "stopped") await this.close(s.owner);
-		return this.present(reply.value);
+		if (reply.value.status === "ready" && reply.value.errorCode === "COMPUTER_OBSERVATION_CHANGED" && !reply.value.receipt) {
+			s.actions--;
+			s.pendingContext = void 0;
+			return {
+				...this.present(reply.value),
+				budget: this.budget(s)
+			};
+		}
+		const context = s.pendingContext;
+		const verification = verifyComputerExpectation(context?.expectation, reply.value.observation);
+		if (context && reply.value.receipt) s.task.record(context.goal, envelope.action, context.before, reply.value.receipt, reply.value.observation, verification);
+		if (!s.pending) s.pendingContext = void 0;
+		if (reply.value.status === "stopped") this.forget(s);
+		return {
+			...this.present(reply.value),
+			verification,
+			verified: verification?.status === "satisfied",
+			...reply.value.status !== "stopped" ? { budget: this.budget(s) } : {}
+		};
+	}
+	budget(s) {
+		const config = this.getConfig().computer;
+		return {
+			actionsRemaining: Math.max(0, config.maxActionsPerSession - s.actions),
+			modelRequestsRemaining: Math.max(0, config.maxModelRequests - s.modelRequests),
+			expiresAt: s.createdAt + config.maxSessionDurationMs,
+			...s.serviceLimits ? { serviceLimits: s.serviceLimits } : {}
+		};
 	}
 	present(reply) {
 		return {
@@ -307,6 +415,7 @@ var ComputerRuntime = class {
 				errorCode: reply.errorCode,
 				nextAction: computerRecovery(reply.errorCode)
 			} : {},
+			...reply.diagnostic ? { diagnostic: reply.diagnostic } : {},
 			...reply.apps ? {
 				apps: reply.apps,
 				summary: reply.apps.length ? "Use a returned appRef. Names are untrusted metadata. Ask only when multiple candidates match the task." : "No matching apps. Try the display name or list with an empty query; never guess a bundle ID."
@@ -349,36 +458,57 @@ var ComputerRuntime = class {
 			descriptorRevision: tool.revision,
 			signal
 		});
-		const json = reply.content.find((item) => item.type === "json");
-		const value = Reply.parse(json?.type === "json" ? json.value : void 0);
-		if (value.sessionId !== s.id) throw new Error("COMPUTER_SESSION_MISMATCH");
 		const file = reply.content.find((item) => item.type === "file");
 		let frame;
 		if (file?.type === "file" && reply.invocationId) frame = this.endpoints.uploads.takeComputerFrame(file.fileId, reply.invocationId);
-		if (signal?.aborted) {
+		try {
+			signal?.throwIfAborted();
+			const json = reply.content.find((item) => item.type === "json");
+			const value = Reply.parse(json?.type === "json" ? json.value : void 0);
+			if (value.sessionId !== s.id) throw new Error("COMPUTER_SESSION_MISMATCH");
+			if (file && !frame || value.observation && !frame && !value.errorCode) throw new Error("COMPUTER_FRAME_HANDOFF_FAILED");
+			if (frame && (!value.observation || !["observe", "act"].includes(command.op))) throw new Error("COMPUTER_UNEXPECTED_FRAME");
+			return {
+				value,
+				frame,
+				mimeType: file?.type === "file" ? file.mimeType : void 0
+			};
+		} catch (error) {
 			frame?.fill(0);
-			signal.throwIfAborted();
+			throw error;
 		}
-		return {
-			value,
-			frame,
-			mimeType: file?.type === "file" ? file.mimeType : void 0
-		};
+	}
+	forget(s) {
+		if (this.sessions.get(s.owner) !== s) return;
+		this.sessions.delete(s.owner);
+		leaveComputerControl(s.owner);
+		s.task.clear();
+		s.pendingContext = void 0;
+		s.controller.abort();
 	}
 	async close(owner) {
 		this.operations.get(owner)?.abort();
 		const s = this.sessions.get(owner);
-		if (!s) return;
-		this.sessions.delete(owner);
-		leaveComputerControl(owner);
+		if (!s) return true;
+		s.task.clear();
+		s.pendingContext = void 0;
 		s.controller.abort();
 		try {
-			await this.send(s, {
+			if ((await this.send(s, {
 				op: "release",
 				sessionId: s.id,
 				owner
-			});
-		} catch {}
+			}, AbortSignal.timeout(5e3))).value.status === "stopped") {
+				this.forget(s);
+				return true;
+			}
+		} catch (error) {
+			if (error instanceof Error && error.message === "COMPUTER_SESSION_NOT_FOUND") {
+				this.forget(s);
+				return true;
+			}
+		}
+		return false;
 	}
 	async shutdown() {
 		await Promise.all([...new Set([...this.sessions.keys(), ...this.operations.keys()])].map((owner) => this.close(owner)));

package/dist/src/computer/task-state.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import type { ComputerAction, ComputerObservation, ComputerReceipt } from '@xopcai/computer-control-contract';
+export declare const ComputerExpectationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"field">;
+    label: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type ComputerExpectation = z.infer<typeof ComputerExpectationSchema>;
+export type ComputerVerification = {
+    status: 'satisfied' | 'not_met' | 'unavailable';
+    source: 'accessibility';
+    scope: 'expectation';
+};
+/** Verify only caller-specified conditions against scoped native evidence, never model prose. */
+export declare function verifyComputerExpectation(expectation: ComputerExpectation | undefined, observation?: ComputerObservation): ComputerVerification | undefined;
+export interface ComputerHistoryEntry {
+    goal: string;
+    action: ComputerAction['kind'];
+    actionPreview: string;
+    dispatch: ComputerReceipt['dispatch'];
+    outcome: ComputerReceipt['outcome'];
+    after: string;
+    verification?: ComputerVerification;
+}
+/** Session-local bounded text only. Screenshots and provider responses never enter history. */
+export declare class ComputerTaskState {
+    readonly history: ComputerHistoryEntry[];
+    private repeated?;
+    assertProgress(action: ComputerAction, observation: ComputerObservation): void;
+    record(goal: string, action: ComputerAction, before: ComputerObservation, receipt: ComputerReceipt, after?: ComputerObservation, verification?: ComputerVerification): void;
+    clear(): void;
+}

package/dist/src/computer/task-state.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+//#region src/computer/task-state.ts
+const ComputerExpectationSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("text"),
+	text: z.string().min(1).max(1e3)
+}).strict(), z.object({
+	kind: z.literal("field"),
+	label: z.string().min(1).max(300),
+	value: z.string().max(4e3)
+}).strict()]);
+/** Verify only caller-specified conditions against scoped native evidence, never model prose. */
+function verifyComputerExpectation(expectation, observation) {
+	if (!expectation) return;
+	const result = (status) => ({
+		status,
+		source: "accessibility",
+		scope: "expectation"
+	});
+	if (!observation) return result("unavailable");
+	try {
+		const data = JSON.parse(observation.summary);
+		if (!Array.isArray(data.elements) || !data.elements.some((e) => e.role === "AXWindow")) return result("unavailable");
+		if (expectation.kind === "text") {
+			if (typeof data.text !== "string" || !data.text) return result("unavailable");
+			return result(data.text.includes(expectation.text) ? "satisfied" : "not_met");
+		}
+		const fields = data.elements.filter((e) => ["AXTextField", "AXTextArea"].includes(String(e.role)) && e.label === expectation.label);
+		if (fields.length !== 1 || typeof fields[0].value !== "string") return result("unavailable");
+		return result(fields[0].value === expectation.value ? "satisfied" : "not_met");
+	} catch {
+		return result("unavailable");
+	}
+}
+/** Session-local bounded text only. Screenshots and provider responses never enter history. */
+var ComputerTaskState = class {
+	history = [];
+	repeated;
+	assertProgress(action, observation) {
+		if (action.kind === "wait") return;
+		const key = JSON.stringify([action, observation.stateDigest]);
+		if (this.repeated?.key === key && this.repeated.count >= 2) throw new Error("COMPUTER_NO_PROGRESS");
+	}
+	record(goal, action, before, receipt, after, verification) {
+		if (receipt.dispatch !== "completed") return;
+		const key = JSON.stringify([action, before.stateDigest]);
+		if (action.kind !== "wait" && after?.stateDigest === before.stateDigest) this.repeated = {
+			key,
+			count: this.repeated?.key === key ? this.repeated.count + 1 : 1
+		};
+		else this.repeated = void 0;
+		this.history.push({
+			goal: goal.slice(0, 1e3),
+			action: action.kind,
+			actionPreview: JSON.stringify(action).slice(0, 1e3),
+			dispatch: receipt.dispatch,
+			outcome: receipt.outcome,
+			after: (after?.summary ?? "").slice(0, 2e3),
+			verification
+		});
+		if (this.history.length > 6) this.history.shift();
+	}
+	clear() {
+		this.history.length = 0;
+		this.repeated = void 0;
+	}
+};
+//#endregion
+export { ComputerExpectationSchema, ComputerTaskState, verifyComputerExpectation };

package/dist/src/config/index.js

@@ -2,15 +2,15 @@ import { ENV_VARS, XOPC_DB_FILENAME, resolveHomeDir, resolveStateDir, resolveXop
 import { TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema } from "../../extensions/telegram/src/config-schema.js";
 import { WeixinAccountConfigSchema, WeixinConfigSchema } from "../../extensions/weixin/src/config-schema.js";
 import { AgentImageGenerationModelSchema, AgentModelRefSchema, AgentModelsSchema, AgentsConfigSchema, BindingMatchSchema, BindingRuleSchema, BindingsConfigSchema, BrowserConfigSchema, ChannelsConfigSchema, CommandsConfigSchema, ConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, GatewayAuthRateLimitSchema, GatewayAuthSchema, GatewayBindModeSchema, GatewayChannelConnectDeferModeSchema, GatewayConfigSchema, GatewayModeSchema, GatewayRemoteSchema, GatewaySecuritySchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayTlsSchema, GatewayTrustedProxySchema, GatewayWebchatConfigSchema, HeartbeatConfigSchema, McpConfigSchema, McpOAuthConfigSchema, McpServerSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, MessagesConfigSchema, ModelCatalogConfigSchema, ModelsDevConfigSchema, ProviderAuthConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProvidersConfigSchema, RuntimeToolsConfigSchema, STTConfigSchema, STTFallbackConfigSchema, STTProviderConfigSchema, SearchProviderEntrySchema, SessionConfigSchema, SessionDmScopeSchema, SessionResetByTypeSchema, SessionResetConfigSchema, SessionResetModeSchema, SessionScopeSchema, SessionStorageConfigSchema, TTSConfigSchema, TTSEdgeConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSProviderConfigSchema, TTSSummarizationConfigSchema, ToolsConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, TuiConfigSchema, TunnelConfigSchema, TunnelConsentSchema, UpdateAutoConfigSchema, UpdateConfigSchema, VoiceConfigSchema, VoiceRefinementConfigSchema, WebSearchConfigSchema, WebToolsConfigSchema, WebsiteBlocklistSchema, WorkspaceConfigSchema, WorkspaceImportConfigSchema, getAgentDefaultImageGenerationModelConfig, getAgentDefaultImageModelConfig, getAgentDefaultModelRef, init_schema, parseModelRef } from "./schema.js";
-import { clearConfigValueCache, getAllowedCommands, getCacheStats, init_resolve_config_value, resolveConfigValue, resolveHeaders, testApiKeyResolution } from "./resolve-config-value.js";
+import { applyConfigOverrides, getConfigOverrides, resetConfigOverrides, setConfigOverride, unsetConfigOverride } from "./runtime-overrides.js";
 import { expandWorkspacePathString, init_workspace_path, normalizeWorkspaceDir, resolveWorkspaceRoot } from "./workspace-path.js";
 import { resolveDefaultAgentWorkspaceDir } from "./workspace-defaults.js";
 import { resolveAgentDir as resolveAgentDir$1, resolveAgentHomeDir as resolveAgentHomeDir$1, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
+import { extractProfileAgentId, resolveEffectiveAgentConfigForAgent, resolveEffectiveAgentConfigForSession, resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession } from "./agent-profile.js";
 import { FILENAMES, WORKSPACE_FILES, existsSync, hasBundledExtensionManifest, init_paths, resolveAgentAuthProfilesPath, resolveAgentDir, resolveAgentHomeDir, resolveAgentProfileDir, resolveAgentProfileMarkdownPath, resolveAuthProfilesPath, resolveBinDir, resolveBundledExtensionsDir, resolveBundledSkillsDir, resolveConfigPath, resolveCredentialsDir, resolveExtensionSdkPath, resolveExtensionsDir, resolveExtensionsLockPath, resolveInboxDir, resolveInboxMessagePath, resolveInboxPendingDir, resolveInboxProcessedDir, resolveLogPath, resolveLogsDir, resolveMcpOAuthPath, resolveModelsJsonPath, resolveNodeBinDir, resolveNodeBinPath, resolveNodeToolsDir, resolveNpmBinPath, resolveOAuthPath, resolvePidPath, resolveSkillPath, resolveSkillsCachePath, resolveSkillsDir, resolveSkillsLockPath, resolveSocketPath, resolveStatusPath, resolveToolsDir, resolveWorkspaceExtensionsDir, resolveWorkspaceFile, resolveWorkspaceStateDir, resolveWorkspaceStatePath, resolveXopcBinPath } from "./paths.js";
-import { CustomModelSchema, ImageGenerationCapabilitiesSchema, ImageGenerationModelSchema, ImageGenerationProviderSchema, ModelOverrideSchema, ModelsJsonSchema, OpenAICompatSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenRouterRoutingSchema, ProviderConfigSchema, VercelGatewayRoutingSchema, getDefaultModelValues, init_models_json, loadModelsJson, modelsJsonExists, saveModelsJson, validateModelsConfig } from "./models-json.js";
 import { init_loader, loadConfig, saveConfig } from "./loader.js";
-import { applyConfigOverrides, getConfigOverrides, resetConfigOverrides, setConfigOverride, unsetConfigOverride } from "./runtime-overrides.js";
-import { extractProfileAgentId, resolveEffectiveAgentConfigForAgent, resolveEffectiveAgentConfigForSession, resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession } from "./agent-profile.js";
+import { clearConfigValueCache, getAllowedCommands, getCacheStats, init_resolve_config_value, resolveConfigValue, resolveHeaders, testApiKeyResolution } from "./resolve-config-value.js";
+import { CustomModelSchema, ImageGenerationCapabilitiesSchema, ImageGenerationModelSchema, ImageGenerationProviderSchema, ModelOverrideSchema, ModelsJsonSchema, OpenAICompatSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenRouterRoutingSchema, ProviderConfigSchema, VercelGatewayRoutingSchema, getDefaultModelValues, init_models_json, loadModelsJson, modelsJsonExists, saveModelsJson, validateModelsConfig } from "./models-json.js";
 import { canonicalizeConfiguredMcpServer, isKnownCliMcpTypeAlias, normalizeConfiguredMcpServers, resolveXopcMcpTransportAlias } from "./mcp-config-normalize.js";
 import { formatThinkingLevels, listThinkingLevels, normalizeElevatedMode, normalizeReasoningLevel, normalizeThinkLevel, normalizeVerboseLevel, thinkLevelToNumber } from "../agent/transcript/thinking-types.js";
 import { getWorkspacePath } from "./workspace-path-helpers.js";

package/dist/src/config/loader.js

@@ -2,10 +2,10 @@ import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { ConfigSchema, init_schema } from "./schema.js";
-import { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.js";
 import { init_paths, resolveConfigPath } from "./paths.js";
-import { init_resolution, setActivePlatformDiscovery } from "../platform/resolution.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";

package/dist/src/config/models-json.js

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { ComputerProfileSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
-import { init_write_file_atomic, writeTextAtomicSync } from "../infra/write-file-atomic.js";
 import { init_paths, resolveModelsJsonPath } from "./paths.js";
+import { init_write_file_atomic, writeTextAtomicSync } from "../infra/write-file-atomic.js";
+import { ComputerProfileSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { init_model_policy, isComputerModel } from "../computer/model-policy.js";
 import { existsSync, readFileSync } from "fs";
 import { z } from "zod";

package/dist/src/endpoint-tools/upload-service.d.ts

@@ -17,6 +17,8 @@ export interface EndpointUploadGrant {
     expiresAt: number;
 }
 export declare class EndpointUploadError extends Error {
+    readonly code: 'INVALID_UPLOAD_GRANT' | 'UPLOAD_TOO_LARGE' | 'INVALID_COMPUTER_FRAME' | 'UPLOAD_BUSY';
+    constructor(message: string, code?: 'INVALID_UPLOAD_GRANT' | 'UPLOAD_TOO_LARGE' | 'INVALID_COMPUTER_FRAME' | 'UPLOAD_BUSY');
 }
 export declare class EndpointUploadService {
     private readonly rootDir;
@@ -24,6 +26,7 @@ export declare class EndpointUploadService {
     private readonly files;
     private readonly frames;
     private readonly pruneTimer;
+    private readonly validatingFrames;
     constructor(rootDir: string);
     createGrant(invocationId: string, endpointId: string, now?: number, profile?: 'durable' | 'computer-frame'): EndpointUploadGrant;
     upload(params: {