manifest 5.27.0 → 5.28.0

package/dist/backend/routing/minimax-oauth.controller.js

@@ -0,0 +1,80 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinimaxOauthController = void 0;
+const common_1 = require("@nestjs/common");
+const current_user_decorator_1 = require("../auth/current-user.decorator");
+const minimax_oauth_service_1 = require("./minimax-oauth.service");
+const resolve_agent_service_1 = require("./resolve-agent.service");
+let MinimaxOauthController = class MinimaxOauthController {
+    oauthService;
+    resolveAgent;
+    constructor(oauthService, resolveAgent) {
+        this.oauthService = oauthService;
+        this.resolveAgent = resolveAgent;
+    }
+    async start(agentName, region, user) {
+        if (!agentName) {
+            throw new common_1.HttpException('agentName query parameter is required', common_1.HttpStatus.BAD_REQUEST);
+        }
+        if (region && !(0, minimax_oauth_service_1.isMinimaxRegion)(region)) {
+            throw new common_1.HttpException('region query parameter must be one of: global, cn', common_1.HttpStatus.BAD_REQUEST);
+        }
+        const agent = await this.resolveAgent.resolve(user.id, agentName);
+        const selectedRegion = region && (0, minimax_oauth_service_1.isMinimaxRegion)(region) ? region : 'global';
+        try {
+            return await this.oauthService.startAuthorization(agent.id, user.id, selectedRegion);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to start MiniMax OAuth';
+            throw new common_1.HttpException(message, common_1.HttpStatus.SERVICE_UNAVAILABLE);
+        }
+    }
+    async poll(flowId, user) {
+        if (!flowId) {
+            throw new common_1.HttpException('flowId query parameter is required', common_1.HttpStatus.BAD_REQUEST);
+        }
+        try {
+            return await this.oauthService.pollAuthorization(flowId, user.id);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to poll MiniMax OAuth';
+            throw new common_1.HttpException(message, common_1.HttpStatus.SERVICE_UNAVAILABLE);
+        }
+    }
+};
+exports.MinimaxOauthController = MinimaxOauthController;
+__decorate([
+    (0, common_1.Post)('start'),
+    __param(0, (0, common_1.Query)('agentName')),
+    __param(1, (0, common_1.Query)('region')),
+    __param(2, (0, current_user_decorator_1.CurrentUser)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], MinimaxOauthController.prototype, "start", null);
+__decorate([
+    (0, common_1.Get)('poll'),
+    __param(0, (0, common_1.Query)('flowId')),
+    __param(1, (0, current_user_decorator_1.CurrentUser)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], MinimaxOauthController.prototype, "poll", null);
+exports.MinimaxOauthController = MinimaxOauthController = __decorate([
+    (0, common_1.Controller)('api/v1/oauth/minimax'),
+    __metadata("design:paramtypes", [minimax_oauth_service_1.MinimaxOauthService,
+        resolve_agent_service_1.ResolveAgentService])
+], MinimaxOauthController);
+//# sourceMappingURL=minimax-oauth.controller.js.map

package/dist/backend/routing/minimax-oauth.service.js

@@ -0,0 +1,306 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var MinimaxOauthService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINIMAX_DEFAULT_RESOURCE_URL = exports.MinimaxOauthService = void 0;
+exports.isMinimaxRegion = isMinimaxRegion;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const crypto_1 = require("crypto");
+const routing_service_1 = require("./routing.service");
+const model_discovery_service_1 = require("./model-discovery/model-discovery.service");
+const provider_base_url_1 = require("./provider-base-url");
+const MINIMAX_BASE_URLS = {
+    global: 'https://api.minimax.io',
+    cn: 'https://api.minimaxi.com',
+};
+const DEFAULT_REGION = 'global';
+const DEFAULT_BASE_URL = MINIMAX_BASE_URLS[DEFAULT_REGION];
+const DEFAULT_CLIENT_ID = '78257093-7e40-4613-99e0-527b14b39113';
+const DEFAULT_RESOURCE_URL = `${DEFAULT_BASE_URL}/anthropic`;
+exports.MINIMAX_DEFAULT_RESOURCE_URL = DEFAULT_RESOURCE_URL;
+const SCOPE = 'group_id profile model.completion';
+const USER_CODE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:user_code';
+const DEFAULT_POLL_INTERVAL_MS = 2000;
+const ABSOLUTE_TIME_THRESHOLD_MS = 10_000_000_000;
+function isMinimaxRegion(value) {
+    return value === 'global' || value === 'cn';
+}
+function getMinimaxBaseUrl(region = DEFAULT_REGION) {
+    return MINIMAX_BASE_URLS[region];
+}
+function buildMinimaxCodeUrl(baseUrl) {
+    return `${baseUrl}/oauth/code`;
+}
+function buildMinimaxTokenUrl(baseUrl) {
+    return `${baseUrl}/oauth/token`;
+}
+function buildMinimaxResourceUrl(baseUrl) {
+    return `${baseUrl}/anthropic`;
+}
+function getMinimaxResourceUrl(resourceUrl) {
+    if (!resourceUrl)
+        return null;
+    return (0, provider_base_url_1.normalizeMinimaxSubscriptionBaseUrl)(resourceUrl);
+}
+function getMinimaxOauthBaseUrl(resourceUrl) {
+    const normalized = getMinimaxResourceUrl(resourceUrl);
+    if (!normalized)
+        return DEFAULT_BASE_URL;
+    return new URL(normalized).origin;
+}
+function toAbsoluteExpiryTimestamp(expiredIn) {
+    if (expiredIn > ABSOLUTE_TIME_THRESHOLD_MS)
+        return expiredIn;
+    return Date.now() + expiredIn * 1000;
+}
+function toPollIntervalMs(interval) {
+    if (!interval || interval <= 0)
+        return DEFAULT_POLL_INTERVAL_MS;
+    return interval >= 1000 ? interval : interval * 1000;
+}
+function isOAuthTokenBlob(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const blob = value;
+    return (typeof blob.t === 'string' &&
+        typeof blob.r === 'string' &&
+        typeof blob.e === 'number' &&
+        Number.isFinite(blob.e) &&
+        (blob.u === undefined || typeof blob.u === 'string'));
+}
+let MinimaxOauthService = MinimaxOauthService_1 = class MinimaxOauthService {
+    routingService;
+    configService;
+    discoveryService;
+    logger = new common_1.Logger(MinimaxOauthService_1.name);
+    pending = new Map();
+    clientId;
+    constructor(routingService, configService, discoveryService) {
+        this.routingService = routingService;
+        this.configService = configService;
+        this.discoveryService = discoveryService;
+        this.clientId = this.configService.get('MINIMAX_OAUTH_CLIENT_ID') ?? DEFAULT_CLIENT_ID;
+    }
+    async startAuthorization(agentId, userId, region = DEFAULT_REGION) {
+        this.cleanupExpired();
+        const verifier = (0, crypto_1.randomBytes)(32).toString('base64url');
+        const challenge = (0, crypto_1.createHash)('sha256').update(verifier).digest('base64url');
+        const flowId = (0, crypto_1.randomBytes)(16).toString('base64url');
+        const baseUrl = getMinimaxBaseUrl(region);
+        const resourceUrl = buildMinimaxResourceUrl(baseUrl);
+        const response = await fetch(buildMinimaxCodeUrl(baseUrl), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+                'x-request-id': (0, crypto_1.randomUUID)(),
+            },
+            body: new URLSearchParams({
+                response_type: 'code',
+                client_id: this.clientId,
+                scope: SCOPE,
+                code_challenge: challenge,
+                code_challenge_method: 'S256',
+                state: flowId,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            this.logger.error(`MiniMax OAuth code request failed: ${text}`);
+            throw new Error('Failed to start MiniMax OAuth');
+        }
+        const payload = (await response.json());
+        if (!payload.user_code || !payload.verification_uri || !payload.expired_in) {
+            throw new Error(payload.error ?? 'MiniMax OAuth returned an incomplete authorization payload.');
+        }
+        if (payload.state !== flowId) {
+            throw new Error('MiniMax OAuth state mismatch');
+        }
+        const pollIntervalMs = toPollIntervalMs(payload.interval);
+        const expiresAt = toAbsoluteExpiryTimestamp(payload.expired_in);
+        this.pending.set(flowId, {
+            verifier,
+            userCode: payload.user_code,
+            agentId,
+            userId,
+            baseUrl,
+            resourceUrl,
+            expiresAt,
+            pollIntervalMs,
+        });
+        return {
+            flowId,
+            userCode: payload.user_code,
+            verificationUri: payload.verification_uri,
+            expiresAt,
+            pollIntervalMs,
+        };
+    }
+    async pollAuthorization(flowId, userId) {
+        this.cleanupExpired();
+        const pending = this.pending.get(flowId);
+        if (!pending) {
+            return { status: 'error', message: 'MiniMax login expired. Start again.' };
+        }
+        if (pending.userId !== userId) {
+            return { status: 'error', message: 'MiniMax login session does not match the current user.' };
+        }
+        if (Date.now() >= pending.expiresAt) {
+            this.pending.delete(flowId);
+            return { status: 'error', message: 'MiniMax login expired. Start again.' };
+        }
+        const response = await fetch(buildMinimaxTokenUrl(pending.baseUrl), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+            body: new URLSearchParams({
+                grant_type: USER_CODE_GRANT_TYPE,
+                client_id: this.clientId,
+                user_code: pending.userCode,
+                code_verifier: pending.verifier,
+            }),
+        });
+        const text = await response.text();
+        const payload = this.parseTokenResponse(text);
+        if (!response.ok) {
+            const message = payload?.base_resp?.status_msg ?? text ?? 'MiniMax OAuth failed';
+            this.pending.delete(flowId);
+            return { status: 'error', message };
+        }
+        if (!payload) {
+            this.pending.delete(flowId);
+            return { status: 'error', message: 'MiniMax OAuth returned an invalid token response.' };
+        }
+        if (payload.status === 'error') {
+            this.pending.delete(flowId);
+            return { status: 'error', message: 'MiniMax OAuth failed. Please try again later.' };
+        }
+        if (payload.status !== 'success') {
+            return {
+                status: 'pending',
+                message: 'Waiting for MiniMax approval…',
+                pollIntervalMs: pending.pollIntervalMs,
+            };
+        }
+        if (!payload.access_token || !payload.refresh_token || !payload.expired_in) {
+            this.pending.delete(flowId);
+            return { status: 'error', message: 'MiniMax OAuth returned an incomplete token payload.' };
+        }
+        this.pending.delete(flowId);
+        const resourceUrl = getMinimaxResourceUrl(payload.resource_url) ?? pending.resourceUrl;
+        const blob = {
+            t: payload.access_token,
+            r: payload.refresh_token,
+            e: toAbsoluteExpiryTimestamp(payload.expired_in),
+            u: resourceUrl,
+        };
+        const { provider: savedProvider } = await this.routingService.upsertProvider(pending.agentId, pending.userId, 'minimax', JSON.stringify(blob), 'subscription');
+        try {
+            await this.discoveryService.discoverModels(savedProvider);
+            await this.routingService.recalculateTiers(pending.agentId);
+        }
+        catch (err) {
+            this.logger.warn(`Model discovery after MiniMax OAuth failed: ${err}`);
+        }
+        this.logger.log(`MiniMax OAuth token stored for agent=${pending.agentId}`);
+        return { status: 'success' };
+    }
+    async refreshAccessToken(refreshToken, resourceUrl) {
+        const baseUrl = getMinimaxOauthBaseUrl(resourceUrl);
+        const response = await fetch(buildMinimaxTokenUrl(baseUrl), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+            body: new URLSearchParams({
+                grant_type: 'refresh_token',
+                refresh_token: refreshToken,
+                client_id: this.clientId,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            this.logger.error(`MiniMax token refresh failed: ${text}`);
+            throw new Error('Token refresh failed');
+        }
+        const payload = (await response.json());
+        if (!payload.access_token || !payload.expired_in) {
+            throw new Error('MiniMax token refresh returned an incomplete payload');
+        }
+        const nextResourceUrl = getMinimaxResourceUrl(payload.resource_url) ??
+            getMinimaxResourceUrl(resourceUrl) ??
+            buildMinimaxResourceUrl(baseUrl);
+        return {
+            t: payload.access_token,
+            r: payload.refresh_token || refreshToken,
+            e: toAbsoluteExpiryTimestamp(payload.expired_in),
+            ...(nextResourceUrl ? { u: nextResourceUrl } : {}),
+        };
+    }
+    async unwrapToken(rawValue, agentId, userId) {
+        let blob;
+        try {
+            const parsed = JSON.parse(rawValue);
+            if (!isOAuthTokenBlob(parsed))
+                return null;
+            blob = parsed;
+        }
+        catch {
+            return null;
+        }
+        if (!blob.t || !blob.r || !blob.e)
+            return null;
+        if (Date.now() < blob.e - 60_000)
+            return blob;
+        try {
+            const refreshed = await this.refreshAccessToken(blob.r, blob.u);
+            await this.routingService.upsertProvider(agentId, userId, 'minimax', JSON.stringify(refreshed), 'subscription');
+            this.logger.log(`MiniMax OAuth token refreshed for agent=${agentId}`);
+            return refreshed;
+        }
+        catch (err) {
+            this.logger.error(`Failed to refresh MiniMax token: ${err}`);
+            return blob;
+        }
+    }
+    getPendingCount() {
+        return this.pending.size;
+    }
+    cleanupExpired() {
+        const now = Date.now();
+        for (const [flowId, pending] of this.pending.entries()) {
+            if (pending.expiresAt <= now)
+                this.pending.delete(flowId);
+        }
+    }
+    parseTokenResponse(text) {
+        if (!text)
+            return null;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+};
+exports.MinimaxOauthService = MinimaxOauthService;
+exports.MinimaxOauthService = MinimaxOauthService = MinimaxOauthService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [routing_service_1.RoutingService,
+        config_1.ConfigService,
+        model_discovery_service_1.ModelDiscoveryService])
+], MinimaxOauthService);
+//# sourceMappingURL=minimax-oauth.service.js.map

package/dist/backend/routing/model-discovery/model-discovery.service.js

@@ -23,6 +23,7 @@ const provider_model_fetcher_service_1 = require("./provider-model-fetcher.servi
 const crypto_util_1 = require("../../common/utils/crypto.util");
 const quality_score_util_1 = require("../../database/quality-score.util");
 const pricing_sync_service_1 = require("../../database/pricing-sync.service");
+const openai_oauth_types_1 = require("../openai-oauth.types");
 const model_fallback_1 = require("./model-fallback");
 const customProviderKey = (id) => `custom:${id}`;
 const customModelKey = (id, modelName) => `custom:${id}/${modelName}`;
@@ -40,6 +41,7 @@ let ModelDiscoveryService = ModelDiscoveryService_1 = class ModelDiscoveryServic
     }
     async discoverModels(provider) {
         let apiKey = '';
+        let endpointOverride;
         if (provider.api_key_encrypted) {
             try {
                 apiKey = (0, crypto_util_1.decrypt)(provider.api_key_encrypted, (0, crypto_util_1.getEncryptionSecret)());
@@ -49,17 +51,17 @@ let ModelDiscoveryService = ModelDiscoveryService_1 = class ModelDiscoveryServic
                 return [];
             }
         }
-        if (provider.auth_type === 'subscription' &&
-            provider.provider.toLowerCase() === 'openai' &&
-            apiKey) {
-            try {
-                const blob = JSON.parse(apiKey);
-                if (blob.t) {
+        if (provider.auth_type === 'subscription' && apiKey) {
+            const lowerProvider = provider.provider.toLowerCase();
+            if (lowerProvider === 'openai' || lowerProvider === 'minimax') {
+                const blob = (0, openai_oauth_types_1.parseOAuthTokenBlob)(apiKey);
+                if (blob?.t) {
                     apiKey = blob.t;
+                    if (lowerProvider === 'minimax' && blob.u) {
+                        endpointOverride = blob.u;
+                    }
                 }
             }
-            catch {
-            }
         }
         let raw;
         if (provider.auth_type === 'subscription' && !apiKey) {
@@ -69,7 +71,7 @@ let ModelDiscoveryService = ModelDiscoveryService_1 = class ModelDiscoveryServic
             }
         }
         else {
-            raw = await this.fetcher.fetch(provider.provider, apiKey, provider.auth_type);
+            raw = await this.fetcher.fetch(provider.provider, apiKey, provider.auth_type, endpointOverride);
             if (raw.length === 0) {
                 raw = (0, model_fallback_1.buildFallbackModels)(this.pricingSync, provider.provider);
                 if (raw.length > 0) {

package/dist/backend/routing/model-discovery/model-fallback.js

@@ -87,6 +87,7 @@ function buildSubscriptionFallbackModels(pricingSync, providerId) {
     const knownPrefixes = (0, subscription_capabilities_1.getSubscriptionKnownModels)(providerId);
     if (!knownPrefixes)
         return [];
+    const normalizedKnownPrefixes = knownPrefixes.map((modelId) => modelId.toLowerCase());
     const capabilities = (0, subscription_capabilities_1.getSubscriptionCapabilities)(providerId);
     const models = [];
     const seen = new Set();
@@ -96,8 +97,9 @@ function buildSubscriptionFallbackModels(pricingSync, providerId) {
             if (!fullId.startsWith(`${orPrefix}/`))
                 continue;
             const modelId = fullId.substring(orPrefix.length + 1);
-            if (!knownPrefixes.some((p) => modelId.startsWith(p)))
+            if (!normalizedKnownPrefixes.some((p) => modelId.toLowerCase().startsWith(p))) {
                 continue;
+            }
             if (seen.has(modelId))
                 continue;
             seen.add(modelId);
@@ -120,7 +122,11 @@ function buildSubscriptionFallbackModels(pricingSync, providerId) {
     }
     const defaultCtx = capabilities?.maxContextWindow ?? 200000;
     for (const modelId of knownPrefixes) {
-        const covered = models.some((m) => m.id === modelId || m.id.startsWith(`${modelId}-`));
+        const lowerModelId = modelId.toLowerCase();
+        const covered = models.some((m) => {
+            const lowerDiscovered = m.id.toLowerCase();
+            return lowerDiscovered === lowerModelId || lowerDiscovered.startsWith(`${lowerModelId}-`);
+        });
         if (covered)
             continue;
         models.push({
@@ -144,7 +150,11 @@ function supplementWithKnownModels(raw, providerId) {
     const capabilities = (0, subscription_capabilities_1.getSubscriptionCapabilities)(providerId);
     const defaultCtx = capabilities?.maxContextWindow ?? 200000;
     for (const modelId of knownModels) {
-        const covered = raw.some((m) => m.id === modelId || m.id.startsWith(`${modelId}-`));
+        const lowerModelId = modelId.toLowerCase();
+        const covered = raw.some((m) => {
+            const lowerDiscovered = m.id.toLowerCase();
+            return lowerDiscovered === lowerModelId || lowerDiscovered.startsWith(`${lowerModelId}-`);
+        });
         if (covered)
             continue;
         raw.push({

package/dist/backend/routing/model-discovery/provider-model-fetcher.service.js

@@ -10,10 +10,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderModelFetcherService = exports.PROVIDER_CONFIGS = void 0;
 const common_1 = require("@nestjs/common");
 const ollama_1 = require("../../common/constants/ollama");
+const provider_base_url_1 = require("../provider-base-url");
 const FETCH_TIMEOUT_MS = 5000;
 const DEFAULT_CONTEXT_WINDOW = 128000;
 const ANTHROPIC_DEFAULT_CONTEXT = 200000;
 const GEMINI_DEFAULT_CONTEXT = 1000000;
+const MINIMAX_SUBSCRIPTION_MODELS_URL = 'https://api.minimax.io/anthropic/v1/models?limit=100';
 function parseOpenAI(body, provider) {
     const data = body?.data;
     if (!Array.isArray(data))
@@ -212,6 +214,14 @@ exports.PROVIDER_CONFIGS = {
         buildHeaders: bearerHeaders,
         parse: parseOpenAI,
     },
+    'minimax-subscription': {
+        endpoint: MINIMAX_SUBSCRIPTION_MODELS_URL,
+        buildHeaders: (key) => ({
+            Authorization: `Bearer ${key}`,
+            'anthropic-version': '2023-06-01',
+        }),
+        parse: parseAnthropic,
+    },
     qwen: {
         endpoint: 'https://dashscope.aliyuncs.com/compatible-mode/v1/models',
         buildHeaders: bearerHeaders,
@@ -257,17 +267,29 @@ exports.PROVIDER_CONFIGS = {
 };
 let ProviderModelFetcherService = ProviderModelFetcherService_1 = class ProviderModelFetcherService {
     logger = new common_1.Logger(ProviderModelFetcherService_1.name);
-    async fetch(providerId, apiKey, authType) {
+    async fetch(providerId, apiKey, authType, endpointOverride) {
         let configKey = providerId.toLowerCase();
         if (configKey === 'openai' && authType === 'subscription') {
             configKey = 'openai-subscription';
         }
+        else if (configKey === 'minimax' && authType === 'subscription') {
+            configKey = 'minimax-subscription';
+        }
         const config = exports.PROVIDER_CONFIGS[configKey];
         if (!config) {
             this.logger.warn(`No fetcher config for provider: ${providerId}`);
             return [];
         }
-        const url = typeof config.endpoint === 'function' ? config.endpoint(apiKey) : config.endpoint;
+        let url = typeof config.endpoint === 'function' ? config.endpoint(apiKey) : config.endpoint;
+        if (endpointOverride && configKey === 'minimax-subscription') {
+            const minimaxBaseUrl = (0, provider_base_url_1.normalizeMinimaxSubscriptionBaseUrl)(endpointOverride);
+            if (minimaxBaseUrl) {
+                url = `${minimaxBaseUrl}/v1/models?limit=100`;
+            }
+            else {
+                this.logger.warn('Ignoring invalid MiniMax subscription endpoint override');
+            }
+        }
         const headers = config.buildHeaders(apiKey, authType);
         try {
             const controller = new AbortController();

package/dist/backend/routing/openai-oauth.types.js

@@ -1,6 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOAuthTokenBlob = parseOAuthTokenBlob;
 exports.oauthDoneHtml = oauthDoneHtml;
+function parseOAuthTokenBlob(rawValue) {
+    try {
+        const parsed = JSON.parse(rawValue);
+        if (typeof parsed?.t !== 'string' ||
+            typeof parsed?.r !== 'string' ||
+            typeof parsed?.e !== 'number' ||
+            (parsed.u !== undefined && typeof parsed.u !== 'string')) {
+            return null;
+        }
+        return {
+            t: parsed.t,
+            r: parsed.r,
+            e: parsed.e,
+            ...(parsed.u !== undefined ? { u: parsed.u } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 function oauthDoneHtml(success) {
     const message = success ? 'manifest-oauth-success' : 'manifest-oauth-error';
     const text = success

package/dist/backend/routing/provider-base-url.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeProviderBaseUrl = normalizeProviderBaseUrl;
+exports.normalizeMinimaxSubscriptionBaseUrl = normalizeMinimaxSubscriptionBaseUrl;
+function normalizeProviderBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+}
+const MINIMAX_SUBSCRIPTION_BASE_URLS = new Set([
+    'https://api.minimax.io/anthropic',
+    'https://api.minimaxi.com/anthropic',
+]);
+function normalizeMinimaxSubscriptionBaseUrl(baseUrl) {
+    try {
+        const url = new URL(baseUrl);
+        if (url.protocol !== 'https:' || url.username || url.password) {
+            return null;
+        }
+        const normalized = normalizeProviderBaseUrl(`${url.origin}${url.pathname}`);
+        return MINIMAX_SUBSCRIPTION_BASE_URLS.has(normalized) ? normalized : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=provider-base-url.js.map

package/dist/backend/routing/proxy/chatgpt-adapter.js

@@ -4,21 +4,19 @@ exports.toResponsesRequest = toResponsesRequest;
 exports.fromResponsesResponse = fromResponsesResponse;
 exports.transformResponsesStreamChunk = transformResponsesStreamChunk;
 const crypto_1 = require("crypto");
+const DEFAULT_INSTRUCTIONS = 'You are a helpful assistant.';
 function toResponsesRequest(body, model) {
     const messages = (body.messages ?? []);
-    const systemMsg = messages.find((m) => m.role === 'system');
     const input = messages
-        .filter((m) => m.role !== 'system')
+        .filter((m) => m.role !== 'system' && m.role !== 'developer')
         .map((m) => ({ role: m.role, content: convertContent(m.content, m.role) }));
     const request = {
         model,
         input,
         stream: body.stream !== false,
         store: false,
+        instructions: extractInstructions(messages),
     };
-    if (systemMsg && typeof systemMsg.content === 'string') {
-        request.instructions = systemMsg.content;
-    }
     return request;
 }
 function fromResponsesResponse(data, model) {
@@ -114,6 +112,28 @@ function convertContent(content, role) {
         return part;
     });
 }
+function extractInstructions(messages) {
+    const parts = [];
+    for (const message of messages) {
+        if (message.role !== 'system' && message.role !== 'developer')
+            continue;
+        parts.push(...extractTextParts(message.content));
+    }
+    const instructions = parts
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join('\n\n');
+    return instructions || DEFAULT_INSTRUCTIONS;
+}
+function extractTextParts(content) {
+    if (typeof content === 'string')
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    return content
+        .filter((part) => part.type === 'text' && typeof part.text === 'string')
+        .map((part) => part.text);
+}
 function safeParse(str) {
     try {
         return JSON.parse(str);