Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { describe, expect, it } from 'vitest';
import { previousModelGenerations } from '../modelGeneration.js';
import { buildUserProvider } from '../user-provider.js';
import { isChatEligible } from '../classification.js';
import { BUNDLED_CATALOG } from '../builtin.js';
import { providerModelGenerationRecord, providerModelRecord, providerModelAdapterId } from '../providerModelCatalog.js';
import { parseModelsListResponse } from '../modelDiscovery.js';
import { mergeDiscoveredRuntimeModels } from '../modelMetadataLayers.js';
import type { ProviderRuntimeModelConfig, ProviderWireProtocol } from '../types.js';
const build = (models: ProviderRuntimeModelConfig[], wireProtocol: ProviderWireProtocol = 'openai-responses') => {
const runtime = { baseUrl: 'https://relay.example/v1', wireProtocol, models };
return buildUserProvider({ id: 'my-sub2api', name: 'Relay', runtimes: {
codex: runtime, pi: runtime, 'claude-code': runtime,
} }, { modelRegistry: BUNDLED_CATALOG.modelRegistry });
};
const discovered = (id: string, metadata = {}) => mergeDiscoveredRuntimeModels([], parseModelsListResponse({ data: [{ id, ...metadata }] })!);
describe('new model generation defaults', () => {
it('imports future GPT generations across all engines without requiring the old model in the account', () => {
for (const id of ['gpt-7-sol', 'gpt-8-sol', 'openai/gpt-9-luna']) {
const oldId = id.includes('luna') ? 'gpt-6-luna' : 'gpt-6-sol';
const previous = build(discovered(oldId)).models.codex![0]!;
const saved = discovered(id);
const provider = build(saved);
for (const agent of ['codex', 'pi', 'claude-code'] as const) {
const model = provider.models[agent]![0]!;
expect(model).toMatchObject({ id, name: id, efforts: previous.efforts,
defaultEffort: previous.defaultEffort, contextWindow: previous.contextWindow,
maxOutput: previous.maxOutput, supportsImageInput: true, contextWindowVerified: false });
expect(model.cost).toBeUndefined();
expect(model.userModelConfig).toEqual(saved[0]);
}
}
});
it('uses a target maximum-only report before inherited working windows without verifying it', () => {
const provider = build([
{ id: 'private-6-sol', name: 'Old', discoveredMetadata: { contextWindow: 272000 } },
...discovered('private-7-sol', { max_context_window: 64000 }),
...discovered('gpt-9-sol', { max_context_window: 32000 }),
]);
for (const agent of ['codex', 'pi', 'claude-code'] as const) {
expect(provider.models[agent]![1]).toMatchObject({ contextWindow: 64000,
contextWindowMax: 64000, contextWindowVerified: false });
expect(provider.models[agent]![2]).toMatchObject({ contextWindow: 32000,
contextWindowMax: 32000, contextWindowVerified: false });
}
});
it('takes the closest same-connection generation, preserves explicit disables, and never changes routing', () => {
const provider = build([
{ id: 'private-6-sol', name: 'Six', discoveredMetadata: { efforts: ['low', 'high'], defaultEffort: 'high', contextWindow: 64000, supportsFastMode: true } },
{ id: 'private-7-sol', name: 'Seven', discoveredMetadata: { efforts: [], supportsFastMode: false } },
{ id: 'private-8-sol', name: 'Eight' },
]);
expect(provider.models.codex![2]).toMatchObject({ id: 'private-8-sol', name: 'Eight',
efforts: [], defaultEffort: null, contextWindow: 64000, supportsFastMode: false });
expect(provider.routing.codex?.upstream).toBe('https://relay.example/v1');
});
it('prefers a newer account declaration over the older public catalog', () => {
const models = build([
{ id: 'gpt-8-sol', name: 'Eight', discoveredMetadata: { efforts: ['high'], defaultEffort: null,
contextWindow: 48000, maxOutputTokens: 4000, supportsFastMode: true } },
...discovered('gpt-9-sol'),
]).models.codex!;
expect(models[1]).toMatchObject({ efforts: ['high'], defaultEffort: null,
contextWindow: 48000, maxOutput: 4000, supportsFastMode: true });
});
it('refresh replaces inherited values, while target user settings survive', () => {
const initial = discovered('gpt-9-sol');
expect(build(initial).models.pi![0]!.efforts.length).toBeGreaterThan(0);
const refreshed = mergeDiscoveredRuntimeModels(initial, parseModelsListResponse({ data: [{ id: 'gpt-9-sol',
supported_reasoning_levels: ['low', 'high'], default_reasoning_level: 'high',
context_window: 32000, input_modalities: ['text'], service_tiers: [],
}] })!);
expect(build(refreshed).models.pi![0]).toMatchObject({ efforts: ['low', 'high'], defaultEffort: 'high',
contextWindow: 32000, supportsImageInput: false, supportsFastMode: false });
refreshed[0]!.contextWindow = 16000;
refreshed[0]!.reasoning = false;
expect(build(refreshed).models.pi![0]).toMatchObject({ efforts: [], defaultEffort: null, contextWindow: 16000 });
});
it('verifies only the target window across engines, including declarations equal to inherited defaults', () => {
const initial: [ProviderRuntimeModelConfig, ProviderRuntimeModelConfig] = [
{ id: 'private-6-sol', name: 'Old', discoveredMetadata: { contextWindow: 64000 } },
{ id: 'private-7-sol', name: 'New' },
];
for (const target of [
initial[1],
{ ...initial[1], discoveredMetadata: { contextWindow: 64000 } },
{ ...initial[1], contextWindow: 32000 },
]) {
const provider = build([initial[0], target]);
for (const agent of ['codex', 'pi', 'claude-code'] as const) {
expect(provider.models[agent]![0]).toMatchObject({ contextWindowVerified: true });
expect(provider.models[agent]![1]).toMatchObject({
contextWindow: target.contextWindow ?? 64000,
contextWindowVerified: target !== initial[1],
});
}
}
});
it.each([
['image_generation', 'imageModels'],
['video_generation', 'videoModels'],
['embedding', 'embeddingModels'],
] as const)('does not inherit %s membership, but preserves the target declaration', (mode, field) => {
for (const declared of [false, true]) {
const provider = build([
{ id: 'private-6-sol', name: 'Old', discoveredMetadata: { mode, contextWindow: 64000 } },
{ id: 'private-7-sol', name: 'New', discoveredMetadata: declared ? { mode } : {} },
]);
for (const agent of ['codex', 'pi', 'claude-code'] as const) {
const target = provider.models[agent]![1]!;
expect(target.contextWindow).toBe(64000);
expect(target.mode).toBe(declared ? mode : undefined);
expect(isChatEligible(target)).toBe(!declared);
}
expect(provider[field]?.map(model => model.id)).toEqual(
declared ? ['private-6-sol', 'private-7-sol'] : ['private-6-sol'],
);
}
});
it('does not inherit from another variant, protocol, private namespace or endpoint', () => {
const target = { id: 'private-9-sol', name: 'New' };
for (const source of [
{ id: 'private-8-luna', name: 'Different variant' },
{ id: 'team/private-8-sol', name: 'Private namespace' },
{ id: 'private-8-sol', name: 'Other API', api: 'anthropic-messages' as const },
{ id: 'private-8-sol', name: 'Other endpoint', route: { baseUrl: 'https://other.example/v1', wireProtocol: 'openai-responses' as const } },
]) {
expect(build([{ ...source, reasoning: true, reasoningEfforts: ['high'] }, target]).models.pi![1]!.efforts).toEqual([]);
}
});
it('does not switch the adapter of an already known model while filling defaults', () => {
const model = build(discovered('claude-sonnet-4-6'), 'anthropic-messages').models.codex![0]!;
expect(model.api).toBeUndefined();
expect(model.route).toBeUndefined();
});
it('compares numeric generations and keeps model sizes and variants separate', () => {
const ids = ['gpt-9-sol', 'gpt-6-sol', 'gpt-10-sol', 'gpt-7-luna'];
expect(previousModelGenerations('gpt-11-sol', ids, id => id)).toEqual(['gpt-6-sol', 'gpt-9-sol', 'gpt-10-sol']);
expect(previousModelGenerations('grok-4.10', ['grok-4.9', 'grok-4.11'], id => id)).toEqual(['grok-4.9']);
expect(previousModelGenerations('claude-sonnet-6', ['claude-sonnet-4-6', 'claude-sonnet-5', 'claude-opus-5'], id => id)).toEqual(['claude-sonnet-4-6', 'claude-sonnet-5']);
expect(previousModelGenerations('qwen4-30b', ['qwen3-235b', 'qwen3-30b'], id => id)).toEqual(['qwen3-30b']);
});
it.each([
['private-7b', 'private-70b'],
['gpt-oss-20b', 'gpt-oss-120b'],
['private-0.5b', 'private-1.5b'],
['private-350m', 'private-700m'],
['mixtral-8x7b', 'mixtral-8x22b'],
])('does not treat parameter sizes %s and %s as generations', (small, large) => {
expect(previousModelGenerations(large, [small], id => id)).toEqual([]);
const target = build([
{ id: small, name: small, discoveredMetadata: { contextWindow: 64000,
efforts: ['high'], supportsImageInput: true, supportsFastMode: true } },
{ id: large, name: large },
]).models.pi![1]!;
expect(target.efforts).toEqual([]);
expect(target.supportsFastMode).not.toBe(true);
expect(target.supportsImageInput).not.toBe(true);
});
it('normalizes long trailing slashes without treating internal slashes as the same endpoint', () => {
const endpoint = 'https://api.openai.com/v1';
const slashes = '/'.repeat(100_000);
const source = providerModelRecord('gpt-5.6-sol', endpoint, 'openai-responses');
expect(source).toBeDefined();
expect(providerModelRecord('gpt-5.6-sol', ` ${endpoint}${slashes} `, 'openai-responses')).toBe(source);
expect(providerModelRecord('gpt-5.6-sol', `${endpoint}${slashes}other`, 'openai-responses')).toBeUndefined();
});
it('uses the exact manufacturer adapter before a predecessor on compatible relays', () => {
const exact = providerModelRecord('gpt-5.4', 'https://api.openai.com/v1', 'openai-responses')!;
expect(exact).toBeDefined();
const relay = providerModelGenerationRecord('gpt-5.4', 'https://relay.example/v1', 'openai-responses')!;
const { headers: _headers, ...parameters } = exact.execution.pi;
expect(relay.inheritedFrom).toBe('gpt-5.4');
expect(relay.execution.pi).toEqual(parameters);
expect(relay.upstream).toBe('https://relay.example/v1');
expect(relay.cost).toBeUndefined();
expect(relay.execution.pi.headers).toBeUndefined();
expect(providerModelGenerationRecord('gpt-5.4', 'https://relay.example/v1', 'anthropic-messages')).toBeUndefined();
});
it('retains exact adapter metadata across engines even without Registry entries', () => {
const exact = providerModelRecord('grok-4.7', 'https://api.x.ai/v1', 'openai-responses')!;
expect(exact).toBeDefined();
const runtime = { baseUrl: 'https://relay.example/v1', wireProtocol: 'openai-responses' as const,
models: discovered('grok-4.7') };
const provider = buildUserProvider({ id: 'relay', name: 'Relay', runtimes: {
codex: runtime, pi: runtime, 'claude-code': runtime,
} }, { modelRegistry: { schemaVersion: 4, updatedAt: '2026-09-24T00:00:00Z', models: [] } });
for (const agent of ['codex', 'pi', 'claude-code'] as const) {
expect(provider.models[agent]![0]).toMatchObject({
contextWindow: exact.contextWindow, efforts: exact.efforts,
supportsImageInput: exact.supportsImageInput, contextWindowVerified: true,
});
}
});
it('clears inherited image input after text-only discovery without changing predecessor or output modalities', () => {
const source: ProviderRuntimeModelConfig = { id: 'private-6-sol', name: 'Old', discoveredMetadata: {
modalities: { input: ['text', 'image'], output: ['text', 'image'] }, supportsImageInput: true,
} };
const provider = build([source, ...discovered('private-7-sol', { input_modalities: ['text'] })]);
for (const agent of ['codex', 'pi', 'claude-code'] as const) {
expect(provider.models[agent]![1]).toMatchObject({ supportsImageInput: false,
modalities: { input: ['text'], output: ['text', 'image'] } });
expect(provider.models[agent]![0]).toMatchObject({ supportsImageInput: true,
modalities: { input: ['text', 'image'], output: ['text', 'image'] } });
}
expect(source.discoveredMetadata?.modalities?.input).toEqual(['text', 'image']);
});
it('drops only inherited capacity when the target declares a larger working window', () => {
for (const ownMax of [undefined, 256000]) {
const provider = build([
{ id: 'private-6-sol', name: 'Old', discoveredMetadata: { contextWindow: 64000, contextWindowMax: 64000 } },
{ id: 'private-7-sol', name: 'New', discoveredMetadata: { contextWindow: 128000,
...(ownMax !== undefined ? { contextWindowMax: ownMax } : {}) } },
]);
for (const agent of ['codex', 'pi', 'claude-code'] as const) {
const model = provider.models[agent]![1]!;
expect(model.contextWindow).toBe(128000);
expect(model.contextWindowMax).toBe(ownMax);
}
}
});
it('reuses serializer mappings without copying the predecessor identity, prices, endpoint or headers', () => {
const source = providerModelRecord('gpt-5.6-sol', 'https://api.openai.com/v1', 'openai-responses')!;
const inherited = providerModelGenerationRecord('gpt-9-sol', 'https://relay.example/v1', 'openai-responses')!;
expect(inherited).toMatchObject({ id: 'gpt-9-sol', name: 'gpt-9-sol', upstream: 'https://relay.example/v1', inheritedFrom: 'gpt-5.6-sol' });
expect(inherited.execution.pi.thinkingLevelMap).toEqual(source.execution.pi.thinkingLevelMap);
expect(inherited.execution.pi.compat).toEqual(source.execution.pi.compat);
expect(inherited.cost).toBeUndefined();
expect(inherited.execution.pi.headers).toBeUndefined();
expect(providerModelGenerationRecord('gpt-9-sol', 'https://relay.example/v1', 'anthropic-messages')).toBeUndefined();
});
});
it('preserves canonical API metadata, including explicit negative capabilities', () => {
const metadata = { nativeApi: 'openai-responses', contextWindow: 1000000, maxOutputTokens: 32000,
supportsFastMode: false, supportsToolCalls: false, supportsImageInput: false,
efforts: ['low', 'high'], defaultEffort: 'low', reasoningRequired: true };
const result = parseModelsListResponse({ data: [{ id: 'gpt-7-sol', ...metadata }] });
expect(result?.[0]?.discoveredMetadata).toMatchObject(metadata);
for (const agent of ['claude-code', 'codex', 'pi'] as const) {
const provider = build(mergeDiscoveredRuntimeModels([], result!));
expect(provider.models[agent]?.[0]).toMatchObject({ maxOutput: 32000,
supportsFastMode: false, supportsToolCalls: false, supportsImageInput: false,
efforts: ['low', 'high'] });
}
});
it('resolves inherited adapters only within a matching connection or explicit preset', () => {
const inherited = providerModelGenerationRecord('claude-opus-9', 'https://account.example/v1', 'anthropic-messages', 'cloudflare-ai-gateway')!;
expect(inherited).toBeDefined();
expect(providerModelAdapterId(inherited, 'cloudflare-ai-gateway')).toBe('cloudflare-ai-gateway');
expect(providerModelAdapterId(inherited)).toBeUndefined();
expect(providerModelAdapterId({ ...inherited, execution: { pi: { api: 'google-generative-ai' } } }, 'cloudflare-ai-gateway')).toBeUndefined();
expect(inherited.execution.pi.headers).toBeUndefined();
expect(inherited.cost).toBeUndefined();
});