@north-light/crouter 0.3.279 → 0.3.280

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/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/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/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.280",
   "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.280",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.279",
+      "version": "0.3.280",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {