@shipfox/api-agent 12.2.0 → 14.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-agent",
   "license": "MIT",
-  "version": "12.2.0",
+  "version": "14.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -39,7 +39,7 @@
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
     "@shipfox/node-error-monitoring": "0.3.0",
-    "@shipfox/api-agent-dto": "12.2.0",
+    "@shipfox/api-agent-dto": "14.0.0",
     "@shipfox/api-auth-context": "12.2.0",
     "@shipfox/api-secrets-dto": "12.0.0",
     "@shipfox/inter-module": "0.2.3",

package/src/config.test.ts

@@ -1,3 +1,5 @@
+import type {ManagedModelEntry, ManagedModelProvider} from '@shipfox/api-agent-dto';
+
 describe('agent config', () => {
   afterEach(() => {
     vi.unstubAllEnvs();
@@ -14,14 +16,56 @@ describe('agent config', () => {
     expect(module.config.AGENT_DEFAULT_PROVIDER_API_KEY).toBe('sk-instance-secret');
   });
 
+  it('defaults workspace provider configuration to enabled', async () => {
+    vi.resetModules();
+
+    const module = await import('./config.js');
+
+    expect(module.config.AGENT_WORKSPACE_PROVIDERS).toBe('enabled');
+    expect(module.workspaceProvidersPolicy).toBe('enabled');
+  });
+
+  it('accepts disabled workspace provider configuration with a managed provider', async () => {
+    vi.resetModules();
+    vi.stubEnv('AGENT_WORKSPACE_PROVIDERS', 'disabled');
+
+    const module = await import('./config.js');
+
+    expect(module.workspaceProvidersPolicy).toBe('disabled');
+    expect(() => module.assertAgentConfig(managedProvider())).not.toThrow();
+  });
+
+  it('requires a managed provider when workspace provider configuration is disabled', async () => {
+    vi.resetModules();
+    vi.stubEnv('AGENT_WORKSPACE_PROVIDERS', 'disabled');
+
+    const module = await import('./config.js');
+
+    expect(() => module.assertAgentConfig()).toThrow(
+      'AGENT_WORKSPACE_PROVIDERS=disabled requires an injected managed model provider',
+    );
+  });
+
+  it('rejects a foreign instance default when workspace provider configuration is disabled', async () => {
+    vi.resetModules();
+    vi.stubEnv('AGENT_WORKSPACE_PROVIDERS', 'disabled');
+    vi.stubEnv('AGENT_DEFAULT_PROVIDER', 'openai');
+
+    const module = await import('./config.js');
+
+    expect(() => module.assertAgentConfig(managedProvider())).toThrow(
+      'This instance only supports provider `shipfox`',
+    );
+  });
+
   it('throws when an instance key is set for a multi-field provider', async () => {
     vi.resetModules();
     vi.stubEnv('AGENT_DEFAULT_PROVIDER', 'azure-openai-responses');
     vi.stubEnv('AGENT_DEFAULT_PROVIDER_API_KEY', 'sk-instance-secret');
 
-    const importConfig = import('./config.js');
+    const module = await import('./config.js');
 
-    await expect(importConfig).rejects.toThrow(
+    expect(() => module.assertAgentConfig()).toThrow(
       'AGENT_DEFAULT_PROVIDER_API_KEY requires AGENT_DEFAULT_PROVIDER',
     );
   });
@@ -30,13 +74,131 @@ describe('agent config', () => {
     vi.resetModules();
     vi.stubEnv('AGENT_DEFAULT_PROVIDER_API_KEY', 'sk-instance-secret');
 
-    const importConfig = import('./config.js');
+    const module = await import('./config.js');
 
-    await expect(importConfig).rejects.toThrow(
+    expect(() => module.assertAgentConfig()).toThrow(
       'AGENT_DEFAULT_PROVIDER_API_KEY requires AGENT_DEFAULT_PROVIDER',
     );
   });
 
+  it('accepts an injected managed provider as the instance default', async () => {
+    vi.resetModules();
+    vi.stubEnv('AGENT_DEFAULT_PROVIDER', 'shipfox');
+
+    const module = await import('./config.js');
+
+    expect(() => module.assertAgentConfig(managedProvider())).not.toThrow();
+  });
+
+  it('rejects an instance API key for an injected managed provider', async () => {
+    vi.resetModules();
+    vi.stubEnv('AGENT_DEFAULT_PROVIDER', 'shipfox');
+    vi.stubEnv('AGENT_DEFAULT_PROVIDER_API_KEY', 'sk-instance-secret');
+
+    const module = await import('./config.js');
+
+    expect(() => module.assertAgentConfig(managedProvider())).toThrow(
+      'AGENT_DEFAULT_PROVIDER_API_KEY cannot be used with a managed model provider',
+    );
+  });
+
+  it('rejects an instance default that is not a registered provider', async () => {
+    vi.resetModules();
+    vi.stubEnv('AGENT_DEFAULT_PROVIDER', 'not-registered');
+
+    const module = await import('./config.js');
+
+    expect(() => module.assertAgentConfig()).toThrow(
+      'AGENT_DEFAULT_PROVIDER must name a supported registered provider',
+    );
+  });
+
+  it.each([
+    ['invalid provider ID', managedProvider({id: 'bad_id'}), 'valid provider slug'],
+    ['reserved provider ID', managedProvider({id: 'openai'}), 'provider ID is reserved'],
+    ['empty provider label', managedProvider({label: ''}), 'label must not be empty'],
+    ['empty model list', managedProvider({models: []}), 'at least one model'],
+    [
+      'empty model ID',
+      managedProvider({
+        models: [{id: '', label: 'Managed model', api: 'anthropic-messages'}],
+      }),
+      'models must have IDs and labels',
+    ],
+    [
+      'empty model label',
+      managedProvider({
+        models: [{id: 'managed-model', label: '', api: 'anthropic-messages'}],
+      }),
+      'models must have IDs and labels',
+    ],
+    [
+      'duplicate model IDs',
+      managedProvider({
+        models: [
+          {id: 'managed-model', label: 'Managed model', api: 'anthropic-messages'},
+          {id: 'managed-model', label: 'Managed model 2', api: 'openai-responses'},
+        ],
+      }),
+      'models must have unique IDs',
+    ],
+    [
+      'invalid model API',
+      managedProvider({
+        models: [
+          {
+            id: 'managed-model',
+            label: 'Managed model',
+            api: 'invalid' as unknown as ManagedModelEntry['api'],
+          },
+        ],
+      }),
+      'model API is invalid',
+    ],
+    ...(
+      [
+        ['null context window', {context_window: null}],
+        ['zero max output tokens', {max_output_tokens: 0}],
+        ['fractional context window', {context_window: 1.5}],
+        ['string context window', {context_window: '128000'}],
+        ['non-boolean reasoning', {reasoning: 'true'}],
+        ['non-boolean input image', {input_image: 1}],
+      ] as const
+    ).map(
+      ([name, metadata]) =>
+        [
+          `invalid ${name}`,
+          managedProviderWithModelMetadata(metadata),
+          'model metadata is invalid',
+        ] as const,
+    ),
+    [
+      'unregistered default model',
+      managedProvider({defaultModel: 'missing-model'}),
+      'default model is not registered',
+    ],
+    [
+      'invalid default thinking',
+      managedProvider({
+        defaultThinking: 'invalid' as unknown as ManagedModelProvider['defaultThinking'],
+      }),
+      'default thinking is invalid',
+    ],
+    [
+      'missing credential resolver',
+      managedProvider({
+        resolveCredentials: undefined as unknown as ManagedModelProvider['resolveCredentials'],
+      }),
+      'must resolve credentials',
+    ],
+  ] as const)('rejects a managed provider with %s', async (_name, provider, message) => {
+    vi.resetModules();
+
+    const module = await import('./config.js');
+
+    expect(() => module.assertAgentConfig(provider)).toThrow(message);
+  });
+
   it('imports without an instance key', async () => {
     vi.resetModules();
     vi.stubEnv('AGENT_DEFAULT_PROVIDER', 'azure-openai-responses');
@@ -116,3 +278,33 @@ describe('agent config', () => {
     await expect(importConfig).rejects.toThrow('AGENT_PI_ENABLED_TOOL_PACKAGES');
   });
 });
+
+function managedProvider(overrides: Partial<ManagedModelProvider> = {}): ManagedModelProvider {
+  return {
+    id: 'shipfox',
+    label: 'Shipfox',
+    models: [{id: 'claude-opus-4-8', label: 'Claude Opus 4.8', api: 'anthropic-messages' as const}],
+    defaultModel: 'claude-opus-4-8',
+    defaultThinking: 'high' as const,
+    resolveCredentials: async () => ({
+      api: 'anthropic-messages' as const,
+      baseUrl: 'https://gateway.example.com',
+      credentials: {api_key: 'token'},
+    }),
+    ...overrides,
+  };
+}
+
+function managedProviderWithModelMetadata(metadata: object): ManagedModelProvider {
+  return managedProvider({
+    models: [
+      {
+        id: 'managed-model',
+        label: 'Managed model',
+        api: 'anthropic-messages',
+        ...metadata,
+      } as ManagedModelEntry,
+    ],
+    defaultModel: 'managed-model',
+  });
+}

package/src/config.ts

@@ -1,18 +1,29 @@
 import {
   agentThinkingSchema,
   buildHarnessToolDeploymentConfig,
+  isReservedModelProviderId,
+  type ManagedModelProvider,
+  managedModelApiSchema,
+  managedModelMetadataSchema,
+  modelProviderRefSchema,
   SUPPORTED_MODEL_PROVIDER_IDS,
-  type SupportedModelProviderId,
+  type WorkspaceProvidersPolicy,
 } from '@shipfox/api-agent-dto';
 import {bool, createConfig, num, str} from '@shipfox/config';
+import {WorkspaceProvidersDisabledError} from '#core/errors.js';
 import {getModelProviderEntry} from '#core/model-provider-policy.js';
 
 const AGENT_THINKING_CHOICES = agentThinkingSchema.options;
+const SUPPORTED_PROVIDER_IDS_DESCRIPTION = SUPPORTED_MODEL_PROVIDER_IDS.join(', ');
 
 export const config = createConfig({
+  AGENT_WORKSPACE_PROVIDERS: str({
+    desc: 'Controls whether workspaces can configure model providers. Use enabled to preserve the default workspace provider behavior, or disabled when the injected managed provider is the only provider for this instance.',
+    choices: ['enabled', 'disabled'],
+    default: 'enabled',
+  }),
   AGENT_DEFAULT_PROVIDER: str({
-    desc: 'Instance-wide default model provider ID used when a workflow and workspace do not choose one. Optional. Use one of the supported model provider IDs from the model provider catalog.',
-    choices: SUPPORTED_MODEL_PROVIDER_IDS,
+    desc: `Instance-wide default model provider ID used when a workflow and workspace do not choose one. Optional. Use one of the supported model catalog IDs (${SUPPORTED_PROVIDER_IDS_DESCRIPTION}) or the injected managed provider.`,
     default: undefined,
   }),
   AGENT_DEFAULT_PROVIDER_MODEL: str({
@@ -50,22 +61,47 @@ export const config = createConfig({
   }),
 });
 
-assertInstanceDefaultModelProviderApiKeyConfig();
+export const workspaceProvidersPolicy =
+  config.AGENT_WORKSPACE_PROVIDERS as WorkspaceProvidersPolicy;
 
 export const harnessToolDeploymentConfig = buildHarnessToolDeploymentConfig({
   piEnabledToolPackages: config.AGENT_PI_ENABLED_TOOL_PACKAGES,
   piWebSearchEnabled: config.AGENT_PI_WEB_SEARCH_ENABLED,
 });
 
-function assertInstanceDefaultModelProviderApiKeyConfig(): void {
+export function assertAgentConfig(managedProvider?: ManagedModelProvider): void {
+  if (managedProvider !== undefined) assertManagedProvider(managedProvider);
+
+  if (workspaceProvidersPolicy === 'disabled') {
+    if (managedProvider === undefined) {
+      throw new Error(
+        'AGENT_WORKSPACE_PROVIDERS=disabled requires an injected managed model provider.',
+      );
+    }
+    if (
+      config.AGENT_DEFAULT_PROVIDER !== undefined &&
+      config.AGENT_DEFAULT_PROVIDER !== managedProvider.id
+    ) {
+      throw new WorkspaceProvidersDisabledError(managedProvider.id);
+    }
+  }
+
+  const defaultProvider = config.AGENT_DEFAULT_PROVIDER;
+  if (defaultProvider !== undefined && !isRegisteredProvider(defaultProvider, managedProvider)) {
+    throw new Error(
+      `AGENT_DEFAULT_PROVIDER must name a supported registered provider: ${defaultProvider}.`,
+    );
+  }
+
   if (!config.AGENT_DEFAULT_PROVIDER_API_KEY) return;
-  if (!config.AGENT_DEFAULT_PROVIDER) {
+  if (!defaultProvider) {
     throw new Error('AGENT_DEFAULT_PROVIDER_API_KEY requires AGENT_DEFAULT_PROVIDER to be set.');
   }
+  if (managedProvider?.id === defaultProvider) {
+    throw new Error('AGENT_DEFAULT_PROVIDER_API_KEY cannot be used with a managed model provider.');
+  }
 
-  const credentialFields =
-    getModelProviderEntry(config.AGENT_DEFAULT_PROVIDER as SupportedModelProviderId)
-      ?.credential_fields ?? [];
+  const credentialFields = getModelProviderEntry(defaultProvider)?.credential_fields ?? [];
   const field = credentialFields[0];
   if (credentialFields.length === 1 && field?.key === 'api_key' && field.secret) return;
 
@@ -73,3 +109,58 @@ function assertInstanceDefaultModelProviderApiKeyConfig(): void {
     'AGENT_DEFAULT_PROVIDER_API_KEY requires AGENT_DEFAULT_PROVIDER to use exactly one secret api_key credential field.',
   );
 }
+
+function isRegisteredProvider(
+  providerId: string,
+  managedProvider: ManagedModelProvider | undefined,
+): boolean {
+  if (managedProvider?.id === providerId) return true;
+  return getModelProviderEntry(providerId)?.support_status === 'supported';
+}
+
+function assertManagedProvider(provider: ManagedModelProvider): void {
+  if (!modelProviderRefSchema.safeParse(provider.id).success) {
+    throw new Error(`Managed model provider ID must be a valid provider slug: ${provider.id}.`);
+  }
+  if (isReservedModelProviderId(provider.id)) {
+    throw new Error(`Managed model provider ID is reserved: ${provider.id}.`);
+  }
+  if (provider.label.length === 0) {
+    throw new Error(`Managed model provider label must not be empty: ${provider.id}.`);
+  }
+  if (provider.models.length === 0) {
+    throw new Error(`Managed model provider must define at least one model: ${provider.id}.`);
+  }
+
+  const modelIds = new Set<string>();
+  for (const model of provider.models) {
+    if (model.id.length === 0 || model.label.length === 0) {
+      throw new Error(`Managed model provider models must have IDs and labels: ${provider.id}.`);
+    }
+    if (modelIds.has(model.id)) {
+      throw new Error(`Managed model provider models must have unique IDs: ${provider.id}.`);
+    }
+    modelIds.add(model.id);
+    if (!managedModelApiSchema.safeParse(model.api).success) {
+      throw new Error(`Managed model provider model API is invalid: ${provider.id}/${model.id}.`);
+    }
+    if (!managedModelMetadataSchema.safeParse(model).success) {
+      throw new Error(
+        `Managed model provider model metadata is invalid: ${provider.id}/${model.id}.`,
+      );
+    }
+  }
+
+  if (!modelIds.has(provider.defaultModel)) {
+    throw new Error(`Managed model provider default model is not registered: ${provider.id}.`);
+  }
+  if (
+    provider.defaultThinking !== undefined &&
+    !agentThinkingSchema.safeParse(provider.defaultThinking).success
+  ) {
+    throw new Error(`Managed model provider default thinking is invalid: ${provider.id}.`);
+  }
+  if (typeof provider.resolveCredentials !== 'function') {
+    throw new Error(`Managed model provider must resolve credentials: ${provider.id}.`);
+  }
+}

package/src/core/errors.ts

@@ -32,6 +32,13 @@ export class UnsupportedModelProviderError extends Error {
   }
 }
 
+export class WorkspaceProvidersDisabledError extends Error {
+  constructor(public readonly managedProviderId: string) {
+    super(`This instance only supports provider \`${managedProviderId}\`.`);
+    this.name = 'WorkspaceProvidersDisabledError';
+  }
+}
+
 export class UnsupportedHarnessProviderError extends Error {
   constructor(
     public readonly harness: Harness,

package/src/core/index.ts

@@ -19,6 +19,7 @@ export {
   UnsupportedHarnessProviderError,
   UnsupportedHarnessThinkingError,
   UnsupportedModelProviderError,
+  WorkspaceProvidersDisabledError,
 } from './errors.js';
 export {
   getHarnessDescriptor,
@@ -61,3 +62,7 @@ export {
   resolveRuntimeCredentials,
 } from './resolve-runtime-credentials.js';
 export {createWorkspaceAgentDefaultsResolver} from './workspace-agent-defaults-resolver.js';
+export {
+  assertWorkspaceProviderConfigurationEnabled,
+  type WorkspaceProviderPolicyOptions,
+} from './workspace-provider-policy.js';

package/src/core/model-provider-catalog.test.ts

@@ -0,0 +1,30 @@
+import type {ManagedModelProvider} from '@shipfox/api-agent-dto';
+import {buildModelProviderCatalog} from './model-provider-catalog.js';
+
+describe('buildModelProviderCatalog', () => {
+  it('deep-freezes managed provider entries in both policy modes', () => {
+    const managedProvider = {
+      id: 'shipfox-managed',
+      label: 'Shipfox Managed',
+      models: [{id: 'managed-claude', label: 'Managed Claude', api: 'anthropic-messages' as const}],
+      defaultModel: 'managed-claude',
+      resolveCredentials: async () => ({
+        api: 'anthropic-messages' as const,
+        baseUrl: 'https://gateway.example.com',
+        credentials: {api_key: 'token'},
+      }),
+    } satisfies ManagedModelProvider;
+
+    for (const workspaceProviders of ['enabled', 'disabled'] as const) {
+      const catalog = buildModelProviderCatalog({managedProvider, workspaceProviders});
+      const managedEntry = catalog.find((entry) => entry.id === managedProvider.id);
+
+      if (managedEntry === undefined) throw new Error('Missing managed provider catalog entry');
+
+      expect(Object.isFrozen(managedEntry)).toBe(true);
+      expect(Object.isFrozen(managedEntry.models)).toBe(true);
+      expect(Object.isFrozen(managedEntry.models[0])).toBe(true);
+      expect(managedEntry.models[0]?.api).toBe('anthropic-messages');
+    }
+  });
+});

package/src/core/model-provider-catalog.ts

@@ -1,13 +1,37 @@
 import {
+  type ManagedModelProvider,
   MODEL_PROVIDER_CATALOG_SEED,
   type ModelProviderCatalogEntryDto,
   modelProviderCatalogEntrySchema,
+  type WorkspaceProvidersPolicy,
 } from '@shipfox/api-agent-dto';
 import {listPiProviderModels} from './harness/pi.js';
 
 let cachedCatalog: readonly ModelProviderCatalogEntryDto[] | undefined;
 
-export function buildModelProviderCatalog(): readonly ModelProviderCatalogEntryDto[] {
+export function buildModelProviderCatalog(
+  options: {
+    managedProvider?: ManagedModelProvider | undefined;
+    workspaceProviders?: WorkspaceProvidersPolicy | undefined;
+  } = {},
+): readonly ModelProviderCatalogEntryDto[] {
+  const workspaceProviders = options.workspaceProviders ?? 'enabled';
+  if (workspaceProviders === 'disabled') {
+    if (options.managedProvider === undefined) {
+      throw new Error(
+        'workspace provider configuration is disabled but no managed provider is registered',
+      );
+    }
+    return Object.freeze([toManagedProviderCatalogEntry(options.managedProvider)]);
+  }
+
+  const catalog = getCatalog();
+  if (options.managedProvider === undefined) return catalog;
+
+  return Object.freeze([...catalog, toManagedProviderCatalogEntry(options.managedProvider)]);
+}
+
+function getCatalog(): readonly ModelProviderCatalogEntryDto[] {
   if (cachedCatalog) return cachedCatalog;
 
   const catalog = modelProviderCatalogEntrySchema.array().parse(
@@ -22,6 +46,22 @@ export function buildModelProviderCatalog(): readonly ModelProviderCatalogEntryD
   return cachedCatalog;
 }
 
+function toManagedProviderCatalogEntry(
+  managedProvider: ManagedModelProvider,
+): ModelProviderCatalogEntryDto {
+  return deepFreeze(
+    modelProviderCatalogEntrySchema.parse({
+      id: managedProvider.id,
+      label: managedProvider.label,
+      support_status: 'supported',
+      default_model: managedProvider.defaultModel,
+      credential_fields: [],
+      unsupported_reason: null,
+      models: managedProvider.models.map(({id, label, api}) => ({id, label, api})),
+    }),
+  );
+}
+
 function deepFreeze<T>(value: T): T {
   if (Array.isArray(value)) {
     for (const item of value) deepFreeze(item);

package/src/core/resolve-agent-config.test.ts

@@ -12,6 +12,7 @@ import {
   UnsupportedHarnessProviderError,
   UnsupportedHarnessThinkingError,
   UnsupportedModelProviderError,
+  WorkspaceProvidersDisabledError,
 } from './errors.js';
 import * as harnessCatalog from './harness/index.js';
 import {catalogDefaultAgentResolver, resolveAgentConfig} from './resolve-agent-config.js';
@@ -108,6 +109,78 @@ describe('resolveAgentConfig', () => {
     expect(invalidModel).toThrow(InvalidAgentModelError);
   });
 
+  test('resolves managed provider models by harness API family', () => {
+    const provider = managedProvider();
+    const context = {managedProvider: provider};
+
+    const pi = resolveAgentConfig({provider: 'shipfox', model: 'completion-model'}, context);
+    const claude = resolveAgentConfig({harness: 'claude', provider: 'shipfox'}, context);
+    const incompatible = () =>
+      resolveAgentConfig(
+        {harness: 'claude', provider: 'shipfox', model: 'responses-model'},
+        context,
+      );
+
+    expect(pi).toEqual({
+      harness: 'pi',
+      provider: 'shipfox',
+      model: 'completion-model',
+      thinking: 'low',
+    });
+    expect(claude).toEqual({
+      harness: 'claude',
+      provider: 'shipfox',
+      model: 'claude-model',
+      thinking: 'low',
+    });
+    expect(incompatible).toThrow(InvalidAgentModelError);
+  });
+
+  test('instance model and thinking overrides win over managed provider defaults', () => {
+    const resolved = resolveAgentConfig(
+      {provider: 'shipfox'},
+      {
+        managedProvider: managedProvider(),
+        instanceDefaultProvider: 'shipfox',
+        instanceDefaultModel: 'claude-model',
+        instanceDefaultThinking: 'high',
+      },
+    );
+
+    expect(resolved).toEqual({
+      harness: 'pi',
+      provider: 'shipfox',
+      model: 'claude-model',
+      thinking: 'high',
+    });
+  });
+
+  test('defaults to the managed provider when workspace providers are disabled', () => {
+    const resolved = resolveAgentConfig(
+      {},
+      {
+        workspaceProviders: 'disabled',
+        workspaceDefaultProviderId: 'openai',
+        instanceDefaultProvider: 'openai',
+        managedProvider: managedProvider(),
+      },
+    );
+
+    expect(resolved.provider).toBe('shipfox');
+    expect(resolved.model).toBe('responses-model');
+  });
+
+  test('rejects foreign provider references when workspace providers are disabled', () => {
+    const resolve = () =>
+      resolveAgentConfig(
+        {provider: 'openai'},
+        {workspaceProviders: 'disabled', managedProvider: managedProvider()},
+      );
+
+    expect(resolve).toThrow(WorkspaceProvidersDisabledError);
+    expect(resolve).toThrow('This instance only supports provider `shipfox`');
+  });
+
   test('uses instance model and thinking only for the resolved instance model provider', () => {
     const resolved = resolveAgentConfig(
       {provider: 'openai'},
@@ -439,3 +512,22 @@ function createModelProviderConfigParams(params: {
     defaultThinking: params.defaultThinking,
   };
 }
+
+function managedProvider() {
+  return {
+    id: 'shipfox',
+    label: 'Shipfox',
+    models: [
+      {id: 'claude-model', label: 'Claude model', api: 'anthropic-messages' as const},
+      {id: 'responses-model', label: 'Responses model', api: 'openai-responses' as const},
+      {id: 'completion-model', label: 'Completions model', api: 'openai-completions' as const},
+    ],
+    defaultModel: 'responses-model',
+    defaultThinking: 'low' as const,
+    resolveCredentials: async () => ({
+      api: 'anthropic-messages' as const,
+      baseUrl: 'https://gateway.example.com',
+      credentials: {api_key: 'token'},
+    }),
+  };
+}