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

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

@@ -0,0 +1,174 @@
+import { describe, it, expect } from 'vitest';
+import type { AnthropicProfile, ProfileFinding } from './profile.js';
+import { validateConfig } from './validateConfig.js';
+
+const richModel: AnthropicProfile = {
+  kind: 'anthropic',
+  model: 'test-rich',
+  maxTokensCeiling: 64000,
+  temperature: { min: 0, max: 1 },
+  topP: { min: 0, max: 1 },
+  topK: true,
+  stopSequences: true,
+  tools: true,
+  toolChoice: ['auto', 'any', 'none', 'tool'],
+  thinking: { modes: ['adaptive', 'enabled', 'disabled'], budgetTokens: { min: 1024, max: 32000 } },
+  effort: ['low', 'medium', 'high'],
+  vision: true,
+};
+
+const reasoningModel: AnthropicProfile = {
+  kind: 'anthropic',
+  model: 'test-reasoning',
+  maxTokensCeiling: 32000,
+  temperature: false,
+  thinking: false,
+  effort: false,
+  vision: false,
+};
+
+const unknownModel: AnthropicProfile = {
+  kind: 'anthropic',
+  model: 'test-unknown',
+};
+
+const baseRequest = {
+  model: 'test-rich',
+  messages: [{ role: 'user', content: 'hi' }],
+  max_tokens: 1024,
+};
+
+function codesFor(findings: ProfileFinding[], field: string): string[] {
+  return findings.filter(finding => finding.field === field).map(finding => finding.code);
+}
+
+describe('validateConfig — clean requests produce no findings', () => {
+  it('accepts a request that only sets required fields', () => {
+    expect(validateConfig(richModel, baseRequest)).toEqual([]);
+  });
+
+  it('accepts every knob set to a value inside the profile', () => {
+    const request = {
+      ...baseRequest,
+      max_tokens: 64000,
+      temperature: 1,
+      top_p: 0,
+      top_k: 40,
+      stop_sequences: ['stop'],
+      tools: [{ name: 't', input_schema: {} }],
+      tool_choice: { type: 'tool', name: 't' },
+      thinking: { type: 'enabled', budget_tokens: 32000 },
+      output_config: { effort: 'high' },
+    };
+    expect(validateConfig(richModel, request)).toEqual([]);
+  });
+});
+
+describe('validateConfig — every accepted knob at its boundary stays clean', () => {
+  const boundaryCases: Array<{ label: string; patch: Record<string, unknown> }> = [
+    { label: 'max_tokens at ceiling', patch: { max_tokens: 64000 } },
+    { label: 'temperature at min', patch: { temperature: 0 } },
+    { label: 'temperature at max', patch: { temperature: 1 } },
+    { label: 'top_p at min', patch: { top_p: 0 } },
+    { label: 'top_p at max', patch: { top_p: 1 } },
+    { label: 'thinking budget at min', patch: { thinking: { type: 'enabled', budget_tokens: 1024 } } },
+    { label: 'thinking budget at max', patch: { thinking: { type: 'enabled', budget_tokens: 32000 } } },
+    { label: 'effort lowest allowed', patch: { output_config: { effort: 'low' } } },
+    { label: 'effort highest allowed', patch: { output_config: { effort: 'high' } } },
+  ];
+
+  for (const boundaryCase of boundaryCases) {
+    it(`${boundaryCase.label} produces no finding`, () => {
+      expect(validateConfig(richModel, { ...baseRequest, ...boundaryCase.patch })).toEqual([]);
+    });
+  }
+});
+
+describe('validateConfig — every out-of-bounds value warns with the right code', () => {
+  const violationCases: Array<{ label: string; patch: Record<string, unknown>; field: string; code: string }> = [
+    { label: 'max_tokens over ceiling', patch: { max_tokens: 200000 }, field: 'max_tokens', code: 'above_ceiling' },
+    { label: 'temperature over max', patch: { temperature: 2 }, field: 'temperature', code: 'above_maximum' },
+    { label: 'temperature under min', patch: { temperature: -1 }, field: 'temperature', code: 'below_minimum' },
+    { label: 'top_p over max', patch: { top_p: 5 }, field: 'top_p', code: 'above_maximum' },
+    { label: 'thinking budget over max', patch: { thinking: { type: 'enabled', budget_tokens: 99999 } }, field: 'thinking.budget_tokens', code: 'above_maximum' },
+    { label: 'thinking budget under min', patch: { thinking: { type: 'enabled', budget_tokens: 1 } }, field: 'thinking.budget_tokens', code: 'below_minimum' },
+    { label: 'thinking mode not allowed', patch: { thinking: { type: 'mystery' } }, field: 'thinking.type', code: 'not_in_allowed_set' },
+    { label: 'effort not in allowed set', patch: { output_config: { effort: 'max' } }, field: 'output_config.effort', code: 'not_in_allowed_set' },
+    { label: 'tool_choice not in allowed set', patch: { tool_choice: { type: 'mystery' } }, field: 'tool_choice.type', code: 'not_in_allowed_set' },
+  ];
+
+  for (const violationCase of violationCases) {
+    it(`${violationCase.label} warns ${violationCase.code}`, () => {
+      const findings = validateConfig(richModel, { ...baseRequest, ...violationCase.patch });
+      expect(codesFor(findings, violationCase.field)).toEqual([violationCase.code]);
+      expect(findings.every(finding => finding.severity === 'warning')).toBe(true);
+    });
+  }
+});
+
+describe('validateConfig — a knob the model rejects warns not_accepted', () => {
+  const rejectedCases: Array<{ label: string; patch: Record<string, unknown>; field: string }> = [
+    { label: 'temperature', patch: { temperature: 0.5 }, field: 'temperature' },
+    { label: 'thinking', patch: { thinking: { type: 'enabled', budget_tokens: 2048 } }, field: 'thinking' },
+    { label: 'effort', patch: { output_config: { effort: 'high' } }, field: 'output_config.effort' },
+    { label: 'vision', patch: { messages: [{ role: 'user', content: [{ type: 'image', source: { type: 'url', url: 'x' } }] }] }, field: 'messages' },
+  ];
+
+  for (const rejectedCase of rejectedCases) {
+    it(`${rejectedCase.label} on a reasoning model warns not_accepted`, () => {
+      const findings = validateConfig(reasoningModel, { ...baseRequest, ...rejectedCase.patch });
+      expect(codesFor(findings, rejectedCase.field)).toEqual(['not_accepted']);
+      expect(findings[0].severity).toBe('warning');
+    });
+  }
+});
+
+describe('validateConfig — fail open when the profile is silent', () => {
+  it('never warns about a knob the profile does not describe', () => {
+    const request = {
+      ...baseRequest,
+      max_tokens: 9_000_000,
+      temperature: 42,
+      top_k: 1000,
+      thinking: { type: 'anything', budget_tokens: 5 },
+      output_config: { effort: 'nonexistent' },
+    };
+    expect(validateConfig(unknownModel, request)).toEqual([]);
+  });
+});
+
+describe('validateConfig — malformed native fields are format errors', () => {
+  const malformedCases: Array<{ label: string; patch: Record<string, unknown>; field: string }> = [
+    { label: 'non-numeric temperature', patch: { temperature: 'hot' }, field: 'temperature' },
+    { label: 'non-object thinking', patch: { thinking: 'deep' }, field: 'thinking' },
+    { label: 'non-string thinking.type', patch: { thinking: { type: 123 } }, field: 'thinking.type' },
+    { label: 'non-numeric thinking.budget_tokens', patch: { thinking: { type: 'enabled', budget_tokens: 'lots' } }, field: 'thinking.budget_tokens' },
+    { label: 'non-object output_config', patch: { output_config: 'high' }, field: 'output_config' },
+    { label: 'non-string effort', patch: { output_config: { effort: 3 } }, field: 'output_config.effort' },
+    { label: 'non-object tool_choice', patch: { tool_choice: 'auto' }, field: 'tool_choice' },
+    { label: 'non-string tool_choice.type', patch: { tool_choice: { type: 7 } }, field: 'tool_choice.type' },
+  ];
+
+  for (const malformedCase of malformedCases) {
+    it(`flags ${malformedCase.label} as an error`, () => {
+      const findings = validateConfig(richModel, { ...baseRequest, ...malformedCase.patch });
+      expect(findings).toEqual([
+        expect.objectContaining({ severity: 'error', field: malformedCase.field, code: 'wrong_type' }),
+      ]);
+    });
+
+    it(`flags ${malformedCase.label} as an error even when the profile is silent`, () => {
+      const findings = validateConfig(unknownModel, { ...baseRequest, ...malformedCase.patch });
+      expect(findings).toEqual([
+        expect.objectContaining({ severity: 'error', field: malformedCase.field, code: 'wrong_type' }),
+      ]);
+    });
+  }
+
+  it('flags a non-object request as an error', () => {
+    const findings = validateConfig(richModel, 'not an object');
+    expect(findings).toEqual([
+      { severity: 'error', field: 'request', code: 'wrong_type', detail: 'request must be an object' },
+    ]);
+  });
+});

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

@@ -0,0 +1,438 @@
+import type { AnthropicEffort, AnthropicThinking, AnthropicToolChoice } from './anthropic.js';
+import type {
+  AnthropicProfile,
+  AnthropicThinkingProfile,
+  GoogleProfile,
+  ModelProfile,
+  NumericRange,
+  OpenAIGenericProfile,
+  OpenAIProProfile,
+  OpenAIToolChoiceOption,
+  ProfileFinding,
+} from './profile.js';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readNumber(findings: ProfileFinding[], request: Record<string, unknown>, field: string, label: string = field): number | undefined {
+  const raw = request[field];
+  if (raw === undefined) return undefined;
+  if (typeof raw !== 'number') {
+    findings.push({ severity: 'error', field: label, code: 'wrong_type', detail: `${label} must be a number` });
+    return undefined;
+  }
+  return raw;
+}
+
+function checkRange(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  field: string,
+  rule: NumericRange | false | undefined,
+  label: string = field,
+): void {
+  const value = readNumber(findings, request, field, label);
+  if (value === undefined || rule === undefined) return;
+  if (rule === false) {
+    findings.push({ severity: 'warning', field: label, code: 'not_accepted', detail: `${label} is not accepted by this model` });
+    return;
+  }
+  if (rule.min !== undefined && value < rule.min) {
+    findings.push({ severity: 'warning', field: label, code: 'below_minimum', detail: `${label} ${value} is below the accepted minimum ${rule.min}` });
+  }
+  if (rule.max !== undefined && value > rule.max) {
+    findings.push({ severity: 'warning', field: label, code: 'above_maximum', detail: `${label} ${value} is above the accepted maximum ${rule.max}` });
+  }
+}
+
+function checkCeiling(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  field: string,
+  ceiling: number | undefined,
+  label: string = field,
+): void {
+  const value = readNumber(findings, request, field, label);
+  if (value === undefined || ceiling === undefined) return;
+  if (value > ceiling) {
+    findings.push({ severity: 'warning', field: label, code: 'above_ceiling', detail: `${label} ${value} exceeds this model's ceiling ${ceiling}` });
+  }
+}
+
+function checkAccepted(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  field: string,
+  accepted: boolean | undefined,
+  label: string = field,
+): void {
+  if (accepted !== false) return;
+  if (request[field] === undefined) return;
+  findings.push({ severity: 'warning', field: label, code: 'not_accepted', detail: `${label} is not accepted by this model` });
+}
+
+function checkEffort(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  allowed: AnthropicEffort[] | false | undefined,
+): void {
+  const outputConfig = request.output_config;
+  if (outputConfig === undefined) return;
+  if (!isRecord(outputConfig)) {
+    findings.push({ severity: 'error', field: 'output_config', code: 'wrong_type', detail: 'output_config must be an object' });
+    return;
+  }
+  const effort = outputConfig.effort;
+  if (effort === undefined) return;
+  if (typeof effort !== 'string') {
+    findings.push({ severity: 'error', field: 'output_config.effort', code: 'wrong_type', detail: 'effort must be a string' });
+    return;
+  }
+  if (allowed === undefined) return;
+  if (allowed === false) {
+    findings.push({ severity: 'warning', field: 'output_config.effort', code: 'not_accepted', detail: 'effort is not accepted by this model' });
+    return;
+  }
+  if (!allowed.includes(effort as AnthropicEffort)) {
+    findings.push({ severity: 'warning', field: 'output_config.effort', code: 'not_in_allowed_set', detail: `effort '${effort}' is not one of ${allowed.join(', ')}` });
+  }
+}
+
+function checkThinking(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  rule: AnthropicThinkingProfile | false | undefined,
+): void {
+  const thinking = request.thinking;
+  if (thinking === undefined) return;
+  if (!isRecord(thinking)) {
+    findings.push({ severity: 'error', field: 'thinking', code: 'wrong_type', detail: 'thinking must be an object' });
+    return;
+  }
+  const mode = thinking.type;
+  if (typeof mode !== 'string') {
+    findings.push({ severity: 'error', field: 'thinking.type', code: 'wrong_type', detail: 'thinking.type must be a string' });
+    return;
+  }
+  const budget = thinking.budget_tokens;
+  if (budget !== undefined && typeof budget !== 'number') {
+    findings.push({ severity: 'error', field: 'thinking.budget_tokens', code: 'wrong_type', detail: 'thinking.budget_tokens must be a number' });
+    return;
+  }
+  if (rule === undefined) return;
+  if (rule === false) {
+    findings.push({ severity: 'warning', field: 'thinking', code: 'not_accepted', detail: 'thinking is not accepted by this model' });
+    return;
+  }
+  if (!rule.modes.includes(mode as AnthropicThinking['type'])) {
+    findings.push({ severity: 'warning', field: 'thinking.type', code: 'not_in_allowed_set', detail: `thinking mode '${mode}' is not one of ${rule.modes.join(', ')}` });
+  }
+  if (rule.budgetTokens !== undefined && typeof budget === 'number') {
+    if (rule.budgetTokens.min !== undefined && budget < rule.budgetTokens.min) {
+      findings.push({ severity: 'warning', field: 'thinking.budget_tokens', code: 'below_minimum', detail: `budget_tokens ${budget} is below the accepted minimum ${rule.budgetTokens.min}` });
+    }
+    if (rule.budgetTokens.max !== undefined && budget > rule.budgetTokens.max) {
+      findings.push({ severity: 'warning', field: 'thinking.budget_tokens', code: 'above_maximum', detail: `budget_tokens ${budget} is above the accepted maximum ${rule.budgetTokens.max}` });
+    }
+  }
+}
+
+function checkToolChoice(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  allowed: AnthropicToolChoice['type'][] | undefined,
+): void {
+  const toolChoice = request.tool_choice;
+  if (toolChoice === undefined) return;
+  if (!isRecord(toolChoice)) {
+    findings.push({ severity: 'error', field: 'tool_choice', code: 'wrong_type', detail: 'tool_choice must be an object' });
+    return;
+  }
+  const choiceType = toolChoice.type;
+  if (typeof choiceType !== 'string') {
+    findings.push({ severity: 'error', field: 'tool_choice.type', code: 'wrong_type', detail: 'tool_choice.type must be a string' });
+    return;
+  }
+  if (allowed === undefined) return;
+  if (!allowed.includes(choiceType as AnthropicToolChoice['type'])) {
+    findings.push({ severity: 'warning', field: 'tool_choice.type', code: 'not_in_allowed_set', detail: `tool_choice '${choiceType}' is not one of ${allowed.join(', ')}` });
+  }
+}
+
+function checkVision(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  vision: boolean | undefined,
+): void {
+  if (vision !== false) return;
+  const messages = request.messages;
+  if (!Array.isArray(messages)) return;
+  const hasImage = messages.some(message =>
+    isRecord(message) &&
+    Array.isArray(message.content) &&
+    message.content.some(block => isRecord(block) && block.type === 'image'),
+  );
+  if (hasImage) {
+    findings.push({ severity: 'warning', field: 'messages', code: 'not_accepted', detail: 'this model does not accept image content blocks' });
+  }
+}
+
+function checkStringEnum(
+  findings: ProfileFinding[],
+  field: string,
+  raw: unknown,
+  allowed: readonly string[] | false | undefined,
+): void {
+  if (raw === undefined) return;
+  if (typeof raw !== 'string') {
+    findings.push({ severity: 'error', field, code: 'wrong_type', detail: `${field} must be a string` });
+    return;
+  }
+  if (allowed === undefined) return;
+  if (allowed === false) {
+    findings.push({ severity: 'warning', field, code: 'not_accepted', detail: `${field} is not accepted by this model` });
+    return;
+  }
+  if (!allowed.includes(raw)) {
+    findings.push({ severity: 'warning', field, code: 'not_in_allowed_set', detail: `${field} '${raw}' is not one of ${allowed.join(', ')}` });
+  }
+}
+
+function checkBooleanField(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  field: string,
+  accepted: boolean | undefined,
+): void {
+  const raw = request[field];
+  if (raw === undefined) return;
+  if (typeof raw !== 'boolean') {
+    findings.push({ severity: 'error', field, code: 'wrong_type', detail: `${field} must be a boolean` });
+    return;
+  }
+  if (accepted === false) {
+    findings.push({ severity: 'warning', field, code: 'not_accepted', detail: `${field} is not accepted by this model` });
+  }
+}
+
+function checkObjectField(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  field: string,
+  accepted: boolean | undefined,
+): void {
+  const raw = request[field];
+  if (raw === undefined) return;
+  if (!isRecord(raw)) {
+    findings.push({ severity: 'error', field, code: 'wrong_type', detail: `${field} must be an object` });
+    return;
+  }
+  if (accepted === false) {
+    findings.push({ severity: 'warning', field, code: 'not_accepted', detail: `${field} is not accepted by this model` });
+  }
+}
+
+function checkOpenAIToolChoice(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  allowed: OpenAIToolChoiceOption[] | undefined,
+): void {
+  const toolChoice = request.tool_choice;
+  if (toolChoice === undefined) return;
+  if (typeof toolChoice !== 'string' && !isRecord(toolChoice)) {
+    findings.push({ severity: 'error', field: 'tool_choice', code: 'wrong_type', detail: 'tool_choice must be a string or an object' });
+    return;
+  }
+  let choice: string;
+  if (typeof toolChoice === 'string') {
+    choice = toolChoice;
+  } else {
+    const choiceType = toolChoice.type;
+    if (typeof choiceType !== 'string') {
+      findings.push({ severity: 'error', field: 'tool_choice.type', code: 'wrong_type', detail: 'tool_choice.type must be a string' });
+      return;
+    }
+    choice = choiceType;
+  }
+  if (allowed === undefined) return;
+  if (!allowed.includes(choice as OpenAIToolChoiceOption)) {
+    findings.push({ severity: 'warning', field: 'tool_choice', code: 'not_in_allowed_set', detail: `tool_choice '${choice}' is not one of ${allowed.join(', ')}` });
+  }
+}
+
+function contentHasPartType(content: unknown, partType: string): boolean {
+  return Array.isArray(content) && content.some(part => isRecord(part) && part.type === partType);
+}
+
+function checkOpenAIChatVision(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  vision: boolean | undefined,
+): void {
+  if (vision !== false) return;
+  const messages = request.messages;
+  if (!Array.isArray(messages)) return;
+  const hasImage = messages.some(message => isRecord(message) && contentHasPartType(message.content, 'image_url'));
+  if (hasImage) {
+    findings.push({ severity: 'warning', field: 'messages', code: 'not_accepted', detail: 'this model does not accept image content parts' });
+  }
+}
+
+function checkOpenAIResponsesVision(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  vision: boolean | undefined,
+): void {
+  if (vision !== false) return;
+  const input = request.input;
+  if (!Array.isArray(input)) return;
+  const hasImage = input.some(item =>
+    isRecord(item) && item.type === 'message' && contentHasPartType(item.content, 'input_image'),
+  );
+  if (hasImage) {
+    findings.push({ severity: 'warning', field: 'input', code: 'not_accepted', detail: 'this model does not accept image content parts' });
+  }
+}
+
+function readNestedObject(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  field: string,
+  label: string = field,
+): Record<string, unknown> | undefined {
+  const raw = request[field];
+  if (raw === undefined) return undefined;
+  if (!isRecord(raw)) {
+    findings.push({ severity: 'error', field: label, code: 'wrong_type', detail: `${label} must be an object` });
+    return undefined;
+  }
+  return raw;
+}
+
+function validateAnthropic(profile: AnthropicProfile, request: Record<string, unknown>): ProfileFinding[] {
+  const findings: ProfileFinding[] = [];
+  checkCeiling(findings, request, 'max_tokens', profile.maxTokensCeiling);
+  checkRange(findings, request, 'temperature', profile.temperature);
+  checkRange(findings, request, 'top_p', profile.topP);
+  checkAccepted(findings, request, 'top_k', profile.topK);
+  checkAccepted(findings, request, 'stop_sequences', profile.stopSequences);
+  checkAccepted(findings, request, 'tools', profile.tools);
+  checkToolChoice(findings, request, profile.toolChoice);
+  checkThinking(findings, request, profile.thinking);
+  checkEffort(findings, request, profile.effort);
+  checkVision(findings, request, profile.vision);
+  return findings;
+}
+
+function validateOpenAIGeneric(profile: OpenAIGenericProfile, request: Record<string, unknown>): ProfileFinding[] {
+  const findings: ProfileFinding[] = [];
+  checkCeiling(findings, request, 'max_completion_tokens', profile.maxTokensCeiling);
+  checkCeiling(findings, request, 'max_tokens', profile.maxTokensCeiling);
+  checkRange(findings, request, 'temperature', profile.temperature);
+  checkRange(findings, request, 'top_p', profile.topP);
+  checkRange(findings, request, 'frequency_penalty', profile.frequencyPenalty);
+  checkRange(findings, request, 'presence_penalty', profile.presencePenalty);
+  checkAccepted(findings, request, 'tools', profile.tools);
+  checkOpenAIToolChoice(findings, request, profile.toolChoice);
+  checkBooleanField(findings, request, 'parallel_tool_calls', profile.parallelToolCalls);
+  checkObjectField(findings, request, 'response_format', profile.responseFormat);
+  checkStringEnum(findings, 'reasoning_effort', request.reasoning_effort, profile.reasoningEffort);
+  checkStringEnum(findings, 'verbosity', request.verbosity, profile.verbosity);
+  checkOpenAIChatVision(findings, request, profile.vision);
+  return findings;
+}
+
+function validateOpenAIPro(profile: OpenAIProProfile, request: Record<string, unknown>): ProfileFinding[] {
+  const findings: ProfileFinding[] = [];
+  checkCeiling(findings, request, 'max_output_tokens', profile.maxTokensCeiling);
+  checkRange(findings, request, 'temperature', profile.temperature);
+  checkRange(findings, request, 'top_p', profile.topP);
+  checkAccepted(findings, request, 'tools', profile.tools);
+  checkOpenAIToolChoice(findings, request, profile.toolChoice);
+  checkBooleanField(findings, request, 'parallel_tool_calls', profile.parallelToolCalls);
+  const reasoning = readNestedObject(findings, request, 'reasoning');
+  if (reasoning !== undefined) {
+    checkStringEnum(findings, 'reasoning.effort', reasoning.effort, profile.reasoningEffort);
+  }
+  const text = readNestedObject(findings, request, 'text');
+  if (text !== undefined) {
+    checkStringEnum(findings, 'text.verbosity', text.verbosity, profile.verbosity);
+  }
+  checkOpenAIResponsesVision(findings, request, profile.vision);
+  return findings;
+}
+
+function partsContainMedia(parts: unknown): boolean {
+  return Array.isArray(parts) && parts.some(part =>
+    isRecord(part) && (part.inlineData !== undefined || part.fileData !== undefined),
+  );
+}
+
+function checkGoogleVision(
+  findings: ProfileFinding[],
+  request: Record<string, unknown>,
+  vision: boolean | undefined,
+): void {
+  if (vision !== false) return;
+  const contents = request.contents;
+  if (!Array.isArray(contents)) return;
+  const hasMedia = contents.some(content => isRecord(content) && partsContainMedia(content.parts));
+  if (hasMedia) {
+    findings.push({ severity: 'warning', field: 'contents', code: 'not_accepted', detail: 'this model does not accept media parts' });
+  }
+}
+
+function validateGoogle(profile: GoogleProfile, request: Record<string, unknown>): ProfileFinding[] {
+  const findings: ProfileFinding[] = [];
+  const generationConfig = readNestedObject(findings, request, 'generationConfig');
+  if (generationConfig !== undefined) {
+    checkCeiling(findings, generationConfig, 'maxOutputTokens', profile.maxTokensCeiling, 'generationConfig.maxOutputTokens');
+    checkRange(findings, generationConfig, 'temperature', profile.temperature, 'generationConfig.temperature');
+    checkRange(findings, generationConfig, 'topP', profile.topP, 'generationConfig.topP');
+    checkAccepted(findings, generationConfig, 'topK', profile.topK, 'generationConfig.topK');
+    checkAccepted(findings, generationConfig, 'stopSequences', profile.stopSequences, 'generationConfig.stopSequences');
+    if (generationConfig.responseSchema !== undefined && profile.responseSchema === false) {
+      findings.push({ severity: 'warning', field: 'generationConfig.responseSchema', code: 'not_accepted', detail: 'responseSchema is not accepted by this model' });
+    }
+    const thinkingConfig = generationConfig.thinkingConfig;
+    if (thinkingConfig !== undefined) {
+      if (!isRecord(thinkingConfig)) {
+        findings.push({ severity: 'error', field: 'generationConfig.thinkingConfig', code: 'wrong_type', detail: 'generationConfig.thinkingConfig must be an object' });
+      } else {
+        checkRange(findings, thinkingConfig, 'thinkingBudget', profile.thinkingBudget, 'generationConfig.thinkingConfig.thinkingBudget');
+      }
+    }
+  }
+  checkAccepted(findings, request, 'tools', profile.tools);
+  const toolConfig = readNestedObject(findings, request, 'toolConfig');
+  if (toolConfig !== undefined) {
+    const functionCallingConfig = readNestedObject(findings, toolConfig, 'functionCallingConfig', 'toolConfig.functionCallingConfig');
+    if (functionCallingConfig !== undefined) {
+      checkStringEnum(findings, 'toolConfig.functionCallingConfig.mode', functionCallingConfig.mode, profile.functionCallingModes);
+    }
+  }
+  checkGoogleVision(findings, request, profile.vision);
+  return findings;
+}
+
+export function validateConfig(profile: ModelProfile, request: unknown): ProfileFinding[] {
+  if (!isRecord(request)) {
+    return [{ severity: 'error', field: 'request', code: 'wrong_type', detail: 'request must be an object' }];
+  }
+  switch (profile.kind) {
+    case 'anthropic':
+      return validateAnthropic(profile, request);
+    case 'openai_generic':
+      return validateOpenAIGeneric(profile, request);
+    case 'openai_pro':
+      return validateOpenAIPro(profile, request);
+    case 'google':
+      return validateGoogle(profile, request);
+    default: {
+      const exhaustive: never = profile;
+      void exhaustive;
+      return [];
+    }
+  }
+}

package/runtime/extensions/switchboard-local/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "switchboard-local",
+	"version": "0.2.0",
+	"type": "module",
+	"description": "Local models in the pi model picker, managed end to end",
+	"keywords": [
+		"pi-package"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Valni-Labs/switchboard-local"
+	},
+	"license": "MIT",
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"scripts": {
+		"test": "npm run typecheck && node --test \"extensions/local/tests/*.test.ts\"",
+		"typecheck": "tsc --noEmit"
+	},
+	"pi": {
+		"extensions": [
+			"./extensions"
+		]
+	},
+	"dependencies": {
+		"@valni/switchboard": "git+https://github.com/Valni-Labs/switchboard-ts.git#d132540a1fd86491ffabb9327ec38bb903f709a3"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "0.82.1",
+		"@earendil-works/pi-coding-agent": "0.82.1",
+		"typescript": "5.9.3"
+	}
+}

package/runtime/extensions/switchboard-local/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"target": "es2023",
+		"module": "nodenext",
+		"moduleResolution": "nodenext",
+		"allowImportingTsExtensions": true,
+		"noEmit": true,
+		"strict": true,
+		"skipLibCheck": true,
+		"types": ["node"]
+	},
+	"include": ["extensions/**/*.ts"]
+}