@yeaft/webchat-agent 1.0.129 → 1.0.131

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.129",
+  "version": "1.0.131",
   "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/config.js

@@ -454,11 +454,14 @@ export function loadConfig(overrides = {}) {
       const p = normalizeKnownProviderForRuntime(rawProvider);
       const normalized = normalizeProviderModels(p);
       for (const m of normalized) {
-        // Avoid duplicates (first provider wins)
-        if (!config.availableModels.some(am => am.id === m.id)) {
+        const ref = p.name ? `${p.name}/${m.id}` : m.id;
+        // A model id is only unique inside its provider. Keep provider-qualified
+        // duplicates so an explicit `provider/model` never disappears from the
+        // runtime catalog just because another provider exposes the same id.
+        if (!config.availableModels.some(am => am.ref === ref)) {
           const entry = {
             id: m.id,
-            ref: p.name ? `${p.name}/${m.id}` : m.id,
+            ref,
             provider: p.name,
             label: m.id,
           };

package/yeaft/tools/create-work-item.js

@@ -60,7 +60,9 @@ Use this when work must continue beyond the current turn, needs role handoffs, r
       goal,
       acceptanceCriteria: cleanCriteria(input.acceptanceCriteria),
       workDir: typeof input.workDir === 'string' ? input.workDir.trim() : (ctx.cwd || ''),
-      workflowTemplate: 'software-change',
+      // The Agent-local Work Center settings choose the default workflow and
+      // freeze its policy snapshot. Tool callers create the contract; they do
+      // not get to smuggle a different dispatch policy into it.
       origin: {
         sessionId,
         messageId: ctx.inboundEnvelope?.msgId || null,

package/yeaft/work-center/assignment.js

@@ -0,0 +1,135 @@
+import { parseModelRef } from '../models.js';
+import { normalizeAssignmentPolicy, normalizeModelPolicy } from './workflow.js';
+
+function policyError(message) {
+  const error = new Error(message);
+  error.retryable = false;
+  return error;
+}
+
+const CAPABILITY_TERMS = Object.freeze({
+  triage: ['triage', 'requirement', 'flow', 'product', 'strategy', 'cross-domain', 'analysis'],
+  implement: ['implement', 'engineer', 'developer', 'engineering', 'systems', 'code', 'execution'],
+  test: ['test', 'testing', 'quality', 'qa', 'verification', 'reliability'],
+  review: ['review', 'reviewer', 'refactor', 'architecture', 'code-smells', 'readability', 'maintainability'],
+  deliver: ['deliver', 'release', 'ship', 'git', 'engineering', 'systems', 'execution'],
+  research: ['research', 'science', 'analysis', 'evidence', 'investigation'],
+  write: ['write', 'writer', 'writing', 'documentation', 'editor', 'communication'],
+});
+
+function vpSearchText(vp) {
+  return [
+    vp.id,
+    vp.name,
+    vp.nameZh,
+    vp.role,
+    vp.roleZh,
+    vp.area,
+    ...(Array.isArray(vp.aliases) ? vp.aliases : []),
+    ...(Array.isArray(vp.traits) ? vp.traits : []),
+  ].filter(Boolean).join(' ').toLowerCase();
+}
+
+function capabilityScore(vp, capability) {
+  const needle = String(capability || '').trim().toLowerCase();
+  if (!needle) return 0;
+  const text = vpSearchText(vp);
+  const terms = CAPABILITY_TERMS[needle] || [needle];
+  let score = 0;
+  for (const term of terms) {
+    if (text.includes(term)) score += term === needle ? 6 : 2;
+  }
+  if (String(vp.area || '').toLowerCase() === needle) score += 4;
+  return score;
+}
+
+function priorVpIdsForSeparation(policy, priorRuns) {
+  const separatedTypes = new Set(policy.separateFromStageTypes || []);
+  if (separatedTypes.size === 0) return new Set();
+  return new Set((priorRuns || [])
+    .filter(run => separatedTypes.has(run.actionType) || separatedTypes.has(run.roleSnapshot?.actionType))
+    .map(run => run.vpSnapshot?.id)
+    .filter(Boolean));
+}
+
+export function selectWorkItemVp({ policy: rawPolicy, stageType, vps, priorRuns = [] }) {
+  const policy = normalizeAssignmentPolicy(rawPolicy, stageType);
+  const all = Array.isArray(vps) ? vps.filter(vp => vp?.id) : [];
+  if (all.length === 0) throw policyError('Work Center has no available VPs');
+  const byId = new Map(all.map(vp => [vp.id, vp]));
+  const excluded = priorVpIdsForSeparation(policy, priorRuns);
+
+  if (policy.mode === 'fixed') {
+    const fixed = byId.get(policy.fixedVpId);
+    if (!fixed) throw policyError(`Fixed Work Center VP is unavailable: ${policy.fixedVpId}`);
+    if (excluded.has(fixed.id)) throw policyError(`Work Center separation policy excludes VP: ${fixed.id}`);
+    return { vp: fixed, reason: `fixed:${fixed.id}`, policy };
+  }
+
+  const pool = policy.mode === 'pool'
+    ? policy.candidateVpIds.map(id => byId.get(id)).filter(Boolean)
+    : all;
+  if (pool.length === 0) throw policyError('No configured Work Center VP candidates are available');
+  const eligible = pool.filter(vp => !excluded.has(vp.id));
+  if (eligible.length === 0) throw policyError('No Work Center VP satisfies the stage separation policy');
+
+  const ranked = eligible
+    .map(vp => ({ vp, score: capabilityScore(vp, policy.capability || stageType) }))
+    .sort((left, right) => right.score - left.score || left.vp.id.localeCompare(right.vp.id));
+  if (ranked[0].score === 0 && policy.mode === 'auto') {
+    throw policyError(`No Work Center VP matches capability: ${policy.capability || stageType}`);
+  }
+  return {
+    vp: ranked[0].vp,
+    reason: `${policy.mode}:${policy.capability || stageType}:score=${ranked[0].score}`,
+    policy,
+  };
+}
+
+function availableModel(config, ref) {
+  const models = Array.isArray(config.availableModels) ? config.availableModels : [];
+  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)
+    || null;
+}
+
+export function resolveWorkItemModel(config, vp, rawPolicy) {
+  const policy = normalizeModelPolicy(rawPolicy);
+  let model;
+  let source;
+  if (policy.mode === 'specific') {
+    model = policy.model;
+    source = 'stage-specific';
+  } else if (policy.mode === 'primary') {
+    model = config.primaryModel || config.model || null;
+    source = 'agent-primary';
+  } else if (policy.mode === 'fast') {
+    model = config.fastModel || null;
+    source = 'agent-fast';
+  } else if (vp.modelHint === 'fast') {
+    model = config.fastModel || config.primaryModel || config.model || null;
+    source = config.fastModel ? 'vp-fast' : 'vp-fast-primary-fallback';
+  } else {
+    model = config.primaryModel || config.model || null;
+    source = vp.modelHint === 'primary' ? 'vp-primary' : 'agent-default';
+  }
+  if (!model) throw policyError(`Work Center model policy "${policy.mode}" has no configured model`);
+  const available = availableModel(config, model);
+  if (Array.isArray(config.availableModels) && config.availableModels.length > 0 && !available) {
+    throw policyError(`Configured Work Center model is unavailable: ${model}`);
+  }
+  const effortOptions = Array.isArray(available?.effortOptions) ? available.effortOptions : [];
+  if (policy.effort && !effortOptions.includes(policy.effort)) {
+    throw policyError(`Configured Work Center effort is unsupported by ${model}: ${policy.effort}`);
+  }
+  const parsed = parseModelRef(model);
+  return {
+    model,
+    effort: policy.effort || null,
+    provider: available?.provider || parsed.providerName || null,
+    source,
+    policy,
+  };
+}

package/yeaft/work-center/bridge.js

@@ -1,11 +1,13 @@
 import ctx from '../../context.js';
 import { sendToServer } from '../../connection/buffer.js';
-import { ensureSessionLoaded } from '../web-bridge.js';
+import { ensureSessionLoaded, resetYeaftSession } from '../web-bridge.js';
 import { defaultRegistry } from '../vp/registry.js';
 import { scanVpLibrary } from '../vp/vp-store.js';
 import { WorkCenterService } from './service.js';
 import { WorkItemRunner } from './runner.js';
-import { projectWorkCenterEvent } from './projection.js';
+import { projectWorkCenterEvent, projectWorkItemDetail } from './projection.js';
+import { previewWorkCenterPlan } from './planner.js';
+import { readWorkCenterSettings } from './settings.js';
 import { join } from 'node:path';
 
 let service = null;
@@ -14,6 +16,8 @@ let shuttingDown = false;
 let shutdownPromise = null;
 let serviceFactory = null;
 
+const BROWSER_DETAIL_OPS = new Set(['get', 'create', 'update', 'start', 'cancel', 'guide', 'retry']);
+
 function send(msg) {
   sendToServer(msg);
 }
@@ -29,7 +33,7 @@ async function createDefaultService() {
     runtimeProvider: async () => {
       const runtime = await getRuntime();
       if (defaultRegistry.vpCount() === 0) {
-        for (const vp of scanVpLibrary({ dir: join(runtime.yeaftDir, 'virtual-persons') })) defaultRegistry.setVp(vp);
+        for (const vp of scanVpLibrary({ dir: join(yeaftDir, 'virtual-persons') })) defaultRegistry.setVp(vp);
       }
       return {
         ...runtime,
@@ -42,6 +46,27 @@ async function createDefaultService() {
   const created = new WorkCenterService({
     yeaftDir,
     runner,
+    runtimeInfoProvider: async () => {
+      const runtime = await getRuntime();
+      if (defaultRegistry.vpCount() === 0) {
+        for (const vp of scanVpLibrary({ dir: join(yeaftDir, 'virtual-persons') })) defaultRegistry.setVp(vp);
+      }
+      return {
+        vps: defaultRegistry.listVps().map(vp => ({
+          id: vp.id,
+          name: vp.name || vp.id,
+          nameZh: vp.nameZh || '',
+          role: vp.role || '',
+          roleZh: vp.roleZh || '',
+          area: vp.area || '',
+          traits: Array.isArray(vp.traits) ? vp.traits : [],
+          modelHint: vp.modelHint || null,
+        })),
+        models: Array.isArray(runtime.config.availableModels) ? runtime.config.availableModels : [],
+        primaryModel: runtime.config.primaryModel || runtime.config.model || null,
+        fastModel: runtime.config.fastModel || null,
+      };
+    },
     onEvent(event) {
       send({ type: 'work_center_event', event: projectWorkCenterEvent(event) });
     },
@@ -85,7 +110,28 @@ export async function handleWorkCenterRequest(msg) {
   const op = typeof msg.op === 'string' ? msg.op : '';
   try {
     const workCenter = await ensureWorkCenter();
-    const data = await workCenter.handle(op, msg.payload || {});
+    let data;
+    if (op === 'preview') {
+      const runtime = await getRuntime();
+      const yeaftDir = ctx.CONFIG?.yeaftDir;
+      if (!yeaftDir) throw new Error('Work Center requires a configured Yeaft directory');
+      if (defaultRegistry.vpCount() === 0) {
+        for (const vp of scanVpLibrary({ dir: join(yeaftDir, 'virtual-persons') })) defaultRegistry.setVp(vp);
+      }
+      data = previewWorkCenterPlan({
+        settings: readWorkCenterSettings(yeaftDir),
+        workflowId: msg.payload?.workflowTemplate,
+        stageOverrides: msg.payload?.stageOverrides,
+        registry: defaultRegistry,
+        config: runtime.config,
+      });
+    } else if (op === 'refresh_runtime') {
+      await resetYeaftSession();
+      data = await workCenter.handle('get_settings', {});
+    } else {
+      data = await workCenter.handle(op, msg.payload || {});
+    }
+    if (BROWSER_DETAIL_OPS.has(op)) data = projectWorkItemDetail(data);
     send({
       type: 'work_center_response',
       requestId,

package/yeaft/work-center/controller.js

@@ -1,4 +1,4 @@
-import { actionInstruction, getNextStep, initialActionFor, RUN_OUTCOMES } from './workflow.js';
+import { actionForStage, actionInstruction, getNextStep, initialActionFor, RUN_OUTCOMES } from './workflow.js';
 import { normalizeEvidence } from './evidence.js';
 
 function normalizeCriteria(value) {
@@ -48,10 +48,12 @@ function normalizeTerminalResult(result, action) {
   return normalized;
 }
 
-function contextEntry(action, result) {
+function contextEntry(action, result, run) {
   return {
     type: action.type,
-    role: action.requiredRole,
+    stageId: action.stageId || action.type,
+    vpId: run?.vpSnapshot?.id || action.requiredRole || null,
+    role: run?.roleSnapshot?.id || action.requiredRole || null,
     summary: result.summary || '',
     evidence: result.evidence || [],
     reviewDecision: result.reviewDecision || null,
@@ -69,12 +71,29 @@ export class WorkflowController {
       workflowTemplate: input.workflowTemplate || 'software-change',
       acceptanceCriteria: Array.isArray(input.acceptanceCriteria) ? input.acceptanceCriteria : [],
     };
-    const firstAction = input.start !== false ? initialActionFor(draft) : null;
+    let firstAction = input.start !== false ? initialActionFor(draft) : null;
+    if (firstAction && draft.reuseMemory !== false) {
+      const context = this.store.getReusableContext(draft.workDir, draft.id);
+      firstAction = {
+        ...firstAction,
+        context,
+        instruction: actionInstruction(firstAction, draft, context),
+      };
+    }
     return this.store.createWorkItem(draft, firstAction);
   }
 
   start(id) {
-    const detail = this.store.startWorkItemAtomic(id, initialActionFor);
+    const detail = this.store.startWorkItemAtomic(id, workItem => {
+      const action = initialActionFor(workItem);
+      if (workItem.reuseMemory === false) return action;
+      const context = this.store.getReusableContext(workItem.workDir, workItem.id);
+      return {
+        ...action,
+        context,
+        instruction: actionInstruction(action, workItem, context),
+      };
+    });
     if (!detail) throw new Error(`WorkItem not found: ${id}`);
     return detail;
   }
@@ -91,6 +110,41 @@ export class WorkflowController {
     return this.store.getWorkItemDetail(id);
   }
 
+  guide(id, input = {}) {
+    const guidance = typeof input.guidance === 'string' ? input.guidance.trim().slice(0, 8_000) : '';
+    if (!guidance) throw new Error('guidance is required');
+    const expected = {
+      actionId: typeof input.actionId === 'string' ? input.actionId : '',
+      revision: Number(input.revision),
+    };
+    if (!expected.actionId || !Number.isInteger(expected.revision)) {
+      throw new Error('actionId and revision are required for guidance');
+    }
+    const detail = this.store.addActionGuidance(id, guidance, expected, (workItem, previous) => {
+      const context = [...(previous.context || []), {
+        type: 'guidance',
+        role: 'user',
+        summary: guidance,
+        evidence: [],
+      }];
+      const step = {
+        type: previous.type,
+        stageId: previous.stageId || previous.type,
+        assignmentPolicy: previous.assignmentPolicy,
+        modelPolicy: previous.modelPolicy,
+        requiredRole: previous.requiredRole,
+      };
+      return {
+        ...step,
+        context,
+        instruction: actionInstruction(step, workItem, context),
+        maxAttempts: previous.maxAttempts || 2,
+      };
+    });
+    if (!detail) throw new Error(`WorkItem not found: ${id}`);
+    return detail;
+  }
+
   retry(id, input = {}) {
     const answer = typeof input.answer === 'string' ? input.answer.trim().slice(0, 8_000) : '';
     const detail = this.store.retryWorkItemAtomic(id, (workItem, previous, previousRun) => {
@@ -98,13 +152,21 @@ export class WorkflowController {
         throw new Error('answer is required to resume a waiting WorkItem');
       }
       const step = previous
-        ? { type: previous.type, requiredRole: previous.requiredRole }
+        ? {
+            type: previous.type,
+            stageId: previous.stageId || previous.type,
+            assignmentPolicy: previous.assignmentPolicy,
+            modelPolicy: previous.modelPolicy,
+            requiredRole: previous.requiredRole,
+          }
         : initialActionFor(workItem);
       const context = Array.isArray(previous?.context) ? [...previous.context] : [];
       if (previousRun) {
         context.push({
           type: previous.type,
-          role: previous.requiredRole,
+          stageId: previous.stageId || previous.type,
+          vpId: previousRun.vpSnapshot?.id || previous.requiredRole || null,
+          role: previousRun.roleSnapshot?.id || previous.requiredRole || null,
           summary: previousRun.summary || '',
           evidence: normalizeEvidence(previousRun.evidence),
           waitingReason: previousRun.waitingReason || null,
@@ -177,7 +239,7 @@ export class WorkflowController {
               revision: workItem.revision + 1,
             }
           : workItem;
-        const nextStep = getNextStep(workItem.workflowTemplate, action.type, result);
+        const nextStep = getNextStep(workItem, action.stageId || action.type, result);
         if (!nextStep) {
           return {
             actionStatus: 'completed',
@@ -188,17 +250,12 @@ export class WorkflowController {
           };
         }
 
-        const context = [...(action.context || []), contextEntry(action, result)];
+        const context = [...(action.context || []), contextEntry(action, result, activeRun)];
         return {
           actionStatus: 'completed',
           workItemStatus: 'ready',
           contractPatch,
-          nextAction: {
-            ...nextStep,
-            context,
-            instruction: actionInstruction(nextStep, effectiveWorkItem, context),
-            maxAttempts: 2,
-          },
+          nextAction: actionForStage(nextStep, effectiveWorkItem, context),
           eventType: 'action.completed',
           eventData: {
             nextActionType: nextStep.type,

package/yeaft/work-center/planner.js

@@ -0,0 +1,66 @@
+import { resolveWorkItemModel, selectWorkItemVp } from './assignment.js';
+import { resolveWorkflowSnapshot } from './workflow.js';
+
+function publicVp(vp) {
+  return vp ? {
+    id: vp.id,
+    name: vp.name || vp.id,
+    nameZh: vp.nameZh || '',
+    role: vp.role || '',
+    roleZh: vp.roleZh || '',
+    area: vp.area || '',
+    traits: Array.isArray(vp.traits) ? vp.traits : [],
+    modelHint: vp.modelHint || null,
+  } : null;
+}
+
+export function previewWorkCenterPlan({ settings, workflowId, stageOverrides, registry, config }) {
+  const workflow = resolveWorkflowSnapshot(settings, workflowId, stageOverrides);
+  const vps = registry.listVps();
+  const syntheticRuns = [];
+  const stages = workflow.stages.map(stage => {
+    try {
+      const assignment = selectWorkItemVp({
+        policy: stage.assignmentPolicy,
+        stageType: stage.type,
+        vps,
+        priorRuns: syntheticRuns,
+      });
+      const model = resolveWorkItemModel(config, assignment.vp, stage.modelPolicy);
+      syntheticRuns.push({
+        actionType: stage.type,
+        roleSnapshot: { actionType: stage.type },
+        vpSnapshot: { id: assignment.vp.id },
+      });
+      return {
+        id: stage.id,
+        name: stage.name,
+        type: stage.type,
+        assignmentPolicy: stage.assignmentPolicy,
+        modelPolicy: stage.modelPolicy,
+        selectedVp: publicVp(assignment.vp),
+        selectionReason: assignment.reason,
+        model: {
+          id: model.model,
+          provider: model.provider,
+          effort: model.effort,
+          source: model.source,
+        },
+        error: null,
+      };
+    } catch (error) {
+      return {
+        id: stage.id,
+        name: stage.name,
+        type: stage.type,
+        assignmentPolicy: stage.assignmentPolicy,
+        modelPolicy: stage.modelPolicy,
+        selectedVp: null,
+        selectionReason: null,
+        model: null,
+        error: error?.message || String(error),
+      };
+    }
+  });
+  return { workflow, stages, valid: stages.every(stage => !stage.error) };
+}

package/yeaft/work-center/projection.js

@@ -3,10 +3,104 @@ function currentAction(detail) {
   return detail.actions.find(action => action.id === detail.currentActionId) || null;
 }
 
+function projectAction(action) {
+  if (!action) return null;
+  return {
+    id: action.id,
+    workItemId: action.workItemId,
+    sequence: action.sequence,
+    type: action.type,
+    stageId: action.stageId || action.type,
+    assignmentPolicy: action.assignmentPolicy || null,
+    modelPolicy: action.modelPolicy || null,
+    requiredRole: action.requiredRole || '',
+    status: action.status,
+    attempt: action.attempt,
+    maxAttempts: action.maxAttempts,
+    currentRunId: action.currentRunId || null,
+    createdAt: action.createdAt,
+    updatedAt: action.updatedAt,
+  };
+}
+
+function projectRun(run) {
+  if (!run) return null;
+  return {
+    id: run.id,
+    actionId: run.actionId,
+    workItemId: run.workItemId,
+    status: run.status,
+    startedAt: run.startedAt,
+    expiresAt: run.expiresAt,
+    endedAt: run.endedAt || null,
+    summary: run.summary || '',
+    evidence: Array.isArray(run.evidence) ? run.evidence : [],
+    waitingReason: run.waitingReason || '',
+    error: run.error || '',
+    reviewDecision: run.reviewDecision || null,
+    roleSnapshot: run.roleSnapshot ? {
+      id: run.roleSnapshot.id,
+      actionType: run.roleSnapshot.actionType,
+      selectionReason: run.roleSnapshot.selectionReason,
+    } : null,
+    vpSnapshot: run.vpSnapshot ? {
+      id: run.vpSnapshot.id,
+      name: run.vpSnapshot.name || run.vpSnapshot.id,
+      nameZh: run.vpSnapshot.nameZh || '',
+      role: run.vpSnapshot.role || '',
+      roleZh: run.vpSnapshot.roleZh || '',
+    } : null,
+    modelSnapshot: run.modelSnapshot ? {
+      id: run.modelSnapshot.id,
+      provider: run.modelSnapshot.provider || null,
+      effort: run.modelSnapshot.effort || null,
+      source: run.modelSnapshot.source || null,
+    } : null,
+  };
+}
+
+function projectEvent(event) {
+  if (!event) return null;
+  return {
+    id: event.id,
+    workItemId: event.workItemId,
+    actionId: event.actionId || null,
+    runId: event.runId || null,
+    type: event.type,
+    createdAt: event.createdAt,
+  };
+}
+
+/**
+ * Authenticated browser detail DTO. Execution-only snapshots, VP persona,
+ * tool policy, prompts, event data, and local filesystem paths never cross the wire.
+ */
+export function projectWorkItemDetail(detail) {
+  if (!detail) return null;
+  return {
+    id: detail.id,
+    revision: detail.revision,
+    title: detail.title,
+    goal: detail.goal,
+    acceptanceCriteria: Array.isArray(detail.acceptanceCriteria) ? detail.acceptanceCriteria : [],
+    workflowTemplate: detail.workflowTemplate,
+    status: detail.status,
+    currentActionId: detail.currentActionId || null,
+    currentRunId: detail.currentRunId || null,
+    reuseMemory: detail.reuseMemory !== false,
+    origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
+    linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
+    createdAt: detail.createdAt,
+    updatedAt: detail.updatedAt,
+    actions: Array.isArray(detail.actions) ? detail.actions.map(projectAction) : [],
+    runs: Array.isArray(detail.runs) ? detail.runs.map(projectRun) : [],
+    events: Array.isArray(detail.events) ? detail.events.map(projectEvent) : [],
+  };
+}
+
 /**
  * Browser event projection. This deliberately excludes local filesystem paths,
  * Run evidence/tool output, prompts, model snapshots, and execution errors.
- * Clients fetch the selected detail explicitly through the authenticated get op.
  */
 export function projectWorkItemSummary(detail) {
   if (!detail) return null;
@@ -36,7 +130,8 @@ export function projectWorkItemSummary(detail) {
     currentAction: action ? {
       id: action.id,
       type: action.type,
-      requiredRole: action.requiredRole,
+      stageId: action.stageId || action.type,
+      assignmentMode: action.assignmentPolicy?.mode || (action.requiredRole ? 'fixed' : null),
       status: action.status,
     } : null,
     origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,