@valni/cli-darwin-x64 0.0.0-stage → 0.1.3

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/profile.ts

@@ -0,0 +1,120 @@
+import type { AnthropicEffort, AnthropicThinking, AnthropicToolChoice } from './anthropic.js';
+import type { GoogleFunctionCallingMode } from './google.js';
+import type { OpenAIChatRequest, OpenAIToolChoice } from './openaiGeneric.js';
+import type { OpenAIResponsesRequest, OpenAIResponsesToolChoice } from './openaiPro.js';
+
+export interface NumericRange {
+  min?: number;
+  max?: number;
+}
+
+export type AnthropicThinkingMode = 'adaptive' | 'enabled' | 'disabled';
+export type AnthropicToolChoiceOption = 'auto' | 'any' | 'none' | 'tool';
+
+export interface AnthropicThinkingProfile {
+  modes: AnthropicThinkingMode[];
+  budgetTokens?: NumericRange;
+}
+
+export interface AnthropicProfile {
+  kind: 'anthropic';
+  model: string;
+  maxTokensCeiling?: number;
+  temperature?: NumericRange | false;
+  topP?: NumericRange | false;
+  topK?: boolean;
+  stopSequences?: boolean;
+  tools?: boolean;
+  toolChoice?: AnthropicToolChoiceOption[];
+  thinking?: AnthropicThinkingProfile | false;
+  effort?: AnthropicEffort[] | false;
+  vision?: boolean;
+}
+
+export type OpenAIToolChoiceOption = 'auto' | 'none' | 'required' | 'function';
+
+export type OpenAIChatEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export type OpenAIChatVerbosity = 'low' | 'medium' | 'high';
+export type OpenAIResponsesEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export type OpenAIResponsesVerbosity = 'low' | 'medium' | 'high';
+
+type MutuallyAssignable<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
+type AssertTrue<Value extends true> = Value;
+
+export type ProfileEnumWireAssertions = [
+  AssertTrue<MutuallyAssignable<AnthropicThinkingMode, AnthropicThinking['type']>>,
+  AssertTrue<MutuallyAssignable<AnthropicToolChoiceOption, AnthropicToolChoice['type']>>,
+  AssertTrue<MutuallyAssignable<
+    OpenAIToolChoiceOption,
+    Extract<OpenAIToolChoice | OpenAIResponsesToolChoice, string> | Extract<OpenAIToolChoice | OpenAIResponsesToolChoice, { type: string }>['type']
+  >>,
+  AssertTrue<MutuallyAssignable<OpenAIChatEffort, NonNullable<OpenAIChatRequest['reasoning_effort']>>>,
+  AssertTrue<MutuallyAssignable<OpenAIChatVerbosity, NonNullable<OpenAIChatRequest['verbosity']>>>,
+  AssertTrue<MutuallyAssignable<OpenAIResponsesEffort, NonNullable<NonNullable<OpenAIResponsesRequest['reasoning']>['effort']>>>,
+  AssertTrue<MutuallyAssignable<OpenAIResponsesVerbosity, NonNullable<NonNullable<OpenAIResponsesRequest['text']>['verbosity']>>>,
+];
+
+export interface OpenAIGenericProfile {
+  kind: 'openai_generic';
+  model: string;
+  maxTokensCeiling?: number;
+  temperature?: NumericRange | false;
+  topP?: NumericRange | false;
+  frequencyPenalty?: NumericRange | false;
+  presencePenalty?: NumericRange | false;
+  tools?: boolean;
+  toolChoice?: OpenAIToolChoiceOption[];
+  parallelToolCalls?: boolean;
+  responseFormat?: boolean;
+  reasoningEffort?: OpenAIChatEffort[] | false;
+  verbosity?: OpenAIChatVerbosity[] | false;
+  vision?: boolean;
+}
+
+export interface OpenAIProProfile {
+  kind: 'openai_pro';
+  model: string;
+  maxTokensCeiling?: number;
+  temperature?: NumericRange | false;
+  topP?: NumericRange | false;
+  tools?: boolean;
+  toolChoice?: OpenAIToolChoiceOption[];
+  parallelToolCalls?: boolean;
+  reasoningEffort?: OpenAIResponsesEffort[] | false;
+  verbosity?: OpenAIResponsesVerbosity[] | false;
+  vision?: boolean;
+}
+
+export interface GoogleProfile {
+  kind: 'google';
+  model: string;
+  maxTokensCeiling?: number;
+  temperature?: NumericRange | false;
+  topP?: NumericRange | false;
+  topK?: boolean;
+  stopSequences?: boolean;
+  tools?: boolean;
+  functionCallingModes?: GoogleFunctionCallingMode[];
+  thinkingBudget?: NumericRange | false;
+  responseSchema?: boolean;
+  vision?: boolean;
+}
+
+export type ModelProfile = AnthropicProfile | OpenAIGenericProfile | OpenAIProProfile | GoogleProfile;
+
+export type ProfileFindingSeverity = 'error' | 'warning';
+
+export type ProfileFindingCode =
+  | 'wrong_type'
+  | 'not_accepted'
+  | 'below_minimum'
+  | 'above_maximum'
+  | 'above_ceiling'
+  | 'not_in_allowed_set';
+
+export interface ProfileFinding {
+  severity: ProfileFindingSeverity;
+  field: string;
+  code: ProfileFindingCode;
+  detail: string;
+}

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/routing.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import { parseSwitchboardRouter } from './routing.js';
+
+const valid = {
+  user_id: 'eu_123',
+  time: '2026-07-16T00:00:00Z',
+  idempotency_key: 'idem_1',
+  kind: { anthropic: { model: 'claude-sonnet-5', messages: [], max_tokens: 1024 } },
+};
+
+describe('parseSwitchboardRouter', () => {
+  it('parses a valid anthropic router and exposes the envelope', () => {
+    const result = parseSwitchboardRouter(valid);
+    expect(result.kind).toBe('ok');
+    if (result.kind !== 'ok') return;
+    expect(result.envelope.userId).toBe('eu_123');
+    expect(result.envelope.time).toBe('2026-07-16T00:00:00Z');
+    expect(result.envelope.kind).toBe('anthropic');
+    expect(result.envelope.idempotencyKey).toBe('idem_1');
+  });
+
+  it('rejects a missing idempotency_key — every envelope field is required', () => {
+    const { idempotency_key: _omitted, ...withoutKey } = valid;
+    expect(parseSwitchboardRouter(withoutKey)).toMatchObject({ kind: 'reject', field: 'idempotency_key' });
+  });
+
+  it('forwards the native body opaquely, verbatim', () => {
+    const native = {
+      model: 'claude-sonnet-5',
+      messages: [{ role: 'user', content: 'hi' }],
+      max_tokens: 64,
+      system: [{ type: 'text', text: 's', cache_control: { type: 'ephemeral' } }],
+      thinking: { type: 'adaptive', display: 'summarized' },
+      output_config: { effort: 'high' },
+    };
+    const result = parseSwitchboardRouter({ user_id: 'eu', time: '2026-07-16T00:00:00Z', idempotency_key: 'idem_1', kind: { anthropic: native } });
+    expect(result.kind).toBe('ok');
+    if (result.kind !== 'ok') return;
+    expect(result.envelope.request).toBe(native);
+  });
+
+  it('rejects a time that is not a parseable timestamp', () => {
+    expect(parseSwitchboardRouter({ ...valid, time: 'not-a-time' })).toMatchObject({ kind: 'reject', field: 'time' });
+  });
+
+  it('tolerates unknown envelope fields from a newer client (forward-compatible)', () => {
+    const result = parseSwitchboardRouter({ ...valid, some_future_field: true });
+    expect(result.kind).toBe('ok');
+  });
+
+  it('rejects an empty user_id', () => {
+    expect(parseSwitchboardRouter({ ...valid, user_id: '' })).toMatchObject({ kind: 'reject', field: 'user_id' });
+  });
+
+  it('rejects a missing user_id — attribution is always explicit on the envelope', () => {
+    const { user_id: _omitted, ...withoutUser } = valid;
+    expect(parseSwitchboardRouter(withoutUser)).toMatchObject({ kind: 'reject', field: 'user_id' });
+  });
+
+  it('rejects a kind carrying more than one provider tag', () => {
+    expect(parseSwitchboardRouter({ ...valid, kind: { anthropic: {}, google: {} } })).toMatchObject({
+      kind: 'reject',
+      field: 'kind',
+    });
+  });
+
+  it('parses a google router and exposes the envelope', () => {
+    const native = { model: 'gemini-2.5-pro', contents: [{ role: 'user', parts: [{ text: 'hi' }] }] };
+    const result = parseSwitchboardRouter({ ...valid, kind: { google: native } });
+    expect(result.kind).toBe('ok');
+    if (result.kind !== 'ok') return;
+    expect(result.envelope.kind).toBe('google');
+    expect(result.envelope.request).toBe(native);
+  });
+
+  it('rejects an unknown provider tag', () => {
+    expect(parseSwitchboardRouter({ ...valid, kind: { mistral: {} } })).toMatchObject({
+      kind: 'reject',
+      field: 'kind',
+    });
+  });
+});

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/routing.ts

@@ -0,0 +1,74 @@
+import type { AnthropicMessagesRequest } from './anthropic.js';
+import type { GoogleGenerateContentRequest } from './google.js';
+import type { OpenAIChatRequest } from './openaiGeneric.js';
+import type { OpenAIResponsesRequest } from './openaiPro.js';
+
+export type SwitchboardKind = 'anthropic' | 'openai_pro' | 'openai_generic' | 'google';
+
+export interface SwitchboardRouter {
+  user_id: string;
+  time: string;
+  idempotency_key: string;
+  kind: RouterBody;
+}
+
+export type RouterBody =
+  | { anthropic: AnthropicMessagesRequest }
+  | { openai_pro: OpenAIResponsesRequest }
+  | { openai_generic: OpenAIChatRequest }
+  | { google: GoogleGenerateContentRequest };
+
+export interface RouterEnvelope {
+  userId: string;
+  time: string;
+  idempotencyKey: string;
+  kind: SwitchboardKind;
+  request: unknown;
+}
+
+export type RouterParse =
+  | { kind: 'ok'; envelope: RouterEnvelope }
+  | { kind: 'reject'; field: string; expected: string };
+
+const KINDS: readonly SwitchboardKind[] = ['anthropic', 'openai_pro', 'openai_generic', 'google'];
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function parseSwitchboardRouter(body: unknown): RouterParse {
+  if (!isPlainObject(body)) return { kind: 'reject', field: 'body', expected: 'a SwitchboardRouter object' };
+
+  if (typeof body.user_id !== 'string' || body.user_id.length === 0) {
+    return { kind: 'reject', field: 'user_id', expected: 'a non-empty string' };
+  }
+  if (typeof body.time !== 'string' || Number.isNaN(Date.parse(body.time))) {
+    return { kind: 'reject', field: 'time', expected: 'an ISO 8601 timestamp' };
+  }
+  if (typeof body.idempotency_key !== 'string' || body.idempotency_key.length === 0) {
+    return { kind: 'reject', field: 'idempotency_key', expected: 'a non-empty string' };
+  }
+  if (!isPlainObject(body.kind)) {
+    return { kind: 'reject', field: 'kind', expected: 'a single-key tagged native body' };
+  }
+
+  const tags = Object.keys(body.kind);
+  if (tags.length !== 1) {
+    return { kind: 'reject', field: 'kind', expected: 'exactly one provider tag' };
+  }
+  const tag = tags[0];
+  if (!KINDS.includes(tag as SwitchboardKind)) {
+    return { kind: 'reject', field: 'kind', expected: `one of ${KINDS.join(', ')}` };
+  }
+
+  return {
+    kind: 'ok',
+    envelope: {
+      userId: body.user_id,
+      time: body.time,
+      idempotencyKey: body.idempotency_key,
+      kind: tag as SwitchboardKind,
+      request: body.kind[tag],
+    },
+  };
+}

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/validateConfig.google.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from 'vitest';
+import type { GoogleProfile, ProfileFinding } from './profile.js';
+import { validateConfig } from './validateConfig.js';
+
+const richModel: GoogleProfile = {
+  kind: 'google',
+  model: 'test-google-rich',
+  maxTokensCeiling: 65536,
+  temperature: { min: 0, max: 2 },
+  topP: { min: 0, max: 1 },
+  topK: true,
+  stopSequences: true,
+  tools: true,
+  functionCallingModes: ['AUTO', 'ANY', 'NONE'],
+  thinkingBudget: { min: 0, max: 24576 },
+  responseSchema: true,
+  vision: true,
+};
+
+const restrictedModel: GoogleProfile = {
+  kind: 'google',
+  model: 'test-google-restricted',
+  maxTokensCeiling: 1000,
+  temperature: false,
+  topP: false,
+  topK: false,
+  stopSequences: false,
+  tools: false,
+  functionCallingModes: ['AUTO'],
+  thinkingBudget: false,
+  responseSchema: false,
+  vision: false,
+};
+
+const emptyModel: GoogleProfile = { kind: 'google', model: 'test-google-empty' };
+
+const base = { model: 'test-google-rich', contents: [{ role: 'user', parts: [{ text: 'hi' }] }] };
+const MEDIA_CONTENTS = [
+  { role: 'user', parts: [{ inlineData: { mimeType: 'image/png', data: 'aGk=' } }] },
+];
+
+function codesFor(findings: ProfileFinding[], field: string): string[] {
+  return findings.filter(finding => finding.field === field).map(finding => finding.code);
+}
+
+describe('validateConfig google — clean and boundary requests', () => {
+  it('accepts a bare request', () => {
+    expect(validateConfig(richModel, base)).toEqual([]);
+  });
+
+  it('accepts every knob inside the profile', () => {
+    const request = {
+      ...base,
+      contents: MEDIA_CONTENTS,
+      tools: [{ functionDeclarations: [{ name: 't' }] }],
+      toolConfig: { functionCallingConfig: { mode: 'ANY' } },
+      generationConfig: {
+        maxOutputTokens: 65536,
+        temperature: 2,
+        topP: 0,
+        topK: 40,
+        stopSequences: ['stop'],
+        responseSchema: { type: 'object' },
+        thinkingConfig: { thinkingBudget: 24576 },
+      },
+    };
+    expect(validateConfig(richModel, request)).toEqual([]);
+  });
+});
+
+describe('validateConfig google — violations warn', () => {
+  const violationCases: Array<{ label: string; patch: Record<string, unknown>; field: string; code: string }> = [
+    { label: 'maxOutputTokens over ceiling', patch: { generationConfig: { maxOutputTokens: 100000 } }, field: 'generationConfig.maxOutputTokens', code: 'above_ceiling' },
+    { label: 'temperature above maximum', patch: { generationConfig: { temperature: 3 } }, field: 'generationConfig.temperature', code: 'above_maximum' },
+    { label: 'thinkingBudget above maximum', patch: { generationConfig: { thinkingConfig: { thinkingBudget: 99999 } } }, field: 'generationConfig.thinkingConfig.thinkingBudget', code: 'above_maximum' },
+    { label: 'undeclared functionCallingConfig mode', patch: { toolConfig: { functionCallingConfig: { mode: 'MYSTERY' } } }, field: 'toolConfig.functionCallingConfig.mode', code: 'not_in_allowed_set' },
+  ];
+
+  for (const violationCase of violationCases) {
+    it(`${violationCase.label} warns ${violationCase.code}`, () => {
+      const findings = validateConfig(richModel, { ...base, ...violationCase.patch });
+      expect(codesFor(findings, violationCase.field)).toEqual([violationCase.code]);
+    });
+  }
+
+  const rejectedCases: Array<{ label: string; patch: Record<string, unknown>; field: string }> = [
+    { label: 'temperature', patch: { generationConfig: { temperature: 0.5 } }, field: 'generationConfig.temperature' },
+    { label: 'topK', patch: { generationConfig: { topK: 40 } }, field: 'generationConfig.topK' },
+    { label: 'stopSequences', patch: { generationConfig: { stopSequences: ['s'] } }, field: 'generationConfig.stopSequences' },
+    { label: 'responseSchema', patch: { generationConfig: { responseSchema: {} } }, field: 'generationConfig.responseSchema' },
+    { label: 'thinkingBudget', patch: { generationConfig: { thinkingConfig: { thinkingBudget: 1024 } } }, field: 'generationConfig.thinkingConfig.thinkingBudget' },
+    { label: 'tools', patch: { tools: [{ functionDeclarations: [{ name: 't' }] }] }, field: 'tools' },
+    { label: 'media content', patch: { contents: MEDIA_CONTENTS }, field: 'contents' },
+  ];
+
+  for (const rejectedCase of rejectedCases) {
+    it(`${rejectedCase.label} on a restricted model warns not_accepted`, () => {
+      const findings = validateConfig(restrictedModel, { ...base, ...rejectedCase.patch });
+      expect(codesFor(findings, rejectedCase.field)).toEqual(['not_accepted']);
+    });
+  }
+
+  it('undeclared mode on the restricted model warns not_in_allowed_set', () => {
+    const findings = validateConfig(restrictedModel, { ...base, toolConfig: { functionCallingConfig: { mode: 'ANY' } } });
+    expect(codesFor(findings, 'toolConfig.functionCallingConfig.mode')).toEqual(['not_in_allowed_set']);
+  });
+});
+
+describe('validateConfig google — format errors and fail-open', () => {
+  const malformedCases: Array<{ label: string; patch: Record<string, unknown>; field: string }> = [
+    { label: 'non-object generationConfig', patch: { generationConfig: 'hot' }, field: 'generationConfig' },
+    { label: 'non-numeric temperature', patch: { generationConfig: { temperature: 'hot' } }, field: 'generationConfig.temperature' },
+    { label: 'non-object thinkingConfig', patch: { generationConfig: { thinkingConfig: 'deep' } }, field: 'generationConfig.thinkingConfig' },
+    { label: 'non-numeric thinkingBudget', patch: { generationConfig: { thinkingConfig: { thinkingBudget: 'lots' } } }, field: 'generationConfig.thinkingConfig.thinkingBudget' },
+    { label: 'non-object toolConfig', patch: { toolConfig: 'auto' }, field: 'toolConfig' },
+    { label: 'non-string mode', patch: { toolConfig: { functionCallingConfig: { mode: 7 } } }, field: 'toolConfig.functionCallingConfig.mode' },
+  ];
+
+  for (const malformedCase of malformedCases) {
+    it(`${malformedCase.label} errors even on an empty profile`, () => {
+      const findings = validateConfig(emptyModel, { ...base, ...malformedCase.patch });
+      expect(findings).toEqual([
+        expect.objectContaining({ severity: 'error', field: malformedCase.field, code: 'wrong_type' }),
+      ]);
+    });
+  }
+
+  it('an empty profile never warns on extreme values', () => {
+    const request = {
+      ...base,
+      contents: MEDIA_CONTENTS,
+      generationConfig: { maxOutputTokens: 9000000, temperature: 42, thinkingConfig: { thinkingBudget: 999999 } },
+      toolConfig: { functionCallingConfig: { mode: 'MYSTERY' } },
+    };
+    expect(validateConfig(emptyModel, request)).toEqual([]);
+  });
+});

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/validateConfig.openai.test.ts

@@ -0,0 +1,241 @@
+import { describe, it, expect } from 'vitest';
+import type { OpenAIGenericProfile, OpenAIProProfile, ProfileFinding } from './profile.js';
+import { validateConfig } from './validateConfig.js';
+
+const richChatModel: OpenAIGenericProfile = {
+  kind: 'openai_generic',
+  model: 'test-chat-rich',
+  maxTokensCeiling: 32000,
+  temperature: { min: 0, max: 2 },
+  topP: { min: 0, max: 1 },
+  frequencyPenalty: { min: -2, max: 2 },
+  presencePenalty: { min: -2, max: 2 },
+  tools: true,
+  toolChoice: ['auto', 'none', 'required', 'function'],
+  parallelToolCalls: true,
+  responseFormat: true,
+  reasoningEffort: ['low', 'medium', 'high'],
+  verbosity: ['low', 'medium', 'high'],
+  vision: true,
+};
+
+const restrictedChatModel: OpenAIGenericProfile = {
+  kind: 'openai_generic',
+  model: 'test-chat-restricted',
+  maxTokensCeiling: 1000,
+  temperature: false,
+  topP: false,
+  frequencyPenalty: false,
+  presencePenalty: false,
+  tools: false,
+  toolChoice: ['auto'],
+  parallelToolCalls: false,
+  responseFormat: false,
+  reasoningEffort: false,
+  verbosity: false,
+  vision: false,
+};
+
+const emptyChatModel: OpenAIGenericProfile = { kind: 'openai_generic', model: 'test-chat-empty' };
+
+const richProModel: OpenAIProProfile = {
+  kind: 'openai_pro',
+  model: 'test-pro-rich',
+  maxTokensCeiling: 64000,
+  temperature: { min: 0, max: 2 },
+  topP: { min: 0, max: 1 },
+  tools: true,
+  toolChoice: ['auto', 'none', 'required', 'function'],
+  parallelToolCalls: true,
+  reasoningEffort: ['low', 'medium', 'high', 'xhigh'],
+  verbosity: ['low', 'medium', 'high'],
+  vision: true,
+};
+
+const restrictedProModel: OpenAIProProfile = {
+  kind: 'openai_pro',
+  model: 'test-pro-restricted',
+  temperature: false,
+  topP: false,
+  tools: false,
+  toolChoice: ['auto'],
+  parallelToolCalls: false,
+  reasoningEffort: false,
+  verbosity: false,
+  vision: false,
+};
+
+const chatBase = { model: 'test-chat-rich', messages: [{ role: 'user', content: 'hi' }] };
+const proBase = { model: 'test-pro-rich', input: 'hi' };
+
+const IMAGE_CHAT_MESSAGES = [
+  { role: 'user', content: [{ type: 'image_url', image_url: { url: 'https://example.com/i.png' } }] },
+];
+const IMAGE_PRO_INPUT = [
+  { type: 'message', role: 'user', content: [{ type: 'input_image', image_url: 'https://example.com/i.png' }] },
+];
+
+function codesFor(findings: ProfileFinding[], field: string): string[] {
+  return findings.filter(finding => finding.field === field).map(finding => finding.code);
+}
+
+describe('validateConfig openai_generic — clean and boundary requests', () => {
+  it('accepts a bare request', () => {
+    expect(validateConfig(richChatModel, chatBase)).toEqual([]);
+  });
+
+  it('accepts every knob inside the profile', () => {
+    const request = {
+      ...chatBase,
+      max_completion_tokens: 32000,
+      temperature: 2,
+      top_p: 0,
+      frequency_penalty: -2,
+      presence_penalty: 2,
+      tools: [{ type: 'function', function: { name: 't' } }],
+      tool_choice: 'auto',
+      parallel_tool_calls: true,
+      response_format: { type: 'json_object' },
+      reasoning_effort: 'high',
+      verbosity: 'low',
+      messages: IMAGE_CHAT_MESSAGES,
+    };
+    expect(validateConfig(richChatModel, request)).toEqual([]);
+  });
+
+  it('accepts object-form tool_choice naming a function', () => {
+    const request = { ...chatBase, tool_choice: { type: 'function', function: { name: 't' } } };
+    expect(validateConfig(richChatModel, request)).toEqual([]);
+  });
+});
+
+describe('validateConfig openai_generic — violations warn', () => {
+  const violationCases: Array<{ label: string; patch: Record<string, unknown>; field: string; code: string }> = [
+    { label: 'max_completion_tokens over ceiling', patch: { max_completion_tokens: 64000 }, field: 'max_completion_tokens', code: 'above_ceiling' },
+    { label: 'legacy max_tokens over ceiling', patch: { max_tokens: 64000 }, field: 'max_tokens', code: 'above_ceiling' },
+    { label: 'temperature above maximum', patch: { temperature: 3 }, field: 'temperature', code: 'above_maximum' },
+    { label: 'frequency_penalty below minimum', patch: { frequency_penalty: -3 }, field: 'frequency_penalty', code: 'below_minimum' },
+    { label: 'undeclared reasoning_effort', patch: { reasoning_effort: 'xhigh' }, field: 'reasoning_effort', code: 'not_in_allowed_set' },
+    { label: 'undeclared verbosity', patch: { verbosity: 'terse' }, field: 'verbosity', code: 'not_in_allowed_set' },
+  ];
+
+  for (const violationCase of violationCases) {
+    it(`${violationCase.label} warns ${violationCase.code}`, () => {
+      const findings = validateConfig(richChatModel, { ...chatBase, ...violationCase.patch });
+      expect(codesFor(findings, violationCase.field)).toEqual([violationCase.code]);
+      expect(findings.every(finding => finding.severity === 'warning')).toBe(true);
+    });
+  }
+
+  const rejectedCases: Array<{ label: string; patch: Record<string, unknown>; field: string }> = [
+    { label: 'temperature', patch: { temperature: 0.5 }, field: 'temperature' },
+    { label: 'top_p', patch: { top_p: 0.5 }, field: 'top_p' },
+    { label: 'tools', patch: { tools: [{ type: 'function', function: { name: 't' } }] }, field: 'tools' },
+    { label: 'parallel_tool_calls', patch: { parallel_tool_calls: true }, field: 'parallel_tool_calls' },
+    { label: 'response_format', patch: { response_format: { type: 'json_object' } }, field: 'response_format' },
+    { label: 'reasoning_effort', patch: { reasoning_effort: 'high' }, field: 'reasoning_effort' },
+    { label: 'vision', patch: { messages: IMAGE_CHAT_MESSAGES }, field: 'messages' },
+  ];
+
+  for (const rejectedCase of rejectedCases) {
+    it(`${rejectedCase.label} on a restricted model warns not_accepted`, () => {
+      const findings = validateConfig(restrictedChatModel, { ...chatBase, ...rejectedCase.patch });
+      expect(codesFor(findings, rejectedCase.field)).toEqual(['not_accepted']);
+    });
+  }
+
+  it('undeclared tool_choice warns not_in_allowed_set', () => {
+    const findings = validateConfig(restrictedChatModel, { ...chatBase, tool_choice: 'required' });
+    expect(codesFor(findings, 'tool_choice')).toEqual(['not_in_allowed_set']);
+  });
+});
+
+describe('validateConfig openai_generic — format errors and fail-open', () => {
+  const malformedCases: Array<{ label: string; patch: Record<string, unknown>; field: string }> = [
+    { label: 'non-numeric temperature', patch: { temperature: 'hot' }, field: 'temperature' },
+    { label: 'non-boolean parallel_tool_calls', patch: { parallel_tool_calls: 'yes' }, field: 'parallel_tool_calls' },
+    { label: 'non-object response_format', patch: { response_format: 'json' }, field: 'response_format' },
+    { label: 'non-string reasoning_effort', patch: { reasoning_effort: 3 }, field: 'reasoning_effort' },
+    { label: 'numeric tool_choice', patch: { tool_choice: 7 }, field: 'tool_choice' },
+    { label: 'object tool_choice without string type', patch: { tool_choice: { type: 7 } }, field: 'tool_choice.type' },
+  ];
+
+  for (const malformedCase of malformedCases) {
+    it(`${malformedCase.label} errors even on an empty profile`, () => {
+      const findings = validateConfig(emptyChatModel, { ...chatBase, ...malformedCase.patch });
+      expect(findings).toEqual([
+        expect.objectContaining({ severity: 'error', field: malformedCase.field, code: 'wrong_type' }),
+      ]);
+    });
+  }
+
+  it('an empty profile never warns on extreme values', () => {
+    const request = {
+      ...chatBase,
+      max_completion_tokens: 9_000_000,
+      temperature: 42,
+      reasoning_effort: 'nonexistent',
+      tool_choice: 'mystery',
+      messages: IMAGE_CHAT_MESSAGES,
+    };
+    expect(validateConfig(emptyChatModel, request)).toEqual([]);
+  });
+});
+
+describe('validateConfig openai_pro', () => {
+  it('accepts every knob inside the profile', () => {
+    const request = {
+      ...proBase,
+      max_output_tokens: 64000,
+      temperature: 0,
+      top_p: 1,
+      tools: [{ type: 'function', name: 't' }],
+      tool_choice: { type: 'function', name: 't' },
+      parallel_tool_calls: true,
+      reasoning: { effort: 'xhigh' },
+      text: { verbosity: 'high' },
+      input: IMAGE_PRO_INPUT,
+    };
+    expect(validateConfig(richProModel, request)).toEqual([]);
+  });
+
+  it('warns above the max_output_tokens ceiling', () => {
+    const findings = validateConfig(richProModel, { ...proBase, max_output_tokens: 128000 });
+    expect(codesFor(findings, 'max_output_tokens')).toEqual(['above_ceiling']);
+  });
+
+  it('warns on an undeclared nested reasoning effort', () => {
+    const findings = validateConfig(richProModel, { ...proBase, reasoning: { effort: 'max' } });
+    expect(codesFor(findings, 'reasoning.effort')).toEqual(['not_in_allowed_set']);
+  });
+
+  it('warns not_accepted on nested effort for a restricted model', () => {
+    const findings = validateConfig(restrictedProModel, { ...proBase, reasoning: { effort: 'high' } });
+    expect(codesFor(findings, 'reasoning.effort')).toEqual(['not_accepted']);
+  });
+
+  it('warns not_accepted on image input for a model without vision', () => {
+    const findings = validateConfig(restrictedProModel, { ...proBase, input: IMAGE_PRO_INPUT });
+    expect(codesFor(findings, 'input')).toEqual(['not_accepted']);
+  });
+
+  it('errors on a non-object reasoning', () => {
+    const findings = validateConfig(richProModel, { ...proBase, reasoning: 'hard' });
+    expect(findings).toEqual([
+      expect.objectContaining({ severity: 'error', field: 'reasoning', code: 'wrong_type' }),
+    ]);
+  });
+
+  it('errors on a non-string nested verbosity', () => {
+    const findings = validateConfig(richProModel, { ...proBase, text: { verbosity: 3 } });
+    expect(findings).toEqual([
+      expect.objectContaining({ severity: 'error', field: 'text.verbosity', code: 'wrong_type' }),
+    ]);
+  });
+
+  it('rejects a non-object request', () => {
+    expect(validateConfig(richProModel, 'not an object')).toEqual([
+      expect.objectContaining({ severity: 'error', field: 'request', code: 'wrong_type' }),
+    ]);
+  });
+});