@yeaft/webchat-agent 1.0.606 → 1.0.607

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.606",
+  "version": "1.0.607",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/person/inspection.js

@@ -18,7 +18,7 @@ export function personName(value) {
   return text(value.trim(), 160);
 }
 const pick = (value, keys) => value == null ? null : Object.fromEntries(keys.filter(key => Object.hasOwn(value, key)).map(key => [key, value[key]]));
-export const settingsView = value => pick(value, ['autonomyEnabled', 'modelCandidates']);
+export const settingsView = value => pick(value, ['autonomyEnabled', 'modelCandidates', 'defaultModel']);
 export function messageView(value) {
   const result = pick(value, ['id', 'schemaVersion', 'revision', 'seq', 'episodeId', 'clientMessageId', 'role', 'text', 'createdAt']);
   if (result && Array.isArray(value.attachments)) result.attachments = value.attachments.slice(0, 4)

package/yeaft/person/provider.js

@@ -14,6 +14,29 @@ export function validateModelCandidates(refs) {
       new Set(refs).size !== refs.length) fail('MODEL_SELECTION');
 }
 
+export function validateDefaultModel(ref) {
+  if (ref !== null) validateModelCandidates([ref]);
+}
+
+/** Resolve router ownership before allowlisting or bounding the Person catalog. */
+export function resolveAgentDefaultModel(config) {
+  const models = config.availableModels || [], requested = config.primaryModel || config.model;
+  const model = models.find(m => (m.ref || m.id) === requested) || models.find(m => m.id === requested);
+  return model?.ref || (model?.id?.includes('/') ? model.id : null);
+}
+
+/** Shared validation for settings, status and runtime; never broaden an explicit subset. */
+export function selectPersonModels({ availableModels, modelCandidates = [], defaultModel = null }) {
+  validateModelCandidates(modelCandidates);
+  validateDefaultModel(defaultModel);
+  if (modelCandidates.some(ref => !availableModels.some(model => model.id === ref))) fail('MODEL_SELECTION');
+  const catalog = modelCandidates.length ? availableModels.filter(model => modelCandidates.includes(model.id))
+    : availableModels.slice(0, MODEL_LIMITS.candidates);
+  if (defaultModel !== null && !catalog.some(model => model.id === defaultModel)) fail('MODEL_SELECTION');
+  if (!catalog.length) fail('MODEL_UNAVAILABLE');
+  return { catalog, defaultSelection: { model: defaultModel ?? catalog[0].id, effort: null } };
+}
+
 // Bounds apply to the actual wire protocol, not a vision flag or compressed file size.
 // OpenAI tile models (including 2833 base tokens for gpt-4o-mini) have a fixed
 // cost only at explicit low detail. Known patch models below fit <=6144 patches
@@ -38,17 +61,13 @@ function imageInputBudget(modelId, protocol) {
 }
 
 /** Only configured native API models; no Session initialization or implicit credential fallback. */
-export async function createPersonProvider({ yeaftDir, config: suppliedConfig, adapter: suppliedAdapter, allowedModels, effortEnabled = process.env.YEAFT_THINKING_V1 === '1', modelCandidates = [] }) {
+export async function createPersonProvider({ yeaftDir, config: suppliedConfig, adapter: suppliedAdapter, allowedModels, effortEnabled = process.env.YEAFT_THINKING_V1 === '1', modelCandidates = [], defaultModel = null }) {
   const config = structuredClone(suppliedConfig || loadConfig({ dir: yeaftDir }));
   if (!config.providers?.length && !suppliedAdapter) fail('MODEL_UNAVAILABLE');
   const models = config.availableModels || [];
-  const requestedDefault = config.primaryModel || config.model;
-  // Match router ownership: exact qualified ref first; bare IDs use the first
-  // configured provider. Resolve before allowlisting, sorting or truncating.
-  const defaultModel = models.find(m => (m.ref || m.id) === requestedDefault)
-    || models.find(m => m.id === requestedDefault);
-  const defaultRef = defaultModel?.ref || defaultModel?.id;
+  const agentDefaultModel = resolveAgentDefaultModel(config);
   validateModelCandidates(modelCandidates);
+  validateDefaultModel(defaultModel);
   const available = models.filter(m => !allowedModels || allowedModels.includes(m.ref || m.id));
   const routingProviders = (config.providers || []).map(normalizeKnownProviderForRuntime);
   const safeModels = available.map(m => {
@@ -76,19 +95,16 @@ export async function createPersonProvider({ yeaftDir, config: suppliedConfig, a
     return { id: m.ref || m.id, efforts, maxOutput, supportsImages: imageBudget !== null, imageBudget,
       contextWindow: Math.floor(resolveContextWindow(m.id, { ...config, modelInfo: m })) };
   }).filter(m => typeof m.id === 'string' && m.id.length <= 256 && m.contextWindow > m.maxOutput + 1024 && m.maxOutput >= 256);
-  safeModels.sort((a, b) => Number(b.id === defaultRef) - Number(a.id === defaultRef));
+  safeModels.sort((a, b) => Number(b.id === agentDefaultModel) - Number(a.id === agentDefaultModel));
   const seen = new Set();
   const uniqueModels = safeModels.filter(model => !seen.has(model.id) && seen.add(model.id));
   const availableModels = uniqueModels.slice(0, MODEL_LIMITS.available);
   // A UI catalog must not be the bounded episode choice set: model 9+ remains selectable.
   // Explicit lists are validated, never silently truncated or broadened on stale config.
-  if (modelCandidates.some(ref => !availableModels.some(model => model.id === ref))) fail('MODEL_SELECTION');
-  const catalog = modelCandidates.length ? availableModels.filter(model => modelCandidates.includes(model.id))
-    : availableModels.slice(0, MODEL_LIMITS.candidates);
-  if (!catalog.length) fail('MODEL_UNAVAILABLE');
+  const { catalog, defaultSelection } = selectPersonModels({ availableModels, modelCandidates, defaultModel });
   const adapter = suppliedAdapter || await createLLMAdapter(config);
   return { adapter, catalog, availableModels, availableModelsTruncated: uniqueModels.length > MODEL_LIMITS.available,
-    catalogRevision: digest(catalog), defaultSelection: { model: catalog[0].id, effort: null }, effortEnabled };
+    catalogRevision: digest(catalog), defaultSelection, agentDefaultModel, effortEnabled };
 }
 
 export function abortable(promise, signal) {

package/yeaft/person/repository.js

@@ -109,7 +109,7 @@ export class MongoPersonRepository {
         if (!p) {
           p = this.doc(scope, {
             name, soul: 'A continuous, curious and honest digital person. Preserve uncertainty, reconsider your judgments, distinguish imagination from experience, and respect permissions. You may disagree without acting without authority.',
-            soulRevision: 1, createdAt: new Date(), settings: { autonomyEnabled: false },
+            soulRevision: 1, createdAt: new Date(), settings: { autonomyEnabled: false, defaultModel: null },
             epoch: 0, writeSerial: 0, inputWatermark: 0, controlVersion: 0, stateVersion: 0,
             traceSeq: 0, messageSeq: 0, activeEpisodeId: null, leaseOwner: null, leaseUntil: new Date(0),
           });
@@ -198,7 +198,7 @@ export class MongoPersonRepository {
         messageId = randomUUID();
         await this.collections.messages.insertOne(this.doc(scope, { id: messageId, revision: 1, seq: p.messageSeq, episodeId: id, role: 'user', text, attachments, createdAt: new Date(), clientMessageId }), { session });
       }
-      const episode = this.doc(scope, { id, clientMessageId, requestHash, kind, text, messageId, attachments, modelCandidates: [...(p.settings.modelCandidates ?? [])], status: 'running', workerId, epoch: p.epoch,
+      const episode = this.doc(scope, { id, clientMessageId, requestHash, kind, text, messageId, attachments, modelCandidates: [...(p.settings.modelCandidates ?? [])], defaultModel: p.settings.defaultModel ?? null, status: 'running', workerId, epoch: p.epoch,
         baseStateVersion: p.stateVersion, inputWatermark: p.inputWatermark, controlVersion: p.controlVersion, budget, createdAt: new Date() });
       await this.collections.episodes.insertOne(episode, { session });
       await this.trace(session, p, id, 'accepted', { trigger: { kind, text, messageId, attachments }, baseStateVersion: p.stateVersion, budget });
@@ -455,12 +455,13 @@ export class MongoPersonRepository {
       return { cancelled: true, episodeId: p.activeEpisodeId };
     });
   }
-  async settings(ownerId, settings) {
+  async settings(ownerId, settings, expectedControlVersion) {
     return this.transaction(async session => {
       const scope = this.scope(ownerId);
       const p = await this.collections.persons.findOne(scope, { session });
       if (!p) fail('NOT_OPEN');
       if (p.activeEpisodeId) fail('BUSY'); // No implicit background API or deferred control effects.
+      if (expectedControlVersion !== undefined && p.controlVersion !== expectedControlVersion) fail('STALE');
       const { name, ...patch } = settings;
       if (Object.hasOwn(settings, 'name')) p.name = personName(name);
       // A partial update must preserve durable fields omitted from the public view.

package/yeaft/person/runtime.js

@@ -201,7 +201,7 @@ export class PersonRuntime {
     }, Math.max(100, Math.floor(this.repository.leaseMs / 3)));
     heartbeat.unref?.();
     try {
-      const provider = await abortable(this.getProvider(episode.modelCandidates ?? []), signal);
+      const provider = await abortable(this.getProvider(episode.modelCandidates ?? [], episode.defaultModel ?? null), signal);
       const snapshot = await abortable(this.repository.context(episode), signal);
       const attachments = episode.attachments?.length ? await abortable(this.repository.episodeAttachments(episode), signal) : [];
       // Bind recovered evidence using the repository's authoritative Person ID,
@@ -209,7 +209,7 @@ export class PersonRuntime {
       await this.tasks()?.context({ episode, parentToolRegistry: this.parentToolRegistry });
       signal.throwIfAborted();
       let selection = { ...provider.defaultSelection, reason: 'configured-default', origin: 'bootstrap' };
-      if (snapshot.state.lastSelection) {
+      if (episode.defaultModel == null && snapshot.state.lastSelection) {
         try { validateSelection(snapshot.state.lastSelection, provider.catalog); selection = { ...snapshot.state.lastSelection, reason: 'last-accepted-choice', origin: 'persisted' }; }
         catch { await this.repository.append(episode, 'selection_rejected', { requested: snapshot.state.lastSelection, code: 'MODEL_SELECTION', fallback: 'configured-default' }); }
       }

package/yeaft/person/service.js

@@ -6,7 +6,7 @@ import { PersonRuntime } from './runtime.js';
 import { allowedNativeToolIds } from './native-tools.js';
 import { loadConfig } from '../config.js';
 import { validateFiles } from './attachments.js';
-import { createPersonProvider, validateModelCandidates } from './provider.js';
+import { createPersonProvider, resolveAgentDefaultModel, selectPersonModels, validateDefaultModel, validateModelCandidates } from './provider.js';
 import { fail, identifier, LIMITS, object, page, personTaskRequest, safeError, text } from './contracts.js';
 import { inspectRequest, personName, searchRequest } from './inspection.js';
 
@@ -46,7 +46,7 @@ export function createPersonService(options = {}) {
   if (memory) repository.recall = (ownerId, args = {}, { signal } = {}) => args.query?.trim()
     ? memory.recall(ownerId, args, { signal }) : literalRecall(ownerId, args);
   // Config/adapter are loaded per explicit episode, not a permanent stale cache.
-  const getProvider = (modelCandidates = []) => createPersonProvider({ yeaftDir, config, adapter, allowedModels, modelCandidates, effortEnabled: options.effortEnabled });
+  const getProvider = (modelCandidates = [], defaultModel = null) => createPersonProvider({ yeaftDir, config, adapter, allowedModels, modelCandidates, defaultModel, effortEnabled: options.effortEnabled });
   const runtime = new PersonRuntime({ repository, getProvider, budget: { calls, timeoutMs }, workDir, yeaftDir, config, namespace });
   let closed = false;
   const requests = new Set();
@@ -56,23 +56,32 @@ export function createPersonService(options = {}) {
     if (typeof op !== 'string') fail('INVALID_REQUEST');
     if (op === 'status') {
       object(payload, []);
-      if (!configured) return { renameSupported: true, configured: false, storage, reason: 'Digital person storage configuration is missing.', storageReady: false, modelReady: false };
+      let agentDefaultModel = null;
+      try { agentDefaultModel = resolveAgentDefaultModel(config ?? loadConfig({ dir: yeaftDir })); } catch { /* Invalid/missing native config. */ }
+      const status = { renameSupported: true, defaultModelSupported: true, configured, storage, modelReady: false,
+        defaultModel: null, agentDefaultModel, modelCandidates: [], effectiveModelCandidates: [], effectiveDefaultModel: null };
+      if (!configured) return { ...status, reason: 'Digital person storage configuration is missing.', storageReady: false };
       try { await repository.init(); }
-      catch (error) { return { renameSupported: true, configured: true, storage, reason: safeError(error).message, storageReady: false, modelReady: false }; }
-      let modelCandidates = [];
-      try { modelCandidates = (await repository.getPerson(ownerId)).settings.modelCandidates ?? []; }
-      catch (error) { if (error.code !== 'NOT_OPEN') throw error; }
+      catch (error) { return { ...status, reason: safeError(error).message, storageReady: false }; }
+      try {
+        const settings = (await repository.getPerson(ownerId)).settings;
+        status.modelCandidates = settings.modelCandidates ?? [];
+        status.defaultModel = settings.defaultModel ?? null;
+      } catch (error) { if (error.code !== 'NOT_OPEN') throw error; }
       try {
         const provider = await getProvider();
-        let modelReady = true;
         try {
-          validateModelCandidates(modelCandidates);
-          if (modelCandidates.some(ref => !provider.availableModels.some(model => model.id === ref))) modelReady = false;
-        } catch { modelReady = false; }
-        return { renameSupported: true, configured: true, storage, reason: modelReady ? null : 'Saved model candidates are unavailable; choose models or reset to Agent defaults.',
-          storageReady: true, modelReady, models: provider.availableModels, availableModels: provider.availableModels,
-          availableModelsTruncated: provider.availableModelsTruncated, modelCandidates, autonomySupported: false };
-      } catch { return { renameSupported: true, configured: true, storage, reason: 'No permitted native model is configured for digital person.', storageReady: true, modelReady: false, models: [], availableModels: [], modelCandidates }; }
+          const selected = selectPersonModels({ availableModels: provider.availableModels,
+            modelCandidates: status.modelCandidates, defaultModel: status.defaultModel });
+          status.modelReady = true;
+          status.effectiveModelCandidates = selected.catalog.map(model => model.id);
+          status.effectiveDefaultModel = selected.defaultSelection.model;
+        } catch { /* Stale settings remain visible, but do not grant fallback candidates. */ }
+        return { ...status, agentDefaultModel: provider.agentDefaultModel,
+          reason: status.modelReady ? null : 'Saved model settings are unavailable; choose models or reset to Agent defaults.',
+          storageReady: true, models: provider.availableModels, availableModels: provider.availableModels,
+          availableModelsTruncated: provider.availableModelsTruncated, autonomySupported: false };
+      } catch { return { ...status, reason: 'No permitted native model is configured for digital person.', storageReady: true, models: [], availableModels: [] }; }
     }
     if (!configured) fail('NOT_CONFIGURED');
     switch (op) {
@@ -143,21 +152,30 @@ export function createPersonService(options = {}) {
         } finally { release(); }
       }
       case 'settings': {
-        object(payload, ['name', 'autonomyEnabled', 'modelCandidates'], []);
+        object(payload, ['name', 'autonomyEnabled', 'modelCandidates', 'defaultModel'], []);
         const patch = { ...payload };
         if (Object.hasOwn(patch, 'name')) patch.name = personName(patch.name);
         if (Object.hasOwn(payload, 'autonomyEnabled') && typeof payload.autonomyEnabled !== 'boolean') fail('INVALID_REQUEST');
-        if (Object.hasOwn(payload, 'modelCandidates')) {
-          const refs = payload.modelCandidates;
-          validateModelCandidates(refs);
-          if (refs.length) {
+        if (Object.hasOwn(payload, 'modelCandidates')) validateModelCandidates(payload.modelCandidates);
+        if (Object.hasOwn(payload, 'defaultModel')) validateDefaultModel(payload.defaultModel);
+        // Timer-driven autonomy is deliberately not claimed or silently enabled.
+        if (payload.autonomyEnabled === true) fail('UNSUPPORTED');
+        let expectedControlVersion;
+        if (Object.hasOwn(payload, 'modelCandidates') || Object.hasOwn(payload, 'defaultModel')) {
+          const prior = await repository.getPerson(ownerId);
+          if (prior.activeEpisodeId) fail('BUSY');
+          const merged = { modelCandidates: [], defaultModel: null, ...prior.settings, ...patch };
+          validateModelCandidates(merged.modelCandidates);
+          validateDefaultModel(merged.defaultModel);
+          // An automatic reset must also work when no model is currently available.
+          if (merged.modelCandidates.length || merged.defaultModel !== null) {
             const provider = await getProvider();
-            if (refs.some(ref => !provider.availableModels.some(model => model.id === ref))) fail('MODEL_SELECTION');
+            selectPersonModels({ availableModels: provider.availableModels, modelCandidates: merged.modelCandidates, defaultModel: merged.defaultModel });
           }
+          // Fence the merge base across concurrent services; retry from fresh settings.
+          expectedControlVersion = prior.controlVersion;
         }
-        // Timer-driven autonomy is deliberately not claimed or silently enabled.
-        if (payload.autonomyEnabled === true) fail('UNSUPPORTED');
-        return repository.settings(ownerId, patch);
+        return repository.settings(ownerId, patch, expectedControlVersion);
       }
       default: fail('INVALID_REQUEST');
     }

package/yeaft/person/sqlite-repository.js

@@ -103,7 +103,7 @@ export class SqlitePersonRepository {
   async commit(episode, proposal, selection, callId, reportedSources = new Map()) { return this.request('commit', [episode, proposal, selection, callId, reportedSources]); }
   async finish(episode, status, code) { return this.request('finish', [episode, status, code]); }
   async cancel(ownerId, episodeId) { return this.request('cancel', [ownerId, episodeId]); }
-  async settings(ownerId, settings) { return this.request('settings', [ownerId, settings]); }
+  async settings(ownerId, settings, expectedControlVersion) { return this.request('settings', [ownerId, settings, expectedControlVersion]); }
   async list(ownerId, collection, options, filter) { return this.request('list', [ownerId, collection, options, filter]); }
   async snapshot(ownerId) { return this.request('snapshot', [ownerId]); }
   async inspect(ownerId, options, nativeToolIds) { return this.request('inspect', [ownerId, options, nativeToolIds]); }

package/yeaft/person/sqlite-store.js

@@ -151,7 +151,7 @@ export class SqlitePersonStore {
     if (!p) {
       p = this.doc(scope, {
         name, soul: 'A continuous, curious and honest digital person. Preserve uncertainty, reconsider your judgments, distinguish imagination from experience, and respect permissions. You may disagree without acting without authority.',
-        soulRevision: 1, createdAt: this.now, settings: { autonomyEnabled: false },
+        soulRevision: 1, createdAt: this.now, settings: { autonomyEnabled: false, defaultModel: null },
         epoch: 0, writeSerial: 0, inputWatermark: 0, controlVersion: 0, stateVersion: 0,
         traceSeq: 0, messageSeq: 0, activeEpisodeId: null, leaseOwner: null, leaseUntil: new Date(0),
       });
@@ -223,7 +223,7 @@ export class SqlitePersonStore {
       const message = this.doc(scope, { id: messageId, revision: 1, seq: p.messageSeq, episodeId: id, role: 'user', text: input, attachments, createdAt: this.now, clientMessageId });
       this.put('messages', message, true); this.journal(scope, 'messages', message);
     }
-    const episode = this.doc(scope, { id, clientMessageId, requestHash, kind, text: input, messageId, attachments, modelCandidates: [...(p.settings.modelCandidates ?? [])], status: 'running', workerId, epoch: p.epoch,
+    const episode = this.doc(scope, { id, clientMessageId, requestHash, kind, text: input, messageId, attachments, modelCandidates: [...(p.settings.modelCandidates ?? [])], defaultModel: p.settings.defaultModel ?? null, status: 'running', workerId, epoch: p.epoch,
       baseStateVersion: p.stateVersion, inputWatermark: p.inputWatermark, controlVersion: p.controlVersion, budget, createdAt: this.now });
     this.put('episodes', episode, true);
     this.trace(ownerId, id, 'accepted', { trigger: { kind, text: input, messageId, attachments }, baseStateVersion: p.stateVersion, budget });
@@ -419,9 +419,10 @@ export class SqlitePersonStore {
     this.trace(ownerId, id, 'cancelled', { code: 'CANCELLED' });
     return { cancelled: true, episodeId: id };
   }
-  settings(ownerId, settings) {
+  settings(ownerId, settings, expectedControlVersion) {
     const p = this.getPerson(ownerId);
     if (p.activeEpisodeId) fail('BUSY');
+    if (expectedControlVersion !== undefined && p.controlVersion !== expectedControlVersion) fail('STALE');
     const { name, ...patch } = settings;
     if (Object.hasOwn(settings, 'name')) p.name = personName(name);
     // A partial update must preserve durable fields omitted from the public view.