@serkanalgur/opencode-nexus 2.4.1 → 2.5.0

package/dist/index.js

@@ -9920,33 +9920,86 @@ class CustomRoleManager {
 }
 
 // src/forecast.ts
+var CACHE_READ_MULTIPLE = 0.1;
+var CACHE_WRITE_MULTIPLE = 1.25;
+function per1kPricing(input, output) {
+  return {
+    input,
+    output,
+    cacheRead: input * CACHE_READ_MULTIPLE,
+    cacheWrite: input * CACHE_WRITE_MULTIPLE
+  };
+}
+var FALLBACK_PRICING_PER_1K = {
+  "claude-sonnet-4-6": per1kPricing(0.015, 0.075),
+  "claude-opus-4-7": per1kPricing(0.075, 0.375),
+  "claude-haiku-4-5": per1kPricing(0.001, 0.005),
+  "gpt-5-mini": per1kPricing(0.00015, 0.0006),
+  "gpt-5": per1kPricing(0.0025, 0.01),
+  "gemini-2.5-flash": per1kPricing(0.000075, 0.0003),
+  "minimax-m2.5-free": per1kPricing(0, 0)
+};
+var UNKNOWN_PRICING_PER_1K = per1kPricing(0.01, 0.05);
+var per1k = (rate, tokens) => rate * tokens / 1000;
+function bareModelId(ref) {
+  return ref.slice(ref.indexOf("/") + 1);
+}
+function totalTokens(usage) {
+  return usage.input + usage.output + usage.reasoning + usage.cache.read + usage.cache.write;
+}
+function priceTokens(usage, pricing) {
+  const inputCost = per1k(pricing.input, usage.input);
+  const outputCost = per1k(pricing.output, usage.output + usage.reasoning);
+  const cacheCost = per1k(pricing.cacheRead, usage.cache.read) + per1k(pricing.cacheWrite, usage.cache.write);
+  return { inputCost, outputCost, cacheCost, total: inputCost + outputCost + cacheCost };
+}
+
 class CostForecaster {
-  modelPricing = new Map;
-  constructor() {
-    this.modelPricing.set("claude-sonnet-4-6", { input: 0.000015, output: 0.000075 });
-    this.modelPricing.set("claude-opus-4-7", { input: 0.000075, output: 0.000375 });
-    this.modelPricing.set("claude-haiku-4-5", { input: 0.000001, output: 0.000005 });
-    this.modelPricing.set("gpt-5-mini", { input: 0.00000015, output: 0.0000006 });
-    this.modelPricing.set("gpt-5", { input: 0.0000025, output: 0.00001 });
-    this.modelPricing.set("gemini-2.5-flash", { input: 0.000000075, output: 0.0000003 });
+  resolvePricing;
+  constructor(pricing) {
+    this.resolvePricing = pricing;
+  }
+  priceFor(model, provider) {
+    const real = this.resolvePricing?.(model, provider);
+    if (real)
+      return { pricing: real, source: "model-costs" };
+    const bare = bareModelId(model);
+    const fallback = FALLBACK_PRICING_PER_1K[model] ?? FALLBACK_PRICING_PER_1K[bare];
+    if (fallback)
+      return { pricing: fallback, source: "fallback-table" };
+    return { pricing: UNKNOWN_PRICING_PER_1K, source: "unknown-model" };
+  }
+  measureCost(usage, model, provider) {
+    const { pricing, source } = this.priceFor(model, provider);
+    return {
+      cost: priceTokens(usage, pricing).total,
+      tokens: totalTokens(usage),
+      pricingSource: source,
+      ...source === "model-costs" ? { confidence: 1 } : {}
+    };
   }
-  updatePricing(modelId, input, output) {
-    this.modelPricing.set(modelId, { input, output });
+  costOf(usage, model, provider) {
+    return priceTokens(usage, this.priceFor(model, provider).pricing).total;
   }
-  estimateTokens(task, complexity) {
+  estimateTokensFor(complexity, fileCount) {
     const baseInput = 700;
     const complexityMultiplier = 1 + complexity.overall / 100 * 3;
-    const fileMultiplier = 1 + task.files.include.length * 0.2;
+    const fileMultiplier = 1 + fileCount * 0.2;
     const input = Math.round(baseInput * complexityMultiplier * fileMultiplier);
     const output = Math.round(input * 0.5);
     return { input, output };
   }
+  estimateTokens(task, complexity) {
+    return this.estimateTokensFor(complexity, task.files.include.length);
+  }
+  estimateCost(complexity, model, provider) {
+    const { input, output } = this.estimateTokensFor(complexity, 0);
+    return this.costOf({ input, output, reasoning: 0, cache: { read: 0, write: 0 } }, model, provider);
+  }
   forecastTask(task, role, modelId, complexity) {
     const { input, output } = this.estimateTokens(task, complexity);
-    const pricing = this.modelPricing.get(modelId) || { input: 0.00001, output: 0.00005 };
-    const inputCost = input * pricing.input;
-    const outputCost = output * pricing.output;
-    const overhead = 0.0001;
+    const { pricing, source } = this.priceFor(modelId);
+    const breakdown = priceTokens({ input, output, reasoning: 0, cache: { read: 0, write: 0 } }, pricing);
     return {
       taskId: task.id,
       taskName: task.name,
@@ -9954,9 +10007,15 @@ class CostForecaster {
       model: modelId,
       estimatedInputTokens: input,
       estimatedOutputTokens: output,
-      estimatedCost: inputCost + outputCost + overhead,
-      confidence: 0.6 + Math.random() * 0.3,
-      breakdown: { inputCost, outputCost, overhead }
+      estimatedCost: breakdown.total,
+      source: "estimated",
+      pricingSource: source,
+      confidence: undefined,
+      breakdown: {
+        inputCost: breakdown.inputCost,
+        outputCost: breakdown.outputCost,
+        cacheCost: breakdown.cacheCost
+      }
     };
   }
   forecastAll(tasks, budgetRemaining) {
@@ -10164,6 +10223,12 @@ function lastAssistantText(messages) {
   }
   return "";
 }
+function sumBy(records, select) {
+  let total = 0;
+  for (const record of records.values())
+    total += select(record);
+  return total;
+}
 var DEFAULT_ESCALATION = {
   maxRetries: 3,
   retryDelay: 1000,
@@ -10209,6 +10274,8 @@ class NexusOrchestrator {
   onStateChange = null;
   stateChangeTimer = null;
   costHistory = [];
+  tokensByModel = new Map;
+  costProvenance = new Map;
   cleanupInterval = null;
   get healthMonitor() {
     return this._healthMonitor;
@@ -10226,6 +10293,7 @@ class NexusOrchestrator {
     this.messageRouter = new MessageRouter;
     this.escalationPolicy = {
       ...DEFAULT_ESCALATION,
+      fallbackModels: [...DEFAULT_ESCALATION.fallbackModels],
       maxRetries: this.config.selfHealing.maxRetries,
       retryDelay: this.config.selfHealing.retryDelay,
       enableRespawn: this.config.selfHealing.contextTransfer
@@ -10235,7 +10303,7 @@ class NexusOrchestrator {
     this.performanceTracker = new PerformanceTracker;
     this.executionHistory = new ExecutionHistory;
     this.customRoles = new CustomRoleManager;
-    this.forecaster = new CostForecaster;
+    this.forecaster = new CostForecaster((model, provider) => this.getModelCost(model, provider));
   }
   async initialize(ctx, onStateChange) {
     this.ctx = ctx;
@@ -10590,14 +10658,17 @@ class NexusOrchestrator {
       await this.sleep(this.config.schedulerInterval);
     }
   }
-  async spawnAndExecute(node, transferContext) {
+  selectQualifiedModel(node) {
     const complexity = this.analyzeComplexity(node.task);
     const model = this.selectModel(node.task.requiredRole, complexity);
     if (!model.provider || !model.model) {
       const missing = !model.provider && !model.model ? "provider and model" : !model.provider ? "provider" : "model";
       throw new Error(`Model selection for role "${node.task.requiredRole}" is missing its ${missing}: ` + `got { provider: ${JSON.stringify(model.provider)}, model: ${JSON.stringify(model.model)} }. ` + `Cannot build a "providerID/modelID" reference.`);
     }
-    const qualifiedModel = `${model.provider}/${model.model}`;
+    return `${model.provider}/${model.model}`;
+  }
+  async spawnAndExecute(node, options = {}) {
+    const qualifiedModel = options.modelOverride ?? this.selectQualifiedModel(node);
     const agent = await this.spawnAgent({
       role: node.task.requiredRole,
       task: node.task,
@@ -10607,7 +10678,7 @@ class NexusOrchestrator {
     node.status = "running";
     node.task.assignedAgent = agent.id;
     this.notifyStateChange();
-    await this.executeTask(agent, node, transferContext);
+    await this.executeTask(agent, node, options.transferContext);
   }
   async executeTask(agent, node, transferContext) {
     if (!this.ctx || !agent.sessionID) {
@@ -10661,20 +10732,21 @@ Please continue from where the previous agent left off.`;
       const messages = await this.ctx.session.context({ sessionID: agent.sessionID });
       const output = lastAssistantText(messages) || "Task completed (no output captured)";
       const duration = Date.now() - startTime;
+      const cost = await this.safeAccountTaskCost(agent, node.task);
       const result = {
         success: true,
         output,
         duration,
-        tokensUsed: 0,
-        cost: this.estimateModelCost(agent.model.model, agent.model.provider)
+        tokensUsed: cost.tokensUsed,
+        cost: cost.cost,
+        costProvenance: cost.provenance
       };
       this.dag.markComplete(node.id, result);
       this.todoEnforcer.completeTask(agent.id);
       agent.metrics.tasksCompleted++;
       agent.metrics.totalCost += result.cost;
-      this.totalSpent += result.cost;
-      this.costByAgent.set(agent.id, (this.costByAgent.get(agent.id) || 0) + result.cost);
-      this.checkBudget();
+      agent.metrics.totalTokens += result.tokensUsed;
+      this.trackCost(agent.id, `${agent.model.provider}/${agent.model.model}`, result.cost, result.tokensUsed, result.costProvenance);
       this.performanceTracker.record({
         model: agent.model.model,
         role: node.task.requiredRole,
@@ -10716,14 +10788,20 @@ Please continue from where the previous agent left off.`;
     } catch (error) {
       const duration = Date.now() - startTime;
       const errorMessage = error.message || "Task failed";
+      const cost = await this.safeAccountTaskCost(agent, node.task);
       const result = {
         success: false,
         error: errorMessage,
         duration,
-        tokensUsed: 0,
-        cost: 0
+        tokensUsed: cost.tokensUsed,
+        cost: cost.cost,
+        costProvenance: cost.provenance
       };
       this.dag.markFailed(node.id, new Error(errorMessage));
+      node.result = result;
+      this.trackCost(agent.id, `${agent.model.provider}/${agent.model.model}`, result.cost, result.tokensUsed, result.costProvenance);
+      agent.metrics.totalCost += result.cost;
+      agent.metrics.totalTokens += result.tokensUsed;
       this.todoEnforcer.completeTask(agent.id);
       agent.metrics.tasksFailed++;
       agent.status = "failed";
@@ -10834,7 +10912,7 @@ Please continue from where the previous agent left off.`;
       await this.terminateAgent(agent.id);
       node.status = "pending";
       this.notifyStateChange();
-      await this.spawnAndExecute(node, context);
+      await this.spawnAndExecute(node, { transferContext: context });
       return;
     }
     if (policy.fallbackModels.length > 0) {
@@ -10843,7 +10921,7 @@ Please continue from where the previous agent left off.`;
         await this.terminateAgent(agent.id);
         node.status = "pending";
         this.notifyStateChange();
-        await this.spawnAgent({ role: node.task.requiredRole, model: fallbackModel });
+        await this.spawnAndExecute(node, { modelOverride: fallbackModel });
         return;
       }
     }
@@ -11077,10 +11155,10 @@ Please continue from where the previous agent left off.`;
       if (qualified)
         return qualified;
     }
-    const bare = model.slice(model.indexOf("/") + 1);
+    const bare = bareModelId(model);
     let best;
     for (const [key, cost] of this.modelCosts) {
-      if (key.slice(key.indexOf("/") + 1) !== bare)
+      if (bareModelId(key) !== bare)
         continue;
       if (!best || cost.input < best.input)
         best = cost;
@@ -11162,28 +11240,96 @@ Please continue from where the previous agent left off.`;
     const scored = unique.map((m) => this.scoreModel(m, role, complexity));
     const budgetRemaining = this.budget.maxTotalCost - this.totalSpent;
     const affordable = scored.filter((s) => {
-      const cost = this.estimateModelCost(s.model, s.provider);
-      return cost <= budgetRemaining || cost === 0;
+      const estimate = this.forecaster.estimateCost(complexity, s.model, s.provider);
+      return estimate <= budgetRemaining || estimate === 0;
     });
     const best = (affordable.length > 0 ? affordable : scored).sort((a, b) => b.overallScore - a.overallScore)[0];
     return {
       provider: best.provider,
       model: best.model,
-      estimatedCost: this.estimateModelCost(best.model, best.provider),
+      estimatedCost: this.forecaster.estimateCost(complexity, best.model, best.provider),
       estimatedQuality: best.qualityScore,
       reasoning: best.reasoning
     };
   }
-  trackCost(agentId, model, cost, tokens) {
+  trackCost(agentId, model, cost, tokens, provenance) {
     this.totalSpent += cost;
     const agentCost = this.costByAgent.get(agentId) || 0;
     this.costByAgent.set(agentId, agentCost + cost);
     const modelCost = this.costByModel.get(model) || 0;
     this.costByModel.set(model, modelCost + cost);
-    this.costHistory.push({ timestamp: Date.now(), cost, agentId });
+    this.tokensByModel.set(model, (this.tokensByModel.get(model) || 0) + tokens);
+    this.recordProvenance(model, cost, provenance);
+    this.costHistory.push({ timestamp: Date.now(), cost, agentId, model, tokens, provenance });
     this.checkBudget();
     this.notifyStateChange();
   }
+  recordProvenance(model, cost, provenance) {
+    const measured = provenance.usage === "measured";
+    const prior = this.costProvenance.get(model) ?? {
+      usage: provenance.usage,
+      pricing: provenance.pricing,
+      measuredEntries: 0,
+      estimatedEntries: 0,
+      measuredSpend: 0,
+      estimatedSpend: 0
+    };
+    prior.usage = provenance.usage;
+    prior.pricing = provenance.pricing;
+    if (measured) {
+      prior.measuredEntries++;
+      prior.measuredSpend += cost;
+    } else {
+      prior.estimatedEntries++;
+      prior.estimatedSpend += cost;
+    }
+    this.costProvenance.set(model, prior);
+  }
+  safeAccountTaskCost(agent, task) {
+    return this.accountTaskCost(agent, task).catch(() => ({
+      cost: 0,
+      tokensUsed: 0,
+      provenance: { usage: "estimated", pricing: "unknown-model" }
+    }));
+  }
+  async accountTaskCost(agent, task) {
+    const model = `${agent.model.provider}/${agent.model.model}`;
+    const read = agent.sessionID ? await this.readSessionTokens(agent.sessionID) : { read: false };
+    if (read.read) {
+      const measured = this.forecaster.measureCost(read.usage, model, agent.model.provider);
+      return {
+        cost: measured.cost,
+        tokensUsed: measured.tokens,
+        provenance: { usage: "measured", pricing: measured.pricingSource }
+      };
+    }
+    const predicted = this.forecaster.forecastTask(task, task.requiredRole, model, task.complexity);
+    return {
+      cost: predicted.estimatedCost,
+      tokensUsed: predicted.estimatedInputTokens + predicted.estimatedOutputTokens,
+      provenance: { usage: "estimated", pricing: predicted.pricingSource }
+    };
+  }
+  async readSessionTokens(sessionID) {
+    const finite = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+    try {
+      const session = await this.ctx?.session.get({ sessionID });
+      const tokens = session?.tokens;
+      if (!tokens)
+        return { read: false };
+      return {
+        read: true,
+        usage: {
+          input: finite(tokens.input),
+          output: finite(tokens.output),
+          reasoning: finite(tokens.reasoning),
+          cache: { read: finite(tokens.cache?.read), write: finite(tokens.cache?.write) }
+        }
+      };
+    } catch {
+      return { read: false };
+    }
+  }
   checkBudget() {
     const remaining = this.budget.maxTotalCost - this.totalSpent;
     const remainingPercent = remaining / this.budget.maxTotalCost;
@@ -11274,7 +11420,11 @@ Please continue from where the previous agent left off.`;
       totalSpent: state.totalSpent,
       budgetRemaining: state.budgetRemaining,
       byAgent: Object.fromEntries(this.costByAgent),
-      byModel: Object.fromEntries(this.costByModel)
+      byModel: Object.fromEntries(this.costByModel),
+      tokensByModel: Object.fromEntries(this.tokensByModel),
+      provenance: Object.fromEntries(this.costProvenance),
+      measuredEntries: sumBy(this.costProvenance, (p) => p.measuredEntries),
+      estimatedEntries: sumBy(this.costProvenance, (p) => p.estimatedEntries)
     }, null, 2);
   }
   pause() {

package/dist/tui.js

@@ -454,6 +454,78 @@ var PRESETS = {
 
 // src/tui.tsx
 import { jsxDEV, Fragment } from "@opentui/solid/jsx-dev-runtime";
+var NEXUS_AGENT_PREFIX = "nexus-";
+function metadataString(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function roleFromAgent(agent) {
+  if (!agent)
+    return;
+  const role = agent.startsWith(NEXUS_AGENT_PREFIX) ? agent.slice(NEXUS_AGENT_PREFIX.length) : agent;
+  return role.length > 0 ? role : undefined;
+}
+function modelLabel(model) {
+  if (!model?.providerID || !model.id)
+    return;
+  return `${model.providerID}/${model.id}`;
+}
+function titleCase(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function sidebarAgentFor(session, status, now) {
+  const role = metadataString(session.metadata, "nexusRole") ?? roleFromAgent(session.agent);
+  return {
+    id: session.id,
+    name: role ? titleCase(role) : session.title || session.id.slice(0, 12),
+    role: role ?? "agent",
+    status,
+    model: metadataString(session.metadata, "nexusModel") ?? modelLabel(session.model) ?? "",
+    sessionID: session.id,
+    spawnedAt: now,
+    tasksCompleted: 0,
+    tasksFailed: 0
+  };
+}
+function sidebarChildSessionIDs(family, currentSessionID) {
+  if (!Array.isArray(family))
+    return [];
+  return family.filter((id) => id !== currentSessionID);
+}
+function collectSidebarAgents(source, currentSessionID, statusOf, now) {
+  const childIDs = sidebarChildSessionIDs(source.family(currentSessionID), currentSessionID);
+  if (childIDs.length === 0)
+    return [];
+  const agents = [];
+  for (const id of childIDs) {
+    try {
+      const session = source.get(id);
+      if (!session)
+        continue;
+      let status = "completed";
+      try {
+        status = statusOf(id);
+      } catch {}
+      agents.push(sidebarAgentFor(session, status, now));
+    } catch {}
+  }
+  return agents;
+}
+function mergeSidebarAgents(agents, polled, childIDs) {
+  const next = agents.map((agent) => ({ ...agent }));
+  for (const agent of polled) {
+    const existing = next.find((a) => a.sessionID === agent.sessionID);
+    if (existing) {
+      existing.status = agent.status;
+      existing.name = agent.name;
+      existing.role = agent.role;
+      existing.model = agent.model;
+    } else {
+      next.push(agent);
+    }
+  }
+  return next.filter((a) => a.sessionID && childIDs.includes(a.sessionID) || a.status === "completed" || a.status === "failed");
+}
 var tui_default = define({
   id: "nexus.cli",
   setup(context) {
@@ -848,69 +920,20 @@ var tui_default = define({
         const currentSessionID = currentRoute.sessionID;
         if (!currentSessionID)
           return;
-        const family = context.data.session.family(currentSessionID);
-        if (!family || !Array.isArray(family))
-          return;
-        const childIDs = family.filter((id) => id !== currentSessionID);
-        try {
-          const allSessions = context.data.session.list();
-          if (allSessions && Array.isArray(allSessions)) {
-            for (const s of allSessions) {
-              if (!s || !s.id)
-                continue;
-              const meta = s.metadata;
-              if (meta?.nexusRole && !childIDs.includes(s.id) && s.id !== currentSessionID) {
-                childIDs.push(s.id);
-              }
-            }
-          }
-        } catch {}
+        const source = context.data.session;
+        const childIDs = sidebarChildSessionIDs(source.family(currentSessionID), currentSessionID);
         if (childIDs.length === 0) {
           setSidebarState((draft) => {
-            draft.agents = draft.agents.filter((a) => a.status === "completed" || a.status === "failed");
+            draft.agents = mergeSidebarAgents(draft.agents, [], []);
           });
           return;
         }
-        const newAgents = childIDs.map((id) => {
-          try {
-            const session = context.data.session.get(id);
-            if (!session)
-              return null;
-            const meta = session.metadata || {};
-            let status = "completed";
-            try {
-              status = context.data.session.status(id) === "running" ? "working" : "completed";
-            } catch {}
-            return {
-              id,
-              name: meta.nexusRole ? `${meta.nexusRole.charAt(0).toUpperCase() + meta.nexusRole.slice(1)}` : session?.title || id.slice(0, 12),
-              role: meta.nexusRole || "agent",
-              status,
-              model: meta.nexusModel || "",
-              sessionID: id,
-              spawnedAt: new Date().toISOString(),
-              tasksCompleted: 0,
-              tasksFailed: 0
-            };
-          } catch {
-            return null;
-          }
-        }).filter(Boolean);
-        if (newAgents.length > 0) {
-          setSidebarState((draft) => {
-            for (const agent of newAgents) {
-              const existing = draft.agents.find((a) => a.sessionID === agent.sessionID);
-              if (existing) {
-                existing.status = agent.status;
-                existing.name = agent.name;
-                existing.model = agent.model;
-              } else {
-                draft.agents.push(agent);
-              }
-            }
-            draft.agents = draft.agents.filter((a) => a.sessionID && childIDs.includes(a.sessionID) || a.status === "completed" || a.status === "failed");
-          });
-        }
+        const newAgents = collectSidebarAgents(source, currentSessionID, (id) => context.data.session.status(id) === "running" ? "working" : "completed", new Date().toISOString());
+        if (newAgents.length === 0)
+          return;
+        setSidebarState((draft) => {
+          draft.agents = mergeSidebarAgents(draft.agents, newAgents, childIDs);
+        });
       } catch {}
     };
     const unsubSessionSucceeded = context.data.on("session.execution.succeeded", (event) => {
@@ -1039,5 +1062,9 @@ var tui_default = define({
   }
 });
 export {
-  tui_default as default
+  collectSidebarAgents,
+  tui_default as default,
+  mergeSidebarAgents,
+  sidebarAgentFor,
+  sidebarChildSessionIDs
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencode-nexus",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "Adaptive Multi-Agent Orchestration with Cost Intelligence for OpenCode V2",
   "keywords": [
     "opencode",