@xopcai/xopc 0.0.308 → 0.0.311

package/dist/src/agent/workflow/subagent-runner.js

@@ -2,7 +2,9 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { createSqliteTranscriptRuntime } from "../embedded/transcript-runtime.js";
 import { createDelegateChildHandle } from "../child-agent-factory.js";
-import { DEFAULT_DELEGATE_TOOLS, DELEGATE_BLOCKED_TOOLS } from "../tools/delegate-tool.js";
+import { DELEGATION_TOOL_CAPABILITIES, protectDelegatedTool, resolveDelegationTools } from "../tools/delegation-policy.js";
+import { DELEGATE_BLOCKED_TOOLS } from "../tools/delegate-tool.js";
+import { createDelegationParentPolicy } from "../tools/delegation-parent-policy.js";
 import { STRUCTURED_OUTPUT_TOOL_NAME, createStructuredOutputTool } from "./structured-output-tool.js";
 //#region src/agent/workflow/subagent-runner.ts
 init_logger();
@@ -38,11 +40,27 @@ var DelegateSubagentRunner = class {
 			agentId: this.deps.agentId,
 			getConfig: this.deps.getConfig,
 			toolExecutorConfig: this.deps.toolExecutorConfig,
+			authorizeToolCall: createDelegationParentPolicy({
+				getConfig: this.deps.getConfig,
+				conversationId: opts.sessionMetadata?.parentConversationId,
+				agentId: this.deps.agentId
+			}).beforeToolCall,
 			buildChildTools: (childOpts) => {
-				const base = this.deps.buildChildTools({
+				const candidates = this.deps.buildChildTools({
 					...childOpts,
 					agentId: this.deps.agentId ?? childOpts.agentId
 				});
+				const access = resolveDelegationTools(candidates.map((tool) => tool.name), "custom", opts.allowedToolNames, [
+					"local_read",
+					"web_read",
+					"knowledge_read",
+					"skills_read",
+					"external_read",
+					...opts.allowedToolNames?.includes("browser_use") ? ["browser"] : []
+				]);
+				if (access.rejected.length) throw new Error(`Workflow delegation rejected tools: ${JSON.stringify(access.rejected)}. Use delegate_task implement for isolated writes and commands.`);
+				const granted = new Set(access.granted);
+				const base = candidates.filter((tool) => granted.has(tool.name)).map(protectDelegatedTool);
 				if (!wantStructured || !opts.schema) return base;
 				return [...base.filter((t) => t.name !== STRUCTURED_OUTPUT_TOOL_NAME), createStructuredOutputTool({
 					schema: opts.schema,
@@ -129,7 +147,11 @@ var DelegateSubagentRunner = class {
 	}
 };
 function resolveAllowedToolNames(requested, wantStructured) {
-	const filtered = (requested ?? [...DEFAULT_DELEGATE_TOOLS]).map((s) => String(s).trim()).filter((s) => s.length > 0).filter((s) => !DELEGATE_BLOCKED_TOOLS.has(s));
+	const filtered = (requested ?? Object.keys(DELEGATION_TOOL_CAPABILITIES).filter((name) => ![
+		"local_write",
+		"command",
+		"browser"
+	].includes(DELEGATION_TOOL_CAPABILITIES[name]))).map((s) => String(s).trim()).filter((s) => s.length > 0).filter((s) => !DELEGATE_BLOCKED_TOOLS.has(s));
 	if (wantStructured && !filtered.includes("structured_output")) filtered.push(STRUCTURED_OUTPUT_TOOL_NAME);
 	return [...new Set(filtered)];
 }

package/dist/src/agent/workflow/workflow-child-tools.js

@@ -1,13 +1,22 @@
-import { EXTERNAL_TOOL_NAMES } from "../external-tools/gateway-tools.js";
-import "../external-tools/index.js";
+import { resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { AgentToolsFactory } from "../tools/factory.js";
 //#region src/agent/workflow/workflow-child-tools.ts
 /** Builds the tool set for workflow child agents (wired from gateway to avoid cycles). */
 function buildWorkflowChildTools(childOptions) {
+	const config = childOptions.getConfig();
+	const profile = config ? childOptions.browserConversationId ? resolveEffectiveAgentProfileForSession(config, childOptions.browserConversationId) : childOptions.agentId ? resolveEffectiveAgentProfile(config, childOptions.agentId) : resolveEffectiveAgentProfileForSession(config, void 0) : void 0;
 	return new AgentToolsFactory({
 		workspace: childOptions.workspace,
 		bus: childOptions.bus,
-		getCurrentContext: () => null,
+		getCurrentContext: () => childOptions.browserConversationId ? {
+			conversationId: childOptions.browserConversationId,
+			channel: "workflow",
+			chatId: childOptions.browserConversationId,
+			origin: {
+				type: "system",
+				source: "workflow"
+			}
+		} : null,
 		getConfig: childOptions.getConfig,
 		getPrimaryModel: () => childOptions.model,
 		endpointTools: childOptions.endpointTools,
@@ -17,11 +26,7 @@ function buildWorkflowChildTools(childOptions) {
 		getPrimaryModel: () => childOptions.model,
 		agentId: childOptions.agentId,
 		conversationId: childOptions.browserConversationId,
-		disabledTools: new Set([
-			EXTERNAL_TOOL_NAMES.search,
-			EXTERNAL_TOOL_NAMES.describe,
-			EXTERNAL_TOOL_NAMES.execute
-		])
+		disabledTools: profile?.tools.denied
 	});
 }
 //#endregion

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

@@ -96,6 +96,7 @@ export declare const ToolPolicySchema: z.ZodObject<{
         deny: "deny";
         ask: "ask";
     }>;
+    readOnly: z.ZodOptional<z.ZodBoolean>;
     maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
@@ -105,6 +106,7 @@ export declare const ToolPoliciesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
         deny: "deny";
         ask: "ask";
     }>;
+    readOnly: z.ZodOptional<z.ZodBoolean>;
     maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>>;
@@ -198,6 +200,7 @@ export declare const AgentDefaultsSchema: z.ZodObject<{
             deny: "deny";
             ask: "ask";
         }>;
+        readOnly: z.ZodOptional<z.ZodBoolean>;
         maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
@@ -289,6 +292,7 @@ export declare const AgentEntrySchema: z.ZodObject<{
             deny: "deny";
             ask: "ask";
         }>;
+        readOnly: z.ZodOptional<z.ZodBoolean>;
         maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
@@ -370,6 +374,7 @@ export declare const AgentsConfigSchema: z.ZodObject<{
                 deny: "deny";
                 ask: "ask";
             }>;
+            readOnly: z.ZodOptional<z.ZodBoolean>;
             maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
             timeoutMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>>;
@@ -457,6 +462,7 @@ export declare const AgentsConfigSchema: z.ZodObject<{
                 deny: "deny";
                 ask: "ask";
             }>;
+            readOnly: z.ZodOptional<z.ZodBoolean>;
             maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
             timeoutMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>>;
@@ -544,6 +550,7 @@ export declare const EffectiveAgentConfigSchema: z.ZodObject<{
             deny: "deny";
             ask: "ask";
         }>;
+        readOnly: z.ZodOptional<z.ZodBoolean>;
         maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;

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

@@ -49,6 +49,8 @@ var init_schema = __esmMin((() => {
 	]);
 	ToolPolicySchema = z.object({
 		mode: ToolModeSchema,
+		/** Host assertion for external tools; remote annotations alone cannot grant read access. */
+		readOnly: z.boolean().optional(),
 		maxCallsPerTurn: z.number().int().positive().optional(),
 		timeoutMs: z.number().int().positive().optional()
 	}).strict();

package/dist/src/automations/service/automation-service.d.ts

@@ -1,4 +1,3 @@
-import type { ProactiveSignalPublisher } from '../../proactive/events/publisher.js';
 import type { Automation, AutomationDeps, AutomationEvent, AutomationMetrics, AutomationProductEventRun, AutomationRun, AutomationRunEvent } from '../domain/types.js';
 import { type CreateAutomationInput, type UpdateAutomationInput } from '../domain/validation.js';
 export declare class AutomationAlreadyRunningError extends Error {
@@ -7,8 +6,6 @@ export declare class AutomationAlreadyRunningError extends Error {
     constructor(automationId: string, runningRunId?: string);
 }
 export declare class AutomationService {
-    private readonly signals?;
-    private readonly workspaceId;
     private readonly executor;
     private timer;
     private stopped;
@@ -18,7 +15,6 @@ export declare class AutomationService {
     private readonly activeRuns;
     private readonly heartbeatTimers;
     private readonly leaseOwner;
-    constructor(signals?: ProactiveSignalPublisher, workspaceId?: string);
     setDeps(deps: AutomationDeps): void;
     initialize(options?: {
         maxConcurrentRuns?: number;

package/dist/src/automations/service/automation-service.js

@@ -41,10 +41,6 @@ var AutomationService = class {
 	activeRuns = /* @__PURE__ */ new Map();
 	heartbeatTimers = /* @__PURE__ */ new Map();
 	leaseOwner = `automation-service:${process.pid}:${randomUUID()}`;
-	constructor(signals, workspaceId = "default") {
-		this.signals = signals;
-		this.workspaceId = workspaceId;
-	}
 	setDeps(deps) {
 		this.deps = {
 			...this.deps,
@@ -458,33 +454,6 @@ var AutomationService = class {
 					error
 				});
 				this.finishAutomationRun(automation.id, status, error, endedAtMs);
-				if (status === "failed" || status === "timeout") this.signals?.publish({
-					type: "automation.run_failed.v1",
-					schemaVersion: 1,
-					source: {
-						kind: "automations",
-						id: automation.id
-					},
-					subject: {
-						kind: "automation_run",
-						id: run.id
-					},
-					actor: { kind: "system" },
-					scope: {
-						workspaceId: this.workspaceId,
-						...automation.projectId ? { projectId: automation.projectId } : {}
-					},
-					occurredAt: new Date(endedAtMs).toISOString(),
-					dedupeKey: `automation_run:${run.id}:failed`,
-					sensitivity: "personal",
-					payload: {
-						automationId: automation.id,
-						status,
-						error,
-						summary: run.summary,
-						durationMs: run.durationMs
-					}
-				});
 			});
 			try {
 				this.deps.onRunCompleted?.(run);

package/dist/src/capabilities/store-connector.js

@@ -1,3 +1,4 @@
+import { getCliAdapter } from "../connectors/cli/adapterRegistry.js";
 import { downloadConnectorStoreZipBuffer, fetchStoreConnectorPackageDetail, listConnectorPackages, resolveSkillsStoreBaseUrl } from "../agent/skills/marketplace/adapters/store/store-api-client.js";
 import { installConnectorDefinition } from "../connectors/install.js";
 import { createHash } from "node:crypto";
@@ -146,6 +147,51 @@ function readConnectorManifest(value, packageName, version, sha256) {
 	if (manifest.contractVersion !== 1) throw new Error("Store connector manifest must use contractVersion 1.");
 	if (asString(manifest.id, "Connector id") !== packageName) throw new Error("Connector manifest id does not match the store package name.");
 	const runtime = asRecord(manifest.runtime, "Connector runtime");
+	if (runtime.type === "cli") {
+		const adapter = getCliAdapter(asString(runtime.adapterId, "CLI adapter id"));
+		if (runtime.adapterVersion !== adapter.version || runtime.binaryVersion !== adapter.binaryVersion || Object.keys(runtime).some((key) => ![
+			"type",
+			"adapterId",
+			"adapterVersion",
+			"binaryVersion"
+		].includes(key))) throw new Error("Store CLI runtime must reference an exact registered adapter.");
+		if (asRecord(manifest.auth, "Connector auth").mode !== "cli") throw new Error("CLI connectors require managed CLI authorization.");
+		const { setup, keys } = readSetup(manifest.setup);
+		if (keys.size) throw new Error("CLI credentials are managed through authorization.");
+		const category = asString(manifest.category, "Connector category");
+		if (![
+			"code",
+			"docs",
+			"browser",
+			"data",
+			"automation",
+			"custom"
+		].includes(category)) throw new Error("Unsupported connector category.");
+		if (asStringArray(manifest.capabilities, "Connector capabilities").some((value) => value !== "tools")) throw new Error("CLI connectors support tools only.");
+		return {
+			id: packageName,
+			version,
+			displayName: asString(manifest.displayName, "Connector displayName"),
+			description: asString(manifest.description, "Connector description"),
+			category,
+			kind: "cli",
+			source: "store",
+			capabilities: ["tools"],
+			auth: { mode: "cli" },
+			setup,
+			runtime: {
+				type: "cli",
+				adapterId: adapter.id,
+				adapterVersion: adapter.version,
+				binaryVersion: adapter.binaryVersion
+			},
+			permissions: readPermissions(manifest.permissions, true),
+			provenance: {
+				packageName,
+				sha256
+			}
+		};
+	}
 	if (runtime.type !== "mcp") throw new Error("Store connectors must use the MCP runtime.");
 	const serverTemplate = asRecord(runtime.serverTemplate, "Connector MCP serverTemplate");
 	const localPackage = readPinnedLocalRuntime(runtime, serverTemplate);

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 v185).`,
+		message: `SQLite schema v${status.dbVersion} (current release v189).`,
 		hints: []
 	};
 }

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

@@ -1,5 +1,5 @@
 import { closeXopcDatabase, isXopcDatabaseOpen, openXopcDatabase } from "../../storage/sqlite/connection.js";
-import { getSessionMetadata } from "../../storage/sqlite/session-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";

package/dist/src/config/schema.d.ts

@@ -100,6 +100,7 @@ export declare const AgentsConfigSchema: z.ZodDefault<z.ZodObject<{
                 deny: "deny";
                 ask: "ask";
             }>;
+            readOnly: z.ZodOptional<z.ZodBoolean>;
             maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
             timeoutMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>>;
@@ -187,6 +188,7 @@ export declare const AgentsConfigSchema: z.ZodDefault<z.ZodObject<{
                 deny: "deny";
                 ask: "ask";
             }>;
+            readOnly: z.ZodOptional<z.ZodBoolean>;
             maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
             timeoutMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>>;
@@ -839,7 +841,7 @@ export declare const GatewayConfigSchema: z.ZodDefault<z.ZodObject<{
             allowLoopback: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>>;
     }, z.core.$strip>>>;
-    heartbeat: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+    heartbeat: z.ZodPreprocess<z.ZodOptional<z.ZodDefault<z.ZodObject<{
         enabled: z.ZodBoolean;
         intervalMs: z.ZodNumber;
         includeSystemPromptSection: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -853,7 +855,7 @@ export declare const GatewayConfigSchema: z.ZodDefault<z.ZodObject<{
             end: z.ZodString;
             timezone: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
-    }, z.core.$strip>>>;
+    }, z.core.$strip>>>>;
     webchat: z.ZodOptional<z.ZodDefault<z.ZodObject<{
         activityDetailDefault: z.ZodDefault<z.ZodEnum<{
             stream: "stream";
@@ -1610,6 +1612,7 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                     deny: "deny";
                     ask: "ask";
                 }>;
+                readOnly: z.ZodOptional<z.ZodBoolean>;
                 maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
                 timeoutMs: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>>;
@@ -1697,6 +1700,7 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                     deny: "deny";
                     ask: "ask";
                 }>;
+                readOnly: z.ZodOptional<z.ZodBoolean>;
                 maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
                 timeoutMs: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>>;
@@ -1879,7 +1883,7 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 allowLoopback: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>;
         }, z.core.$strip>>>;
-        heartbeat: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        heartbeat: z.ZodPreprocess<z.ZodOptional<z.ZodDefault<z.ZodObject<{
             enabled: z.ZodBoolean;
             intervalMs: z.ZodNumber;
             includeSystemPromptSection: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -1893,7 +1897,7 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 end: z.ZodString;
                 timezone: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
-        }, z.core.$strip>>>;
+        }, z.core.$strip>>>>;
         webchat: z.ZodOptional<z.ZodDefault<z.ZodObject<{
             activityDetailDefault: z.ZodDefault<z.ZodEnum<{
                 stream: "stream";

package/dist/src/config/schema.js

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { ComputerConfigSchema, init_config } from "../computer/config.js";
 import { AgentModelsOverrideSchema, AgentsConfigSchema as AgentsConfigSchema$1, DEFAULT_AGENT_MODEL_REF, ImageGenerationRouteSchema, ModelRouteSchema } from "../agent-config/schema.js";
 import { init_agent_config } from "../agent-config/index.js";
-import { ComputerConfigSchema, init_config } from "../computer/config.js";
 import { DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, init_config as init_config$1 } from "../user-context/config.js";
 import { init_default_model } from "./default-model.js";
 import { init_public_url, validatePublicUrl } from "./public-url.js";
@@ -497,7 +497,7 @@ activityDetailDefault: z.enum([
 		tailscale: GatewayTailscaleSchema.optional(),
 		tls: GatewayTlsSchema.optional(),
 		auth: GatewayAuthSchema.optional(),
-		heartbeat: HeartbeatConfigSchema.optional(),
+		heartbeat: z.preprocess(() => void 0, HeartbeatConfigSchema.optional()),
 		webchat: GatewayWebchatConfigSchema.optional(),
 		corsOrigins: z.array(z.string()).optional(),
 		/**
@@ -684,11 +684,6 @@ activityDetailDefault: z.enum([
 		bind: "loopback",
 		port: 18790,
 		auth: { mode: "token" },
-		heartbeat: {
-			enabled: true,
-			intervalMs: 18e5,
-			includeSystemPromptSection: false
-		},
 		webchat: { activityDetailDefault: "on" },
 		corsOrigins: [],
 		skillsMarketplaceProvider: "store",
@@ -1149,11 +1144,6 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 			bind: "loopback",
 			port: 18790,
 			auth: { mode: "token" },
-			heartbeat: {
-				enabled: true,
-				intervalMs: 18e5,
-				includeSystemPromptSection: false
-			},
 			webchat: { activityDetailDefault: "on" },
 			corsOrigins: [],
 			skillsMarketplaceProvider: "store",

package/dist/src/config/web-patch.js

@@ -88,11 +88,6 @@ function mergeGatewaySkillsMarketplacePatch(config, patch) {
 		bind: "loopback",
 		port: 18790,
 		auth: { mode: "token" },
-		heartbeat: {
-			enabled: true,
-			intervalMs: 18e5,
-			includeSystemPromptSection: false
-		},
 		corsOrigins: []
 	};
 	if (parsed.data.skillsMarketplaceProvider !== void 0) config.gateway.skillsMarketplaceProvider = parsed.data.skillsMarketplaceProvider.trim();

package/dist/src/connectors/account-selection.d.ts

@@ -0,0 +1,14 @@
+import { listConnectorConnections } from '../storage/sqlite/connector-repository.js';
+import type { ConnectorInstallationPolicy } from './types.js';
+/** Resolve one explicitly allowed account without falling back from an unavailable selection. */
+export declare function selectConnectorAccount(input: {
+    installation: ConnectorInstallationPolicy;
+    agentId?: string;
+    conversationId?: string;
+    requestedAccountId?: string;
+    accept?: (connection: ReturnType<typeof listConnectorConnections>[number]) => boolean;
+}): {
+    connection: import("./types.js").ConnectorConnection;
+    candidates: import("./types.js").ConnectorConnection[];
+    requestedAccountId: string;
+};

package/dist/src/connectors/account-selection.js

@@ -0,0 +1,26 @@
+import { init_connector_repository, listConnectorConnections } from "../storage/sqlite/connector-repository.js";
+import { bindObjectiveAccount, connectionBindings, init_connection_wait_repository } from "../storage/sqlite/connection-wait-repository.js";
+import { canAccessConnectorAccount, currentAccountConnections } from "./account-access.js";
+//#region src/connectors/account-selection.ts
+init_connection_wait_repository();
+init_connector_repository();
+/** Resolve one explicitly allowed account without falling back from an unavailable selection. */
+function selectConnectorAccount(input) {
+	const { installation } = input;
+	const candidates = currentAccountConnections(listConnectorConnections({
+		principalId: installation.principalId,
+		connectorId: installation.connectorId
+	}).filter((connection) => connection.status === "active" && canAccessConnectorAccount(connection, installation, input.agentId) && (!input.accept || input.accept(connection))));
+	const bindings = input.conversationId ? connectionBindings(input.conversationId).filter((binding) => binding.connectorId === installation.connectorId) : [];
+	const requested = input.requestedAccountId ?? (bindings.length === 1 ? bindings[0]?.accountId : void 0);
+	if (requested && bindings.length && !bindings.some((binding) => binding.accountId === requested)) throw new Error("This account is not selected for the current objective.");
+	const connection = requested ? candidates.find((candidate) => candidate.accountId === requested) : bindings.length > 1 ? void 0 : candidates.length === 1 ? candidates[0] : void 0;
+	if (connection?.accountId && input.conversationId) bindObjectiveAccount(input.conversationId, installation.connectorId, connection.accountId);
+	return {
+		connection,
+		candidates,
+		requestedAccountId: requested
+	};
+}
+//#endregion
+export { selectConnectorAccount };