@xopcai/xopc 0.0.285 → 0.0.291

package/dist/src/computer/runtime.js

@@ -0,0 +1,388 @@
+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 { 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 { randomUUID } from "node:crypto";
+import { z } from "zod";
+//#region src/computer/runtime.ts
+init_src();
+init_providers();
+init_model_policy();
+const Reply = z.object({
+	status: z.enum([
+		"pending_authorization",
+		"ready",
+		"running",
+		"pending_action",
+		"paused",
+		"stopped"
+	]),
+	sessionId: z.string(),
+	brokerEpoch: z.string(),
+	generation: z.number().int().nonnegative(),
+	grantId: z.string().optional(),
+	observation: ComputerObservationSchema.optional(),
+	errorCode: z.string().optional(),
+	apps: z.array(ComputerAppSchema).max(100).optional(),
+	windows: z.array(ComputerWindowSchema).max(100).optional(),
+	receipt: z.object({
+		actionId: z.string(),
+		dispatch: z.enum([
+			"notStarted",
+			"started",
+			"completed",
+			"unknown"
+		]),
+		outcome: z.enum([
+			"applied",
+			"notApplied",
+			"unknown"
+		]),
+		verification: z.enum([
+			"semantic",
+			"artifact",
+			"visual",
+			"none"
+		]),
+		errorCode: z.string().optional()
+	}).optional()
+}).strict();
+const ComputerUseInputSchema = z.discriminatedUnion("op", [
+	z.object({
+		op: z.literal("discover"),
+		query: z.string().max(200)
+	}).strict(),
+	z.object({
+		op: z.literal("open"),
+		appRef: z.string().min(1).max(200),
+		windowRef: z.string().min(1).max(200).optional(),
+		mode: z.enum(["observe", "control"]),
+		prepare: z.boolean()
+	}).strict(),
+	z.object({
+		op: z.literal("observe"),
+		question: z.string().min(1).max(4e3).optional()
+	}).strict(),
+	z.object({
+		op: z.literal("step"),
+		goal: z.string().min(1).max(4e3)
+	}).strict(),
+	z.object({ op: z.literal("close") }).strict()
+]);
+var ComputerRuntime = class {
+	sessions = /* @__PURE__ */ new Map();
+	operations = /* @__PURE__ */ new Map();
+	constructor(endpoints, getConfig, getTurnEndpoint) {
+		this.endpoints = endpoints;
+		this.getConfig = getConfig;
+		this.getTurnEndpoint = getTurnEndpoint;
+	}
+	async execute(owner, input, signal) {
+		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 {
+				status: "stopped",
+				sessionId
+			};
+		}
+		if (this.operations.has(owner)) throw new Error("COMPUTER_BUSY");
+		const operation = new AbortController();
+		this.operations.set(owner, operation);
+		try {
+			return await this.executeInput(owner, input, signal ? AbortSignal.any([signal, operation.signal]) : operation.signal);
+		} finally {
+			if (this.operations.get(owner) === operation) this.operations.delete(owner);
+		}
+	}
+	async executeInput(owner, input, signal) {
+		signal.throwIfAborted();
+		const config = this.getConfig();
+		if (!config.computer.enabled) {
+			await this.close(owner);
+			throw new Error("COMPUTER_DISABLED");
+		}
+		let s = this.sessions.get(owner);
+		if (input.op === "discover") {
+			const endpoint = this.resolveEndpoint(owner);
+			const id = randomUUID();
+			const reply = await this.send({
+				endpointId: endpoint.endpointId,
+				id
+			}, {
+				op: "discover",
+				sessionId: id,
+				owner,
+				query: input.query
+			}, signal);
+			reply.frame?.fill(0);
+			return this.present(reply.value);
+		}
+		if (input.op === "open" && !s) {
+			const endpoint = this.resolveEndpoint(owner);
+			const effective = resolveEffectiveAgentConfigForSession(config, owner).config;
+			const ref = effective.models.computerUse?.primary;
+			if (!ref) throw new Error("COMPUTER_MODEL_REQUIRED");
+			const model = resolveModel(ref);
+			const profile = computerModelProfile(model);
+			if (!profile) throw new Error("COMPUTER_MODEL_CAPABILITY_REQUIRED");
+			const apiKey = await getApiKey(model.provider, {
+				agentId: effective.id,
+				appConfig: config
+			});
+			if (!apiKey) throw new Error("COMPUTER_MODEL_KEY_MISSING");
+			let deployment;
+			if (model.provider === "xopc-cloud") {
+				const response = await fetch(`${model.baseUrl.replace(/\/$/, "")}/models`, {
+					headers: { Authorization: `Bearer ${apiKey}` },
+					redirect: "error",
+					signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15e3)]) : AbortSignal.timeout(15e3)
+				});
+				if (!response.ok) {
+					await response.body?.cancel();
+					throw new Error("COMPUTER_DEPLOYMENT_UNAVAILABLE");
+				}
+				const body = await readComputerJson(response, 2 * 1024 * 1024);
+				deployment = 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);
+			}
+			const adapter = new ComputerModelAdapter({
+				modelId: model.id,
+				baseUrl: model.baseUrl,
+				apiKey,
+				profile,
+				headers: model.headers,
+				deploymentRevision: deployment?.revision
+			});
+			signal.throwIfAborted();
+			s = {
+				id: randomUUID(),
+				owner,
+				appRef: input.appRef,
+				mode: input.mode,
+				prepare: input.prepare,
+				windowRef: input.windowRef,
+				endpointId: endpoint.endpointId,
+				adapter,
+				binding: {
+					modelRef: ref,
+					profile,
+					origin: new URL(model.baseUrl).origin,
+					runtimeLocation: "unknown",
+					...deployment ? { upstreamOrigin: deployment.origin } : {}
+				},
+				createdAt: Date.now(),
+				actions: 0,
+				modelRequests: 0,
+				controller: new AbortController()
+			};
+			this.sessions.set(owner, s);
+			enterComputerControl(owner, () => this.close(owner));
+		}
+		if (!s) throw new Error("COMPUTER_OPEN_REQUIRED");
+		signal = signal ? AbortSignal.any([signal, s.controller.signal]) : s.controller.signal;
+		if (Date.now() - s.createdAt >= config.computer.maxSessionDurationMs) {
+			await this.close(owner);
+			throw new Error("COMPUTER_SESSION_BUDGET");
+		}
+		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");
+				const reply = await this.send(s, {
+					op: "open",
+					sessionId: s.id,
+					owner,
+					appRef: s.appRef,
+					mode: s.mode,
+					prepare: s.prepare,
+					...s.windowRef ? { windowRef: s.windowRef } : {},
+					model: s.binding
+				}, signal);
+				if (reply.value.status === "stopped") await this.close(owner);
+				return this.present(reply.value);
+			}
+			const status = await this.send(s, {
+				op: "status",
+				sessionId: s.id,
+				owner
+			}, signal);
+			if (status.value.status === "stopped") {
+				this.sessions.delete(owner);
+				leaveComputerControl(owner);
+				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);
+				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",
+					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);
+			}
+		} catch (error) {
+			await this.close(owner);
+			throw error;
+		}
+	}
+	async dispatchAction(s, envelope, signal) {
+		if (!s.pending) {
+			if (s.actions >= this.getConfig().computer.maxActionsPerSession) throw new Error("COMPUTER_ACTION_BUDGET");
+			s.actions++;
+			s.pending = envelope;
+		}
+		const reply = await this.send(s, {
+			op: "act",
+			sessionId: s.id,
+			owner: s.owner,
+			envelope
+		}, 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);
+	}
+	present(reply) {
+		return {
+			status: reply.status,
+			sessionId: reply.sessionId,
+			...reply.errorCode ? {
+				errorCode: reply.errorCode,
+				nextAction: computerRecovery(reply.errorCode)
+			} : {},
+			...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."
+			} : {},
+			...reply.windows ? { windows: reply.windows } : {},
+			pending: [
+				"pending_authorization",
+				"pending_action",
+				"paused"
+			].includes(reply.status),
+			...reply.status === "pending_action" ? { summary: "The exact action is held and has NOT executed. After local confirmation, call computer_use with {\"op\":\"step\",\"goal\":\"Resume the approved action\"}. This resumes the same action without another model prediction. Do not call observe to resume; observe never executes pending input." } : {},
+			...reply.status === "pending_authorization" ? { summary: "After local authorization, call {\"op\":\"observe\"} to check readiness. Do not add appId or sessionId to observe." } : {},
+			...reply.observation ? {
+				summary: reply.observation.summary,
+				observation: {
+					id: reply.observation.id,
+					width: reply.observation.imageWidth,
+					height: reply.observation.imageHeight
+				}
+			} : {},
+			...reply.receipt ? { receipt: reply.receipt } : {}
+		};
+	}
+	resolveEndpoint(owner) {
+		const explicitBinding = this.endpoints.bindings.get(owner);
+		const turnEndpoint = this.getTurnEndpoint?.(owner);
+		const endpoint = explicitBinding ? this.endpoints.bindings.resolve(owner) : turnEndpoint ? this.endpoints.registry.get(turnEndpoint) : this.endpoints.bindings.resolve(owner);
+		if (!endpoint || endpoint.kind !== "desktop") throw new Error("COMPUTER_DESKTOP_BINDING_REQUIRED");
+		return endpoint;
+	}
+	async send(s, command, signal) {
+		signal?.throwIfAborted();
+		const tool = this.endpoints.registry.getTool(s.endpointId, COMPUTER_CONTROL_TOOL);
+		if (!tool) throw new Error("COMPUTER_DESKTOP_UPGRADE_REQUIRED");
+		const reply = await this.endpoints.invocations.invoke({
+			endpointId: s.endpointId,
+			toolCallId: randomUUID(),
+			toolName: COMPUTER_CONTROL_TOOL,
+			arguments: command,
+			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) {
+			frame?.fill(0);
+			signal.throwIfAborted();
+		}
+		return {
+			value,
+			frame,
+			mimeType: file?.type === "file" ? file.mimeType : void 0
+		};
+	}
+	async close(owner) {
+		this.operations.get(owner)?.abort();
+		const s = this.sessions.get(owner);
+		if (!s) return;
+		this.sessions.delete(owner);
+		leaveComputerControl(owner);
+		s.controller.abort();
+		try {
+			await this.send(s, {
+				op: "release",
+				sessionId: s.id,
+				owner
+			});
+		} catch {}
+	}
+	async shutdown() {
+		await Promise.all([...new Set([...this.sessions.keys(), ...this.operations.keys()])].map((owner) => this.close(owner)));
+	}
+};
+//#endregion
+export { ComputerRuntime, ComputerUseInputSchema };

package/dist/src/config/agent-profile.d.ts

@@ -17,8 +17,8 @@ export interface EffectiveAgentProfile {
     tools: EffectiveAgentTools;
     params: Record<string, unknown>;
 }
-export declare function extractProfileAgentId(sessionKey: string | undefined | null, config: Config): string;
+export declare function extractProfileAgentId(conversationId: string | undefined | null, config: Config): string;
 export declare function resolveEffectiveAgentConfigForAgent(config: Config, agentId: string): ResolveEffectiveAgentConfigResult;
-export declare function resolveEffectiveAgentConfigForSession(config: Config, sessionKey: string | undefined | null): ResolveEffectiveAgentConfigResult;
+export declare function resolveEffectiveAgentConfigForSession(config: Config, conversationId: string | undefined | null): ResolveEffectiveAgentConfigResult;
 export declare function resolveEffectiveAgentProfile(config: Config, agentId: string): EffectiveAgentProfile;
-export declare function resolveEffectiveAgentProfileForSession(config: Config, sessionKey: string | undefined | null): EffectiveAgentProfile;
+export declare function resolveEffectiveAgentProfileForSession(config: Config, conversationId: string | undefined | null): EffectiveAgentProfile;

package/dist/src/config/agent-profile.js

@@ -1,7 +1,8 @@
 import { resolveEffectiveAgentConfig } from "../agent-config/resolver.js";
 import { init_agent_config } from "../agent-config/index.js";
 import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
-import { init_session_key, parseSessionKey } from "../routing/session-key.js";
+import { getConversationRouting } from "../storage/sqlite/conversation-repository.js";
+import { init_session_key } from "../routing/session-key.js";
 import { agentExists, getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 //#region src/config/agent-profile.ts
 init_agent_config();
@@ -12,15 +13,14 @@ function findAgent(config, agentId) {
 	const id = normalizeAgentId(agentId);
 	return config.agents.list.find((agent) => agent.enabled !== false && normalizeAgentId(agent.id) === id);
 }
-function extractProfileAgentId(sessionKey, config) {
-	const parsed = parseSessionKey(sessionKey ?? "");
-	if (!parsed) return getDefaultAgentId(config);
-	const id = parsed.agentId;
-	if (id === "subagent" || id.startsWith("subagent:") || !agentExists(id, config)) return getDefaultAgentId(config);
-	return id.toLowerCase();
+function extractProfileAgentId(conversationId, config) {
+	if (!conversationId) return getDefaultAgentId(config);
+	const routing = getConversationRouting(conversationId);
+	if (!routing || !agentExists(routing.agentId, config)) throw new Error(`Conversation agent is unavailable: ${conversationId}`);
+	return routing.agentId;
 }
 function resolveEffectiveAgentConfigForAgent(config, agentId) {
-	const agent = findAgent(config, agentId) ?? findAgent(config, getDefaultAgentId(config));
+	const agent = findAgent(config, agentId);
 	if (!agent) throw new Error(`No enabled agent found for "${agentId}"`);
 	return resolveEffectiveAgentConfig({
 		agent,
@@ -28,8 +28,8 @@ function resolveEffectiveAgentConfigForAgent(config, agentId) {
 		defaultWorkspace: (id) => resolveAgentWorkspaceDir(config, id)
 	});
 }
-function resolveEffectiveAgentConfigForSession(config, sessionKey) {
-	return resolveEffectiveAgentConfigForAgent(config, extractProfileAgentId(sessionKey, config));
+function resolveEffectiveAgentConfigForSession(config, conversationId) {
+	return resolveEffectiveAgentConfigForAgent(config, extractProfileAgentId(conversationId, config));
 }
 function resolveEffectiveAgentProfile(config, agentId) {
 	const resolved = resolveEffectiveAgentConfigForAgent(config, agentId);
@@ -51,8 +51,8 @@ function resolveEffectiveAgentProfile(config, agentId) {
 		params: {}
 	};
 }
-function resolveEffectiveAgentProfileForSession(config, sessionKey) {
-	return resolveEffectiveAgentProfile(config, extractProfileAgentId(sessionKey, config));
+function resolveEffectiveAgentProfileForSession(config, conversationId) {
+	return resolveEffectiveAgentProfile(config, extractProfileAgentId(conversationId, config));
 }
 //#endregion
 export { extractProfileAgentId, resolveAgentWorkspaceDir, resolveEffectiveAgentConfigForAgent, resolveEffectiveAgentConfigForSession, resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession };

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 { applyConfigOverrides, getConfigOverrides, resetConfigOverrides, setConfigOverride, unsetConfigOverride } from "./runtime-overrides.js";
+import { clearConfigValueCache, getAllowedCommands, getCacheStats, init_resolve_config_value, resolveConfigValue, resolveHeaders, testApiKeyResolution } from "./resolve-config-value.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 { init_loader, loadConfig, saveConfig } from "./loader.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 { 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 { 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_paths, resolveConfigPath } from "./paths.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_paths, resolveConfigPath } from "./paths.js";
 import { init_resolution, setActivePlatformDiscovery } from "../platform/resolution.js";
+import { assertChannelPluginConfigs, init_validate_channel_configs } from "./validate-channel-configs.js";
 import { dirname } from "path";
 import { existsSync, mkdirSync, promises, readFileSync } from "fs";
 import { config } from "dotenv";

package/dist/src/config/models-json.d.ts

@@ -262,6 +262,12 @@ export declare const ImageGenerationProviderSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const CustomModelSchema: z.ZodObject<{
+    computerUse: z.ZodOptional<z.ZodObject<{
+        profile: z.ZodEnum<{
+            "gui-plus-2026-02-26": "gui-plus-2026-02-26";
+            "structured-tools-v1": "structured-tools-v1";
+        }>;
+    }, z.core.$strict>>;
     id: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
     api: z.ZodOptional<z.ZodEnum<{
@@ -286,8 +292,8 @@ export declare const CustomModelSchema: z.ZodObject<{
         max: "max";
     }> & z.core.$partial, z.ZodNullable<z.ZodString>>>;
     input: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        image: "image";
         text: "text";
+        image: "image";
     }>>>;
     contextWindow: z.ZodOptional<z.ZodNumber>;
     maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -337,6 +343,12 @@ export declare const CustomModelSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>]>>;
 }, z.core.$strip>;
 export declare const ModelOverrideSchema: z.ZodObject<{
+    computerUse: z.ZodOptional<z.ZodObject<{
+        profile: z.ZodEnum<{
+            "gui-plus-2026-02-26": "gui-plus-2026-02-26";
+            "structured-tools-v1": "structured-tools-v1";
+        }>;
+    }, z.core.$strict>>;
     name: z.ZodOptional<z.ZodString>;
     reasoning: z.ZodOptional<z.ZodBoolean>;
     thinkingLevelMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
@@ -349,8 +361,8 @@ export declare const ModelOverrideSchema: z.ZodObject<{
         max: "max";
     }> & z.core.$partial, z.ZodNullable<z.ZodString>>>;
     input: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        image: "image";
         text: "text";
+        image: "image";
     }>>>;
     contextWindow: z.ZodOptional<z.ZodNumber>;
     maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -416,6 +428,12 @@ export declare const ProviderConfigSchema: z.ZodObject<{
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     authHeader: z.ZodOptional<z.ZodBoolean>;
     models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        computerUse: z.ZodOptional<z.ZodObject<{
+            profile: z.ZodEnum<{
+                "gui-plus-2026-02-26": "gui-plus-2026-02-26";
+                "structured-tools-v1": "structured-tools-v1";
+            }>;
+        }, z.core.$strict>>;
         id: z.ZodString;
         name: z.ZodOptional<z.ZodString>;
         api: z.ZodOptional<z.ZodEnum<{
@@ -440,8 +458,8 @@ export declare const ProviderConfigSchema: z.ZodObject<{
             max: "max";
         }> & z.core.$partial, z.ZodNullable<z.ZodString>>>;
         input: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            image: "image";
             text: "text";
+            image: "image";
         }>>>;
         contextWindow: z.ZodOptional<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -491,6 +509,12 @@ export declare const ProviderConfigSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>]>>;
     }, z.core.$strip>>>;
     modelOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        computerUse: z.ZodOptional<z.ZodObject<{
+            profile: z.ZodEnum<{
+                "gui-plus-2026-02-26": "gui-plus-2026-02-26";
+                "structured-tools-v1": "structured-tools-v1";
+            }>;
+        }, z.core.$strict>>;
         name: z.ZodOptional<z.ZodString>;
         reasoning: z.ZodOptional<z.ZodBoolean>;
         thinkingLevelMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
@@ -503,8 +527,8 @@ export declare const ProviderConfigSchema: z.ZodObject<{
             max: "max";
         }> & z.core.$partial, z.ZodNullable<z.ZodString>>>;
         input: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            image: "image";
             text: "text";
+            image: "image";
         }>>>;
         contextWindow: z.ZodOptional<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -651,6 +675,12 @@ export declare const ModelsJsonSchema: z.ZodObject<{
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         authHeader: z.ZodOptional<z.ZodBoolean>;
         models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            computerUse: z.ZodOptional<z.ZodObject<{
+                profile: z.ZodEnum<{
+                    "gui-plus-2026-02-26": "gui-plus-2026-02-26";
+                    "structured-tools-v1": "structured-tools-v1";
+                }>;
+            }, z.core.$strict>>;
             id: z.ZodString;
             name: z.ZodOptional<z.ZodString>;
             api: z.ZodOptional<z.ZodEnum<{
@@ -675,8 +705,8 @@ export declare const ModelsJsonSchema: z.ZodObject<{
                 max: "max";
             }> & z.core.$partial, z.ZodNullable<z.ZodString>>>;
             input: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                image: "image";
                 text: "text";
+                image: "image";
             }>>>;
             contextWindow: z.ZodOptional<z.ZodNumber>;
             maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -726,6 +756,12 @@ export declare const ModelsJsonSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>]>>;
         }, z.core.$strip>>>;
         modelOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            computerUse: z.ZodOptional<z.ZodObject<{
+                profile: z.ZodEnum<{
+                    "gui-plus-2026-02-26": "gui-plus-2026-02-26";
+                    "structured-tools-v1": "structured-tools-v1";
+                }>;
+            }, z.core.$strict>>;
             name: z.ZodOptional<z.ZodString>;
             reasoning: z.ZodOptional<z.ZodBoolean>;
             thinkingLevelMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
@@ -738,8 +774,8 @@ export declare const ModelsJsonSchema: z.ZodObject<{
                 max: "max";
             }> & z.core.$partial, z.ZodNullable<z.ZodString>>>;
             input: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                image: "image";
                 text: "text";
+                image: "image";
             }>>>;
             contextWindow: z.ZodOptional<z.ZodNumber>;
             maxTokens: z.ZodOptional<z.ZodNumber>;