wishforge-ide/apps/api/src/domain/executor-settings.ts
eust-w 4e9e5fb874 ✨ Let tenant admins configure each executor: gateway, models and time limit
A per-tenant, per-executor settings record (GET /executor-settings,
GET/PUT /executor-settings/:provider, owner/admin, idempotent replace) with
baseUrl, defaultModel, smallFastModel, fallbackModel, timeoutMinutes, askModel
and askFallbackModel. Unset fields keep the operator's configuration.

- defaultModel is pinned at submission below the wish and bundle models.
- smallFastModel, fallbackModel and timeoutMinutes travel in the run context
  to the worker; Claude Code gets ANTHROPIC_SMALL_FAST_MODEL /
  ANTHROPIC_DEFAULT_HAIKU_MODEL and --fallback-model, CodeBuddy the limit.
- baseUrl goes only with the tenant's own key, over HTTPS (plain HTTP only
  where plainHttpAllowed), never in production, behind the model proxy or
  with the deployment's native Claude account.
- The wish refiner tries the tenant's ask models first.
- The 执行器 page gets an 执行器设置 dialog, also in native-account mode;
  model fields (and the agent page's) accept gateway names like
  deepseek-flash@latest[1m].

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-04 12:19:02 +08:00

180 lines
7.1 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { z } from 'zod';
import {
DomainError,
executorSettingFields,
executorSettingsInput,
isProduction,
plainHttpAllowed,
providerCatalog,
providers,
type Actor,
type Entity,
type ExecutorSettings,
type ProviderId,
} from '@wishforge/contracts';
import type { Store, Transaction } from '../db/store.js';
import { record, touch } from './control-plane.js';
import { nativeClaudeEnabled } from './local-execution.js';
import { requireHuman, requireRole } from './policy.js';
const providerParam = z.enum(providers);
type Settings = Omit<ExecutorSettings, keyof Entity | 'provider' | 'updatedBy'>;
/**
* Why a tenant's base URL cannot apply to this executor here, or undefined when it can: only with
* the tenant's own key, sent straight to the model API. Production and the model proxy use the
* operator's upstream, and the deployment's native Claude account must never be sent elsewhere.
*/
export function tenantBaseUrlBlocked(env: NodeJS.ProcessEnv, tenantId: string, provider: ProviderId) {
if (!providerCatalog[provider].settings.includes('baseUrl')) return 'unsupported';
if (isProduction(env) || env.WF_PROVIDER_PROXY_ENABLED === 'true') return 'operator_managed';
if (provider === 'claude-code' && nativeClaudeEnabled(env, tenantId)) return 'native_account';
return undefined;
}
/** An HTTPS origin with an optional path; plain HTTP only where services may use it (plainHttpAllowed). */
export function tenantBaseUrl(env: NodeJS.ProcessEnv, value: string) {
let url: URL;
try {
url = new URL(value);
} catch {
throw new DomainError('INVALID_BASE_URL', 'The base URL must be a URL such as https://gateway.example/v1', 400);
}
if (
!(url.protocol === 'https:' || plainHttpAllowed(env, url)) ||
url.username ||
url.password ||
url.search ||
url.hash
)
throw new DomainError(
'INVALID_BASE_URL',
'The base URL must use HTTPS and carry no credentials, query or fragment',
400,
);
return url.href.replace(/\/$/, '');
}
/** The settings of one executor, or none; tolerant of fields the executor no longer takes. */
export async function storedExecutorSettings(tx: Transaction, provider: ProviderId): Promise<Settings> {
const stored = await tx.get<ExecutorSettings>('executor_settings', provider);
if (!stored) return {};
const supported = providerCatalog[provider].settings;
return Object.fromEntries(
executorSettingFields.flatMap(field =>
supported.includes(field) && stored[field] !== undefined && stored[field] !== null
? [[field, stored[field]]]
: [],
),
) as Settings;
}
/** What the executor of a run applies besides the model: its run context's `executorSettings`. */
export async function runExecutorSettings(tx: Transaction, provider: ProviderId) {
const { smallFastModel, fallbackModel, timeoutMinutes } = await storedExecutorSettings(tx, provider);
return {
...(smallFastModel ? { smallFastModel } : {}),
...(fallbackModel ? { fallbackModel } : {}),
...(timeoutMinutes ? { timeoutMinutes } : {}),
};
}
/**
* A tenant admin's settings for each executor: gateway, models and time limit. Unset fields keep
* the operator's configuration. Settings are not secret; keys stay in provider connections.
*/
export class ExecutorSettingsService {
constructor(
private store: Store,
private env = process.env,
) {}
private view(tenantId: string, provider: ProviderId, settings: Settings, stored?: ExecutorSettings) {
const blocked = tenantBaseUrlBlocked(this.env, tenantId, provider);
return {
provider,
...settings,
supported: providerCatalog[provider].settings,
baseUrlAllowed: !blocked,
...(blocked && providerCatalog[provider].settings.includes('baseUrl') ? { baseUrlBlocked: blocked } : {}),
...(stored ? { version: stored.version, updatedAt: stored.updatedAt } : {}),
};
}
list(actor: Actor) {
requireRole(actor, ['owner', 'admin']);
return this.store.read(actor.tenantId, async tx =>
Promise.all(
providers.map(async provider =>
this.view(
actor.tenantId,
provider,
await storedExecutorSettings(tx, provider),
await tx.get<ExecutorSettings>('executor_settings', provider),
),
),
),
);
}
async get(actor: Actor, provider: unknown) {
requireRole(actor, ['owner', 'admin']);
const id = providerParam.parse(provider);
return this.store.read(actor.tenantId, async tx =>
this.view(
actor.tenantId,
id,
await storedExecutorSettings(tx, id),
await tx.get<ExecutorSettings>('executor_settings', id),
),
);
}
/** Replaces the executor's settings; the same body again changes nothing. */
async put(actor: Actor, provider: unknown, input: unknown) {
requireHuman(actor);
requireRole(actor, ['owner', 'admin']);
const id = providerParam.parse(provider);
const data = executorSettingsInput.parse(input);
const supported = providerCatalog[id].settings;
const unsupported = executorSettingFields.filter(field => data[field] !== undefined && !supported.includes(field));
if (unsupported.length)
throw new DomainError(
'SETTING_UNSUPPORTED',
`${providerCatalog[id].name} does not take these settings: ${unsupported.join(', ')}`,
400,
);
const settings: Settings = Object.fromEntries(
executorSettingFields.flatMap(field => (data[field] !== undefined ? [[field, data[field]]] : [])),
);
if (settings.baseUrl !== undefined) {
const blocked = tenantBaseUrlBlocked(this.env, actor.tenantId, id);
if (blocked)
throw new DomainError(
'BASE_URL_OPERATOR_MANAGED',
blocked === 'native_account'
? 'This executor runs on the deployment’s own Claude account, whose gateway the operator sets'
: 'The operator manages the model gateway of this deployment',
400,
);
settings.baseUrl = tenantBaseUrl(this.env, settings.baseUrl);
}
if (settings.fallbackModel && settings.fallbackModel === settings.defaultModel)
throw new DomainError('INVALID_FALLBACK_MODEL', 'The fallback model must differ from the default model', 400);
return this.store.transaction(actor.tenantId, async tx => {
const current = await tx.get<ExecutorSettings>('executor_settings', id);
const same =
current &&
executorSettingFields.every(field => (current[field] ?? undefined) === (settings[field] ?? undefined));
if (same) return this.view(actor.tenantId, id, settings, current);
const next: ExecutorSettings = {
...(current ? touch(current) : { ...record(actor.tenantId), id }),
provider: id,
...Object.fromEntries(executorSettingFields.map(field => [field, undefined])),
...settings,
updatedBy: actor.userId,
};
// Stored rows are JSON: unset fields are left out rather than kept as undefined.
for (const field of executorSettingFields) if (next[field] === undefined) delete next[field];
await tx.put('executor_settings', next);
return this.view(actor.tenantId, id, settings, next);
});
}
}