@xopcai/xopc 0.0.190 → 0.0.192

package/dist/src/agent/embedded/run-for-session.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
 import { resolveAgentTurnTimeoutMs } from "../orchestration/run-agent-turn-with-timeout.js";
 import { evaluateContextBudget } from "../memory/context-budget.js";
@@ -47,6 +48,7 @@ async function runEmbeddedTurnForSession(params) {
 	const thinkingLevel = params.thinkingOverride ?? agent.state.thinkingLevel;
 	const workspaceDir = agentManager.getResolvedWorkspaceForSession(sessionKey);
 	const config = params.getConfig?.();
+	const cacheRetention = config ? resolveEffectiveAgentProfileForSession(config, sessionKey).manifest.runtime?.promptCacheRetention : void 0;
 	const configuredTurnTimeoutMs = resolveAgentTurnTimeoutMs(config, sessionKey);
 	const turnTimeoutMs = params.deadlineAtMs === void 0 ? configuredTurnTimeoutMs : Math.max(1, Math.min(configuredTurnTimeoutMs, params.deadlineAtMs - Date.now()));
 	let userMessageForTurn = userMessage;
@@ -113,6 +115,7 @@ async function runEmbeddedTurnForSession(params) {
 					tools,
 					systemPrompt,
 					thinkingLevel,
+					cacheRetention,
 					workspaceDir,
 					sessionStore,
 					timeoutMs: turnTimeoutMs,

package/dist/src/agent/embedded/run-turn.js

@@ -173,7 +173,10 @@ async function runXopcEmbeddedTurn(params) {
 					tools: effectiveContext.tools
 				} } : {}
 			}, "Sending messages to AI");
-			return streamFnWithXopcExtensions(streamModel, effectiveContext, options);
+			return streamFnWithXopcExtensions(streamModel, effectiveContext, {
+				...options,
+				...params.cacheRetention ? { cacheRetention: params.cacheRetention } : {}
+			});
 		};
 		session.agent.streamFunction = loggingStreamFn;
 		if (onEvent) unsubscribe = subscribeEmbeddedSessionEvents(session, (event) => {

package/dist/src/agent/embedded/session-runner.js

@@ -19,16 +19,15 @@ function providerCredentialRevision(providerId) {
 }
 function buildEmbeddedRunnerFingerprint(input) {
 	const tools = [...input.toolNames].sort().join("\0");
-	const promptMarker = `${input.systemPrompt.length}:${input.systemPrompt.slice(0, 128)}`;
-	return [
+	return createHash("sha256").update([
 		input.sessionId,
 		input.workspaceDir,
 		input.modelRef,
 		tools,
-		promptMarker,
+		input.systemPrompt,
 		input.thinkingLevel,
 		input.credentialRevision
-	].join("");
+	].join("\0")).digest("base64url");
 }
 function isEmbeddedSessionRunnerEnabled() {
 	const raw = process.env.XOPC_SESSION_RUNNER?.trim().toLowerCase();

package/dist/src/agent/embedded/types.d.ts

@@ -1,5 +1,5 @@
 import type { AgentMessage, AgentToolResult, ThinkingLevel } from '@earendil-works/pi-agent-core';
-import type { AssistantMessageEvent, Model, Api, ImageContent } from '@earendil-works/pi-ai';
+import type { AssistantMessageEvent, Model, Api, CacheRetention, ImageContent } from '@earendil-works/pi-ai';
 import type { SessionStore } from '../../session/store.js';
 export type EmbeddedStreamEvent = {
     type: 'agent_start';
@@ -62,6 +62,14 @@ export type EmbeddedStreamEvent = {
         content: string;
         kind: string;
     }>;
+} | {
+    type: 'memory_candidate';
+    runId?: string;
+    records: Array<{
+        id: string;
+        content: string;
+        kind: string;
+    }>;
 } | {
     type: 'error';
     runId?: string;
@@ -83,6 +91,7 @@ export type RunXopcEmbeddedTurnParams = {
     tools: import('@earendil-works/pi-agent-core').AgentTool[];
     systemPrompt: string;
     thinkingLevel?: ThinkingLevel;
+    cacheRetention?: CacheRetention;
     workspaceDir: string;
     sessionStore: SessionStore;
     timeoutMs: number;

package/dist/src/agent/embedded/xopc-stream-bridge.js

@@ -1,6 +1,7 @@
 import "../../providers/constants.js";
 import { init_providers } from "../../providers/index.js";
 import { createExtensionAwareStreamFn } from "../../providers/extension-stream-bridge.js";
+import { preparePromptCacheContext, withPromptCachePayloadTransform } from "../../providers/prompt-cache-payload.js";
 //#region src/agent/embedded/xopc-stream-bridge.ts
 init_providers();
 /**
@@ -15,8 +16,8 @@ init_providers();
 function wrapStreamFnForXopcExtensions(originalStreamFn) {
 	const extensionStreamFn = createExtensionAwareStreamFn();
 	return ((model, context, options) => {
-		if (model.baseUrl === "extension://provider-plugin") return extensionStreamFn(model, context, options);
-		return originalStreamFn(model, context, options);
+		if (model.baseUrl === "extension://provider-plugin") return extensionStreamFn(model, preparePromptCacheContext(model, context), options);
+		return originalStreamFn(model, preparePromptCacheContext(model, context), withPromptCachePayloadTransform(model, context, options));
 	});
 }
 //#endregion

package/dist/src/agent/external-tools/mcp-provider.d.ts

@@ -25,5 +25,6 @@ export declare class McpToolProvider implements ExternalToolProvider {
     execute(toolRef: string, args: Record<string, unknown>, _approvalId: string | undefined, context: ExternalToolExecutionContext): Promise<AgentToolResult<Record<string, unknown>>>;
     private resolve;
     private isAllowed;
+    private executionSignal;
     private withRuntime;
 }

package/dist/src/agent/external-tools/mcp-provider.js

@@ -1,6 +1,6 @@
 import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { externalToolRef, parseExternalToolRef } from "./refs.js";
-import { isMcpCatalogToolDenied, mcpToolPolicyId } from "../mcp/bundle-mcp-policy.js";
+import { isMcpCatalogToolDenied, mcpToolPolicyId, resolveMcpToolPolicy } from "../mcp/bundle-mcp-policy.js";
 import { getOrCreateSessionMcpRuntime } from "../mcp/bundle-mcp-runtime.js";
 //#region src/agent/external-tools/mcp-provider.ts
 function policyToolId(tool) {
@@ -33,9 +33,9 @@ var McpToolProvider = class {
 	async search(_query) {
 		return this.withRuntime(async (runtime) => {
 			return (await runtime.getCatalog()).tools.filter((tool) => this.isAllowed(tool)).map((tool) => ({
-				toolRef: externalToolRef(this.source, tool.serverName, tool.toolName),
+				toolRef: externalToolRef(this.source, tool.safeServerName, tool.toolName),
 				source: this.source,
-				namespace: tool.serverName,
+				namespace: tool.safeServerName,
 				title: tool.title || tool.toolName,
 				summary: tool.description || tool.fallbackDescription
 			}));
@@ -71,7 +71,7 @@ var McpToolProvider = class {
 				if (!hook.allowed) throw new Error(hook.reason ?? "MCP tool call blocked by policy hook.");
 				executionArgs = hook.params ?? args;
 			}
-			const result = await runtime.callTool(tool.serverName, tool.toolName, executionArgs, context.signal);
+			const result = await runtime.callTool(tool.serverName, tool.toolName, executionArgs, this.executionSignal(tool, context.signal));
 			return toAgentToolResult({
 				serverName: tool.serverName,
 				toolName: tool.toolName,
@@ -82,7 +82,7 @@ var McpToolProvider = class {
 	async resolve(runtime, toolRef) {
 		const parsed = parseExternalToolRef(toolRef, this.source);
 		if (!parsed) return void 0;
-		const tool = (await runtime.getCatalog()).tools.find((candidate) => candidate.serverName === parsed.namespace && candidate.toolName === parsed.toolName);
+		const tool = (await runtime.getCatalog()).tools.find((candidate) => candidate.safeServerName === parsed.namespace && candidate.toolName === parsed.toolName);
 		return tool && this.isAllowed(tool) ? tool : void 0;
 	}
 	isAllowed(tool) {
@@ -90,11 +90,26 @@ var McpToolProvider = class {
 		const sessionKey = this.deps.getSessionKey();
 		const profile = cfg && sessionKey ? resolveEffectiveAgentProfileForSession(cfg, sessionKey) : void 0;
 		const policyName = policyToolId(tool);
-		return !profile?.tools.denied.has(policyName) && !isMcpCatalogToolDenied({
+		return !(resolveMcpToolPolicy({
+			serverId: tool.safeServerName,
+			policyToolId: policyName
+		}, profile?.manifest.tools.mcp)?.scope === "readonly" && tool.annotations?.readOnlyHint !== true) && !profile?.tools.denied.has(policyName) && !isMcpCatalogToolDenied({
 			serverId: tool.safeServerName,
 			policyToolId: policyName
 		}, profile?.manifest.tools.mcp);
 	}
+	executionSignal(tool, signal) {
+		const cfg = this.deps.getConfig();
+		const sessionKey = this.deps.getSessionKey();
+		const profile = cfg && sessionKey ? resolveEffectiveAgentProfileForSession(cfg, sessionKey) : void 0;
+		const timeoutMs = resolveMcpToolPolicy({
+			serverId: tool.safeServerName,
+			policyToolId: policyToolId(tool)
+		}, profile?.manifest.tools.mcp)?.limits?.timeoutMs;
+		if (!timeoutMs) return signal;
+		const timeoutSignal = AbortSignal.timeout(timeoutMs);
+		return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+	}
 	async withRuntime(run) {
 		const cfg = this.deps.getConfig();
 		const sessionKey = this.deps.getSessionKey();

package/dist/src/agent/image/generation/openai-images-provider.d.ts

@@ -43,7 +43,7 @@ export interface OpenAiImagesProviderOptions {
     /** Sync env / cfg lookup that decides if the provider has any usable credential. */
     isConfigured: (ctx: ImageGenerationProviderConfiguredContext) => boolean;
     /** Resolve API key for one request. May return null when using OAuth/header auth. */
-    resolveApiKey: (req: ImageGenerationRequest) => string | null | undefined;
+    resolveApiKey: (req: ImageGenerationRequest) => string | null | undefined | Promise<string | null | undefined>;
     /** Resolve endpoint info per-request (region, baseUrl override, Azure deployment, …). */
     resolveEndpoint: (req: ImageGenerationRequest) => OpenAiImagesEndpointResolution;
     /** Default per-call timeout. Combined with provider-level config in provider-http. */

package/dist/src/agent/image/generation/openai-images-provider.js

@@ -26,7 +26,7 @@ function createOpenAiImagesProvider(options) {
 		capabilities: options.capabilities,
 		isConfigured: options.isConfigured,
 		async generateImage(req) {
-			const apiKey = options.resolveApiKey(req) ?? null;
+			const apiKey = await options.resolveApiKey(req) ?? null;
 			const endpoint = options.resolveEndpoint(req);
 			const httpDefaults = resolveProviderHttpRequestConfig({
 				providerId: options.id,

package/dist/src/agent/image/generation/provider-registry.d.ts

@@ -2,6 +2,8 @@ import type { ModelsJsonConfig } from '../../../config/models-json.js';
 import type { ImageGenerationProvider, ImageGenerationProviderSummary } from './types.js';
 export declare function reloadImageGenerationProviders(config?: ModelsJsonConfig): void;
 export declare function getImageGenerationProvider(providerId: string): ImageGenerationProvider | undefined;
+/** Resolve the auth mode consistently for provider objects and catalog summaries. */
+export declare function resolveImageGenerationCredentialMode(provider: Pick<ImageGenerationProvider, 'credentialMode'>): NonNullable<ImageGenerationProvider['credentialMode']>;
 export declare function listImageGenerationProviders(): ImageGenerationProvider[];
 export declare function listImageGenerationProvidersSummary(): ImageGenerationProviderSummary[];
 export type { ImageGenerationProvider, ImageGenerationProviderSummary } from './types.js';

package/dist/src/agent/image/generation/provider-registry.js

@@ -7,24 +7,30 @@ import { buildFalImageGenerationProvider } from "./providers/fal.js";
 import { buildGoogleImageGenerationProvider } from "./providers/google.js";
 import { buildMinimaxImageGenerationProvider } from "./providers/minimax.js";
 import { buildOpenAIImageGenerationProvider } from "./providers/openai.js";
+import { buildXopcCloudImageGenerationProvider } from "./providers/xopc-cloud.js";
 //#region src/agent/image/generation/provider-registry.ts
 init_models_json();
 init_logger();
 const log = createLogger("ImageGenerationRegistry");
-const builtInProviders = [
-	buildOpenAIImageGenerationProvider(),
-	buildDashScopeImageGenerationProvider(),
-	buildMinimaxImageGenerationProvider(),
-	buildGoogleImageGenerationProvider(),
-	buildFalImageGenerationProvider()
-];
-let providers = [...builtInProviders];
+function buildBuiltInProviders() {
+	const cloud = buildXopcCloudImageGenerationProvider();
+	return [
+		...cloud ? [cloud] : [],
+		buildOpenAIImageGenerationProvider(),
+		buildDashScopeImageGenerationProvider(),
+		buildMinimaxImageGenerationProvider(),
+		buildGoogleImageGenerationProvider(),
+		buildFalImageGenerationProvider()
+	];
+}
+let providers = buildBuiltInProviders();
 let providersById = new Map(providers.map((provider) => [provider.id, provider]));
 let customProvidersLoaded = false;
 function ensureCustomProvidersLoaded() {
 	if (!customProvidersLoaded) reloadImageGenerationProviders();
 }
 function reloadImageGenerationProviders(config) {
+	const builtInProviders = buildBuiltInProviders();
 	let resolved = config;
 	if (!resolved) {
 		const loaded = loadModelsJson();
@@ -54,6 +60,10 @@ function getImageGenerationProvider(providerId) {
 	ensureCustomProvidersLoaded();
 	return providersById.get(providerId);
 }
+/** Resolve the auth mode consistently for provider objects and catalog summaries. */
+function resolveImageGenerationCredentialMode(provider) {
+	return provider.credentialMode ?? "api-key";
+}
 function listImageGenerationProviders() {
 	ensureCustomProvidersLoaded();
 	return [...providers];
@@ -64,9 +74,10 @@ function listImageGenerationProvidersSummary() {
 		id: provider.id,
 		label: provider.label,
 		source: provider.source ?? "builtin",
-		credentialMode: provider.credentialMode ?? "api-key",
+		credentialMode: resolveImageGenerationCredentialMode(provider),
 		...provider.documentationUrl ? { documentationUrl: provider.documentationUrl } : {},
 		...provider.apiKeyUrl ? { apiKeyUrl: provider.apiKeyUrl } : {},
+		configFields: structuredClone(provider.configFields ?? []),
 		defaultModel: provider.defaultModel,
 		models: [...provider.models],
 		capabilities: provider.capabilities,
@@ -74,4 +85,4 @@ function listImageGenerationProvidersSummary() {
 	}));
 }
 //#endregion
-export { getImageGenerationProvider, listImageGenerationProviders, listImageGenerationProvidersSummary, reloadImageGenerationProviders };
+export { getImageGenerationProvider, listImageGenerationProviders, listImageGenerationProvidersSummary, reloadImageGenerationProviders, resolveImageGenerationCredentialMode };

package/dist/src/agent/image/generation/providers/dashscope.js

@@ -211,6 +211,26 @@ function buildDashScopeImageGenerationProvider() {
 	return {
 		id: "dashscope",
 		label: "Alibaba Model Studio",
+		documentationUrl: "https://www.alibabacloud.com/help/en/model-studio/wan-image-generation-and-editing-api-reference",
+		apiKeyUrl: "https://dashscope.console.aliyun.com/apiKey",
+		configFields: [{
+			key: "region",
+			label: "Service region",
+			type: "select",
+			required: true,
+			options: [{
+				value: "cn",
+				label: "China"
+			}, {
+				value: "intl",
+				label: "International"
+			}]
+		}, {
+			key: "baseUrl",
+			label: "Base URL",
+			type: "url",
+			placeholder: "https://…"
+		}],
 		defaultModel: DASHSCOPE_DEFAULT_IMAGE_MODEL,
 		models: [...DASHSCOPE_IMAGE_MODELS],
 		capabilities: DASHSCOPE_CAPABILITIES,

package/dist/src/agent/image/generation/providers/fal.d.ts

@@ -1,5 +1,5 @@
 import type { ImageGenerationProvider, ImageGenerationRequest, ImageGenerationResult } from '../types.js';
-export declare const FAL_DEFAULT_IMAGE_MODEL = "fal-ai/flux/schnell";
+export declare const FAL_DEFAULT_IMAGE_MODEL = "fal-ai/flux-2";
 export declare const FAL_IMAGE_MODELS: readonly string[];
 /**
  * Resolve Fal queue base URL precedence:

package/dist/src/agent/image/generation/providers/fal.js

@@ -28,16 +28,14 @@ import "../../../../providers/auth-runtime/index.js";
 init_logger();
 const log = createLogger("ImageGen:Fal");
 const DEFAULT_FAL_QUEUE_BASE_URL = "https://queue.fal.run";
-const FAL_DEFAULT_IMAGE_MODEL = "fal-ai/flux/schnell";
+const FAL_DEFAULT_IMAGE_MODEL = "fal-ai/flux-2";
 const DEFAULT_TIMEOUT_MS = 6e5;
 const DEFAULT_POLL_INTERVAL_MS = 1500;
 const MAX_POLL_INTERVAL_MS = 5e3;
 const FAL_IMAGE_MODELS = [
 	FAL_DEFAULT_IMAGE_MODEL,
-	"fal-ai/flux/dev",
-	"fal-ai/flux-pro/v1.1",
-	"fal-ai/flux-pro/v1.1-ultra",
-	"fal-ai/nano-banana"
+	"fal-ai/flux-2-pro",
+	"fal-ai/nano-banana-2"
 ];
 const FAL_CAPABILITIES = {
 	generate: {
@@ -240,7 +238,7 @@ async function downloadFalImages(params) {
 async function generateFalImages(params) {
 	const { req, apiKey } = params;
 	const baseUrl = resolveFalBaseUrl(req);
-	const model = req.model?.trim() || "fal-ai/flux/schnell";
+	const model = req.model?.trim() || "fal-ai/flux-2";
 	const submitUrl = `${baseUrl}/${model}`;
 	const httpDefaults = resolveProviderHttpRequestConfig({
 		providerId: "fal",
@@ -291,6 +289,14 @@ function buildFalImageGenerationProvider() {
 	return {
 		id: "fal",
 		label: "Fal.ai",
+		documentationUrl: "https://docs.fal.ai/",
+		apiKeyUrl: "https://fal.ai/dashboard/keys",
+		configFields: [{
+			key: "baseUrl",
+			label: "Base URL",
+			type: "url",
+			placeholder: "https://queue.fal.run"
+		}],
 		defaultModel: FAL_DEFAULT_IMAGE_MODEL,
 		models: [...FAL_IMAGE_MODELS],
 		capabilities: FAL_CAPABILITIES,

package/dist/src/agent/image/generation/providers/google.js

@@ -210,6 +210,14 @@ function buildGoogleImageGenerationProvider() {
 	return {
 		id: "google",
 		label: "Google Gemini",
+		documentationUrl: "https://ai.google.dev/gemini-api/docs/image-generation",
+		apiKeyUrl: "https://aistudio.google.com/app/apikey",
+		configFields: [{
+			key: "baseUrl",
+			label: "Base URL",
+			type: "url",
+			placeholder: "https://generativelanguage.googleapis.com"
+		}],
 		defaultModel: GOOGLE_DEFAULT_IMAGE_MODEL,
 		models: [...GOOGLE_IMAGE_MODELS],
 		capabilities: GOOGLE_CAPABILITIES,

package/dist/src/agent/image/generation/providers/minimax.js

@@ -169,6 +169,26 @@ function buildMinimaxImageGenerationProvider() {
 	return {
 		id: "minimax",
 		label: "MiniMax",
+		documentationUrl: "https://platform.minimaxi.com/document/Image%20Generation",
+		apiKeyUrl: "https://platform.minimaxi.com/user-center/basic-information/interface-key",
+		configFields: [{
+			key: "region",
+			label: "Service region",
+			type: "select",
+			required: true,
+			options: [{
+				value: "cn",
+				label: "China"
+			}, {
+				value: "intl",
+				label: "International"
+			}]
+		}, {
+			key: "baseUrl",
+			label: "Base URL",
+			type: "url",
+			placeholder: "https://…"
+		}],
 		defaultModel: MINIMAX_DEFAULT_IMAGE_MODEL,
 		models: [...MINIMAX_IMAGE_MODELS],
 		capabilities: MINIMAX_CAPABILITIES,

package/dist/src/agent/image/generation/providers/openai.js

@@ -17,7 +17,7 @@ import { createOpenAiImagesProvider } from "../openai-images-provider.js";
 */
 const OPENAI_DEFAULT_BASE_URL = "https://api.openai.com/v1";
 /** Image models exposed by the OpenAI Images API. */
-const OPENAI_IMAGE_MODELS = ["gpt-image-2", "gpt-image-1.5"];
+const OPENAI_IMAGE_MODELS = ["gpt-image-2"];
 const OPENAI_DEFAULT_IMAGE_MODEL = OPENAI_IMAGE_MODELS[0];
 const OPENAI_CAPABILITIES = {
 	generate: {
@@ -93,32 +93,42 @@ function buildAzureEndpoint(azure) {
 	};
 }
 function buildOpenAIImageGenerationProvider() {
-	return createOpenAiImagesProvider({
-		id: "openai",
-		label: "OpenAI",
-		defaultModel: OPENAI_DEFAULT_IMAGE_MODEL,
-		models: [...OPENAI_IMAGE_MODELS],
-		capabilities: OPENAI_CAPABILITIES,
-		isConfigured: (ctx) => isProviderApiKeyConfigured({
-			providerId: "openai",
-			cfg: ctx.cfg,
-			agentId: ctx.agentId
-		}),
-		resolveApiKey: (req) => {
-			return resolveAuthProfileForProvider({
+	return {
+		...createOpenAiImagesProvider({
+			id: "openai",
+			label: "OpenAI",
+			defaultModel: OPENAI_DEFAULT_IMAGE_MODEL,
+			models: [...OPENAI_IMAGE_MODELS],
+			capabilities: OPENAI_CAPABILITIES,
+			isConfigured: (ctx) => isProviderApiKeyConfigured({
 				providerId: "openai",
-				cfg: req.cfg,
-				agentId: req.agentId,
-				store: req.authStore
-			}).apiKey ?? null;
-		},
-		resolveEndpoint: (req) => {
-			const azure = resolveAzureSettings(req);
-			if (azure) return buildAzureEndpoint(azure);
-			return { baseUrl: resolveOpenAiBaseUrl(req) };
-		},
-		defaultTimeoutMs: 12e4
-	});
+				cfg: ctx.cfg,
+				agentId: ctx.agentId
+			}),
+			resolveApiKey: (req) => {
+				return resolveAuthProfileForProvider({
+					providerId: "openai",
+					cfg: req.cfg,
+					agentId: req.agentId,
+					store: req.authStore
+				}).apiKey ?? null;
+			},
+			resolveEndpoint: (req) => {
+				const azure = resolveAzureSettings(req);
+				if (azure) return buildAzureEndpoint(azure);
+				return { baseUrl: resolveOpenAiBaseUrl(req) };
+			},
+			defaultTimeoutMs: 12e4
+		}),
+		documentationUrl: "https://platform.openai.com/docs/guides/image-generation",
+		apiKeyUrl: "https://platform.openai.com/api-keys",
+		configFields: [{
+			key: "baseUrl",
+			label: "Base URL",
+			type: "url",
+			placeholder: "https://api.openai.com/v1"
+		}]
+	};
 }
 //#endregion
 export { OPENAI_DEFAULT_IMAGE_MODEL, OPENAI_IMAGE_MODELS, buildOpenAIImageGenerationProvider };

package/dist/src/agent/image/generation/providers/xopc-cloud.d.ts

@@ -0,0 +1,2 @@
+import type { ImageGenerationProvider } from '../types.js';
+export declare function buildXopcCloudImageGenerationProvider(): ImageGenerationProvider | undefined;

package/dist/src/agent/image/generation/providers/xopc-cloud.js

@@ -0,0 +1,74 @@
+import { getModelCatalogStore, init_model_catalog_store } from "../../../../providers/model-catalog-store.js";
+import { init_xopc_cloud_config, resolveXopcModelRouterUrl } from "../../../../providers/xopc-cloud-config.js";
+import { getProviderAuthService, init_provider_auth_service } from "../../../../providers/provider-auth-service.js";
+import { createOpenAiImagesProvider } from "../openai-images-provider.js";
+//#region src/agent/image/generation/providers/xopc-cloud.ts
+init_model_catalog_store();
+init_provider_auth_service();
+init_xopc_cloud_config();
+function buildXopcCloudImageGenerationProvider() {
+	const source = getModelCatalogStore().getSource("xopc-cloud");
+	const models = source?.models.filter((model) => model.availability === "available" && model.kind === "image" && model.operations.includes("images.generate")) ?? [];
+	if (models.length === 0) return void 0;
+	const modelCapabilities = Object.fromEntries(models.map((model) => [model.id, toProviderCapabilities(model)]));
+	const defaultModel = models[0].id;
+	const baseUrl = source?.baseUrl ?? resolveXopcModelRouterUrl();
+	const executors = new Map(models.map((model) => [model.id, createOpenAiImagesProvider({
+		id: "xopc-cloud",
+		label: "XOPC Model Service",
+		defaultModel: model.id,
+		models: [model.id],
+		capabilities: modelCapabilities[model.id],
+		isConfigured: () => true,
+		resolveApiKey: (request) => getProviderAuthService().resolveApiKey("xopc-cloud", request.signal),
+		resolveEndpoint: () => ({ baseUrl }),
+		...model.imageGeneration?.sizes[0] ? { defaultSize: model.imageGeneration.sizes[0] } : {}
+	})]));
+	return {
+		id: "xopc-cloud",
+		label: "XOPC Model Service",
+		credentialMode: "oauth",
+		defaultModel,
+		models: models.map((model) => model.id),
+		capabilities: modelCapabilities[defaultModel],
+		modelCapabilities,
+		isConfigured: () => true,
+		async generateImage(request) {
+			const executor = executors.get(request.model);
+			if (!executor) throw new Error(`Image model is not available from XOPC Model Service: ${request.model}`);
+			const geometry = modelCapabilities[request.model]?.geometry;
+			const size = request.size ?? (request.aspectRatio && geometry?.aspectRatios?.includes(request.aspectRatio) ? request.aspectRatio : void 0) ?? (request.resolution && geometry?.resolutions?.includes(request.resolution) ? request.resolution : void 0);
+			return executor.generateImage({
+				...request,
+				...size ? { size } : {}
+			});
+		}
+	};
+}
+function toProviderCapabilities(model) {
+	const image = model.imageGeneration;
+	return {
+		generate: {
+			maxCount: image?.maxCount ?? 1,
+			supportsSize: Boolean(image?.sizes.length),
+			supportsAspectRatio: Boolean(image?.aspectRatios?.length)
+		},
+		edit: {
+			enabled: model.operations.includes("images.edit"),
+			maxInputImages: image?.maxInputImages ?? 0,
+			supportsSize: Boolean(image?.sizes.length),
+			supportsAspectRatio: Boolean(image?.aspectRatios?.length)
+		},
+		geometry: {
+			sizes: image?.sizes ?? [],
+			aspectRatios: image?.aspectRatios ?? []
+		},
+		output: {
+			qualities: image?.qualities ?? [],
+			formats: image?.formats ?? [],
+			backgrounds: image?.backgrounds ?? []
+		}
+	};
+}
+//#endregion
+export { buildXopcCloudImageGenerationProvider };

package/dist/src/agent/image/generation/types.d.ts

@@ -48,13 +48,25 @@ export interface ImageGenerationProviderConfiguredContext {
     agentId?: string;
     agentDir?: string;
 }
+export interface ImageGenerationProviderConfigField {
+    key: 'baseUrl' | 'region';
+    label: string;
+    type: 'url' | 'select';
+    required?: boolean;
+    placeholder?: string;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+}
 export interface ImageGenerationProvider {
     id: string;
     label: string;
     source?: 'builtin' | 'custom';
-    credentialMode?: 'api-key' | 'none';
+    credentialMode?: 'api-key' | 'oauth' | 'none';
     documentationUrl?: string;
     apiKeyUrl?: string;
+    configFields?: ImageGenerationProviderConfigField[];
     defaultModel: string;
     models: string[];
     capabilities: ImageGenerationProviderCapabilities;
@@ -67,9 +79,10 @@ export interface ImageGenerationProviderSummary {
     id: string;
     label: string;
     source: 'builtin' | 'custom';
-    credentialMode: 'api-key' | 'none';
+    credentialMode: 'api-key' | 'oauth' | 'none';
     documentationUrl?: string;
     apiKeyUrl?: string;
+    configFields: ImageGenerationProviderConfigField[];
     defaultModel: string;
     models: string[];
     capabilities: ImageGenerationProviderCapabilities;

package/dist/src/agent/mcp/bundle-mcp-gateway.d.ts

@@ -3,6 +3,7 @@ export type McpGatewayToolEntry = {
     name: string;
     shortName: string;
     description: string;
+    readOnly: boolean;
 };
 export type McpGatewayResourceEntry = {
     uri: string;

package/dist/src/agent/mcp/bundle-mcp-gateway.js

@@ -6,7 +6,8 @@ function mapTools(tools, serverId) {
 	return tools.filter((tool) => tool.serverName === serverId).map((tool) => ({
 		name: mcpToolPolicyId(tool.safeServerName, tool.toolName),
 		shortName: tool.toolName,
-		description: tool.description || tool.title || tool.fallbackDescription
+		description: tool.description || tool.title || tool.fallbackDescription,
+		readOnly: tool.annotations?.readOnlyHint === true
 	}));
 }
 function mapResources(resources, serverId) {

package/dist/src/agent/mcp/bundle-mcp-policy.d.ts

@@ -1,5 +1,9 @@
-import type { AgentManifest } from '../../agent-manifest/schema.js';
+import type { AgentManifest, ToolPolicy } from '../../agent-manifest/schema.js';
 export declare function mcpToolPolicyId(serverId: string, toolName: string): string;
+export declare function resolveMcpToolPolicy(identity: {
+    serverId: string;
+    policyToolId: string;
+}, policy: AgentManifest['tools']['mcp']): ToolPolicy | undefined;
 export declare function isMcpCatalogToolDenied(identity: {
     serverId: string;
     policyToolId: string;

package/dist/src/agent/mcp/bundle-mcp-policy.js

@@ -1,10 +1,18 @@
+import { sanitizeServerName } from "./bundle-mcp-names.js";
 //#region src/agent/mcp/bundle-mcp-policy.ts
 function mcpToolPolicyId(serverId, toolName) {
 	return `mcp:${encodeURIComponent(serverId)}:${encodeURIComponent(toolName)}`;
 }
+function resolveMcpToolPolicy(identity, policy) {
+	const toolPolicy = policy?.tools?.[identity.policyToolId];
+	if (toolPolicy) return toolPolicy;
+	const directServerPolicy = policy?.servers?.[identity.serverId];
+	if (directServerPolicy) return directServerPolicy;
+	const usedNames = /* @__PURE__ */ new Set();
+	for (const [serverId, serverPolicy] of Object.entries(policy?.servers ?? {})) if (sanitizeServerName(serverId, usedNames) === identity.serverId) return serverPolicy;
+}
 function isMcpCatalogToolDenied(identity, policy) {
-	if (!policy) return false;
-	return policy.servers?.[identity.serverId]?.mode === "deny" || policy.tools?.[identity.policyToolId]?.mode === "deny";
+	return resolveMcpToolPolicy(identity, policy)?.mode === "deny";
 }
 //#endregion
-export { isMcpCatalogToolDenied, mcpToolPolicyId };
+export { isMcpCatalogToolDenied, mcpToolPolicyId, resolveMcpToolPolicy };