@xopcai/xopc 0.0.251 → 0.0.253

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>;

package/dist/src/platform/contracts.js

@@ -0,0 +1,150 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region src/platform/contracts.ts
+var identifier, sha256, exactVersion, PlatformCapabilitySchema, PlatformDiscoverySchema, PlatformConfigSchema, agentDependency, AgentManifestSchema, PlatformEventSchema;
+var init_contracts = __esmMin((() => {
+	identifier = z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+	sha256 = z.string().regex(/^[a-f0-9]{64}$/);
+	exactVersion = z.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/);
+	PlatformCapabilitySchema = z.enum([
+		"models",
+		"connectors",
+		"tunnels",
+		"shares",
+		"managedRuntime",
+		"runtimeFleet",
+		"traceUpload",
+		"a2a"
+	]);
+	PlatformDiscoverySchema = z.object({
+		schemaVersion: z.literal("1"),
+		platformId: identifier,
+		displayName: z.string().min(1).max(120),
+		deploymentMode: z.enum([
+			"cloud",
+			"private",
+			"development"
+		]),
+		region: identifier,
+		endpoints: z.object({
+			authorizationServer: z.string().url(),
+			controlApi: z.string().url(),
+			modelApi: z.string().url().optional(),
+			storeApi: z.string().url().optional(),
+			tunnelApi: z.string().url().optional(),
+			shareApi: z.string().url().optional(),
+			agentApi: z.string().url().optional(),
+			a2aApi: z.string().url().optional(),
+			realtime: z.string().url().optional()
+		}).strict(),
+		capabilities: z.record(PlatformCapabilitySchema, z.boolean()),
+		protocols: z.object({
+			xopc: z.object({
+				min: z.string().min(1),
+				max: z.string().min(1)
+			}).strict(),
+			mcp: z.array(z.string().min(1)).default([]),
+			a2a: z.array(z.string().min(1)).default([])
+		}).strict()
+	}).strict();
+	PlatformConfigSchema = z.discriminatedUnion("mode", [z.object({ mode: z.literal("standalone") }).strict(), z.object({
+		mode: z.literal("connected"),
+		url: z.string().url(),
+		workspaceId: identifier.optional(),
+		discovery: PlatformDiscoverySchema
+	}).strict()]).default({ mode: "standalone" });
+	agentDependency = z.object({
+		id: identifier,
+		version: exactVersion,
+		sha256: sha256.optional()
+	}).strict();
+	AgentManifestSchema = z.object({
+		schemaVersion: z.literal("1"),
+		agentId: identifier,
+		version: exactVersion,
+		runtime: z.object({
+			engine: z.literal("xopc"),
+			requires: z.string().min(1),
+			execution: z.array(z.enum([
+				"local",
+				"managed",
+				"enterprise"
+			])).min(1)
+		}).strict(),
+		entry: z.object({
+			instructions: z.string().min(1),
+			workflow: z.string().min(1).optional()
+		}).strict(),
+		models: z.object({
+			intents: z.array(z.enum([
+				"fast",
+				"reasoning",
+				"coding",
+				"review",
+				"vision",
+				"understanding"
+			])),
+			allow: z.array(z.string().min(1))
+		}).strict(),
+		dependencies: z.object({
+			skills: z.array(agentDependency),
+			connectors: z.array(agentDependency),
+			extensions: z.array(agentDependency).default([])
+		}).strict(),
+		permissions: z.object({
+			tools: z.array(z.string().min(1)),
+			networkDomains: z.array(z.string().min(1)),
+			filesystem: z.array(z.string().min(1)),
+			effects: z.array(z.enum([
+				"read",
+				"write",
+				"send",
+				"execute",
+				"delete",
+				"purchase",
+				"publish",
+				"admin"
+			]))
+		}).strict(),
+		data: z.object({
+			classification: z.enum([
+				"public",
+				"internal",
+				"confidential",
+				"restricted"
+			]),
+			memory: z.enum([
+				"none",
+				"local",
+				"workspace"
+			]),
+			retentionPolicy: identifier
+		}).strict(),
+		quality: z.object({
+			evaluationSuite: identifier.optional(),
+			releaseGate: identifier.optional()
+		}).strict()
+	}).strict();
+	PlatformEventSchema = z.object({
+		schemaVersion: z.literal("1"),
+		eventId: identifier,
+		type: z.string().min(1).max(160).regex(/^xopc\.[a-z0-9_.-]+$/),
+		time: z.string().datetime(),
+		organizationId: identifier,
+		workspaceId: identifier,
+		runId: identifier.optional(),
+		traceId: identifier.optional(),
+		sequence: z.number().int().nonnegative().optional(),
+		producer: identifier,
+		payload: z.record(z.string(), z.unknown())
+	}).strict().superRefine((event, context) => {
+		if (event.runId && event.sequence === void 0) context.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Run events require a sequence",
+			path: ["sequence"]
+		});
+	});
+}));
+//#endregion
+init_contracts();
+export { AgentManifestSchema, PlatformCapabilitySchema, PlatformConfigSchema, PlatformDiscoverySchema, PlatformEventSchema, init_contracts };

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

@@ -0,0 +1,4 @@
+export * from './contracts.js';
+export * from './client.js';
+export * from './worker.js';
+export * from './resolution.js';

package/dist/src/platform/index.js

@@ -0,0 +1,9 @@
+import { AgentManifestSchema, PlatformCapabilitySchema, PlatformConfigSchema, PlatformDiscoverySchema, PlatformEventSchema, init_contracts } from "./contracts.js";
+import { init_resolution, resolveConnectedPlatformDiscovery, resolveConnectedPlatformEndpoint, setActivePlatformDiscovery } from "./resolution.js";
+import { PLATFORM_RUNTIME_PROFILE, PLATFORM_RUNTIME_PROVIDER, PlatformRuntimeClient, RuntimeCommandSchema, discoverPlatform } from "./client.js";
+import { processRuntimeCommand } from "./worker.js";
+//#region src/platform/index.ts
+init_contracts();
+init_resolution();
+//#endregion
+export { AgentManifestSchema, PLATFORM_RUNTIME_PROFILE, PLATFORM_RUNTIME_PROVIDER, PlatformCapabilitySchema, PlatformConfigSchema, PlatformDiscoverySchema, PlatformEventSchema, PlatformRuntimeClient, RuntimeCommandSchema, discoverPlatform, processRuntimeCommand, resolveConnectedPlatformDiscovery, resolveConnectedPlatformEndpoint, setActivePlatformDiscovery };

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

@@ -0,0 +1,4 @@
+import type { PlatformDiscovery } from './contracts.js';
+export declare function setActivePlatformDiscovery(discovery: PlatformDiscovery | undefined): void;
+export declare function resolveConnectedPlatformDiscovery(): PlatformDiscovery | undefined;
+export declare function resolveConnectedPlatformEndpoint(endpoint: keyof PlatformDiscovery['endpoints']): string | undefined;

package/dist/src/platform/resolution.js

@@ -0,0 +1,16 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+//#region src/platform/resolution.ts
+function setActivePlatformDiscovery(discovery) {
+	activeDiscovery = discovery;
+}
+function resolveConnectedPlatformDiscovery() {
+	return activeDiscovery;
+}
+function resolveConnectedPlatformEndpoint(endpoint) {
+	return resolveConnectedPlatformDiscovery()?.endpoints[endpoint];
+}
+var activeDiscovery;
+var init_resolution = __esmMin((() => {}));
+//#endregion
+init_resolution();
+export { init_resolution, resolveConnectedPlatformDiscovery, resolveConnectedPlatformEndpoint, setActivePlatformDiscovery };

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

@@ -0,0 +1,6 @@
+import { PlatformRuntimeClient, type RuntimeCommand } from './client.js';
+export interface RuntimeExecutionResult {
+    output?: unknown;
+}
+export type RuntimeCommandHandler = (command: RuntimeCommand, signal: AbortSignal) => Promise<RuntimeExecutionResult>;
+export declare function processRuntimeCommand(client: PlatformRuntimeClient, handler: RuntimeCommandHandler): Promise<'idle' | 'completed' | 'failed' | 'cancelled'>;

package/dist/src/platform/worker.js

@@ -0,0 +1,75 @@
+import { randomUUID } from "node:crypto";
+//#region src/platform/worker.ts
+var RuntimeCancellation = class extends Error {
+	constructor() {
+		super("Run cancellation requested by platform");
+		this.name = "RuntimeCancellation";
+	}
+};
+function commandIdentity(command) {
+	const { organizationId, workspaceId, traceId, runtimeId } = command.payload;
+	if ([
+		organizationId,
+		workspaceId,
+		traceId,
+		runtimeId
+	].some((value) => typeof value !== "string" || value.length === 0)) throw new Error("Runtime command is missing tenant or trace identity");
+	return {
+		organizationId,
+		workspaceId,
+		traceId,
+		runtimeId
+	};
+}
+function event(command, type, sequence, payload) {
+	const identity = commandIdentity(command);
+	return {
+		schemaVersion: "1",
+		eventId: `event_${randomUUID()}`,
+		type,
+		time: (/* @__PURE__ */ new Date()).toISOString(),
+		organizationId: identity.organizationId,
+		workspaceId: identity.workspaceId,
+		runId: command.runId,
+		traceId: identity.traceId,
+		sequence,
+		producer: identity.runtimeId,
+		payload
+	};
+}
+async function processRuntimeCommand(client, handler) {
+	const command = await client.lease();
+	if (!command) return "idle";
+	await client.report(event(command, "xopc.run.started", 1, {}), command.leaseToken);
+	const controller = new AbortController();
+	let renewing = false;
+	let renewalInFlight = Promise.resolve();
+	const renewalIntervalMs = Math.max(1e3, Math.min(3e4, Math.floor((command.leaseExpiresAt - Date.now()) / 3)));
+	const renewal = setInterval(() => {
+		if (renewing || controller.signal.aborted) return;
+		renewing = true;
+		renewalInFlight = client.renew(command.id, command.leaseToken).then((result) => {
+			if (result.cancelRequested) controller.abort(new RuntimeCancellation());
+		}).catch((error) => controller.abort(error)).finally(() => {
+			renewing = false;
+		});
+	}, renewalIntervalMs);
+	renewal.unref?.();
+	try {
+		const result = await handler(command, controller.signal);
+		await renewalInFlight;
+		if (controller.signal.aborted) throw controller.signal.reason;
+		await client.report(event(command, "xopc.run.succeeded", 2, { output: result.output }), command.leaseToken);
+		return "completed";
+	} catch (error) {
+		const effectiveError = controller.signal.aborted ? controller.signal.reason : error;
+		const cancelled = effectiveError instanceof RuntimeCancellation;
+		await client.report(event(command, cancelled ? "xopc.run.cancelled" : "xopc.run.failed", 2, cancelled ? {} : { error: effectiveError instanceof Error ? effectiveError.message : "Runtime command failed" }), command.leaseToken);
+		return cancelled ? "cancelled" : "failed";
+	} finally {
+		clearInterval(renewal);
+		await renewalInFlight;
+	}
+}
+//#endregion
+export { processRuntimeCommand };

package/dist/src/providers/auth-runtime/resolve-auth.js

@@ -1,5 +1,5 @@
-import { getApiKeyFromEnv, init_env_keys } from "../env-keys.js";
 import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
+import { getApiKeyFromEnv, init_env_keys } from "../env-keys.js";
 import { getDefaultAuthProfileStore } from "./auth-profile-store.js";
 //#region src/providers/auth-runtime/resolve-auth.ts
 init_env_keys();

package/dist/src/providers/index.js

@@ -1,11 +1,11 @@
 import { __esmMin, __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
+import { getModelOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
+import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
 import { PROVIDER_ENV_MAP, getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { init_model_ref, splitProviderModelRef } from "./model-ref.js";
 import { ModelRegistry, getModelRegistry, init_model_registry, prewarmModelRegistry, resetModelRegistry } from "./model-registry.js";
-import { getModelOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
 import { CredentialResolver, hasCredentials, init_credentials } from "../auth/credentials.js";
-import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
 import { EXTENSION_PROVIDER_BASE_URL, init_constants } from "./constants.js";
 import { applyOfficialModelMetadataCorrections, getSupplementalModels, init_model_supplements } from "./model-supplements.js";
 import { getProviderRegistry, init_plugin_registry } from "./plugin-registry.js";

package/dist/src/providers/model-registry.js

@@ -1,8 +1,8 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { init_resolve_config_value, resolveConfigValue, resolveHeaders } from "../config/resolve-config-value.js";
 import { resolveModelsJsonPath } from "../config/paths.js";
+import { init_resolve_config_value, resolveConfigValue, resolveHeaders } from "../config/resolve-config-value.js";
 import { getDefaultModelValues, init_models_json, validateModelsConfig } from "../config/models-json.js";
 import { getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";

package/dist/src/providers/register-runtime-providers.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
 import { getOAuthProviderDefinition, init_registry } from "../auth/oauth/registry.js";
+import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
 import { XOPC_CLOUD_PROVIDER_ID, init_xopc_cloud_config, resolveXopcModelRouterUrl } from "./xopc-cloud-config.js";
 //#region src/providers/register-runtime-providers.ts
 function registerRuntimeProvider(modelRuntime, source) {

package/dist/src/providers/xopc-cloud-config.js

@@ -1,10 +1,12 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_resolution, resolveConnectedPlatformEndpoint } from "../platform/resolution.js";
 //#region src/providers/xopc-cloud-config.ts
 function resolveXopcModelRouterUrl(override) {
-	return (override ?? process.env.XOPC_MODEL_ROUTER_URL ?? "https://router.xopc.ai/v1").replace(/\/+$/, "");
+	return (override ?? process.env.XOPC_MODEL_ROUTER_URL ?? resolveConnectedPlatformEndpoint("modelApi") ?? "https://router.xopc.ai/v1").replace(/\/+$/, "");
 }
 var XOPC_CLOUD_PROVIDER_ID, DEFAULT_XOPC_MODEL_ROUTER_URL;
 var init_xopc_cloud_config = __esmMin((() => {
+	init_resolution();
 	XOPC_CLOUD_PROVIDER_ID = "xopc-cloud";
 	DEFAULT_XOPC_MODEL_ROUTER_URL = "https://router.xopc.ai/v1";
 }));

package/dist/src/session/session-context-for-llm.js

@@ -127,6 +127,46 @@ function toolCallIds(message) {
 	}
 	return ids;
 }
+function browserToolCallIds(messages) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		const content = message.content;
+		if (!Array.isArray(content)) continue;
+		for (const block of content) {
+			const record = asRecord(block);
+			if (!record || stringValue(record.name) !== "browser_use") continue;
+			const id = toolCallIdFromBlock(record);
+			if (id) ids.add(id);
+		}
+	}
+	return ids;
+}
+/** Keep semantic browser text throughout history, but only the newest browser screenshot. */
+function projectBrowserVisualContext(messages) {
+	const browserIds = browserToolCallIds(messages);
+	let latestVisualIndex = -1;
+	for (let index = 0; index < messages.length; index += 1) {
+		const message = messages[index];
+		if (!browserIds.has(toolResultId(message) ?? "")) continue;
+		const content = message.content;
+		if (Array.isArray(content) && content.some((block) => asRecord(block)?.type === "image")) latestVisualIndex = index;
+	}
+	if (latestVisualIndex < 0) return messages;
+	return messages.map((message, index) => {
+		if (index === latestVisualIndex || !browserIds.has(toolResultId(message) ?? "")) return message;
+		const record = message;
+		if (!Array.isArray(record.content)) return message;
+		const content = record.content.map((block) => asRecord(block)?.type === "image" ? {
+			type: "text",
+			text: "[Earlier browser screenshot omitted; semantic observation retained.]"
+		} : block);
+		return {
+			...record,
+			content
+		};
+	});
+}
 function filterAssistantToolCalls(message, pairedIds) {
 	const record = message;
 	const content = record.content;
@@ -257,7 +297,7 @@ function buildSessionContextForLlm(rows) {
 		}
 		if (isLikelyAgentMessage(r)) out.push(r);
 	}
-	return sanitizeToolPairs(out);
+	return projectBrowserVisualContext(sanitizeToolPairs(out));
 }
 /** Visible chat messages only - no LLM-only audit/context expansion. */
 function buildSessionDisplayMessages(rows) {

package/dist/src/share/hosted-session-share.js

@@ -1,5 +1,6 @@
 import { requireXopcDatabase } from "../storage/sqlite/connection.js";
 import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { init_resolution, resolveConnectedPlatformEndpoint } from "../platform/resolution.js";
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { DurableState } from "../storage/sqlite/durable-state.js";
 import { resolveMediaReference } from "../media/media-reference.js";
@@ -11,6 +12,7 @@ import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 //#region src/share/hosted-session-share.ts
 init_credentials();
+init_resolution();
 const DEFAULT_SHARE_URL = "https://share.xopc.ai";
 const MAX_MESSAGES = 1e4;
 const MAX_ATTACHMENTS = 20;
@@ -105,7 +107,7 @@ var HostedSessionShareBuilder = class {
 };
 var HostedSessionSharePublisher = class {
 	baseUrl;
-	constructor(baseUrl = process.env.XOPC_SHARE_URL ?? DEFAULT_SHARE_URL, credentials = new CredentialResolver(), fetchImpl = fetch) {
+	constructor(baseUrl = process.env.XOPC_SHARE_URL ?? resolveConnectedPlatformEndpoint("shareApi") ?? DEFAULT_SHARE_URL, credentials = new CredentialResolver(), fetchImpl = fetch) {
 		this.credentials = credentials;
 		this.fetchImpl = fetchImpl;
 		this.baseUrl = baseUrl.replace(/\/+$/, "");

package/dist/src/share/share-thumbnail.js

@@ -14,7 +14,7 @@ import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
 * Responsibilities:
 *  - Render a 1200x630 jpeg preview for shareable artefacts.
 *  - HTML / sites: launch its own Playwright browser (does NOT share the user
-*    BrowserManager — the user-facing browser is for the agent and we mustn't
+*    Browser Control runtime — the user-facing browser is for the agent and we mustn't
 *    pollute its context).
 *  - Images: pass through with size cap; downscale only if oversized.
 *  - Anything else: emit an SVG placeholder card with the file name + icon.

package/dist/src/storage/sqlite/clarification-wait-repository.d.ts

@@ -0,0 +1,41 @@
+import type { ClarificationKind, ClarificationResponseAction, ClarificationWait, ClarificationWaitSnapshot } from '@xopcai/gateway-contract';
+import { type SessionInput } from './session-input-repository.js';
+export type CreateClarificationInput = {
+    sessionKey: string;
+    runId: string;
+    toolCallId: string;
+    kind: ClarificationKind;
+    question: string;
+    choices?: string[];
+    suggestedAnswer?: string;
+    approvalKey?: string;
+    now?: number;
+};
+export type ResolveClarificationInput = {
+    id: string;
+    expectedVersion: number;
+    idempotencyKey: string;
+    action: ClarificationResponseAction;
+    answer?: string;
+    now?: number;
+};
+export type ResolveClarificationResult = {
+    ok: true;
+    clarification: ClarificationWait;
+    idempotent: boolean;
+    queued: boolean;
+} | {
+    ok: false;
+    code: 'NOT_FOUND' | 'CONFLICT' | 'EXPIRED' | 'INVALID';
+    clarification?: ClarificationWait;
+};
+export declare function getClarification(id: string): ClarificationWait | undefined;
+export declare function getActiveClarification(sessionKey: string): ClarificationWait | undefined;
+export declare function getClarificationSnapshot(sessionKey: string): ClarificationWaitSnapshot | undefined;
+export declare function createClarificationWait(input: CreateClarificationInput): ClarificationWait;
+export declare function isClarificationSuspended(sessionKey: string, runId: string): boolean;
+export declare function resolveClarification(input: ResolveClarificationInput): ResolveClarificationResult;
+export declare function getClarificationResumeInput(sessionKey: string, runId: string): SessionInput | undefined;
+export declare function consumeClarificationResume(input: SessionInput): boolean;
+export declare function consumeClarificationApproval(sessionKey: string, approvalKey: string): 'approved' | 'denied' | undefined;
+export declare function supersedeActiveClarification(sessionKey: string, now?: number): ClarificationWait | undefined;