@xopcai/xopc 0.0.250 → 0.0.252

package/dist/src/gateway/hono/routes/lazy-bundles.js

@@ -53,18 +53,18 @@ const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
 	},
 	{
 		id: "browser-install",
-		match: (path) => path === "/api/browser/playwright/install/stream" || path === "/api/browser/cloakbrowser/install/stream",
+		match: (path) => path === "/api/browser/playwright/install/stream",
 		load: async () => {
 			const { registerBrowserInstallRoutes } = await import("./browser-install.js");
 			return { register: registerBrowserInstallRoutes };
 		}
 	},
 	{
-		id: "browser-workflows",
-		match: (path) => startsWithAny(path, ["/api/browser/workflows", "/api/browser/workflow-runs"]),
+		id: "browser-automations",
+		match: (path) => startsWithAny(path, ["/api/browser/automations", "/api/browser/automation-runs"]),
 		load: async () => {
-			const { registerBrowserWorkflowRoutes } = await import("./browser-workflows.js");
-			return { register: registerBrowserWorkflowRoutes };
+			const { registerBrowserAutomationRoutes } = await import("./browser-automations.js");
+			return { register: registerBrowserAutomationRoutes };
 		}
 	},
 	{

package/dist/src/gateway/service.d.ts

@@ -14,7 +14,7 @@ import { ModelCatalogSyncService } from '../providers/model-catalog-sync-service
 import { ProjectService } from '../projects/index.js';
 import { LocalAppService } from '../local-apps/index.js';
 import { TaskConversationRepository } from '../tasks/task-conversation-repository.js';
-import { type BrowserRecipeService } from '../browser/recipes/index.js';
+import { type BrowserAutomationService } from '../browser/automations/index.js';
 import { listInsights, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker } from '../proactive/index.js';
 import { GatewaySessionsApi } from './service/sessions-api.js';
 import { GatewayMarketplaceService } from './service/marketplace-service.js';
@@ -35,7 +35,7 @@ export declare class GatewayService {
     private _agentService;
     private channelManager;
     private automationService;
-    private browserRecipeService;
+    private browserAutomationService;
     private notesService;
     private extensionLoader;
     private extensionMetadataSnapshot;
@@ -56,7 +56,7 @@ export declare class GatewayService {
     readonly voiceRealtime: VoiceRealtimeRuntime;
     getConfig(): Config;
     getModelCatalogSync(): ModelCatalogSyncService;
-    get browserRecipes(): BrowserRecipeService;
+    get browserAutomations(): BrowserAutomationService;
     private stopGatewayUpdateCheck;
     /** When set (e.g. by `GatewayServer`), `triggerGatewayProcessRestart` can stop HTTP then exit. */
     private gatewayShutdownForRestart;
@@ -196,10 +196,8 @@ export declare class GatewayService {
      */
     onHttpListening(): Promise<void>;
     stop(): Promise<void>;
-    /** Start the browser extension WS server when backend is 'extension'. */
+    /** Start the browser extension WebSocket server when its driver is active. */
     private startBrowserExtensionServerIfNeeded;
-    /** Release the gateway's hold on the shared extension bridge (does not restart). */
-    releaseBrowserExtensionBridge(): Promise<void>;
     /**
      * Start/stop/rebind the Chrome extension bridge.
      * PATCH saves update config in memory without re-running gateway startup, so this must run on save too.

package/dist/src/gateway/service.js

@@ -101,8 +101,8 @@ import { runBootstrapMigrationsSync } from "../migrations/runner.js";
 import { NotificationService } from "../notifications/service.js";
 import { LocalAppService } from "../local-apps/service.js";
 import "../local-apps/index.js";
-import { createRuntimeBrowserRecipeService } from "../browser/recipes/runtime-service.js";
-import "../browser/recipes/index.js";
+import { createRuntimeBrowserAutomationService } from "../browser/automations/runtime-service.js";
+import "../browser/automations/index.js";
 import { mapProductEventToProactive } from "../proactive/events/product-event-bridge.js";
 import { ProactiveEventService } from "../proactive/service.js";
 import { ReadonlyProactiveAgentExecutor } from "../proactive/execution/agent-executor.js";
@@ -145,7 +145,7 @@ var GatewayService = class {
 	_agentService = null;
 	channelManager;
 	automationService;
-	browserRecipeService = null;
+	browserAutomationService = null;
 	notesService;
 	extensionLoader = null;
 	extensionMetadataSnapshot = null;
@@ -237,12 +237,12 @@ var GatewayService = class {
 	getModelCatalogSync() {
 		return this.modelCatalogSync;
 	}
-	get browserRecipes() {
-		if (!this.browserRecipeService) this.browserRecipeService = createRuntimeBrowserRecipeService({
+	get browserAutomations() {
+		if (!this.browserAutomationService) this.browserAutomationService = createRuntimeBrowserAutomationService({
 			getConfig: () => this.config,
 			emit: (type, payload) => this.emit(type, payload)
 		});
-		return this.browserRecipeService;
+		return this.browserAutomationService;
 	}
 	stopGatewayUpdateCheck = null;
 	/** When set (e.g. by `GatewayServer`), `triggerGatewayProcessRestart` can stop HTTP then exit. */
@@ -552,7 +552,8 @@ var GatewayService = class {
 			extensionRegistry: this.extensionLoader?.getRegistry(),
 			endpointTools: this.endpointTools,
 			getAutomationService: () => this.automationService,
-			getBrowserRecipeService: () => this.browserRecipes,
+			getBrowserAutomationService: () => this.browserAutomations,
+			emitBrowserEvent: (type, payload) => this.emit(type, payload),
 			getNotesService: () => this.notesService,
 			getProjectService: () => this.projects,
 			getLocalAppService: () => this.localApps,
@@ -592,7 +593,7 @@ var GatewayService = class {
 			getDefaultAgentId: () => getDefaultAgentId(this.config),
 			prepareAgentSession: (input) => prepareAutomationAgentSession(this.sessionIndex.getStore(), this.projects, input),
 			workflowRunService: this.createWorkflowRunService(),
-			browserRecipeService: this.browserRecipes,
+			browserAutomationService: this.browserAutomations,
 			executeTaskCommand: ({ taskId, idempotencyKey, command }) => {
 				const task = new TaskRepository().get(taskId);
 				if (!task) return {
@@ -1002,7 +1003,7 @@ var GatewayService = class {
 			getDefaultAgentId: () => getDefaultAgentId(this.config),
 			prepareAgentSession: (input) => prepareAutomationAgentSession(this.sessionIndex.getStore(), this.projects, input),
 			workflowRunService: this.createWorkflowRunService(),
-			browserRecipeService: this.browserRecipes,
+			browserAutomationService: this.browserAutomations,
 			executeTaskCommand: ({ taskId, idempotencyKey, command }) => {
 				const task = new TaskRepository().get(taskId);
 				if (!task) return {
@@ -1234,7 +1235,7 @@ var GatewayService = class {
 		this.connectedSourceChangePublisher = null;
 		this.connectedKnowledgeCoordinator?.stop();
 		this.connectedKnowledgeCoordinator = null;
-		await this.browserRecipeService?.shutdown();
+		await this.browserAutomationService?.shutdown();
 		if (this.browserExtensionRelease) {
 			await this.browserExtensionRelease();
 			this.browserExtensionRelease = null;
@@ -1263,33 +1264,29 @@ var GatewayService = class {
 		closeXopcDatabase();
 		log.debug("Gateway service stopped");
 	}
-	/** Start the browser extension WS server when backend is 'extension'. */
+	/** Start the browser extension WebSocket server when its driver is active. */
 	async startBrowserExtensionServerIfNeeded() {
 		await this.reconcileBrowserExtensionServer();
 	}
-	/** Release the gateway's hold on the shared extension bridge (does not restart). */
-	async releaseBrowserExtensionBridge() {
-		if (!this.browserExtensionRelease) return;
-		await this.browserExtensionRelease();
-		this.browserExtensionRelease = null;
-		this.browserExtensionProvider = null;
-		this.browserExtensionBindKey = null;
-		log.debug("Browser extension WS server released");
-	}
 	/**
 	* Start/stop/rebind the Chrome extension bridge.
 	* PATCH saves update config in memory without re-running gateway startup, so this must run on save too.
 	*/
 	async reconcileBrowserExtensionServer() {
-		const { resolveExtensionBridgeServerConfig } = await import("../browser/backend-from-config.js");
-		const bridgeConfig = resolveExtensionBridgeServerConfig(this.config);
+		const driver = this.config.browser.driver;
+		const bridgeConfig = this.config.browser.enabled && driver.kind === "extension" ? {
+			host: "127.0.0.1",
+			port: 19820,
+			connectionTimeout: this.config.browser.limits.actionTimeoutMs,
+			commandTimeout: this.config.browser.limits.actionTimeoutMs
+		} : null;
 		if (!bridgeConfig) {
 			if (this.browserExtensionRelease) {
 				await this.browserExtensionRelease();
 				this.browserExtensionRelease = null;
 				this.browserExtensionProvider = null;
 				this.browserExtensionBindKey = null;
-				log.debug("Browser extension WS server stopped (backend is not extension)");
+				log.debug("Browser extension WebSocket server stopped because its driver is inactive");
 			}
 			return;
 		}

package/dist/src/platform/client.d.ts

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { type PlatformDiscovery, type PlatformEvent } from './contracts.js';
+export declare const PLATFORM_RUNTIME_PROVIDER = "xopc-platform-runtime";
+export declare const PLATFORM_RUNTIME_PROFILE = "xopc-platform-runtime:default";
+export declare function discoverPlatform(baseUrl: string, fetchImpl?: typeof fetch): Promise<PlatformDiscovery>;
+export declare const RuntimeCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"run.start">;
+    payload: z.ZodObject<{
+        runId: z.ZodString;
+        traceId: z.ZodString;
+        agentVersionId: z.ZodString;
+        organizationId: z.ZodString;
+        workspaceId: z.ZodString;
+        runtimeId: z.ZodString;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1">;
+            agentId: z.ZodString;
+            version: z.ZodString;
+            runtime: z.ZodObject<{
+                engine: z.ZodLiteral<"xopc">;
+                requires: z.ZodString;
+                execution: z.ZodArray<z.ZodEnum<{
+                    local: "local";
+                    managed: "managed";
+                    enterprise: "enterprise";
+                }>>;
+            }, z.core.$strict>;
+            entry: z.ZodObject<{
+                instructions: z.ZodString;
+                workflow: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            models: z.ZodObject<{
+                intents: z.ZodArray<z.ZodEnum<{
+                    review: "review";
+                    coding: "coding";
+                    understanding: "understanding";
+                    fast: "fast";
+                    reasoning: "reasoning";
+                    vision: "vision";
+                }>>;
+                allow: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            dependencies: z.ZodObject<{
+                skills: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                    sha256: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                connectors: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                    sha256: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                extensions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                    sha256: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            permissions: z.ZodObject<{
+                tools: z.ZodArray<z.ZodString>;
+                networkDomains: z.ZodArray<z.ZodString>;
+                filesystem: z.ZodArray<z.ZodString>;
+                effects: z.ZodArray<z.ZodEnum<{
+                    delete: "delete";
+                    read: "read";
+                    write: "write";
+                    execute: "execute";
+                    admin: "admin";
+                    send: "send";
+                    purchase: "purchase";
+                    publish: "publish";
+                }>>;
+            }, z.core.$strict>;
+            data: z.ZodObject<{
+                classification: z.ZodEnum<{
+                    public: "public";
+                    internal: "internal";
+                    confidential: "confidential";
+                    restricted: "restricted";
+                }>;
+                memory: z.ZodEnum<{
+                    workspace: "workspace";
+                    none: "none";
+                    local: "local";
+                }>;
+                retentionPolicy: z.ZodString;
+            }, z.core.$strict>;
+            quality: z.ZodObject<{
+                evaluationSuite: z.ZodOptional<z.ZodString>;
+                releaseGate: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$loose>;
+    id: z.ZodString;
+    runId: z.ZodString;
+    leaseToken: z.ZodString;
+    leaseExpiresAt: z.ZodNumber;
+}, z.core.$strict>;
+export type RuntimeCommand = z.infer<typeof RuntimeCommandSchema>;
+declare const runtimeRenewalResponseSchema: z.ZodObject<{
+    leaseExpiresAt: z.ZodNumber;
+    cancelRequested: z.ZodBoolean;
+}, z.core.$strict>;
+export type RuntimeLeaseRenewal = z.infer<typeof runtimeRenewalResponseSchema>;
+export declare class PlatformRuntimeClient {
+    private readonly token;
+    private readonly fetchImpl;
+    private readonly agentApi;
+    constructor(discovery: PlatformDiscovery, token: string, fetchImpl?: typeof fetch);
+    private request;
+    heartbeat(input?: {
+        capabilities?: Record<string, unknown>;
+        endpoint?: string;
+        leaseSeconds?: number;
+    }): Promise<Record<string, unknown>>;
+    lease(leaseSeconds?: number): Promise<RuntimeCommand | null>;
+    report(event: PlatformEvent, leaseToken?: string): Promise<'accepted' | 'duplicate'>;
+    renew(commandId: string, leaseToken: string, leaseSeconds?: number): Promise<RuntimeLeaseRenewal>;
+}
+export {};

package/dist/src/platform/client.js

@@ -0,0 +1,108 @@
+import { AgentManifestSchema, PlatformDiscoverySchema, PlatformEventSchema, init_contracts } from "./contracts.js";
+import { z } from "zod";
+//#region src/platform/client.ts
+init_contracts();
+const PLATFORM_RUNTIME_PROVIDER = "xopc-platform-runtime";
+const PLATFORM_RUNTIME_PROFILE = "xopc-platform-runtime:default";
+function trimBaseUrl(value) {
+	const url = new URL(value);
+	url.hash = "";
+	url.search = "";
+	url.pathname = url.pathname.replace(/\/+$/, "");
+	return url.toString().replace(/\/+$/, "");
+}
+async function responseJson(response) {
+	return response.json().catch(() => null);
+}
+async function discoverPlatform(baseUrl, fetchImpl = fetch) {
+	const response = await fetchImpl(`${trimBaseUrl(baseUrl)}/.well-known/xopc-platform`, {
+		headers: { accept: "application/json" },
+		signal: AbortSignal.timeout(15e3)
+	});
+	if (!response.ok) throw new Error(`Platform discovery failed with HTTP ${response.status}`);
+	return PlatformDiscoverySchema.parse(await responseJson(response));
+}
+const runtimeIdentifier = z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+const runtimeCommandBase = {
+	id: runtimeIdentifier,
+	runId: runtimeIdentifier,
+	leaseToken: z.string().min(1).max(512),
+	leaseExpiresAt: z.number().int().positive()
+};
+const RuntimeCommandSchema = z.object({
+	...runtimeCommandBase,
+	type: z.literal("run.start"),
+	payload: z.object({
+		runId: runtimeIdentifier,
+		traceId: runtimeIdentifier,
+		agentVersionId: runtimeIdentifier,
+		organizationId: runtimeIdentifier,
+		workspaceId: runtimeIdentifier,
+		runtimeId: runtimeIdentifier,
+		manifest: AgentManifestSchema
+	}).passthrough()
+}).strict().superRefine((command, context) => {
+	if (command.payload.runId !== command.runId) context.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "Runtime command run identity does not match its payload",
+		path: ["payload", "runId"]
+	});
+});
+const runtimeLeaseResponseSchema = z.object({ command: RuntimeCommandSchema }).strict();
+const runtimeRenewalResponseSchema = z.object({
+	leaseExpiresAt: z.number().int().positive(),
+	cancelRequested: z.boolean()
+}).strict();
+var PlatformRuntimeClient = class {
+	agentApi;
+	constructor(discovery, token, fetchImpl = fetch) {
+		this.token = token;
+		this.fetchImpl = fetchImpl;
+		if (!discovery.capabilities.runtimeFleet || !discovery.endpoints.agentApi) throw new Error("Connected platform does not provide a runtime fleet");
+		this.agentApi = discovery.endpoints.agentApi.replace(/\/+$/, "");
+		if (!token.startsWith("xopc_rt_")) throw new Error("Invalid platform runtime token");
+	}
+	async request(path, body) {
+		return this.fetchImpl(`${this.agentApi}${path}`, {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${this.token}`,
+				"content-type": "application/json",
+				accept: "application/json"
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(3e4)
+		});
+	}
+	async heartbeat(input = {}) {
+		const response = await this.request("/heartbeat", input);
+		if (!response.ok) throw new Error(`Runtime heartbeat failed with HTTP ${response.status}`);
+		return await responseJson(response);
+	}
+	async lease(leaseSeconds = 30) {
+		const response = await this.request("/lease", { leaseSeconds });
+		if (response.status === 204) return null;
+		if (!response.ok) throw new Error(`Runtime lease failed with HTTP ${response.status}`);
+		return runtimeLeaseResponseSchema.parse(await responseJson(response)).command;
+	}
+	async report(event, leaseToken) {
+		const response = await this.request("/events", {
+			event: PlatformEventSchema.parse(event),
+			leaseToken
+		});
+		if (!response.ok) throw new Error(`Runtime event failed with HTTP ${response.status}`);
+		const value = await responseJson(response);
+		if (value?.status !== "accepted" && value?.status !== "duplicate") throw new Error("Runtime event response is incomplete");
+		return value.status;
+	}
+	async renew(commandId, leaseToken, leaseSeconds = 60) {
+		const response = await this.request(`/commands/${encodeURIComponent(commandId)}/renew`, {
+			leaseToken,
+			leaseSeconds
+		});
+		if (!response.ok) throw new Error(`Runtime lease renewal failed with HTTP ${response.status}`);
+		return runtimeRenewalResponseSchema.parse(await responseJson(response));
+	}
+};
+//#endregion
+export { PLATFORM_RUNTIME_PROFILE, PLATFORM_RUNTIME_PROVIDER, PlatformRuntimeClient, RuntimeCommandSchema, discoverPlatform };

package/dist/src/platform/contracts.d.ts

@@ -0,0 +1,194 @@
+import { z } from 'zod';
+export declare const PlatformCapabilitySchema: z.ZodEnum<{
+    models: "models";
+    connectors: "connectors";
+    tunnels: "tunnels";
+    shares: "shares";
+    managedRuntime: "managedRuntime";
+    runtimeFleet: "runtimeFleet";
+    traceUpload: "traceUpload";
+    a2a: "a2a";
+}>;
+export declare const PlatformDiscoverySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    platformId: z.ZodString;
+    displayName: z.ZodString;
+    deploymentMode: z.ZodEnum<{
+        development: "development";
+        private: "private";
+        cloud: "cloud";
+    }>;
+    region: z.ZodString;
+    endpoints: z.ZodObject<{
+        authorizationServer: z.ZodString;
+        controlApi: z.ZodString;
+        modelApi: z.ZodOptional<z.ZodString>;
+        storeApi: z.ZodOptional<z.ZodString>;
+        tunnelApi: z.ZodOptional<z.ZodString>;
+        shareApi: z.ZodOptional<z.ZodString>;
+        agentApi: z.ZodOptional<z.ZodString>;
+        a2aApi: z.ZodOptional<z.ZodString>;
+        realtime: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    capabilities: z.ZodRecord<z.ZodEnum<{
+        models: "models";
+        connectors: "connectors";
+        tunnels: "tunnels";
+        shares: "shares";
+        managedRuntime: "managedRuntime";
+        runtimeFleet: "runtimeFleet";
+        traceUpload: "traceUpload";
+        a2a: "a2a";
+    }>, z.ZodBoolean>;
+    protocols: z.ZodObject<{
+        xopc: z.ZodObject<{
+            min: z.ZodString;
+            max: z.ZodString;
+        }, z.core.$strict>;
+        mcp: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        a2a: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PlatformDiscovery = z.infer<typeof PlatformDiscoverySchema>;
+export declare const PlatformConfigSchema: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"standalone">;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"connected">;
+    url: z.ZodString;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    discovery: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        platformId: z.ZodString;
+        displayName: z.ZodString;
+        deploymentMode: z.ZodEnum<{
+            development: "development";
+            private: "private";
+            cloud: "cloud";
+        }>;
+        region: z.ZodString;
+        endpoints: z.ZodObject<{
+            authorizationServer: z.ZodString;
+            controlApi: z.ZodString;
+            modelApi: z.ZodOptional<z.ZodString>;
+            storeApi: z.ZodOptional<z.ZodString>;
+            tunnelApi: z.ZodOptional<z.ZodString>;
+            shareApi: z.ZodOptional<z.ZodString>;
+            agentApi: z.ZodOptional<z.ZodString>;
+            a2aApi: z.ZodOptional<z.ZodString>;
+            realtime: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        capabilities: z.ZodRecord<z.ZodEnum<{
+            models: "models";
+            connectors: "connectors";
+            tunnels: "tunnels";
+            shares: "shares";
+            managedRuntime: "managedRuntime";
+            runtimeFleet: "runtimeFleet";
+            traceUpload: "traceUpload";
+            a2a: "a2a";
+        }>, z.ZodBoolean>;
+        protocols: z.ZodObject<{
+            xopc: z.ZodObject<{
+                min: z.ZodString;
+                max: z.ZodString;
+            }, z.core.$strict>;
+            mcp: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            a2a: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "mode">>;
+export type PlatformConfig = z.infer<typeof PlatformConfigSchema>;
+export declare const AgentManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    agentId: z.ZodString;
+    version: z.ZodString;
+    runtime: z.ZodObject<{
+        engine: z.ZodLiteral<"xopc">;
+        requires: z.ZodString;
+        execution: z.ZodArray<z.ZodEnum<{
+            local: "local";
+            managed: "managed";
+            enterprise: "enterprise";
+        }>>;
+    }, z.core.$strict>;
+    entry: z.ZodObject<{
+        instructions: z.ZodString;
+        workflow: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    models: z.ZodObject<{
+        intents: z.ZodArray<z.ZodEnum<{
+            review: "review";
+            coding: "coding";
+            understanding: "understanding";
+            fast: "fast";
+            reasoning: "reasoning";
+            vision: "vision";
+        }>>;
+        allow: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    dependencies: z.ZodObject<{
+        skills: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        connectors: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        extensions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    permissions: z.ZodObject<{
+        tools: z.ZodArray<z.ZodString>;
+        networkDomains: z.ZodArray<z.ZodString>;
+        filesystem: z.ZodArray<z.ZodString>;
+        effects: z.ZodArray<z.ZodEnum<{
+            delete: "delete";
+            read: "read";
+            write: "write";
+            execute: "execute";
+            admin: "admin";
+            send: "send";
+            purchase: "purchase";
+            publish: "publish";
+        }>>;
+    }, z.core.$strict>;
+    data: z.ZodObject<{
+        classification: z.ZodEnum<{
+            public: "public";
+            internal: "internal";
+            confidential: "confidential";
+            restricted: "restricted";
+        }>;
+        memory: z.ZodEnum<{
+            workspace: "workspace";
+            none: "none";
+            local: "local";
+        }>;
+        retentionPolicy: z.ZodString;
+    }, z.core.$strict>;
+    quality: z.ZodObject<{
+        evaluationSuite: z.ZodOptional<z.ZodString>;
+        releaseGate: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentManifest = z.infer<typeof AgentManifestSchema>;
+export declare const PlatformEventSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    eventId: z.ZodString;
+    type: z.ZodString;
+    time: z.ZodString;
+    organizationId: z.ZodString;
+    workspaceId: z.ZodString;
+    runId: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    producer: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export type PlatformEvent = z.infer<typeof PlatformEventSchema>;