nolo-cli 0.1.48 → 0.1.49

package/index.js

@@ -3436,6 +3436,35 @@ function accumulateToolCallDelta(accumulated, deltas) {
 function finalizeAccumulatedToolCalls(accumulated) {
   return Object.keys(accumulated).map((key2) => accumulated[Number(key2)]).filter((call) => call?.function?.name);
 }
+function processOpenAiCompatibleSseEvent(event, state) {
+  for (const line of event.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:")) continue;
+    const payload = trimmed.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      continue;
+    }
+    if (parsed?.usage && typeof parsed.usage === "object") {
+      state.usage = parsed.usage;
+    }
+    const delta = parsed?.choices?.[0]?.delta;
+    if (!delta || typeof delta !== "object") continue;
+    const reasoningChunk = typeof delta.reasoning_content === "string" ? delta.reasoning_content : typeof delta.reasoning === "string" ? delta.reasoning : "";
+    if (reasoningChunk) state.reasoning += reasoningChunk;
+    if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
+      accumulateToolCallDelta(state.accumulatedToolCalls, delta.tool_calls);
+    }
+    const textChunk = typeof delta.content === "string" ? delta.content : "";
+    if (textChunk) {
+      state.content += textChunk;
+      state.onTextDelta?.(textChunk);
+    }
+  }
+}
 async function readOpenAiCompatibleSseCompletion(args2) {
   const reader = args2.response.body?.getReader();
   if (!reader) {
@@ -3443,10 +3472,13 @@ async function readOpenAiCompatibleSseCompletion(args2) {
   }
   const decoder = new TextDecoder();
   let buffer = "";
-  let content = "";
-  let reasoning = "";
-  let usage2;
-  const accumulatedToolCalls = {};
+  const state = {
+    content: "",
+    reasoning: "",
+    usage: void 0,
+    accumulatedToolCalls: {},
+    onTextDelta: args2.onTextDelta
+  };
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
@@ -3456,41 +3488,19 @@ async function readOpenAiCompatibleSseCompletion(args2) {
       if (boundary === -1) break;
       const event = buffer.slice(0, boundary);
       buffer = buffer.slice(boundary + 2);
-      for (const line of event.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data:")) continue;
-        const payload = trimmed.slice(5).trim();
-        if (!payload || payload === "[DONE]") continue;
-        let parsed;
-        try {
-          parsed = JSON.parse(payload);
-        } catch {
-          continue;
-        }
-        if (parsed?.usage && typeof parsed.usage === "object") {
-          usage2 = parsed.usage;
-        }
-        const delta = parsed?.choices?.[0]?.delta;
-        if (!delta || typeof delta !== "object") continue;
-        const reasoningChunk = typeof delta.reasoning_content === "string" ? delta.reasoning_content : typeof delta.reasoning === "string" ? delta.reasoning : "";
-        if (reasoningChunk) reasoning += reasoningChunk;
-        if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
-          accumulateToolCallDelta(accumulatedToolCalls, delta.tool_calls);
-        }
-        const textChunk = typeof delta.content === "string" ? delta.content : "";
-        if (textChunk) {
-          content += textChunk;
-          args2.onTextDelta?.(textChunk);
-        }
-      }
+      processOpenAiCompatibleSseEvent(event, state);
     }
   }
-  const tool_calls = finalizeAccumulatedToolCalls(accumulatedToolCalls);
+  buffer += decoder.decode();
+  if (buffer.trim()) {
+    processOpenAiCompatibleSseEvent(buffer, state);
+  }
+  const tool_calls = finalizeAccumulatedToolCalls(state.accumulatedToolCalls);
   return {
-    content,
-    ...reasoning ? { reasoning_content: reasoning } : {},
+    content: state.content,
+    ...state.reasoning ? { reasoning_content: state.reasoning } : {},
     ...tool_calls.length > 0 ? { tool_calls } : {},
-    ...usage2 ? { usage: usage2 } : {}
+    ...state.usage ? { usage: state.usage } : {}
   };
 }
 async function executeOpenAiCompatibleChatCompletion(args2) {
@@ -64754,7 +64764,9 @@ function createCliLocalRuntimeAdapter(deps) {
                 const data2 = parsePlatformChatCompletionData(raw2);
                 throw new Error(`platform provider failed: HTTP ${res.status} ${JSON.stringify(data2)}`);
               }
-              if (stream && options?.onTextDelta) {
+              const contentType = res.headers.get("content-type") ?? "";
+              const shouldStream = Boolean(stream && options?.onTextDelta) && contentType.includes("text/event-stream");
+              if (shouldStream && options?.onTextDelta) {
                 const streamed = await readOpenAiCompatibleSseCompletion({
                   response: res,
                   onTextDelta: options.onTextDelta
@@ -68114,6 +68126,64 @@ function formatAssistantDisplay(text, mode = "rich") {
   }
   return polished.split("\n").map((line) => styleRichMarkdownLine(line)).join("\n");
 }
+function emitFormattedAssistantBlock(write2, text, renderMode, trailingNewline = false) {
+  if (!text) return;
+  write2(formatAssistantDisplay(text, renderMode));
+  if (trailingNewline) write2("\n");
+}
+function createRenderAwareStreamWriter(args2) {
+  let buffer = "";
+  const flushCompleteBlocks = () => {
+    if (args2.renderMode === "plain") {
+      if (!buffer) return;
+      args2.write(buffer);
+      buffer = "";
+      return;
+    }
+    while (buffer.includes("\n")) {
+      const lines = buffer.split("\n");
+      if (lines.length < 2) break;
+      if (isTableRow(lines[0] ?? "") && isTableSeparator(lines[1] ?? "")) {
+        let end = 2;
+        while (end < lines.length && isTableRow(lines[end] ?? "") && !isTableSeparator(lines[end] ?? "")) {
+          end += 1;
+        }
+        const tableComplete = end < lines.length || buffer.endsWith("\n");
+        if (!tableComplete) break;
+        emitFormattedAssistantBlock(
+          args2.write,
+          lines.slice(0, end).join("\n"),
+          args2.renderMode,
+          true
+        );
+        buffer = lines.slice(end).join("\n");
+        continue;
+      }
+      emitFormattedAssistantBlock(args2.write, lines[0] ?? "", args2.renderMode, true);
+      buffer = lines.slice(1).join("\n");
+    }
+  };
+  return {
+    push(chunk) {
+      if (!chunk) return;
+      if (args2.renderMode === "plain") {
+        args2.write(chunk);
+        return;
+      }
+      buffer += chunk;
+      flushCompleteBlocks();
+    },
+    flush() {
+      if (!buffer) return;
+      if (args2.renderMode === "plain") {
+        args2.write(buffer);
+      } else {
+        emitFormattedAssistantBlock(args2.write, buffer, args2.renderMode);
+      }
+      buffer = "";
+    }
+  };
+}
 
 // packages/cli/client/thinkingOutput.ts
 var THINK_OPEN = /<think>/i;
@@ -68920,12 +68990,16 @@ async function runLocalAgentTurnForCli(options, settings) {
     const traceLocalTools = shouldEmitToolEvents(toolDisplayMode);
     const formatToolEvent = createToolEventFormatter(toolDisplayMode);
     const eventMode = resolveAgentEventMode(options);
-    let wroteToolTrace = false;
     let streamedAssistantText = false;
     let printedAssistantLabel = false;
     const thinkingMode = resolveThinkingDisplayMode(options.env);
+    const renderMode = resolveRenderDisplayMode(options.env);
+    const renderWriter = createRenderAwareStreamWriter({
+      write: (chunk) => options.output.write(chunk),
+      renderMode
+    });
     const thinkingFilter = createThinkingAwareStreamFilter(
-      (chunk) => options.output.write(chunk),
+      (chunk) => renderWriter.push(chunk),
       thinkingMode
     );
     const subjectRefs = buildSubjectRefs(options);
@@ -68959,7 +69033,6 @@ async function runLocalAgentTurnForCli(options, settings) {
           spinner.stop();
           const chunk = eventMode === "jsonl" ? formatToolJsonEvent(event) : formatToolEvent(event);
           if (chunk) {
-            wroteToolTrace = true;
             options.output.write(chunk);
           }
         }
@@ -68980,6 +69053,7 @@ ${options.agentName} > `);
     spinner.stop();
     if (streamedAssistantText) {
       thinkingFilter.flush();
+      renderWriter.flush();
       options.output.write("\n");
     } else {
       const content = formatAssistantResponseForCli(result.content.trim(), options);
@@ -69017,8 +69091,13 @@ async function readStreamingAgentRun(options, res) {
   }
   const decoder = new TextDecoder();
   const thinkingMode = resolveThinkingDisplayMode(options.env);
+  const renderMode = resolveRenderDisplayMode(options.env);
+  const renderWriter = createRenderAwareStreamWriter({
+    write: (chunk) => options.output.write(chunk),
+    renderMode
+  });
   const writer = createStreamingTextWriter({
-    write: (chunk) => options.output.write(chunk)
+    write: (chunk) => renderWriter.push(chunk)
   });
   const thinkingFilter = createThinkingAwareStreamFilter(
     (chunk) => writer.push(chunk),
@@ -69091,6 +69170,7 @@ ${options.agentName} > `);
   } finally {
     writer.flushAll();
     thinkingFilter.flush();
+    renderWriter.flush();
   }
   if (!content) {
     options.output.write(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.48",
+  "version": "0.1.49",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {