@xopcai/xopc 0.0.400 → 0.0.402

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

@@ -1,11 +1,11 @@
 import { creditDecimal } from "../../../packages/gateway-contract/src/cloud-credits.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { AgentCatalogRepository, init_repository } from "../../agent-catalog/repository.js";
-import { AgentCatalogService } from "../../agent-catalog/service.js";
 import { getAgentDefaultModelRef, init_schema } from "../../config/schema.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
 import { getAllModels, getAvailableModels, getConfiguredProviders, getProviderAuthState, getProviderDisplayName, init_providers, isProviderConfigured, providerSupportsApiKey, providerSupportsOAuth, resolveModel } from "../../providers/index.js";
 import { XopcCloudAccountService } from "../../providers/xopc-cloud-account-service.js";
+import { AgentCatalogService } from "../../agent-catalog/service.js";
 import { listImageProviderSpecs } from "../../../packages/image-providers/src/catalog.js";
 import "../../../packages/image-providers/src/index.js";
 import { loadConfig } from "../../config/loader.js";

package/dist/src/cli/commands/onboard/model.js

@@ -1,12 +1,12 @@
 import { AgentCatalogRepository, init_repository } from "../../../agent-catalog/repository.js";
-import { AgentCatalogService } from "../../../agent-catalog/service.js";
-import { ConfigSchema, getAgentDefaultModelRef, init_schema } from "../../../config/schema.js";
 import { resolveModelsJsonPath } from "../../../config/paths.js";
+import { ConfigSchema, getAgentDefaultModelRef, init_schema } from "../../../config/schema.js";
 import { init_models_json, loadModelsJson, saveModelsJson } from "../../../config/models-json.js";
 import { getApiKeyFromEnv } from "../../../providers/env-keys.js";
 import { getModelRegistry } from "../../../providers/model-registry.js";
 import { CredentialResolver, init_credentials } from "../../../auth/credentials.js";
 import { getAllProviders, getModelsByProvider, getProviderDisplayName, init_providers, providerSupportsApiKey, providerSupportsOAuth } from "../../../providers/index.js";
+import { AgentCatalogService } from "../../../agent-catalog/service.js";
 import { prepareUpdateGlobalDefaults } from "../../../gateway/global-defaults-admin.js";
 import { discoverProviderModels, isProviderApiDiscoverable } from "../../../providers/model-discovery.js";
 import { getXopcCloudCatalogCoordinator } from "../../../providers/xopc-cloud-catalog-coordinator.js";

package/dist/src/cli/utils/init-workspace-core.js

@@ -1,6 +1,6 @@
 import { AgentCatalogRepository, init_repository } from "../../agent-catalog/repository.js";
-import { AgentCatalogService } from "../../agent-catalog/service.js";
 import { ConfigSchema, init_schema } from "../../config/schema.js";
+import { AgentCatalogService } from "../../agent-catalog/service.js";
 import { assertConfigRewriteSafeForRunningGateway, saveConfig } from "../../config/loader.js";
 import { ensureStarterAgentsInitialized } from "../../agent/starter-agents.js";
 import { bootstrapApplicationStateSync } from "../../bootstrap/application-state.js";

package/dist/src/config/agent-model-intents.js

@@ -1,8 +1,8 @@
 import { ModelIntentSchema } from "../agent-config/schema.js";
 import { init_agent_config } from "../agent-config/index.js";
 import { getModelUsageOrigin, init_model_usage } from "../providers/model-usage.js";
-import { resolveEffectiveAgentConfigForAgent } from "./agent-profile.js";
 import { init_schema, parseModelRef } from "./schema.js";
+import { resolveEffectiveAgentConfigForAgent } from "./agent-profile.js";
 //#region src/config/agent-model-intents.ts
 init_model_usage();
 init_agent_config();

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

@@ -1,6 +1,6 @@
+import { normalizeAgentId } from "../agent-catalog/id.js";
 import { resolveEffectiveAgentConfig } from "../agent-config/resolver.js";
 import { init_agent_config } from "../agent-config/index.js";
-import { normalizeAgentId } from "../agent-catalog/id.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
 import { init_agent_scope, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
 import { getConversationRouting } from "../storage/sqlite/conversation-repository.js";

package/dist/src/config/index.js

@@ -2,12 +2,12 @@ import { ENV_VARS, XOPC_DB_FILENAME, resolveHomeDir, resolveStateDir, resolveXop
 import { expandWorkspacePathString, init_workspace_path, normalizeWorkspaceDir, resolveWorkspaceRoot } from "./workspace-path.js";
 import { resolveDefaultAgentWorkspaceDir } from "./workspace-defaults.js";
 import { resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
-import { extractProfileAgentId, resolveEffectiveAgentConfigForAgent, resolveEffectiveAgentConfigForSession, resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession } from "./agent-profile.js";
+import { FILENAMES, WORKSPACE_FILES, existsSync, hasBundledExtensionManifest, init_paths, resolveAgentAuthProfilesPath, resolveAgentDir, resolveAgentHomeDir, resolveAgentProfileDir, resolveAgentProfileMarkdownPath, resolveAuthProfilesPath, resolveBinDir, resolveBundledExtensionsDir, resolveBundledSkillsDir, resolveConfigPath, resolveCredentialsDir, resolveExtensionSdkPath, resolveExtensionsDir, resolveExtensionsLockPath, resolveInboxDir, resolveInboxMessagePath, resolveInboxPendingDir, resolveInboxProcessedDir, resolveLogPath, resolveLogsDir, resolveModelsJsonPath, resolveNodeBinDir, resolveNodeBinPath, resolveNodeToolsDir, resolveNpmBinPath, resolveOAuthPath, resolvePidPath, resolveSkillPath, resolveSkillsCachePath, resolveSkillsDir, resolveSkillsLockPath, resolveSocketPath, resolveStatusPath, resolveToolsDir, resolveWorkspaceExtensionsDir, resolveWorkspaceFile, resolveWorkspaceStateDir, resolveWorkspaceStatePath, resolveXopcBinPath } from "./paths.js";
 import { TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema } from "../../extensions/telegram/src/config-schema.js";
 import { WeixinAccountConfigSchema, WeixinConfigSchema } from "../../extensions/weixin/src/config-schema.js";
 import { AgentImageGenerationModelSchema, AgentModelRefSchema, AgentModelsSchema, BrowserConfigSchema, ChannelsConfigSchema, CommandsConfigSchema, ConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, GatewayAuthRateLimitSchema, GatewayAuthSchema, GatewayBindModeSchema, GatewayChannelConnectDeferModeSchema, GatewayConfigSchema, GatewayModeSchema, GatewayRemoteSchema, GatewaySecuritySchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayTlsSchema, GatewayTrustedProxySchema, GatewayWebchatConfigSchema, McpConfigSchema, McpOAuthConfigSchema, McpServerSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, MessagesConfigSchema, ModelCatalogConfigSchema, ModelsDevConfigSchema, ProviderAuthConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProvidersConfigSchema, RuntimeToolsConfigSchema, STTConfigSchema, STTFallbackConfigSchema, STTProviderConfigSchema, SearchProviderEntrySchema, SessionConfigSchema, SessionDmScopeSchema, SessionResetByTypeSchema, SessionResetConfigSchema, SessionResetModeSchema, SessionScopeSchema, SessionStorageConfigSchema, TTSConfigSchema, TTSEdgeConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSProviderConfigSchema, TTSSummarizationConfigSchema, ToolsConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, TunnelBrokerUrlSchema, TunnelConfigSchema, TunnelConsentSchema, UpdateAutoConfigSchema, UpdateConfigSchema, VoiceConfigSchema, VoiceRefinementConfigSchema, WebSearchConfigSchema, WebToolsConfigSchema, WebsiteBlocklistSchema, WorkspaceConfigSchema, WorkspaceImportConfigSchema, getAgentDefaultChatModelConfig, getAgentDefaultImageGenerationModelConfig, getAgentDefaultImageModelConfig, getAgentDefaultModelRef, init_schema, parseModelRef } from "./schema.js";
+import { extractProfileAgentId, resolveEffectiveAgentConfigForAgent, resolveEffectiveAgentConfigForSession, resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession } from "./agent-profile.js";
 import { clearConfigValueCache, getAllowedCommands, getCacheStats, init_resolve_config_value, resolveConfigValue, resolveHeaders, testApiKeyResolution } from "./resolve-config-value.js";
-import { FILENAMES, WORKSPACE_FILES, existsSync, hasBundledExtensionManifest, init_paths, resolveAgentAuthProfilesPath, resolveAgentDir, resolveAgentHomeDir, resolveAgentProfileDir, resolveAgentProfileMarkdownPath, resolveAuthProfilesPath, resolveBinDir, resolveBundledExtensionsDir, resolveBundledSkillsDir, resolveConfigPath, resolveCredentialsDir, resolveExtensionSdkPath, resolveExtensionsDir, resolveExtensionsLockPath, resolveInboxDir, resolveInboxMessagePath, resolveInboxPendingDir, resolveInboxProcessedDir, resolveLogPath, resolveLogsDir, resolveModelsJsonPath, resolveNodeBinDir, resolveNodeBinPath, resolveNodeToolsDir, resolveNpmBinPath, resolveOAuthPath, resolvePidPath, resolveSkillPath, resolveSkillsCachePath, resolveSkillsDir, resolveSkillsLockPath, resolveSocketPath, resolveStatusPath, resolveToolsDir, resolveWorkspaceExtensionsDir, resolveWorkspaceFile, resolveWorkspaceStateDir, resolveWorkspaceStatePath, resolveXopcBinPath } from "./paths.js";
 import { CustomModelSchema, ImageGenerationCapabilitiesSchema, ImageGenerationModelSchema, ImageGenerationProviderSchema, ModelOverrideSchema, ModelsJsonSchema, OpenAICompatSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenRouterRoutingSchema, ProviderConfigSchema, VercelGatewayRoutingSchema, getDefaultModelValues, init_models_json, loadModelsJson, modelsJsonExists, saveModelsJson, validateModelsConfig } from "./models-json.js";
 import { getWorkspacePath } from "./workspace-path-helpers.js";
 import { applyConfigOverrides, getConfigOverrides, resetConfigOverrides, setConfigOverride, unsetConfigOverride } from "./runtime-overrides.js";

package/dist/src/config/loader.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.js";
-import { ConfigSchema, init_schema } from "./schema.js";
 import { init_paths, resolveConfigPath } from "./paths.js";
+import { ConfigSchema, init_schema } from "./schema.js";
 import { init_resolution, setActivePlatformDiscovery } from "../platform/resolution.js";
 import { assertChannelPluginConfigs } from "./validate-channel-configs.js";
 import { isGatewayConfigLockedByAnotherProcessSync } from "../gateway/lock.js";

package/dist/src/config/models-json.js

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { init_write_file_atomic, writeTextAtomicSync } from "../infra/write-file-atomic.js";
-import { ComputerProfileSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { init_paths, resolveModelsJsonPath } from "./paths.js";
+import { ComputerProfileSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { init_model_policy, isComputerModel } from "../computer/model-policy.js";
 import { assertCurrentModelProvider, init_provider_policy } from "../providers/provider-policy.js";
 import { existsSync, readFileSync } from "fs";

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

@@ -1173,16 +1173,38 @@ export declare const McpServerSchema: z.ZodObject<{
             fieldKey: z.ZodString;
             prefix: z.ZodOptional<z.ZodString>;
             suffix: z.ZodOptional<z.ZodString>;
+            urlPolicy: z.ZodOptional<z.ZodObject<{
+                domains: z.ZodArray<z.ZodString>;
+                pathPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                encodeValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
         }, z.core.$strip>;
     }, z.core.$strip>]>>>;
     cwd: z.ZodOptional<z.ZodString>;
-    url: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        xopcSecretRef: z.ZodObject<{
+            provider: z.ZodString;
+            fieldKey: z.ZodString;
+            prefix: z.ZodOptional<z.ZodString>;
+            suffix: z.ZodOptional<z.ZodString>;
+            urlPolicy: z.ZodOptional<z.ZodObject<{
+                domains: z.ZodArray<z.ZodString>;
+                pathPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                encodeValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         xopcSecretRef: z.ZodObject<{
             provider: z.ZodString;
             fieldKey: z.ZodString;
             prefix: z.ZodOptional<z.ZodString>;
             suffix: z.ZodOptional<z.ZodString>;
+            urlPolicy: z.ZodOptional<z.ZodObject<{
+                domains: z.ZodArray<z.ZodString>;
+                pathPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                encodeValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
         }, z.core.$strip>;
     }, z.core.$strip>]>>>;
     oauth: z.ZodOptional<z.ZodObject<{
@@ -1238,16 +1260,38 @@ export declare const McpConfigSchema: z.ZodOptional<z.ZodObject<{
                 fieldKey: z.ZodString;
                 prefix: z.ZodOptional<z.ZodString>;
                 suffix: z.ZodOptional<z.ZodString>;
+                urlPolicy: z.ZodOptional<z.ZodObject<{
+                    domains: z.ZodArray<z.ZodString>;
+                    pathPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    encodeValue: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
             }, z.core.$strip>;
         }, z.core.$strip>]>>>;
         cwd: z.ZodOptional<z.ZodString>;
-        url: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            xopcSecretRef: z.ZodObject<{
+                provider: z.ZodString;
+                fieldKey: z.ZodString;
+                prefix: z.ZodOptional<z.ZodString>;
+                suffix: z.ZodOptional<z.ZodString>;
+                urlPolicy: z.ZodOptional<z.ZodObject<{
+                    domains: z.ZodArray<z.ZodString>;
+                    pathPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    encodeValue: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             xopcSecretRef: z.ZodObject<{
                 provider: z.ZodString;
                 fieldKey: z.ZodString;
                 prefix: z.ZodOptional<z.ZodString>;
                 suffix: z.ZodOptional<z.ZodString>;
+                urlPolicy: z.ZodOptional<z.ZodObject<{
+                    domains: z.ZodArray<z.ZodString>;
+                    pathPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    encodeValue: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
             }, z.core.$strip>;
         }, z.core.$strip>]>>>;
         oauth: z.ZodOptional<z.ZodObject<{
@@ -1895,16 +1939,38 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                     fieldKey: z.ZodString;
                     prefix: z.ZodOptional<z.ZodString>;
                     suffix: z.ZodOptional<z.ZodString>;
+                    urlPolicy: z.ZodOptional<z.ZodObject<{
+                        domains: z.ZodArray<z.ZodString>;
+                        pathPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        encodeValue: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>;
             }, z.core.$strip>]>>>;
             cwd: z.ZodOptional<z.ZodString>;
-            url: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                xopcSecretRef: z.ZodObject<{
+                    provider: z.ZodString;
+                    fieldKey: z.ZodString;
+                    prefix: z.ZodOptional<z.ZodString>;
+                    suffix: z.ZodOptional<z.ZodString>;
+                    urlPolicy: z.ZodOptional<z.ZodObject<{
+                        domains: z.ZodArray<z.ZodString>;
+                        pathPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        encodeValue: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>]>>;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                 xopcSecretRef: z.ZodObject<{
                     provider: z.ZodString;
                     fieldKey: z.ZodString;
                     prefix: z.ZodOptional<z.ZodString>;
                     suffix: z.ZodOptional<z.ZodString>;
+                    urlPolicy: z.ZodOptional<z.ZodObject<{
+                        domains: z.ZodArray<z.ZodString>;
+                        pathPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        encodeValue: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>;
             }, z.core.$strip>]>>>;
             oauth: z.ZodOptional<z.ZodObject<{

package/dist/src/config/schema.js

@@ -3,11 +3,11 @@ import { AgentModelsOverrideSchema, ImageGenerationRouteSchema, ModelRouteSchema
 import { resolveEffectiveAgentConfig } from "../agent-config/resolver.js";
 import { init_agent_config } from "../agent-config/index.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, init_config } from "../user-context/config.js";
 import { getModelUsageOrigin, init_model_usage } from "../providers/model-usage.js";
-import { TracingConfigSchema, init_config as init_config$1 } from "../observability/config.js";
+import { TracingConfigSchema, init_config } from "../observability/config.js";
 import { OutboundProxySchema, init_outbound_proxy } from "./outbound-proxy.js";
-import { ComputerConfigSchema, init_config as init_config$2 } from "../computer/config.js";
+import { ComputerConfigSchema, init_config as init_config$1 } from "../computer/config.js";
+import { DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, init_config as init_config$2 } from "../user-context/config.js";
 import { init_public_url, validatePublicUrl } from "./public-url.js";
 import { PlatformConfigSchema, init_contracts } from "../platform/contracts.js";
 import { deepseekSearchEndpoint, init_deepseek_protocol } from "../agent/tools/search/providers/deepseek-protocol.js";
@@ -53,12 +53,12 @@ function parseModelRef(ref) {
 var AgentModelRefSchema, AgentImageGenerationModelSchema, AgentModelsSchema, BrowserDriverSchema, BrowserHostnameSchema, BrowserConfigSchema, SessionDmScopeSchema, SessionStorageConfigSchema, SessionResetModeSchema, SessionResetConfigSchema, SessionResetByTypeSchema, SessionScopeSchema, SessionConfigSchema, ChannelsConfigSchema, SearchProviderEntrySchema, WebSearchConfigSchema, WebsiteBlocklistSchema, WebToolsConfigSchema, ToolsConfigSchema, RuntimePreferenceSchema, RuntimeProvisionSchema, RuntimeVersionRequestSchema, LanguageRuntimeSchema, DEFAULT_RUNTIME_TOOLS_CONFIG, RuntimeToolsConfigSchema, GatewayAuthRateLimitSchema, GatewaySecuritySchema, GatewayTrustedProxySchema, GatewayAuthSchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayRemoteSchema, GatewayTlsSchema, GatewayModeSchema, GatewayChannelConnectDeferModeSchema, TunnelConsentSchema, TunnelBrokerUrlSchema, 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, McpHttpUrlSchema, ConnectorSecretReferenceSchema, McpConfigScalarSchema, McpExposureSchema, McpOAuthConfigSchema, McpServerSchema, McpConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ConfigSchema;
 var init_schema = __esmMin((() => {
 	init_model_usage();
-	init_config$1();
+	init_config();
 	init_outbound_proxy();
-	init_config$2();
+	init_config$1();
 	init_agent_config();
 	init_repository();
-	init_config();
+	init_config$2();
 	init_public_url();
 	init_contracts();
 	init_deepseek_protocol();
@@ -928,7 +928,12 @@ tts: TTSConfigSchema.optional() }).optional();
 		provider: z.string().min(1),
 		fieldKey: z.string().min(1),
 		prefix: z.string().optional(),
-		suffix: z.string().optional()
+		suffix: z.string().optional(),
+		urlPolicy: z.object({
+			domains: z.array(z.string()).min(1),
+			pathPrefixes: z.array(z.string()).optional(),
+			encodeValue: z.boolean().optional()
+		}).strict().optional()
 	}) });
 	McpConfigScalarSchema = z.union([z.string(), ConnectorSecretReferenceSchema]);
 	McpExposureSchema = z.enum([
@@ -959,7 +964,7 @@ tts: TTSConfigSchema.optional() }).optional();
 		args: z.array(z.string()).optional(),
 		env: z.record(z.string(), McpConfigScalarSchema).optional(),
 		cwd: z.string().optional(),
-		url: McpHttpUrlSchema.optional(),
+		url: z.union([McpHttpUrlSchema, ConnectorSecretReferenceSchema]).optional(),
 		headers: z.record(z.string(), McpConfigScalarSchema).optional(),
 		oauth: McpOAuthConfigSchema.optional(),
 		auth: z.object({ provider: z.string().min(1) }).strict().optional(),

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

@@ -0,0 +1,7 @@
+export type ConnectorEndpointPolicy = {
+    domains: string[];
+    pathPrefixes?: string[];
+    encodeValue?: boolean;
+};
+export declare function validEndpointDomain(domain: string): boolean;
+export declare function assertConnectorEndpoint(value: string, policy: ConnectorEndpointPolicy): string;

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

@@ -0,0 +1,14 @@
+import { isIP } from "node:net";
+//#region src/connectors/endpoint-policy.ts
+function validEndpointDomain(domain) {
+	return /^(?:\*\.)?(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/i.test(domain) && !domain.endsWith(".localhost") && !domain.endsWith(".local");
+}
+function assertConnectorEndpoint(value, policy) {
+	const url = new URL(value);
+	const host = url.hostname.toLowerCase();
+	if (url.protocol !== "https:" || url.username || url.password || url.hash || isIP(host) || !policy.domains.length || policy.domains.some((domain) => !validEndpointDomain(domain)) || !policy.domains.some((domain) => domain.startsWith("*.") ? host.endsWith(domain.slice(1)) && host !== domain.slice(2) : host === domain.toLowerCase())) throw new Error("Connector endpoint must use HTTPS on a declared provider domain.");
+	if (policy.pathPrefixes?.length && !policy.pathPrefixes.some((prefix) => url.pathname === prefix || url.pathname.startsWith(`${prefix.replace(/\/$/, "")}/`))) throw new Error("Connector endpoint is outside the declared MCP path.");
+	return value;
+}
+//#endregion
+export { assertConnectorEndpoint, validEndpointDomain };

package/dist/src/connectors/materialize.js

@@ -1,5 +1,6 @@
 import { McpServerSchema, init_schema } from "../config/schema.js";
-import { createConnectorSecretReference } from "./secret-store.js";
+import { assertConnectorEndpoint } from "./endpoint-policy.js";
+import { createConnectorSecretReference, isConnectorSecretReference } from "./secret-store.js";
 //#region src/connectors/materialize.ts
 init_schema();
 const SERVER_ID_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
@@ -62,6 +63,20 @@ function materializeConnectorMcpServer(definition, input) {
 	assertValidConnectorServerId(serverId);
 	const rawServer = materializeTemplate(definition.runtime.serverTemplate, definition, input);
 	if (!rawServer || typeof rawServer !== "object" || Array.isArray(rawServer)) throw new Error("Connector MCP server template must resolve to a JSON object.");
+	const remote = rawServer;
+	if (isConnectorSecretReference(remote.url)) {
+		const templateUrl = definition.runtime.serverTemplate.url;
+		if (typeof templateUrl !== "string") throw new Error("Connector endpoint template is missing.");
+		const embedded = !TEMPLATE_PATTERN.test(templateUrl);
+		const policy = definition.runtime.endpointPolicy ?? { domains: [new URL(templateUrl.replace(EMBEDDED_SECRET_PATTERN, "credential")).hostname] };
+		remote.url.xopcSecretRef.urlPolicy = {
+			...policy,
+			...embedded ? { encodeValue: true } : {}
+		};
+		const key = remote.url.xopcSecretRef.fieldKey;
+		const rawInput = input.secrets?.[key];
+		if (typeof rawInput === "string" && !rawInput.startsWith("secret://")) assertConnectorEndpoint(`${remote.url.xopcSecretRef.prefix ?? ""}${embedded ? encodeURIComponent(rawInput) : rawInput}${remote.url.xopcSecretRef.suffix ?? ""}`, policy);
+	}
 	const marker = {
 		managed: true,
 		connectorId: definition.id,

package/dist/src/connectors/secret-store.js

@@ -1,5 +1,6 @@
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { consumeConnectorSetupSecretRef } from "./setup-secrets.js";
+import { assertConnectorEndpoint } from "./endpoint-policy.js";
 //#region src/connectors/secret-store.ts
 init_credentials();
 function normalizeSecretSegment(value) {
@@ -32,7 +33,9 @@ async function saveConnectorSecrets(definition, input, resolver = new Credential
 async function resolveSecretReference(reference, resolver) {
 	const value = await resolver.resolveApiKey(reference.xopcSecretRef.provider);
 	if (!value) return void 0;
-	return `${reference.xopcSecretRef.prefix ?? ""}${value}${reference.xopcSecretRef.suffix ?? ""}`;
+	const policy = reference.xopcSecretRef.urlPolicy;
+	const resolved = `${reference.xopcSecretRef.prefix ?? ""}${policy?.encodeValue ? encodeURIComponent(value) : value}${reference.xopcSecretRef.suffix ?? ""}`;
+	return policy ? assertConnectorEndpoint(resolved, policy) : resolved;
 }
 async function resolveConnectorSecretReferences(value, resolver = new CredentialResolver()) {
 	if (isConnectorSecretReference(value)) return resolveSecretReference(value, resolver);

package/dist/src/connectors/types.d.ts

@@ -43,6 +43,7 @@ export type ConnectorSecretReference = {
         fieldKey: string;
         prefix?: string;
         suffix?: string;
+        urlPolicy?: import('./endpoint-policy.js').ConnectorEndpointPolicy;
     };
 };
 export type ConnectorSecretField = {
@@ -74,6 +75,7 @@ export type ConnectorRuntimeDefinition = {
     type: 'mcp';
     serverId: string;
     serverTemplate: Record<string, unknown>;
+    endpointPolicy?: import('./endpoint-policy.js').ConnectorEndpointPolicy;
     localPackage?: {
         registry: 'npm';
         name: string;

package/dist/src/execution-environments/local-worktree-manager.js

@@ -8,8 +8,8 @@ import { assertManagedWorktreePath, assertNoNestedRegisteredWorktrees, readDirec
 import { dirname, resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { mkdir, rm, stat } from "node:fs/promises";
 import lockfile from "proper-lockfile";
+import { mkdir, rm, stat } from "node:fs/promises";
 //#region src/execution-environments/local-worktree-manager.ts
 init_logger();
 const log = createLogger("ExecutionEnvironment:LocalWorktree");

package/dist/src/extensions/agent-plugins/auth.js

@@ -1,8 +1,8 @@
 import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
 import { init_write_file_atomic, writeTextAtomic, writeTextAtomicSync } from "../../infra/write-file-atomic.js";
+import { pluginName } from "./validation.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
 import { isDangerousHostEnvVarName } from "../../infra/host-env-security.js";
-import { pluginName } from "./validation.js";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";

package/dist/src/extensions/agent-plugins/capability-access.d.ts

@@ -0,0 +1,23 @@
+import type { AgentPluginStore, InstalledAgentPlugin } from './store.js';
+export declare function pluginCapabilityAccess(manifest: InstalledAgentPlugin['manifest']): {
+    skills: Record<string, {
+        authorizations: (string | {
+            id: string;
+            scopes: string[];
+        })[];
+        servers: string[];
+    }>;
+    mcp: Record<string, {
+        authorizations: (string | {
+            id: string;
+            scopes: string[];
+        })[];
+        servers: string[];
+    }>;
+};
+/** One fail-closed access decision shared by Skill discovery and MCP projection. */
+export declare function resolvePluginCapabilityAccess(plugin: InstalledAgentPlugin, store: AgentPluginStore, now?: number): {
+    skill: (_name: string) => boolean;
+    server: (_name: string) => boolean;
+};
+export declare function pluginRuntimeAccessKey(store: AgentPluginStore, workspace: string, agentId?: string): string;

package/dist/src/extensions/agent-plugins/capability-access.js

@@ -0,0 +1,101 @@
+import { pluginAuthorizations } from "./setup-contract.js";
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { z } from "zod";
+//#region src/extensions/agent-plugins/capability-access.ts
+const authorization = z.union([z.string().min(1), z.strictObject({
+	id: z.string().min(1),
+	scopes: z.array(z.string().min(1)).max(100)
+})]);
+const requirement = z.strictObject({
+	authorizations: z.array(authorization).max(20).default([]),
+	servers: z.array(z.string().min(1)).max(20).default([])
+});
+const accessSchema = z.strictObject({
+	skills: z.record(z.string(), requirement).default({}),
+	mcp: z.record(z.string(), requirement).default({})
+});
+function pluginCapabilityAccess(manifest) {
+	const extension = manifest.extensions?.["ai.xopc"];
+	return accessSchema.parse(extension?.setup?.capabilityAccess ?? {});
+}
+const stateSchema = z.object({
+	packageRevision: z.string(),
+	state: z.string(),
+	installed: z.boolean().optional(),
+	resources: z.string(),
+	connections: z.array(z.object({
+		name: z.string(),
+		state: z.string()
+	})),
+	authorizations: z.array(z.object({
+		id: z.string(),
+		state: z.string(),
+		expiresAt: z.number().finite().optional(),
+		issues: z.array(z.object({ scopes: z.array(z.string()).default([]) })).default([])
+	})).default([])
+});
+/** One fail-closed access decision shared by Skill discovery and MCP projection. */
+function resolvePluginCapabilityAccess(plugin, store, now = Date.now()) {
+	let declarations, access;
+	try {
+		declarations = pluginAuthorizations(plugin.manifest);
+		access = pluginCapabilityAccess(plugin.manifest);
+	} catch {
+		return {
+			skill: (_name) => false,
+			server: (_name) => false
+		};
+	}
+	const path = join(store.stateDir, "plugin-setup", `${plugin.id}.json`);
+	let state, damaged = false;
+	if (existsSync(path)) try {
+		const parsed = stateSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+		if (parsed.packageRevision === plugin.receipt.revision) state = parsed;
+	} catch {
+		damaged = true;
+	}
+	const extension = plugin.manifest.extensions?.["ai.xopc"];
+	const prepared = !damaged && plugin.readiness !== "blocked" && (state ? state.resources === "ready" && (state.installed === true || state.state === "completed") && state.state !== "cancelled" : !extension?.setup?.resources?.length);
+	const connected = (name) => state?.connections.find((value) => value.name === name)?.state === "connected";
+	const requiresConnection = (name) => {
+		const server = plugin.servers[name];
+		if (!server) return true;
+		return server.type !== "stdio" ? server.connectionAuth?.mode !== "none" : Object.values(server.env ?? {}).some((value) => Object.entries(plugin.layout?.userConfig ?? {}).some(([key, field]) => field.sensitive && value.includes(`\${user_config.${key}}`)));
+	};
+	const granted = (entry) => {
+		const id = typeof entry === "string" ? entry : entry.id;
+		const declaration = declarations.find((value) => value.id === id);
+		const saved = state?.authorizations.find((value) => value.id === id);
+		if (!declaration || saved?.state !== "connected" || saved.expiresAt !== void 0 && saved.expiresAt <= now || !declaration.servers.every(connected)) return false;
+		return saved.issues.every((issue) => typeof entry !== "string" && issue.scopes.length > 0 && !issue.scopes.some((scope) => entry.scopes.includes(scope)));
+	};
+	const allows = (rule) => prepared && rule.authorizations.every(granted) && rule.servers.every(connected);
+	const defaults = {
+		authorizations: declarations.map((value) => value.id),
+		servers: declarations.length ? [] : Object.keys(plugin.servers).filter(requiresConnection)
+	};
+	return {
+		skill: (name) => allows(access.skills[name] ?? defaults),
+		server: (name) => {
+			const owners = declarations.filter((value) => value.servers.includes(name));
+			return allows(access.mcp[name] ?? {
+				authorizations: (owners.length ? owners : declarations).map((value) => value.id),
+				servers: []
+			}) && (state ? connected(name) : !requiresConnection(name));
+		}
+	};
+}
+function pluginRuntimeAccessKey(store, workspace, agentId) {
+	return JSON.stringify(store.active(agentId, workspace).map((plugin) => {
+		const access = resolvePluginCapabilityAccess(plugin, store);
+		return [
+			plugin.id,
+			plugin.receipt.revision,
+			plugin.skills.filter((skill) => access.skill(skill.name)).map((skill) => skill.name),
+			Object.keys(plugin.servers).filter(access.server)
+		];
+	}));
+}
+//#endregion
+export { pluginCapabilityAccess, pluginRuntimeAccessKey, resolvePluginCapabilityAccess };

package/dist/src/extensions/agent-plugins/cli-authorization.d.ts

@@ -24,6 +24,7 @@ export declare function inspectPluginCliAuthorization(store: AgentPluginStore, p
         method?: string;
         helpUrl?: string;
     }[];
+    expiresAt?: number;
 }>;
 export declare function checkPluginCliAuthorization(store: AgentPluginStore, plugin: InstalledAgentPlugin, authorization: string, method: CliMethod, signal: AbortSignal): Promise<boolean>;
 export declare function startPluginCliAuthorization(store: AgentPluginStore, plugin: InstalledAgentPlugin, authorization: string, method: CliMethod, owner: string): PluginCliAuthorization;

package/dist/src/extensions/agent-plugins/cli-authorization.js

@@ -1,7 +1,7 @@
-import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
-import { spawnProcess } from "../../process/run-process.js";
 import { parsePluginAuthorizationCheck, pluginAuthorizations, safeAuthorizationUrl } from "./setup-contract.js";
 import { containedPath, expandPluginVariables, resolvePluginCwd, validatePluginServer } from "./validation.js";
+import { spawnProcess } from "../../process/run-process.js";
+import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
 import { expandUserConfig, readPluginUserConfig } from "./user-config.js";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";

package/dist/src/extensions/agent-plugins/credentials.js

@@ -1,6 +1,6 @@
 import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
-import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
 import { pluginName, pluginServerId } from "./validation.js";
+import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
 import { createNativeMcpCredentials } from "../../agent/mcp/credential-store.js";
 import { pluginCredentialProviderPrefix } from "./auth.js";
 import { pluginOAuthCredentialId } from "./mcp-adapter.js";

package/dist/src/extensions/agent-plugins/inventory.js

@@ -16,7 +16,7 @@ function agentPluginInventoryRow(plugin, store = new AgentPluginStore()) {
 	try {
 		authorizations = pluginAuthorizations(plugin.manifest);
 	} catch {}
-	const needsAuthorization = !!job && ((job.missingConfig?.length ?? 0) > 0 || job.connections?.some((value) => value.state !== "connected") || job.authorizations?.some((value) => value.state !== "connected" || !!value.issues?.length));
+	const needsAuthorization = !job && (authorizations.length > 0 || Object.values(plugin.servers).some((server) => server.type !== "stdio" && server.connectionAuth?.mode !== "none")) || !!job && ((job.missingConfig?.length ?? 0) > 0 || job.connections?.some((value) => value.state !== "connected") || job.authorizations?.some((value) => value.state !== "connected" || !!value.issues?.length || value.expiresAt !== void 0 && value.expiresAt <= Date.now()));
 	return {
 		id: `plugin:${plugin.id}`,
 		pluginId: plugin.id,

package/dist/src/extensions/agent-plugins/mcp-adapter.js

@@ -1,10 +1,11 @@
+import { resolvePluginCapabilityAccess } from "./capability-access.js";
 import { containedPath, expandPluginVariables, pluginServerId, resolvePluginCwd } from "./validation.js";
 import { AgentPluginStore } from "./store.js";
 import { applyPluginAuthBinding, readPluginAuthBinding } from "./auth.js";
 import { expandUserConfig, readPluginUserConfig } from "./user-config.js";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { createHash } from "node:crypto";
 //#region src/extensions/agent-plugins/mcp-adapter.ts
 function pluginOAuthCredentialId(pluginId, revision, serverName) {
@@ -28,10 +29,9 @@ function materializePluginServers(plugin, store = new AgentPluginStore(), diagno
 	};
 	const expand = (value) => expandUserConfig(expandPluginVariables(value.replace(/\$\{PLUGIN_ACCOUNTS\}/g, join(data, "accounts", plugin.receipt.revision)).replace(/\$\{PLUGIN_RESOURCES\}/g, join(data, "resources", plugin.receipt.revision)), root, data), values);
 	const servers = Object.create(null);
-	const setupPath = join(store.stateDir, "plugin-setup", `${plugin.id}.json`);
-	const job = !setup && existsSync(setupPath) ? JSON.parse(readFileSync(setupPath, "utf8")) : void 0;
+	const access = setup ? void 0 : resolvePluginCapabilityAccess(plugin, store);
 	for (const [name, server] of Object.entries(plugin.servers)) try {
-		if (job?.packageRevision === plugin.receipt.revision && (job.state !== "completed" && !job.installed || job.connections.find((c) => c.name === name)?.state !== "connected")) continue;
+		if (access && !access.server(name)) continue;
 		const origin = {
 			id: plugin.id,
 			serverName: name,

package/dist/src/extensions/agent-plugins/refresh-runtime-access.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from '../../config/schema.js';
+/** Check provider-defined credentials before constructing a new turn's Skill index and MCP config. */
+export declare function refreshPluginRuntimeAccess(config: Config, workspace: string, agentId?: string): Promise<boolean>;