@bli-cockpit/cli 0.2.48 → 0.2.50

package/dist/tower-client.js

@@ -81,14 +81,15 @@ export async function towerRequest(options) {
     };
     try {
         const response = await options.fetch(url, init);
+        const respondedMs = Date.now() - startedAt;
         log(`[tower client] responded ${JSON.stringify({
             request: options.label,
             http_status: response.status,
             content_type: response.headers.get("content-type") ?? "none",
             streamed: (response.headers.get("content-type") ?? "").includes("application/x-ndjson"),
-            elapsed_ms: Date.now() - startedAt,
+            elapsed_ms: respondedMs,
         })}`);
-        return { ok: true, response };
+        return { ok: true, response, startedAt, respondedMs };
     }
     catch (error) {
         const reason = isAbortError(error)

package/dist/tower-stream.js

@@ -2,8 +2,9 @@
  * Reading a Tower turn as it happens (BLI-3457).
  *
  * The dashboard's conversation routes speak one JSON object per line
- * (`application/x-ndjson`): `activity` events as tools start and settle, then
- * exactly one `final` event carrying what the plain JSON response used to be.
+ * (`application/x-ndjson`): `activity` events as tools start and settle,
+ * `token` events carrying the answer as it is written (BLI-3517), then exactly
+ * one `final` event carrying what the plain JSON response used to be.
  * That is the same wire format the browser already reads
  * (`apps/dashboard/src/lib/webchat/tool-trace.ts`); this is the terminal's
  * reader for it.
@@ -39,7 +40,7 @@ const CEILING_HINT_MS = 110_000;
  * from a dashboard that does not stream yet (yielded as the final event, after
  * a `stream_not_available` note).
  */
-export async function* readTowerStream(response) {
+export async function* readTowerStream(response, options = {}) {
     const contentType = response.headers.get("content-type") ?? "";
     if (!contentType.includes("application/x-ndjson")) {
         yield* readPlainJsonBody(response);
@@ -48,6 +49,7 @@ export async function* readTowerStream(response) {
     let buffer = "";
     try {
         for await (const chunk of iterateBody(response)) {
+            options.onBytes?.();
             buffer += chunk;
             const lines = buffer.split("\n");
             buffer = lines.pop() ?? "";
@@ -89,7 +91,18 @@ export async function readTowerTurn(response, options = {}) {
     const notes = [];
     let streamed = true;
     let final = null;
-    for await (const item of readTowerStream(response)) {
+    let draft = "";
+    let tokenFrames = 0;
+    let firstByteMs = null;
+    let firstFrameMs = null;
+    let firstTokenMs = null;
+    for await (const item of readTowerStream(response, {
+        onBytes: () => {
+            firstByteMs ??= Date.now() - startedAt;
+        },
+    })) {
+        if (item.kind === "event")
+            firstFrameMs ??= Date.now() - startedAt;
         if (item.kind === "note") {
             if (item.reason === "stream_not_available")
                 streamed = false;
@@ -101,10 +114,21 @@ export async function readTowerTurn(response, options = {}) {
             final = item.event;
             break;
         }
+        if (item.event.type === "token") {
+            const text = item.event.text ?? "";
+            // The mark a person actually feels: the first frame with WORDS in it.
+            if (text)
+                firstTokenMs ??= Date.now() - startedAt;
+            tokenFrames += 1;
+            draft = item.event.reset ? text : draft + text;
+            options.onToken?.(item.event);
+            continue;
+        }
         activity.push(item.event);
         options.onActivity?.(item.event);
     }
     const elapsedMs = Date.now() - startedAt;
+    const timing = { firstByteMs, firstFrameMs, firstTokenMs };
     if (!final) {
         // The last named note is the truest reason we have; absent one, a stream
         // that simply stopped near the dashboard's ceiling is a timeout.
@@ -117,18 +141,64 @@ export async function readTowerTurn(response, options = {}) {
         options.log?.(`[tower stream] turn incomplete ${JSON.stringify({
             reason,
             activity_events: activity.length,
+            token_frames: tokenFrames,
+            drafted_chars: draft.length,
             notes: notes.length,
             elapsed_ms: elapsedMs,
+            // BLI-3591: a turn that died still says how far it got — a stream that
+            // never produced a byte and one that produced words and then broke are
+            // different failures.
+            ...turnTimingFields(timing),
         })}`);
         return { ok: false, reason, detail: streamFailureDetail(reason, terminal?.detail) };
     }
     options.log?.(`[tower stream] turn complete ${JSON.stringify({
         streamed,
+        // BLI-3582: the dashboard's own split of the wait, relayed verbatim off
+        // the final frame — `wire_ms` (request accepted → first byte out),
+        // `prep_ms` (→ the model call started) and `model_ttft_ms` (→ its first
+        // token). All null against a dashboard that does not send them, which is
+        // a different fact from a turn that was instant.
+        ...finalLatencyFields(final),
         activity_events: activity.length,
+        // BLI-3517: zero token frames against a streaming dashboard means the
+        // answer arrived all at once — worth telling apart from a quiet turn.
+        token_frames: tokenFrames,
+        drafted_chars: draft.length,
         notes: notes.length,
         elapsed_ms: elapsedMs,
+        // BLI-3591: this side's own three marks, beside the dashboard's three
+        // above. `first_byte_ms` is the socket opening (the dashboard's flushed
+        // newline), `first_frame_ms` the first readable frame and
+        // `first_token_ms` the first WORDS — so the 1-2 s that used to sit
+        // unexplained between the dashboard's first token and the terminal's
+        // first visible character now has a number on each end of it.
+        ...turnTimingFields(timing),
     })}`);
-    return { ok: true, final, activity, streamed };
+    return { ok: true, final, activity, streamed, draft, timing };
+}
+/** The same three marks as log fields, snake_case like every other line here. */
+export function turnTimingFields(timing) {
+    return {
+        first_byte_ms: timing.firstByteMs,
+        first_frame_ms: timing.firstFrameMs,
+        first_token_ms: timing.firstTokenMs,
+    };
+}
+/**
+ * The three latency spans off a final frame, as log fields (BLI-3582).
+ *
+ * Read defensively: this module knows the ENVELOPE, not the body, and a body
+ * shape that drifts must degrade to three nulls rather than a thrown turn.
+ */
+function finalLatencyFields(final) {
+    const raw = final["latency"];
+    const latency = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    const ms = (key) => {
+        const value = latency[key];
+        return typeof value === "number" && Number.isFinite(value) ? value : null;
+    };
+    return { wire_ms: ms("wireMs"), prep_ms: ms("prepMs"), model_ttft_ms: ms("modelTtftMs") };
 }
 /** One plain sentence per way a turn can end without an answer. */
 export function streamFailureDetail(reason, detail) {
@@ -207,7 +277,7 @@ function parseLine(line) {
         return { kind: "note", reason: "unexpected_event_type" };
     }
     const type = parsed.type;
-    if (type !== "activity" && type !== "final") {
+    if (type !== "activity" && type !== "token" && type !== "final") {
         return { kind: "note", reason: "unexpected_event_type" };
     }
     return { kind: "event", event: parsed };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.48",
+  "version": "0.2.50",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
+    "@bli-cockpit/memory-mcp": "0.1.0",
     "@bli-cockpit/telemetry-core": "0.1.26"
   }
 }