import { ChannelCapacityQueueError } from './channel-capacity-queue'; import { createChannelRouter, describeChannelFailure, getChannelPoolSummary, isChannelFailure, isChannelRequestModeFailure, isCredentialFailure, parseChannelPoolConfig, resolveEffectiveCredential, toPublicChannelFailure } from './channel-router'; import { RequestValidationError } from './image-request-utils'; import { IMAGE_UPSTREAM_PROFILES } from './image-upstream-profile'; import assert from 'node:assert/strict'; import { describe, it } from 'node:test'; const DEFAULT_HEADER_SUMMARY = { user_agent_effective: 'visual-journal/2.2.0', has_extra_headers: false, allowed_header_names: ['user-agent', 'x-app-id', 'x-app-secret'], configured_header_names: [] }; describe('parseChannelPoolConfig', () => { it('parses multiple channels with multiple keys from numbered env vars', () => { const config = parseChannelPoolConfig({ OPENAI_ROUTING_STRATEGY: 'round_robin', OPENAI_CHANNEL_1_ID: 'official', OPENAI_CHANNEL_1_BASE_URL: 'https://api.openai.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one, sk-two', OPENAI_CHANNEL_2_ID: 'backup', OPENAI_CHANNEL_2_BASE_URL: 'https://backup.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'sk-three' }); assert.equal(config.strategy, 'round_robin'); assert.deepEqual( config.credentials.map((credential) => ({ id: credential.id, channelId: credential.channelId, apiKey: credential.apiKey, baseUrl: credential.baseUrl })), [ { id: 'official#0', channelId: 'official', apiKey: 'sk-one', baseUrl: 'https://api.openai.com/v1' }, { id: 'official#1', channelId: 'official', apiKey: 'sk-two', baseUrl: 'https://api.openai.com/v1' }, { id: 'backup#0', channelId: 'backup', apiKey: 'sk-three', baseUrl: 'https://backup.example.com/v1' } ] ); }); it('falls back to legacy single key env when numbered channels are not configured', () => { const config = parseChannelPoolConfig({ OPENAI_API_KEY: 'sk-legacy', OPENAI_API_BASE_URL: 'https://legacy.example.com/v1' }); assert.equal(config.strategy, 'sticky'); assert.deepEqual(config.credentials, [ { id: 'default#0', channelId: 'default', apiKey: 'sk-legacy', baseUrl: 'https://legacy.example.com/v1', upstreamProfile: 'openai-compatible' } ]); }); it('applies the global proxy and lets a numbered channel override it', () => { const config = parseChannelPoolConfig({ OPENAI_UPSTREAM_PROXY_URL: 'https://global-proxy.example:8443', OPENAI_CHANNEL_1_ID: 'primary', OPENAI_CHANNEL_1_BASE_URL: 'https://primary.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-primary', OPENAI_CHANNEL_2_ID: 'backup', OPENAI_CHANNEL_2_BASE_URL: 'https://backup.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'sk-backup', OPENAI_CHANNEL_2_PROXY_URL: 'http://channel-proxy.example:8080' }); assert.deepEqual( config.credentials.map((credential) => ({ id: credential.id, upstreamProxyUrl: credential.upstreamProxyUrl })), [ { id: 'primary#0', upstreamProxyUrl: 'https://global-proxy.example:8443/' }, { id: 'backup#0', upstreamProxyUrl: 'http://channel-proxy.example:8080/' } ] ); const summary = getChannelPoolSummary(config); assert.deepEqual( summary.channels.map((channel) => ({ id: channel.id, upstreamProxy: channel.upstreamProxy })), [ { id: 'primary', upstreamProxy: { configured: true, protocol: 'https' } }, { id: 'backup', upstreamProxy: { configured: true, protocol: 'http' } } ] ); assert.equal(JSON.stringify(summary).includes('global-proxy.example'), false); assert.equal(JSON.stringify(summary).includes('channel-proxy.example'), false); }); it('rejects an invalid global or channel proxy URL explicitly', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_API_KEY: 'sk-legacy', OPENAI_API_BASE_URL: 'https://legacy.example.com/v1', OPENAI_UPSTREAM_PROXY_URL: 'ftp://proxy.example' }), /OPENAI_UPSTREAM_PROXY_URL/ ); assert.throws( () => parseChannelPoolConfig({ OPENAI_CHANNEL_1_BASE_URL: 'https://primary.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-primary', OPENAI_CHANNEL_1_PROXY_URL: 'http://proxy.example/path' }), /OPENAI_CHANNEL_1_PROXY_URL/ ); }); it('rejects invalid legacy upstream profile values instead of silently using the default profile', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_API_KEY: 'sk-legacy', OPENAI_API_BASE_URL: 'https://legacy.example.com/v1', OPENAI_UPSTREAM_PROFILE: 'unknown' }), /OPENAI_UPSTREAM_PROFILE/ ); }); it('uses channel index as the default channel id', () => { const config = parseChannelPoolConfig({ OPENAI_CHANNEL_1_BASE_URL: 'https://default-id.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one' }); assert.deepEqual(config.credentials, [ { id: 'channel-1#0', channelId: 'channel-1', apiKey: 'sk-one', baseUrl: 'https://default-id.example.com/v1', upstreamProfile: 'openai-compatible' } ]); }); it('rejects remote HTTP-compatible upstream base URLs unless they are allowlisted', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'j3gb', OPENAI_CHANNEL_1_BASE_URL: 'http://api.j3gb.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one' }), /HTTPS/ ); }); it('accepts allowlisted HTTP-compatible upstream base URLs in server channels', () => { const config = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'j3gb', OPENAI_CHANNEL_1_BASE_URL: 'http://api.j3gb.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_ALLOWED_PLAIN_HTTP_API_BASE_URLS: 'http://api.j3gb.com/v1' }); assert.equal(config.credentials[0]?.baseUrl, 'http://api.j3gb.com/v1'); }); it('rejects a channel with missing API keys instead of silently falling back', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'empty', OPENAI_CHANNEL_1_BASE_URL: 'https://empty.example.com/v1' }), /OPENAI_CHANNEL_1_API_KEYS/ ); }); it('rejects removed JSON config with a migration hint', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_CHANNELS_JSON: '{"channels":[]}', OPENAI_UPSTREAM_REQUEST_MODE_PRIORITY: 'images-sse,images-non-stream' }), /OPENAI_CHANNEL_N/ ); }); it('parses explicit per-channel request modes', () => { const config = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'images-only', OPENAI_CHANNEL_1_BASE_URL: 'https://images.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-json, images-sse' }); assert.deepEqual(config.credentials[0]?.requestModes, ['images-non-stream', 'images-sse']); }); it('parses global and per-channel request mode priority without changing the whitelist', () => { const config = parseChannelPoolConfig({ OPENAI_UPSTREAM_REQUEST_MODE_PRIORITY: 'images-sse, images-json', OPENAI_CHANNEL_1_ID: 'images', OPENAI_CHANNEL_1_BASE_URL: 'https://images.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-json,images-sse', OPENAI_CHANNEL_2_ID: 'json-first', OPENAI_CHANNEL_2_BASE_URL: 'https://json-first.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'sk-two', OPENAI_CHANNEL_2_REQUEST_MODES: 'images-json,images-sse', OPENAI_CHANNEL_2_REQUEST_MODE_PRIORITY: 'images-json,images-sse' }); assert.deepEqual(config.credentials[0]?.requestModes, ['images-non-stream', 'images-sse']); assert.deepEqual(config.requestModePriority, ['images-sse', 'images-non-stream']); assert.deepEqual(config.credentials[0]?.requestModePriority, ['images-sse', 'images-non-stream']); assert.deepEqual(config.credentials[1]?.requestModePriority, ['images-non-stream', 'images-sse']); }); it('rejects invalid per-channel request modes', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'bad', OPENAI_CHANNEL_1_BASE_URL: 'https://bad.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_REQUEST_MODES: 'responses-websocket' }), /请求方式/ ); }); it('rejects per-channel request mode priority outside the channel whitelist', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'images-only', OPENAI_CHANNEL_1_BASE_URL: 'https://images.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-json', OPENAI_CHANNEL_1_REQUEST_MODE_PRIORITY: 'responses-sse,images-json' }), /REQUEST_MODE_PRIORITY.*不在白名单/ ); }); }); describe('getChannelPoolSummary', () => { it('returns sanitized capacity metadata without exposing API keys', () => { const config = parseChannelPoolConfig({ OPENAI_ROUTING_STRATEGY: 'round_robin', OPENAI_CHANNEL_1_ID: 'official', OPENAI_CHANNEL_1_BASE_URL: 'https://api.openai.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one, sk-two', OPENAI_CHANNEL_2_ID: 'backup', OPENAI_CHANNEL_2_BASE_URL: 'https://backup.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'sk-three' }); assert.deepEqual(getChannelPoolSummary(config), { credentialCount: 3, channelCount: 2, strategy: 'round_robin', channels: [ { id: 'official', baseUrl: 'https://api.openai.com/v1', upstreamProxy: { configured: false }, upstreamProfile: 'openai-compatible', effectiveProfile: IMAGE_UPSTREAM_PROFILES['openai-compatible'], hasExtraHeaders: false, requestHeaders: DEFAULT_HEADER_SUMMARY, requestModes: ['images-non-stream'], requestModePriority: ['images-non-stream'], credentialCount: 2 }, { id: 'backup', baseUrl: 'https://backup.example.com/v1', upstreamProxy: { configured: false }, upstreamProfile: 'openai-compatible', effectiveProfile: IMAGE_UPSTREAM_PROFILES['openai-compatible'], hasExtraHeaders: false, requestHeaders: DEFAULT_HEADER_SUMMARY, requestModes: ['images-non-stream'], requestModePriority: ['images-non-stream'], credentialCount: 1 } ] }); }); it('reports channel upstream profile and extra header availability without exposing header values', () => { const config = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'matsca', OPENAI_CHANNEL_1_BASE_URL: 'https://matsca.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_UPSTREAM_PROFILE: 'matsca', OPENAI_CHANNEL_1_MATSCA_APP_ID: 'app-id', OPENAI_CHANNEL_1_MATSCA_APP_SECRET: 'app-secret' }); assert.deepEqual(getChannelPoolSummary(config), { credentialCount: 1, channelCount: 1, strategy: 'sticky', channels: [ { id: 'matsca', baseUrl: 'https://matsca.example.com/v1', upstreamProxy: { configured: false }, upstreamProfile: 'matsca', effectiveProfile: IMAGE_UPSTREAM_PROFILES.matsca, hasExtraHeaders: true, requestHeaders: { ...DEFAULT_HEADER_SUMMARY, has_extra_headers: true, configured_header_names: ['x-app-id', 'x-app-secret'] }, requestModes: ['images-non-stream'], requestModePriority: ['images-non-stream'], credentialCount: 1 } ] }); }); it('supports safe per-channel User-Agent overrides without exposing header values', () => { const config = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'jisuanyun', OPENAI_CHANNEL_1_BASE_URL: 'https://xkj.jisuanyun.vip/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_USER_AGENT: 'visual-journal/customer-node' }); assert.equal(config.credentials[0]?.upstreamHeaders?.['User-Agent'], 'visual-journal/customer-node'); assert.deepEqual(getChannelPoolSummary(config).channels[0]?.requestHeaders, { ...DEFAULT_HEADER_SUMMARY, user_agent_effective: 'visual-journal/customer-node', configured_header_names: ['user-agent'] }); assert.equal(JSON.stringify(getChannelPoolSummary(config)).includes('sk-one'), false); }); it('rejects unsafe per-channel JSON headers that would override protocol headers', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'bad', OPENAI_CHANNEL_1_BASE_URL: 'https://bad.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_UPSTREAM_HEADERS_JSON: '{"Authorization":"Bearer wrong"}' }), /不能配置 Authorization/ ); }); it('rejects half-configured Matsca app headers', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'matsca', OPENAI_CHANNEL_1_BASE_URL: 'https://matsca.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_UPSTREAM_PROFILE: 'matsca', OPENAI_CHANNEL_1_MATSCA_APP_ID: 'app-id' }), /必须成对配置/ ); }); it('parses provider manifest summaries and derived profile constraints without exposing secrets', () => { const manifest = JSON.stringify({ schema_version: 1, id: 'custom_provider', name: 'Custom Provider', base_profile: 'matsca', modes: { generate: { submit: { path: '/images/generations', content_type: 'application/json', response_format: 'custom-json' }, poll: { path: '/jobs/{id}', status_path: 'status', success_values: ['succeeded'], failure_values: ['failed'] } }, edit: { submit: { path: '/images/edits', content_type: 'multipart/form-data' } } }, constraints: { generate_count: { min: 1, max: 2 }, edit_count: { min: 1, max: 1 }, partial_images: { min: 0, max: 2 }, upload: { max_images: 4, max_single_bytes: 10485760, max_total_bytes: 41943040 } } }); const config = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'custom', OPENAI_CHANNEL_1_BASE_URL: 'https://custom.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_UPSTREAM_PROFILE: 'matsca', OPENAI_CHANNEL_1_PROVIDER_MANIFEST: manifest }); assert.equal(config.credentials[0]?.providerProfile?.generateCount.max, 2); assert.equal(config.credentials[0]?.providerProfile?.editCount.max, 1); assert.equal(config.credentials[0]?.providerProfile?.upload.maxImages, 4); assert.deepEqual(getChannelPoolSummary(config), { credentialCount: 1, channelCount: 1, strategy: 'sticky', channels: [ { id: 'custom', baseUrl: 'https://custom.example.com/v1', upstreamProxy: { configured: false }, upstreamProfile: 'matsca', effectiveProfile: config.credentials[0]?.providerProfile, hasExtraHeaders: false, requestHeaders: DEFAULT_HEADER_SUMMARY, requestModes: ['images-non-stream'], requestModePriority: ['images-non-stream'], providerManifest: { id: 'custom_provider', name: 'Custom Provider', baseProfile: 'matsca', modes: { generate: 'async-poll', edit: 'multipart' }, requestTypes: { generate: 'application/json', edit: 'multipart/form-data' }, responseFormats: { generate: 'custom-json', edit: 'openai-images' }, asyncPolling: { generate: true, edit: false }, executionSupport: { generate: 'declared_only', edit: 'implemented' } }, credentialCount: 1 } ] }); assert.equal(JSON.stringify(getChannelPoolSummary(config)).includes('sk-one'), false); }); it('rejects provider manifests whose base profile conflicts with the channel profile', () => { assert.throws( () => parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'custom', OPENAI_CHANNEL_1_BASE_URL: 'https://custom.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-one', OPENAI_CHANNEL_1_UPSTREAM_PROFILE: 'openai-compatible', OPENAI_CHANNEL_1_PROVIDER_MANIFEST: JSON.stringify({ id: 'custom_provider', base_profile: 'matsca', modes: { generate: { submit: { path: '/images/generations' } } } }) }), /base_profile 必须和该渠道 upstream profile 一致/ ); }); }); describe('createChannelRouter', () => { const config = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'a', OPENAI_CHANNEL_1_BASE_URL: 'https://a.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'a1,a2', OPENAI_CHANNEL_2_ID: 'b', OPENAI_CHANNEL_2_BASE_URL: 'https://b.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'b1' }); it('keeps sticky selection stable for the same affinity key', () => { const router = createChannelRouter({ ...config, strategy: 'sticky' }); const first = router.select({ affinityKey: 'client-a' }); const second = router.select({ affinityKey: 'client-a' }); assert.equal(first.id, second.id); assert.ok(config.credentials.some((credential) => credential.id === first.id)); }); it('cycles through credentials with round robin', () => { const router = createChannelRouter({ ...config, strategy: 'round_robin' }); assert.deepEqual( [router.select().id, router.select().id, router.select().id, router.select().id], ['a#0', 'a#1', 'b#0', 'a#0'] ); }); it('uses injected random source for random routing', () => { const router = createChannelRouter({ ...config, strategy: 'random', random: () => 0.75 }); assert.equal(router.select().id, 'b#0'); }); it('selects only channels that support the requested mode', () => { const modeConfig = parseChannelPoolConfig({ OPENAI_ROUTING_STRATEGY: 'round_robin', OPENAI_CHANNEL_1_ID: 'images', OPENAI_CHANNEL_1_BASE_URL: 'https://images.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sk-images', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream', OPENAI_CHANNEL_2_ID: 'responses', OPENAI_CHANNEL_2_BASE_URL: 'https://responses.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'sk-responses', OPENAI_CHANNEL_2_REQUEST_MODES: 'responses-sse' }); const router = createChannelRouter(modeConfig); assert.equal(router.select({ requestMode: 'responses-sse' }).channelId, 'responses'); assert.equal(router.select({ requestMode: 'images-non-stream' }).channelId, 'images'); assert.throws(() => router.select({ requestMode: 'images-sse' }), /支持 images-sse/); }); it('selects a request mode from channel priority when callers provide candidates', () => { const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'images', OPENAI_CHANNEL_1_BASE_URL: 'https://images.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'images-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse', OPENAI_CHANNEL_1_REQUEST_MODE_PRIORITY: 'images-sse,images-non-stream' }); const router = createChannelRouter(requestModeConfig); assert.deepEqual( router.selectWithRequestModes({ affinityKey: 'same-user', requestModes: ['images-non-stream', 'images-sse'] }), { credential: requestModeConfig.credentials[0], requestMode: 'images-sse', preferredRequestMode: 'images-sse', requestModePriority: ['images-sse', 'images-non-stream'] } ); }); it('selects the lowest-cost request mode before routing across split-mode channels', () => { const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'sse', OPENAI_CHANNEL_1_BASE_URL: 'https://sse.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sse-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-sse', OPENAI_CHANNEL_2_ID: 'json', OPENAI_CHANNEL_2_BASE_URL: 'https://json.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'json-key', OPENAI_CHANNEL_2_REQUEST_MODES: 'images-non-stream' }); const router = createChannelRouter({ ...requestModeConfig, strategy: 'round_robin' }); assert.deepEqual( router.selectWithRequestModes({ affinityKey: 'same-user', requestModes: ['images-non-stream', 'images-sse'] }), { credential: requestModeConfig.credentials[1], requestMode: 'images-non-stream', preferredRequestMode: 'images-non-stream', requestModePriority: ['images-non-stream', 'images-sse'] } ); }); it('uses a shared explicit request mode priority before routing across split-mode channels', () => { const requestModeConfig = parseChannelPoolConfig({ OPENAI_UPSTREAM_REQUEST_MODE_PRIORITY: 'images-sse,images-non-stream', OPENAI_CHANNEL_1_ID: 'sse', OPENAI_CHANNEL_1_BASE_URL: 'https://sse.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sse-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-sse', OPENAI_CHANNEL_2_ID: 'json', OPENAI_CHANNEL_2_BASE_URL: 'https://json.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'json-key', OPENAI_CHANNEL_2_REQUEST_MODES: 'images-non-stream' }); const router = createChannelRouter({ ...requestModeConfig, strategy: 'round_robin' }); assert.deepEqual( router.selectWithRequestModes({ affinityKey: 'same-user', requestModes: ['images-non-stream', 'images-sse'] }), { credential: requestModeConfig.credentials[0], requestMode: 'images-sse', preferredRequestMode: 'images-sse', requestModePriority: ['images-sse', 'images-non-stream'] } ); }); it('uses a local request mode priority before global priority across split-mode channels', () => { const requestModeConfig = parseChannelPoolConfig({ OPENAI_UPSTREAM_REQUEST_MODE_PRIORITY: 'images-sse,images-non-stream', OPENAI_CHANNEL_1_ID: 'sse', OPENAI_CHANNEL_1_BASE_URL: 'https://sse.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'sse-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-sse', OPENAI_CHANNEL_2_ID: 'json', OPENAI_CHANNEL_2_BASE_URL: 'https://json.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'json-key', OPENAI_CHANNEL_2_REQUEST_MODES: 'images-non-stream', OPENAI_CHANNEL_2_REQUEST_MODE_PRIORITY: 'images-non-stream' }); const router = createChannelRouter({ ...requestModeConfig, strategy: 'round_robin' }); assert.deepEqual( router.selectWithRequestModes({ affinityKey: 'same-user', requestModes: ['images-non-stream', 'images-sse'] }), { credential: requestModeConfig.credentials[1], requestMode: 'images-non-stream', preferredRequestMode: 'images-non-stream', requestModePriority: ['images-non-stream'] } ); }); it('uses a mixed channel local priority before default low-cost priority on sibling channels', () => { const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'mixed', OPENAI_CHANNEL_1_BASE_URL: 'https://mixed.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'mixed-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse', OPENAI_CHANNEL_1_REQUEST_MODE_PRIORITY: 'images-sse,images-non-stream', OPENAI_CHANNEL_2_ID: 'json', OPENAI_CHANNEL_2_BASE_URL: 'https://json.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'json-key', OPENAI_CHANNEL_2_REQUEST_MODES: 'images-non-stream' }); const router = createChannelRouter({ ...requestModeConfig, strategy: 'round_robin' }); assert.deepEqual( router.selectWithRequestModes({ affinityKey: 'same-user', requestModes: ['images-non-stream', 'images-sse'] }), { credential: requestModeConfig.credentials[0], requestMode: 'images-sse', preferredRequestMode: 'images-sse', requestModePriority: ['images-sse', 'images-non-stream'] } ); }); it('uses the local channel request mode priority for a single mixed-mode channel', () => { const requestModeConfig = parseChannelPoolConfig({ OPENAI_UPSTREAM_REQUEST_MODE_PRIORITY: 'images-sse,images-non-stream', OPENAI_CHANNEL_1_ID: 'mixed', OPENAI_CHANNEL_1_BASE_URL: 'https://mixed.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'mixed-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse', OPENAI_CHANNEL_1_REQUEST_MODE_PRIORITY: 'images-non-stream,images-sse' }); const router = createChannelRouter(requestModeConfig); assert.deepEqual( router.selectWithRequestModes({ affinityKey: 'same-user', requestModes: ['images-non-stream', 'images-sse'] }), { credential: requestModeConfig.credentials[0], requestMode: 'images-non-stream', preferredRequestMode: 'images-non-stream', requestModePriority: ['images-non-stream', 'images-sse'] } ); }); it('skips a failed credential until the cooldown expires', () => { let now = 1000; const router = createChannelRouter({ ...config, strategy: 'round_robin', failureCooldownMs: 100, now: () => now }); const failed = router.select(); assert.equal(failed.id, 'a#0'); router.reportFailure(failed); assert.equal(router.select().id, 'a#1'); assert.equal(router.select().id, 'b#0'); assert.equal(router.select().id, 'a#1'); now = 1100; assert.equal(router.select().id, 'b#0'); assert.equal(router.select().id, 'a#0'); }); it('fails explicitly when every credential is cooling down', () => { const router = createChannelRouter({ ...config, failureCooldownMs: 100, now: () => 1000 }); config.credentials.forEach((credential) => router.reportFailure(credential)); assert.throws(() => router.select({ affinityKey: 'client-a' }), /没有可用的健康渠道凭证/); }); it('keeps credentials routable when failure cooldown is disabled', () => { const router = createChannelRouter({ ...config, failureCooldownEnabled: false, failureCooldownMs: 100, now: () => 1000, requireProbeForRecovery: true }); const report = router.reportFailure(config.credentials[0], { scope: 'channel' }); assert.equal(report.cooldownApplied, false); assert.deepEqual(router.getRecoveryProbeCandidates(), []); assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 3, unhealthyCredentialCount: 0, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'channel' } }); const selected = router.select({ affinityKey: 'client-a' }); assert.ok(config.credentials.some((credential) => credential.id === selected.id)); }); it('uses a 30 second default failure cooldown', () => { const router = createChannelRouter({ ...config, now: () => 1000 }); const report = router.reportFailure(config.credentials[0]); assert.equal(report.cooldownApplied, true); assert.equal(report.retryAfterMs, 30_000); assert.equal(report.cooldownUntil, 31_000); }); it('reports healthy capacity after credentials enter and leave cooldown', () => { let now = 1000; const router = createChannelRouter({ ...config, failureCooldownMs: 100, now: () => now }); const failed = config.credentials[0]; assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 3, unhealthyCredentialCount: 0, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0 }); router.reportFailure(failed); assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 2, unhealthyCredentialCount: 1, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'credential' } }); now = 1100; assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 3, unhealthyCredentialCount: 0, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'credential' } }); }); it('reports healthy channel capacity when some credentials or whole channels are cooling down', () => { let now = 1000; const router = createChannelRouter({ ...config, failureCooldownMs: 100, now: () => now }); router.reportFailure(config.credentials[0]); assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 2, unhealthyCredentialCount: 1, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'credential' } }); router.reportFailure(config.credentials[2], { scope: 'channel' }); assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 1, unhealthyCredentialCount: 2, channelCount: 2, healthyChannelCount: 1, unhealthyChannelCount: 1, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'channel' } }); now = 1100; assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 3, unhealthyCredentialCount: 0, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'channel' } }); }); it('reports configured and effective request modes separately', () => { let now = 1000; const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'images', OPENAI_CHANNEL_1_BASE_URL: 'https://images.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'images-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse', OPENAI_CHANNEL_2_ID: 'responses', OPENAI_CHANNEL_2_BASE_URL: 'https://responses.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'responses-key', OPENAI_CHANNEL_2_REQUEST_MODES: 'responses-sse' }); const router = createChannelRouter({ ...requestModeConfig, failureCooldownMs: 100, now: () => now }); assert.deepEqual(router.getRequestModeHealthSummary(), { configuredRequestModes: ['images-non-stream', 'images-sse', 'responses-sse'], effectiveRequestModes: ['images-non-stream', 'images-sse', 'responses-sse'], defaultRequestModePriority: ['images-non-stream', 'images-sse', 'responses-non-stream', 'responses-sse'], modes: [ { mode: 'images-non-stream', configuredCredentialCount: 1, healthyCredentialCount: 1, configuredChannelCount: 1, healthyChannelCount: 1 }, { mode: 'images-sse', configuredCredentialCount: 1, healthyCredentialCount: 1, configuredChannelCount: 1, healthyChannelCount: 1 }, { mode: 'responses-non-stream', configuredCredentialCount: 0, healthyCredentialCount: 0, configuredChannelCount: 0, healthyChannelCount: 0 }, { mode: 'responses-sse', configuredCredentialCount: 1, healthyCredentialCount: 1, configuredChannelCount: 1, healthyChannelCount: 1 } ], effectiveRequestModesByChannel: [ { channelId: 'images', requestModes: ['images-non-stream', 'images-sse'], requestModePriority: ['images-non-stream', 'images-sse'] }, { channelId: 'responses', requestModes: ['responses-sse'], requestModePriority: ['responses-sse'] } ] }); router.reportFailure(requestModeConfig.credentials[1], { scope: 'channel' }); assert.deepEqual(router.getRequestModeHealthSummary(), { configuredRequestModes: ['images-non-stream', 'images-sse', 'responses-sse'], effectiveRequestModes: ['images-non-stream', 'images-sse'], defaultRequestModePriority: ['images-non-stream', 'images-sse', 'responses-non-stream', 'responses-sse'], modes: [ { mode: 'images-non-stream', configuredCredentialCount: 1, healthyCredentialCount: 1, configuredChannelCount: 1, healthyChannelCount: 1 }, { mode: 'images-sse', configuredCredentialCount: 1, healthyCredentialCount: 1, configuredChannelCount: 1, healthyChannelCount: 1 }, { mode: 'responses-non-stream', configuredCredentialCount: 0, healthyCredentialCount: 0, configuredChannelCount: 0, healthyChannelCount: 0 }, { mode: 'responses-sse', configuredCredentialCount: 1, healthyCredentialCount: 0, configuredChannelCount: 1, healthyChannelCount: 0 } ], effectiveRequestModesByChannel: [ { channelId: 'images', requestModes: ['images-non-stream', 'images-sse'], requestModePriority: ['images-non-stream', 'images-sse'] } ] }); now = 1100; assert.deepEqual(router.getRequestModeHealthSummary().effectiveRequestModes, [ 'images-non-stream', 'images-sse', 'responses-sse' ]); }); it('cools only the failed request mode when failure reports include a request mode', () => { let now = 1000; const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'mixed', OPENAI_CHANNEL_1_BASE_URL: 'https://mixed.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'mixed-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse' }); const router = createChannelRouter({ ...requestModeConfig, failureCooldownMs: 100, now: () => now }); const credential = requestModeConfig.credentials[0]; const report = router.reportFailure(credential, { scope: 'channel', requestMode: 'images-sse', reason: { at: now, scope: 'channel', status: 524 } }); assert.deepEqual(report.target, { channelId: 'mixed', requestMode: 'images-sse' }); assert.deepEqual(report.reason, { at: 1000, scope: 'channel', status: 524, requestMode: 'images-sse' }); assert.throws(() => router.select({ requestMode: 'images-sse' }), /支持 images-sse/); assert.equal(router.select({ requestMode: 'images-non-stream' }).id, credential.id); assert.deepEqual(router.getHealthSummary(), { credentialCount: 1, healthyCredentialCount: 1, unhealthyCredentialCount: 0, channelCount: 1, healthyChannelCount: 1, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'channel', status: 524, requestMode: 'images-sse' } }); assert.deepEqual(router.getRequestModeHealthSummary(), { configuredRequestModes: ['images-non-stream', 'images-sse'], effectiveRequestModes: ['images-non-stream'], defaultRequestModePriority: ['images-non-stream', 'images-sse', 'responses-non-stream', 'responses-sse'], modes: [ { mode: 'images-non-stream', configuredCredentialCount: 1, healthyCredentialCount: 1, configuredChannelCount: 1, healthyChannelCount: 1 }, { mode: 'images-sse', configuredCredentialCount: 1, healthyCredentialCount: 0, configuredChannelCount: 1, healthyChannelCount: 0 }, { mode: 'responses-non-stream', configuredCredentialCount: 0, healthyCredentialCount: 0, configuredChannelCount: 0, healthyChannelCount: 0 }, { mode: 'responses-sse', configuredCredentialCount: 0, healthyCredentialCount: 0, configuredChannelCount: 0, healthyChannelCount: 0 } ], effectiveRequestModesByChannel: [ { channelId: 'mixed', requestModes: ['images-non-stream'], requestModePriority: ['images-non-stream'] } ] }); now = 1100; assert.equal(router.select({ requestMode: 'images-sse' }).id, credential.id); assert.deepEqual(router.getRequestModeHealthSummary().effectiveRequestModes, [ 'images-non-stream', 'images-sse' ]); }); it('uses per-channel cooldown when a channel defines a longer window', () => { let now = 1000; const channelConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'a', OPENAI_CHANNEL_1_BASE_URL: 'https://a.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'a1,a2', OPENAI_CHANNEL_1_FAILURE_COOLDOWN_MS: '250', OPENAI_CHANNEL_2_ID: 'b', OPENAI_CHANNEL_2_BASE_URL: 'https://b.example.com/v1', OPENAI_CHANNEL_2_API_KEYS: 'b1' }); const router = createChannelRouter({ ...channelConfig, failureCooldownMs: 100, now: () => now }); router.reportFailure(channelConfig.credentials[0], { scope: 'channel' }); now = 1100; assert.equal(router.select({ affinityKey: 'client-a' }).channelId, 'b'); now = 1250; assert.ok(router.getHealthSummary().healthyCredentialCount >= 2); }); it('falls forward from a cooled sticky credential to the next healthy credential', () => { const router = createChannelRouter({ ...config, strategy: 'sticky', failureCooldownMs: 100, now: () => 1000 }); const sticky = router.select({ affinityKey: 'client-a' }); router.reportFailure(sticky); const replacement = router.select({ affinityKey: 'client-a' }); assert.notEqual(replacement.id, sticky.id); assert.ok(config.credentials.some((credential) => credential.id === replacement.id)); }); it('does not change health when a non-credential error is ignored by the caller', () => { const router = createChannelRouter({ ...config, failureCooldownMs: 100, now: () => 1000 }); assert.equal(isCredentialFailure({ status: 400, code: 'invalid_request_error' }), false); assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 3, unhealthyCredentialCount: 0, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0 }); }); it('cools every credential in the failed channel while preserving other channels', () => { let now = 1000; const router = createChannelRouter({ ...config, strategy: 'round_robin', failureCooldownMs: 100, now: () => now }); const failed = router.select(); assert.equal(failed.id, 'a#0'); router.reportFailure(failed, { scope: 'channel' }); assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 1, unhealthyCredentialCount: 2, channelCount: 2, healthyChannelCount: 1, unhealthyChannelCount: 1, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'channel' } }); assert.equal(router.select().id, 'b#0'); assert.equal(router.select().id, 'b#0'); now = 1100; assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 3, unhealthyCredentialCount: 0, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'channel' } }); }); it('requires a successful recovery probe before a cooled credential returns to user traffic', () => { let now = 1000; const router = createChannelRouter({ ...config, strategy: 'round_robin', failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const failed = router.select(); assert.equal(failed.id, 'a#0'); router.reportFailure(failed); now = 1100; assert.deepEqual([router.select().id, router.select().id, router.select().id], ['a#1', 'b#0', 'a#1']); const candidates = router.getRecoveryProbeCandidates(); assert.deepEqual( candidates.map((candidate) => ({ scope: candidate.scope, credentialId: candidate.credential.id })), [{ scope: 'credential', credentialId: 'a#0' }] ); assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 2, unhealthyCredentialCount: 1, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 1, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1000, scope: 'credential' } }); router.reportRecoveryProbeSuccess(candidates[0]); assert.equal(router.select().id, 'b#0'); assert.equal(router.select().id, 'a#0'); }); it('requires channel recovery probes and re-cools the channel after a failed probe', () => { let now = 1000; const router = createChannelRouter({ ...config, strategy: 'round_robin', failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); router.reportFailure(config.credentials[0], { scope: 'channel' }); now = 1100; assert.equal(router.select().id, 'b#0'); assert.equal(router.select().id, 'b#0'); assert.deepEqual( router.getRecoveryProbeCandidates().map((candidate) => ({ scope: candidate.scope, credentialId: candidate.credential.id })), [{ scope: 'channel', credentialId: 'a#0' }] ); router.reportRecoveryProbeFailure(router.getRecoveryProbeCandidates()[0], { at: now, scope: 'channel', status: 503, code: 'probe_failed' }); assert.deepEqual(router.getRecoveryProbeCandidates(), []); assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 1, unhealthyCredentialCount: 2, channelCount: 2, healthyChannelCount: 1, unhealthyChannelCount: 1, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 1, lastFailure: { at: 1100, scope: 'channel', status: 503, code: 'probe_failed' } }); now = 1200; const retryCandidate = router.getRecoveryProbeCandidates()[0]; assert.equal(retryCandidate.scope, 'channel'); assert.equal(retryCandidate.credential.id, 'a#0'); router.reportRecoveryProbeSuccess(retryCandidate); assert.deepEqual(router.getHealthSummary(), { credentialCount: 3, healthyCredentialCount: 3, unhealthyCredentialCount: 0, channelCount: 2, healthyChannelCount: 2, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 0, lastFailure: { at: 1100, scope: 'channel', status: 503, code: 'probe_failed' } }); }); it('requires recovery probes for request-mode cooldowns', () => { let now = 1000; const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'mixed', OPENAI_CHANNEL_1_BASE_URL: 'https://mixed.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'mixed-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse' }); const router = createChannelRouter({ ...requestModeConfig, failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const failed = requestModeConfig.credentials[0]; router.reportFailure(failed, { scope: 'channel', requestMode: 'images-sse' }); now = 1100; assert.equal(router.select({ requestMode: 'images-non-stream' }).id, failed.id); assert.throws(() => router.select({ requestMode: 'images-sse' }), /支持 images-sse/); assert.deepEqual( router.getRecoveryProbeCandidates().map((candidate) => ({ scope: candidate.scope, credentialId: candidate.credential.id, requestMode: candidate.requestMode })), [{ scope: 'channel', credentialId: 'mixed#0', requestMode: 'images-sse' }] ); assert.deepEqual(router.getHealthSummary(), { credentialCount: 1, healthyCredentialCount: 1, unhealthyCredentialCount: 0, channelCount: 1, healthyChannelCount: 1, unhealthyChannelCount: 0, pendingRecoveryProbeCredentialCount: 0, pendingRecoveryProbeChannelCount: 1, lastFailure: { at: 1000, scope: 'channel', requestMode: 'images-sse' } }); const candidate = router.getRecoveryProbeCandidates()[0]; assert.equal(router.reportRecoveryProbeSuccess(candidate), true); assert.equal(router.select({ requestMode: 'images-sse' }).id, failed.id); }); it('uses a request-mode-capable sibling credential for channel request-mode recovery probes', () => { let now = 1000; const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'mixed', OPENAI_CHANNEL_1_BASE_URL: 'https://mixed.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'mixed-a,mixed-b', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse' }); const router = createChannelRouter({ ...requestModeConfig, failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const [first, second] = requestModeConfig.credentials; router.reportFailure(first, { scope: 'channel', requestMode: 'images-sse' }); now = 1010; router.reportFailure(first, { requestMode: 'images-sse' }); now = 1100; assert.deepEqual( router.getRecoveryProbeCandidates().map((candidate) => ({ scope: candidate.scope, credentialId: candidate.credential.id, requestMode: candidate.requestMode })), [{ scope: 'channel', credentialId: second.id, requestMode: 'images-sse' }] ); assert.equal(router.reportRecoveryProbeSuccess(router.getRecoveryProbeCandidates()[0]), true); assert.equal(router.getHealthSummary().pendingRecoveryProbeCredentialCount, 1); }); it('queues the channel recovery probe before request-mode probes for the same channel', () => { let now = 1000; const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'mixed', OPENAI_CHANNEL_1_BASE_URL: 'https://mixed.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'mixed-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse' }); const router = createChannelRouter({ ...requestModeConfig, failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const failed = requestModeConfig.credentials[0]; router.reportFailure(failed, { scope: 'channel' }); router.reportFailure(failed, { scope: 'channel', requestMode: 'images-sse' }); now = 1100; assert.deepEqual( router.getRecoveryProbeCandidates().map((candidate) => ({ scope: candidate.scope, credentialId: candidate.credential.id, requestMode: candidate.requestMode })), [{ scope: 'channel', credentialId: failed.id, requestMode: undefined }] ); }); it('queues the credential recovery probe before request-mode probes for the same credential', () => { let now = 1000; const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'mixed', OPENAI_CHANNEL_1_BASE_URL: 'https://mixed.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'mixed-key', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse' }); const router = createChannelRouter({ ...requestModeConfig, failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const failed = requestModeConfig.credentials[0]; router.reportFailure(failed); router.reportFailure(failed, { requestMode: 'images-sse' }); now = 1100; assert.deepEqual( router.getRecoveryProbeCandidates().map((candidate) => ({ scope: candidate.scope, credentialId: candidate.credential.id, requestMode: candidate.requestMode })), [{ scope: 'credential', credentialId: failed.id, requestMode: undefined }] ); }); it('clears older credential request-mode probes when a channel request-mode probe recovers', () => { let now = 1000; const requestModeConfig = parseChannelPoolConfig({ OPENAI_CHANNEL_1_ID: 'mixed', OPENAI_CHANNEL_1_BASE_URL: 'https://mixed.example.com/v1', OPENAI_CHANNEL_1_API_KEYS: 'mixed-a,mixed-b', OPENAI_CHANNEL_1_REQUEST_MODES: 'images-non-stream,images-sse' }); const router = createChannelRouter({ ...requestModeConfig, failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const [first, second] = requestModeConfig.credentials; router.reportFailure(first, { requestMode: 'images-sse' }); router.reportFailure(second, { requestMode: 'images-sse' }); now = 1010; router.reportFailure(first, { scope: 'channel', requestMode: 'images-sse' }); now = 1110; const candidate = router.getRecoveryProbeCandidates()[0]; assert.equal(router.reportRecoveryProbeSuccess(candidate), true); assert.equal(router.getHealthSummary().pendingRecoveryProbeCredentialCount, 0); assert.equal(router.select({ requestMode: 'images-sse' }).channelId, 'mixed'); }); it('ignores stale recovery probe success after the credential fails again', () => { let now = 1000; const router = createChannelRouter({ ...config, strategy: 'round_robin', failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const failed = config.credentials[0]; router.reportFailure(failed); now = 1100; const staleCandidate = router.getRecoveryProbeCandidates()[0]; now = 1110; router.reportFailure(failed); router.reportRecoveryProbeSuccess(staleCandidate); assert.equal(router.getHealthSummary().pendingRecoveryProbeCredentialCount, 1); assert.throws(() => selectOnlyCredential(router, failed.id), /没有可用的健康渠道凭证/); now = 1210; const freshCandidate = router.getRecoveryProbeCandidates()[0]; assert.equal(freshCandidate.credential.id, failed.id); router.reportRecoveryProbeSuccess(freshCandidate); assert.equal(selectOnlyCredential(router, failed.id).id, failed.id); }); it('ignores stale recovery probe success after the channel fails again', () => { let now = 1000; const router = createChannelRouter({ ...config, strategy: 'round_robin', failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const failed = config.credentials[0]; router.reportFailure(failed, { scope: 'channel' }); now = 1100; const staleCandidate = router.getRecoveryProbeCandidates()[0]; now = 1110; router.reportFailure(failed, { scope: 'channel' }); router.reportRecoveryProbeSuccess(staleCandidate); assert.equal(router.getHealthSummary().pendingRecoveryProbeChannelCount, 1); assert.deepEqual( config.credentials.filter((credential) => credential.channelId === 'a').filter(canSelect(router)), [] ); now = 1210; const freshCandidate = router.getRecoveryProbeCandidates()[0]; assert.equal(freshCandidate.scope, 'channel'); router.reportRecoveryProbeSuccess(freshCandidate); assert.deepEqual( config.credentials .filter((credential) => credential.channelId === 'a') .filter(canSelect(router)) .map((credential) => credential.id), ['a#0', 'a#1'] ); }); it('clears the selected credential probe when its channel probe proves the same credential recovered', () => { let now = 1000; const router = createChannelRouter({ ...config, strategy: 'round_robin', failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const failed = config.credentials[0]; router.reportFailure(failed); now = 1010; router.reportFailure(failed, { scope: 'channel' }); now = 1110; const candidate = router.getRecoveryProbeCandidates()[0]; assert.equal(candidate.scope, 'channel'); assert.equal(candidate.credential.id, failed.id); assert.equal(router.reportRecoveryProbeSuccess(candidate), true); assert.equal(router.getHealthSummary().pendingRecoveryProbeChannelCount, 0); assert.equal(router.getHealthSummary().pendingRecoveryProbeCredentialCount, 0); assert.equal(selectOnlyCredential(router, failed.id).id, failed.id); }); it('keeps a selected credential pending when its failure is newer than the channel probe', () => { let now = 1000; const router = createChannelRouter({ ...config, strategy: 'round_robin', failureCooldownMs: 100, now: () => now, requireProbeForRecovery: true }); const failed = config.credentials[0]; router.reportFailure(failed, { scope: 'channel' }); now = 1100; const candidate = router.getRecoveryProbeCandidates()[0]; now = 1110; router.reportFailure(failed); assert.equal(router.reportRecoveryProbeSuccess(candidate), true); assert.equal(router.getHealthSummary().pendingRecoveryProbeChannelCount, 0); assert.equal(router.getHealthSummary().pendingRecoveryProbeCredentialCount, 1); assert.throws(() => selectOnlyCredential(router, failed.id), /没有可用的健康渠道凭证/); }); it('stores sanitized failure diagnostics without exposing API keys', () => { const router = createChannelRouter({ ...config, failureCooldownMs: 100, now: () => 1000 }); router.reportFailure(config.credentials[0], { scope: 'channel', reason: { at: 1000, scope: 'channel', status: 524, code: 'cf_timeout', requestId: 'req_123', message: 'A timeout occurred' } }); const summary = router.getHealthSummary(); assert.deepEqual(summary.lastFailure, { at: 1000, scope: 'channel', status: 524, code: 'cf_timeout', requestId: 'req_123', message: 'A timeout occurred' }); assert.equal(JSON.stringify(summary).includes('a1'), false); }); it('returns a public failure summary without upstream message text', () => { const reason = describeChannelFailure( { status: 524, code: 'cf_timeout', requestID: 'req_123', message: 'upstream message with private details' }, 'channel', 1000 ); assert.deepEqual(toPublicChannelFailure({ ...reason, requestMode: 'images-sse' }), { at: 1000, scope: 'channel', status: 524, code: 'cf_timeout', requestId: 'req_123', requestMode: 'images-sse' }); }); it('captures requestId from non-OpenAI error casing', () => { const reason = describeChannelFailure( { status: 500, requestId: 'req_lowercase' }, 'channel', 1000 ); assert.equal(reason.requestId, 'req_lowercase'); }); }); function canSelect(router: ReturnType) { return (credential: { id: string }) => { try { selectOnlyCredential(router, credential.id); return true; } catch { return false; } }; } function selectOnlyCredential(router: ReturnType, credentialId: string) { for (let attempt = 0; attempt < 10; attempt += 1) { const credential = router.select(); if (credential.id === credentialId) return credential; } throw new RequestValidationError('当前没有可用的健康渠道凭证。', 503); } describe('resolveEffectiveCredential', () => { it('uses request API key while preserving legacy server base URL when request URL is blank', () => { const credential = resolveEffectiveCredential({ requestApiKey: 'sk-browser', requestApiBaseUrl: '', legacyBaseUrl: 'https://legacy.example.com/v1', legacyUpstreamProxyUrl: 'http://proxy.example:8080/', selectedCredential: { id: 'server#0', channelId: 'server', apiKey: 'sk-server', baseUrl: 'https://server.example.com/v1', upstreamProfile: 'openai-compatible' } }); assert.deepEqual(credential, { apiKey: 'sk-browser', baseUrl: 'https://legacy.example.com/v1', upstreamProxyUrl: 'http://proxy.example:8080/', upstreamProfile: 'openai-compatible' }); }); it('uses selected server credential when request API key is blank', () => { const selectedCredential = { id: 'server#0', channelId: 'server', apiKey: 'sk-server', baseUrl: 'https://server.example.com/v1', upstreamProfile: 'openai-compatible' } as const; assert.deepEqual( resolveEffectiveCredential({ requestApiKey: '', requestApiBaseUrl: '', legacyBaseUrl: 'https://legacy.example.com/v1', selectedCredential }), { apiKey: 'sk-server', baseUrl: 'https://server.example.com/v1', upstreamProfile: 'openai-compatible', upstreamHeaders: undefined, selectedCredential } ); }); it('does not send a selected server credential to a request-supplied base URL without a request key', () => { const selectedCredential = { id: 'server#0', channelId: 'server', apiKey: 'sk-server', baseUrl: 'https://server.example.com/v1', upstreamProfile: 'openai-compatible', upstreamHeaders: { 'X-App-ID': 'server-app' } } as const; assert.deepEqual( resolveEffectiveCredential({ requestApiKey: '', requestApiBaseUrl: 'https://attacker.example.com/v1', selectedCredential }), { apiKey: 'sk-server', baseUrl: 'https://server.example.com/v1', upstreamProfile: 'openai-compatible', upstreamHeaders: { 'X-App-ID': 'server-app' }, selectedCredential } ); }); }); describe('isCredentialFailure', () => { it('treats auth, quota, and rate limit responses as credential failures', () => { assert.equal(isCredentialFailure({ status: 401 }), true); assert.equal(isCredentialFailure({ status: 403 }), true); assert.equal(isCredentialFailure({ status: 429 }), true); assert.equal(isCredentialFailure({ code: 'insufficient_quota' }), true); assert.equal(isCredentialFailure({ error: { code: 'invalid_api_key' } }), true); }); it('does not mark request validation errors as credential failures', () => { assert.equal(isCredentialFailure({ status: 400, code: 'invalid_request_error' }), false); assert.equal(isCredentialFailure(new Error('prompt is required')), false); }); it('prefers explicit credential error codes even when a gateway wraps them in 5xx status', () => { assert.equal(isCredentialFailure({ status: 503, error: { code: 'invalid_api_key' } }), true); assert.equal(isCredentialFailure({ status: 500, code: 'insufficient_quota' }), true); }); it('does not treat local channel capacity queue errors as credential failures', () => { assert.equal(isCredentialFailure(createCapacityQueueError()), false); }); }); describe('isChannelRequestModeFailure', () => { it('treats Responses image_generation-disabled 403 as a request-mode failure', () => { assert.equal( isChannelRequestModeFailure( new Error('status_code=403, Image generation is not enabled for this group'), 'responses-sse' ), true ); assert.equal( isChannelRequestModeFailure( { status: 403, error: { message: 'Image generation is not enabled for this group' } }, 'responses-non-stream' ), true ); }); it('does not apply the Responses image_generation-disabled rule to Images API modes', () => { assert.equal( isChannelRequestModeFailure( { status: 403, message: 'Image generation is not enabled for this group' }, 'images-sse' ), false ); }); }); describe('isChannelFailure', () => { it('treats upstream 5xx and CDN timeout statuses as channel failures', () => { [500, 502, 503, 504, 520, 522, 523, 524].forEach((status) => { assert.equal(isChannelFailure({ status }), true); }); }); it('does not treat credential or request errors as channel failures', () => { assert.equal(isChannelFailure({ status: 400 }), false); assert.equal(isChannelFailure({ status: 401 }), false); assert.equal(isChannelFailure({ status: 429 }), false); assert.equal(isChannelFailure({ status: 503, error: { code: 'invalid_api_key' } }), false); assert.equal(isChannelFailure(new Error('prompt is required')), false); }); it('does not treat local validation errors as channel failures even when they use a 500 response', () => { assert.equal(isChannelFailure(new RequestValidationError('local config error', 500)), false); }); it('does not treat local channel capacity queue errors as channel failures', () => { assert.equal(isChannelFailure(createCapacityQueueError()), false); }); it('treats upstream connection and timeout failures as channel failures', () => { const connectionError = Object.assign(new Error('Connection error.'), { name: 'APIConnectionError' }); const timeoutError = Object.assign(new Error('Request timed out.'), { name: 'APIConnectionTimeoutError' }); const dnsError = Object.assign(new Error('getaddrinfo ENOTFOUND api.example.com'), { code: 'ENOTFOUND' }); const nestedConnectionError = Object.assign(new Error('Connection error.'), { cause: Object.assign(new TypeError('fetch failed'), { cause: Object.assign(new Error('connect ECONNREFUSED 127.0.0.1:65535'), { code: 'ECONNREFUSED' }) }) }); const messageOnlyConnectionError = new Error('Connection error.'); assert.equal(isChannelFailure(connectionError), true); assert.equal(isChannelFailure(timeoutError), true); assert.equal(isChannelFailure(dnsError), true); assert.equal(isChannelFailure(nestedConnectionError), true); assert.equal(isChannelFailure(messageOnlyConnectionError), true); }); }); function createCapacityQueueError(): ChannelCapacityQueueError { return new ChannelCapacityQueueError({ code: 'channel_capacity_queue_timeout', message: '渠道凭证并发队列等待超时，请稍后重试。', status: 429, retryable: true, details: { credential_id: 'official#0', queue_position: 1, max_wait_ms: 420000 } }); }