@xopcai/xopc 0.0.188 → 0.0.190

package/dist/src/config/schema.js

@@ -64,7 +64,7 @@ function parseModelRef(ref) {
 		model: trimmed.slice(idx + 1).trim()
 	};
 }
-var AgentModelRefSchema, AgentImageGenerationModelSchema, AgentTypedModelRoleSchema, AgentTypedModelRolesSchema, AgentModelsSchema, AgentsConfigSchema, BrowserCloudConfigSchema, BrowserExtensionConfigSchema, BrowserCloakConfigSchema, BrowserConfigSchema, BindingMatchSchema, BindingRuleSchema, BindingsConfigSchema, SessionDmScopeSchema, SessionStorageConfigSchema, SessionResetModeSchema, SessionResetConfigSchema, SessionResetByTypeSchema, SessionScopeSchema, SessionConfigSchema, ChannelsConfigSchema, SearchProviderEntrySchema, WebSearchConfigSchema, WebsiteBlocklistSchema, WebToolsConfigSchema, ToolsConfigSchema, GatewayAuthRateLimitSchema, GatewaySecuritySchema, GatewayTrustedProxySchema, GatewayAuthSchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayRemoteSchema, GatewayTlsSchema, GatewayModeSchema, HeartbeatConfigSchema, GatewayChannelConnectDeferModeSchema, TunnelConsentSchema, TunnelConfigSchema, WorkspaceImportConfigSchema, WorkspaceConfigSchema, GatewayBindModeSchema, GatewayWebchatConfigSchema, GatewayConfigSchema, ModelsDevConfigSchema, ModelCatalogConfigSchema, SttProviderConfigCatchallSchema, STTProviderConfigSchema, STTFallbackConfigSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, STTConfigSchema, TtsProviderConfigCatchallSchema, TTSProviderConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSEdgeConfigSchema, TTSSummarizationConfigSchema, TTSConfigSchema, VoiceRefinementConfigSchema, VoiceConfigSchema, MessagesConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProviderAuthConfigSchema, ProvidersConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, UpdateAutoConfigSchema, UpdateConfigSchema, CommandsConfigSchema, TuiConfigSchema, McpHttpUrlSchema, ConnectorSecretReferenceSchema, McpConfigScalarSchema, McpServerSchema, McpConfigSchema, CodeIntelligenceConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ConfigSchema;
+var AgentModelRefSchema, AgentImageGenerationModelSchema, AgentTypedModelRoleSchema, AgentTypedModelRolesSchema, AgentModelsSchema, AgentsConfigSchema, BrowserCloudConfigSchema, BrowserExtensionConfigSchema, BrowserCloakConfigSchema, BrowserConfigSchema, BindingMatchSchema, BindingRuleSchema, BindingsConfigSchema, SessionDmScopeSchema, SessionStorageConfigSchema, SessionResetModeSchema, SessionResetConfigSchema, SessionResetByTypeSchema, SessionScopeSchema, SessionConfigSchema, ChannelsConfigSchema, SearchProviderEntrySchema, WebSearchConfigSchema, WebsiteBlocklistSchema, WebToolsConfigSchema, ToolsConfigSchema, GatewayAuthRateLimitSchema, GatewaySecuritySchema, GatewayTrustedProxySchema, GatewayAuthSchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayRemoteSchema, GatewayTlsSchema, GatewayModeSchema, HeartbeatConfigSchema, GatewayChannelConnectDeferModeSchema, TunnelConsentSchema, TunnelConfigSchema, WorkspaceImportConfigSchema, WorkspaceConfigSchema, GatewayBindModeSchema, GatewayWebchatConfigSchema, GatewayConfigSchema, ModelsDevConfigSchema, ModelCatalogConfigSchema, SttProviderConfigCatchallSchema, STTProviderConfigSchema, STTFallbackConfigSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, STTConfigSchema, TtsProviderConfigCatchallSchema, TTSProviderConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSEdgeConfigSchema, TTSSummarizationConfigSchema, TTSConfigSchema, VoiceRefinementConfigSchema, VoiceConfigSchema, MessagesConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProviderAuthConfigSchema, ProvidersConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, UpdateAutoConfigSchema, UpdateConfigSchema, CommandsConfigSchema, TuiConfigSchema, McpHttpUrlSchema, ConnectorSecretReferenceSchema, McpConfigScalarSchema, McpServerSchema, McpConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ConfigSchema;
 var init_schema = __esmMin((() => {
 	init_schema$1();
 	init_preset_chain();
@@ -465,7 +465,6 @@ activityDetailDefault: z.enum([
 		auth: GatewayAuthSchema.optional(),
 		heartbeat: HeartbeatConfigSchema.optional(),
 		webchat: GatewayWebchatConfigSchema.optional(),
-		maxSseConnections: z.number().optional(),
 		corsOrigins: z.array(z.string()).optional(),
 		/**
 		* Reverse-proxy publicly reachable URL (e.g. `https://gateway.example.com`).
@@ -639,7 +638,6 @@ activityDetailDefault: z.enum([
 			includeSystemPromptSection: false
 		},
 		webchat: { activityDetailDefault: "on" },
-		maxSseConnections: 100,
 		corsOrigins: [],
 		skillsMarketplaceProvider: "store",
 		skillsStoreBaseUrl: "https://store.xopc.ai"
@@ -904,30 +902,6 @@ defaultAgent: z.string().min(1).optional() }).strict().default({});
 		servers: z.record(z.string(), McpServerSchema).optional(),
 		sessionIdleTtlMs: z.number().finite().min(0).optional()
 	}).strict().optional();
-	CodeIntelligenceConfigSchema = z.object({
-		enabled: z.boolean().default(true),
-		agentIds: z.array(z.string().min(1)).default(["coder"]),
-		indexMode: z.enum([
-			"fast",
-			"moderate",
-			"full"
-		]).default("moderate"),
-		autoIndex: z.boolean().default(true),
-		autoRefresh: z.boolean().default(true),
-		refreshDebounceMs: z.number().int().min(100).max(3e4).default(600),
-		queryTimeoutMs: z.number().int().min(1e3).max(12e4).default(2e4),
-		indexTimeoutMs: z.number().int().min(1e4).max(30 * 6e4).default(5 * 6e4),
-		binaryPath: z.string().min(1).optional()
-	}).strict().default({
-		enabled: true,
-		agentIds: ["coder"],
-		indexMode: "moderate",
-		autoIndex: true,
-		autoRefresh: true,
-		refreshDebounceMs: 600,
-		queryTimeoutMs: 2e4,
-		indexTimeoutMs: 5 * 6e4
-	});
 	ConnectorsConfigSchema = z.object({ instances: z.record(z.string(), z.record(z.string(), z.unknown())).optional() }).strict().optional();
 	ExperimentalConfigSchema = z.object({ 
 	/** First-run activation that analyzes one explicitly selected local folder. */
@@ -944,7 +918,6 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 		workspace: WorkspaceConfigSchema,
 		tools: ToolsConfigSchema,
 		mcp: McpConfigSchema,
-		codeIntelligence: CodeIntelligenceConfigSchema,
 		connectors: ConnectorsConfigSchema,
 		experimental: ExperimentalConfigSchema,
 		extensions: ExtensionsConfigSchema.default({}),
@@ -959,7 +932,7 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 		update: UpdateConfigSchema,
 		commands: CommandsConfigSchema,
 		tui: TuiConfigSchema
-	}).default({
+	}).strict().default({
 		userContext: {
 			enabled: true,
 			preferences: { responseLanguage: "auto" },
@@ -981,7 +954,12 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 				writeStrategy: "local-first",
 				allowExternalWrites: false
 			},
-			dreaming: { mode: "off" }
+			dreaming: {
+				mode: "review",
+				schedule: { time: "03:00" },
+				minEvidenceSources: 2,
+				limit: 500
+			}
 		},
 		agents: {
 			default: "main",
@@ -1042,7 +1020,6 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 				includeSystemPromptSection: false
 			},
 			webchat: { activityDetailDefault: "on" },
-			maxSseConnections: 100,
 			corsOrigins: [],
 			skillsMarketplaceProvider: "store",
 			skillsStoreBaseUrl: "https://store.xopc.ai"
@@ -1055,16 +1032,6 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 			maxResults: 5,
 			providers: []
 		} } },
-		codeIntelligence: {
-			enabled: true,
-			agentIds: ["coder"],
-			indexMode: "moderate",
-			autoIndex: true,
-			autoRefresh: true,
-			refreshDebounceMs: 600,
-			queryTimeoutMs: 2e4,
-			indexTimeoutMs: 5 * 6e4
-		},
 		experimental: { workDiscoveryOnboarding: true },
 		extensions: {
 			allow: [],
@@ -1088,4 +1055,4 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 }));
 //#endregion
 init_schema();
-export { AgentImageGenerationModelSchema, AgentModelRefSchema, AgentModelsSchema, AgentTypedModelRoleSchema, AgentsConfigSchema, BindingMatchSchema, BindingRuleSchema, BindingsConfigSchema, BrowserConfigSchema, ChannelsConfigSchema, CodeIntelligenceConfigSchema, CommandsConfigSchema, ConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, GatewayAuthRateLimitSchema, GatewayAuthSchema, GatewayBindModeSchema, GatewayChannelConnectDeferModeSchema, GatewayConfigSchema, GatewayModeSchema, GatewayRemoteSchema, GatewaySecuritySchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayTlsSchema, GatewayTrustedProxySchema, GatewayWebchatConfigSchema, HeartbeatConfigSchema, McpConfigSchema, McpServerSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, MessagesConfigSchema, ModelCatalogConfigSchema, ModelsDevConfigSchema, ProviderAuthConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProvidersConfigSchema, STTConfigSchema, STTFallbackConfigSchema, STTProviderConfigSchema, SearchProviderEntrySchema, SessionConfigSchema, SessionDmScopeSchema, SessionResetByTypeSchema, SessionResetConfigSchema, SessionResetModeSchema, SessionScopeSchema, SessionStorageConfigSchema, TTSConfigSchema, TTSEdgeConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSProviderConfigSchema, TTSSummarizationConfigSchema, TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema, ToolsConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, TuiConfigSchema, TunnelConfigSchema, TunnelConsentSchema, UpdateAutoConfigSchema, UpdateConfigSchema, VoiceConfigSchema, VoiceRefinementConfigSchema, WebSearchConfigSchema, WebToolsConfigSchema, WebsiteBlocklistSchema, WeixinAccountConfigSchema, WeixinConfigSchema, WorkspaceConfigSchema, WorkspaceImportConfigSchema, getAgentDefaultImageGenerationModelConfig, getAgentDefaultImageModelConfig, getAgentDefaultModelRef, init_schema, parseModelRef };
+export { AgentImageGenerationModelSchema, AgentModelRefSchema, AgentModelsSchema, AgentTypedModelRoleSchema, 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, McpServerSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, MessagesConfigSchema, ModelCatalogConfigSchema, ModelsDevConfigSchema, ProviderAuthConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProvidersConfigSchema, STTConfigSchema, STTFallbackConfigSchema, STTProviderConfigSchema, SearchProviderEntrySchema, SessionConfigSchema, SessionDmScopeSchema, SessionResetByTypeSchema, SessionResetConfigSchema, SessionResetModeSchema, SessionScopeSchema, SessionStorageConfigSchema, TTSConfigSchema, TTSEdgeConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSProviderConfigSchema, TTSSummarizationConfigSchema, TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema, ToolsConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, TuiConfigSchema, TunnelConfigSchema, TunnelConsentSchema, UpdateAutoConfigSchema, UpdateConfigSchema, VoiceConfigSchema, VoiceRefinementConfigSchema, WebSearchConfigSchema, WebToolsConfigSchema, WebsiteBlocklistSchema, WeixinAccountConfigSchema, WeixinConfigSchema, WorkspaceConfigSchema, WorkspaceImportConfigSchema, getAgentDefaultImageGenerationModelConfig, getAgentDefaultImageModelConfig, getAgentDefaultModelRef, init_schema, parseModelRef };

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

@@ -93,7 +93,6 @@ function mergeGatewaySkillsMarketplacePatch(config, patch) {
 			intervalMs: 18e5,
 			includeSystemPromptSection: false
 		},
-		maxSseConnections: 100,
 		corsOrigins: []
 	};
 	if (parsed.data.skillsMarketplaceProvider !== void 0) config.gateway.skillsMarketplaceProvider = parsed.data.skillsMarketplaceProvider.trim();

package/dist/src/connectors/learning-coordinator.js

@@ -10,6 +10,7 @@ import { connectorIdentityKey, normalizeConnectorIdentity } from "./connector-id
 import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { buildConnectorLearningArguments, getConnectorLearningPlan } from "./learning-recipes.js";
 import { getConnectorDefinition } from "./catalog.js";
+import { createUnderstandingSourceRun, listUnderstandingSourceRuns, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant, upsertUserFocus } from "../user-context/sources/repository.js";
 import { ConnectedUnderstandingPipeline } from "../knowledge/connected-understanding-pipeline.js";
 import "../knowledge/index.js";
 import { ingestComposioConnectedSource } from "./connected-source-ingestion.js";
@@ -22,8 +23,41 @@ function learningFailureCode(error) {
 	const message = error instanceof Error ? error.message : String(error);
 	return message.includes("ToolRouterV2_InvalidConnectedAccountIds") || message.includes("Could not find connected account(s)") || message.includes("missing its provider identity") ? CONNECTED_ACCOUNT_UNAVAILABLE : CONNECTED_SOURCE_SYNC_FAILED;
 }
+function connectorSourceCategory(toolkit) {
+	if (toolkit === "gmail") return "mail";
+	if (toolkit === "googlecalendar") return "calendar";
+	if (toolkit === "github" || toolkit === "linear") return "code_activity";
+	if (toolkit === "slack") return "messages";
+	return "files";
+}
+function ensureUnderstandingSourceRun(job, toolkit, displayName) {
+	const grant = upsertUnderstandingSourceGrant({
+		sourceKey: `connector-account:${job.accountId}`,
+		adapterId: `connector:${job.connectorId}`,
+		category: connectorSourceCategory(toolkit),
+		platform: "all",
+		displayName,
+		accessMode: "continuous",
+		retentionPolicy: "bounded_raw",
+		processingPolicy: "remote_allowed",
+		config: {
+			connectorId: job.connectorId,
+			accountId: job.accountId,
+			readOnly: true
+		}
+	});
+	return listUnderstandingSourceRuns(grant.id, 100).find((run) => run.metadata.connectorLearningJobId === job.id) ?? createUnderstandingSourceRun({
+		grantId: grant.id,
+		kind: job.mode,
+		status: "queued",
+		metadata: {
+			connectorLearningJobId: job.id,
+			connectorId: job.connectorId
+		}
+	});
+}
 function learningEnabled(config) {
-	return config.userContext.enabled && config.userContext.understanding.enabled && config.userContext.memory.mode !== "off" && config.userContext.memory.sources.includes("connectedSources");
+	return config.userContext.enabled && config.userContext.understanding.enabled;
 }
 function startConnectorLearningCoordinator(options) {
 	const intervalMs = Math.max(2e3, Math.min(options.intervalMs ?? 1e4, 6e4));
@@ -60,6 +94,7 @@ function startConnectorLearningCoordinator(options) {
 			idempotencyKey: request.idempotencyKey ?? (mode === "bootstrap" ? `bootstrap:${connection.accountId}:v1` : `incremental:${connection.accountId}:${request.reason ?? "manual"}:${bucket}`),
 			nextRunAt: request.nextRunAt
 		});
+		ensureUnderstandingSourceRun(job, definition.runtime.toolkit, definition.displayName);
 		publish(job);
 		queueMicrotask(() => void runNow());
 		return job;
@@ -77,6 +112,8 @@ function startConnectorLearningCoordinator(options) {
 		if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error(`Connector learning is unavailable for ${job.connectorId}.`);
 		const plan = getConnectorLearningPlan(definition.runtime.toolkit);
 		if (!plan) throw new Error(`Connector learning has no plan for ${definition.runtime.toolkit}.`);
+		const sourceRun = ensureUnderstandingSourceRun(job, plan.toolkit, definition.displayName);
+		updateUnderstandingSourceRun(sourceRun.id, { status: "running" });
 		let connection = listConnectorConnections().find((candidate) => candidate.id === job.connectionId);
 		if (!connection) throw new Error("Connector account no longer exists.");
 		const installation = getConnectorInstallation(`${job.connectorId}-local-owner`);
@@ -153,13 +190,42 @@ function startConnectorLearningCoordinator(options) {
 		}));
 		publish(updateConnectorLearningJob(job.id, { phase: "deriving" }));
 		const understanding = await new ConnectedUnderstandingPipeline(options.getMemoryManager()).process(job.sourceInstanceId, job.connectorId, job.agentId);
-		publish(updateConnectorLearningJob(job.id, {
+		for (const record of understanding.createdRecords.filter((item) => item.kind === "project_context")) upsertUserFocus({
+			canonicalKey: `connector-focus:${job.accountId}:${record.id}`,
+			title: record.content.slice(0, 120),
+			summary: record.content,
+			horizon: "ongoing",
+			status: "candidate",
+			confidence: .72,
+			evidenceRefs: [`connector-account:${job.accountId}`],
+			sourceRunId: sourceRun.id
+		});
+		const completed = updateConnectorLearningJob(job.id, {
 			status: "completed",
 			phase: "completed",
 			candidatesCreated: understanding.created,
 			nextRunAt: null,
 			finished: true
-		}));
+		});
+		updateUnderstandingSourceRun(sourceRun.id, {
+			status: "completed",
+			itemsSeen,
+			cursorAfter: (/* @__PURE__ */ new Date()).toISOString(),
+			completed: true,
+			metadata: {
+				...sourceRun.metadata,
+				itemsIndexed,
+				candidatesCreated: understanding.created
+			}
+		});
+		updateUnderstandingSourceGrantCheckpoint(sourceRun.grantId, {
+			checkpoint: {
+				cursor: (/* @__PURE__ */ new Date()).toISOString(),
+				connectorLearningJobId: job.id
+			},
+			lastCollectedAt: Date.now()
+		});
+		publish(completed);
 		pruneBoundedKnowledgeSourceItems(job.sourceInstanceId, Date.now() - plan.bootstrapWindowDays * 24 * 60 * 6e4);
 		const syncPolicy = getConnectorSyncPolicyForConnection(job.connectionId);
 		if (syncPolicy?.scanEnabled === false) return;
@@ -190,6 +256,12 @@ function startConnectorLearningCoordinator(options) {
 						nextRunAt: exhausted ? null : Date.now() + Math.min(30 * 6e4, 3e4 * 2 ** Math.min(job.attemptCount, 6)),
 						finished: true
 					}));
+					const definition = getConnectorDefinition(job.connectorId);
+					if (definition?.runtime.type === "composio" && definition.runtime.role === "toolkit") updateUnderstandingSourceRun(ensureUnderstandingSourceRun(job, definition.runtime.toolkit, definition.displayName).id, {
+						status: "failed",
+						errorMessage,
+						completed: true
+					});
 					log.warn({
 						err,
 						jobId: job.id,

package/dist/src/endpoint-tools/auth.d.ts

@@ -0,0 +1,20 @@
+import crypto from 'node:crypto';
+import { type EndpointHelloPayload } from '@xopcai/endpoint-tools-protocol';
+import type { EndpointPrincipal } from '../storage/sqlite/index.js';
+export interface EndpointAuthenticatorDeps {
+    getPrincipal(id: string): EndpointPrincipal | undefined;
+    bindEndpoint(endpointId: string, principalId: string, boundAt?: number): boolean;
+    touchPrincipal(id: string, seenAt?: number): void;
+    now?: () => number;
+}
+export declare class EndpointAuthenticationError extends Error {
+}
+export declare function parseEndpointPublicKey(encoded: string): crypto.KeyObject;
+export declare class EndpointAuthenticator {
+    private readonly deps;
+    private readonly usedNonces;
+    private readonly now;
+    constructor(deps: EndpointAuthenticatorDeps);
+    authenticate(payload: EndpointHelloPayload): EndpointPrincipal;
+    private pruneNonces;
+}

package/dist/src/endpoint-tools/auth.js

@@ -0,0 +1,51 @@
+import { endpointHelloSigningPayload } from "../../packages/endpoint-tools-protocol/src/index.js";
+import crypto from "node:crypto";
+//#region src/endpoint-tools/auth.ts
+const MAX_CLOCK_SKEW_MS = 6e4;
+var EndpointAuthenticationError = class extends Error {};
+function parseEndpointPublicKey(encoded) {
+	const key = crypto.createPublicKey({
+		key: Buffer.from(encoded, "base64url"),
+		format: "der",
+		type: "spki"
+	});
+	if (key.asymmetricKeyType !== "ec" || key.asymmetricKeyDetails?.namedCurve !== "prime256v1") throw new Error("Endpoint public key must be ECDSA P-256");
+	return key;
+}
+var EndpointAuthenticator = class {
+	usedNonces = /* @__PURE__ */ new Map();
+	now;
+	constructor(deps) {
+		this.deps = deps;
+		this.now = deps.now ?? Date.now;
+	}
+	authenticate(payload) {
+		const now = this.now();
+		this.pruneNonces(now);
+		if (Math.abs(now - payload.signedAt) > MAX_CLOCK_SKEW_MS) throw new EndpointAuthenticationError("Endpoint signature timestamp is outside the allowed window");
+		const nonceKey = `${payload.principalId}:${payload.nonce}`;
+		if (this.usedNonces.has(nonceKey)) throw new EndpointAuthenticationError("Endpoint hello nonce was already used");
+		const principal = this.deps.getPrincipal(payload.principalId);
+		if (!principal || principal.revokedAt !== void 0) throw new EndpointAuthenticationError("Endpoint principal is unknown or revoked");
+		if (principal.kind !== payload.kind || principal.platform !== payload.platform || principal.displayName !== payload.displayName) throw new EndpointAuthenticationError("Endpoint identity does not match its registered principal");
+		let publicKey;
+		try {
+			publicKey = parseEndpointPublicKey(principal.publicKey);
+		} catch (error) {
+			throw new EndpointAuthenticationError("Endpoint principal public key is invalid", { cause: error });
+		}
+		if (!crypto.verify("sha256", Buffer.from(endpointHelloSigningPayload(payload), "utf8"), {
+			key: publicKey,
+			dsaEncoding: "ieee-p1363"
+		}, Buffer.from(payload.signature, "base64url"))) throw new EndpointAuthenticationError("Endpoint hello signature is invalid");
+		if (!this.deps.bindEndpoint(payload.endpointId, principal.id, now)) throw new EndpointAuthenticationError("Endpoint instance belongs to another principal");
+		this.usedNonces.set(nonceKey, now + MAX_CLOCK_SKEW_MS);
+		this.deps.touchPrincipal(principal.id, now);
+		return principal;
+	}
+	pruneNonces(now) {
+		for (const [key, expiresAt] of this.usedNonces) if (expiresAt <= now) this.usedNonces.delete(key);
+	}
+};
+//#endregion
+export { EndpointAuthenticationError, EndpointAuthenticator, parseEndpointPublicKey };

package/dist/src/endpoint-tools/index.d.ts

@@ -0,0 +1,5 @@
+export { EndpointToolRuntime } from './runtime.js';
+export { EndpointInvocationService, EndpointToolExecutionError, type EndpointInvocationAuditSink, type EndpointInvocationResult, } from './invocation-service.js';
+export { EndpointToolPolicy, EndpointToolPolicyError } from './policy.js';
+export { EndpointRegistry, endpointToolRevision, type EndpointConnectionSnapshot, type RegisteredEndpointTool, } from './registry.js';
+export { EndpointUploadError, EndpointUploadService, ENDPOINT_UPLOAD_MAX_BYTES, type EndpointUploadedFile, type EndpointUploadGrant, } from './upload-service.js';

package/dist/src/endpoint-tools/index.js

@@ -0,0 +1,6 @@
+import { EndpointToolPolicy, EndpointToolPolicyError } from "./policy.js";
+import { EndpointInvocationService, EndpointToolExecutionError } from "./invocation-service.js";
+import { EndpointRegistry, endpointToolRevision } from "./registry.js";
+import { ENDPOINT_UPLOAD_MAX_BYTES, EndpointUploadError, EndpointUploadService } from "./upload-service.js";
+import { EndpointToolRuntime } from "./runtime.js";
+export { ENDPOINT_UPLOAD_MAX_BYTES, EndpointInvocationService, EndpointRegistry, EndpointToolExecutionError, EndpointToolPolicy, EndpointToolPolicyError, EndpointToolRuntime, EndpointUploadError, EndpointUploadService, endpointToolRevision };

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

@@ -0,0 +1,68 @@
+import { type ClientEndpointMessage, type EndpointToolContent, type EndpointToolErrorCode } from '@xopcai/endpoint-tools-protocol';
+import { EndpointRegistry } from './registry.js';
+import { EndpointToolPolicy } from './policy.js';
+import type { EndpointUploadService } from './upload-service.js';
+type ToolClientMessage = Exclude<ClientEndpointMessage, {
+    type: `endpoint.${string}`;
+}>;
+export interface EndpointInvocationAuditSink {
+    started(params: {
+        id: string;
+        principalId: string;
+        endpointId: string;
+        toolCallId: string;
+        toolName: string;
+        effect: 'read' | 'write' | 'destructive';
+        confirmationRequired: boolean;
+        argumentsSha256: string;
+        startedAt: number;
+    }): void;
+    finished(params: {
+        id: string;
+        status: 'succeeded' | 'failed';
+        errorCode?: EndpointToolErrorCode;
+        errorMessage?: string;
+        completedAt: number;
+    }): void;
+}
+export interface EndpointInvocationServiceOptions {
+    audit?: EndpointInvocationAuditSink;
+    uploads?: EndpointUploadService;
+    policy?: EndpointToolPolicy;
+}
+export interface EndpointInvocationResult {
+    content: EndpointToolContent[];
+    details?: Record<string, unknown>;
+}
+export declare class EndpointToolExecutionError extends Error {
+    readonly code: EndpointToolErrorCode;
+    constructor(code: EndpointToolErrorCode, message: string);
+}
+export declare class EndpointInvocationService {
+    private readonly registry;
+    private readonly options;
+    private readonly pending;
+    private readonly policy;
+    constructor(registry: EndpointRegistry, options?: EndpointInvocationServiceOptions);
+    invoke(params: {
+        endpointId: string;
+        toolCallId: string;
+        toolName: string;
+        arguments: Record<string, unknown>;
+        descriptorRevision: string;
+        signal?: AbortSignal;
+        onProgress?: (progress: {
+            message?: string;
+            percent?: number;
+        }) => void;
+    }): Promise<EndpointInvocationResult>;
+    handleMessage(endpointId: string, message: ToolClientMessage): void;
+    failEndpoint(endpointId: string): void;
+    close(): void;
+    private cancel;
+    private succeed;
+    private fail;
+    private take;
+    private error;
+}
+export {};

package/dist/src/endpoint-tools/invocation-service.js

@@ -0,0 +1,190 @@
+import { ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS, canonicalJson } from "../../packages/endpoint-tools-protocol/src/index.js";
+import { EndpointToolPolicy, EndpointToolPolicyError } from "./policy.js";
+import crypto from "node:crypto";
+//#region src/endpoint-tools/invocation-service.ts
+var EndpointToolExecutionError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "EndpointToolExecutionError";
+	}
+};
+var EndpointInvocationService = class {
+	pending = /* @__PURE__ */ new Map();
+	policy;
+	constructor(registry, options = {}) {
+		this.registry = registry;
+		this.options = options;
+		this.policy = options.policy ?? new EndpointToolPolicy();
+	}
+	invoke(params) {
+		const endpoint = this.registry.get(params.endpointId);
+		if (!endpoint) return Promise.reject(this.error("ENDPOINT_OFFLINE", "Endpoint is offline"));
+		const tool = this.registry.getTool(params.endpointId, params.toolName);
+		if (!tool) return Promise.reject(this.error("TOOL_NOT_FOUND", "Endpoint tool is unavailable"));
+		if (tool.revision !== params.descriptorRevision) return Promise.reject(this.error("TOOL_REVISION_MISMATCH", "Endpoint tool contract changed"));
+		let confirmationRequired;
+		try {
+			confirmationRequired = this.policy.evaluate(tool.descriptor, endpoint.availability).confirmationRequired;
+		} catch (error) {
+			if (error instanceof EndpointToolPolicyError) return Promise.reject(this.error("ENDPOINT_NOT_FOREGROUND", error.message));
+			throw error;
+		}
+		if (params.signal?.aborted) return Promise.reject(this.error("TOOL_CANCELLED", "Endpoint tool call was cancelled"));
+		const endpointPending = [...this.pending.values()].filter((item) => item.endpointId === params.endpointId);
+		if (endpointPending.length >= 4) return Promise.reject(this.error("TOOL_BUSY", "Endpoint has reached its invocation limit"));
+		if (endpointPending.filter((item) => item.toolName === params.toolName).length >= tool.descriptor.maxConcurrency) return Promise.reject(this.error("TOOL_BUSY", "Endpoint tool has reached its invocation limit"));
+		const invocationId = crypto.randomUUID();
+		const startedAt = Date.now();
+		const uploadGrant = tool.descriptor.resultKinds.includes("file") ? this.options.uploads?.createGrant(invocationId, params.endpointId, startedAt) : void 0;
+		try {
+			this.options.audit?.started({
+				id: invocationId,
+				principalId: endpoint.principalId,
+				endpointId: params.endpointId,
+				toolCallId: params.toolCallId,
+				toolName: params.toolName,
+				effect: tool.descriptor.effect,
+				confirmationRequired,
+				argumentsSha256: crypto.createHash("sha256").update(canonicalJson(params.arguments)).digest("hex"),
+				startedAt
+			});
+		} catch (error) {
+			this.options.uploads?.abort(invocationId);
+			return Promise.reject(error);
+		}
+		return new Promise((resolve, reject) => {
+			const pending = {
+				id: invocationId,
+				endpointId: params.endpointId,
+				toolName: params.toolName,
+				state: "sent",
+				receiptTimer: setTimeout(() => {
+					this.fail(invocationId, this.error("TOOL_TIMEOUT", "Endpoint did not receive the invocation"));
+				}, ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS),
+				deadlineTimer: setTimeout(() => {
+					this.cancel(invocationId, "Endpoint tool timed out", "TOOL_TIMEOUT");
+				}, tool.descriptor.timeoutMs),
+				abortSignal: params.signal,
+				onProgress: params.onProgress,
+				resolve,
+				reject
+			};
+			if (params.signal) {
+				pending.abortHandler = () => this.cancel(invocationId, "Agent cancelled the tool call", "TOOL_CANCELLED");
+				params.signal.addEventListener("abort", pending.abortHandler, { once: true });
+			}
+			this.pending.set(invocationId, pending);
+			try {
+				this.registry.send(params.endpointId, "tool.invoke", {
+					invocationId,
+					toolCallId: params.toolCallId,
+					toolName: params.toolName,
+					arguments: params.arguments,
+					descriptorRevision: params.descriptorRevision,
+					confirmationRequired,
+					deadlineAt: Date.now() + tool.descriptor.timeoutMs,
+					...uploadGrant ? { uploadGrant } : {}
+				});
+			} catch {
+				this.fail(invocationId, this.error("ENDPOINT_DISCONNECTED", "Endpoint disconnected before invocation"));
+			}
+		});
+	}
+	handleMessage(endpointId, message) {
+		const invocationId = message.payload.invocationId;
+		const pending = this.pending.get(invocationId);
+		if (!pending || pending.endpointId !== endpointId) return;
+		switch (message.type) {
+			case "tool.received":
+				if (pending.state !== "sent") return;
+				pending.state = "running";
+				clearTimeout(pending.receiptTimer);
+				return;
+			case "tool.progress":
+				if (pending.state !== "running") return;
+				pending.onProgress?.({
+					...message.payload.message === void 0 ? {} : { message: message.payload.message },
+					...message.payload.percent === void 0 ? {} : { percent: message.payload.percent }
+				});
+				return;
+			case "tool.result":
+				if (pending.state !== "running") return;
+				try {
+					this.options.uploads?.validateAndClose(invocationId, message.payload.content);
+				} catch (error) {
+					this.fail(invocationId, this.error("PROTOCOL_ERROR", error instanceof Error ? error.message : String(error)));
+					return;
+				}
+				this.succeed(invocationId, {
+					content: message.payload.content,
+					...message.payload.details === void 0 ? {} : { details: message.payload.details }
+				});
+				return;
+			case "tool.error":
+				this.fail(invocationId, this.error(message.payload.code, message.payload.message));
+				return;
+			case "tool.cancelled": this.fail(invocationId, this.error("TOOL_CANCELLED", "Endpoint cancelled the tool call"));
+		}
+	}
+	failEndpoint(endpointId) {
+		for (const pending of this.pending.values()) if (pending.endpointId === endpointId) this.fail(pending.id, this.error("ENDPOINT_DISCONNECTED", "Endpoint disconnected"));
+	}
+	close() {
+		for (const pending of this.pending.values()) this.fail(pending.id, this.error("ENDPOINT_DISCONNECTED", "Endpoint runtime stopped"));
+	}
+	cancel(invocationId, reason, code) {
+		const pending = this.pending.get(invocationId);
+		if (!pending) return;
+		try {
+			this.registry.send(pending.endpointId, "tool.cancel", {
+				invocationId,
+				reason
+			});
+		} catch {}
+		this.fail(invocationId, this.error(code, reason));
+	}
+	succeed(invocationId, result) {
+		const pending = this.take(invocationId);
+		if (!pending) return;
+		try {
+			this.options.audit?.finished({
+				id: invocationId,
+				status: "succeeded",
+				completedAt: Date.now()
+			});
+		} finally {
+			pending.resolve(result);
+		}
+	}
+	fail(invocationId, error) {
+		const pending = this.take(invocationId);
+		if (!pending) return;
+		try {
+			this.options.uploads?.abort(invocationId);
+			this.options.audit?.finished({
+				id: invocationId,
+				status: "failed",
+				...error instanceof EndpointToolExecutionError ? { errorCode: error.code } : {},
+				errorMessage: error.message,
+				completedAt: Date.now()
+			});
+		} finally {
+			pending.reject(error);
+		}
+	}
+	take(invocationId) {
+		const pending = this.pending.get(invocationId);
+		if (!pending) return void 0;
+		this.pending.delete(invocationId);
+		clearTimeout(pending.receiptTimer);
+		clearTimeout(pending.deadlineTimer);
+		if (pending.abortSignal && pending.abortHandler) pending.abortSignal.removeEventListener("abort", pending.abortHandler);
+		return pending;
+	}
+	error(code, message) {
+		return new EndpointToolExecutionError(code, message);
+	}
+};
+//#endregion
+export { EndpointInvocationService, EndpointToolExecutionError };

package/dist/src/endpoint-tools/policy.d.ts

@@ -0,0 +1,10 @@
+import type { EndpointAvailability, EndpointKind, EndpointToolDescriptor } from '@xopcai/endpoint-tools-protocol';
+export interface EndpointToolPolicyDecision {
+    confirmationRequired: boolean;
+}
+export declare class EndpointToolPolicyError extends Error {
+}
+export declare class EndpointToolPolicy {
+    validateDescriptor(kind: EndpointKind, descriptor: EndpointToolDescriptor): void;
+    evaluate(descriptor: EndpointToolDescriptor, availability: EndpointAvailability): EndpointToolPolicyDecision;
+}

package/dist/src/endpoint-tools/policy.js

@@ -0,0 +1,18 @@
+//#region src/endpoint-tools/policy.ts
+var EndpointToolPolicyError = class extends Error {};
+var EndpointToolPolicy = class {
+	validateDescriptor(kind, descriptor) {
+		if (!descriptor.name.startsWith(`${kind}.`)) throw new EndpointToolPolicyError(`Tool ${descriptor.name} does not belong to ${kind}`);
+		if (descriptor.effect !== "read") {
+			if (descriptor.confirmation !== "always") throw new EndpointToolPolicyError(`Mutating tool ${descriptor.name} must always require confirmation`);
+			if (!descriptor.requiresForeground) throw new EndpointToolPolicyError(`Mutating tool ${descriptor.name} must require foreground`);
+			if (descriptor.requiredPermissions.length === 0) throw new EndpointToolPolicyError(`Mutating tool ${descriptor.name} must declare a permission`);
+		}
+	}
+	evaluate(descriptor, availability) {
+		if (descriptor.requiresForeground && availability !== "foreground") throw new EndpointToolPolicyError("Endpoint is not in the foreground");
+		return { confirmationRequired: descriptor.confirmation === "always" || descriptor.effect !== "read" };
+	}
+};
+//#endregion
+export { EndpointToolPolicy, EndpointToolPolicyError };