@yeaft/webchat-agent 1.0.551 → 1.0.552

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.551",
+  "version": "1.0.552",
   "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/work-center/assignment.js

@@ -162,17 +162,21 @@ function availableModel(config, ref) {
   if (models.length === 0) return null;
   const parsed = parseModelRef(ref);
   return models.find(model => model.ref === ref)
-    || models.find(model => !parsed.providerName && model.id === parsed.modelId)
+    || models.find(model => model.id === parsed.modelId
+      && (!parsed.providerName || model.provider === parsed.providerName))
     || null;
 }
 
-export function resolveWorkItemModel(config, vp, rawPolicy) {
+export function resolveWorkItemModel(config, vp, rawPolicy, modelTags = {}) {
   const policy = normalizeModelPolicy(rawPolicy);
   let model;
   let source;
   if (policy.mode === 'specific') {
     model = policy.model;
     source = 'stage-specific';
+  } else if (policy.mode === 'tag') {
+    model = modelTags[policy.tag] || null;
+    source = `tag:${policy.tag}`;
   } else if (policy.mode === 'primary') {
     model = config.primaryModel || config.model || null;
     source = 'agent-primary';
@@ -191,8 +195,9 @@ export function resolveWorkItemModel(config, vp, rawPolicy) {
   if (Array.isArray(config.availableModels) && config.availableModels.length > 0 && !available) {
     throw policyError(`Configured Work Center model is unavailable: ${model}`);
   }
+  if (policy.mode === 'tag' && available?.ref) model = available.ref;
   const effortOptions = Array.isArray(available?.effortOptions) ? available.effortOptions : [];
-  const effortOrder = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+  const effortOrder = ['medium', 'high', 'xhigh'];
   const requestedIndex = effortOrder.indexOf(policy.effort);
   const effort = !policy.effort || effortOptions.length === 0
     ? null

package/yeaft/work-center/coordinator.js

@@ -20,7 +20,10 @@ import { isDynamicWorkItem } from './execution-mode.js';
 import { applyCoordinatorReplan } from './plan-mutation.js';
 import { buildWorkItemAttachmentContext } from './attachments.js';
 import { sanitizeDiagnosticText } from './debug-projection.js';
-import { generatedActionGraphRules } from './workflow.js';
+import {
+  DEFAULT_WORK_CENTER_MODEL_TAGS,
+  generatedActionGraphRules,
+} from './workflow.js';
 import { workItemCapabilityContext } from './capabilities.js';
 
 const COORDINATOR_MAX_REPLY_CHARS = 8_000;
@@ -900,7 +903,12 @@ export class WorkItemCoordinator {
             ...(settings?.modelPolicy || {}),
             effort: settings?.actionModelPolicies?.triage?.effort || settings?.modelPolicy?.effort || 'high',
           };
-          resolved = resolveWorkItemModel(runtime.config, assignment.vp, coordinatorPolicy);
+          resolved = resolveWorkItemModel(
+            runtime.config,
+            assignment.vp,
+            coordinatorPolicy,
+            settings?.modelTags || DEFAULT_WORK_CENTER_MODEL_TAGS,
+          );
         } catch (error) {
           throw coordinatorExecutionError(error, 'selection', language);
         }

package/yeaft/work-center/planner.js

@@ -1,5 +1,5 @@
 import { resolveWorkItemModel, selectWorkItemVp } from './assignment.js';
-import { resolveWorkflowSnapshot } from './workflow.js';
+import { normalizeWorkCenterSettings, resolveWorkflowSnapshot } from './workflow.js';
 
 function publicVp(vp) {
   return vp ? {
@@ -17,6 +17,7 @@ function publicVp(vp) {
 }
 
 export function previewWorkCenterPlan({ settings, workflowId, stageOverrides, registry, config }) {
+  const normalizedSettings = normalizeWorkCenterSettings(settings);
   const workflow = resolveWorkflowSnapshot(settings, workflowId, stageOverrides);
   const vps = registry.listVps();
   const syntheticRuns = [];
@@ -28,7 +29,12 @@ export function previewWorkCenterPlan({ settings, workflowId, stageOverrides, re
         vps,
         priorRuns: syntheticRuns,
       });
-      const model = resolveWorkItemModel(config, assignment.vp, stage.modelPolicy);
+      const model = resolveWorkItemModel(
+        config,
+        assignment.vp,
+        stage.modelPolicy,
+        normalizedSettings.modelTags,
+      );
       syntheticRuns.push({
         actionType: stage.type,
         roleSnapshot: { actionType: stage.type },

package/yeaft/work-center/runner.js

@@ -37,7 +37,11 @@ import { loadMCPConfig } from '../config.js';
 import { MCPManager } from '../mcp.js';
 import { buildMcpFlattenedTools } from '../tools/mcp-tools.js';
 import { recallWorkspaceSessionContext } from './workspace-context.js';
-import { applyGeneratedPlan, BUILT_IN_ACTION_TYPES } from './workflow.js';
+import {
+  applyGeneratedPlan,
+  BUILT_IN_ACTION_TYPES,
+  DEFAULT_WORK_CENTER_MODEL_TAGS,
+} from './workflow.js';
 import { isDynamicWorkItem, usesMainlineContext } from './execution-mode.js';
 import {
   applyAdditivePlanProposal,
@@ -1081,8 +1085,10 @@ export class WorkItemRunner {
   async run({ workItem, action, run, signal, ownerBootId, onProgress, registerProgressReader, registerInputWake, onEngineEvent = null }) {
     assertCreateVpActionAuthority(workItem, action, this.registry);
     const runtime = await this.runtimeProvider();
+    const settings = this.policyProvider ? await this.policyProvider() : null;
     const currentSettings = ['ai', 'coordinator'].includes(workItem?.workflowSnapshot?.planningMode)
-      && this.policyProvider ? await this.policyProvider() : null;
+      ? settings
+      : null;
     const currentModelPolicy = currentSettings?.actionModelPolicies?.[action.type]
       || currentSettings?.actionModelPolicies?.custom
       || currentSettings?.modelPolicy
@@ -1125,7 +1131,16 @@ export class WorkItemRunner {
       error.retryable = false;
       throw error;
     }
-    const resolvedModel = resolveWorkItemModel(runtime.config, vp, executionAction.modelPolicy);
+    const fallbackModel = runtime.config.primaryModel || runtime.config.model || null;
+    const modelTags = settings?.modelTags || Object.fromEntries(
+      Object.keys(DEFAULT_WORK_CENTER_MODEL_TAGS).map(tag => [tag, fallbackModel]),
+    );
+    const resolvedModel = resolveWorkItemModel(
+      runtime.config,
+      vp,
+      executionAction.modelPolicy,
+      modelTags,
+    );
     const memoryBlock = recallWorkItemMemory(
       { ...runtime, yeaftDir: runtime.yeaftDir || this.yeaftDir },
       workItem,

package/yeaft/work-center/workflow.js

@@ -21,12 +21,35 @@ export const BUILT_IN_ACTION_TYPES = Object.freeze([
 ]);
 const STAGE_TYPES = new Set(BUILT_IN_ACTION_TYPES);
 const ASSIGNMENT_MODES = new Set(['auto', 'pool', 'fixed', 'planned']);
-const MODEL_MODES = new Set(['inherit', 'primary', 'fast', 'specific']);
-const MODEL_EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+const MODEL_MODES = new Set(['inherit', 'primary', 'fast', 'specific', 'tag']);
+const MODEL_EFFORTS = new Set(['medium', 'high', 'xhigh']);
 const WORKSPACE_MODES = new Set(['shared', 'read', 'isolated-write', 'integrate']);
-const HIGH_EFFORT_ACTION_TYPES = new Set(['triage', 'research', 'design', 'diagnose', 'review']);
 const ACTION_CONTEXT_QUOTE_MAX_BYTES = 8 * 1024;
 
+export const DEFAULT_WORK_CENTER_MODEL_TAGS = Object.freeze({
+  fast: 'gpt-5.6-luna',
+  balanced: 'gpt-5.6-sol',
+  ultimate: 'gpt-6-astra',
+});
+
+const ULTIMATE_ACTION_TYPES = new Set(['triage', 'research', 'design', 'diagnose', 'review']);
+const FAST_ACTION_TYPES = new Set(['document', 'deliver', 'write']);
+
+function normalizeModelTags(value) {
+  const source = value && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : DEFAULT_WORK_CENTER_MODEL_TAGS;
+  return Object.fromEntries(Object.entries(source)
+    .map(([tag, model]) => [canonicalActionId(tag), typeof model === 'string' ? model.trim() : ''])
+    .filter(([tag, model]) => tag && model));
+}
+
+function defaultActionModelTag(type) {
+  if (ULTIMATE_ACTION_TYPES.has(type)) return { tag: 'ultimate', effort: 'xhigh' };
+  if (FAST_ACTION_TYPES.has(type)) return { tag: 'fast', effort: 'medium' };
+  return { tag: 'balanced', effort: 'high' };
+}
+
 const DEFAULT_STAGE_INSTRUCTIONS = Object.freeze({
   triage: 'Turn the request into an executable contract. Inspect relevant repository facts before deciding the flow. Classify the WorkItem, identify constraints, risks, dependencies, and missing acceptance criteria, then plan only the Actions needed for this task. Do not implement. If the goal or acceptance criteria must change, submit a contractPatch and explain why.',
   research: 'Answer the Action objective with verifiable evidence. Search the repository and, when needed, authoritative external sources. Separate observed facts from inference, record unresolved uncertainty, and produce a concise conclusion that a later Action can use.',
@@ -97,26 +120,26 @@ const DEFAULT_SOFTWARE_CHANGE_STAGES = Object.freeze([
   {
     id: 'triage', name: 'Triage', type: 'triage',
     assignmentPolicy: { mode: 'auto', capability: 'triage', candidateVpIds: [], fixedVpId: null, separateFromStageTypes: [] },
-    modelPolicy: { mode: 'inherit', model: null, effort: null },
+    modelPolicy: { mode: 'tag', tag: 'ultimate', effort: 'xhigh' },
     maxAttempts: 2,
   },
   {
     id: 'implement', name: 'Implement', type: 'implement',
     assignmentPolicy: { mode: 'auto', capability: 'implement', candidateVpIds: [], fixedVpId: null, separateFromStageTypes: [] },
-    modelPolicy: { mode: 'inherit', model: null, effort: null },
+    modelPolicy: { mode: 'tag', tag: 'balanced', effort: 'high' },
     maxAttempts: 2,
   },
   {
     id: 'review', name: 'Review', type: 'review',
     assignmentPolicy: { mode: 'auto', capability: 'review', candidateVpIds: [], fixedVpId: null, separateFromStageTypes: ['implement'] },
-    modelPolicy: { mode: 'inherit', model: null, effort: null },
+    modelPolicy: { mode: 'tag', tag: 'ultimate', effort: 'xhigh' },
     maxAttempts: 2,
     changesRequestedStageId: 'implement',
   },
   {
     id: 'deliver', name: 'Deliver', type: 'deliver',
     assignmentPolicy: { mode: 'auto', capability: 'deliver', candidateVpIds: [], fixedVpId: null, separateFromStageTypes: [] },
-    modelPolicy: { mode: 'inherit', model: null, effort: null },
+    modelPolicy: { mode: 'tag', tag: 'fast', effort: 'medium' },
     maxAttempts: 2,
   },
 ]);
@@ -183,14 +206,18 @@ export function normalizeModelPolicy(value) {
   const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
   const mode = MODEL_MODES.has(source.mode) ? source.mode : 'inherit';
   const model = typeof source.model === 'string' && source.model.trim() ? source.model.trim() : null;
+  const tag = typeof source.tag === 'string' && source.tag.trim()
+    ? canonicalActionId(source.tag)
+    : null;
   const effort = MODEL_EFFORTS.has(source.effort) ? source.effort : null;
   if (mode === 'specific' && !model) throw new Error('Specific Work Center model policy requires a model');
-  return { mode, model, effort };
+  if (mode === 'tag' && !tag) throw new Error('Tagged Work Center model policy requires a tag');
+  return { mode, model, tag, effort };
 }
 
 export function defaultActionModelPolicy(type, fallback = null) {
-  const base = normalizeModelPolicy(fallback);
-  return { ...base, effort: HIGH_EFFORT_ACTION_TYPES.has(type) ? 'high' : 'medium' };
+  if (fallback) return normalizeModelPolicy(fallback);
+  return normalizeModelPolicy({ mode: 'tag', ...defaultActionModelTag(type) });
 }
 
 export function normalizeActionModelPolicies(value, fallback = null) {
@@ -308,8 +335,9 @@ export function defaultWorkCenterSettings() {
     maxConcurrentActions: 3,
     defaultWorkDir: '',
     globalInstructions: '',
-    modelPolicy: { mode: 'inherit', model: null, effort: null },
-    coordinatorModelPolicy: { mode: 'inherit', model: null, effort: 'high' },
+    modelTags: { ...DEFAULT_WORK_CENTER_MODEL_TAGS },
+    modelPolicy: normalizeModelPolicy({ mode: 'tag', tag: 'balanced', effort: 'high' }),
+    coordinatorModelPolicy: normalizeModelPolicy({ mode: 'tag', tag: 'ultimate', effort: 'xhigh' }),
     actionModelPolicies: normalizeActionModelPolicies(),
     actionInstructions: normalizeActionInstructions(),
     workflows: [normalizeWorkflowDefinition({
@@ -347,6 +375,7 @@ export function normalizeWorkCenterSettings(value) {
     maxConcurrentActions: Math.min(Math.max(Number(source.maxConcurrentActions) || 3, 1), 12),
     defaultWorkDir: typeof source.defaultWorkDir === 'string' ? source.defaultWorkDir.trim() : '',
     globalInstructions: normalizeGlobalInstructions(source.globalInstructions),
+    modelTags: normalizeModelTags(source.modelTags),
     modelPolicy: normalizeModelPolicy(source.modelPolicy || migratedModelPolicy),
     coordinatorModelPolicy: normalizeModelPolicy(
       source.coordinatorModelPolicy || { ...(source.modelPolicy || migratedModelPolicy), effort: 'high' },