@undefineds.co/xpod 0.4.3 → 0.4.5

package/dist/api/ai-gateway/models/PodModelSelectionRepository.d.ts

@@ -22,7 +22,8 @@ export interface PodModelSelection {
 export interface PodModelSelectionDb {
     init?: (...resources: unknown[]) => Promise<void>;
     select(): {
-        from(resource: typeof aiModelResource): {
+        from(resource: typeof aiProviderResource | typeof aiModelResource): {
+            execute?(): Promise<Record<string, unknown>[]>;
             where(condition: unknown): {
                 execute(): Promise<Record<string, unknown>[]>;
             };
@@ -91,6 +92,8 @@ export declare class PodModelSelectionRepository {
     private replaceSelectionLocked;
     reconcileAvailability(input: ReconcileAvailabilityInput): Promise<PodModelSelection>;
     listActiveSelections(input: ListActiveSelectionsInput): Promise<PodModelSelection[]>;
+    private readActiveSelection;
+    private findSelectedModel;
     private readSelection;
     private findProvider;
     private dbForOwner;

package/dist/api/ai-gateway/models/PodModelSelectionRepository.js

@@ -195,20 +195,66 @@ class PodModelSelectionRepository {
     }
     async listActiveSelections(input) {
         const db = await this.dbForOwner(input.webId, input.auth);
-        // The shared drizzle-solid schema resources are rebound while a query is
-        // prepared. Keep provider reads sequential so one query cannot change the
-        // base/endpoint underneath another in-flight query.
         const selections = [];
         for (const provider of this.providerIds) {
-            selections.push((await this.readSelection(db, input.webId, provider)).selection);
+            selections.push(await this.readActiveSelection(db, input.webId, provider));
         }
         return selections
-            .map((selection) => ({
-            ...selection,
-            models: selection.models.filter((model) => model.status === 'active'),
-        }))
             .filter((selection) => selection.models.length > 0);
     }
+    async readActiveSelection(db, webId, provider) {
+        const providerId = normalizeProvider(provider);
+        const providerResourceId = models_1.aiProviderResource.buildId({ id: providerId });
+        const providerIri = buildProviderResourceIri(webId, providerResourceId);
+        const providerRow = await this.findProvider(db, providerResourceId, webId);
+        const models = [];
+        for (const relation of relationList(providerRow?.hasModel)) {
+            const modelResourceId = selectedModelResourceIdFromRelation(relation, webId);
+            if (!modelResourceId || !resourceBelongsToProvider(modelResourceId, providerId)) {
+                continue;
+            }
+            const row = await this.findSelectedModel(db, modelResourceId, webId);
+            if (!row || row.status === REMOVED_MODEL_STATUS || row.status === 'inactive') {
+                continue;
+            }
+            if (!modelProviderRelationMatches(row.isProvidedBy, modelResourceId, webId)) {
+                continue;
+            }
+            models.push(selectedLinkedModelFromRow(row, modelResourceId));
+        }
+        const activeModels = dedupeSelectedModels(models);
+        const configuredDefault = selectedModelResourceIdFromRelation(providerRow?.defaultModel, webId);
+        const defaultModel = configuredDefault && activeModels.some((model) => model.id === configuredDefault)
+            ? configuredDefault
+            : undefined;
+        return {
+            provider: providerId,
+            models: activeModels,
+            ...(defaultModel ? { defaultModel } : {}),
+            version: computeSelectionVersion(providerIri, defaultModel, activeModels),
+        };
+    }
+    async findSelectedModel(db, modelResourceId, webId) {
+        try {
+            const row = await db.findById(models_1.aiModelResource, modelResourceId);
+            if (row)
+                return row;
+        }
+        catch (error) {
+            if (!isMissingResourceError(error))
+                throw error;
+        }
+        // A model uses a fragment IRI inside its offering document. Plain-LDP
+        // findById can fetch that document yet fail to select the fragment subject,
+        // so resolve it through the indexed isProvidedBy relation as a fallback.
+        const document = modelResourceId.split('#', 1)[0];
+        const offeringIri = buildProviderResourceIri(webId, `${document}#this`);
+        const rows = await db.select()
+            .from(models_1.aiModelResource)
+            .where((0, drizzle_solid_1.eq)(models_1.aiModelResource.isProvidedBy, offeringIri))
+            .execute();
+        return rows.find((row) => modelRowMatchesResourceId(row, modelResourceId, webId)) ?? null;
+    }
     async readSelection(db, webId, provider) {
         const providerId = normalizeProvider(provider);
         const providerResourceId = models_1.aiProviderResource.buildId({ id: providerId });
@@ -227,7 +273,7 @@ class PodModelSelectionRepository {
         const modelRows = rows
             .filter((row) => row.status !== REMOVED_MODEL_STATUS)
             .filter((row) => relationMatches(row.isProvidedBy, providerIri, webId));
-        const providerRow = await this.findProvider(db, providerResourceId);
+        const providerRow = await this.findProvider(db, providerResourceId, webId);
         const models = modelRows
             .map((row) => selectedModelFromRow(row, providerResourceId, webId))
             .filter((model) => model !== undefined)
@@ -248,16 +294,21 @@ class PodModelSelectionRepository {
             },
         };
     }
-    async findProvider(db, id) {
+    async findProvider(db, id, webId) {
         try {
-            return await db.findById(models_1.aiProviderResource, id);
+            const row = await db.findById(models_1.aiProviderResource, id);
+            if (row)
+                return row;
         }
         catch (error) {
-            if (isMissingResourceError(error)) {
-                return null;
-            }
-            throw error;
+            if (!isMissingResourceError(error))
+                throw error;
         }
+        const collection = db.select().from(models_1.aiProviderResource);
+        if (typeof collection.execute !== 'function')
+            return null;
+        const rows = await collection.execute();
+        return rows.find((row) => providerRowMatchesResourceId(row, id, webId)) ?? null;
     }
     async dbForOwner(owner, auth) {
         assertOwnerWebId(owner);
@@ -443,6 +494,88 @@ function selectedModelFromRow(row, providerResourceId, webId) {
         ...(dateValue(row.updatedAt) ? { updatedAt: dateValue(row.updatedAt) } : {}),
     };
 }
+function selectedLinkedModelFromRow(row, id) {
+    return {
+        id,
+        ...(typeof row.displayName === 'string' && row.displayName ? { displayName: row.displayName } : {}),
+        modelType: normalizeModelType(row.modelType),
+        status: 'active',
+        ...(dateValue(row.createdAt) ? { createdAt: dateValue(row.createdAt) } : {}),
+        ...(dateValue(row.updatedAt) ? { updatedAt: dateValue(row.updatedAt) } : {}),
+    };
+}
+function modelRowMatchesResourceId(row, modelResourceId, webId) {
+    const rawId = typeof row.id === 'string' ? row.id : row['@id'];
+    if (typeof rawId !== 'string' || !rawId.trim())
+        return false;
+    if (rawId === modelResourceId)
+        return true;
+    try {
+        return selectedModelResourceIdFromRelation(rawId, webId) === modelResourceId;
+    }
+    catch {
+        return false;
+    }
+}
+function providerRowMatchesResourceId(row, providerResourceId, webId) {
+    const rawId = typeof row.id === 'string' ? row.id : row['@id'];
+    if (typeof rawId !== 'string' || !rawId.trim())
+        return false;
+    if (rawId === providerResourceId)
+        return true;
+    try {
+        const relative = toPodRelative(rawId, webId);
+        const prefix = 'settings/providers/';
+        const id = relative.startsWith(prefix) ? relative.slice(prefix.length) : relative;
+        return id === providerResourceId || id === `${providerResourceId}#this`;
+    }
+    catch {
+        return false;
+    }
+}
+function relationList(value) {
+    if (typeof value === 'string')
+        return [value];
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function selectedModelResourceIdFromRelation(value, webId) {
+    if (typeof value !== 'string' || !value.trim())
+        return undefined;
+    try {
+        const relative = toPodRelative(value, webId);
+        const prefix = 'settings/providers/';
+        const id = relative.startsWith(prefix) ? relative.slice(prefix.length) : relative;
+        const [document, fragment, extra] = id.split('#');
+        return document && fragment && extra === undefined && !document.includes('/') && document.endsWith('.ttl')
+            ? `${document}#${fragment}`
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resourceBelongsToProvider(resourceId, providerId) {
+    const document = resourceId.split('#', 1)[0];
+    return document === `${providerId}.ttl` || document.startsWith(`${providerId}-`);
+}
+function modelProviderRelationMatches(value, modelResourceId, webId) {
+    if (typeof value !== 'string')
+        return false;
+    try {
+        const relative = toPodRelative(value, webId);
+        const prefix = 'settings/providers/';
+        const providerId = relative.startsWith(prefix) ? relative.slice(prefix.length) : relative;
+        const document = modelResourceId.split('#', 1)[0];
+        return providerId === document || providerId === `${document}#this`;
+    }
+    catch {
+        return false;
+    }
+}
+function dedupeSelectedModels(models) {
+    return [...new Map(models.map((model) => [model.id, model])).values()]
+        .sort((left, right) => left.id.localeCompare(right.id));
+}
 function rowResourceId(row, providerResourceId, webId) {
     const rawId = typeof row.id === 'string' ? row.id : row['@id'];
     return typeof rawId === 'string' && rawId.trim()
@@ -720,14 +853,16 @@ function wrapModelSelectionDb(db, modelResource) {
             return {
                 from: (resource) => {
                     const from = query.from(resource);
-                    if (resource !== modelResource) {
-                        return from;
-                    }
                     return {
+                        ...(typeof from.execute === 'function'
+                            ? { execute: () => withModelEndpointLock(() => from.execute()) }
+                            : {}),
                         where: (condition) => {
                             const where = from.where(condition);
                             return {
-                                execute: () => withModelCollectionEndpoint(modelResource, () => where.execute()),
+                                execute: () => resource === modelResource
+                                    ? withModelCollectionEndpoint(modelResource, () => where.execute())
+                                    : withModelEndpointLock(() => where.execute()),
                             };
                         },
                     };

package/dist/api/ai-gateway/providers/DeepSeekRuntimeAdapter.js

@@ -24,6 +24,12 @@ class DeepSeekRuntimeAdapter extends ProviderRuntimeAdapter_1.OpenAiCompatibleRu
 }
 exports.DeepSeekRuntimeAdapter = DeepSeekRuntimeAdapter;
 function mapDeepSeekReasoningEffort(effort, modelId, model) {
+    // Codex sends `none` for models whose catalog does not expose a reasoning
+    // control. This disables reasoning; it must not require the capability or be
+    // translated to DeepSeek's `high` setting.
+    if (effort === 'none') {
+        return undefined;
+    }
     if (model?.capabilities?.reasoningEffort !== true) {
         throw new errors_1.GatewayProtocolError('DeepSeek reasoning effort is not registered for this model', {
             code: 'invalid_request',
@@ -36,12 +42,10 @@ function mapDeepSeekReasoningEffort(effort, modelId, model) {
             },
         });
     }
-    if (effort === 'low' || effort === 'medium') {
-        return 'high';
-    }
-    if (effort === 'xhigh') {
+    if (effort === 'minimal' || effort === 'low')
+        return 'low';
+    if (effort === 'max')
         return 'max';
-    }
-    return effort === 'max' ? 'max' : 'high';
+    return 'high';
 }
 //# sourceMappingURL=DeepSeekRuntimeAdapter.js.map

package/dist/api/ai-gateway/providers/ModelsDevCatalog.d.ts

@@ -46,5 +46,12 @@ export interface FetchModelsDevCatalogOptions {
 export declare function resetModelsDevCatalogCache(): void;
 export declare function fetchModelsDevCatalog(options?: FetchModelsDevCatalogOptions): Promise<ModelsDevCatalog | undefined>;
 export declare function modelsDevModelDescriptors(provider: ModelsDevProvider): ProviderModelDescriptor[];
+/**
+ * Synchronous lookup of a single model in the already-fetched models.dev cache.
+ * Returns undefined when the catalog has not been fetched or the model is unknown.
+ * Used to enrich gateway projections for models that are absent from the static registry
+ * (e.g. newly released models discovered via the provider's live /models endpoint).
+ */
+export declare function lookupModelsDevModelDescriptor(providerId: string, modelId: string, mapping?: Record<string, string>): ProviderModelDescriptor | undefined;
 export declare function syncProviderRegistryWithModelsDev(registry: ProviderRegistry, catalog: ModelsDevCatalog, mapping?: Record<string, string>): string[];
 export declare function syncProviderRegistryFromModelsDev(registry: ProviderRegistry, options?: FetchModelsDevCatalogOptions): Promise<string[]>;

package/dist/api/ai-gateway/providers/ModelsDevCatalog.js

@@ -4,6 +4,7 @@ exports.XPOD_PROVIDER_TO_MODELS_DEV = exports.MODELS_DEV_API_URL = void 0;
 exports.resetModelsDevCatalogCache = resetModelsDevCatalogCache;
 exports.fetchModelsDevCatalog = fetchModelsDevCatalog;
 exports.modelsDevModelDescriptors = modelsDevModelDescriptors;
+exports.lookupModelsDevModelDescriptor = lookupModelsDevModelDescriptor;
 exports.syncProviderRegistryWithModelsDev = syncProviderRegistryWithModelsDev;
 exports.syncProviderRegistryFromModelsDev = syncProviderRegistryFromModelsDev;
 const global_logger_factory_1 = require("global-logger-factory");
@@ -16,6 +17,7 @@ exports.XPOD_PROVIDER_TO_MODELS_DEV = {
     kimi: 'moonshotai',
     bailian: 'alibaba-cn',
     deepseek: 'deepseek',
+    zhipu: 'zhipuai',
 };
 let catalogCache;
 function resetModelsDevCatalogCache() {
@@ -57,7 +59,10 @@ function modelsDevModelDescriptors(provider) {
         inputModalities: model.modalities?.input,
         capabilities: {
             toolCalls: model.tool_call,
-            reasoningEffort: model.reasoning,
+            // The DeepSeek Flash offerings expose the same reasoning-effort control
+            // as Pro, although the shared catalog currently marks them as ordinary
+            // chat models. Preserve that provider contract in Gateway projections.
+            reasoningEffort: provider.id === 'deepseek' && /flash/iu.test(model.id) ? true : model.reasoning,
             imageInput: model.modalities?.input?.includes('image') ?? undefined,
         },
         metadata: {
@@ -74,6 +79,25 @@ function modelsDevModelDescriptors(provider) {
         },
     }));
 }
+/**
+ * Synchronous lookup of a single model in the already-fetched models.dev cache.
+ * Returns undefined when the catalog has not been fetched or the model is unknown.
+ * Used to enrich gateway projections for models that are absent from the static registry
+ * (e.g. newly released models discovered via the provider's live /models endpoint).
+ */
+function lookupModelsDevModelDescriptor(providerId, modelId, mapping = exports.XPOD_PROVIDER_TO_MODELS_DEV) {
+    const modelsDevId = mapping[providerId];
+    const models = modelsDevId ? catalogCache?.catalog[modelsDevId]?.models : undefined;
+    if (!models) {
+        return undefined;
+    }
+    const key = Object.keys(models).find((candidate) => candidate.toLowerCase() === modelId.toLowerCase());
+    const model = key ? models[key] : undefined;
+    if (!model) {
+        return undefined;
+    }
+    return modelsDevModelDescriptors({ id: modelsDevId, models: { [model.id]: model } })[0];
+}
 function syncProviderRegistryWithModelsDev(registry, catalog, mapping = exports.XPOD_PROVIDER_TO_MODELS_DEV) {
     const synced = [];
     for (const [providerId, modelsDevId] of Object.entries(mapping)) {

package/dist/api/ai-gateway/providers/OfferingAuthorization.d.ts

@@ -0,0 +1,24 @@
+/** Public entry points, separate from how the resulting credential authenticates. */
+export interface OfferingAuthorizationMethod {
+    id: string;
+    authMode: 'oauth' | 'deviceCode' | 'local' | 'apiKey';
+    connectMode?: 'authorizationCodeOAuth' | 'deviceCodeOAuth' | 'browserAssistedApiKey';
+    label: string;
+    lifecycle: 'active' | 'unavailable';
+    reason?: string;
+}
+/** Xpod integrations supplement the shared offering catalog with runtime capabilities. */
+export declare const SUBSCRIPTION_AUTHORIZATION_BINDINGS: readonly [{
+    readonly provider: "openai";
+    readonly offeringId: "official-subscription";
+    readonly integrationId: "openai-codex-public";
+    readonly browserIntegrationId: "openai-codex-browser-public";
+}, {
+    readonly provider: "kimi";
+    readonly offeringId: "subscription-key";
+    readonly integrationId: "kimi-code-public";
+}];
+export declare function subscriptionAuthorizationMethods(deployment: 'local' | 'cloud', binding?: {
+    integrationId: string;
+    browserIntegrationId?: string;
+}): OfferingAuthorizationMethod[];

package/dist/api/ai-gateway/providers/OfferingAuthorization.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBSCRIPTION_AUTHORIZATION_BINDINGS = void 0;
+exports.subscriptionAuthorizationMethods = subscriptionAuthorizationMethods;
+/** Xpod integrations supplement the shared offering catalog with runtime capabilities. */
+exports.SUBSCRIPTION_AUTHORIZATION_BINDINGS = [
+    { provider: 'openai', offeringId: 'official-subscription', integrationId: 'openai-codex-public', browserIntegrationId: 'openai-codex-browser-public' },
+    { provider: 'kimi', offeringId: 'subscription-key', integrationId: 'kimi-code-public' },
+];
+function subscriptionAuthorizationMethods(deployment, binding) {
+    const browserMethods = binding?.browserIntegrationId ? [{
+            id: 'browser-oauth',
+            authMode: 'oauth',
+            connectMode: 'authorizationCodeOAuth',
+            label: '浏览器登录',
+            lifecycle: deployment === 'local' ? 'active' : 'unavailable',
+            ...(deployment === 'local' ? {} : { reason: '浏览器登录需要本机回调，请在本机 Xpod 中使用，或选择设备码登录。' }),
+        }] : [];
+    return [
+        ...browserMethods,
+        {
+            id: 'device-code',
+            authMode: 'deviceCode',
+            connectMode: 'deviceCodeOAuth',
+            label: '设备码登录',
+            lifecycle: 'active',
+        },
+        {
+            id: 'local-session-import',
+            authMode: 'local',
+            label: '已有登录态',
+            lifecycle: deployment === 'local' ? 'active' : 'unavailable',
+            ...(deployment === 'local' ? {} : { reason: '请在运行本机客户端的 Xpod 上导入登录态。' }),
+        },
+    ];
+}
+//# sourceMappingURL=OfferingAuthorization.js.map

package/dist/api/ai-gateway/providers/OpenAiRuntimeAdapter.d.ts

@@ -1,5 +1,5 @@
 import { BaseProviderRuntimeAdapter, type ProviderRuntimeAdapterOptions, type ProviderRuntimeExecuteInput } from './ProviderRuntimeAdapter';
-import type { ProviderDescriptor } from './ProviderRegistry';
+import { type ProviderDescriptor } from './ProviderRegistry';
 import type { GatewayEvent } from '../types';
 export interface OpenAiRuntimeAdapterOptions extends ProviderRuntimeAdapterOptions {
     provider?: ProviderDescriptor;

package/dist/api/ai-gateway/providers/OpenAiRuntimeAdapter.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAiRuntimeAdapter = void 0;
 const ProviderRuntimeAdapter_1 = require("./ProviderRuntimeAdapter");
+const ProviderRegistry_1 = require("./ProviderRegistry");
 const OPENAI_BASE_URL = 'https://api.openai.com/v1';
-const OPENAI_SUBSCRIPTION_RESPONSES_URL = 'https://chatgpt.com/backend-api/codex/responses';
 class OpenAiRuntimeAdapter extends ProviderRuntimeAdapter_1.BaseProviderRuntimeAdapter {
     constructor(options = {}) {
         super(options);
@@ -16,7 +16,9 @@ class OpenAiRuntimeAdapter extends ProviderRuntimeAdapter_1.BaseProviderRuntimeA
         const baseUrl = this.resolveBaseUrl({
             configuredBaseUrl: input.credential?.baseUrl,
             defaultBaseUrl: this.defaultBaseUrl,
-            safeBaseUrls: this.safeBaseUrls,
+            // Imported subscription credentials persist their canonical Codex endpoint.
+            // Keep that endpoint scoped to subscription credentials, not API keys.
+            safeBaseUrls: subscription ? [...this.safeBaseUrls, ProviderRegistry_1.OPENAI_SUBSCRIPTION_BASE_URL] : this.safeBaseUrls,
         });
         try {
             const headers = new Headers();
@@ -34,7 +36,7 @@ class OpenAiRuntimeAdapter extends ProviderRuntimeAdapter_1.BaseProviderRuntimeA
                 delete responsesBody.max_output_tokens;
             }
             yield* (0, ProviderRuntimeAdapter_1.parseOpenAiResponsesSse)(this.transport.postSse({
-                url: subscription ? OPENAI_SUBSCRIPTION_RESPONSES_URL : `${baseUrl}/responses`,
+                url: subscription ? `${ProviderRegistry_1.OPENAI_SUBSCRIPTION_BASE_URL}/responses` : `${baseUrl}/responses`,
                 apiKey: input.apiKey,
                 body: {
                     ...responsesBody,

package/dist/api/ai-gateway/providers/ProviderRegistry.d.ts

@@ -1,12 +1,14 @@
 import type { GatewayProtocol } from '../types';
+import { type OfferingAuthorizationMethod } from './OfferingAuthorization';
+export declare const OPENAI_SUBSCRIPTION_BASE_URL = "https://chatgpt.com/backend-api/codex";
 export type ProviderId = 'openai' | 'anthropic' | 'kimi' | 'bailian' | 'deepseek' | string;
 export type ProviderProductId = 'openai' | 'anthropic' | 'kimi' | 'bailian' | 'deepseek' | string;
-export type ProviderAuthMode = 'browserAssistedApiKey' | 'deviceCodeOAuth' | 'apiKey' | 'local' | 'connectUnsupported';
-export type ProviderConnectMode = 'browserAssistedApiKey' | 'deviceCodeOAuth' | 'connectUnsupported';
+export type ProviderAuthMode = 'browserAssistedApiKey' | 'authorizationCodeOAuth' | 'deviceCodeOAuth' | 'apiKey' | 'local' | 'connectUnsupported';
+export type ProviderConnectMode = 'browserAssistedApiKey' | 'authorizationCodeOAuth' | 'deviceCodeOAuth' | 'connectUnsupported';
 export type OfferingAuthMode = 'oauth' | 'deviceCode' | 'apiKey' | 'local';
 export type ProviderOfferingKind = 'oauth-subscription' | 'api-platform' | 'token-plan' | 'local';
 export type ProviderOfferingLifecycle = 'active' | 'legacy' | 'unavailable';
-export type ProviderAuthCapabilityProtocol = 'api-key' | 'subscription-key' | 'local-none' | 'oauth-device-code';
+export type ProviderAuthCapabilityProtocol = 'api-key' | 'subscription-key' | 'local-none' | 'oauth-device-code' | 'oauth-authorization-code';
 export interface ProviderAuthCapabilityDescriptor {
     protocol: ProviderAuthCapabilityProtocol;
 }
@@ -52,6 +54,7 @@ export interface ProviderOfferingDescriptor {
     region: string;
     lifecycle: ProviderOfferingLifecycle;
     oauthIntegrationId?: string;
+    authorizationMethods?: OfferingAuthorizationMethod[];
 }
 export interface ProviderProductDescriptor {
     id: ProviderProductId;

package/dist/api/ai-gateway/providers/ProviderRegistry.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PROVIDER_DESCRIPTORS = exports.DEFAULT_PROVIDER_PRODUCT_DESCRIPTORS = exports.ProviderRegistry = void 0;
+exports.DEFAULT_PROVIDER_DESCRIPTORS = exports.DEFAULT_PROVIDER_PRODUCT_DESCRIPTORS = exports.ProviderRegistry = exports.OPENAI_SUBSCRIPTION_BASE_URL = void 0;
 exports.createDefaultProviderRegistry = createDefaultProviderRegistry;
 exports.providerProductsForDeployment = providerProductsForDeployment;
 exports.normalizeProviderId = normalizeProviderId;
 const models_1 = require("@undefineds.co/models");
+const OfferingAuthorization_1 = require("./OfferingAuthorization");
+exports.OPENAI_SUBSCRIPTION_BASE_URL = 'https://chatgpt.com/backend-api/codex';
 const RESERVED_DISCOVERY_METADATA_KEYS = new Set([
     'baseUrl',
     'base_url',
@@ -132,21 +134,51 @@ function createDefaultProviderRegistry(options = {}) {
     return new ProviderRegistry(exports.DEFAULT_PROVIDER_DESCRIPTORS, options);
 }
 function providerProductsForDeployment(deployment) {
-    const products = exports.DEFAULT_PROVIDER_PRODUCT_DESCRIPTORS.map(normalizeOpenAiSubscriptionProduct);
-    if (deployment !== 'local') {
-        return products;
-    }
-    return products.map((product) => product.id === 'openai'
-        ? {
-            ...product,
-            offerings: product.offerings.map((offering) => offering.id === 'official-subscription'
-                ? {
-                    ...offering,
+    return exports.DEFAULT_PROVIDER_PRODUCT_DESCRIPTORS.map((product) => ({
+        ...product,
+        offerings: product.offerings.map((offering) => {
+            const binding = OfferingAuthorization_1.SUBSCRIPTION_AUTHORIZATION_BINDINGS.find((candidate) => candidate.provider === product.id && candidate.offeringId === offering.id);
+            const authorizationMethods = [];
+            if (offering.authModes.includes('apiKey')) {
+                authorizationMethods.push({
+                    id: 'api-key', authMode: 'apiKey', label: '添加 API Key',
+                    lifecycle: offering.lifecycle === 'unavailable' ? 'unavailable' : 'active',
+                });
+            }
+            if (binding) {
+                authorizationMethods.push(...(0, OfferingAuthorization_1.subscriptionAuthorizationMethods)(deployment, binding));
+            }
+            else if (offering.kind === 'local') {
+                authorizationMethods.push({
+                    id: 'local-service', authMode: 'local', label: '本地服务',
+                    lifecycle: offering.lifecycle === 'unavailable' ? 'unavailable' : 'active',
+                });
+            }
+            else if (offering.authModes.some((mode) => mode === 'oauth' || mode === 'deviceCode')) {
+                authorizationMethods.push({
+                    id: 'device-code', authMode: 'deviceCode', connectMode: 'deviceCodeOAuth',
+                    label: '浏览器登录', lifecycle: 'unavailable', reason: '此授权方式尚未接入。',
+                });
+            }
+            return {
+                ...offering,
+                ...(binding ? {
                     lifecycle: 'active',
-                }
-                : offering),
-        }
-        : product);
+                    oauthIntegrationId: binding.integrationId,
+                    authModes: [...new Set([
+                            ...offering.authModes.filter((mode) => mode !== 'local'),
+                            ...authorizationMethods.filter((method) => method.lifecycle === 'active').map((method) => method.authMode),
+                            ...(deployment === 'local' ? ['local'] : []),
+                        ])],
+                    auth: [...offering.auth.filter((capability) => capability.protocol !== 'local-none' && capability.protocol !== 'oauth-device-code'),
+                        { protocol: 'oauth-device-code' },
+                        ...(authorizationMethods.some((method) => method.connectMode === 'authorizationCodeOAuth' && method.lifecycle === 'active')
+                            ? [{ protocol: 'oauth-authorization-code' }] : [])],
+                } : {}),
+                authorizationMethods,
+            };
+        }),
+    }));
 }
 function catalogOffering(productLabel, input) {
     const consoleUrl = input.consoleUrl ?? input.subscriptionUrl;
@@ -574,6 +606,7 @@ function normalizeOpenAiSubscriptionProduct(product) {
                 consoleUrl: 'https://chatgpt.com/',
                 subscriptionUrl: 'https://chatgpt.com/#pricing',
                 quota: { strategy: 'subscription', url: 'https://chatgpt.com/' },
+                endpoints: [{ protocol: 'responses', baseUrl: exports.OPENAI_SUBSCRIPTION_BASE_URL }],
                 lifecycle: 'unavailable',
             }
             : offering),
@@ -652,7 +685,7 @@ exports.DEFAULT_PROVIDER_DESCRIPTORS = [
             configured: true,
             requiresAuthenticatedManagementApi: true,
             publicCallbackSupported: false,
-            notes: ['Do not reuse official Codex client IDs or scrape browser cookies.'],
+            notes: ['API keys use the official settings page; OAuth uses a trusted server-side client profile.'],
         },
         protocols: ['responses', 'chatCompletions'],
         defaultBaseUrl: 'https://api.openai.com/v1',
@@ -772,6 +805,9 @@ exports.DEFAULT_PROVIDER_DESCRIPTORS = [
         models: [
             { id: 'deepseek-chat', capabilities: { toolCalls: true } },
             { id: 'deepseek-reasoner', capabilities: { toolCalls: true, reasoningEffort: true } },
+            { id: 'deepseek-flash', capabilities: { toolCalls: true, reasoningEffort: true } },
+            { id: 'deepseek-v4-flash', capabilities: { toolCalls: true, reasoningEffort: true } },
+            { id: 'deepseek-v4-pro', capabilities: { toolCalls: true, reasoningEffort: true } },
         ],
     },
     {
@@ -903,6 +939,9 @@ function freezeProviderProductDescriptor(product) {
             runtimeProviderIds: offering.runtimeProviderIds.map(normalizeProviderId),
             authModes: [...offering.authModes],
             auth: offering.auth.map((capability) => ({ ...capability })),
+            ...(offering.authorizationMethods ? {
+                authorizationMethods: offering.authorizationMethods.map((method) => ({ ...method })),
+            } : {}),
             upstream: offering.upstream.map((capability) => ({
                 ...capability,
                 options: capability.options ? { ...capability.options } : undefined,

package/dist/api/ai-gateway/providers/ProviderRuntimeAdapter.d.ts

@@ -26,6 +26,7 @@ export interface ProviderRuntimeAdapter {
 export interface ProviderRuntimeAdapterOptions {
     transport?: ProviderHttpTransport;
     maxOutputTokensDefault?: number;
+    resolveModel?: (provider: string, model: string) => ProviderModelDescriptor | undefined;
 }
 export interface CompatibleChatAdapterOptions extends ProviderRuntimeAdapterOptions {
     provider: string;
@@ -66,6 +67,7 @@ export declare class OpenAiCompatibleRuntimeAdapter extends BaseProviderRuntimeA
     private readonly supportsDeveloperMessages;
     private readonly allowToolChoiceRequired;
     private readonly descriptor?;
+    private readonly resolveModel?;
     private readonly reasoningEffortMapper?;
     private readonly fallbackReasoningBody?;
     private readonly preserveReasoningContent;