@xopcai/xopc 0.0.388 → 0.0.389

package/dist/src/gateway/service/config-coordinator.d.ts

@@ -26,6 +26,7 @@ export declare class GatewayConfigCoordinator {
     private configReloader;
     private channelReloadFlushPromise;
     private channelReloadPending;
+    private configWrite;
     constructor(opts: GatewayConfigCoordinatorOptions);
     /** Start the fs.watch-based reloader (idempotent — only starts once). */
     startHotReloader(): void;
@@ -34,10 +35,627 @@ export declare class GatewayConfigCoordinator {
         reloaded: boolean;
         error?: string;
     }>;
-    saveConfig(config: Config): Promise<{
+    saveConfig(config: Config, expectedConfig?: {
+        userContext: {
+            enabled: boolean;
+            preferences: {
+                responseLanguage: "en" | "auto" | "zh-CN";
+            };
+            userModel: {
+                enabled: boolean;
+                writePolicy: "allow" | "deny";
+                sensitiveWritePolicy: "allow" | "deny" | "confirm";
+                showMemoryReferences: boolean;
+                processingPolicy: "local_only" | "remote_allowed";
+                extraction: {
+                    reviewIntervalTurns: number;
+                    maxHistoryMessages: number;
+                    maxDurationMs: number;
+                };
+                maintenance: {
+                    enabled: boolean;
+                    temporalSweepMinutes: number;
+                    dailyTime: string;
+                    weeklyDay: "sun" | "mon" | "tue" | "wed" | "thu" | "fri" | "sat";
+                    weeklyTime: string;
+                    evidenceThreshold: number;
+                    limit: number;
+                    staleRetentionDays: number;
+                    timezone?: string;
+                };
+            };
+            knowledgeMemory: {
+                enabled: boolean;
+                writePolicy: "allow" | "deny";
+                readScopes: ("project" | "session" | "agent" | "workspace" | "global")[];
+                contentSources: ("memory" | "connector" | "local_import")[];
+                searchStrategy: "local-first" | "external-first" | "fanout" | "local-only" | "external-only";
+                searchTimeoutMs: number;
+                writeStrategy: "local-first" | "external-first" | "local-only" | "external-only" | "write-through";
+                allowExternalWrites: boolean;
+                learning?: {
+                    idleFlushMs: number;
+                    maxBatchChars: number;
+                    maxDailyBatches: number;
+                };
+                allowedProviderIds?: string[];
+                autoWriteKinds?: string[];
+            };
+            contextPlanning: {
+                enabled: boolean;
+                maxAssertions: number;
+                maxKnowledge: number;
+                maxChars: number;
+                compaction: {
+                    personalIdle: {
+                        enabled: boolean;
+                        idleMs: number;
+                        triggerThreshold: number;
+                        cooldownMs: number;
+                        timeoutMs: number;
+                        keepRecentTokens: number;
+                        summaryMaxTokens: number;
+                        model?: string;
+                    };
+                    enabled: boolean;
+                    triggerThreshold: number;
+                    reserveTokens: number;
+                    minMessagesBeforeCompact: number;
+                    keepRecentTokens: number;
+                    recentTurnsPreserve: number;
+                    summaryMaxTokens: number;
+                    summaryChunkTokens: number;
+                    summaryTimeoutMs: number;
+                    summaryRetries: number;
+                    reasoningLevel: "low" | "off";
+                    qualityGuard: boolean;
+                    gapAudit: boolean;
+                    minToolResultKeepChars: number;
+                    maxActiveTranscriptBytes: number;
+                    postCompactionSections: string[];
+                    model?: string;
+                };
+            };
+            homeIntelligence: {
+                enabled: boolean;
+                refreshOnContextChange: boolean;
+            };
+        };
+        session: {
+            scope: "global" | "per-sender";
+            mainKey: string;
+            dmScope: "main" | "per-peer" | "per-channel-peer" | "per-account-channel-peer";
+            identityLinks?: Record<string, string[]>;
+            resetTriggers?: string[];
+            reset?: {
+                mode?: "idle" | "daily";
+                atHour?: number;
+                idleMinutes?: number;
+            };
+            resetByType?: {
+                direct?: {
+                    mode?: "idle" | "daily";
+                    atHour?: number;
+                    idleMinutes?: number;
+                };
+                group?: {
+                    mode?: "idle" | "daily";
+                    atHour?: number;
+                    idleMinutes?: number;
+                };
+                thread?: {
+                    mode?: "idle" | "daily";
+                    atHour?: number;
+                    idleMinutes?: number;
+                };
+            };
+            resetByChannel?: Record<string, {
+                mode?: "idle" | "daily";
+                atHour?: number;
+                idleMinutes?: number;
+            }>;
+            storage?: {
+                pruneAfterMs?: number;
+                maxEntries?: number;
+            };
+        };
+        channels: Record<string, unknown>;
+        gateway: {
+            bind?: "custom" | "auto" | "loopback" | "lan" | "tailnet";
+            customBindHost?: string;
+            port?: number;
+            mode?: "local" | "remote";
+            remote?: {
+                url: string;
+                transport: "direct" | "ssh";
+                token?: string;
+                password?: string;
+                sshTarget?: string;
+                sshIdentity?: string;
+                tlsFingerprint?: string;
+            };
+            tailscale?: {
+                mode: "off" | "serve" | "funnel";
+                resetOnExit: boolean;
+                consent?: {
+                    version: string;
+                    acceptedAt: string;
+                };
+            };
+            tls?: {
+                enabled: boolean;
+                autoGenerate: boolean;
+                certPath?: string;
+                keyPath?: string;
+            };
+            auth?: {
+                mode: "token" | "password" | "none" | "trusted-proxy";
+                token?: string;
+                password?: string;
+                allowTailscale?: boolean;
+                rateLimit?: {
+                    enabled: boolean;
+                    maxAttempts: number;
+                    windowMs: number;
+                    blockDurationMs: number;
+                    exemptLoopback: boolean;
+                    burstCoalesceMs: number;
+                    lockoutMs?: number;
+                };
+                trustedProxy?: {
+                    userHeader: string;
+                    requiredHeaders?: string[];
+                    allowUsers?: string[];
+                    allowLoopback?: boolean;
+                };
+            };
+            webchat?: {
+                activityDetailDefault: "stream" | "on" | "off";
+            };
+            scenes?: {
+                enabled: boolean;
+            };
+            corsOrigins?: string[];
+            publicUrl?: string;
+            dangerouslyAllowHostHeaderOriginFallback?: boolean;
+            trustedProxies?: string[];
+            allowRealIpFallback?: boolean;
+            security?: {
+                strict?: boolean;
+            };
+            channelConnectDeferMode?: "explicit" | "off" | "auto";
+            channelConnectDeferIds?: string[];
+            channelConnectDeferSkipIds?: string[];
+            skillsMarketplaceProvider?: string;
+            skillsStoreBaseUrl?: string;
+            share?: {
+                enabled: boolean;
+                defaultTtlMs: number;
+                maxTtlMs: number;
+                maxActiveShares: number;
+                maxFileSize: number;
+                inlinePreviewMimes: string[];
+                directory: {
+                    enabled: boolean;
+                    maxFolderSize: number;
+                    maxFileCount: number;
+                    maxDepth: number;
+                    listingCacheMs: number;
+                    zipConcurrency: number;
+                };
+                note: {
+                    enabled: boolean;
+                    maxMarkdownBytes: number;
+                    maxAttachmentCount: number;
+                    maxAttachmentSize: number;
+                    maxTotalSize: number;
+                    assetTicketTtlMs: number;
+                    revokeOnSourceDelete: boolean;
+                };
+            };
+            siteShare?: {
+                enabled: boolean;
+                publicHostSuffix: string;
+                defaultTtlMs: number;
+                maxTtlMs: number;
+                maxActiveSites: number;
+                static: {
+                    enabled: boolean;
+                    maxRootDirSize: number;
+                    maxFileCount: number;
+                    rewriteEnabledByDefault: boolean;
+                };
+                proxy: {
+                    enabled: boolean;
+                    allowedUpstreamHosts: string[];
+                    allowedUpstreamPorts: number[];
+                    forwardWebSocket: boolean;
+                    bodySizeLimit: number;
+                    requestTimeoutMs: number;
+                    wsIdleTimeoutMs: number;
+                    rewriteSetCookiePath: boolean;
+                };
+            };
+        };
+        browser: {
+            enabled: boolean;
+            driver: {
+                kind: "extension";
+            } | {
+                kind: "playwright";
+                headless: boolean;
+                executablePath?: string;
+            } | {
+                kind: "cdp";
+                endpoint: string;
+            } | {
+                kind: "remote";
+                provider: "browserbase" | "browser-use";
+                apiKey?: string;
+                projectId?: string;
+                region?: string;
+            };
+            observation: {
+                maxNodes: number;
+                maxCharacters: number;
+                visualFallback: boolean;
+            };
+            limits: {
+                actionTimeoutMs: number;
+                sessionTimeoutMs: number;
+                maxSequenceLength: number;
+            };
+            security: {
+                privateNetworks: "deny";
+                allowedPrivateHosts: string[];
+                crossDomainNavigation?: "allow" | "deny";
+                uploads?: "allow" | "deny";
+                consequentialActions?: "allow" | "deny";
+            };
+        };
+        computer: {
+            enabled: boolean;
+            maxActionsPerSession: number;
+            maxModelRequests: number;
+            maxSessionDurationMs: number;
+            idleGrantTtlMs: number;
+        };
+        tools: {
+            web?: {
+                region?: "global" | "cn";
+                search?: {
+                    maxResults: number;
+                    providers: {
+                        type: "brave" | "tavily" | "bing" | "searxng";
+                        apiKey?: string;
+                        url?: string;
+                        disabled?: boolean;
+                    }[];
+                };
+                blocklist?: {
+                    enabled: boolean;
+                    domains: string[];
+                };
+            };
+            media?: {
+                models?: {
+                    [x: string]: string | number | boolean | Record<string, unknown> | unknown[];
+                    provider?: string;
+                    model?: string;
+                    capabilities?: ("image" | "video" | "audio")[];
+                    type?: "cli" | "provider";
+                    command?: string;
+                    baseUrl?: string;
+                    headers?: Record<string, string>;
+                    apiKey?: string;
+                    language?: string;
+                    prompt?: string;
+                }[];
+                audio?: {
+                    enabled: boolean;
+                    provider: string;
+                    fallback: {
+                        enabled: boolean;
+                        order: string[];
+                    };
+                    timeoutMs?: number;
+                    models?: {
+                        [x: string]: string | number | boolean | Record<string, unknown> | unknown[];
+                        provider?: string;
+                        model?: string;
+                        capabilities?: ("image" | "video" | "audio")[];
+                        type?: "cli" | "provider";
+                        command?: string;
+                        baseUrl?: string;
+                        headers?: Record<string, string>;
+                        apiKey?: string;
+                        language?: string;
+                        prompt?: string;
+                    }[];
+                    providers?: Record<string, {
+                        [x: string]: string | number | boolean | Record<string, unknown> | unknown[];
+                        apiKey?: string;
+                        model?: string;
+                        baseUrl?: string;
+                        headers?: Record<string, string>;
+                        language?: string;
+                        prompt?: string;
+                    }>;
+                };
+            };
+        };
+        runtimeTools: {
+            enabled: boolean;
+            node: {
+                enabled: boolean;
+                preference: "managed-only" | "managed-first" | "system-first" | "system-only";
+                provision: "disabled" | "eager" | "on-demand";
+                version?: string;
+            };
+            python: {
+                enabled: boolean;
+                preference: "managed-only" | "managed-first" | "system-first" | "system-only";
+                provision: "disabled" | "eager" | "on-demand";
+                version?: string;
+            };
+            uv: {
+                enabled: boolean;
+                version?: string;
+            };
+            download: {
+                source: "auto" | "website-only" | "direct-only";
+                gatewayBaseUrl: string;
+                timeoutMs: number;
+                bundleDir?: string;
+                proxy?: string;
+            };
+            retention: {
+                keepVersions: number;
+                maxCacheBytes?: number;
+            };
+        };
+        experimental: {
+            workDiscoveryOnboarding: boolean;
+        };
+        platform: {
+            mode: "standalone";
+        } | {
+            mode: "connected";
+            url: string;
+            discovery: {
+                schemaVersion: "1";
+                platformId: string;
+                displayName: string;
+                deploymentMode: "development" | "private" | "cloud";
+                region: string;
+                endpoints: {
+                    authorizationServer: string;
+                    controlApi: string;
+                    modelApi?: string;
+                    storeApi?: string;
+                    tunnelApi?: string;
+                    shareApi?: string;
+                    agentApi?: string;
+                    a2aApi?: string;
+                    realtime?: string;
+                };
+                capabilities: Record<"shares" | "models" | "connectors" | "tunnels" | "managedRuntime" | "runtimeFleet" | "traceUpload" | "a2a", boolean>;
+                protocols: {
+                    xopc: {
+                        min: string;
+                        max: string;
+                    };
+                    mcp: string[];
+                    a2a: string[];
+                };
+            };
+            workspaceId?: string;
+        };
+        extensions: Record<string, unknown>;
+        modelsDev: {
+            enabled: boolean;
+        };
+        modelCatalog: {
+            enabled: boolean;
+            refreshOnStartup: boolean;
+            intervalHours: number;
+        };
+        observability?: {
+            tracing: {
+                enabled: boolean;
+                capture: "metadata" | "redacted" | "detailed";
+                local: {
+                    retentionDays: number;
+                    maxStoreMiB: number;
+                    maxTraces: number;
+                    maxSpans: number;
+                    maxTraceKiB: number;
+                    maxWriteMiBPerMinute: number;
+                };
+                langfuse: {
+                    enabled: boolean;
+                    baseUrl: string;
+                };
+                detailedUntil?: number;
+            };
+        };
+        tunnel?: {
+            enabled: boolean;
+            brokerUrl: string;
+            autoStart: boolean;
+            registrationSecret?: string;
+            subdomain?: string;
+            consent?: {
+                version: string;
+                acceptedAt: string;
+            };
+        };
+        workspace?: {
+            import?: {
+                targetDir: string;
+                maxBytes: number;
+                allowOverwrite: boolean;
+            };
+        };
+        mcp?: {
+            servers?: Record<string, {
+                [x: string]: unknown;
+                displayName?: string;
+                xopcOAuthCredentialId?: string;
+                type?: "http" | "stdio" | "streamable-http";
+                command?: string;
+                args?: string[];
+                env?: Record<string, string | {
+                    xopcSecretRef: {
+                        provider: string;
+                        fieldKey: string;
+                        prefix?: string;
+                        suffix?: string;
+                    };
+                }>;
+                cwd?: string;
+                url?: string;
+                headers?: Record<string, string | {
+                    xopcSecretRef: {
+                        provider: string;
+                        fieldKey: string;
+                        prefix?: string;
+                        suffix?: string;
+                    };
+                }>;
+                oauth?: {
+                    clientId?: string;
+                    clientSecret?: string;
+                    callbackPort?: number;
+                    callbackUrl?: string;
+                    scope?: string;
+                    clientName?: string;
+                    clientRegistration?: "dcr" | "cimd";
+                    authServerMetadataUrl?: string;
+                };
+                auth?: {
+                    provider: string;
+                };
+                timeout?: number;
+                enabled?: boolean;
+                exposure?: "direct" | "codemode" | "deferred" | "hidden";
+                toolExposure?: Record<string, "direct" | "codemode" | "deferred" | "hidden">;
+                description?: string;
+                transport?: never;
+                workingDirectory?: never;
+                connectionTimeoutMs?: never;
+                requestTimeoutMs?: never;
+            }>;
+        };
+        connectors?: {
+            instances?: Record<string, Record<string, unknown>>;
+        };
+        providers?: Record<string, {
+            baseUrl?: string;
+            region?: "cn" | "intl";
+            request?: {
+                timeoutMs?: number;
+                headers?: Record<string, string>;
+            };
+            azure?: {
+                resource?: string;
+                deployment?: string;
+                apiVersion?: string;
+            };
+        }>;
+        messages?: {
+            tts?: {
+                enabled: boolean;
+                provider: string;
+                trigger: "off" | "always" | "inbound" | "tagged";
+                maxTextLength: number;
+                timeoutMs: number;
+                fallback?: {
+                    enabled: boolean;
+                    order: string[];
+                };
+                summarization?: {
+                    enabled?: boolean;
+                    targetLength?: number;
+                    threshold?: number;
+                    model?: string;
+                };
+                modelOverrides?: {
+                    enabled: boolean;
+                    allowText: boolean;
+                    allowProvider: boolean;
+                    allowVoice: boolean;
+                    allowModelId: boolean;
+                    allowVoiceSettings: boolean;
+                    allowNormalization: boolean;
+                    allowSeed: boolean;
+                };
+                providers?: Record<string, {
+                    [x: string]: string | number | boolean | Record<string, unknown> | unknown[];
+                    apiKey?: string;
+                    model?: string;
+                    voice?: string;
+                }>;
+            };
+        };
+        voice?: {
+            realtime: {
+                enabled: boolean;
+                defaultEngine: "agent" | "omni";
+                silenceDurationMs: number;
+                idleTimeoutMs: number;
+                maxDictationMs: number;
+                maxConversationMs: number;
+                bargeIn: boolean;
+                stt?: {
+                    provider: "xopc-cloud";
+                    model: string;
+                };
+                tts?: {
+                    provider: "alibaba" | "xopc-cloud";
+                    model?: string;
+                    voice?: string;
+                };
+                omni?: {
+                    provider: "alibaba" | "xopc-cloud";
+                    model: string;
+                    voice: string;
+                    instructions: string;
+                    baseUrl?: string;
+                    apiKey?: string;
+                };
+            };
+            languageMode?: "manual" | "auto";
+            language?: "en" | "zh";
+            input?: {
+                refinement?: {
+                    mode: "off" | "custom" | "punctuation" | "light";
+                    model?: string;
+                    customInstruction?: string;
+                };
+            };
+        };
+        update?: {
+            checkOnStart: boolean;
+            channel: "stable" | "beta" | "dev";
+            auto?: {
+                enabled: boolean;
+                stableDelayHours: number;
+                stableJitterHours: number;
+                betaCheckIntervalHours: number;
+            };
+        };
+        commands?: {
+            restart?: boolean;
+        };
+    }): Promise<{
         saved: boolean;
         error?: string;
+        persisted?: boolean;
+        conflict?: boolean;
     }>;
+    private queueConfigWrite;
+    private persistConfig;
     /** Merge partial updates into `currentConfig` and persist. */
     updateConfig(updates: Partial<Config>): Promise<{
         updated: boolean;