@shipfox/api-agent-dto 2.0.0

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@shipfox/api-agent-dto",
+  "license": "MIT",
+  "version": "2.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
+    "directory": "libs/api/agent-dto"
+  },
+  "private": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "imports": {
+    "#test/*": "./test/*",
+    "#*": {
+      "workspace-source": "./src/*",
+      "development": "./src/*",
+      "default": "./dist/*"
+    }
+  },
+  "exports": {
+    ".": {
+      "development": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "dependencies": {
+    "zod": "^4.4.3",
+    "@shipfox/workflow-document": "2.0.1"
+  },
+  "devDependencies": {
+    "@shipfox/biome": "1.8.1",
+    "@shipfox/depcruise": "1.0.1",
+    "@shipfox/swc": "1.2.5",
+    "@shipfox/typescript": "1.1.6",
+    "@shipfox/vitest": "1.2.2",
+    "@shipfox/ts-config": "1.3.8"
+  },
+  "scripts": {
+    "build": "shipfox-swc",
+    "check": "shipfox-biome-check",
+    "check:fix": "shipfox-biome-check --write",
+    "depcruise": "shipfox-depcruise",
+    "test": "shipfox-vitest-run",
+    "test:watch": "shipfox-vitest-watch",
+    "type": "shipfox-tsc-check",
+    "type:emit": "shipfox-tsc-emit"
+  }
+}

package/src/index.ts

@@ -0,0 +1,122 @@
+export {
+  AGENT_INTEGRATION_MCP_AUTH,
+  AGENT_INTEGRATION_MCP_ENDPOINT,
+  AGENT_INTEGRATION_MCP_SERVER_NAME,
+  AGENT_INTEGRATION_MCP_TRANSPORT,
+  type AgentIntegrationMcpServerConfigDto,
+  type AgentModelOptionDto,
+  type AgentRuntimeCredentialsResponseDto,
+  type AgentThinking,
+  agentIntegrationMcpServerSchema,
+  agentModelOptionSchema,
+  agentRuntimeCredentialsResponseSchema,
+  agentThinkingByHarness,
+  agentThinkingSchema,
+  buildHarnessToolDeploymentConfig,
+  CLAUDE_HARNESS,
+  type CreateCustomModelProviderBodyDto,
+  type CustomAgentModelDto,
+  type CustomModelProviderConfigDto,
+  type CustomModelProviderHeaderDto,
+  type CustomModelProviderHeaderRequestDto,
+  type CustomModelProviderRuntimeConfigDto,
+  claudeAgentThinkingSchema,
+  createCustomModelProviderBodySchema,
+  customAgentModelSchema,
+  customModelProviderConfigDtoSchema,
+  customModelProviderHeaderDtoSchema,
+  customModelProviderHeaderRequestSchema,
+  customModelProviderRuntimeConfigSchema,
+  DEFAULT_AGENT_THINKING,
+  DEFAULT_CUSTOM_MODEL_CONTEXT_WINDOW,
+  DEFAULT_CUSTOM_MODEL_INPUT_IMAGE,
+  DEFAULT_CUSTOM_MODEL_MAX_OUTPUT_TOKENS,
+  DEFAULT_CUSTOM_MODEL_REASONING,
+  DEFAULT_HARNESS,
+  DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG,
+  DEFAULT_MODEL_PROVIDER,
+  DEFAULT_PI_ENABLED_TOOL_PACKAGES,
+  DEFAULT_PI_WEB_SEARCH_ENABLED,
+  type DiscoverCustomModelProviderModelsBodyDto,
+  type DiscoverCustomModelProviderModelsBySlugBodyDto,
+  type DiscoverCustomModelProviderModelsResponseDto,
+  discoverCustomModelProviderModelsBodySchema,
+  discoverCustomModelProviderModelsBySlugBodySchema,
+  discoverCustomModelProviderModelsResponseSchema,
+  getHarnessDescriptor,
+  getHarnessToolDescriptor,
+  getModelProviderCredentialKeys,
+  getModelProviderEntry,
+  HARNESS_TOOL_PACKAGE_NAMES,
+  type Harness,
+  type HarnessDescriptor,
+  type HarnessToolDeploymentConfig,
+  type HarnessToolDescriptor,
+  type HarnessToolPackageName,
+  harnessSchema,
+  harnessSupportsProvider,
+  harnessSupportsTool,
+  isReservedModelProviderId,
+  type ListModelProviderConfigsResponseDto,
+  listEnabledHarnessTools,
+  listHarnessDescriptors,
+  listHarnessTools,
+  listModelProviderConfigsResponseSchema,
+  listSupportedModelProviders,
+  MAX_MODEL_COUNT,
+  type MaterializedAgentIntegrationConfigDto,
+  type MaterializedAgentIntegrationToolConfigDto,
+  type MaterializedAgentStepConfigDto,
+  MODEL_PROVIDER_CATALOG_SEED,
+  MODEL_PROVIDER_IDS,
+  MODEL_PROVIDER_SLUG_PATTERN,
+  type ModelProviderApi,
+  type ModelProviderCatalogEntryDto,
+  type ModelProviderCatalogResponseDto,
+  type ModelProviderCatalogSeedDto,
+  type ModelProviderConfigDto,
+  type ModelProviderConfigResponseDto,
+  type ModelProviderCredentialFieldDto,
+  type ModelProviderId,
+  type ModelProviderRef,
+  type ModelProviderSupportStatus,
+  materializedAgentIntegrationSchema,
+  materializedAgentIntegrationToolSchema,
+  materializedAgentStepConfigSchema,
+  modelProviderApiSchema,
+  modelProviderCatalogEntrySchema,
+  modelProviderCatalogResponseSchema,
+  modelProviderCatalogSeedSchema,
+  modelProviderConfigDtoSchema,
+  modelProviderConfigResponseSchema,
+  modelProviderCredentialFieldSchema,
+  modelProviderCredentialKeysMatch,
+  modelProviderRefSchema,
+  modelProviderSupportStatusSchema,
+  PI_HARNESS,
+  PI_HARNESS_TOOL_PACKAGE_NAMES,
+  parsePiEnabledToolPackages,
+  piAgentThinkingSchema,
+  providerIdSchema,
+  type SetDefaultHarnessBodyDto,
+  type SetDefaultHarnessResponseDto,
+  type SetDefaultModelProviderBodyDto,
+  type SetDefaultModelProviderResponseDto,
+  SUPPORTED_MODEL_PROVIDER_IDS,
+  type SupportedModelProviderId,
+  setDefaultHarnessBodySchema,
+  setDefaultHarnessResponseSchema,
+  setDefaultModelProviderBodySchema,
+  setDefaultModelProviderResponseSchema,
+  supportedModelProviderIdSchema,
+  thinkingLevelsForHarness,
+  UNSUPPORTED_MODEL_PROVIDER_IDS,
+  type UpdateCustomModelProviderBodyDto,
+  type UpdateCustomModelProviderHeaderRequestDto,
+  type UpdateModelProviderConfigBodyDto,
+  type UpdateModelProviderDefaultModelBodyDto,
+  updateCustomModelProviderBodySchema,
+  updateCustomModelProviderHeaderRequestSchema,
+  updateModelProviderConfigBodySchema,
+  updateModelProviderDefaultModelBodySchema,
+} from '#schemas/index.js';

package/src/schemas/catalog.test.ts

@@ -0,0 +1,206 @@
+import {
+  agentThinkingSchema,
+  DEFAULT_AGENT_THINKING,
+  getModelProviderEntry,
+  listSupportedModelProviders,
+  MODEL_PROVIDER_CATALOG_SEED,
+  modelProviderCatalogEntrySchema,
+  modelProviderCatalogSeedSchema,
+} from './catalog.js';
+import {
+  MODEL_PROVIDER_IDS,
+  SUPPORTED_MODEL_PROVIDER_IDS,
+  UNSUPPORTED_MODEL_PROVIDER_IDS,
+} from './model-provider-id.js';
+
+describe('model provider catalog', () => {
+  it('parses the catalog seed', () => {
+    const parsed = modelProviderCatalogSeedSchema.array().parse(MODEL_PROVIDER_CATALOG_SEED);
+
+    expect(parsed).toHaveLength(35);
+  });
+
+  it('rejects a supported provider without a default model', () => {
+    const parse = () =>
+      modelProviderCatalogSeedSchema.parse({
+        id: 'openai',
+        label: 'OpenAI',
+        support_status: 'supported',
+        default_model: null,
+        credential_fields: [{key: 'api_key', label: 'API key', secret: true}],
+        unsupported_reason: null,
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects a supported provider without credential fields', () => {
+    const parse = () =>
+      modelProviderCatalogSeedSchema.parse({
+        id: 'openai',
+        label: 'OpenAI',
+        support_status: 'supported',
+        default_model: 'gpt-5.5-pro',
+        credential_fields: [],
+        unsupported_reason: null,
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects an unsupported provider with a default model', () => {
+    const parse = () =>
+      modelProviderCatalogSeedSchema.parse({
+        id: 'github-copilot',
+        label: 'GitHub Copilot',
+        support_status: 'unsupported',
+        default_model: 'gpt-5.5-pro',
+        credential_fields: [],
+        unsupported_reason: 'OAuth is not supported.',
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects an unsupported provider with credential fields', () => {
+    const parse = () =>
+      modelProviderCatalogSeedSchema.parse({
+        id: 'github-copilot',
+        label: 'GitHub Copilot',
+        support_status: 'unsupported',
+        default_model: null,
+        credential_fields: [{key: 'api_key', label: 'API key', secret: true}],
+        unsupported_reason: 'OAuth is not supported.',
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects a catalog entry whose support status disagrees with its provider id', () => {
+    const parse = () =>
+      modelProviderCatalogSeedSchema.parse({
+        id: 'github-copilot',
+        label: 'GitHub Copilot',
+        support_status: 'supported',
+        default_model: 'gpt-5.5-pro',
+        credential_fields: [{key: 'api_key', label: 'API key', secret: true}],
+        unsupported_reason: null,
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('keeps catalog ids unique and synced with provider id constants', () => {
+    const supportedIds = MODEL_PROVIDER_CATALOG_SEED.filter(
+      (entry) => entry.support_status === 'supported',
+    ).map((entry) => entry.id);
+    const unsupportedIds = MODEL_PROVIDER_CATALOG_SEED.filter(
+      (entry) => entry.support_status === 'unsupported',
+    ).map((entry) => entry.id);
+    const ids = [...supportedIds, ...unsupportedIds];
+
+    expect(supportedIds).toEqual([...SUPPORTED_MODEL_PROVIDER_IDS]);
+    expect(unsupportedIds).toEqual([...UNSUPPORTED_MODEL_PROVIDER_IDS]);
+    expect(ids).toEqual([...MODEL_PROVIDER_IDS]);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  it('defines non-empty supported credential fields with at least one secret field', () => {
+    const supportedEntries = MODEL_PROVIDER_CATALOG_SEED.filter(
+      (entry) => entry.support_status === 'supported',
+    );
+
+    for (const entry of supportedEntries) {
+      expect(entry.credential_fields.length).toBeGreaterThan(0);
+      expect(entry.credential_fields.some((field) => field.secret)).toBe(true);
+      for (const field of entry.credential_fields) {
+        expect(field.key).not.toBe('');
+        expect(field.label).not.toBe('');
+        expect(typeof field.secret).toBe('boolean');
+      }
+    }
+  });
+
+  it('does not share credential field arrays between API-key providers', () => {
+    const anthropic = getModelProviderEntry('anthropic');
+    const openai = getModelProviderEntry('openai');
+    if (anthropic === undefined || openai === undefined) {
+      throw new Error('Missing API-key catalog entries');
+    }
+    const originalOpenAiFieldCount = openai.credential_fields.length;
+
+    try {
+      anthropic.credential_fields.push({key: 'extra', label: 'Extra', secret: true});
+
+      expect(openai.credential_fields).toHaveLength(originalOpenAiFieldCount);
+    } finally {
+      anthropic.credential_fields.pop();
+    }
+  });
+
+  it('parses catalog response entries assembled from seed entries and models', () => {
+    const responseEntries = MODEL_PROVIDER_CATALOG_SEED.map((entry) => ({
+      ...entry,
+      models:
+        entry.default_model === null
+          ? []
+          : [{id: entry.default_model, label: `${entry.label} default`}],
+    }));
+
+    const parsed = modelProviderCatalogEntrySchema.array().parse(responseEntries);
+
+    expect(parsed).toHaveLength(35);
+  });
+
+  it('rejects a supported response entry without models', () => {
+    const supportedEntry = getModelProviderEntry('openai');
+    if (supportedEntry === undefined) throw new Error('Missing OpenAI catalog entry');
+
+    const parse = () => modelProviderCatalogEntrySchema.parse({...supportedEntry, models: []});
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects a supported response entry whose default model is not in models', () => {
+    const supportedEntry = getModelProviderEntry('openai');
+    if (supportedEntry === undefined) throw new Error('Missing OpenAI catalog entry');
+
+    const parse = () =>
+      modelProviderCatalogEntrySchema.parse({
+        ...supportedEntry,
+        models: [{id: 'not-the-default', label: 'Not the default'}],
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects an unsupported response entry with models', () => {
+    const unsupportedEntry = getModelProviderEntry('github-copilot');
+    if (unsupportedEntry === undefined) throw new Error('Missing Copilot catalog entry');
+
+    const parse = () =>
+      modelProviderCatalogEntrySchema.parse({
+        ...unsupportedEntry,
+        models: [{id: 'gpt-5.5-pro', label: 'GPT-5.5 Pro'}],
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('finds catalog entries and lists only supported providers', () => {
+    const found = getModelProviderEntry('openai');
+    const missing = getModelProviderEntry('missing-provider');
+    const supportedEntries = listSupportedModelProviders();
+
+    expect(found?.id).toBe('openai');
+    expect(missing).toBeUndefined();
+    expect(supportedEntries).toHaveLength(31);
+    expect(supportedEntries.every((entry) => entry.support_status === 'supported')).toBe(true);
+  });
+
+  it('re-exports the instance-wide thinking contract', () => {
+    const parsed = agentThinkingSchema.parse(DEFAULT_AGENT_THINKING);
+
+    expect(parsed).toBe('xhigh');
+  });
+});

package/src/schemas/catalog.ts

@@ -0,0 +1,304 @@
+import {
+  agentThinkingByHarness,
+  agentThinkingSchema,
+  claudeAgentThinkingSchema,
+  DEFAULT_AGENT_THINKING,
+  DEFAULT_HARNESS,
+  DEFAULT_MODEL_PROVIDER,
+  harnessSchema,
+  piAgentThinkingSchema,
+  thinkingLevelsForHarness,
+} from '@shipfox/workflow-document';
+import {z} from 'zod';
+import {
+  type ModelProviderId,
+  providerIdSchema,
+  SUPPORTED_MODEL_PROVIDER_IDS,
+  type SupportedModelProviderId,
+  UNSUPPORTED_MODEL_PROVIDER_IDS,
+} from './model-provider-id.js';
+
+export type {AgentThinking, Harness} from '@shipfox/workflow-document';
+export {
+  agentThinkingByHarness,
+  agentThinkingSchema,
+  claudeAgentThinkingSchema,
+  DEFAULT_AGENT_THINKING,
+  DEFAULT_HARNESS,
+  DEFAULT_MODEL_PROVIDER,
+  harnessSchema,
+  piAgentThinkingSchema,
+  thinkingLevelsForHarness,
+};
+
+export const agentModelOptionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+});
+
+export type AgentModelOptionDto = z.infer<typeof agentModelOptionSchema>;
+
+export const modelProviderCredentialFieldSchema = z.object({
+  key: z.string().min(1),
+  label: z.string().min(1),
+  secret: z.boolean(),
+});
+
+export type ModelProviderCredentialFieldDto = z.infer<typeof modelProviderCredentialFieldSchema>;
+
+export const modelProviderSupportStatusSchema = z.enum(['supported', 'unsupported']);
+
+export type ModelProviderSupportStatus = z.infer<typeof modelProviderSupportStatusSchema>;
+
+const supportedModelProviderIds = new Set<string>(SUPPORTED_MODEL_PROVIDER_IDS);
+const unsupportedModelProviderIds = new Set<string>(UNSUPPORTED_MODEL_PROVIDER_IDS);
+
+const modelProviderCatalogSeedBaseSchema = z.object({
+  id: providerIdSchema,
+  label: z.string().min(1),
+  support_status: modelProviderSupportStatusSchema,
+  default_model: z.string().min(1).nullable(),
+  credential_fields: z.array(modelProviderCredentialFieldSchema),
+  unsupported_reason: z.string().min(1).nullable(),
+});
+
+export const modelProviderCatalogSeedSchema =
+  modelProviderCatalogSeedBaseSchema.superRefine(validateCatalogSeedEntry);
+
+export type ModelProviderCatalogSeedDto = z.infer<typeof modelProviderCatalogSeedSchema>;
+
+export const modelProviderCatalogEntrySchema = modelProviderCatalogSeedBaseSchema
+  .extend({
+    models: z.array(agentModelOptionSchema),
+  })
+  .superRefine((entry, ctx) => {
+    validateCatalogSeedEntry(entry, ctx);
+
+    if (entry.support_status === 'supported') {
+      if (entry.models.length === 0) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['models'],
+          message: 'Supported model providers must include at least one model.',
+        });
+      }
+      if (
+        entry.default_model !== null &&
+        !entry.models.some((model) => model.id === entry.default_model)
+      ) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['default_model'],
+          message: 'Supported model provider default_model must be present in models.',
+        });
+      }
+    } else if (entry.models.length > 0) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['models'],
+        message: 'Unsupported model providers must not include models.',
+      });
+    }
+  });
+
+export type ModelProviderCatalogEntryDto = z.infer<typeof modelProviderCatalogEntrySchema>;
+
+export const modelProviderCatalogResponseSchema = z.object({
+  providers: z.array(modelProviderCatalogEntrySchema),
+});
+
+export type ModelProviderCatalogResponseDto = z.infer<typeof modelProviderCatalogResponseSchema>;
+
+const apiKeyCredentialFields = [credentialField('api_key', 'API key', true)];
+
+const azureCredentialFields = [
+  credentialField('endpoint', 'Endpoint', false),
+  credentialField('api_key', 'API key', true),
+];
+
+const cloudflareAiGatewayCredentialFields = [
+  credentialField('api_key', 'API token', true),
+  credentialField('account_id', 'Account ID', false),
+  credentialField('gateway_id', 'Gateway ID', false),
+];
+
+const cloudflareWorkersAiCredentialFields = [
+  credentialField('api_key', 'API token', true),
+  credentialField('account_id', 'Account ID', false),
+];
+
+export const MODEL_PROVIDER_CATALOG_SEED: ModelProviderCatalogSeedDto[] = [
+  supportedProvider('anthropic', 'Anthropic', 'claude-opus-4-8'),
+  supportedProvider('ant-ling', 'Ant Ling', 'Ring-2.6-1T'),
+  supportedProvider('azure-openai-responses', 'Azure OpenAI', 'gpt-5.5-pro', azureCredentialFields),
+  supportedProvider('openai', 'OpenAI', 'gpt-5.5-pro'),
+  supportedProvider('deepseek', 'DeepSeek', 'deepseek-v4-pro'),
+  supportedProvider('nvidia', 'NVIDIA', 'nvidia/nemotron-3-ultra-550b-a55b'),
+  supportedProvider('google', 'Google AI Studio', 'gemini-3.1-pro-preview'),
+  supportedProvider('mistral', 'Mistral', 'mistral-large-latest'),
+  supportedProvider('groq', 'Groq', 'openai/gpt-oss-120b'),
+  supportedProvider('cerebras', 'Cerebras', 'gpt-oss-120b'),
+  supportedProvider(
+    'cloudflare-ai-gateway',
+    'Cloudflare AI Gateway',
+    'claude-opus-4-8',
+    cloudflareAiGatewayCredentialFields,
+  ),
+  supportedProvider(
+    'cloudflare-workers-ai',
+    'Cloudflare Workers AI',
+    '@cf/moonshotai/kimi-k2.7-code',
+    cloudflareWorkersAiCredentialFields,
+  ),
+  supportedProvider('xai', 'xAI', 'grok-4.3'),
+  supportedProvider('openrouter', 'OpenRouter', 'anthropic/claude-opus-4.8'),
+  supportedProvider('vercel-ai-gateway', 'Vercel AI Gateway', 'anthropic/claude-opus-4.8'),
+  supportedProvider('zai', 'Z.ai', 'glm-5.2'),
+  supportedProvider('zai-coding-cn', 'Z.ai Coding CN', 'glm-5.2'),
+  supportedProvider('opencode', 'OpenCode', 'claude-opus-4-8'),
+  supportedProvider('opencode-go', 'OpenCode Go', 'kimi-k2.7-code'),
+  supportedProvider('huggingface', 'Hugging Face', 'deepseek-ai/DeepSeek-V4-Pro'),
+  supportedProvider('fireworks', 'Fireworks', 'accounts/fireworks/models/deepseek-v4-pro'),
+  supportedProvider('together', 'Together AI', 'deepseek-ai/DeepSeek-V4-Pro'),
+  supportedProvider('kimi-coding', 'Kimi Coding', 'k2p7'),
+  supportedProvider('minimax', 'MiniMax', 'MiniMax-M3'),
+  supportedProvider('minimax-cn', 'MiniMax CN', 'MiniMax-M3'),
+  supportedProvider('moonshotai', 'Moonshot AI', 'kimi-k2.7-code'),
+  supportedProvider('moonshotai-cn', 'Moonshot AI CN', 'kimi-k2.7-code'),
+  supportedProvider('xiaomi', 'Xiaomi', 'mimo-v2.5-pro'),
+  supportedProvider('xiaomi-token-plan-cn', 'Xiaomi Token Plan CN', 'mimo-v2.5-pro'),
+  supportedProvider('xiaomi-token-plan-ams', 'Xiaomi Token Plan AMS', 'mimo-v2.5-pro'),
+  supportedProvider('xiaomi-token-plan-sgp', 'Xiaomi Token Plan SGP', 'mimo-v2.5-pro'),
+  unsupportedProvider(
+    'amazon-bedrock',
+    'Amazon Bedrock',
+    'AWS cloud credentials are not supported by workspace API-key provider configs yet.',
+  ),
+  unsupportedProvider(
+    'google-vertex',
+    'Google Vertex AI',
+    'GCP cloud credentials are not supported by workspace API-key provider configs yet.',
+  ),
+  unsupportedProvider(
+    'openai-codex',
+    'OpenAI Codex',
+    'ChatGPT subscription and OAuth credentials are not supported by workspace API-key provider configs yet.',
+  ),
+  unsupportedProvider(
+    'github-copilot',
+    'GitHub Copilot',
+    'GitHub Copilot OAuth credentials are not supported by workspace API-key provider configs yet.',
+  ),
+];
+
+export function getModelProviderEntry(id: string): ModelProviderCatalogSeedDto | undefined {
+  return MODEL_PROVIDER_CATALOG_SEED.find((entry) => entry.id === id);
+}
+
+export function listSupportedModelProviders(): ModelProviderCatalogSeedDto[] {
+  return MODEL_PROVIDER_CATALOG_SEED.filter((entry) => entry.support_status === 'supported');
+}
+
+function validateCatalogSeedEntry(
+  entry: z.infer<typeof modelProviderCatalogSeedBaseSchema>,
+  ctx: z.RefinementCtx,
+): void {
+  if (entry.support_status === 'supported') {
+    if (!supportedModelProviderIds.has(entry.id)) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['id'],
+        message: 'Supported catalog entries must use a supported model provider id.',
+      });
+    }
+    if (entry.default_model === null) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['default_model'],
+        message: 'Supported model providers must define a default_model.',
+      });
+    }
+    if (entry.credential_fields.length === 0) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['credential_fields'],
+        message: 'Supported model providers must define credential_fields.',
+      });
+    }
+    if (entry.unsupported_reason !== null) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['unsupported_reason'],
+        message: 'Supported model providers must not define unsupported_reason.',
+      });
+    }
+  } else {
+    if (!unsupportedModelProviderIds.has(entry.id)) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['id'],
+        message: 'Unsupported catalog entries must use an unsupported model provider id.',
+      });
+    }
+    if (entry.default_model !== null) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['default_model'],
+        message: 'Unsupported model providers must not define a default_model.',
+      });
+    }
+    if (entry.credential_fields.length > 0) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['credential_fields'],
+        message: 'Unsupported model providers must not define credential_fields.',
+      });
+    }
+    if (entry.unsupported_reason === null) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['unsupported_reason'],
+        message: 'Unsupported model providers must define unsupported_reason.',
+      });
+    }
+  }
+}
+
+function credentialField(
+  key: string,
+  label: string,
+  secret: boolean,
+): ModelProviderCredentialFieldDto {
+  return {key, label, secret};
+}
+
+function supportedProvider(
+  id: SupportedModelProviderId,
+  label: string,
+  defaultModel: string,
+  credentialFields: ModelProviderCredentialFieldDto[] = apiKeyCredentialFields,
+): ModelProviderCatalogSeedDto {
+  return {
+    id,
+    label,
+    support_status: 'supported',
+    default_model: defaultModel,
+    credential_fields: credentialFields.map((field) => ({...field})),
+    unsupported_reason: null,
+  };
+}
+
+function unsupportedProvider(
+  id: ModelProviderId,
+  label: string,
+  unsupportedReason: string,
+): ModelProviderCatalogSeedDto {
+  return {
+    id,
+    label,
+    support_status: 'unsupported',
+    default_model: null,
+    credential_fields: [],
+    unsupported_reason: unsupportedReason,
+  };
+}