@north-light/crouter 0.3.279 → 0.3.281

package/dist/api/dto/model-config.d.ts

@@ -0,0 +1,25 @@
+export type ModelStrengthDTO = 'ultra' | 'strong' | 'medium' | 'light';
+export interface ModelRouteConfigDTO {
+    family: string;
+    credentialSource: string;
+    providerId: string;
+    models: Record<ModelStrengthDTO, string>;
+}
+export interface ModelRoutingDTO {
+    credentialSourceOrder?: string[];
+    familyOrder?: string[];
+    strengthFallback?: ModelStrengthDTO[];
+}
+export interface PutModelConfigRequest {
+    config_version: string;
+    modelRoutes: Record<string, ModelRouteConfigDTO>;
+    modelRouting: ModelRoutingDTO;
+    kinds: Record<string, {
+        model: string;
+        orchestratorModel?: string;
+    }>;
+}
+export interface PutModelConfigResponse {
+    config_version: string;
+    delivered: true;
+}

package/dist/api/dto/model-config.js

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/model-pin-durability.test.js

@@ -86,8 +86,8 @@ test('only concrete provider/id tokens pin; logical family/tier refs remain pref
     assert.equal(isProviderPinnedModelToken('ultra'), false, 'a bare tier has no `/` and stays unpinned');
     assert.equal(isProviderPinnedModelToken('opus'), false, 'a bare family alias has no `/` and stays unpinned');
 });
-test('a new --model override resolves once and freezes portable and concrete requests', () => {
-    for (const requested of ['anthropic/opus', 'strong', 'anthropic/claude-fable-5:high']) {
+test('a new --model override freezes a concrete pick', () => {
+    for (const requested of ['anthropic/claude-fable-5:high', 'openai-codex/gpt-5.6-sol:max']) {
         const launch = buildSpec({ model: requested, modelOverride: true });
         assert.equal(launch.model, normalizeModel(requested, ladders), `${requested} resolves through the configured ladder`);
         assert.equal(launch.modelExact, true, `${requested} is exact after resolution`);
@@ -95,6 +95,21 @@ test('a new --model override resolves once and freezes portable and concrete req
         assert.equal(launch.env.CRTR_MODEL_INTENT, undefined, `${requested} cannot re-enable fallback on revive`);
     }
 });
+// A strength word is a preference, not a model identity. Freezing it made every
+// `--model medium` child fail closed on a canvas whose only authenticated route
+// belonged to another provider, while a sibling that passed no --model routed
+// fine. Exactness now follows the raw token's shape, not the mere presence of
+// an override.
+test('a new --model override keeps a portable ladder token routable', () => {
+    for (const requested of ['medium', 'strong', 'anthropic/opus', 'opus']) {
+        const launch = buildSpec({ model: requested, modelOverride: true });
+        assert.equal(launch.model, normalizeModel(requested, ladders), `${requested} resolves through the configured ladder`);
+        assert.equal(launch.modelExact, undefined, `${requested} is a preference, so it must not fail closed`);
+        assert.notEqual(launch.modelIntent, undefined, `${requested} keeps its route intent`);
+        assert.equal(launch.env.CRTR_MODEL_INTENT, `${launch.modelIntent.family}/${launch.modelIntent.strength}`, `${requested} hands the broker the intent route fallback needs`);
+        assert.equal(launch.modelProviderPinned, false, `${requested} names no provider to pin to`);
+    }
+});
 // Direction 1: an EXPLICIT concrete pin must SURVIVE a config/lifecycle rebuild
 // even when the carried override has portablized back to a bare tier.
 test('an explicit concrete pin survives a config/lifecycle rebuild whose portablized override reads as a bare tier', () => {
@@ -112,7 +127,7 @@ test('an explicit concrete pin survives a config/lifecycle rebuild whose portabl
 // Direction 2: a deliberately TIER-run (unpinned) node must NOT be wrongly
 // re-pinned when a subsequent rebuild/persist normalizes its override to the
 // concrete cell it happens to share bytes with.
-test('reshape resolves and persists a new --model override as the exact revive recipe', () => {
+test('reshape resolves a new --model override and keeps a family alias routable', () => {
     createNode(node('override-node', {
         model_override: 'strong',
         launch: { extensions: [], env: { CRTR_MODEL_INTENT: 'anthropic/strong' }, model: normalizeModel('strong', ladders), modelIntent: { family: 'anthropic', strength: 'strong' } },
@@ -122,6 +137,19 @@ test('reshape resolves and persists a new --model override as the exact revive r
     const expected = normalizeModel('anthropic/opus', ladders);
     assert.equal(after?.model_override, expected, 'the raw alias never becomes the durable override');
     assert.equal(after?.launch?.model, expected, 'revive replays the resolved provider/model');
+    assert.equal(after?.launch?.modelExact, undefined, 'a family alias is a preference, so revive may still route');
+    assert.deepEqual(after?.launch?.modelIntent, { family: 'anthropic', strength: 'strong' }, 'the route intent follows the new alias');
+    assert.equal(after?.launch?.env.CRTR_MODEL_INTENT, 'anthropic/strong');
+});
+test('reshape freezes a new concrete --model override as the exact revive recipe', () => {
+    createNode(node('concrete-override-node', {
+        model_override: 'strong',
+        launch: { extensions: [], env: { CRTR_MODEL_INTENT: 'anthropic/strong' }, model: normalizeModel('strong', ladders), modelIntent: { family: 'anthropic', strength: 'strong' } },
+    }));
+    reshapeNode('concrete-override-node', { model: 'anthropic/claude-fable-5:high' });
+    const after = getNode('concrete-override-node');
+    assert.equal(after?.model_override, 'anthropic/claude-fable-5:high', 'the concrete pick is the durable override');
+    assert.equal(after?.launch?.model, 'anthropic/claude-fable-5:high', 'revive replays the exact spec');
     assert.equal(after?.launch?.modelExact, true, 'retries and revives reject substitutes');
     assert.equal(after?.launch?.modelIntent, undefined);
     assert.equal(after?.launch?.env.CRTR_MODEL_INTENT, undefined);

package/dist/core/model-config.d.ts

@@ -0,0 +1,20 @@
+import type { ModelRoutingConfig, ModelStrength } from '../types.js';
+export type CoreModelRoute = {
+    family: string;
+    credentialSource: string;
+    providerId: string;
+    models: Record<ModelStrength, string>;
+};
+export type CoreKindAssignment = {
+    model: string;
+    orchestratorModel?: string;
+};
+export type CoreModelConfig = {
+    modelRoutes: Record<string, CoreModelRoute>;
+    modelRouting: ModelRoutingConfig;
+    kinds: Record<string, CoreKindAssignment>;
+};
+/** Validate the complete Core-owned payload before its single user-scope write. */
+export declare function validateCoreModelConfig(value: unknown): CoreModelConfig;
+/** Write Core-owned fields atomically while retaining unrelated config and kind fields. */
+export declare function replaceCoreModelConfig(config: CoreModelConfig): void;

package/dist/core/model-config.js

@@ -0,0 +1,107 @@
+import { updateRawConfigAtomically } from './config.js';
+const strengths = ['ultra', 'strong', 'medium', 'light'];
+const logicalModel = /^[^/\s]+\/(ultra|strong|medium|light)$/;
+function object(value, name) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${name} must be an object`);
+    return value;
+}
+function nonempty(value, name) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new Error(`${name} must be a non-empty string`);
+    return value;
+}
+/** Validate the complete Core-owned payload before its single user-scope write. */
+export function validateCoreModelConfig(value) {
+    const raw = object(value, 'model config');
+    const routes = object(raw.modelRoutes, 'modelRoutes');
+    const modelRoutes = {};
+    for (const [id, value] of Object.entries(routes)) {
+        nonempty(id, 'route id');
+        const route = object(value, `modelRoutes.${id}`);
+        const providerId = nonempty(route.providerId, `modelRoutes.${id}.providerId`);
+        const models = object(route.models, `modelRoutes.${id}.models`);
+        const complete = {};
+        for (const strength of strengths) {
+            const spec = nonempty(models[strength], `modelRoutes.${id}.models.${strength}`);
+            const slash = spec.indexOf('/');
+            if (slash <= 0 || slash === spec.length - 1 || spec.slice(0, slash) !== providerId) {
+                throw new Error(`modelRoutes.${id}.models.${strength} must be a ${providerId}/id ref`);
+            }
+            complete[strength] = spec;
+        }
+        for (const strength of Object.keys(models)) {
+            if (!strengths.includes(strength))
+                throw new Error(`modelRoutes.${id}.models.${strength} is not a model strength`);
+        }
+        modelRoutes[id] = {
+            family: nonempty(route.family, `modelRoutes.${id}.family`),
+            credentialSource: nonempty(route.credentialSource, `modelRoutes.${id}.credentialSource`),
+            providerId,
+            models: complete,
+        };
+    }
+    const modelRouting = object(raw.modelRouting, 'modelRouting');
+    for (const field of ['credentialSourceOrder', 'familyOrder']) {
+        if (modelRouting[field] !== undefined && (!Array.isArray(modelRouting[field]) || !modelRouting[field].every((item) => typeof item === 'string' && item.trim() !== ''))) {
+            throw new Error(`modelRouting.${field} must be an array of non-empty strings`);
+        }
+    }
+    if (modelRouting.strengthFallback !== undefined && (!Array.isArray(modelRouting.strengthFallback) || !modelRouting.strengthFallback.every((item) => strengths.includes(item)))) {
+        throw new Error('modelRouting.strengthFallback must be an array of model strengths');
+    }
+    const families = new Set(Object.values(modelRoutes).map((route) => route.family));
+    const credentialSources = new Set(Object.values(modelRoutes).map((route) => route.credentialSource));
+    for (const family of modelRouting.familyOrder ?? []) {
+        if (!families.has(family))
+            throw new Error(`modelRouting.familyOrder names unknown route family ${family}`);
+    }
+    for (const source of modelRouting.credentialSourceOrder ?? []) {
+        if (!credentialSources.has(source))
+            throw new Error(`modelRouting.credentialSourceOrder names unknown credential source ${source}`);
+    }
+    const rawKinds = object(raw.kinds, 'kinds');
+    const kinds = {};
+    for (const [kind, value] of Object.entries(rawKinds)) {
+        nonempty(kind, 'kind');
+        const assignment = object(value, `kinds.${kind}`);
+        const model = nonempty(assignment.model, `kinds.${kind}.model`);
+        if (!logicalModel.test(model))
+            throw new Error(`kinds.${kind}.model must be family/strength`);
+        if (!families.has(model.slice(0, model.lastIndexOf('/'))))
+            throw new Error(`kinds.${kind}.model names unknown route family`);
+        const orchestratorModel = assignment.orchestratorModel === undefined ? undefined : nonempty(assignment.orchestratorModel, `kinds.${kind}.orchestratorModel`);
+        if (orchestratorModel !== undefined && !logicalModel.test(orchestratorModel))
+            throw new Error(`kinds.${kind}.orchestratorModel must be family/strength`);
+        if (orchestratorModel !== undefined && !families.has(orchestratorModel.slice(0, orchestratorModel.lastIndexOf('/'))))
+            throw new Error(`kinds.${kind}.orchestratorModel names unknown route family`);
+        kinds[kind] = { model, ...(orchestratorModel === undefined ? {} : { orchestratorModel }) };
+    }
+    return { modelRoutes, modelRouting: structuredClone(modelRouting), kinds };
+}
+/** Write Core-owned fields atomically while retaining unrelated config and kind fields. */
+export function replaceCoreModelConfig(config) {
+    updateRawConfigAtomically('user', (latest) => {
+        const currentKinds = latest.kinds !== null && typeof latest.kinds === 'object' && !Array.isArray(latest.kinds)
+            ? latest.kinds
+            : {};
+        const kinds = Object.fromEntries(Object.entries(currentKinds).map(([kind, value]) => {
+            const previous = value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
+            const { model: _model, orchestratorModel: _orchestratorModel, ...unowned } = previous;
+            return [kind, unowned];
+        }));
+        for (const [kind, assignment] of Object.entries(config.kinds)) {
+            const previous = kinds[kind] !== null && typeof kinds[kind] === 'object' && !Array.isArray(kinds[kind])
+                ? kinds[kind]
+                : {};
+            // Materialize Core's inheritance here: omission cannot clear a lower scope field.
+            kinds[kind] = { ...previous, model: assignment.model, orchestratorModel: assignment.orchestratorModel ?? assignment.model };
+        }
+        return {
+            ...latest,
+            modelRoutes: structuredClone(config.modelRoutes),
+            modelRouting: structuredClone(config.modelRouting),
+            kinds,
+        };
+    });
+}

package/dist/core/model-routes.d.ts

@@ -59,6 +59,11 @@ export interface UnregisteredConcreteModel {
     candidate: RoutedCandidate;
     reason: 'unregistered';
 }
+export declare function parseModelSpec(spec: string): {
+    providerId: string;
+    modelId: string;
+    thinkingLevel?: string;
+} | undefined;
 /** Expand config-derived route order only. Availability never affects rank. */
 export declare function expandModelCandidates(request: ModelRequest, cwd?: string, profileId?: string | null): RoutedCandidate[];
 /** Identify the one permanently invalid recipe shape: a concrete/exact request

package/dist/core/model-routes.js

@@ -2,7 +2,7 @@ import { readMergedLaunchConfig } from './config.js';
 import { isManagedProvider, readRotationConfig, readSubscriptionPool, resolveProviderCandidates, } from './subscription-state.js';
 const STRENGTHS = ['ultra', 'strong', 'medium', 'light'];
 const THINKING_SUFFIXES = new Set(['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
-function parseSpec(spec) {
+export function parseModelSpec(spec) {
     const slash = spec.indexOf('/');
     if (slash <= 0 || slash === spec.length - 1)
         return undefined;
@@ -43,13 +43,13 @@ export function expandModelCandidates(request, cwd, profileId) {
     const declarationFamilies = routeEntries.map(([, route]) => route.family).filter((value, index, all) => all.indexOf(value) === index);
     const declarationSources = routeEntries.map(([, route]) => route.credentialSource).filter((value, index, all) => all.indexOf(value) === index);
     if (request.kind === 'exact') {
-        const parsed = parseSpec(request.spec);
+        const parsed = parseModelSpec(request.spec);
         return parsed ? [{ routeId: 'exact', credentialSource: 'exact', family: parsed.providerId, strength: 'strong', ...parsed, rank: 0 }] : [];
     }
-    const concrete = request.kind === 'concrete' ? parseSpec(request.spec) : undefined;
+    const concrete = request.kind === 'concrete' ? parseModelSpec(request.spec) : undefined;
     const logical = request.kind === 'logical' ? request : undefined;
     const matchesConcrete = (spec, exactThinking) => {
-        const parsed = parseSpec(spec);
+        const parsed = parseModelSpec(spec);
         return parsed !== undefined
             && concrete !== undefined
             && parsed.providerId === concrete.providerId
@@ -79,7 +79,7 @@ export function expandModelCandidates(request, cwd, profileId) {
     const emitted = [];
     const seen = new Set();
     const append = (routeId, route, strength, spec) => {
-        const parsed = parseSpec(spec);
+        const parsed = parseModelSpec(spec);
         if (!parsed)
             return;
         if (concrete && parsed.modelId !== concrete.modelId)

package/dist/core/runtime/launch.d.ts

@@ -68,8 +68,13 @@ export interface LaunchBuildOptions {
     /** A newly supplied `--model` override. Resolve it through the target
      *  ladder and any quality floor once, then freeze the resulting concrete
      *  provider/id[:thinking] spec into the launch recipe so every launch,
-     *  revive, and retry consults exactly that model. Existing recipes instead
-     *  carry `modelExact`/`modelIntent` below verbatim. */
+     *  revive, and retry consults exactly that model — but ONLY when the raw
+     *  token names a concrete model. A PORTABLE ladder token (`medium`,
+     *  `anthropic/opus`) is a strength preference, not a model identity, so it
+     *  keeps its route intent and stays eligible for fallback; freezing it
+     *  would fail a node closed on a canvas whose only authenticated route is a
+     *  different provider. Existing recipes instead carry
+     *  `modelExact`/`modelIntent` below verbatim. */
     modelOverride?: boolean;
     /** The TARGET node's cwd — anchors the project-scope stack for kind/ladder
      *  resolution. Defaults to this process's own cwd, which is correct only

package/dist/core/runtime/launch.js

@@ -251,7 +251,8 @@ function buildLaunchSpecFromMerged(kind, mode, opts, merged) {
     const ladders = merged.modelLadders;
     const kindModel = mode === 'orchestrator' ? kindConfig?.orchestratorModel ?? kindConfig?.model : kindConfig?.model;
     const chosenModel = opts.modelExact === true ? opts.model : floorReviewModel(kind, opts.model, kindModel, ladders);
-    const exact = opts.modelExact === true || opts.modelOverride === true;
+    const exact = opts.modelExact === true
+        || (opts.modelOverride === true && opts.model !== undefined && !isPortableModelToken(opts.model));
     const resolvedModel = opts.modelExact === true
         ? chosenModel
         : (chosenModel !== undefined ? normalizeModel(chosenModel, ladders) : undefined);

package/dist/daemon/api/__tests__/model-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/daemon/api/__tests__/model-config.test.js

@@ -0,0 +1,73 @@
+import { after, afterEach, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ApiError } from '../../../api/errors.js';
+import { resetScopeCache } from '../../../core/scope.js';
+import { modelConfigRoutes } from '../handlers/model-config.js';
+const previousHome = process.env.HOME;
+const previousAgentDir = process.env['PI_CODING_AGENT_DIR'];
+let home = '';
+const payload = {
+    config_version: 'core-doc-digest',
+    modelRoutes: {
+        northlight: {
+            family: 'cloud', credentialSource: 'northlight', providerId: 'northlight',
+            models: { ultra: 'northlight/u', strong: 'northlight/s:high', medium: 'northlight/m', light: 'northlight/l' },
+        },
+    },
+    modelRouting: { familyOrder: ['cloud'], strengthFallback: ['strong', 'medium'] },
+    kinds: { developer: { model: 'cloud/medium' } },
+};
+beforeEach(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-model-config-'));
+    process.env.HOME = home;
+    const agentDir = join(home, 'agent');
+    mkdirSync(agentDir);
+    process.env['PI_CODING_AGENT_DIR'] = agentDir;
+    writeFileSync(join(agentDir, 'models.json'), JSON.stringify({
+        providers: { northlight: { baseUrl: 'http://127.0.0.1:1', api: 'openai-completions', apiKey: 'test', models: ['u', 's', 'm', 'l'].map((id) => ({ id, name: id })) } },
+    }));
+    resetScopeCache();
+});
+afterEach(() => {
+    rmSync(home, { recursive: true, force: true });
+    resetScopeCache();
+});
+after(() => {
+    if (previousHome === undefined)
+        delete process.env.HOME;
+    else
+        process.env.HOME = previousHome;
+    if (previousAgentDir === undefined)
+        delete process.env['PI_CODING_AGENT_DIR'];
+    else
+        process.env['PI_CODING_AGENT_DIR'] = previousAgentDir;
+    resetScopeCache();
+});
+function putRoute() {
+    const route = modelConfigRoutes.find((entry) => entry.method === 'PUT' && entry.pattern === '/v1/model-config');
+    assert.ok(route, 'PUT /v1/model-config is registered');
+    return route;
+}
+function context(body) {
+    return { method: 'PUT', path: '/v1/model-config', params: {}, query: new URLSearchParams(), body };
+}
+test('PUT atomically replaces Core-owned blocks without touching unrelated config', async () => {
+    const configPath = join(home, '.crouter', 'config.json');
+    mkdirSync(join(home, '.crouter'));
+    writeFileSync(configPath, JSON.stringify({ completion_bell: false, kinds: { developer: { tools: ['bash'], model: 'old/strong', orchestratorModel: 'old/ultra' } } }));
+    const result = await putRoute().handler(context(payload));
+    assert.deepEqual(result, { status: 200, body: { config_version: 'core-doc-digest', delivered: true } });
+    const written = JSON.parse(readFileSync(configPath, 'utf8'));
+    assert.equal(written.completion_bell, false);
+    assert.deepEqual(written.kinds.developer, { tools: ['bash'], model: 'cloud/medium', orchestratorModel: 'cloud/medium' });
+    assert.deepEqual(written.modelRoutes, payload.modelRoutes);
+});
+test('PUT rejects invalid payloads and absent baked refs before writing', async () => {
+    const configPath = join(home, '.crouter', 'config.json');
+    await assert.rejects(async () => putRoute().handler(context({ ...payload, modelRoutes: { ...payload.modelRoutes, northlight: { ...payload.modelRoutes.northlight, models: { strong: 'northlight/s' } } } })), (error) => error instanceof ApiError && error.status === 400 && error.code === 'invalid_request');
+    await assert.rejects(async () => putRoute().handler(context({ ...payload, modelRoutes: { ...payload.modelRoutes, northlight: { ...payload.modelRoutes.northlight, models: { ...payload.modelRoutes.northlight.models, ultra: 'northlight/missing' } } } })), (error) => error instanceof ApiError && error.status === 422 && error.code === 'unprocessable');
+    assert.throws(() => readFileSync(configPath, 'utf8'), { code: 'ENOENT' });
+});

package/dist/daemon/api/__tests__/node-model-validation.test.js

@@ -103,7 +103,12 @@ test('promote and yield reject unregistered model recipes before reshaping the n
         assert.equal(after?.mode, before?.mode, `${operation} did not reshape the node`);
     }
 });
-test('promote and yield reject an unregistered resolved portable override before reshaping the node', async () => {
+// A portable override names a strength, not a model identity, so it is a route
+// request: the registry cannot pre-judge it, and the broker resolves it against
+// whichever route is authenticated at launch. Gating it on the ladder cell being
+// registered is what killed every `--model medium` child on a canvas whose only
+// authenticated route belonged to another provider.
+test('promote and yield accept a portable override whose ladder cell is unregistered', async () => {
     const cwd = join(home, 'target-project');
     mkdirSync(join(cwd, '.crouter'), { recursive: true });
     writeFileSync(join(cwd, '.crouter', 'config.json'), JSON.stringify({
@@ -113,14 +118,15 @@ test('promote and yield reject an unregistered resolved portable override before
     for (const operation of ['promote', 'yield']) {
         const id = `${operation}-portable-model`;
         createNode(node(id, cwd));
-        const before = getNode(id);
         const request = ctx('POST', `/v1/nodes/${id}/${operation}`, id, { model: 'openai/strong' });
-        await assert.rejects(() => operation === 'promote'
-            ? handlePromote(request, { modelRegistry: registry })
-            : handleYield(request, { modelRegistry: registry }), (error) => error instanceof CrtrError && error.code === 'usage' && /target-openai\/missing-strong/.test(error.message));
+        if (operation === 'promote')
+            await handlePromote(request, { modelRegistry: registry });
+        else
+            await handleYield(request, { modelRegistry: registry });
         const after = getNode(id);
-        assert.deepEqual(after?.launch, before?.launch, `${operation} did not rewrite the launch recipe`);
-        assert.equal(after?.mode, before?.mode, `${operation} did not reshape the node`);
+        assert.equal(after?.launch?.model, 'target-openai/missing-strong', `${operation} resolves the tier against the target scope`);
+        assert.equal(after?.launch?.modelExact, undefined, `${operation} leaves the strength request routable`);
+        assert.deepEqual(after?.launch?.modelIntent, { family: 'openai', strength: 'strong' }, `${operation} keeps the route intent`);
     }
 });
 test('config normalizes portable models against the target node scope', async () => {
@@ -151,5 +157,7 @@ test('config normalizes portable models against the target node scope', async ()
     await handleConfig(ctx('PATCH', `/v1/nodes/${id}/config`, id, { model: 'openai/strong' }), { modelRegistry: registry });
     assert.equal(getNode(id)?.model_override, 'target-openai/o-strong');
     assert.equal(getNode(id)?.launch?.model, 'target-openai/o-strong');
+    // `config --model` records exactness in the model-swap path (updateModelRecipe),
+    // not in buildLaunchSpec, so a live user's pick freezes whatever its shape.
     assert.equal(getNode(id)?.launch?.modelExact, true, 'a config override cannot route away on revive');
 });

package/dist/daemon/api/handlers/model-config.d.ts

@@ -0,0 +1,2 @@
+import type { RouteTable } from '../router.js';
+export declare const modelConfigRoutes: RouteTable;

package/dist/daemon/api/handlers/model-config.js

@@ -0,0 +1,44 @@
+import { ApiError } from '../../../api/errors.js';
+import { validateCoreModelConfig, replaceCoreModelConfig } from '../../../core/model-config.js';
+import { parseModelSpec } from '../../../core/model-routes.js';
+import { openModelRegistry } from '../../../core/runtime/model-registry.js';
+function parseRequest(body) {
+    if (body === null || typeof body !== 'object' || Array.isArray(body))
+        throw new ApiError(400, 'invalid_request', 'model config must be an object');
+    const request = body;
+    if (typeof request.config_version !== 'string' || request.config_version.trim() === '') {
+        throw new ApiError(400, 'invalid_request', 'config_version must be a non-empty string');
+    }
+    try {
+        return { configVersion: request.config_version, config: validateCoreModelConfig(request) };
+    }
+    catch (error) {
+        throw new ApiError(400, 'invalid_request', error instanceof Error ? error.message : String(error));
+    }
+}
+/** Validate route refs against this image's baked descriptor catalog before disk changes. */
+async function validateCatalog(config) {
+    const registry = await openModelRegistry();
+    for (const route of Object.values(config.modelRoutes)) {
+        for (const spec of Object.values(route.models)) {
+            const model = parseModelSpec(spec);
+            if (model === undefined || registry.find(model.providerId, model.modelId) === undefined) {
+                throw new ApiError(422, 'unprocessable', `route ref ${spec} is absent from the baked model registry`);
+            }
+        }
+    }
+}
+async function handlePut(ctx) {
+    const { configVersion, config } = parseRequest(ctx.body);
+    await validateCatalog(config);
+    try {
+        replaceCoreModelConfig(config);
+    }
+    catch (error) {
+        throw new ApiError(500, 'model_config_write_failed', error instanceof Error ? error.message : String(error));
+    }
+    return { status: 200, body: { config_version: configVersion, delivered: true } };
+}
+export const modelConfigRoutes = [
+    { method: 'PUT', pattern: '/v1/model-config', handler: handlePut },
+];

package/dist/daemon/api/server.js

@@ -36,6 +36,7 @@ import { feedbackCommentRoutes } from './handlers/feedback-comments.js';
 import { memoryRoutes } from './handlers/memory.js';
 import { messageRoutes } from './handlers/messages.js';
 import { modelAuthRoutes } from './handlers/modelauth.js';
+import { modelConfigRoutes } from './handlers/model-config.js';
 import { nodeRoutes } from './handlers/nodes.js';
 import { profileRoutes } from './handlers/profiles.js';
 import { prospectiveChatInventoryRoutes } from './handlers/prospective-chat-inventory.js';
@@ -67,6 +68,7 @@ function buildRouter() {
         .registerAll(cronRoutes)
         .registerAll(profileRoutes)
         .registerAll(modelAuthRoutes)
+        .registerAll(modelConfigRoutes)
         .registerAll(humanRoutes)
         .registerAll(reviewRoutes)
         .registerAll(reviewCommentRoutes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.279",
+  "version": "0.3.281",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.279",
+  "version": "0.3.281",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.279",
+      "version": "0.3.281",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {