@cloudcli-ai/cloudcli 1.37.0 → 1.37.2

package/server/index.ts

@@ -9,7 +9,7 @@ import http from 'http';
 import express, { type NextFunction, type Request, type Response } from 'express';
 import cors from 'cors';
 
-import { AppError, findApplicationRoot, getModuleDirectory, terminalTextStyles } from '@/shared/utils.js';
+import { AppError, findApplicationRoot, getModuleDirectory, IS_PLATFORM, terminalTextStyles } from '@/shared/utils.js';
 import {
     closeSessionsWatcher,
     initializeSessionsWatcher,
@@ -50,7 +50,6 @@ import browserUseMcpRoutes from './modules/browser-use/browser-use-mcp.routes.js
 import { browserUseService } from './modules/browser-use/browser-use.service.js';
 import { initializeDatabase, sessionsDb } from './modules/database/index.js';
 import { configureWebPush } from './modules/notifications/index.js';
-import { IS_PLATFORM } from './constants/config.js';
 
 const __dirname = getModuleDirectory(import.meta.url);
 // The server source runs from /server, while the compiled output runs from /dist-server/server.

package/server/modules/agent/agent.module.ts

@@ -12,6 +12,7 @@ import {
   userDb,
 } from '@/modules/database/index.js';
 import { providerModelsService } from '@/modules/providers/index.js';
+import { IS_PLATFORM } from '@/shared/utils.js';
 
 import { createAgentRouter } from './agent.routes.js';
 
@@ -30,7 +31,7 @@ export function createAgentModule(externalDependencies: AgentExternalDependencie
     crypto,
     homeDirectory: os.homedir,
     spawnProcess: spawn,
-    platformMode: process.env.VITE_IS_PLATFORM === 'true',
+    platformMode: IS_PLATFORM,
     users: {
       getFirstUser: () => userDb.getFirstUser(),
     },

package/server/modules/auth/auth.middleware.ts

@@ -1,9 +1,9 @@
 // @ts-nocheck -- JWT request augmentation is narrowed by Auth route contracts.
 import jwt from 'jsonwebtoken';
 
-import { userDb, appConfigDb } from '../database/index.js';
+import { IS_PLATFORM } from '@/shared/utils.js';
 
-const IS_PLATFORM = process.env.VITE_IS_PLATFORM === 'true';
+import { userDb, appConfigDb } from '../database/index.js';
 
 // Use env var if set, otherwise auto-generate a unique secret per installation
 const JWT_SECRET = process.env.JWT_SECRET || appConfigDb.getOrCreateJwtSecret();

package/server/modules/browser-use/browser-use-runtime.ts

@@ -0,0 +1,10 @@
+import { IS_PLATFORM } from '@/shared/utils.js';
+
+/**
+ * Resolves the runtime label exposed by Browser Use status and session APIs.
+ * The Browser Use service and CLI environment-mode regression coverage consume
+ * this after the server or CLI entrypoint has completed environment bootstrapping.
+ */
+export function getBrowserUseRuntime(): 'cloud' | 'local' {
+  return IS_PLATFORM ? 'cloud' : 'local';
+}

package/server/modules/browser-use/browser-use.service.ts

@@ -11,15 +11,16 @@ import { appConfigDb } from '@/modules/database/index.js';
 import { providerMcpService } from '@/modules/providers/index.js';
 import { getModuleDirectory } from '@/shared/utils.js';
 
+import { getBrowserUseRuntime } from './browser-use-runtime.js';
+
 const require = createRequire(import.meta.url);
 const __dirname = getModuleDirectory(import.meta.url);
-const IS_PLATFORM = process.env.VITE_IS_PLATFORM === 'true';
 const MAX_SESSIONS_PER_OWNER = Number.parseInt(process.env.CLOUDCLI_BROWSER_USE_MAX_SESSIONS_PER_OWNER || '3', 10);
 const SESSION_TTL_MS = Number.parseInt(process.env.CLOUDCLI_BROWSER_USE_SESSION_TTL_MS || String(30 * 60 * 1000), 10);
 const BROWSER_USE_SETTINGS_KEY = 'browser_use_settings';
 const BROWSER_USE_MCP_TOKEN_KEY = 'browser_use_mcp_token';
 
-type BrowserUseRuntime = 'cloud' | 'local';
+type BrowserUseRuntime = ReturnType<typeof getBrowserUseRuntime>;
 type BrowserUseSessionStatus = 'ready' | 'stopped' | 'unavailable';
 
 type BrowserUseSession = {
@@ -85,10 +86,6 @@ const MCP_SERVER_NAME = 'cloudcli-browser';
 const LEGACY_MCP_SERVER_NAMES = ['cloudcli-browser-use'];
 const RUNTIME_READINESS_CACHE_TTL_MS = 30_000;
 
-function getRuntime(): BrowserUseRuntime {
-  return IS_PLATFORM ? 'cloud' : 'local';
-}
-
 function readSettings(): BrowserUseSettings {
   try {
     const raw = appConfigDb.get(BROWSER_USE_SETTINGS_KEY);
@@ -446,7 +443,7 @@ export const browserUseService = {
 
     return {
       enabled: settings.enabled,
-      runtime: getRuntime(),
+      runtime: getBrowserUseRuntime(),
       available,
       playwrightInstalled: readiness.playwrightInstalled,
       chromiumInstalled: readiness.chromiumInstalled,
@@ -515,7 +512,7 @@ export const browserUseService = {
       id: randomUUID(),
       ownerId: AGENT_OWNER_ID,
       createdBy: 'agent',
-      runtime: getRuntime(),
+      runtime: getBrowserUseRuntime(),
       status: 'unavailable',
       url: null,
       title: null,

package/server/modules/browser-use/index.ts

@@ -6,3 +6,6 @@
 export async function startBrowserUseMcp(): Promise<void> {
   await import('./browser-use-mcp.js');
 }
+
+// getBrowserUseRuntime: used by Browser Use services and environment-mode regression coverage.
+export { getBrowserUseRuntime } from './browser-use-runtime.js';

package/server/modules/cli/cli.module.ts

@@ -28,7 +28,6 @@ export function createCliApplication(): CliApplication {
     bugsUrl: packageMetadataJson.bugs?.url,
   };
   const fileSystem = {
-    readTextFile: (filePath: string) => fs.readFileSync(filePath, 'utf8'),
     pathExists: (filePath: string) => fs.existsSync(filePath),
     getFileStats: (filePath: string) => {
       const stats = fs.statSync(filePath);

package/server/modules/cli/cli.service.ts

@@ -77,27 +77,7 @@ function isNewerVersion(candidateVersion: string, currentVersion: string): boole
   return false;
 }
 
-function loadEnvironmentFile(dependencies: CliServiceDependencies): void {
-  try {
-    const environmentFile = dependencies.fileSystem.readTextFile(
-      path.join(dependencies.applicationRoot, '.env'),
-    );
-    for (const line of environmentFile.split('\n')) {
-      const trimmedLine = line.trim();
-      if (!trimmedLine || trimmedLine.startsWith('#')) continue;
-
-      const [key, ...valueParts] = trimmedLine.split('=');
-      if (key && valueParts.length > 0 && !dependencies.environment[key]) {
-        dependencies.environment[key] = valueParts.join('=').trim();
-      }
-    }
-  } catch {
-    // The repository-level .env file is optional for every CLI command.
-  }
-}
-
 function showStatus(dependencies: CliServiceDependencies): void {
-  loadEnvironmentFile(dependencies);
   const { environment, fileSystem, output } = dependencies;
   const databasePath = environment.DATABASE_PATH || dependencies.defaultDatabasePath;
   const databaseExists = fileSystem.pathExists(databasePath);

package/server/modules/cli/cli.ts

@@ -1,10 +1,16 @@
 #!/usr/bin/env node
 
-import { createCliApplication } from './index.js';
+// The CLI can reach shared environment constants through its composition root,
+// so finish the root environment bootstrap before loading that import graph.
+// eslint-disable-next-line boundaries/no-unknown
+import '../../load-env.js';
 
-const cliApplication = createCliApplication();
+async function runCli(): Promise<number> {
+  const { createCliApplication } = await import('./index.js');
+  return createCliApplication().run(process.argv.slice(2));
+}
 
-cliApplication.run(process.argv.slice(2)).then((exitCode) => {
+runCli().then((exitCode) => {
   process.exitCode = exitCode;
 }).catch((error: unknown) => {
   const message = error instanceof Error ? error.message : String(error);

package/server/modules/cli/tests/cli-environment-bootstrap.test.ts

@@ -0,0 +1,186 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { copyFile, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+type BootstrapResult = {
+  command: string | null;
+  environmentFileReads: number;
+  mode: string | null;
+  authNextCalled: boolean;
+  authStatus: number;
+  authenticatedUsername: string | null;
+  runtime: string;
+};
+
+const RESULT_PREFIX = '__CLOUDCLI_BOOTSTRAP_RESULT__';
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+const applicationRoot = path.resolve(testDirectory, '..', '..', '..', '..');
+
+function sourceModuleUrl(...segments: string[]): string {
+  return pathToFileURL(path.join(applicationRoot, ...segments)).href;
+}
+
+async function runCliBootstrapFixture(isPlatform: boolean): Promise<BootstrapResult> {
+  const fixtureRoot = await mkdtemp(path.join(os.tmpdir(), 'cloudcli-cli-bootstrap-'));
+  const fixtureServerDirectory = path.join(fixtureRoot, 'server');
+  const fixtureCliDirectory = path.join(fixtureServerDirectory, 'modules', 'cli');
+  const fixtureDatabasePath = path.join(fixtureRoot, 'auth.db');
+
+  try {
+    await mkdir(fixtureCliDirectory, { recursive: true });
+    await Promise.all([
+      copyFile(
+        path.join(applicationRoot, 'server', 'load-env.ts'),
+        path.join(fixtureServerDirectory, 'load-env.ts'),
+      ),
+      copyFile(
+        path.join(applicationRoot, 'server', 'modules', 'cli', 'cli.ts'),
+        path.join(fixtureCliDirectory, 'cli.ts'),
+      ),
+    ]);
+    await writeFile(
+      path.join(fixtureRoot, '.env'),
+      [
+        `VITE_IS_PLATFORM=${String(isPlatform)}`,
+        `DATABASE_PATH=${fixtureDatabasePath.replace(/\\/g, '/')}`,
+      ].join('\n'),
+      'utf8',
+    );
+
+    const fixtureIndexSource = `
+import { createCliService } from ${JSON.stringify(sourceModuleUrl('server', 'modules', 'cli', 'cli.service.ts'))};
+import { authenticateToken } from ${JSON.stringify(sourceModuleUrl('server', 'modules', 'auth', 'index.ts'))};
+import { getBrowserUseRuntime } from ${JSON.stringify(sourceModuleUrl('server', 'modules', 'browser-use', 'index.ts'))};
+import { closeConnection, initializeDatabase, userDb } from ${JSON.stringify(sourceModuleUrl('server', 'modules', 'database', 'index.ts'))};
+
+let environmentFileReads = 0;
+
+export function createCliApplication() {
+  const service = createCliService({
+    applicationRoot: ${JSON.stringify(fixtureRoot)},
+    defaultDatabasePath: ${JSON.stringify(fixtureDatabasePath)},
+    homeDirectory: ${JSON.stringify(fixtureRoot)},
+    packageMetadata: { version: '1.0.0' },
+    environment: process.env,
+    fileSystem: {
+      readTextFile: () => {
+        environmentFileReads += 1;
+        return '';
+      },
+      pathExists: () => false,
+      getFileStats: () => ({ size: 0, modifiedAt: new Date(0) }),
+    },
+    output: { log: () => undefined, error: () => undefined },
+    sandboxService: { execute: async () => 0 },
+    getLatestPackageVersion: async () => '1.0.0',
+    updateGlobalPackage: () => undefined,
+    startServer: async () => undefined,
+    startBrowserUseMcp: async () => undefined,
+  });
+
+  return {
+    async run(argumentsList: string[]) {
+      const exitCode = await service.run(argumentsList);
+      await initializeDatabase();
+      userDb.createUser('bootstrap-user', 'password-hash');
+
+      const request: any = { headers: {}, query: {} };
+      const response: any = {
+        statusCode: 200,
+        body: null,
+        headers: {},
+        setHeader(name: string, value: string) {
+          this.headers[name] = value;
+        },
+        status(statusCode: number) {
+          this.statusCode = statusCode;
+          return this;
+        },
+        json(body: unknown) {
+          this.body = body;
+          return this;
+        },
+      };
+      let authNextCalled = false;
+      await authenticateToken(request, response, () => {
+        authNextCalled = true;
+      });
+      const runtime = getBrowserUseRuntime();
+
+      console.log(${JSON.stringify(RESULT_PREFIX)} + JSON.stringify({
+        command: argumentsList[0] ?? null,
+        environmentFileReads,
+        mode: process.env.VITE_IS_PLATFORM ?? null,
+        authNextCalled,
+        authStatus: response.statusCode,
+        authenticatedUsername: request.user?.username ?? null,
+        runtime,
+      }));
+      closeConnection();
+      return exitCode;
+    },
+  };
+}
+`;
+    await writeFile(path.join(fixtureCliDirectory, 'index.ts'), fixtureIndexSource, 'utf8');
+
+    const childEnvironment = { ...process.env };
+    delete childEnvironment.VITE_IS_PLATFORM;
+    delete childEnvironment.DATABASE_PATH;
+    const stdout = execFileSync(
+      process.execPath,
+      [
+        path.join(applicationRoot, 'node_modules', 'tsx', 'dist', 'cli.mjs'),
+        '--tsconfig',
+        path.join(applicationRoot, 'server', 'tsconfig.json'),
+        path.join(fixtureCliDirectory, 'cli.ts'),
+        'status',
+      ],
+      {
+        cwd: applicationRoot,
+        encoding: 'utf8',
+        env: childEnvironment,
+        timeout: 30_000,
+      },
+    );
+    const resultLine = stdout
+      .split(/\r?\n/)
+      .find((line) => line.startsWith(RESULT_PREFIX));
+    assert.ok(resultLine, `Missing bootstrap result in child output:\n${stdout}`);
+    return JSON.parse(resultLine.slice(RESULT_PREFIX.length)) as BootstrapResult;
+  } finally {
+    await rm(fixtureRoot, { recursive: true, force: true });
+  }
+}
+
+test('CLI bootstrap selects Platform authentication and cloud runtime from .env', async () => {
+  const result = await runCliBootstrapFixture(true);
+
+  assert.deepEqual(result, {
+    command: 'status',
+    environmentFileReads: 0,
+    mode: 'true',
+    authNextCalled: true,
+    authStatus: 200,
+    authenticatedUsername: 'bootstrap-user',
+    runtime: 'cloud',
+  });
+});
+
+test('CLI bootstrap selects OSS authentication and local runtime from .env', async () => {
+  const result = await runCliBootstrapFixture(false);
+
+  assert.deepEqual(result, {
+    command: 'status',
+    environmentFileReads: 0,
+    mode: 'false',
+    authNextCalled: false,
+    authStatus: 401,
+    authenticatedUsername: null,
+    runtime: 'local',
+  });
+});

package/server/modules/cli/tests/cli.service.test.ts

@@ -26,9 +26,6 @@ function createHarness() {
     },
     environment,
     fileSystem: {
-      readTextFile: () => {
-        throw new Error('missing');
-      },
       pathExists: () => false,
       getFileStats: () => ({ size: 0, modifiedAt: new Date(0) }),
     },

package/server/modules/commands/commands.routes.ts

@@ -63,14 +63,15 @@ const resolveCommandModel = async (modelsService, provider, context) => {
 
 const executeModelsCommand = async (args, context, modelsService) => {
   const currentProvider = readModelProvider(context?.provider);
-  const result = await modelsService.getProviderModels(currentProvider);
-  const catalog = result.models;
+  const catalog = await modelsService.getProviderModels(currentProvider);
   const currentModel = await resolveCommandModel(modelsService, currentProvider, context);
   const availableModels = catalog.OPTIONS.map((option) => option.value);
   const availableOptions = catalog.OPTIONS.map((option) => ({
     value: option.value,
     label: option.label,
     description: option.description,
+    recordId: option.recordId,
+    isCustom: option.isCustom,
   }));
 
   return {
@@ -88,7 +89,6 @@ const executeModelsCommand = async (args, context, modelsService) => {
       availableModels,
       availableOptions,
       defaultModel: catalog.DEFAULT,
-      cache: result.cache,
       message: `Current model: ${currentModel}`,
     },
   };

package/server/modules/commands/tests/commands.test.ts

@@ -16,12 +16,8 @@ import { createCommandsRouter } from '../commands.routes.js';
 function createModelsService(sessionModels: Record<string, string> = {}) {
   return {
     getProviderModels: async () => ({
-      models: { OPTIONS: [{ value: 'default', label: 'Default' }], DEFAULT: 'default' },
-      cache: {
-        updatedAt: '2026-01-01T00:00:00.000Z',
-        expiresAt: '2026-01-02T00:00:00.000Z',
-        source: 'fresh' as const,
-      },
+      OPTIONS: [{ value: 'default', label: 'Default' }],
+      DEFAULT: 'default',
     }),
     getCurrentActiveModel: async () => ({ model: 'default' }),
     setSessionModel: () => null,
@@ -39,7 +35,6 @@ function createModelsService(sessionModels: Record<string, string> = {}) {
       };
     },
     resolveResumeModel: async () => undefined,
-    clearCache: () => undefined,
   };
 }
 

package/server/modules/database/index.ts

@@ -6,6 +6,8 @@ export { credentialsDb } from '@/modules/database/repositories/credentials.js';
 export { githubTokensDb } from '@/modules/database/repositories/github-tokens.js';
 export { notificationChannelEndpointsDb } from '@/modules/database/repositories/notification-channel-endpoints.js';
 export { notificationPreferencesDb } from '@/modules/database/repositories/notification-preferences.js';
+// providerModelsDb: used by Providers to persist user-managed custom model rows.
+export { providerModelsDb } from '@/modules/database/repositories/provider-models.js';
 // projectsDb: used by Projects, Worktrees, Git, WebSocket, and notification modules to persist and resolve project records.
 export { projectsDb } from '@/modules/database/repositories/projects.db.js';
 export { pushSubscriptionsDb } from '@/modules/database/repositories/push-subscriptions.js';

package/server/modules/database/migrations.ts

@@ -5,6 +5,7 @@ import {
   LAST_SCANNED_AT_SQL,
   NOTIFICATION_CHANNEL_ENDPOINTS_TABLE_SCHEMA_SQL,
   PROJECTS_TABLE_SCHEMA_SQL,
+  PROVIDER_MODELS_TABLE_SCHEMA_SQL,
   PUSH_SUBSCRIPTIONS_TABLE_SCHEMA_SQL,
   SESSIONS_TABLE_SCHEMA_SQL,
   USER_NOTIFICATION_PREFERENCES_TABLE_SCHEMA_SQL,
@@ -416,6 +417,19 @@ const addSessionModelColumn = (db: Database): void => {
   addColumnToTableIfNotExists(db, 'sessions', columnNames, 'model', 'TEXT');
 };
 
+/**
+ * Adds the `effort` column that records a session's reasoning-effort choice.
+ *
+ * Existing rows stay NULL so clients can continue falling back to their
+ * per-provider preference until the user selects an effort or sends a turn.
+ */
+const addSessionEffortColumn = (db: Database): void => {
+  const sessionsTableInfo = getTableInfo(db, 'sessions');
+  const columnNames = sessionsTableInfo.map((column) => column.name);
+
+  addColumnToTableIfNotExists(db, 'sessions', columnNames, 'effort', 'TEXT');
+};
+
 const ensureProjectsForSessionPaths = (db: Database): void => {
   if (!tableExists(db, 'sessions')) {
     return;
@@ -458,6 +472,11 @@ export const runMigrations = (db: Database) => {
     db.exec(NOTIFICATION_CHANNEL_ENDPOINTS_TABLE_SCHEMA_SQL);
     db.exec('CREATE INDEX IF NOT EXISTS idx_notification_channel_endpoints_user_channel ON notification_channel_endpoints(user_id, channel)');
     db.exec('CREATE INDEX IF NOT EXISTS idx_notification_channel_endpoints_enabled ON notification_channel_endpoints(enabled)');
+    db.exec(PROVIDER_MODELS_TABLE_SCHEMA_SQL);
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_provider_models_provider_order
+      ON provider_models(provider, sort_order, id)
+    `);
 
     db.exec(PROJECTS_TABLE_SCHEMA_SQL);
     rebuildProjectsTableWithPrimaryKeySchema(db);
@@ -467,6 +486,7 @@ export const runMigrations = (db: Database) => {
     migrateLegacySessionNames(db);
     addProviderSessionIdMapping(db);
     addSessionModelColumn(db);
+    addSessionEffortColumn(db);
     ensureProjectsForSessionPaths(db);
 
     db.exec('CREATE INDEX IF NOT EXISTS idx_session_ids_lookup ON sessions(session_id)');

package/server/modules/database/repositories/provider-models.ts

@@ -0,0 +1,168 @@
+import { getConnection } from '@/modules/database/connection.js';
+import type {
+  CustomProviderModelInput,
+  CustomProviderModelRecord,
+  LLMProvider,
+} from '@/shared/types.js';
+
+type CustomProviderModelRow = {
+  id: number;
+  provider: LLMProvider;
+  model_id: string;
+  model_name: string;
+  sort_order: number;
+};
+
+const toCustomProviderModelRecord = (
+  row: CustomProviderModelRow,
+): CustomProviderModelRecord => ({
+  recordId: row.id,
+  provider: row.provider,
+  modelId: row.model_id,
+  model: row.model_name,
+  sortOrder: row.sort_order,
+});
+
+const readCustomProviderModelRow = (
+  provider: LLMProvider,
+  recordId: number,
+): CustomProviderModelRow | null => {
+  const row = getConnection().prepare(`
+    SELECT id, provider, model_id, model_name, sort_order
+    FROM provider_models
+    WHERE provider = ? AND id = ?
+  `).get(provider, recordId) as CustomProviderModelRow | undefined;
+
+  return row ?? null;
+};
+
+/**
+ * Custom provider-model persistence API consumed by the Providers module.
+ *
+ * Every row in this repository is user-created. Predefined models are owned by
+ * provider adapters and never enter this table. Model-id changes are propagated
+ * to stored sessions, while deletion replaces affected session selections with
+ * the predefined default supplied by the Providers service.
+ */
+export const providerModelsDb = {
+  listCustomProviderModels(provider: LLMProvider): CustomProviderModelRecord[] {
+    const rows = getConnection().prepare(`
+      SELECT id, provider, model_id, model_name, sort_order
+      FROM provider_models
+      WHERE provider = ?
+      ORDER BY sort_order ASC, lower(model_name) ASC, id ASC
+    `).all(provider) as CustomProviderModelRow[];
+
+    return rows.map(toCustomProviderModelRecord);
+  },
+
+  getCustomProviderModel(
+    provider: LLMProvider,
+    recordId: number,
+  ): CustomProviderModelRecord | null {
+    const row = readCustomProviderModelRow(provider, recordId);
+    return row ? toCustomProviderModelRecord(row) : null;
+  },
+
+  findCustomProviderModelByModelId(
+    provider: LLMProvider,
+    modelId: string,
+  ): CustomProviderModelRecord | null {
+    const row = getConnection().prepare(`
+      SELECT id, provider, model_id, model_name, sort_order
+      FROM provider_models
+      WHERE provider = ? AND model_id = ?
+    `).get(provider, modelId) as CustomProviderModelRow | undefined;
+
+    return row ? toCustomProviderModelRecord(row) : null;
+  },
+
+  createCustomProviderModel(
+    provider: LLMProvider,
+    input: CustomProviderModelInput,
+  ): CustomProviderModelRecord {
+    const db = getConnection();
+    const nextOrder = db.prepare(`
+      SELECT COALESCE(MAX(sort_order), -1) + 1 AS next_order
+      FROM provider_models
+      WHERE provider = ?
+    `).get(provider) as { next_order: number };
+
+    const result = db.prepare(`
+      INSERT INTO provider_models (provider, model_id, model_name, sort_order)
+      VALUES (?, ?, ?, ?)
+    `).run(provider, input.id, input.model, nextOrder.next_order);
+
+    const row = readCustomProviderModelRow(provider, Number(result.lastInsertRowid));
+    if (!row) {
+      throw new Error('Created provider model could not be read back.');
+    }
+
+    return toCustomProviderModelRecord(row);
+  },
+
+  updateCustomProviderModel(
+    provider: LLMProvider,
+    recordId: number,
+    input: CustomProviderModelInput,
+  ): CustomProviderModelRecord | null {
+    const db = getConnection();
+    const update = db.transaction(() => {
+      const previous = readCustomProviderModelRow(provider, recordId);
+      if (!previous) {
+        return null;
+      }
+
+      db.prepare(`
+        UPDATE provider_models
+        SET model_id = ?, model_name = ?, updated_at = CURRENT_TIMESTAMP
+        WHERE provider = ? AND id = ?
+      `).run(input.id, input.model, provider, recordId);
+
+      if (previous.model_id !== input.id) {
+        db.prepare(`
+          UPDATE sessions
+          SET model = ?, updated_at = CURRENT_TIMESTAMP
+          WHERE provider = ? AND model = ?
+        `).run(input.id, provider, previous.model_id);
+      }
+
+      return readCustomProviderModelRow(provider, recordId);
+    });
+
+    const row = update();
+    return row ? toCustomProviderModelRecord(row) : null;
+  },
+
+  deleteCustomProviderModel(
+    provider: LLMProvider,
+    recordId: number,
+    fallbackModelId: string,
+  ): CustomProviderModelRecord | null {
+    const db = getConnection();
+    const remove = db.transaction(() => {
+      const row = readCustomProviderModelRow(provider, recordId);
+      if (!row) {
+        return null;
+      }
+
+      // The effort is cleared alongside the model because it was chosen for the
+      // deleted model; replaced sessions resume on the fallback model's default.
+      db.prepare(`
+        UPDATE sessions
+        SET model = ?, effort = NULL, updated_at = CURRENT_TIMESTAMP
+        WHERE provider = ? AND model = ?
+      `).run(fallbackModelId, provider, row.model_id);
+
+      db.prepare(`
+        DELETE FROM provider_models
+        WHERE provider = ? AND id = ?
+      `).run(provider, recordId);
+
+      return row;
+    });
+
+    const row = remove();
+    return row ? toCustomProviderModelRecord(row) : null;
+  },
+};