reasonix 0.5.13 → 0.5.20

package/dist/index.d.ts

@@ -69,6 +69,14 @@ interface ChatMessage {
     name?: string;
     tool_call_id?: string;
     tool_calls?: ToolCall[];
+    /**
+     * R1 `reasoning_content` captured from the assistant's thinking turn.
+     * DeepSeek's thinking mode 400s with "reasoning_content in the
+     * thinking mode must be passed back" when a tool-loop continuation
+     * omits it from the preceding assistant message. Round-tripped for
+     * deepseek-reasoner turns with tool_calls; absent for deepseek-chat.
+     */
+    reasoning_content?: string | null;
 }
 interface RawUsage {
     prompt_tokens?: number;
@@ -790,6 +798,19 @@ interface LoopEvent {
     toolArgs?: string;
     /** Cumulative arguments-string length for `role === "tool_call_delta"`. */
     toolCallArgsChars?: number;
+    /**
+     * Zero-based index of the tool call this delta belongs to. Surfaces
+     * multi-tool turns: on a response emitting 4 write_file calls the UI
+     * can show "building call 3/?" instead of a context-free spinner.
+     */
+    toolCallIndex?: number;
+    /**
+     * Count of prior tool calls (this turn) whose arguments have finished
+     * streaming into valid JSON. Not all ready calls have been dispatched
+     * yet — dispatch still happens post-stream — but the user gets "2
+     * ready" progress feedback while later calls keep streaming.
+     */
+    toolCallReadyCount?: number;
     stats?: TurnStats;
     planState?: TypedPlanState;
     repair?: RepairReport;
@@ -922,7 +943,7 @@ declare class CacheFirstLoop {
         tokensSaved: number;
         charsSaved: number;
     };
-    private appendAndPersist;
+    appendAndPersist(message: ChatMessage): void;
     /**
      * Start a fresh conversation WITHOUT exiting. Drops every message
      * in the in-memory log AND rewrites the session file to empty so
@@ -970,6 +991,15 @@ declare class CacheFirstLoop {
     private forceSummaryAfterIterLimit;
     run(userInput: string, onEvent?: (ev: LoopEvent) => void): Promise<string>;
     private assistantMessage;
+    /**
+     * Build a synthetic assistant message we insert into the log without
+     * a real API round trip (abort notices, future system injections).
+     * Reasoner models reject follow-up requests whose assistant history
+     * is missing `reasoning_content`, so we stamp an empty-string
+     * placeholder on reasoner sessions to satisfy the validator. V3
+     * doesn't care — field stays absent there.
+     */
+    private syntheticAssistantMessage;
 }
 /**
  * R1 occasionally hallucinates tool-call markup as plain text when the
@@ -1550,6 +1580,10 @@ interface SubagentEvent {
     kind: "start" | "progress" | "end";
     /** First ~30 chars of the task prompt — used for the TUI status row. */
     task: string;
+    /** Skill that spawned this subagent, when applicable. Stamped on every event so the TUI/logger can attribute without extra plumbing. */
+    skillName?: string;
+    /** Model id the child loop ran on. Stamped alongside skillName. */
+    model?: string;
     /** Iteration count inside the child loop (number of tool results so far). */
     iter?: number;
     /** Wall-clock ms since the subagent started. */
@@ -1560,6 +1594,10 @@ interface SubagentEvent {
     error?: string;
     /** Total turns the subagent took. Set on `end`. */
     turns?: number;
+    /** Total USD spent inside the child loop. Set on `end`. */
+    costUsd?: number;
+    /** Aggregated child-loop Usage (sum across turns). Set on `end`. */
+    usage?: Usage;
 }
 /**
  * Mutable ref the registration writes through. The TUI sets `.current`
@@ -3066,6 +3104,22 @@ interface UsageRecord {
     costUsd: number;
     /** What the same turn would have cost at Claude Sonnet 4.6 rates. */
     claudeEquivUsd: number;
+    /**
+     * Distinguishes ordinary parent-loop turns from subagent summary rows.
+     * Absent on pre-0.5.14 records — treat as "turn" when missing.
+     */
+    kind?: "turn" | "subagent";
+    /** Present when `kind === "subagent"`. Attribution metadata for the /stats roll-up. */
+    subagent?: {
+        /** Skill that spawned it, when the spawn came from a `runAs: subagent` skill. */
+        skillName?: string;
+        /** First ~60 chars of the task prompt — enough context to recognize a run, never the full text. */
+        taskPreview: string;
+        /** Tool calls the child loop dispatched before returning. */
+        toolIters: number;
+        /** Wall-clock ms. */
+        durationMs: number;
+    };
 }
 /** Where the log lives. Tests override via `opts.path`. */
 declare function defaultUsageLogPath(homeDirOverride?: string): string;
@@ -3077,6 +3131,9 @@ interface AppendUsageInput {
     now?: number;
     /** Override the log path (tests). */
     path?: string;
+    /** When appending a subagent summary row, set `kind: "subagent"` and populate `subagent`. */
+    kind?: "turn" | "subagent";
+    subagent?: UsageRecord["subagent"];
 }
 /**
  * Append one record and return it. Swallows disk errors — the TUI
@@ -3131,6 +3188,25 @@ interface UsageAggregate {
     firstSeen: number | null;
     /** Latest record's ts, or `null` when the log is empty. */
     lastSeen: number | null;
+    /**
+     * Subagent-specific rollup. Undefined when no subagent records exist
+     * in the log so consumers can cheaply skip the section. Counts reflect
+     * subagent SPAWNS (not internal child-loop turns) — one row per run.
+     */
+    subagents?: SubagentAggregate;
+}
+/** Rolled-up view of all `kind: "subagent"` records. */
+interface SubagentAggregate {
+    total: number;
+    costUsd: number;
+    totalDurationMs: number;
+    /** Per-skill breakdown. Records without `skillName` (raw spawn_subagent calls) group under `"(adhoc)"`. */
+    bySkill: Array<{
+        skillName: string;
+        count: number;
+        costUsd: number;
+        durationMs: number;
+    }>;
 }
 /**
  * Fold a flat record list into the dashboard shape — rolling windows

package/dist/index.js

@@ -1563,6 +1563,11 @@ function deleteSession(name) {
   const path = sessionPath(name);
   try {
     unlinkSync(path);
+    const sidecar = path.replace(/\.jsonl$/, ".pending.json");
+    try {
+      unlinkSync(sidecar);
+    } catch {
+    }
     return true;
   } catch {
     return false;
@@ -1590,13 +1595,18 @@ function countLines(path) {
 
 // src/telemetry.ts
 var DEEPSEEK_PRICING = {
-  "deepseek-chat": { inputCacheHit: 0.028, inputCacheMiss: 0.28, output: 0.42 },
-  "deepseek-reasoner": { inputCacheHit: 0.028, inputCacheMiss: 0.28, output: 0.42 }
+  "deepseek-v4-flash": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
+  "deepseek-v4-pro": { inputCacheHit: 0.139, inputCacheMiss: 1.667, output: 3.333 },
+  // Compat aliases — priced as v4-flash per the deprecation notice.
+  "deepseek-chat": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
+  "deepseek-reasoner": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 }
 };
 var CLAUDE_SONNET_PRICING = { input: 3, output: 15 };
 var DEEPSEEK_CONTEXT_TOKENS = {
-  "deepseek-chat": 131072,
-  "deepseek-reasoner": 131072
+  "deepseek-v4-flash": 1e6,
+  "deepseek-v4-pro": 1e6,
+  "deepseek-chat": 1e6,
+  "deepseek-reasoner": 1e6
 };
 var DEFAULT_CONTEXT_TOKENS = 131072;
 function costUsd(model, usage) {
@@ -1924,7 +1934,7 @@ var CacheFirstLoop = class {
           content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)`
         };
         const stoppedMsg = "[aborted by user (Esc) \u2014 no summary produced. Ask again or /retry when ready; prior tool output is still in the log.]";
-        this.appendAndPersist({ role: "assistant", content: stoppedMsg });
+        this.appendAndPersist(this.syntheticAssistantMessage(stoppedMsg));
         yield {
           turn: this._turn,
           role: "assistant_final",
@@ -2060,6 +2070,7 @@ var CacheFirstLoop = class {
           };
         } else if (this.stream) {
           const callBuf = /* @__PURE__ */ new Map();
+          const readyIndices = /* @__PURE__ */ new Set();
           for await (const chunk of this.client.stream({
             model: this.model,
             messages,
@@ -2095,13 +2106,18 @@ var CacheFirstLoop = class {
               if (d.argumentsDelta)
                 cur.function.arguments = (cur.function.arguments ?? "") + d.argumentsDelta;
               callBuf.set(d.index, cur);
+              if (!readyIndices.has(d.index) && cur.function.name && looksLikeCompleteJson(cur.function.arguments ?? "")) {
+                readyIndices.add(d.index);
+              }
               if (cur.function.name) {
                 yield {
                   turn: this._turn,
                   role: "tool_call_delta",
                   content: "",
                   toolName: cur.function.name,
-                  toolCallArgsChars: (cur.function.arguments ?? "").length
+                  toolCallArgsChars: (cur.function.arguments ?? "").length,
+                  toolCallIndex: d.index,
+                  toolCallReadyCount: readyIndices.size
                 };
               }
             }
@@ -2152,7 +2168,9 @@ var CacheFirstLoop = class {
         reasoningContent || null,
         assistantContent || null
       );
-      this.appendAndPersist(this.assistantMessage(assistantContent, repairedCalls));
+      this.appendAndPersist(
+        this.assistantMessage(assistantContent, repairedCalls, reasoningContent)
+      );
       yield {
         turn: this._turn,
         role: "assistant_final",
@@ -2314,7 +2332,7 @@ ${reason}`;
 
 ${summary}`;
       const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
-      this.appendAndPersist({ role: "assistant", content: summary });
+      this.appendAndPersist(this.assistantMessage(summary, [], resp.reasoningContent ?? void 0));
       yield {
         turn: this._turn,
         role: "assistant_final",
@@ -2343,12 +2361,35 @@ ${summary}`;
     }
     return final;
   }
-  assistantMessage(content, toolCalls) {
+  assistantMessage(content, toolCalls, reasoningContent) {
     const msg = { role: "assistant", content };
     if (toolCalls.length > 0) msg.tool_calls = toolCalls;
+    if (reasoningContent && reasoningContent.length > 0) {
+      msg.reasoning_content = reasoningContent;
+    }
+    return msg;
+  }
+  /**
+   * Build a synthetic assistant message we insert into the log without
+   * a real API round trip (abort notices, future system injections).
+   * Reasoner models reject follow-up requests whose assistant history
+   * is missing `reasoning_content`, so we stamp an empty-string
+   * placeholder on reasoner sessions to satisfy the validator. V3
+   * doesn't care — field stays absent there.
+   */
+  syntheticAssistantMessage(content) {
+    const msg = { role: "assistant", content };
+    if (isThinkingModeModel(this.model)) {
+      msg.reasoning_content = "";
+    }
     return msg;
   }
 };
+function isThinkingModeModel(model) {
+  if (model.includes("reasoner")) return true;
+  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return true;
+  return false;
+}
 function stripHallucinatedToolMarkup(s) {
   let out = s;
   out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
@@ -2364,6 +2405,15 @@ function safeParseToolArgs(raw) {
     return raw;
   }
 }
+function looksLikeCompleteJson(s) {
+  if (!s || !s.trim()) return false;
+  try {
+    JSON.parse(s);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function* hookWarnings(outcomes, turn) {
   for (const o of outcomes) {
     if (o.decision === "pass") continue;
@@ -3961,11 +4011,14 @@ async function spawnSubagent(opts) {
   const maxToolIters = opts.maxToolIters ?? DEFAULT_MAX_ITERS;
   const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS2;
   const sink = opts.sink;
+  const skillName = opts.skillName;
   const startedAt = Date.now();
   const taskPreview = opts.task.length > 30 ? `${opts.task.slice(0, 30)}\u2026` : opts.task;
   sink?.current?.({
     kind: "start",
     task: taskPreview,
+    skillName,
+    model,
     iter: 0,
     elapsedMs: 0
   });
@@ -3995,6 +4048,8 @@ async function spawnSubagent(opts) {
         sink?.current?.({
           kind: "progress",
           task: taskPreview,
+          skillName,
+          model,
           iter: toolIter,
           elapsedMs: Date.now() - startedAt
         });
@@ -4017,17 +4072,22 @@ async function spawnSubagent(opts) {
   const elapsedMs = Date.now() - startedAt;
   const turns = childLoop.stats.turns.length;
   const costUsd2 = childLoop.stats.totalCost;
+  const usage = aggregateChildUsage(childLoop);
   const truncated = final.length > maxResultChars ? `${final.slice(0, maxResultChars)}
 
 [\u2026truncated ${final.length - maxResultChars} chars; ask the subagent for a tighter summary if you need more.]` : final;
   sink?.current?.({
     kind: "end",
     task: taskPreview,
+    skillName,
+    model,
     iter: toolIter,
     elapsedMs,
     summary: errorMessage ? void 0 : truncated.slice(0, 120),
     error: errorMessage,
-    turns
+    turns,
+    costUsd: costUsd2,
+    usage
   });
   return {
     success: !errorMessage,
@@ -4036,9 +4096,23 @@ async function spawnSubagent(opts) {
     turns,
     toolIters: toolIter,
     elapsedMs,
-    costUsd: costUsd2
+    costUsd: costUsd2,
+    model,
+    skillName,
+    usage
   };
 }
+function aggregateChildUsage(loop) {
+  const agg = new Usage();
+  for (const t of loop.stats.turns) {
+    agg.promptTokens += t.usage.promptTokens;
+    agg.completionTokens += t.usage.completionTokens;
+    agg.totalTokens += t.usage.totalTokens;
+    agg.promptCacheHitTokens += t.usage.promptCacheHitTokens;
+    agg.promptCacheMissTokens += t.usage.promptCacheMissTokens;
+  }
+  return agg;
+}
 function formatSubagentResult(r) {
   if (!r.success) {
     return JSON.stringify({
@@ -4081,8 +4155,8 @@ function registerSubagentTool(parentRegistry, opts) {
         },
         model: {
           type: "string",
-          enum: ["deepseek-chat", "deepseek-reasoner"],
-          description: "Which DeepSeek model the subagent runs on. 'deepseek-chat' (V3) is the default \u2014 fast and cheap. Use 'deepseek-reasoner' (R1) only when the subtask genuinely needs planning or multi-step reasoning; it is roughly 5-10x more expensive."
+          enum: ["deepseek-v4-flash", "deepseek-v4-pro", "deepseek-chat", "deepseek-reasoner"],
+          description: "Which DeepSeek model the subagent runs on. 'deepseek-v4-flash' (default; thinking mode) is fast and cheap and is what the legacy 'deepseek-chat' / 'deepseek-reasoner' aliases route to today. Use 'deepseek-v4-pro' only when the subtask needs the strongest model \u2014 roughly 12\xD7 the input cost and 12\xD7 the output cost vs flash."
         }
       },
       required: ["task"]
@@ -6245,6 +6319,8 @@ function appendUsage(input) {
     costUsd: costUsd(input.model, input.usage),
     claudeEquivUsd: claudeEquivalentCost(input.usage)
   };
+  if (input.kind === "subagent") record.kind = "subagent";
+  if (input.subagent) record.subagent = input.subagent;
   const path = input.path ?? defaultUsageLogPath();
   try {
     mkdirSync6(dirname7(path), { recursive: true });
@@ -6318,6 +6394,10 @@ function aggregateUsage(records, opts = {}) {
   const sessionCounts = /* @__PURE__ */ new Map();
   let firstSeen = null;
   let lastSeen = null;
+  const skillCounts = /* @__PURE__ */ new Map();
+  let subagentTotal = 0;
+  let subagentCost = 0;
+  let subagentDuration = 0;
   for (const r of records) {
     addToBucket(all, r);
     if (r.ts >= today.since) addToBucket(today, r);
@@ -6328,15 +6408,34 @@ function aggregateUsage(records, opts = {}) {
     sessionCounts.set(sessKey, (sessionCounts.get(sessKey) ?? 0) + 1);
     if (firstSeen === null || r.ts < firstSeen) firstSeen = r.ts;
     if (lastSeen === null || r.ts > lastSeen) lastSeen = r.ts;
+    if (r.kind === "subagent") {
+      subagentTotal += 1;
+      subagentCost += r.costUsd;
+      const dur = r.subagent?.durationMs ?? 0;
+      subagentDuration += dur;
+      const key = r.subagent?.skillName?.trim() || "(adhoc)";
+      const prev = skillCounts.get(key) ?? { count: 0, costUsd: 0, durationMs: 0 };
+      prev.count += 1;
+      prev.costUsd += r.costUsd;
+      prev.durationMs += dur;
+      skillCounts.set(key, prev);
+    }
   }
   const byModel = Array.from(modelCounts.entries()).map(([model, turns]) => ({ model, turns })).sort((a, b) => b.turns - a.turns);
   const bySession = Array.from(sessionCounts.entries()).map(([session, turns]) => ({ session, turns })).sort((a, b) => b.turns - a.turns);
+  const subagents = subagentTotal > 0 ? {
+    total: subagentTotal,
+    costUsd: subagentCost,
+    totalDurationMs: subagentDuration,
+    bySkill: Array.from(skillCounts.entries()).map(([skillName, v]) => ({ skillName, ...v })).sort((a, b) => b.count - a.count)
+  } : void 0;
   return {
     buckets: [today, week, month, all],
     byModel,
     bySession,
     firstSeen,
-    lastSeen
+    lastSeen,
+    subagents
   };
 }
 function formatLogSize(path = defaultUsageLogPath()) {