@mercury-fw/core 0.26.0 → 0.27.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @mercury-fw/core
 
+## 0.27.1
+
+### Patch Changes
+
+- 2c0e020: The REPL no longer prints the answer a second time, under "risposta corretta rispetto a quanto già mostrato sopra", after a turn that reasoned or called a tool.
+  - @mercury-fw/plugin-types@0.27.1
+  - @mercury-fw/channel-types@0.27.1
+  - @mercury-fw/cli-engine@0.27.1
+  - @mercury-fw/confirm-engine@0.27.1
+
+## 0.27.0
+
+### Patch Changes
+
+- @mercury-fw/plugin-types@0.27.0
+- @mercury-fw/channel-types@0.27.0
+- @mercury-fw/cli-engine@0.27.0
+- @mercury-fw/confirm-engine@0.27.0
+
 ## 0.26.0
 
 ### Minor Changes

package/dist/src/router/terminal.d.ts

@@ -21,7 +21,10 @@ export declare const PROMPT = "> ";
  *   resolve. If `onChunk` is never called, the function's returned
  *   string is written instead once `handleInput` resolves, exactly as
  *   before streaming existed — this is what keeps the `/dump` command
- *   and any other non-streaming reply working unchanged.
+ *   and any other non-streaming reply working unchanged. A chunk passed
+ *   with `{ aside: true }` (reasoning, a tool label, a confirmation line)
+ *   is written the same way but isn't part of the answer, so it's left out
+ *   when the returned string is compared with what was streamed.
  * @param io - Test seam. Defaults to real stdin/stdout when omitted.
  * @param opts.promptSuffix - Optional, called fresh right before every
  *   prompt (including the very first one) and written ahead of it — e.g.
@@ -29,7 +32,9 @@ export declare const PROMPT = "> ";
  *   `formatContextUsage`), recomputed each time since the value changes
  *   turn to turn.
  */
-export declare function startTerminalRepl(handleInput: (input: string, onChunk: (chunk: string) => void) => Promise<string>, io?: {
+export declare function startTerminalRepl(handleInput: (input: string, onChunk: (chunk: string, opts?: {
+    aside?: boolean;
+}) => void) => Promise<string>, io?: {
     input?: AsyncIterable<string>;
     output?: {
         write(s: string, opts?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercury-fw/core",
-  "version": "0.26.0",
+  "version": "0.27.1",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -31,10 +31,10 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@mercury-fw/channel-types": "0.26.0",
-    "@mercury-fw/cli-engine": "0.26.0",
-    "@mercury-fw/confirm-engine": "0.26.0",
-    "@mercury-fw/plugin-types": "0.26.0",
+    "@mercury-fw/channel-types": "0.27.1",
+    "@mercury-fw/cli-engine": "0.27.1",
+    "@mercury-fw/confirm-engine": "0.27.1",
+    "@mercury-fw/plugin-types": "0.27.1",
     "@qdrant/js-client-rest": "^1.19.0",
     "ai": "^7.0.77",
     "ai-sdk-ollama": "^4.2.0",

package/src/router/terminal-provider.ts

@@ -80,7 +80,10 @@ export function createTerminalProvider(deps: TerminalProviderDeps): Provider {
           // seeing its result), each burst getting its own header/close
           // rather than being mistaken for a continuation of the first.
           const reasoningIdsStarted = new Set<string>();
-          const dim = (label: string) => onChunk(`\x1b[2m\x1b[3m${label}\x1b[0m\n`);
+          // Everything but the answer text is an aside: printed as it comes,
+          // but not part of the answer the REPL compares with the result.
+          const aside = (chunk: string) => onChunk(chunk, { aside: true });
+          const dim = (label: string) => aside(`\x1b[2m\x1b[3m${label}\x1b[0m\n`);
           const sink: TurnSink = {
             onToolStart: dim,
             // PENDING_CONFIRMATION_NOTE is dropped here: onStep (below)
@@ -99,10 +102,10 @@ export function createTerminalProvider(deps: TerminalProviderDeps): Provider {
                 reasoningIdsStarted.add(id);
                 dim("Sto pensando…");
               }
-              onChunk(`\x1b[2m\x1b[3m${chunk}\x1b[0m`);
+              aside(`\x1b[2m\x1b[3m${chunk}\x1b[0m`);
             },
             onReasoningEnd: (id) => {
-              if (reasoningIdsStarted.has(id)) onChunk("\n");
+              if (reasoningIdsStarted.has(id)) aside("\n");
             },
             onStep: (step) => {
               lastSteps.push(step);
@@ -111,7 +114,7 @@ export function createTerminalProvider(deps: TerminalProviderDeps): Provider {
               // say it itself, from the structured step data.
               const pending = detectPendingConfirmation(step);
               if (pending) {
-                onChunk(`Azione in sospeso: \`${pending.summary}\` — scrivi: ${pending.token}\n`);
+                aside(`Azione in sospeso: \`${pending.summary}\` — scrivi: ${pending.token}\n`);
               }
             },
             onUsage: (tokens) => {
@@ -140,7 +143,11 @@ export function createTerminalProvider(deps: TerminalProviderDeps): Provider {
           if (contextLength === null) {
             contextLength = await getLoadedContextLengthFn(deps.ollamaHost, deps.ollamaModel);
           }
-          return finalText;
+          // The note's chunk was dropped above, so it isn't returned either,
+          // also when a surfaced display follows it.
+          return finalText.startsWith(PENDING_CONFIRMATION_NOTE)
+            ? finalText.slice(PENDING_CONFIRMATION_NOTE.length).replace(/^\n\n/, "")
+            : finalText;
         },
         undefined,
         { promptSuffix: () => formatContextUsage(lastInputTokens, contextLength) },

package/src/router/terminal.ts

@@ -53,7 +53,10 @@ export const PROMPT = "> ";
  *   resolve. If `onChunk` is never called, the function's returned
  *   string is written instead once `handleInput` resolves, exactly as
  *   before streaming existed — this is what keeps the `/dump` command
- *   and any other non-streaming reply working unchanged.
+ *   and any other non-streaming reply working unchanged. A chunk passed
+ *   with `{ aside: true }` (reasoning, a tool label, a confirmation line)
+ *   is written the same way but isn't part of the answer, so it's left out
+ *   when the returned string is compared with what was streamed.
  * @param io - Test seam. Defaults to real stdin/stdout when omitted.
  * @param opts.promptSuffix - Optional, called fresh right before every
  *   prompt (including the very first one) and written ahead of it — e.g.
@@ -62,7 +65,7 @@ export const PROMPT = "> ";
  *   turn to turn.
  */
 export async function startTerminalRepl(
-  handleInput: (input: string, onChunk: (chunk: string) => void) => Promise<string>,
+  handleInput: (input: string, onChunk: (chunk: string, opts?: { aside?: boolean }) => void) => Promise<string>,
   io?: {
     input?: AsyncIterable<string>;
     output?: { write(s: string, opts?: { newline?: boolean }): void };
@@ -115,9 +118,9 @@ export async function startTerminalRepl(
   for await (const line of input) {
     let streamed = false;
     let streamedText = "";
-    const onChunk = (chunk: string) => {
+    const onChunk = (chunk: string, chunkOpts?: { aside?: boolean }) => {
       streamed = true;
-      streamedText += chunk;
+      if (!chunkOpts?.aside) streamedText += chunk;
       output.write(chunk, { newline: false });
     };
     try {
@@ -132,9 +135,9 @@ export async function startTerminalRepl(
         // needs writing.
         output.write(result.slice(streamedText.length));
       } else {
-        // The final result no longer extends what was already streamed —
-        // e.g. turn-runner.ts's issue-list correction replaced the text
-        // with a rewrite or the fixed fallback. What's already printed
+        // The final result no longer extends what was already streamed:
+        // a plugin's post-turn guard (turn-runner.ts) rewrote the text
+        // after it was streamed. What's already printed
         // can't be un-printed, so show the real final answer in full
         // instead of a slice computed against text that isn't there
         // anymore.