@shipfox/api-agent 2.0.0

package/src/db/agent-workspace-settings.ts

@@ -0,0 +1,92 @@
+import type {Harness, ModelProviderRef} from '@shipfox/api-agent-dto';
+import {and, eq, sql} from 'drizzle-orm';
+import type {AgentWorkspaceSettings} from '#core/entities/agent-workspace-settings.js';
+import {ModelProviderConfigNotFoundError} from '#core/errors.js';
+import {db} from './db.js';
+import {
+  agentWorkspaceSettings,
+  toAgentWorkspaceSettings,
+} from './schema/agent-workspace-settings.js';
+import {modelProviderConfigs} from './schema/model-provider-configs.js';
+
+export async function getAgentWorkspaceSettings(
+  workspaceId: string,
+): Promise<AgentWorkspaceSettings | undefined> {
+  const rows = await db()
+    .select()
+    .from(agentWorkspaceSettings)
+    .where(eq(agentWorkspaceSettings.workspaceId, workspaceId))
+    .limit(1);
+
+  const row = rows[0];
+  if (!row) return undefined;
+  return toAgentWorkspaceSettings(row);
+}
+
+export async function setDefaultModelProvider(params: {
+  workspaceId: string;
+  providerId: ModelProviderRef | null;
+}): Promise<AgentWorkspaceSettings> {
+  return await db().transaction(async (tx) => {
+    if (params.providerId !== null) {
+      const existingRows = await tx
+        .select({id: modelProviderConfigs.id})
+        .from(modelProviderConfigs)
+        .where(
+          and(
+            eq(modelProviderConfigs.workspaceId, params.workspaceId),
+            eq(modelProviderConfigs.providerId, params.providerId),
+          ),
+        )
+        .limit(1)
+        .for('update');
+
+      if (!existingRows[0]) {
+        throw new ModelProviderConfigNotFoundError(params.workspaceId, params.providerId);
+      }
+    }
+
+    const rows = await tx
+      .insert(agentWorkspaceSettings)
+      .values({
+        workspaceId: params.workspaceId,
+        defaultProviderId: params.providerId,
+      })
+      .onConflictDoUpdate({
+        target: agentWorkspaceSettings.workspaceId,
+        set: {
+          defaultProviderId: params.providerId,
+          updatedAt: sql`NOW()`,
+        },
+      })
+      .returning();
+
+    const row = rows[0];
+    if (!row) throw new Error('Upsert returned no rows');
+    return toAgentWorkspaceSettings(row);
+  });
+}
+
+export async function setDefaultHarness(params: {
+  workspaceId: string;
+  harnessId: Harness;
+}): Promise<AgentWorkspaceSettings> {
+  const rows = await db()
+    .insert(agentWorkspaceSettings)
+    .values({
+      workspaceId: params.workspaceId,
+      defaultHarnessId: params.harnessId,
+    })
+    .onConflictDoUpdate({
+      target: agentWorkspaceSettings.workspaceId,
+      set: {
+        defaultHarnessId: params.harnessId,
+        updatedAt: sql`NOW()`,
+      },
+    })
+    .returning();
+
+  const row = rows[0];
+  if (!row) throw new Error('Upsert returned no rows');
+  return toAgentWorkspaceSettings(row);
+}

package/src/db/db.ts

@@ -0,0 +1,20 @@
+import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';
+import {pgClient} from '@shipfox/node-postgres';
+import {agentWorkspaceSettings} from './schema/agent-workspace-settings.js';
+import {modelProviderConfigs} from './schema/model-provider-configs.js';
+
+export const schema = {
+  modelProviderConfigs,
+  agentWorkspaceSettings,
+};
+
+let _db: NodePgDatabase<typeof schema> | undefined;
+
+export function db() {
+  if (!_db) _db = drizzle(pgClient(), {schema});
+  return _db;
+}
+
+export function closeDb(): void {
+  _db = undefined;
+}

package/src/db/index.ts

@@ -0,0 +1,29 @@
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+export {
+  type AgentWorkspaceDefaultsSnapshot,
+  getAgentWorkspaceDefaultsSnapshot,
+} from './agent-defaults-snapshot.js';
+export {
+  getAgentWorkspaceSettings,
+  setDefaultHarness,
+  setDefaultModelProvider,
+} from './agent-workspace-settings.js';
+export {closeDb, db, schema} from './db.js';
+export type {
+  InsertCustomModelProviderConfigParams,
+  UpsertModelProviderConfigParams,
+} from './model-provider-configs.js';
+export {
+  deleteModelProviderConfig,
+  getModelProviderConfig,
+  insertCustomModelProviderConfig,
+  listModelProviderConfigs,
+  updateModelProviderDefaultModel,
+  upsertModelProviderConfig,
+} from './model-provider-configs.js';
+export {agentWorkspaceSettings} from './schema/agent-workspace-settings.js';
+export {modelProviderConfigs} from './schema/model-provider-configs.js';
+
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');

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

@@ -0,0 +1,281 @@
+import crypto from 'node:crypto';
+import type {
+  AgentThinking,
+  ModelProviderRef,
+  SupportedModelProviderId,
+} from '@shipfox/api-agent-dto';
+import {
+  db,
+  deleteModelProviderConfig,
+  getAgentWorkspaceSettings,
+  getModelProviderConfig,
+  listModelProviderConfigs,
+  setDefaultModelProvider,
+  type UpsertModelProviderConfigParams,
+  updateModelProviderDefaultModel,
+  upsertModelProviderConfig,
+} from '#db/index.js';
+import {modelProviderConfigs} from './schema/model-provider-configs.js';
+
+describe('model provider configs', () => {
+  let workspaceId: string;
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+  });
+
+  it('persists a provider config for a workspace provider pair', async () => {
+    const params = createModelProviderConfigParams({workspaceId, providerId: 'anthropic'});
+
+    const created = await upsertModelProviderConfig(params);
+
+    const found = await getModelProviderConfig({workspaceId, providerId: 'anthropic'});
+    expect(found).toEqual(created);
+    expect(found).toMatchObject({
+      workspaceId,
+      providerId: 'anthropic',
+      defaultModel: 'claude-opus-4-8',
+      defaultThinking: 'high',
+      kind: 'builtin',
+      displayName: null,
+      api: null,
+      baseUrl: null,
+      headers: null,
+      models: null,
+      requiresApiKey: false,
+    });
+    expect(found?.createdAt).toBeInstanceOf(Date);
+    expect(found?.updatedAt).toBeInstanceOf(Date);
+  });
+
+  it('updates the existing config for the same workspace provider pair', async () => {
+    await upsertModelProviderConfig(
+      createModelProviderConfigParams({workspaceId, providerId: 'openai'}),
+    );
+
+    const updated = await upsertModelProviderConfig(
+      createModelProviderConfigParams({
+        workspaceId,
+        providerId: 'openai',
+        defaultModel: 'gpt-5.5-pro',
+        defaultThinking: 'medium',
+      }),
+    );
+
+    const configs = await listModelProviderConfigs(workspaceId);
+    expect(configs).toHaveLength(1);
+    expect(configs[0]).toEqual(updated);
+    expect(configs[0]).toMatchObject({
+      defaultThinking: 'medium',
+    });
+  });
+
+  it('lists only configs for the requested workspace', async () => {
+    const otherWorkspaceId = crypto.randomUUID();
+    await upsertModelProviderConfig(
+      createModelProviderConfigParams({workspaceId, providerId: 'openai'}),
+    );
+    await upsertModelProviderConfig(
+      createModelProviderConfigParams({workspaceId, providerId: 'anthropic'}),
+    );
+    await upsertModelProviderConfig(
+      createModelProviderConfigParams({workspaceId: otherWorkspaceId, providerId: 'google'}),
+    );
+
+    const configs = await listModelProviderConfigs(workspaceId);
+
+    expect(configs.map((config) => config.providerId)).toEqual(['anthropic', 'openai']);
+  });
+
+  it('updates only the provider default model', async () => {
+    const created = await upsertModelProviderConfig(
+      createModelProviderConfigParams({
+        workspaceId,
+        providerId: 'anthropic',
+        defaultModel: 'claude-opus-4-8',
+      }),
+    );
+
+    const updated = await updateModelProviderDefaultModel({
+      workspaceId,
+      providerId: 'anthropic',
+      defaultModel: 'claude-haiku-4-5',
+    });
+
+    expect(updated).toMatchObject({
+      defaultModel: 'claude-haiku-4-5',
+      defaultThinking: created.defaultThinking,
+    });
+  });
+
+  it('returns undefined when updating a missing provider default model', async () => {
+    const updated = await updateModelProviderDefaultModel({
+      workspaceId,
+      providerId: 'anthropic',
+      defaultModel: null,
+    });
+
+    expect(updated).toBeUndefined();
+  });
+
+  it('hard-deletes a provider config', async () => {
+    await upsertModelProviderConfig(
+      createModelProviderConfigParams({workspaceId, providerId: 'anthropic'}),
+    );
+
+    const deleted = await deleteModelProviderConfig({workspaceId, providerId: 'anthropic'});
+
+    const found = await getModelProviderConfig({workspaceId, providerId: 'anthropic'});
+    expect(deleted).toBe(true);
+    expect(found).toBeUndefined();
+  });
+
+  it('returns false when deleting a missing provider config', async () => {
+    const deleted = await deleteModelProviderConfig({workspaceId, providerId: 'anthropic'});
+
+    expect(deleted).toBe(false);
+  });
+
+  it('clears the workspace default when the default provider config is deleted', async () => {
+    await upsertModelProviderConfig(
+      createModelProviderConfigParams({workspaceId, providerId: 'anthropic'}),
+    );
+    await setDefaultModelProvider({workspaceId, providerId: 'anthropic'});
+
+    await deleteModelProviderConfig({workspaceId, providerId: 'anthropic'});
+
+    const settings = await getAgentWorkspaceSettings(workspaceId);
+    expect(settings?.defaultProviderId).toBeNull();
+  });
+
+  it('keeps the workspace default when a non-default provider config is deleted', async () => {
+    await upsertModelProviderConfig(
+      createModelProviderConfigParams({workspaceId, providerId: 'anthropic'}),
+    );
+    await upsertModelProviderConfig(
+      createModelProviderConfigParams({workspaceId, providerId: 'openai'}),
+    );
+    await setDefaultModelProvider({workspaceId, providerId: 'anthropic'});
+
+    await deleteModelProviderConfig({workspaceId, providerId: 'openai'});
+
+    const settings = await getAgentWorkspaceSettings(workspaceId);
+    expect(settings?.defaultProviderId).toBe('anthropic');
+  });
+
+  it('round-trips a custom model provider row without storing secret headers in plaintext headers', async () => {
+    const created = await upsertModelProviderConfig({
+      workspaceId,
+      providerId: 'local-vllm',
+      kind: 'custom',
+      displayName: 'Local vLLM',
+      api: 'openai-responses',
+      baseUrl: 'https://llm.example.test/v1',
+      headers: [{name: 'x-region', value: 'local'}],
+      secretHeaderNames: ['authorization'],
+      models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+      requiresApiKey: true,
+      defaultModel: 'llama-3.1',
+      defaultThinking: 'high',
+    });
+
+    const found = await getModelProviderConfig({workspaceId, providerId: 'local-vllm'});
+
+    expect(found).toEqual(created);
+    expect(found).toMatchObject({
+      workspaceId,
+      providerId: 'local-vllm',
+      kind: 'custom',
+      displayName: 'Local vLLM',
+      api: 'openai-responses',
+      baseUrl: 'https://llm.example.test/v1',
+      headers: [{name: 'x-region', value: 'local'}],
+      secretHeaderNames: ['authorization'],
+      models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+      requiresApiKey: true,
+      defaultModel: 'llama-3.1',
+    });
+    expect(found?.headers).not.toContainEqual({
+      name: 'authorization',
+      value: 'Bearer header-secret',
+    });
+  });
+
+  it('does not clobber custom columns when a later upsert omits them', async () => {
+    await upsertModelProviderConfig({
+      workspaceId,
+      providerId: 'local-vllm',
+      kind: 'custom',
+      displayName: 'Local vLLM',
+      api: 'openai-responses',
+      baseUrl: 'https://llm.example.test/v1',
+      headers: [{name: 'x-region', value: 'local'}],
+      secretHeaderNames: ['authorization'],
+      models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+      requiresApiKey: true,
+      defaultModel: 'llama-3.1',
+      defaultThinking: 'high',
+    });
+
+    const updated = await upsertModelProviderConfig({
+      workspaceId,
+      providerId: 'local-vllm',
+      defaultModel: null,
+      defaultThinking: 'medium',
+    });
+
+    expect(updated).toMatchObject({
+      kind: 'custom',
+      displayName: 'Local vLLM',
+      api: 'openai-responses',
+      baseUrl: 'https://llm.example.test/v1',
+      headers: [{name: 'x-region', value: 'local'}],
+      secretHeaderNames: ['authorization'],
+      models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+      requiresApiKey: true,
+      defaultModel: null,
+      defaultThinking: 'medium',
+    });
+  });
+
+  it('keeps custom columns null for built-in rows', async () => {
+    const created = await upsertModelProviderConfig(
+      createModelProviderConfigParams({workspaceId, providerId: 'anthropic'}),
+    );
+
+    expect(created).toMatchObject({
+      kind: 'builtin',
+      displayName: null,
+      api: null,
+      baseUrl: null,
+      headers: null,
+      models: null,
+    });
+  });
+
+  it('rejects custom rows missing required custom fields', async () => {
+    const insert = db().insert(modelProviderConfigs).values({
+      workspaceId,
+      providerId: 'broken-custom',
+      kind: 'custom',
+      defaultModel: null,
+      defaultThinking: 'high',
+    });
+
+    await expect(insert).rejects.toThrow();
+  });
+});
+
+function createModelProviderConfigParams(params: {
+  workspaceId: string;
+  providerId: SupportedModelProviderId | ModelProviderRef;
+  defaultModel?: string | undefined;
+  defaultThinking?: AgentThinking | undefined;
+}): UpsertModelProviderConfigParams {
+  return {
+    workspaceId: params.workspaceId,
+    providerId: params.providerId,
+    defaultModel: params.defaultModel ?? 'claude-opus-4-8',
+    defaultThinking: params.defaultThinking ?? 'high',
+  };
+}

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

@@ -0,0 +1,230 @@
+import type {
+  AgentThinking,
+  CustomAgentModelDto,
+  CustomModelProviderHeaderDto,
+  ModelProviderApi,
+  ModelProviderRef,
+} from '@shipfox/api-agent-dto';
+import {and, eq, sql} from 'drizzle-orm';
+import type {ModelProviderConfig} from '#core/entities/model-provider-config.js';
+import {db} from './db.js';
+import {agentWorkspaceSettings} from './schema/agent-workspace-settings.js';
+import {modelProviderConfigs, toModelProviderConfig} from './schema/model-provider-configs.js';
+
+export interface UpsertModelProviderConfigParams {
+  workspaceId: string;
+  providerId: ModelProviderRef;
+  kind?: 'builtin' | 'custom' | undefined;
+  displayName?: string | null | undefined;
+  api?: ModelProviderApi | null | undefined;
+  baseUrl?: string | null | undefined;
+  headers?: CustomModelProviderHeaderDto[] | null | undefined;
+  secretHeaderNames?: string[] | null | undefined;
+  models?: CustomAgentModelDto[] | null | undefined;
+  requiresApiKey?: boolean | undefined;
+  defaultModel: string | null;
+  defaultThinking: AgentThinking;
+  setAsDefault?: boolean | undefined;
+}
+
+export type InsertCustomModelProviderConfigParams = Omit<
+  UpsertModelProviderConfigParams,
+  'kind' | 'requiresApiKey'
+> & {kind: 'custom'; requiresApiKey: boolean};
+
+export async function insertCustomModelProviderConfig(
+  params: InsertCustomModelProviderConfigParams,
+): Promise<ModelProviderConfig | undefined> {
+  return await db().transaction(async (tx) => {
+    const rows = await tx
+      .insert(modelProviderConfigs)
+      .values({
+        workspaceId: params.workspaceId,
+        providerId: params.providerId,
+        kind: params.kind,
+        displayName: params.displayName,
+        api: params.api,
+        baseUrl: params.baseUrl,
+        headers: params.headers,
+        secretHeaderNames: params.secretHeaderNames,
+        models: params.models,
+        requiresApiKey: params.requiresApiKey,
+        defaultModel: params.defaultModel,
+        defaultThinking: params.defaultThinking,
+      })
+      .onConflictDoNothing({
+        target: [modelProviderConfigs.workspaceId, modelProviderConfigs.providerId],
+      })
+      .returning();
+
+    const row = rows[0];
+    if (!row) return undefined;
+
+    if (params.setAsDefault) {
+      await tx
+        .insert(agentWorkspaceSettings)
+        .values({
+          workspaceId: params.workspaceId,
+          defaultProviderId: params.providerId,
+        })
+        .onConflictDoUpdate({
+          target: agentWorkspaceSettings.workspaceId,
+          set: {
+            defaultProviderId: params.providerId,
+            updatedAt: sql`NOW()`,
+          },
+        });
+    }
+
+    return toModelProviderConfig(row);
+  });
+}
+
+export async function upsertModelProviderConfig(
+  params: UpsertModelProviderConfigParams,
+): Promise<ModelProviderConfig> {
+  return await db().transaction(async (tx) => {
+    const rows = await tx
+      .insert(modelProviderConfigs)
+      .values({
+        workspaceId: params.workspaceId,
+        providerId: params.providerId,
+        ...(params.kind !== undefined ? {kind: params.kind} : {}),
+        ...(params.displayName !== undefined ? {displayName: params.displayName} : {}),
+        ...(params.api !== undefined ? {api: params.api} : {}),
+        ...(params.baseUrl !== undefined ? {baseUrl: params.baseUrl} : {}),
+        ...(params.headers !== undefined ? {headers: params.headers} : {}),
+        ...(params.secretHeaderNames !== undefined
+          ? {secretHeaderNames: params.secretHeaderNames}
+          : {}),
+        ...(params.models !== undefined ? {models: params.models} : {}),
+        ...(params.requiresApiKey !== undefined ? {requiresApiKey: params.requiresApiKey} : {}),
+        defaultModel: params.defaultModel,
+        defaultThinking: params.defaultThinking,
+      })
+      .onConflictDoUpdate({
+        target: [modelProviderConfigs.workspaceId, modelProviderConfigs.providerId],
+        set: {
+          ...(params.kind !== undefined ? {kind: params.kind} : {}),
+          ...(params.displayName !== undefined ? {displayName: params.displayName} : {}),
+          ...(params.api !== undefined ? {api: params.api} : {}),
+          ...(params.baseUrl !== undefined ? {baseUrl: params.baseUrl} : {}),
+          ...(params.headers !== undefined ? {headers: params.headers} : {}),
+          ...(params.secretHeaderNames !== undefined
+            ? {secretHeaderNames: params.secretHeaderNames}
+            : {}),
+          ...(params.models !== undefined ? {models: params.models} : {}),
+          ...(params.requiresApiKey !== undefined ? {requiresApiKey: params.requiresApiKey} : {}),
+          defaultModel: params.defaultModel,
+          defaultThinking: params.defaultThinking,
+          updatedAt: sql`NOW()`,
+        },
+      })
+      .returning();
+
+    const row = rows[0];
+    if (!row) throw new Error('Upsert returned no rows');
+
+    if (params.setAsDefault) {
+      await tx
+        .insert(agentWorkspaceSettings)
+        .values({
+          workspaceId: params.workspaceId,
+          defaultProviderId: params.providerId,
+        })
+        .onConflictDoUpdate({
+          target: agentWorkspaceSettings.workspaceId,
+          set: {
+            defaultProviderId: params.providerId,
+            updatedAt: sql`NOW()`,
+          },
+        });
+    }
+
+    return toModelProviderConfig(row);
+  });
+}
+
+export async function getModelProviderConfig(params: {
+  workspaceId: string;
+  providerId: ModelProviderRef;
+}): Promise<ModelProviderConfig | undefined> {
+  const rows = await db()
+    .select()
+    .from(modelProviderConfigs)
+    .where(
+      and(
+        eq(modelProviderConfigs.workspaceId, params.workspaceId),
+        eq(modelProviderConfigs.providerId, params.providerId),
+      ),
+    )
+    .limit(1);
+
+  const row = rows[0];
+  if (!row) return undefined;
+  return toModelProviderConfig(row);
+}
+
+export async function updateModelProviderDefaultModel(params: {
+  workspaceId: string;
+  providerId: ModelProviderRef;
+  defaultModel: string | null;
+}): Promise<ModelProviderConfig | undefined> {
+  const rows = await db()
+    .update(modelProviderConfigs)
+    .set({defaultModel: params.defaultModel, updatedAt: sql`NOW()`})
+    .where(
+      and(
+        eq(modelProviderConfigs.workspaceId, params.workspaceId),
+        eq(modelProviderConfigs.providerId, params.providerId),
+      ),
+    )
+    .returning();
+
+  const row = rows[0];
+  if (!row) return undefined;
+  return toModelProviderConfig(row);
+}
+
+export async function listModelProviderConfigs(
+  workspaceId: string,
+): Promise<ModelProviderConfig[]> {
+  const rows = await db()
+    .select()
+    .from(modelProviderConfigs)
+    .where(eq(modelProviderConfigs.workspaceId, workspaceId))
+    .orderBy(modelProviderConfigs.providerId);
+
+  return rows.map(toModelProviderConfig);
+}
+
+export async function deleteModelProviderConfig(params: {
+  workspaceId: string;
+  providerId: ModelProviderRef;
+}): Promise<boolean> {
+  return await db().transaction(async (tx) => {
+    const deleted = await tx
+      .delete(modelProviderConfigs)
+      .where(
+        and(
+          eq(modelProviderConfigs.workspaceId, params.workspaceId),
+          eq(modelProviderConfigs.providerId, params.providerId),
+        ),
+      )
+      .returning({id: modelProviderConfigs.id});
+
+    if (deleted.length === 0) return false;
+
+    await tx
+      .update(agentWorkspaceSettings)
+      .set({defaultProviderId: null, updatedAt: sql`NOW()`})
+      .where(
+        and(
+          eq(agentWorkspaceSettings.workspaceId, params.workspaceId),
+          eq(agentWorkspaceSettings.defaultProviderId, params.providerId),
+        ),
+      );
+
+    return true;
+  });
+}

package/src/db/schema/agent-workspace-settings.ts

@@ -0,0 +1,27 @@
+import {harnessSchema, type ModelProviderRef} from '@shipfox/api-agent-dto';
+import {text, timestamp, uuid} from 'drizzle-orm/pg-core';
+import type {AgentWorkspaceSettings} from '#core/entities/agent-workspace-settings.js';
+import {pgTable} from './common.js';
+
+export const agentWorkspaceSettings = pgTable('workspace_settings', {
+  workspaceId: uuid('workspace_id').primaryKey(),
+  defaultProviderId: text('default_provider_id'),
+  defaultHarnessId: text('default_harness_id'),
+  createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
+});
+
+export type AgentWorkspaceSettingsDb = typeof agentWorkspaceSettings.$inferSelect;
+export type AgentWorkspaceSettingsCreateDb = typeof agentWorkspaceSettings.$inferInsert;
+
+export function toAgentWorkspaceSettings(row: AgentWorkspaceSettingsDb): AgentWorkspaceSettings {
+  const parsedHarness = harnessSchema.safeParse(row.defaultHarnessId);
+
+  return {
+    workspaceId: row.workspaceId,
+    defaultProviderId: row.defaultProviderId as ModelProviderRef | null,
+    defaultHarnessId: parsedHarness.success ? parsedHarness.data : null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}

package/src/db/schema/common.ts

@@ -0,0 +1,3 @@
+import {pgTableCreator} from 'drizzle-orm/pg-core';
+
+export const pgTable = pgTableCreator((name) => `agent_${name}`);