onbuzz 4.1.0 → 4.2.0

package/src/services/__tests__/conversationQuery.reasoning.test.js

@@ -0,0 +1,102 @@
+/**
+ * Tests for reasoning-content handling in conversationQuery.read().
+ *
+ * Contract:
+ *   - `hasReasoning` is ALWAYS surfaced when the archived message carries
+ *     a non-empty `reasoning` field, even when the text isn't returned.
+ *     Gives the agent a signal to re-fetch with includeReasoning=true.
+ *   - `reasoningTokens` is ALWAYS surfaced when present (non-null).
+ *   - The reasoning TEXT is returned only when includeReasoning=true.
+ *   - Other modes (overview, range, search, around, byTool) are
+ *     unaffected by this change — reasoning is deliberately scoped to
+ *     `read` because loading chain-of-thought in bulk responses would
+ *     blow the byte cap immediately.
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import { read, range, around } from '../conversationQuery.js';
+
+function mkMsg({ id = 'msg_0001', content = 'hello', reasoning, reasoningTokens }) {
+  const m = {
+    id,
+    role: 'assistant',
+    content,
+    createdAt: '2026-04-21T10:00:00Z',
+    tokenUsage: { totalTokens: 100 },
+  };
+  if (reasoning !== undefined) m.reasoning = reasoning;
+  if (reasoningTokens !== undefined) m.reasoningTokens = reasoningTokens;
+  return m;
+}
+
+describe('read() — reasoning presence signalling', () => {
+  test('hasReasoning=true + reasoningTokens surfaced without returning the text', () => {
+    const messages = [mkMsg({ reasoning: 'long chain of thought', reasoningTokens: 512 })];
+    const out = read(messages, { messageId: 'msg_0001' });
+    expect(out.targetFound).toBe(true);
+    expect(out.message.hasReasoning).toBe(true);
+    expect(out.message.reasoningTokens).toBe(512);
+    // Reasoning text is NOT returned by default
+    expect(out.message.reasoning).toBeUndefined();
+  });
+
+  test('includeReasoning=true returns the reasoning text', () => {
+    const thought = 'Let me think step by step. First I need to...';
+    const messages = [mkMsg({ reasoning: thought, reasoningTokens: 150 })];
+    const out = read(messages, { messageId: 'msg_0001', includeReasoning: true });
+    expect(out.message.reasoning).toBe(thought);
+    expect(out.message.hasReasoning).toBe(true);
+    expect(out.message.reasoningTokens).toBe(150);
+  });
+
+  test('message with no reasoning → hasReasoning=false, reasoningTokens=null', () => {
+    const messages = [mkMsg({})];
+    const out = read(messages, { messageId: 'msg_0001' });
+    expect(out.message.hasReasoning).toBe(false);
+    expect(out.message.reasoningTokens).toBeNull();
+    expect(out.message.reasoning).toBeUndefined();
+  });
+
+  test('message with only reasoningTokens (opaque provider, no text)', () => {
+    // OpenAI o-series case: we know they thought, but not what they thought.
+    const messages = [mkMsg({ reasoningTokens: 4217 })];
+    const out = read(messages, { messageId: 'msg_0001', includeReasoning: true });
+    expect(out.message.hasReasoning).toBe(false);    // no text present
+    expect(out.message.reasoningTokens).toBe(4217);
+    expect(out.message.reasoning).toBeUndefined();
+  });
+
+  test('empty reasoning string treated as absent (keeps signal honest)', () => {
+    const messages = [mkMsg({ reasoning: '', reasoningTokens: 0 })];
+    const out = read(messages, { messageId: 'msg_0001', includeReasoning: true });
+    expect(out.message.hasReasoning).toBe(false);
+    expect(out.message.reasoning).toBeUndefined();
+  });
+
+  test('reasoning is not pulled into around()/range() responses (byte-cap discipline)', () => {
+    // Other modes return slim entries; reasoning inclusion is scoped to
+    // read() only because chain-of-thought content can dwarf content.
+    const messages = [mkMsg({ reasoning: 'x'.repeat(50_000) })];
+    const rangeOut = range(messages);
+    const aroundOut = around(messages, { messageId: 'msg_0001' });
+    expect(rangeOut.messages[0].reasoning).toBeUndefined();
+    expect(aroundOut.messages[0].reasoning).toBeUndefined();
+  });
+
+  test('includeReasoning does not leak reasoning across byte cap — cap still applies', () => {
+    // A large reasoning block honored alongside a small content block
+    // should still be bounded by maxBytes in the overall response.
+    const huge = 'R'.repeat(50_000);
+    const messages = [mkMsg({ content: 'tiny', reasoning: huge })];
+    const out = read(messages, {
+      messageId: 'msg_0001',
+      includeReasoning: true,
+      maxBytes: 4096,
+    });
+    // Either reasoning was omitted entirely, OR included but the content
+    // field was trimmed via the existing byte-cap path — both are valid.
+    // What must NOT happen: the full 50KB reasoning in the response.
+    const serialized = JSON.stringify(out);
+    expect(serialized.length).toBeLessThan(50_000);
+  });
+});

package/src/services/__tests__/toolCallBridgeContract.test.js

@@ -0,0 +1,129 @@
+/**
+ * Cross-repo contract test: the inline-JSON format that
+ * autopilot-backend's tool-call bridge produces MUST be extractable by
+ * this CLI's TagParser.
+ *
+ * The test reproduces the exact output of the backend's
+ * `formatToolCallInlineBlock` (from autopilot-backend/services/toolCallBridge.js)
+ * as a literal template string here, then feeds it to
+ * `TagParser.extractToolCommands` + `normalizeToolCommand` and asserts
+ * the extraction produces a valid tool invocation.
+ *
+ * Why the literal template: the backend and CLI are separate repos, so we
+ * can't share code. The only way to lock a cross-repo contract is to
+ * write the expected format on BOTH sides and test both ends against it.
+ * Backend: `services/__tests__/toolCallBridge.test.js` verifies
+ * `formatToolCallInlineBlock` produces this exact string. CLI: this file
+ * verifies TagParser extracts tools from the same string. If either
+ * side's format drifts, the other repo's test breaks. Works because both
+ * repos are in the same workspace — deploys happen together.
+ *
+ * The template MUST stay in lockstep with backend's formatter. Any
+ * change there requires a corresponding change here.
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import TagParser from '../../utilities/tagParser.js';
+
+/**
+ * Reproduce the backend's `formatToolCallInlineBlock` output byte-for-byte.
+ * Must stay identical to what `autopilot-backend/services/toolCallBridge.js`
+ * emits — the single wire contract between provider tool_calls and the
+ * CLI's inline-JSON tool extraction.
+ */
+function bridgeOutput({ name, args }) {
+  const params = args ? JSON.parse(args) : {};
+  const paramSummary = Object.entries(params)
+    .map(([k, v]) => `${k}: ${typeof v === 'string' ? v : JSON.stringify(v)}`)
+    .join(', ')
+    .slice(0, 120);
+  return `\n**Calling ${name}** — ${paramSummary || 'no params'}…\n\n` +
+    '```json\n' +
+    JSON.stringify({ toolId: name, parameters: params }, null, 2) +
+    '\n```\n';
+}
+
+const parser = new TagParser();
+
+describe('cross-repo contract: backend bridge output → CLI TagParser extraction', () => {
+  test('single tool call with string params extracts correctly', () => {
+    const bridged = bridgeOutput({
+      name: 'filesystem',
+      args: '{"action":"read","path":"/etc/hosts"}',
+    });
+    // Prefix with some assistant prose — real responses combine both.
+    const content = 'Let me check that file.' + bridged;
+
+    const commands = parser.extractToolCommands(content);
+    expect(commands.length).toBeGreaterThan(0);
+
+    const normalized = parser.normalizeToolCommand(commands[0]);
+    expect(normalized.toolId).toBe('filesystem');
+    // Parameters may land either flat on the command (unwrapped by
+    // tagParser) or inside a `parameters` object — either is fine as
+    // long as the agent has access to them. Verify at least one path.
+    const params = normalized.parameters || normalized;
+    expect(params.action).toBe('read');
+    expect(params.path).toBe('/etc/hosts');
+  });
+
+  test('multiple tool calls in the same content extract as separate commands in order', () => {
+    const content =
+      'I will run two commands.' +
+      bridgeOutput({ name: 'filesystem', args: '{"path":"/a"}' }) +
+      ' Then: ' +
+      bridgeOutput({ name: 'terminal', args: '{"cmd":"ls"}' });
+
+    const commands = parser.extractToolCommands(content);
+    expect(commands.length).toBeGreaterThanOrEqual(2);
+    // The parser may order by appearance; at minimum both tool ids are
+    // present.
+    const toolIds = commands.map(c => parser.normalizeToolCommand(c).toolId);
+    expect(toolIds).toContain('filesystem');
+    expect(toolIds).toContain('terminal');
+  });
+
+  test('tool call with nested object params extracts with structure preserved', () => {
+    const bridged = bridgeOutput({
+      name: 'taskmanager',
+      args: JSON.stringify({
+        action: 'sync',
+        tasks: [
+          { title: 'Task 1', priority: 'high' },
+          { title: 'Task 2', priority: 'medium' },
+        ],
+      }),
+    });
+    const commands = parser.extractToolCommands(bridged);
+    expect(commands.length).toBeGreaterThan(0);
+    const normalized = parser.normalizeToolCommand(commands[0]);
+    expect(normalized.toolId).toBe('taskmanager');
+    const params = normalized.parameters || normalized;
+    expect(params.action).toBe('sync');
+    expect(Array.isArray(params.tasks)).toBe(true);
+    expect(params.tasks).toHaveLength(2);
+    expect(params.tasks[0].title).toBe('Task 1');
+  });
+
+  test('bridge output with no params (empty args object) extracts toolId correctly', () => {
+    const bridged = bridgeOutput({ name: 'jobdone', args: '{}' });
+    const commands = parser.extractToolCommands(bridged);
+    expect(commands.length).toBeGreaterThan(0);
+    const normalized = parser.normalizeToolCommand(commands[0]);
+    expect(normalized.toolId).toBe('jobdone');
+  });
+
+  test('bridge output surrounded by assistant prose does not trip the extractor', () => {
+    const content =
+      "I'll analyze this step by step. First, I need to check the file.\n\n" +
+      bridgeOutput({ name: 'filesystem', args: '{"path":"/x","action":"stat"}' }) +
+      "\n\nAfter I see the metadata I'll decide next steps.";
+
+    const commands = parser.extractToolCommands(content);
+    expect(commands.length).toBeGreaterThan(0);
+    const normalized = parser.normalizeToolCommand(commands[0]);
+    expect(normalized.toolId).toBe('filesystem');
+    const params = normalized.parameters || normalized;
+    expect(params.path).toBe('/x');
+  });
+});

package/src/services/agentActivityService.js

@@ -164,8 +164,18 @@ export function shouldAgentBeActive(agent) {
     };
   }
 
+  // Belt-and-suspenders: queued inbound work (user message, inter-agent
+  // ping, tool result) overrides delay/pause. Inbound enqueue paths clear
+  // delay/pause at arrival time via agentPool._wakeAgentForMessage, so in
+  // the happy path a delayed agent never has queued messages. This guard
+  // is a defensive second line: if anything bypasses the enqueue helpers
+  // (persisted state loaded mid-delay, direct mutation in legacy code,
+  // future paths) we still refuse to sideline an agent that has work to do.
+  const _queueStatus = getMessageQueueStatus(agent);
+  const _hasInboundWork = _queueStatus.hasUserMessages || _queueStatus.hasInterAgentMessages || _queueStatus.hasToolResults;
+
   // 3. Delay check
-  if (isAgentDelayed(agent)) {
+  if (isAgentDelayed(agent) && !_hasInboundWork) {
     return {
       active: false,
       reason: AGENT_ACTIVITY_STATUS.AGENT_DELAYED,
@@ -174,7 +184,7 @@ export function shouldAgentBeActive(agent) {
   }
 
   // 4. Pause check
-  if (isAgentPaused(agent)) {
+  if (isAgentPaused(agent) && !_hasInboundWork) {
     return {
       active: false,
       reason: AGENT_ACTIVITY_STATUS.AGENT_PAUSED,
@@ -359,14 +369,25 @@ export function shouldSkipIteration(agent) {
     return { skip: true, reason: 'Agent not found' };
   }
 
+  // Belt-and-suspenders: a queued inbound message is a stronger signal
+  // than any delay/pause. Inbound enqueue paths (addUserMessage,
+  // addInterAgentMessage, addToolResult) call agentPool._wakeAgentForMessage
+  // to clear delay/pause *before* queueing — so in the happy path we never
+  // reach this branch with a non-empty queue AND a live delay. But if
+  // anything bypassed that (direct state mutation in tests, future code
+  // paths, persisted state loaded mid-delay with pre-existing queue), we
+  // still refuse to skip.
+  const q = getMessageQueueStatus(agent);
+  const hasInbound = q.hasUserMessages || q.hasInterAgentMessages || q.hasToolResults;
+
   // Skip if delayed (but don't remove - delay will expire)
   // This is also used for WebTool auto-delay to allow browser operations to complete
-  if (isAgentDelayed(agent)) {
+  if (isAgentDelayed(agent) && !hasInbound) {
     return { skip: true, reason: `Agent delayed until ${agent.delayEndTime}` };
   }
 
   // Skip if paused with expiration (but don't remove - pause will expire)
-  if (agent.pausedUntil && new Date() < new Date(agent.pausedUntil)) {
+  if (agent.pausedUntil && new Date() < new Date(agent.pausedUntil) && !hasInbound) {
     return { skip: true, reason: `Agent paused until ${agent.pausedUntil}` };
   }
 

package/src/services/aiService.js

@@ -20,6 +20,138 @@ import {
 } from '../utilities/constants.js';
 import { getOllamaService, OLLAMA_MODEL_PREFIX } from './ollamaService.js';
 
+/**
+ * Pull the reasoning-token count out of a usage object, checking every
+ * provider shape we've seen in the fleet:
+ *   - OpenAI:      usage.completion_tokens_details.reasoning_tokens
+ *   - Some Azure:  usage.reasoning_tokens (flattened)
+ *   - Claude:      usage.output_tokens_details.reasoning_tokens
+ * Returns null when no reasoning tokens are reported (non-reasoning model,
+ * or provider hasn't populated the field).
+ *
+ * Surfaced even for models that don't expose reasoning content text
+ * (OpenAI o-series, gpt-5-*-reasoning variants): the count alone is useful
+ * — it tells the operator "the model spent N tokens thinking" which
+ * explains slow turns and signal "depth of deliberation" at a glance.
+ *
+ * @param {Object|null|undefined} usage
+ * @returns {number|null}
+ * @private
+ */
+/**
+ * Parse the SSE stream emitted by autopilot-backend's `/llm/chat` route
+ * into a final response object. This is the CLI half of the backend ↔
+ * CLI wire contract (backend emission is tested in autopilot-backend's
+ * `routes/__tests__/llm.chat.reasoning.test.js`).
+ *
+ * Accepts anything that returns chunks matching the ReadableStream
+ * default-reader protocol: an object with `.read()` returning
+ * `{ done, value: Uint8Array }`. Production callers pass
+ * `response.body.getReader()`; tests pass a fake reader constructed over
+ * a fixed set of byte chunks.
+ *
+ * Event shapes understood (must match backend's emission):
+ *   { type: 'start',           ...metadata }              → ignored
+ *   { type: 'chunk',           content: string }          → accumulated into `content`
+ *   { type: 'reasoning_chunk', content: string }          → accumulated into `reasoning`
+ *   { type: 'done',            content, reasoning?, usage, model, finishReason } → finalizes
+ *   { type: 'error',           error, code }              → throws
+ *
+ * Callbacks (all optional) fire progressively:
+ *   onChunk(content)           — on each text chunk
+ *   onReasoningChunk(content)  — on each reasoning chunk
+ *
+ * @param {{ read(): Promise<{done: boolean, value: Uint8Array|undefined}> }} reader
+ * @param {Object} [opts]
+ * @param {Function} [opts.onChunk]
+ * @param {Function} [opts.onReasoningChunk]
+ * @param {string}   [opts.fallbackModel]  Used when the final `done` event lacks `model`.
+ * @returns {Promise<{
+ *   content: string, reasoning: string, reasoningTokens: number|null,
+ *   usage: Object|null, model: string, finishReason: string
+ * }>}
+ */
+export async function _parseSSEResponseStream(reader, opts = {}) {
+  const { onChunk, onReasoningChunk, fallbackModel = null } = opts;
+  const decoder = new TextDecoder();
+  let fullContent = '';
+  let fullReasoning = '';
+  let finalData = null;
+  let lineBuffer = '';
+
+  const processLine = (line) => {
+    const trimmedLine = line.trim();
+    if (!trimmedLine.startsWith('data: ')) return;
+    const data = trimmedLine.slice(6).trim();
+    if (data === '[DONE]' || data.length === 0) return;
+
+    let parsed;
+    try { parsed = JSON.parse(data); }
+    catch { return; /* malformed SSE chunk — skip defensively */ }
+
+    if (parsed.type === 'chunk' && parsed.content) {
+      fullContent += parsed.content;
+      if (onChunk) onChunk(parsed.content);
+    } else if (parsed.type === 'reasoning_chunk' && parsed.content) {
+      fullReasoning += parsed.content;
+      if (onReasoningChunk) onReasoningChunk(parsed.content);
+    } else if (parsed.type === 'done') {
+      finalData = {
+        content: parsed.content || fullContent,
+        // Prefer the streamed accumulation; fall back to a batched `reasoning`
+        // field on the done event (rare but supported).
+        reasoning: fullReasoning || parsed.reasoning || '',
+        reasoningTokens: _extractReasoningTokens(parsed.usage),
+        usage: parsed.usage,
+        model: parsed.model || fallbackModel,
+        finishReason: parsed.finishReason || 'stop',
+      };
+    } else if (parsed.type === 'error') {
+      const error = new Error(parsed.error);
+      error.code = parsed.code;
+      throw error;
+    }
+    // Unknown event types (e.g. 'start') are silently ignored — forward
+    // compat for future backend event additions.
+  };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    lineBuffer += decoder.decode(value, { stream: true });
+    const parts = lineBuffer.split('\n');
+    lineBuffer = parts.pop() || ''; // last fragment may be incomplete
+    for (const line of parts) processLine(line);
+  }
+  // Flush any trailing unterminated line (streams that end without \n).
+  if (lineBuffer.trim().length > 0) processLine(lineBuffer);
+
+  if (finalData) return finalData;
+  // Stream ended without a `done` event — return what we accumulated.
+  return {
+    content: fullContent,
+    reasoning: fullReasoning,
+    reasoningTokens: null,
+    usage: null,
+    model: fallbackModel,
+    finishReason: 'stop',
+  };
+}
+
+export function _extractReasoningTokens(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  const candidates = [
+    usage.reasoning_tokens,
+    usage.completion_tokens_details?.reasoning_tokens,
+    usage.output_tokens_details?.reasoning_tokens,
+    usage.completionTokensDetails?.reasoningTokens,
+  ];
+  for (const c of candidates) {
+    if (typeof c === 'number' && Number.isFinite(c)) return c;
+  }
+  return null;
+}
+
 class AIService {
   constructor(config, logger, budgetService, errorHandler) {
     this.config = config;
@@ -342,8 +474,20 @@ class AIService {
       // Track model reliability - mark as verified
       this.recordModelSuccess(model);
 
+      const msg = response.choices[0]?.message || {};
+      // Non-streaming reasoning: providers that surface content text put it
+      // on the message as `reasoning_content` (DeepSeek-R1, xAI reasoning)
+      // or `reasoning` (some OpenAI-compatible gateways) or `thinking`
+      // (Anthropic when surfaced through a compatible shape). Token count
+      // comes from usage regardless of content presence.
+      const reasoning = (typeof msg.reasoning_content === 'string' && msg.reasoning_content)
+        || (typeof msg.reasoning === 'string' && msg.reasoning)
+        || (typeof msg.thinking === 'string' && msg.thinking)
+        || '';
       return {
-        content: response.choices[0]?.message?.content || '',
+        content: msg.content || '',
+        reasoning,
+        reasoningTokens: _extractReasoningTokens(response.usage),
         model: response.model,
         tokenUsage: response.usage,
         requestId,
@@ -591,6 +735,11 @@ class AIService {
 
     // Track accumulated content for partial return on abort
     let fullContent = '';
+    // Reasoning/thinking accumulator hoisted to outer scope so the catch
+    // block (user-abort path) can return any reasoning captured before the
+    // abort fired. Populated from 'reasoning_chunk' SSE events inside the
+    // try block.
+    let fullReasoning = '';
 
     try {
       const response = await fetch(backendUrl, {
@@ -698,101 +847,37 @@ class AIService {
         return fallbackResult;
       }
 
-      // Process SSE stream with line buffering
-      // SSE events can be split across read() calls, so we buffer incomplete lines
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      fullContent = ''; // Reset (declared outside try for catch block access)
+      // Parse the SSE stream via the shared helper — see `_parseSSEResponseStream`
+      // (exported for testability). The helper encodes the full backend
+      // contract: chunk/reasoning_chunk/done/error event shapes, line
+      // buffering across TCP frames, accumulation of reasoning, trailing-
+      // unterminated-line flush. Changing this contract means updating the
+      // helper AND the autopilot-backend tests that lock the emission side.
+      fullContent = '';   // Reset (declared outside try for catch block access)
+      fullReasoning = ''; // Same reason — hoisted for catch-block reuse.
       let finalData = null;
-      let lineBuffer = ''; // Buffer for incomplete lines across chunks
-
-      while (true) {
-        const { done, value } = await reader.read();
-
-        if (done) {
-          break;
-        }
-
-        const text = decoder.decode(value, { stream: true });
-        lineBuffer += text;
-
-        // Split on newlines but keep the last fragment if it doesn't end with \n
-        const parts = lineBuffer.split('\n');
-        // The last element may be an incomplete line — keep it in the buffer
-        lineBuffer = parts.pop() || '';
-
-        for (const line of parts) {
-          const trimmedLine = line.trim();
-          if (trimmedLine.startsWith('data: ')) {
-            const data = trimmedLine.slice(6).trim();
-
-            if (data === '[DONE]') {
-              continue;
-            }
-
-            try {
-              const parsed = JSON.parse(data);
-
-              if (parsed.type === 'chunk' && parsed.content) {
-                fullContent += parsed.content;
-                if (onChunk) {
-                  onChunk(parsed.content);
-                }
-              } else if (parsed.type === 'done') {
-                finalData = {
-                  content: parsed.content || fullContent,
-                  usage: parsed.usage,
-                  model: parsed.model || payload.model,
-                  finishReason: parsed.finishReason || 'stop'
-                };
-              } else if (parsed.type === 'error') {
-                const error = new Error(parsed.error);
-                error.code = parsed.code;
-                if (onError) {
-                  onError(error);
-                }
-                throw error;
-              }
-            } catch (parseError) {
-              // Rethrow intentional backend error events (have .code from parsed.type === 'error')
-              // but never rethrow JSON SyntaxErrors — those are just malformed SSE chunks
-              if (parseError.code && !(parseError instanceof SyntaxError)) {
-                throw parseError;
-              }
-              this.logger?.debug('Skipping unparseable SSE data', {
-                requestId,
-                dataPreview: data.substring(0, 120),
-                error: parseError.message
-              });
-              continue;
-            }
-          }
-        }
-      }
-
-      // Process any remaining buffered data (in case stream ended without trailing newline)
-      if (lineBuffer.trim().startsWith('data: ')) {
-        const data = lineBuffer.trim().slice(6).trim();
-        if (data !== '[DONE]') {
-          try {
-            const parsed = JSON.parse(data);
-            if (parsed.type === 'done') {
-              finalData = {
-                content: parsed.content || fullContent,
-                usage: parsed.usage,
-                model: parsed.model || payload.model,
-                finishReason: parsed.finishReason || 'stop'
-              };
-            }
-          } catch (e) {
-            // Ignore parse errors on final buffer
-          }
-        }
+      try {
+        finalData = await _parseSSEResponseStream(response.body.getReader(), {
+          onChunk: (chunk) => {
+            fullContent += chunk;
+            if (onChunk) onChunk(chunk);
+          },
+          onReasoningChunk: (chunk) => {
+            fullReasoning += chunk;
+            if (options.onReasoningChunk) options.onReasoningChunk(chunk);
+          },
+          fallbackModel: payload.model,
+        });
+      } catch (streamError) {
+        // Backend `type: 'error'` events throw out of the helper with a .code.
+        // Route them through onError like the previous implementation did.
+        if (streamError?.code && onError) onError(streamError);
+        throw streamError;
       }
 
       // Final callback with complete data
       if (onDone) {
-        onDone(finalData || { content: fullContent });
+        onDone(finalData || { content: fullContent, reasoning: fullReasoning, reasoningTokens: null });
       }
 
       // Clean up active request tracking on success
@@ -803,6 +888,8 @@ class AIService {
 
       return finalData || {
         content: fullContent,
+        reasoning: fullReasoning,
+        reasoningTokens: null,
         usage: null,
         model: payload.model,
         finishReason: 'stop'
@@ -833,6 +920,8 @@ class AIService {
         // Return partial content that was received before abort
         const abortResult = {
           content: fullContent || '', // Use accumulated content
+          reasoning: fullReasoning || '', // Preserve any reasoning captured before abort
+          reasoningTokens: null,
           usage: null,
           model: payload.model,
           finishReason: 'user_abort',

package/src/services/conversationQuery.js

@@ -714,11 +714,37 @@ export function read(messages, params = {}) {
     tokenCount: _tokenCountOf(m),
     hasToolCalls: _hasToolCalls(m),
     model: m?.metadata?.model || null,
+    // Signal presence of reasoning even when we're not returning the text
+    // — agent can decide to re-fetch with includeReasoning=true.
+    hasReasoning: typeof m?.reasoning === 'string' && m.reasoning.length > 0,
+    reasoningTokens: Number.isFinite(m?.reasoningTokens) ? m.reasoningTokens : null,
   };
   const extras = detail === 'full' ? {
     toolExecutions: Array.isArray(m?.toolExecutions) ? m.toolExecutions : [],
     contextReferences: Array.isArray(m?.contextReferences) ? m.contextReferences : [],
   } : {};
+  // Reasoning is opt-in on `read` because chain-of-thought can dwarf the
+  // content in token count; default slim responses skip it, callers who
+  // want the thinking text pass includeReasoning=true. When included, it
+  // gets its own byte budget (50% of maxBytes by default) so a huge
+  // reasoning block doesn't devour content or blow the response cap.
+  // Truncation marker "…(N more chars)" preserves the "hasMore" signal.
+  if (params.includeReasoning && typeof m?.reasoning === 'string' && m.reasoning.length > 0) {
+    const reasoningBudget = Math.floor(maxBytes / 2);
+    if (Buffer.byteLength(m.reasoning, 'utf-8') <= reasoningBudget) {
+      extras.reasoning = m.reasoning;
+    } else {
+      // Binary-trim to the budget (same pattern as content truncation below).
+      let lo = 0, hi = m.reasoning.length;
+      while (lo < hi) {
+        const mid = (lo + hi + 1) >>> 1;
+        if (Buffer.byteLength(m.reasoning.slice(0, mid), 'utf-8') <= reasoningBudget) lo = mid;
+        else hi = mid - 1;
+      }
+      extras.reasoning = m.reasoning.slice(0, lo) + `…(${m.reasoning.length - lo} more chars)`;
+      extras.reasoningTruncated = true;
+    }
+  }
 
   // Serialize incrementally: shell of the response minus content is a
   // cheap lower bound on overhead; we give content the remaining budget.