@shipfox/api-agent 2.0.0

package/src/db/schema/model-provider-configs.ts

@@ -0,0 +1,80 @@
+import type {
+  AgentThinking,
+  CustomAgentModelDto,
+  CustomModelProviderHeaderDto,
+  ModelProviderApi,
+  ModelProviderRef,
+} from '@shipfox/api-agent-dto';
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {sql} from 'drizzle-orm';
+import {
+  boolean,
+  check,
+  jsonb,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from 'drizzle-orm/pg-core';
+import type {ModelProviderConfig} from '#core/entities/model-provider-config.js';
+
+export const modelProviderConfigKindEnum = pgEnum('model_provider_config_kind', [
+  'builtin',
+  'custom',
+]);
+
+export const modelProviderConfigs = pgTable(
+  'model_provider_configs',
+  {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    providerId: text('provider_id').notNull(),
+    kind: modelProviderConfigKindEnum('kind').notNull().default('builtin'),
+    displayName: text('display_name'),
+    api: text('api').$type<ModelProviderApi>(),
+    baseUrl: text('base_url'),
+    headers: jsonb('headers').$type<CustomModelProviderHeaderDto[]>(),
+    secretHeaderNames: jsonb('secret_header_names').$type<string[]>(),
+    models: jsonb('models').$type<CustomAgentModelDto[]>(),
+    requiresApiKey: boolean('requires_api_key').notNull().default(false),
+    defaultModel: text('default_model'),
+    defaultThinking: text('default_thinking').notNull(),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('model_provider_configs_workspace_provider_unique').on(
+      table.workspaceId,
+      table.providerId,
+    ),
+    check(
+      'model_provider_configs_custom_required_fields',
+      sql`${table.kind} <> 'custom' OR (${table.api} IS NOT NULL AND ${table.baseUrl} IS NOT NULL AND ${table.models} IS NOT NULL AND ${table.displayName} IS NOT NULL)`,
+    ),
+  ],
+);
+
+export type ModelProviderConfigDb = typeof modelProviderConfigs.$inferSelect;
+export type ModelProviderConfigCreateDb = typeof modelProviderConfigs.$inferInsert;
+
+export function toModelProviderConfig(row: ModelProviderConfigDb): ModelProviderConfig {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    providerId: row.providerId as ModelProviderRef,
+    kind: row.kind,
+    displayName: row.displayName,
+    api: row.api,
+    baseUrl: row.baseUrl,
+    headers: row.headers,
+    secretHeaderNames: row.secretHeaderNames,
+    models: row.models,
+    requiresApiKey: row.requiresApiKey,
+    defaultModel: row.defaultModel,
+    defaultThinking: row.defaultThinking as AgentThinking,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+import type {ShipfoxModule} from '@shipfox/node-module';
+import {db, migrationsPath} from '#db/index.js';
+import {agentE2eRoutes} from '#presentation/e2eRoutes/index.js';
+import {routes} from '#presentation/index.js';
+
+export {
+  type AgentConfigResolutionContext,
+  type AgentDefaultsResolver,
+  type AgentWorkspaceSettings,
+  buildModelProviderCatalog,
+  type ContextualAgentConfig,
+  catalogDefaultAgentResolver,
+  createCustomModelProviderConfig,
+  createWorkspaceAgentDefaultsResolver,
+  deleteModelProviderConfig,
+  InvalidAgentModelError,
+  InvalidCredentialFieldsError,
+  type ModelProviderConfig,
+  ModelProviderConfigNotFoundError,
+  ModelProviderValidationError,
+  ModelProviderValidationUnavailableError,
+  type ResolvedAgentConfig,
+  type ResolveRuntimeCredentialsParams,
+  resolveAgentConfig,
+  resolveRuntimeCredentials,
+  testAndSaveModelProviderConfig,
+  UnsupportedModelProviderError,
+  updateCustomModelProviderConfig,
+} from '#core/index.js';
+export {
+  getAgentWorkspaceSettings,
+  getModelProviderConfig,
+  listModelProviderConfigs,
+  setDefaultModelProvider,
+  upsertModelProviderConfig,
+} from '#db/index.js';
+
+export const agentModule: ShipfoxModule = {
+  name: 'agent',
+  database: {db, migrationsPath},
+  routes,
+  e2eRoutes: [agentE2eRoutes],
+};

package/src/metrics/index.ts

@@ -0,0 +1 @@
+export {agentRuntimeConfigResolvedCount, modelProviderValidationCount} from './instance.js';

package/src/metrics/instance.ts

@@ -0,0 +1,18 @@
+import type {SupportedModelProviderId} from '@shipfox/api-agent-dto';
+import {instanceMetrics} from '@shipfox/node-opentelemetry';
+
+const meter = instanceMetrics.getMeter('agent');
+
+export const modelProviderValidationCount = meter.createCounter<{
+  model_provider: SupportedModelProviderId | 'custom';
+  outcome: 'succeeded' | 'failed';
+}>('model_provider_validation_attempted', {
+  description: 'Model provider credential test attempts by model provider and outcome',
+});
+
+export const agentRuntimeConfigResolvedCount = meter.createCounter<{
+  source: 'workspace' | 'instance';
+  outcome: 'resolved' | 'unavailable' | 'decryption_failed';
+}>('agent_runtime_config_resolved', {
+  description: 'Lease-scoped agent runtime credential resolution by source and outcome',
+});

package/src/presentation/dto/index.ts

@@ -0,0 +1,5 @@
+export {
+  toCustomModelProviderConfigDto,
+  toModelProviderConfigDto,
+  toModelProviderConfigResponseDto,
+} from './model-provider-config.js';

package/src/presentation/dto/model-provider-config.ts

@@ -0,0 +1,41 @@
+import type {
+  CustomModelProviderConfigDto,
+  ModelProviderConfigDto,
+  ModelProviderConfigResponseDto,
+} from '@shipfox/api-agent-dto';
+import type {ModelProviderConfig} from '#core/index.js';
+
+export function toModelProviderConfigDto(config: ModelProviderConfig): ModelProviderConfigDto {
+  return {
+    kind: 'builtin',
+    provider_id: config.providerId,
+    default_model: config.defaultModel,
+    created_at: config.createdAt.toISOString(),
+    updated_at: config.updatedAt.toISOString(),
+  };
+}
+
+export function toCustomModelProviderConfigDto(
+  config: ModelProviderConfig,
+): CustomModelProviderConfigDto {
+  return {
+    kind: 'custom',
+    provider_id: config.providerId,
+    display_name: config.displayName ?? config.providerId,
+    api: config.api ?? 'openai-responses',
+    base_url: config.baseUrl ?? '',
+    headers: config.headers ?? [],
+    secret_header_names: [...(config.secretHeaderNames ?? [])].sort(),
+    models: config.models ?? [],
+    default_model: config.defaultModel,
+    created_at: config.createdAt.toISOString(),
+    updated_at: config.updatedAt.toISOString(),
+  };
+}
+
+export function toModelProviderConfigResponseDto(
+  config: ModelProviderConfig,
+): ModelProviderConfigResponseDto {
+  if (config.kind === 'custom') return toCustomModelProviderConfigDto(config);
+  return toModelProviderConfigDto(config);
+}

package/src/presentation/e2eRoutes/create-model-provider.test.ts

@@ -0,0 +1,47 @@
+import {closeApp, createApp} from '@shipfox/node-fastify';
+import {agentE2eRoutes} from './index.js';
+
+describe('agent e2e routes', () => {
+  afterEach(async () => {
+    await closeApp();
+  });
+
+  it('rejects malformed workspace ids through route validation', async () => {
+    const app = await createApp({routes: [agentE2eRoutes], swagger: false});
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/agent/model-provider',
+      payload: {
+        workspace_id: 'not-a-uuid',
+        provider_id: 'anthropic',
+        api_key: 'sk-e2e-placeholder',
+        default_model: 'claude-opus-4-8',
+      },
+    });
+
+    expect(res.statusCode).toBe(400);
+    expect(res.json()).toMatchObject({code: 'validation-error'});
+  });
+
+  it('rejects default models outside the Anthropic catalog', async () => {
+    const app = await createApp({routes: [agentE2eRoutes], swagger: false});
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/agent/model-provider',
+      payload: {
+        workspace_id: crypto.randomUUID(),
+        provider_id: 'anthropic',
+        api_key: 'sk-e2e-placeholder',
+        default_model: 'missing-model',
+      },
+    });
+
+    expect(res.statusCode).toBe(400);
+    expect(res.json()).toMatchObject({
+      code: 'unsupported-model',
+      details: {default_model: 'missing-model'},
+    });
+  });
+});

package/src/presentation/e2eRoutes/create-model-provider.ts

@@ -0,0 +1,61 @@
+import {DEFAULT_AGENT_THINKING, getModelProviderEntry} from '@shipfox/api-agent-dto';
+import {setSecrets} from '@shipfox/api-secrets';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {agentSystemNamespace} from '#core/credential-fingerprints.js';
+import {listHarnessProviderModels} from '#core/harness/registry.js';
+import {upsertModelProviderConfig} from '#db/index.js';
+
+const createE2eModelProviderBodySchema = z.object({
+  workspace_id: z.string().uuid(),
+  provider_id: z.literal('anthropic'),
+  api_key: z.string().min(1),
+  default_model: z.string().min(1).optional(),
+  set_as_default: z.boolean().optional(),
+});
+
+const createE2eModelProviderResponseSchema = z.object({
+  provider_id: z.literal('anthropic'),
+});
+
+export const createE2eModelProviderRoute = defineRoute({
+  method: 'POST',
+  path: '/model-provider',
+  description: 'Create an Anthropic model provider config for E2E tests.',
+  schema: {
+    body: createE2eModelProviderBodySchema,
+    response: {201: createE2eModelProviderResponseSchema},
+  },
+  handler: async (request, reply) => {
+    const entry = getModelProviderEntry(request.body.provider_id);
+    if (entry === undefined || entry.default_model === null) {
+      throw new ClientError('Unsupported E2E model provider', 'unsupported-model-provider', {
+        status: 400,
+      });
+    }
+    const defaultModel = request.body.default_model ?? entry.default_model;
+    const supportedModels = listHarnessProviderModels('claude', request.body.provider_id);
+    if (!supportedModels.some((model) => model.id === defaultModel)) {
+      throw new ClientError('Unsupported Anthropic default model', 'unsupported-model', {
+        status: 400,
+        details: {default_model: defaultModel},
+      });
+    }
+
+    await setSecrets({
+      workspaceId: request.body.workspace_id,
+      namespace: agentSystemNamespace(request.body.provider_id),
+      values: {API_KEY: request.body.api_key},
+    });
+    await upsertModelProviderConfig({
+      workspaceId: request.body.workspace_id,
+      providerId: request.body.provider_id,
+      defaultModel,
+      defaultThinking: DEFAULT_AGENT_THINKING,
+      setAsDefault: request.body.set_as_default,
+    });
+
+    reply.code(201);
+    return {provider_id: request.body.provider_id};
+  },
+});

package/src/presentation/e2eRoutes/index.ts

@@ -0,0 +1,7 @@
+import type {RouteGroup} from '@shipfox/node-fastify';
+import {createE2eModelProviderRoute} from './create-model-provider.js';
+
+export const agentE2eRoutes: RouteGroup = {
+  prefix: '/agent',
+  routes: [createE2eModelProviderRoute],
+};

package/src/presentation/index.ts

@@ -0,0 +1 @@
+export {agentRoutes as routes} from './routes/index.js';

package/src/presentation/routes/create-custom-model-provider.ts

@@ -0,0 +1,45 @@
+import {
+  createCustomModelProviderBodySchema,
+  customModelProviderConfigDtoSchema,
+} from '@shipfox/api-agent-dto';
+import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
+import {defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {createCustomModelProviderConfig} from '#core/index.js';
+import {toCustomModelProviderConfigDto} from '#presentation/dto/index.js';
+import {translateModelProviderRouteError} from './errors.js';
+
+export const createCustomModelProviderRoute = defineRoute({
+  method: 'POST',
+  path: '/custom-model-providers',
+  description: 'Create a custom model provider configuration for a workspace',
+  schema: {
+    params: z.object({workspaceId: z.string().uuid()}),
+    body: createCustomModelProviderBodySchema,
+    response: {
+      200: customModelProviderConfigDtoSchema,
+    },
+  },
+  errorHandler: translateModelProviderRouteError,
+  handler: async (request, reply) => {
+    const {workspaceId} = request.params;
+    const abortController = new AbortController();
+    let responseFinished = false;
+    reply.raw.on('finish', () => {
+      responseFinished = true;
+    });
+    reply.raw.on('close', () => {
+      if (!responseFinished) abortController.abort();
+    });
+
+    requireWorkspaceAccess({request, workspaceId});
+
+    const config = await createCustomModelProviderConfig({
+      workspaceId,
+      body: request.body,
+      signal: abortController.signal,
+    });
+
+    return toCustomModelProviderConfigDto(config);
+  },
+});

package/src/presentation/routes/delete-model-provider-config.ts

@@ -0,0 +1,31 @@
+import {modelProviderRefSchema} from '@shipfox/api-agent-dto';
+import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {deleteModelProviderConfig} from '#core/index.js';
+
+export const deleteModelProviderConfigRoute = defineRoute({
+  method: 'DELETE',
+  path: '/model-providers/:providerId',
+  description: 'Delete a model provider configuration for a workspace',
+  schema: {
+    params: z.object({
+      workspaceId: z.string().uuid(),
+      providerId: modelProviderRefSchema,
+    }),
+    response: {
+      204: z.void(),
+    },
+  },
+  handler: async (request, reply) => {
+    const {workspaceId, providerId} = request.params;
+    requireWorkspaceAccess({request, workspaceId});
+
+    const deleted = await deleteModelProviderConfig({workspaceId, providerId});
+    if (!deleted) {
+      throw new ClientError('Model provider configuration not found', 'not-found', {status: 404});
+    }
+
+    reply.code(204);
+  },
+});

package/src/presentation/routes/discover-custom-model-provider-models-by-slug.ts

@@ -0,0 +1,42 @@
+import {
+  discoverCustomModelProviderModelsBySlugBodySchema,
+  discoverCustomModelProviderModelsResponseSchema,
+  modelProviderRefSchema,
+} from '@shipfox/api-agent-dto';
+import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
+import {defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {
+  discoverCustomModelProviderModels,
+  resolveCustomModelProviderDiscoveryParams,
+} from '#core/index.js';
+import {translateModelProviderRouteError} from './errors.js';
+
+export const discoverCustomModelProviderModelsBySlugRoute = defineRoute({
+  method: 'POST',
+  path: '/custom-model-providers/:slug/discover-models',
+  description: 'Discover models for a stored custom model provider configuration',
+  schema: {
+    params: z.object({
+      workspaceId: z.string().uuid(),
+      slug: modelProviderRefSchema,
+    }),
+    body: discoverCustomModelProviderModelsBySlugBodySchema,
+    response: {
+      200: discoverCustomModelProviderModelsResponseSchema,
+    },
+  },
+  errorHandler: translateModelProviderRouteError,
+  handler: async (request) => {
+    const {workspaceId, slug} = request.params;
+    requireWorkspaceAccess({request, workspaceId});
+
+    const discoveryParams = await resolveCustomModelProviderDiscoveryParams({
+      workspaceId,
+      providerId: slug,
+      body: request.body ?? {},
+    });
+
+    return await discoverCustomModelProviderModels(discoveryParams);
+  },
+});

package/src/presentation/routes/discover-custom-model-provider-models.ts

@@ -0,0 +1,29 @@
+import {
+  discoverCustomModelProviderModelsBodySchema,
+  discoverCustomModelProviderModelsResponseSchema,
+} from '@shipfox/api-agent-dto';
+import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
+import {defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {discoverCustomModelProviderModels} from '#core/index.js';
+import {translateModelProviderRouteError} from './errors.js';
+
+export const discoverCustomModelProviderModelsRoute = defineRoute({
+  method: 'POST',
+  path: '/custom-model-providers/discover-models',
+  description: 'Discover models exposed by a custom model provider endpoint',
+  schema: {
+    params: z.object({workspaceId: z.string().uuid()}),
+    body: discoverCustomModelProviderModelsBodySchema,
+    response: {
+      200: discoverCustomModelProviderModelsResponseSchema,
+    },
+  },
+  errorHandler: translateModelProviderRouteError,
+  handler: async (request) => {
+    const {workspaceId} = request.params;
+    requireWorkspaceAccess({request, workspaceId});
+
+    return await discoverCustomModelProviderModels(request.body);
+  },
+});

package/src/presentation/routes/errors.ts

@@ -0,0 +1,122 @@
+import {getModelProviderCredentialKeys} from '@shipfox/api-agent-dto';
+import {SecretValueTooLargeError, WorkspaceSecretCapExceededError} from '@shipfox/api-secrets';
+import {EgressDeniedError} from '@shipfox/node-egress-guard';
+import {ClientError} from '@shipfox/node-fastify';
+import {
+  CustomModelProviderConfigNotFoundError,
+  CustomModelProviderSlugCollisionError,
+  CustomModelProviderStoredSecretBaseUrlChangeError,
+  InvalidAgentModelError,
+  InvalidCredentialFieldsError,
+  InvalidCustomModelProviderHeaderKeepError,
+  ModelProviderConfigNotFoundError,
+  ModelProviderValidationError,
+  UnsupportedModelProviderError,
+} from '#core/index.js';
+
+export function translateModelProviderRouteError(error: unknown): never {
+  if (error instanceof ModelProviderValidationError) {
+    throw new ClientError(error.sanitizedMessage, 'provider-validation-failed', {
+      status: 422,
+      details: {
+        provider_id: error.providerId,
+        message: error.sanitizedMessage,
+      },
+    });
+  }
+
+  if (error instanceof EgressDeniedError) {
+    throw new ClientError('Egress denied', 'egress-denied', {
+      status: 400,
+      details: {
+        reason: error.reason,
+        target: error.target,
+      },
+    });
+  }
+
+  if (error instanceof CustomModelProviderSlugCollisionError) {
+    throw new ClientError('Custom model provider slug already exists', 'slug-collision', {
+      status: 409,
+      details: {provider_id: error.providerId},
+    });
+  }
+
+  if (error instanceof CustomModelProviderConfigNotFoundError) {
+    throw new ClientError('Custom model provider configuration not found', 'not-found', {
+      status: 404,
+      details: {provider_id: error.providerId},
+    });
+  }
+
+  if (error instanceof InvalidCustomModelProviderHeaderKeepError) {
+    throw new ClientError('Invalid kept secret header', 'invalid-header-keep', {
+      status: 422,
+      details: {provider_id: error.providerId, name: error.headerName},
+    });
+  }
+
+  if (error instanceof CustomModelProviderStoredSecretBaseUrlChangeError) {
+    throw new ClientError(
+      'Stored custom model provider secrets cannot be reused with a changed base URL',
+      'stored-secret-base-url-changed',
+      {
+        status: 422,
+        details: {provider_id: error.providerId},
+      },
+    );
+  }
+
+  if (error instanceof InvalidCredentialFieldsError) {
+    throw new ClientError('Invalid credential fields', 'invalid-credential-fields', {
+      status: 422,
+      details: {
+        provider_id: error.providerId,
+        expected_keys: getModelProviderCredentialKeys(error.providerId) ?? [],
+      },
+    });
+  }
+
+  if (error instanceof InvalidAgentModelError) {
+    throw new ClientError('Invalid agent model', 'invalid-agent-model', {
+      status: 422,
+      details: {
+        harness: error.harness,
+        provider_id: error.providerId,
+        model: error.model,
+      },
+    });
+  }
+
+  if (error instanceof UnsupportedModelProviderError) {
+    throw new ClientError('Provider is not supported', 'provider-unsupported', {
+      status: 422,
+      details: {provider_id: error.providerId},
+    });
+  }
+
+  if (error instanceof ModelProviderConfigNotFoundError) {
+    throw new ClientError('Provider is not configured', 'provider-not-configured', {
+      status: 422,
+      details: {
+        provider_id: error.providerId,
+      },
+    });
+  }
+
+  if (error instanceof WorkspaceSecretCapExceededError) {
+    throw new ClientError('Workspace secret cap exceeded', 'workspace-secret-cap-exceeded', {
+      status: 409,
+      details: {cap: error.cap},
+    });
+  }
+
+  if (error instanceof SecretValueTooLargeError) {
+    throw new ClientError(error.message, 'value-too-large', {
+      status: 400,
+      details: {max_bytes: error.maxBytes},
+    });
+  }
+
+  throw error;
+}

package/src/presentation/routes/index.ts

@@ -0,0 +1,37 @@
+import {AUTH_USER} from '@shipfox/api-auth-context';
+import type {RouteGroup} from '@shipfox/node-fastify';
+import {createCustomModelProviderRoute} from './create-custom-model-provider.js';
+import {deleteModelProviderConfigRoute} from './delete-model-provider-config.js';
+import {discoverCustomModelProviderModelsRoute} from './discover-custom-model-provider-models.js';
+import {discoverCustomModelProviderModelsBySlugRoute} from './discover-custom-model-provider-models-by-slug.js';
+import {listModelProviderCatalogRoute} from './list-model-provider-catalog.js';
+import {listModelProviderConfigsRoute} from './list-model-provider-configs.js';
+import {setDefaultHarnessRoute} from './set-default-harness.js';
+import {setDefaultModelProviderRoute} from './set-default-model-provider.js';
+import {updateCustomModelProviderRoute} from './update-custom-model-provider.js';
+import {updateModelProviderDefaultModelRoute} from './update-model-provider-default-model.js';
+import {upsertModelProviderConfigRoute} from './upsert-model-provider-config.js';
+
+export const agentRoutes: RouteGroup[] = [
+  {
+    prefix: '/workspaces/:workspaceId/agent',
+    auth: AUTH_USER,
+    routes: [
+      listModelProviderConfigsRoute,
+      createCustomModelProviderRoute,
+      discoverCustomModelProviderModelsRoute,
+      discoverCustomModelProviderModelsBySlugRoute,
+      updateCustomModelProviderRoute,
+      upsertModelProviderConfigRoute,
+      updateModelProviderDefaultModelRoute,
+      deleteModelProviderConfigRoute,
+      setDefaultHarnessRoute,
+      setDefaultModelProviderRoute,
+    ],
+  },
+  {
+    prefix: '/agent',
+    auth: AUTH_USER,
+    routes: [listModelProviderCatalogRoute],
+  },
+];

package/src/presentation/routes/list-model-provider-catalog.ts

@@ -0,0 +1,15 @@
+import {modelProviderCatalogResponseSchema} from '@shipfox/api-agent-dto';
+import {defineRoute} from '@shipfox/node-fastify';
+import {buildModelProviderCatalog} from '#core/index.js';
+
+export const listModelProviderCatalogRoute = defineRoute({
+  method: 'GET',
+  path: '/model-provider-catalog',
+  description: 'List available model providers and models',
+  schema: {
+    response: {
+      200: modelProviderCatalogResponseSchema,
+    },
+  },
+  handler: () => ({providers: buildModelProviderCatalog()}),
+});

package/src/presentation/routes/list-model-provider-configs.ts

@@ -0,0 +1,33 @@
+import {listModelProviderConfigsResponseSchema} from '@shipfox/api-agent-dto';
+import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
+import {defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {getAgentWorkspaceSettings, listModelProviderConfigs} from '#db/index.js';
+import {toModelProviderConfigResponseDto} from '#presentation/dto/index.js';
+
+export const listModelProviderConfigsRoute = defineRoute({
+  method: 'GET',
+  path: '/model-providers',
+  description: 'List model provider configurations for a workspace',
+  schema: {
+    params: z.object({workspaceId: z.string().uuid()}),
+    response: {
+      200: listModelProviderConfigsResponseSchema,
+    },
+  },
+  handler: async (request) => {
+    const {workspaceId} = request.params;
+    requireWorkspaceAccess({request, workspaceId});
+
+    const [configs, settings] = await Promise.all([
+      listModelProviderConfigs(workspaceId),
+      getAgentWorkspaceSettings(workspaceId),
+    ]);
+
+    return {
+      configs: configs.map(toModelProviderConfigResponseDto),
+      default_harness_id: settings?.defaultHarnessId ?? null,
+      default_provider_id: settings?.defaultProviderId ?? null,
+    };
+  },
+});