@xopcai/xopc 0.0.161 → 0.0.163

package/dist/src/gateway/hono/routes/you.js

@@ -1,4 +1,5 @@
 import { runSqliteWriteTransaction } from "../../../storage/sqlite/transaction.js";
+import { getRelationshipSettings, updateRelationshipSettings } from "../../../storage/sqlite/relationship-settings-repository.js";
 import { deleteMemoryRecord, getMemoryRecord, listMemoryRecords, upsertMemoryRecord } from "../../../storage/sqlite/memory-records-repository.js";
 import { listKnowledgeSourceItems, listKnowledgeSyncRuns } from "../../../storage/sqlite/knowledge-repository.js";
 import { getConnectorConnection, listConnectorConnections } from "../../../storage/sqlite/connector-repository.js";
@@ -15,6 +16,7 @@ import "../../../goals/index.js";
 import { revokeComposioConnection } from "../../../connectors/composio.js";
 import { listConnectorCatalog } from "../../../connectors/catalog.js";
 import { nextMemoryReviewAt, resolveMemoryStability } from "../../../agent/memory/lifecycle.js";
+import { PERSONAL_PLAYBOOK_DISABLED_TAG, PERSONAL_PLAYBOOK_ORDER_PREFIX, PERSONAL_PLAYBOOK_RULE_TAG, patchPersonalPlaybookContextTags, personalPlaybookContext } from "../../../user-context/personal-playbook.js";
 import { listConnectorInstances } from "../../../connectors/instances.js";
 import { uninstallConnector } from "../../../connectors/install.js";
 import { readUserProfileFile, writeUserProfileFile } from "../../agents-admin.js";
@@ -44,8 +46,13 @@ const PLAYBOOK_IDS = [
 	"execution",
 	"routines"
 ];
-const PLAYBOOK_DISABLED_TAG = "playbook:disabled";
-const PLAYBOOK_ORDER_PREFIX = "playbook:order:";
+const PLAYBOOK_SUPPORT_NEEDS = new Set([
+	"listen",
+	"clarify",
+	"advise",
+	"act",
+	"unknown"
+]);
 const PROFILE_FIELD_LIMITS = {
 	callName: 80,
 	pronouns: 80,
@@ -154,34 +161,57 @@ function parseProfilePatch(body) {
 	return Object.keys(patch).length > 0 ? { patch } : { error: "No profile fields provided" };
 }
 function playbookForRecord(record) {
+	if (!record.tags?.includes("playbook:rule")) return void 0;
 	if (record.kind === "preference" || record.kind === "boundary" || record.kind === "tool_preference") return "communication";
 	if (record.kind === "task_lesson" || record.kind === "derived_insight") return "execution";
 	if (record.kind === "routine") return "routines";
 }
 function playbookRuleOrder(record) {
-	const tag = record.tags?.find((value) => value.startsWith(PLAYBOOK_ORDER_PREFIX));
-	const parsed = tag ? Number.parseInt(tag.slice(15), 10) : NaN;
+	const tag = record.tags?.find((value) => value.startsWith(PERSONAL_PLAYBOOK_ORDER_PREFIX));
+	const parsed = tag ? Number.parseInt(tag.slice(PERSONAL_PLAYBOOK_ORDER_PREFIX.length), 10) : NaN;
 	return Number.isFinite(parsed) ? parsed : 1e3;
 }
 function patchPlaybookRuleTags(record, patch) {
-	let tags = (record.tags ?? []).filter((tag) => !tag.startsWith(PLAYBOOK_ORDER_PREFIX));
-	if (patch.enabled === true) tags = tags.filter((tag) => tag !== PLAYBOOK_DISABLED_TAG);
-	if (patch.enabled === false) tags.push(PLAYBOOK_DISABLED_TAG);
-	if (patch.order !== void 0) tags.push(`${PLAYBOOK_ORDER_PREFIX}${patch.order}`);
+	let tags = (record.tags ?? []).filter((tag) => !tag.startsWith(PERSONAL_PLAYBOOK_ORDER_PREFIX));
+	if (patch.enabled === true) tags = tags.filter((tag) => tag !== PERSONAL_PLAYBOOK_DISABLED_TAG);
+	if (patch.enabled === false) tags.push(PERSONAL_PLAYBOOK_DISABLED_TAG);
+	if (patch.order !== void 0) tags.push(`${PERSONAL_PLAYBOOK_ORDER_PREFIX}${patch.order}`);
 	return [...new Set(tags)];
 }
+function parsePlaybookContext(value) {
+	if (value === void 0) return { context: {} };
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { error: "context must be an object" };
+	const input = value;
+	const context = {};
+	if ("channel" in input) {
+		if (input.channel !== null && (typeof input.channel !== "string" || !/^[a-z0-9_-]{1,40}$/i.test(input.channel))) return { error: "context.channel is invalid" };
+		context.channel = input.channel === null ? void 0 : String(input.channel);
+	}
+	if ("supportNeed" in input) {
+		if (input.supportNeed !== null && !PLAYBOOK_SUPPORT_NEEDS.has(String(input.supportNeed))) return { error: "context.supportNeed is invalid" };
+		context.supportNeed = input.supportNeed === null ? void 0 : input.supportNeed;
+	}
+	return { context };
+}
 function buildPersonalPlaybooks(records) {
 	return PLAYBOOK_IDS.map((id) => {
-		const rules = records.filter((record) => playbookForRecord(record) === id).sort((left, right) => playbookRuleOrder(left) - playbookRuleOrder(right) || left.updatedAt.localeCompare(right.updatedAt));
+		const rules = records.filter((record) => record.status === "active" && playbookForRecord(record) === id).sort((left, right) => playbookRuleOrder(left) - playbookRuleOrder(right) || left.updatedAt.localeCompare(right.updatedAt));
 		return {
 			id,
-			enabled: rules.some((record) => !record.tags?.includes(PLAYBOOK_DISABLED_TAG)),
+			enabled: rules.some((record) => !record.tags?.includes(PERSONAL_PLAYBOOK_DISABLED_TAG)),
 			rules: rules.map((record) => ({
 				id: record.id,
 				statement: record.content,
 				origin: record.explicitness,
-				enabled: !record.tags?.includes(PLAYBOOK_DISABLED_TAG),
-				order: playbookRuleOrder(record)
+				enabled: !record.tags?.includes(PERSONAL_PLAYBOOK_DISABLED_TAG),
+				order: playbookRuleOrder(record),
+				context: personalPlaybookContext(record),
+				versions: playbookVersionChain(records, record.id).map((version) => ({
+					id: version.id,
+					statement: version.content,
+					updatedAt: version.updatedAt,
+					current: version.id === record.id
+				}))
 			})),
 			updatedAt: rules.map((record) => record.updatedAt).sort().at(-1)
 		};
@@ -195,7 +225,7 @@ function buildInsightSuggestions(records) {
 		id: record.id,
 		insight: record.content,
 		kind: record.kind,
-		action: record.kind === "routine" ? "make_repeatable" : "start_progress",
+		action: record.kind === "routine" ? "make_repeatable" : record.kind === "task_lesson" || record.kind === "derived_insight" ? "add_playbook" : "start_progress",
 		evidenceCount: record.evidence?.length ?? 0,
 		confidence: record.confidence,
 		sourceName: record.source.provider ?? "local"
@@ -216,11 +246,11 @@ function editableRecord(recordId) {
 	if (!record || !VISIBLE_STATUSES.has(record.status) || !isUserContextRecord(record)) return null;
 	return record;
 }
-function preserveRecord(record, patch) {
-	return upsertMemoryRecord({
-		id: record.id,
+function memoryRecordInput(record) {
+	return {
 		providerId: record.source.provider ?? "local",
 		kind: record.kind,
+		userId: record.scope.userId,
 		sourceAgentId: record.provenance.sourceAgentId,
 		workspaceId: record.scope.workspaceId,
 		sessionKey: record.scope.sessionKey,
@@ -242,8 +272,41 @@ function preserveRecord(record, patch) {
 		validFrom: record.validFrom,
 		validTo: record.validTo,
 		supersedesRecordId: record.supersedesRecordId,
-		conflictGroupId: record.conflictGroupId,
-		...patch
+		conflictGroupId: record.conflictGroupId
+	};
+}
+function preserveRecord(record, patch) {
+	return upsertMemoryRecord({
+		...memoryRecordInput(record),
+		...patch,
+		id: record.id
+	});
+}
+function playbookVersionChain(records, recordId) {
+	const relatedIds = new Set([recordId]);
+	let previousSize = 0;
+	while (previousSize !== relatedIds.size) {
+		previousSize = relatedIds.size;
+		for (const record of records) {
+			if (!record.supersedesRecordId) continue;
+			if (relatedIds.has(record.id) || relatedIds.has(record.supersedesRecordId)) {
+				relatedIds.add(record.id);
+				relatedIds.add(record.supersedesRecordId);
+			}
+		}
+	}
+	return records.filter((record) => relatedIds.has(record.id) && playbookForRecord(record) !== void 0).sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+}
+function versionPlaybookRule(record, patch) {
+	return upsertMemoryRecord({
+		...memoryRecordInput(record),
+		...patch,
+		status: "active",
+		supersedesRecordId: record.id,
+		source: {
+			provider: "local",
+			path: "you://playbook/version"
+		}
 	});
 }
 function registerYouRoutes(authenticated, deps) {
@@ -291,13 +354,14 @@ function registerYouRoutes(authenticated, deps) {
 			}),
 			conflictGroups: buildConflictGroups(allUserContextRecords),
 			insights: buildInsightSuggestions(records),
-			playbooks: buildPersonalPlaybooks(records.filter((record) => record.status === "active")),
+			playbooks: buildPersonalPlaybooks(allUserContextRecords),
 			sources,
 			sourceRecommendations: buildGoalSourceRecommendations(sourceDefinitions.filter((definition) => definition.capabilities.includes("context") || definition.capabilities.includes("memory_source")), new Set(sourceInstances.map((instance) => instance.connectorId)), activeGoals),
 			controls: {
 				mode: config.userContext.memory.mode,
 				sensitiveWritePolicy: config.userContext.privacy.sensitiveWritePolicy
 			},
+			relationship: getRelationshipSettings(),
 			trust: {
 				defaultActionLevel: trustPolicy.defaultActionLevel,
 				levels: USER_TRUST_LEVELS,
@@ -305,6 +369,41 @@ function registerYouRoutes(authenticated, deps) {
 			}
 		});
 	});
+	authenticated.patch("/api/you/relationship", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		if (!body || typeof body !== "object" || Array.isArray(body)) return c.json({ error: "Invalid relationship settings" }, 400);
+		const input = body;
+		const patch = {};
+		if ("supportMode" in input) {
+			if (![
+				"efficient",
+				"coach",
+				"companion",
+				"auto"
+			].includes(String(input.supportMode))) return c.json({ error: "Invalid supportMode" }, 400);
+			patch.supportMode = input.supportMode;
+		}
+		if ("proactiveEnabled" in input) {
+			if (typeof input.proactiveEnabled !== "boolean") return c.json({ error: "proactiveEnabled must be boolean" }, 400);
+			patch.proactiveEnabled = input.proactiveEnabled;
+		}
+		for (const field of ["quietStart", "quietEnd"]) {
+			if (!(field in input)) continue;
+			const value = input[field];
+			if (value !== null && (typeof value !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(value))) return c.json({ error: `${field} must use HH:mm` }, 400);
+			patch[field] = value === null ? void 0 : String(value);
+		}
+		for (const field of ["allowedTopics", "blockedTopics"]) {
+			if (!(field in input)) continue;
+			if (!Array.isArray(input[field]) || input[field].length > 20 || input[field].some((value) => typeof value !== "string" || !value.trim() || value.length > 80)) return c.json({ error: `${field} must contain up to 20 short topics` }, 400);
+			patch[field] = [...new Set(input[field].map((value) => value.trim()))];
+		}
+		if (Object.keys(patch).length === 0) return c.json({ error: "No relationship settings provided" }, 400);
+		return c.json({
+			ok: true,
+			relationship: updateRelationshipSettings(patch)
+		});
+	});
 	authenticated.get("/api/you/profile", async (c) => {
 		return c.json(await readProfileBundle(deps.service.currentConfig));
 	});
@@ -523,7 +622,7 @@ function registerYouRoutes(authenticated, deps) {
 			limit: 500
 		}).filter(isUserContextRecord).filter((record) => playbookForRecord(record) === id);
 		runSqliteWriteTransaction(() => {
-			for (const record of active) preserveRecord(record, { tags: patchPlaybookRuleTags(record, { enabled }) });
+			for (const record of active) versionPlaybookRule(record, { tags: patchPlaybookRuleTags(record, { enabled }) });
 		});
 		const current = active.map((record) => ({
 			...record,
@@ -540,6 +639,8 @@ function registerYouRoutes(authenticated, deps) {
 		const body = await c.req.json().catch(() => ({}));
 		const statement = typeof body.statement === "string" ? body.statement.trim() : "";
 		if (!statement || statement.length > 5e3) return c.json({ error: "Rule statement is required" }, 400);
+		const parsedContext = parsePlaybookContext(body.context);
+		if ("error" in parsedContext) return c.json({ error: parsedContext.error }, 400);
 		const record = upsertMemoryRecord({
 			providerId: "local",
 			kind: id === "communication" ? "preference" : id === "execution" ? "task_lesson" : "routine",
@@ -550,11 +651,11 @@ function registerYouRoutes(authenticated, deps) {
 				path: "you://playbook"
 			},
 			confidence: 1,
-			tags: [
+			tags: patchPersonalPlaybookContextTags([
 				"user-understanding",
-				"playbook:explicit",
-				`${PLAYBOOK_ORDER_PREFIX}${Number.isInteger(body.order) ? body.order : 1e3}`
-			],
+				PERSONAL_PLAYBOOK_RULE_TAG,
+				`${PERSONAL_PLAYBOOK_ORDER_PREFIX}${Number.isInteger(body.order) ? body.order : 1e3}`
+			], parsedContext.context),
 			status: "active",
 			sensitivity: "normal",
 			explicitness: "explicit",
@@ -576,12 +677,14 @@ function registerYouRoutes(authenticated, deps) {
 		if (!content || content.length > 5e3) return c.json({ error: "Rule statement is required" }, 400);
 		if (body.enabled !== void 0 && typeof body.enabled !== "boolean") return c.json({ error: "enabled must be boolean" }, 400);
 		if (body.order !== void 0 && (!Number.isInteger(body.order) || body.order < 0 || body.order > 1e4)) return c.json({ error: "order must be an integer between 0 and 10000" }, 400);
-		const updated = preserveRecord(record, {
+		const parsedContext = parsePlaybookContext(body.context);
+		if ("error" in parsedContext) return c.json({ error: parsedContext.error }, 400);
+		const updated = versionPlaybookRule(record, {
 			content,
-			tags: patchPlaybookRuleTags(record, {
+			tags: patchPersonalPlaybookContextTags(patchPlaybookRuleTags(record, {
 				enabled: body.enabled,
 				order: body.order
-			}),
+			}), parsedContext.context),
 			explicitness: body.statement === void 0 ? record.explicitness : "explicit"
 		});
 		return c.json({
@@ -593,9 +696,32 @@ function registerYouRoutes(authenticated, deps) {
 		const id = c.req.param("id");
 		const record = editableRecord(c.req.param("recordId"));
 		if (!PLAYBOOK_IDS.includes(id) || !record || playbookForRecord(record) !== id) return c.json({ error: "Playbook rule not found" }, 404);
-		deleteMemoryRecord(record.id);
+		preserveRecord(record, {
+			status: "archived",
+			validTo: (/* @__PURE__ */ new Date()).toISOString()
+		});
 		return c.json({ ok: true });
 	});
+	authenticated.post("/api/you/playbooks/:id/rules/:recordId/rollback", deps.strictRateLimitMiddleware, async (c) => {
+		const id = c.req.param("id");
+		const current = editableRecord(c.req.param("recordId"));
+		if (!PLAYBOOK_IDS.includes(id) || !current || playbookForRecord(current) !== id) return c.json({ error: "Playbook rule not found" }, 404);
+		const body = await c.req.json().catch(() => ({}));
+		const versionId = typeof body.versionId === "string" ? body.versionId : "";
+		const all = listAllUserContextRecords(ALL_MEMORY_STATUSES);
+		const target = playbookVersionChain(all, current.id).find((record) => record.id === versionId);
+		if (!target || target.id === current.id) return c.json({ error: "Previous version not found" }, 404);
+		const rolledBack = versionPlaybookRule(current, {
+			content: target.content,
+			tags: target.tags,
+			evidence: target.evidence,
+			explicitness: "explicit"
+		});
+		return c.json({
+			ok: true,
+			rule: buildPersonalPlaybooks([...all, rolledBack]).find((playbook) => playbook.id === id)?.rules.find((rule) => rule.id === rolledBack.id)
+		});
+	});
 	authenticated.patch("/api/you/insights/:id", deps.strictRateLimitMiddleware, async (c) => {
 		const config = deps.service.currentConfig;
 		const existing = editableRecord(c.req.param("id"));
@@ -622,6 +748,36 @@ function registerYouRoutes(authenticated, deps) {
 			status: "drafting",
 			href: buildRoutineAutomationDraftHref(existing)
 		});
+		if (existing.kind === "task_lesson" || existing.kind === "derived_insight") {
+			upsertMemoryRecord({
+				providerId: "local",
+				kind: "task_lesson",
+				sourceAgentId: selectedAgentId(config),
+				content: existing.content,
+				source: {
+					provider: "local",
+					path: "you://insight-proposal"
+				},
+				confidence: 1,
+				tags: [
+					"user-understanding",
+					PERSONAL_PLAYBOOK_RULE_TAG,
+					`${PERSONAL_PLAYBOOK_ORDER_PREFIX}1000`
+				],
+				status: "active",
+				sensitivity: existing.sensitivity,
+				explicitness: "explicit",
+				durability: "durable",
+				importance: existing.importance,
+				disclosurePolicy: existing.disclosurePolicy,
+				evidence: existing.evidence
+			});
+			preserveRecord(existing, { tags: [...new Set([...existing.tags ?? [], INSIGHT_ACCEPTED_TAG])] });
+			return c.json({
+				ok: true,
+				status: "saved"
+			});
+		}
 		const title = existing.content.trim().split(/\r?\n/)[0].slice(0, 72);
 		const uiLocale = body.uiLocale === "zh" ? "zh" : "en";
 		const contractDraft = await draftGoalContract({

package/dist/src/gateway/image-generation-setup.d.ts

@@ -0,0 +1,40 @@
+import { listImageGenerationProvidersSummary } from '../agent/image/generation/provider-registry.js';
+import { type Config } from '../config/schema.js';
+export type ImageGenerationSetupInput = {
+    providerId: string;
+    modelId?: string;
+    region?: 'cn' | 'intl';
+    baseUrl?: string;
+};
+export type ImageGenerationCatalogItem = ReturnType<typeof listImageGenerationProvidersSummary>[number] & {
+    configured: boolean;
+    requiresRegion: boolean;
+};
+export declare function getImageGenerationCatalog(config: Config): ImageGenerationCatalogItem[];
+export declare function getAgentImageGenerationConfig(config: Config, agentIdRaw: string): {
+    agentId: string;
+    model: {
+        primary: string;
+        fallbacks?: string[];
+        timeoutMs?: number;
+        autoProviderFallback?: boolean;
+    };
+};
+export declare function prepareImageGenerationSetup(config: Config, agentIdRaw: string, input: ImageGenerationSetupInput): {
+    ok: true;
+    config: Config;
+    providerId: string;
+    modelId: string;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function verifyImageGenerationCredential(input: {
+    providerId: string;
+    apiKey: string;
+    baseUrl?: string;
+}): Promise<{
+    verified: boolean;
+    supported: boolean;
+    message?: string;
+}>;

package/dist/src/gateway/image-generation-setup.js

@@ -0,0 +1,130 @@
+import { ConfigSchema, init_schema } from "../config/schema.js";
+import { init_agent_scope, normalizeAgentId } from "../agent/agent-scope.js";
+import { resolveEffectiveAgentManifestForAgent } from "../config/agent-profile.js";
+import { fetchWithTimeoutGuarded } from "../media-shared/http/provider-http.js";
+import "../media-shared/http/index.js";
+import { getImageGenerationProvider, listImageGenerationProvidersSummary } from "../agent/image/generation/provider-registry.js";
+//#region src/gateway/image-generation-setup.ts
+init_agent_scope();
+init_schema();
+function getImageGenerationCatalog(config) {
+	return listImageGenerationProvidersSummary().map((summary) => {
+		const provider = getImageGenerationProvider(summary.id);
+		return {
+			...summary,
+			configured: provider.isConfigured({ cfg: config }),
+			requiresRegion: summary.id === "dashscope" || summary.id === "minimax"
+		};
+	});
+}
+function getAgentImageGenerationConfig(config, agentIdRaw) {
+	const agentId = normalizeAgentId(agentIdRaw);
+	if (!config.agents.list.some((entry) => entry.enabled !== false && normalizeAgentId(entry.id) === agentId)) throw new Error(`Agent not found: ${agentId}`);
+	return {
+		agentId,
+		model: resolveEffectiveAgentManifestForAgent(config, agentId).models.imageGenerationModel ?? null
+	};
+}
+function prepareImageGenerationSetup(config, agentIdRaw, input) {
+	const agentId = normalizeAgentId(agentIdRaw);
+	if (!config.agents.list.some((entry) => entry.enabled !== false && normalizeAgentId(entry.id) === agentId)) return {
+		ok: false,
+		error: `Agent not found: ${agentId}`
+	};
+	const providerId = input.providerId.trim();
+	const provider = getImageGenerationProvider(providerId);
+	if (!provider) return {
+		ok: false,
+		error: `Unknown image provider: ${providerId}`
+	};
+	const modelId = input.modelId?.trim() || provider.defaultModel;
+	if (!provider.models.includes(modelId)) return {
+		ok: false,
+		error: `Unknown ${providerId} image model: ${modelId}`
+	};
+	if ((providerId === "dashscope" || providerId === "minimax") && input.region !== "cn" && input.region !== "intl") return {
+		ok: false,
+		error: `${providerId} requires region "cn" or "intl"`
+	};
+	const next = structuredClone(config);
+	const index = next.agents.list.findIndex((entry) => entry.enabled !== false && normalizeAgentId(entry.id) === agentId);
+	if (index < 0) return {
+		ok: false,
+		error: `Agent not found: ${agentId}`
+	};
+	const connection = {
+		...input.region ? { region: input.region } : {},
+		...input.baseUrl?.trim() ? { baseUrl: input.baseUrl.trim() } : {}
+	};
+	next.providers = {
+		...next.providers ?? {},
+		[providerId]: {
+			...next.providers?.[providerId] ?? {},
+			...connection
+		}
+	};
+	const entry = next.agents.list[index];
+	entry.models.imageGenerationModel = { primary: `${providerId}/${modelId}` };
+	const parsed = ConfigSchema.safeParse(next);
+	if (!parsed.success) return {
+		ok: false,
+		error: parsed.error.issues.map((issue) => issue.message).join("; ")
+	};
+	return {
+		ok: true,
+		config: next,
+		providerId,
+		modelId
+	};
+}
+async function verifyImageGenerationCredential(input) {
+	const apiKey = input.apiKey.trim();
+	if (!apiKey) return {
+		verified: false,
+		supported: true,
+		message: "API key is required"
+	};
+	if (!getImageGenerationProvider(input.providerId)) return {
+		verified: false,
+		supported: true,
+		message: `Unknown image provider: ${input.providerId}`
+	};
+	let url;
+	let headers = {};
+	if (input.providerId === "openai") {
+		url = `${input.baseUrl?.trim().replace(/\/+$/, "") || "https://api.openai.com/v1"}/models`;
+		headers = { Authorization: `Bearer ${apiKey}` };
+	} else if (input.providerId === "google") url = `${input.baseUrl?.trim().replace(/\/+$/, "") || "https://generativelanguage.googleapis.com"}/v1beta/models?pageSize=1&key=${encodeURIComponent(apiKey)}`;
+	else return {
+		verified: false,
+		supported: false
+	};
+	try {
+		const response = await fetchWithTimeoutGuarded(url, {
+			timeoutMs: 1e4,
+			label: `${input.providerId} credential verification`,
+			allowPrivateNetwork: false,
+			init: {
+				headers,
+				redirect: "error"
+			}
+		});
+		if (response.ok) return {
+			verified: true,
+			supported: true
+		};
+		return {
+			verified: false,
+			supported: true,
+			message: `Provider returned HTTP ${response.status}`
+		};
+	} catch (error) {
+		return {
+			verified: false,
+			supported: true,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+//#endregion
+export { getAgentImageGenerationConfig, getImageGenerationCatalog, prepareImageGenerationSetup, verifyImageGenerationCredential };

package/dist/src/gateway/rate-limit/buckets.d.ts

@@ -35,6 +35,7 @@ declare class BucketRegistry {
     private authFailureLimiter?;
     private authFailureSignature?;
     private strictApiLimiter?;
+    private xopcCloudPollLimiter?;
     private channelApiLimiter?;
     private tunnelMutateLimiter?;
     private pairingExchangeLimiter?;
@@ -48,6 +49,8 @@ declare class BucketRegistry {
     authFailure(cfg: ResolvedAuthRateLimitConfig): FailureLimiter;
     /** Sensitive admin / mutation endpoints — 15 req / 60 s per client IP. */
     strictApi(): RateLimiter;
+    /** XOPC Cloud authorization polling — 60 req / 60 s per client IP. */
+    xopcCloudPoll(): RateLimiter;
     /** Channel mutation/action endpoints — 20 req / 60 s per client IP. */
     channelApi(): RateLimiter;
     /** Tunnel mutation calls — 12 req / 5 min per gateway-token fingerprint. */

package/dist/src/gateway/rate-limit/buckets.js

@@ -47,6 +47,7 @@ var BucketRegistry = class {
 	authFailureLimiter;
 	authFailureSignature;
 	strictApiLimiter;
+	xopcCloudPollLimiter;
 	channelApiLimiter;
 	tunnelMutateLimiter;
 	pairingExchangeLimiter;
@@ -79,6 +80,14 @@ var BucketRegistry = class {
 		});
 		return this.strictApiLimiter;
 	}
+	/** XOPC Cloud authorization polling — 60 req / 60 s per client IP. */
+	xopcCloudPoll() {
+		if (!this.xopcCloudPollLimiter) this.xopcCloudPollLimiter = new RateLimiter({
+			maxRequests: 60,
+			windowMs: 6e4
+		});
+		return this.xopcCloudPollLimiter;
+	}
 	/** Channel mutation/action endpoints — 20 req / 60 s per client IP. */
 	channelApi() {
 		if (!this.channelApiLimiter) this.channelApiLimiter = new RateLimiter({
@@ -123,6 +132,7 @@ var BucketRegistry = class {
 	destroyAll() {
 		this.authFailureLimiter?.destroy();
 		this.strictApiLimiter?.destroy();
+		this.xopcCloudPollLimiter?.destroy();
 		this.channelApiLimiter?.destroy();
 		this.tunnelMutateLimiter?.destroy();
 		this.pairingExchangeLimiter?.destroy();
@@ -130,6 +140,7 @@ var BucketRegistry = class {
 		this.sharePublicLongLimiter?.destroy();
 		this.authFailureLimiter = void 0;
 		this.strictApiLimiter = void 0;
+		this.xopcCloudPollLimiter = void 0;
 		this.channelApiLimiter = void 0;
 		this.tunnelMutateLimiter = void 0;
 		this.pairingExchangeLimiter = void 0;
@@ -141,6 +152,7 @@ var BucketRegistry = class {
 	resetAllForTests() {
 		this.authFailureLimiter?.resetForTests();
 		this.strictApiLimiter?.resetForTests();
+		this.xopcCloudPollLimiter?.resetForTests();
 		this.channelApiLimiter?.resetForTests();
 		this.tunnelMutateLimiter?.resetForTests();
 		this.pairingExchangeLimiter?.resetForTests();