agent-relay-server 0.60.1 → 0.61.0

package/runner/src/config.ts

@@ -2,8 +2,8 @@ import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import { join, resolve } from "node:path";
-import { DEFAULT_RELAY_URL, stringValue } from "agent-relay-sdk";
-import type { WorkspaceMetadata } from "agent-relay-sdk";
+import { DEFAULT_RELAY_URL, RELAY_TOKEN_HEADER, errMessage, stringValue } from "agent-relay-sdk";
+import type { SettingEntry, WorkspaceMetadata } from "agent-relay-sdk";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import type { ProviderConfig } from "./adapter";
 
@@ -36,6 +36,7 @@ export function defaultProviderConfig(provider: string): ProviderConfig {
     defaultApprovalMode: "guarded",
     defaultTags: [],
     chatCaptureMode: "final",
+    reasoningCapture: true,
     headless: {
       tmuxPrefix: `${provider}-relay`,
       shutdownTimeoutMs: 10_000,
@@ -67,6 +68,7 @@ export function loadProviderConfig(provider: string, home = agentRelayHome()): L
     defaultApprovalMode: stringValue(raw.defaultApprovalMode) ?? defaults.defaultApprovalMode,
     defaultTags: stringArray(raw.defaultTags) ?? defaults.defaultTags,
     chatCaptureMode: enumValue(raw.chatCaptureMode, ["final", "full"]) ?? defaults.chatCaptureMode,
+    reasoningCapture: booleanValue(raw.reasoningCapture) ?? defaults.reasoningCapture,
     headless: {
       tmuxPrefix: stringValue(recordValue(raw.headless).tmuxPrefix) ?? defaults.headless.tmuxPrefix,
       shutdownTimeoutMs: positiveInteger(recordValue(raw.headless).shutdownTimeoutMs) ?? defaults.headless.shutdownTimeoutMs,
@@ -74,6 +76,24 @@ export function loadProviderConfig(provider: string, home = agentRelayHome()): L
   };
 }
 
+export async function loadProviderConfigFromRelay(
+  provider: string,
+  opts: { relayUrl: string; token?: string; home?: string; host?: string },
+): Promise<LoadedProviderConfig> {
+  const host = opts.host ?? hostname();
+  const home = opts.home ?? agentRelayHome();
+  const local = loadProviderConfig(provider, home);
+  const key = `${host}/${provider}`;
+
+  try {
+    const fetched = await fetchProviderConfig(provider, opts.relayUrl, opts.token, key);
+    if (fetched) return fetched;
+  } catch (error) {
+    console.warn(`[agent-relay] provider config relay read failed (${errMessage(error)}); using local fallback ${local.path}.`);
+  }
+  return local;
+}
+
 export function writeProviderConfig(provider: string, config: ProviderConfig, home = agentRelayHome()): LoadedProviderConfig {
   const dir = providersDir(home);
   mkdirSync(dir, { recursive: true });
@@ -93,6 +113,7 @@ export function providerConfigPublic(config: LoadedProviderConfig): Record<strin
     defaultApprovalMode: config.defaultApprovalMode,
     defaultTags: config.defaultTags,
     chatCaptureMode: config.chatCaptureMode,
+    reasoningCapture: config.reasoningCapture,
     headless: config.headless,
   };
 }
@@ -156,6 +177,10 @@ function enumValue<T extends string>(value: unknown, allowed: T[]): T | undefine
   return typeof value === "string" && allowed.includes(value as T) ? (value as T) : undefined;
 }
 
+function booleanValue(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}
+
 function stringArray(value: unknown): string[] | undefined {
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : undefined;
 }
@@ -178,3 +203,42 @@ function maskEnv(env: Record<string, string>): Record<string, string> {
   }
   return result;
 }
+
+async function fetchProviderConfig(
+  provider: string,
+  relayUrl: string,
+  token: string | undefined,
+  key: string,
+): Promise<LoadedProviderConfig | null> {
+  const url = new URL(`/api/settings/provider-config/${encodeURIComponent(key)}`, relayUrl);
+  const res = await fetch(url, {
+    headers: token ? { [RELAY_TOKEN_HEADER]: token } : undefined,
+    signal: AbortSignal.timeout(5_000),
+  });
+  if (res.status === 404) return null;
+  const body = await res.json().catch(() => null) as (Partial<SettingEntry> & { error?: string }) | null;
+  if (!res.ok) throw new Error(body?.error ? `${res.status}: ${body.error}` : `HTTP ${res.status}`);
+  if (body?.version === 0) return null;
+  return providerConfigFromValue(provider, body?.value, `config:provider-config/${key}`);
+}
+
+function providerConfigFromValue(provider: string, value: unknown, path: string): LoadedProviderConfig {
+  const raw = recordValue(value);
+  const defaults = defaultProviderConfig(provider);
+  return {
+    path,
+    command: stringValue(raw.command) ?? defaults.command,
+    defaultArgs: stringArray(raw.defaultArgs) ?? defaults.defaultArgs,
+    env: stringRecord(raw.env) ?? defaults.env,
+    pluginDirs: stringArray(raw.pluginDirs) ?? defaults.pluginDirs,
+    defaultCapabilities: stringArray(raw.defaultCapabilities) ?? defaults.defaultCapabilities,
+    defaultApprovalMode: stringValue(raw.defaultApprovalMode) ?? defaults.defaultApprovalMode,
+    defaultTags: stringArray(raw.defaultTags) ?? defaults.defaultTags,
+    chatCaptureMode: enumValue(raw.chatCaptureMode, ["final", "full"]) ?? defaults.chatCaptureMode,
+    reasoningCapture: booleanValue(raw.reasoningCapture) ?? defaults.reasoningCapture,
+    headless: {
+      tmuxPrefix: stringValue(recordValue(raw.headless).tmuxPrefix) ?? defaults.headless.tmuxPrefix,
+      shutdownTimeoutMs: positiveInteger(recordValue(raw.headless).shutdownTimeoutMs) ?? defaults.headless.shutdownTimeoutMs,
+    },
+  };
+}

package/src/automations.ts

@@ -16,7 +16,7 @@ import { createCommand } from "./commands-db";
 import { cleanEnum, cleanString, cleanStringArray, optionalEnum } from "./validation";
 import { getAgentProfile, getSpawnPolicy } from "./config-store";
 import { buildSpawnCommand, resolveSpawnModelParams } from "./spawn-command";
-import { resolveProviderSelection, type ProviderEffort, VALID_EFFORTS } from "agent-relay-sdk/provider-catalog";
+import { resolveProviderSelection, type ProviderEffort } from "agent-relay-sdk/provider-catalog"; import { effectiveProviderCatalogList } from "./provider-catalog-store";
 import { errMessage, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
 import { runnerRuntimeTokenEnv } from "./runtime-tokens";
 import type {
@@ -38,7 +38,6 @@ import type {
   TaskSeverity,
   UpdateAutomationInput,
 } from "./types";
-
 const AUTOMATION_KIND = "scheduled_task";
 const DEFAULT_TIMEZONE = "UTC";
 const DEFAULT_CATCH_UP: AutomationCatchUpPolicy = "skip";
@@ -200,11 +199,11 @@ function normalizeTargetPolicy(value: unknown): AutomationTargetPolicy {
   }
   const provider = optionalEnum(input.provider, "targetPolicy.provider", ["claude", "codex"] as const, "codex");
   const model = cleanString(input.model, "targetPolicy.model", { max: 120 });
-  const effort = input.effort === undefined || input.effort === null ? undefined : cleanEnum(input.effort, "targetPolicy.effort", VALID_EFFORTS) as ProviderEffort;
+  const effort = cleanString(input.effort, "targetPolicy.effort", { max: 120 }) as ProviderEffort | undefined;
   const profile = cleanString(input.profile, "targetPolicy.profile", { max: 120 });
   if (profile && !getAgentProfile(profile)) throw new ValidationError("agent profile not found");
   try {
-    resolveProviderSelection({ provider, model, effort });
+    resolveProviderSelection({ provider, model, effort }, effectiveProviderCatalogList());
   } catch (error) {
     throw new ValidationError(errMessage(error));
   }

package/src/config-store.ts

@@ -4,7 +4,7 @@ import { DEFAULT_CONTEXT_THRESHOLD_CONFIG, validateContextThresholdConfig } from
 import { DEFAULT_SELF_RESUME_CONFIG, validateSelfResumeConfig } from "./self-resume-config";
 import { TEAM_TEMPLATE_NAMESPACE, validateTeamTemplate } from "./team-template-config";
 import { resolveProviderSelection, type ProviderEffort } from "agent-relay-sdk/provider-catalog";
-import { errMessage, isRecord, SPAWN_PROVIDERS, VALID_EFFORTS, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
+import { errMessage, isRecord, SPAWN_PROVIDERS, VALID_WORKSPACE_MODES } from "agent-relay-sdk"; import { effectiveProviderCatalogList } from "./provider-catalog-store";
 import type {
   AgentProfile,
   AgentProfileBase,
@@ -23,7 +23,6 @@ import type {
   WorkspaceConfig,
   WorkspaceLandingPolicy,
 } from "./types";
-
 const CONFIG_HISTORY_LIMIT = 50;
 const SPAWN_POLICY_NAMESPACE = "spawn-policy";
 const AGENT_PROFILE_NAMESPACE = "agent-profile";
@@ -342,7 +341,7 @@ function validateSpawnPolicy(key: string, value: unknown): SpawnPolicy {
     workspaceMode: value.workspaceMode === undefined || value.workspaceMode === null ? "inherit" : cleanEnum(value.workspaceMode, "workspaceMode", VALID_WORKSPACE_MODES),
     rig: cleanString(value.rig, "rig", { max: 120 }),
     model: cleanString(value.model, "model", { max: 120 }),
-    effort: value.effort === undefined || value.effort === null ? undefined : cleanEnum(value.effort, "effort", VALID_EFFORTS) as ProviderEffort,
+    effort: cleanString(value.effort, "effort", { max: 120 }) as ProviderEffort | undefined,
     profile: cleanString(value.profile, "profile", { max: 120 }),
     providerArgs: cleanStringArray(value.providerArgs, "providerArgs", { itemMax: 120, maxItems: 100 }) ?? [],
     prompt: cleanString(value.prompt, "prompt", { max: 16_000 }),
@@ -356,7 +355,7 @@ function validateSpawnPolicy(key: string, value: unknown): SpawnPolicy {
     backoff: cleanBackoff(value.backoff),
   };
   try {
-    resolveProviderSelection({ provider: policy.provider, model: policy.model, effort: policy.effort });
+    resolveProviderSelection({ provider: policy.provider, model: policy.model, effort: policy.effort }, effectiveProviderCatalogList());
   } catch (error) {
     throw new ValidationError(errMessage(error));
   }
@@ -408,7 +407,7 @@ function validateStewardConfig(value: unknown): StewardConfig {
     enabled: value.enabled === undefined ? false : cleanBoolean(value.enabled, "enabled"),
     provider: cleanEnum(value.provider, "provider", SPAWN_PROVIDERS) as SpawnProvider,
     model: cleanString(value.model, "model", { max: 120 }),
-    effort: value.effort === undefined || value.effort === null ? undefined : cleanEnum(value.effort, "effort", VALID_EFFORTS) as ProviderEffort,
+    effort: cleanString(value.effort, "effort", { max: 120 }) as ProviderEffort | undefined,
     permissionMode: (value.permissionMode === undefined || value.permissionMode === null
       ? "open"
       : cleanEnum(value.permissionMode, "permissionMode", VALID_PERMISSION_MODES)) as SpawnApprovalMode,
@@ -419,7 +418,7 @@ function validateStewardConfig(value: unknown): StewardConfig {
   // Reject a provider/model/effort combo the catalog can't resolve before it ever
   // reaches a spawn (same guard as spawn policies).
   try {
-    resolveProviderSelection({ provider: config.provider, model: config.model, effort: config.effort });
+    resolveProviderSelection({ provider: config.provider, model: config.model, effort: config.effort }, effectiveProviderCatalogList());
   } catch (error) {
     throw new ValidationError(errMessage(error));
   }

package/src/connectors.ts

@@ -4,6 +4,7 @@ import { dirname, join } from "node:path";
 import type { ConnectorAction, ConnectorActionResult, ConnectorManifest, ConnectorSummary } from "./types";
 import { ValidationError } from "./db";
 import { isRecord } from "agent-relay-sdk";
+import { registerConnectorConfigSetting, validateConnectorConfig } from "./settings/modules";
 
 const CONNECTOR_SCHEMA = "agent-relay.connector.v1";
 const VALID_KINDS = new Set(["channel", "event", "provider", "orchestrator"]);
@@ -99,6 +100,7 @@ function stringArray(value: unknown, field: string): string[] {
 
 export function registerConnectorManifest(manifest: ConnectorManifest, opts: { config?: Record<string, unknown>; state?: Record<string, unknown> } = {}): ConnectorSummary {
   const normalized = normalizeConnectorManifest(manifest);
+  registerConnectorConfigSetting(normalized, { defaults: opts.config });
   const dir = connectorDir(normalized.id);
   mkdirSync(dir, { recursive: true, mode: 0o700 });
   writeFileSync(join(dir, "manifest.json"), JSON.stringify(normalized, null, 2) + "\n", { mode: 0o600 });
@@ -165,6 +167,9 @@ export function readConnectorConfig(id: string): Record<string, unknown> {
 
 export function writeConnectorConfig(id: string, config: Record<string, unknown>): Record<string, unknown> {
   if (!isRecord(config)) throw new ValidationError("connector config must be an object");
+  const connector = getConnector(id);
+  if (!connector) throw new ValidationError(`connector ${id} not found`);
+  validateConnectorConfig(connector.manifest, config);
   const path = join(connectorDir(id), "config.json");
   mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
   writeFileSync(path, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });

package/src/db/migrations.ts

@@ -394,6 +394,12 @@ export function applyMigrations(): void {
     "UPDATE tasks SET claim_expires_at = coalesce(claimed_at, ?) + ? WHERE claimed_by IS NOT NULL AND claim_expires_at IS NULL",
   ).run(Date.now(), CLAIM_LEASE_MS);
 
+  const providerModelOverrideCols = getDb().query("PRAGMA table_info(provider_model_overrides)").all() as any[];
+  const providerModelOverrideColNames = providerModelOverrideCols.map((c: any) => c.name);
+  if (!providerModelOverrideColNames.includes("disabled")) {
+    getDb().run("ALTER TABLE provider_model_overrides ADD COLUMN disabled INTEGER NOT NULL DEFAULT 0");
+  }
+
   // Migration: orchestrators.api_url
   const orchCols = getDb().query("PRAGMA table_info(orchestrators)").all() as any[];
   const orchColNames = orchCols.map((c: any) => c.name);

package/src/db/schema.ts

@@ -829,7 +829,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
       provider TEXT NOT NULL,
       alias TEXT NOT NULL,
       entry TEXT NOT NULL DEFAULT '{}',
-      deleted INTEGER NOT NULL DEFAULT 0,
+      deleted INTEGER NOT NULL DEFAULT 0, disabled INTEGER NOT NULL DEFAULT 0,
       updated_at INTEGER NOT NULL,
       updated_by TEXT,
       PRIMARY KEY (provider, alias)

package/src/index.ts

@@ -268,13 +268,16 @@ export function createFetchHandler(
       if (!publicPaths.includes(url.pathname)) {
         const integrationAuth = getIntegrationAuth(req);
         const componentAuth = getComponentAuth(req);
+        const handlerOwnsScopedAuth = url.pathname === "/api/tokens/me" ||
+          url.pathname === "/api/settings" ||
+          url.pathname.startsWith("/api/settings/");
         if (!isAuthorized(req)) {
           if (!integrationAuth) {
             return unauthorized(req);
           }
-          if (!isScopedRequestAuthorized(req)) return forbidden(req);
+          if (!handlerOwnsScopedAuth && !isScopedRequestAuthorized(req)) return forbidden(req);
         }
-        if (componentAuth && !isScopedRequestAuthorized(req)) return forbidden(req);
+        if (componentAuth && !handlerOwnsScopedAuth && !isScopedRequestAuthorized(req)) return forbidden(req);
       }
       const response = await matched.handler(req, matched.params);
       applyCors(req, response);

package/src/mcp-provider-catalog.ts

@@ -0,0 +1,9 @@
+import { VALID_EFFORTS, isRecord } from "agent-relay-sdk";
+import { effectiveProviderEffortLevels } from "./provider-catalog-store";
+
+export function providerCatalogToolInputSchema(name: string, inputSchema: Record<string, unknown>): Record<string, unknown> {
+  if (name !== "relay_spawn_agent") return inputSchema;
+  const efforts = effectiveProviderEffortLevels();
+  const properties = isRecord(inputSchema.properties) ? inputSchema.properties : {};
+  return { ...inputSchema, properties: { ...properties, effort: { type: "string", enum: efforts.length ? efforts : VALID_EFFORTS } } };
+}

package/src/mcp.ts

@@ -52,7 +52,7 @@ import { BLACKBOARD_TOOLS, relayBlackboardTool } from "./mcp-blackboard-tools";
 import { PROJECT_TOOLS, relayProjectTool } from "./mcp-project-tools";
 import { NOTIFICATION_SUBSCRIPTION_TOOLS, relayNotificationSubscriptionTool } from "./mcp-notification-subscription-tools"; import { MERGE_TOOLS, relayMergeTool } from "./mcp-merge-tools";
 import { PROJECT_INSTRUCTION_POLICY_NAMES, parseProjectInstructions } from "./project-instructions";
-import { AGENT_ACTION_TOOL, relayAgentAction } from "./mcp-agent-action";
+import { AGENT_ACTION_TOOL, relayAgentAction } from "./mcp-agent-action"; import { providerCatalogToolInputSchema } from "./mcp-provider-catalog";
 import type { ActivityKind, AgentLifecycle, ArtifactKind, ArtifactSensitivity, AttachmentRef, Command, SendMessageInput, Message, SpawnApprovalMode, SpawnProvider, WorkspaceAutoMergePolicy, WorkspaceMergeStrategy, WorkspaceMode, WorkspaceRecord } from "./types";
 import { LAND_STRATEGIES, applyWorkspaceAction, waitForWorkspaceStatus, type WorkspaceAction } from "./workspace-actions";
 import { AUTO_MERGE_POLICIES } from "./workspace-merge";
@@ -869,7 +869,7 @@ async function relaySpawnAgent(auth: McpAuthContext, args: Record<string, unknow
     orchestratorId: optionalString(args.orchestratorId, "orchestratorId", 200),
     cwd: optionalString(args.cwd, "cwd", 500),
     model: optionalString(args.model, "model", 120),
-    effort: optionalEnum(args.effort, "effort", VALID_EFFORTS) as ProviderEffort | undefined,
+    effort: optionalString(args.effort, "effort", 120) as ProviderEffort | undefined,
     approvalMode: optionalEnum(args.approvalMode, "approvalMode", APPROVAL_MODES) as SpawnApprovalMode | undefined,
     workspaceMode: optionalEnum(args.workspaceMode, "workspaceMode", VALID_WORKSPACE_MODES) as WorkspaceMode | undefined,
     lifecycle: (optionalEnum(args.lifecycle, "lifecycle", VALID_AGENT_LIFECYCLES) as AgentLifecycle | undefined) ?? "persistent",
@@ -1140,10 +1140,10 @@ function sniffMediaType(bytes: Uint8Array, hinted?: string, filename?: string):
 function visibleTools(auth: McpAuthContext): Array<Record<string, unknown>> {
   return TOOLS
     .filter((tool) => hasAnyScope(auth, tool.requiredScopes))
-    .map(({ name, description, inputSchema, alwaysLoad }) => ({
+    .map(({ name, description, alwaysLoad, ...tool }) => ({
       name,
       description,
-      inputSchema,
+      inputSchema: providerCatalogToolInputSchema(name, tool.inputSchema),
       ...(alwaysLoad ? { _meta: { "anthropic/alwaysLoad": true } } : {}),
     }));
 }

package/src/provider-catalog-store.ts

@@ -13,6 +13,7 @@ interface ProviderModelOverrideRow {
   alias: string;
   entry: string;
   deleted: number;
+  disabled: number;
   updated_at: number;
   updated_by?: string | null;
 }
@@ -22,6 +23,7 @@ interface ProviderModelOverride {
   alias: string;
   entry: ProviderModelCatalogEntry;
   deleted: boolean;
+  disabled: boolean;
   updatedAt: number;
   updatedBy?: string;
 }
@@ -31,6 +33,7 @@ interface ProviderModelOverrideInput {
   alias: string;
   entry: ProviderModelCatalogEntry;
   deleted?: boolean;
+  disabled?: boolean;
   updatedBy?: string;
 }
 
@@ -45,11 +48,12 @@ export function upsertProviderModelOverride(input: ProviderModelOverrideInput):
   const normalized = normalizeOverrideInput(input);
   const now = Date.now();
   getDb().query(`
-    INSERT INTO provider_model_overrides (provider, alias, entry, deleted, updated_at, updated_by)
-    VALUES (?, ?, ?, ?, ?, ?)
+    INSERT INTO provider_model_overrides (provider, alias, entry, deleted, disabled, updated_at, updated_by)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(provider, alias) DO UPDATE SET
       entry = excluded.entry,
       deleted = excluded.deleted,
+      disabled = excluded.disabled,
       updated_at = excluded.updated_at,
       updated_by = excluded.updated_by
   `).run(
@@ -57,6 +61,7 @@ export function upsertProviderModelOverride(input: ProviderModelOverrideInput):
     normalized.alias,
     JSON.stringify(normalized.entry),
     normalized.deleted ? 1 : 0,
+    normalized.disabled ? 1 : 0,
     now,
     normalized.updatedBy ?? null,
   );
@@ -66,6 +71,7 @@ export function upsertProviderModelOverride(input: ProviderModelOverrideInput):
     alias: normalized.alias,
     entry: normalized.entry,
     deleted: Boolean(normalized.deleted),
+    disabled: Boolean(normalized.disabled),
     updatedAt: now,
     updatedBy: normalized.updatedBy,
   };
@@ -83,10 +89,26 @@ export function removeProviderModelOverride(provider: SpawnProvider, alias: stri
   });
 }
 
+export function setProviderModelDisabled(provider: SpawnProvider, alias: string, disabled: boolean, updatedBy?: string): ProviderModelOverride {
+  const existing = findModelEntry(provider, alias);
+  if (!existing) throw new ValidationError(`unknown ${provider} model: ${alias}`);
+  return upsertProviderModelOverride({
+    provider,
+    alias,
+    entry: existing,
+    disabled,
+    updatedBy,
+  });
+}
+
 export function effectiveProviderCatalogList(): ProviderCatalogEntry[] {
   return mergeProviderCatalog(providerCatalogList(), listProviderModelOverrides());
 }
 
+export function effectiveProviderEffortLevels(): string[] {
+  return [...new Set(effectiveProviderCatalogList().flatMap((provider) => provider.models.flatMap((model) => model.efforts)))].sort();
+}
+
 export function mergeProviderCatalog(
   baseCatalog: ProviderCatalogEntry[],
   overrides: ProviderModelOverride[],
@@ -102,7 +124,11 @@ export function mergeProviderCatalog(
       if (existingIndex >= 0) providerEntry.models.splice(existingIndex, 1);
       continue;
     }
-    const nextEntry = cloneModelEntry({ ...override.entry, alias: override.alias });
+    const nextEntry = cloneModelEntry({
+      ...override.entry,
+      alias: override.alias,
+      ...(override.disabled ? { disabled: true } : { disabled: undefined }),
+    });
     if (existingIndex >= 0) providerEntry.models[existingIndex] = nextEntry;
     else providerEntry.models.push(nextEntry);
   }
@@ -118,10 +144,12 @@ function normalizeOverrideInput(input: ProviderModelOverrideInput): ProviderMode
   if (!input.entry.label?.trim()) throw new ValidationError("model label is required");
   if (!input.entry.providerModel?.trim()) throw new ValidationError("provider model is required");
   if (!Array.isArray(input.entry.efforts)) throw new ValidationError("model efforts must be an array");
+  const entry = cloneModelEntry({ ...input.entry, alias });
+  delete entry.disabled;
   return {
     ...input,
     alias,
-    entry: cloneModelEntry({ ...input.entry, alias }),
+    entry,
     updatedBy: input.updatedBy?.trim() || undefined,
   };
 }
@@ -134,6 +162,7 @@ function rowToOverride(row: ProviderModelOverrideRow): ProviderModelOverride | u
     alias: row.alias,
     entry: cloneModelEntry({ ...parsed, alias: row.alias }),
     deleted: row.deleted === 1,
+    disabled: row.disabled === 1,
     updatedAt: row.updated_at,
     updatedBy: row.updated_by ?? undefined,
   };

package/src/provider-config-store.ts

@@ -0,0 +1,216 @@
+import { existsSync, readdirSync } from "node:fs";
+import { hostname } from "node:os";
+import { join } from "node:path";
+import { ValidationError, listOrchestrators } from "./db";
+import { getConfig, listConfig, setConfig } from "./config-store";
+import { cleanString, cleanStringArray, optionalEnum } from "./validation";
+import { emitConfigChanged } from "./sse";
+import {
+  PROVIDER_CONFIG_NAMESPACE,
+  validateSettingValue,
+} from "./settings/registry";
+import {
+  getProviderSettingsDeclaration,
+  listProviderSettingsDeclarations,
+  providerConfigDefaults,
+  registerDeclaredProviderConfigSetting,
+} from "./settings/modules";
+import { defaultProviderConfig, loadProviderConfig as loadLocalProviderConfig } from "../runner/src/config";
+import { SPAWN_PROVIDERS, isRecord, type ConfigEntry, type SpawnProvider } from "agent-relay-sdk";
+import type { ProviderConfig } from "../runner/src/adapter";
+
+export const VALID_PROVIDER_CONFIGS = SPAWN_PROVIDERS;
+
+type ProviderConfigProvider = string;
+type ProviderConfigEntry = ConfigEntry<ProviderConfig>;
+
+export function defaultProviderConfigHost(): string {
+  return hostname();
+}
+
+export function providerConfigKey(host: string, provider: string): string {
+  return `${normalizeProviderConfigHost(host)}/${normalizeProviderConfigProvider(provider)}`;
+}
+
+export function parseProviderConfigKey(key: string): { host: string; provider: ProviderConfigProvider } | null {
+  const slash = key.lastIndexOf("/");
+  if (slash <= 0 || slash === key.length - 1) return null;
+  const host = cleanString(key.slice(0, slash), "host", { required: true, max: 120 })!;
+  const provider = cleanString(key.slice(slash + 1), "provider", { required: true, max: 80 })!;
+  return getProviderSettingsDeclaration(provider) ? { host, provider } : null;
+}
+
+export function ensureProviderConfigDescriptors(extraKeys: string[] = []): void {
+  const keys = new Set<string>();
+  const providerDeclarations = listProviderSettingsDeclarations();
+  for (const entry of listConfig(PROVIDER_CONFIG_NAMESPACE)) keys.add(entry.key);
+  for (const orchestrator of listOrchestrators()) {
+    if (!orchestrator.hostname) continue;
+    for (const declaration of providerDeclarations) keys.add(providerConfigKey(orchestrator.hostname, declaration.provider));
+  }
+  for (const declaration of providerDeclarations) keys.add(providerConfigKey(defaultProviderConfigHost(), declaration.provider));
+  for (const key of extraKeys) keys.add(key);
+
+  for (const key of keys) {
+    const parsed = parseProviderConfigKey(key);
+    if (!parsed) continue;
+    registerDeclaredProviderConfigSetting({
+      host: parsed.host,
+      provider: parsed.provider,
+    });
+  }
+}
+
+export function getProviderConfigEntry(provider: string, host = defaultProviderConfigHost()): ProviderConfigEntry {
+  const cleanProvider = normalizeProviderConfigProvider(provider);
+  const cleanHost = normalizeProviderConfigHost(host);
+  const key = providerConfigKey(cleanHost, cleanProvider);
+  ensureProviderConfigDescriptors([key]);
+  const entry = getConfig<ProviderConfig>(PROVIDER_CONFIG_NAMESPACE, key);
+  if (entry) return { ...entry, value: mergeProviderConfig(cleanProvider, entry.value) };
+  return {
+    namespace: PROVIDER_CONFIG_NAMESPACE,
+    key,
+    value: providerConfigDefaults(cleanProvider),
+    version: 0,
+    updatedAt: "default",
+    updatedBy: "system",
+  };
+}
+
+export function listProviderConfigEntries(host = defaultProviderConfigHost()): Record<SpawnProvider, ProviderConfigEntry> {
+  return Object.fromEntries(
+    VALID_PROVIDER_CONFIGS.map((provider) => [provider, getProviderConfigEntry(provider, host)]),
+  ) as Record<SpawnProvider, ProviderConfigEntry>;
+}
+
+export function setProviderConfig(
+  provider: string,
+  value: unknown,
+  opts: { host?: string; updatedBy?: string } = {},
+): ProviderConfigEntry {
+  const cleanProvider = normalizeProviderConfigProvider(provider);
+  const host = normalizeProviderConfigHost(opts.host ?? defaultProviderConfigHost());
+  const normalized = cleanProviderConfig(cleanProvider, value);
+  const key = providerConfigKey(host, cleanProvider);
+  ensureProviderConfigDescriptors([key]);
+  const validation = validateSettingValue(PROVIDER_CONFIG_NAMESPACE, key, normalized);
+  if (!validation.valid) throw new ValidationError(validation.errors.join("; "));
+  return setConfig(PROVIDER_CONFIG_NAMESPACE, key, normalized, opts.updatedBy) as ProviderConfigEntry;
+}
+
+export function providerConfigPublic(entry: ProviderConfigEntry, opts: { maskEnv?: boolean } = {}): Record<string, unknown> {
+  const parsed = parseProviderConfigKey(entry.key);
+  return {
+    namespace: entry.namespace,
+    key: entry.key,
+    path: `config:${entry.namespace}/${entry.key}`,
+    host: parsed?.host,
+    provider: parsed?.provider,
+    version: entry.version,
+    updatedAt: entry.updatedAt,
+    updatedBy: entry.updatedBy,
+    command: entry.value.command,
+    defaultArgs: entry.value.defaultArgs,
+    env: opts.maskEnv === false ? entry.value.env : maskEnv(entry.value.env),
+    pluginDirs: entry.value.pluginDirs,
+    defaultCapabilities: entry.value.defaultCapabilities,
+    defaultApprovalMode: entry.value.defaultApprovalMode,
+    defaultTags: entry.value.defaultTags,
+    chatCaptureMode: entry.value.chatCaptureMode,
+    reasoningCapture: entry.value.reasoningCapture,
+    headless: entry.value.headless,
+  };
+}
+
+export function migrateLocalProviderConfigs(home = agentRelayHome(), host = defaultProviderConfigHost()): ProviderConfigEntry[] {
+  const dir = join(home, "providers");
+  if (!existsSync(dir)) return [];
+  const migrated: ProviderConfigEntry[] = [];
+  for (const file of readdirSync(dir)) {
+    const provider = file.endsWith(".json") ? file.slice(0, -".json".length) : "";
+    if (!VALID_PROVIDER_CONFIGS.includes(provider as SpawnProvider)) continue;
+    const key = providerConfigKey(host, provider);
+    if (getConfig(PROVIDER_CONFIG_NAMESPACE, key)) continue;
+    const local = loadLocalProviderConfig(provider, home);
+    const entry = setProviderConfig(provider, local, { host, updatedBy: `migration:${host}` });
+    emitConfigChanged(entry.namespace, entry.key, entry.version);
+    migrated.push(entry);
+  }
+  return migrated;
+}
+
+function normalizeProviderConfigHost(host: string): string {
+  return cleanString(host, "host", { required: true, max: 120 })!;
+}
+
+function normalizeProviderConfigProvider(provider: string): ProviderConfigProvider {
+  const clean = cleanString(provider, "provider", { required: true, max: 80 })!;
+  if (!getProviderSettingsDeclaration(clean)) {
+    throw new ValidationError(`provider must be one of: ${listProviderSettingsDeclarations().map((d) => d.provider).join(", ")}`);
+  }
+  return clean;
+}
+
+function cleanProviderConfig(provider: string, value: unknown): ProviderConfig {
+  if (!isRecord(value)) throw new ValidationError("provider config body must be an object");
+  const defaults = providerConfigDefaults(provider);
+  const headless = isRecord(value.headless) ? value.headless : {};
+  return {
+    command: cleanString(value.command, "command", { required: true, max: 500 })!,
+    defaultArgs: cleanStringArray(value.defaultArgs, "defaultArgs", { itemMax: 80, maxItems: 50 }) ?? defaults.defaultArgs,
+    env: cleanEnvRecord(value.env),
+    pluginDirs: cleanStringArray(value.pluginDirs, "pluginDirs", { itemMax: 80, maxItems: 50 }) ?? defaults.pluginDirs,
+    defaultCapabilities: cleanStringArray(value.defaultCapabilities, "defaultCapabilities", { itemMax: 80, maxItems: 50 }) ?? defaults.defaultCapabilities,
+    defaultApprovalMode: cleanString(value.defaultApprovalMode, "defaultApprovalMode", { max: 80 }) ?? defaults.defaultApprovalMode,
+    defaultTags: cleanStringArray(value.defaultTags, "defaultTags", { itemMax: 80, maxItems: 50 }) ?? defaults.defaultTags,
+    chatCaptureMode: (optionalEnum(value.chatCaptureMode, "chatCaptureMode", ["final", "full"]) ?? defaults.chatCaptureMode) as "final" | "full",
+    reasoningCapture: value.reasoningCapture === undefined ? defaults.reasoningCapture ?? true : cleanBoolean(value.reasoningCapture, "reasoningCapture"),
+    headless: {
+      tmuxPrefix: cleanString(headless.tmuxPrefix, "headless.tmuxPrefix", { max: 120 }) ?? defaults.headless.tmuxPrefix,
+      shutdownTimeoutMs: cleanPositiveInt(headless.shutdownTimeoutMs, "headless.shutdownTimeoutMs") ?? defaults.headless.shutdownTimeoutMs,
+    },
+  };
+}
+
+function mergeProviderConfig(provider: string, value: Partial<ProviderConfig>): ProviderConfig {
+  const defaults = providerConfigDefaults(provider);
+  return cleanProviderConfig(provider, { ...defaults, ...value, headless: { ...defaults.headless, ...value.headless } });
+}
+
+function cleanEnvRecord(value: unknown): Record<string, string> {
+  if (value === undefined) return {};
+  if (!isRecord(value)) throw new ValidationError("env must be an object");
+  const env: Record<string, string> = {};
+  for (const [key, item] of Object.entries(value)) {
+    const cleanKey = cleanString(key, "env key", { required: true, max: 120 })!;
+    if (typeof item !== "string") throw new ValidationError(`env.${cleanKey} must be a string`);
+    env[cleanKey] = item;
+  }
+  return env;
+}
+
+function cleanBoolean(value: unknown, field: string): boolean {
+  if (typeof value !== "boolean") throw new ValidationError(`${field} must be a boolean`);
+  return value;
+}
+
+function cleanPositiveInt(value: unknown, field: string): number | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw new ValidationError(`${field} must be a positive integer`);
+  }
+  return value;
+}
+
+function maskEnv(env: Record<string, string>): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = /token|secret|key|password/i.test(key) && !value.startsWith("$env:") ? "********" : value;
+  }
+  return result;
+}
+
+function agentRelayHome(): string {
+  return process.env.AGENT_RELAY_HOME || join(process.env.HOME || ".", ".agent-relay");
+}

package/src/recipe-runner.ts

@@ -2,6 +2,7 @@ import { createCommand } from "./commands-db";
 import { listOrchestrators } from "./db";
 import { resolveProviderSelection } from "agent-relay-sdk/provider-catalog";
 import { getRecipe } from "./recipe-loader";
+import { effectiveProviderCatalogList } from "./provider-catalog-store";
 import {
   createRecipeInstance,
   getRecipeInstance,
@@ -56,7 +57,7 @@ export function startRecipe(input: StartRecipeInput): StartRecipeResult {
   for (const agent of recipe.agents) {
     const count = agent.count ?? 1;
     for (let index = 0; index < count; index++) {
-      const selection = resolveProviderSelection({ provider: agent.provider, model: agent.model, effort: agent.effort });
+      const selection = resolveProviderSelection({ provider: agent.provider, model: agent.model, effort: agent.effort }, effectiveProviderCatalogList());
       const label = count > 1 ? `${recipe.name}:${agent.role}:${index + 1}` : `${recipe.name}:${agent.role}`;
       const memoryTags = [...new Set([...(recipe.lifecycle?.memory?.memoryTags ?? []), ...(agent.memoryTags ?? [])])];
       const alwaysReload = recipe.lifecycle?.memory?.alwaysReload ?? [];