turbollm 1.12.5 → 1.12.6

package/README.md

@@ -439,6 +439,11 @@ connected); **Remove** undoes it.
   and percentages — pulled from `nvidia-smi`, WDDM counters, `rocm-smi`, AMD sysfs, `ioreg`,
   or `/proc` on Linux. Clicking the bar opens detailed gauges and sparklines in Settings → System.
   Toggle it off entirely from Settings → General.
+- **Engines → Monitor** puts the live engine log and those same hardware gauges on one
+  always-visible split screen, plus a second, LM Studio-style **developer request log**: every
+  completion the daemon serves — external API clients, Code sessions, in-app Chat — with
+  sampling params, timings, token counts, and (opt-in, off by default) full prompt/response
+  text. In-memory only; never written to disk or sent anywhere.
 
 </details>
 

package/dist/{chunk-6GI5HUKN.js → chunk-4D7DDGNU.js}

@@ -252,6 +252,98 @@ async function proxyStream(remote, path, init, signal, fetchImpl = fetch) {
   return fetchImpl(buildUpstream(remote, path), { ...init, signal });
 }
 
+// src/observability/request-log.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function requestLogConfig(d) {
+  return d.store.snapshot().requestLog ?? { enabled: false, captureBodies: false, maxEntries: 500 };
+}
+var PARAM_KEYS = [
+  "temperature",
+  "top_p",
+  "top_k",
+  "min_p",
+  "max_tokens",
+  "max_completion_tokens",
+  "presence_penalty",
+  "frequency_penalty",
+  "repeat_penalty",
+  "seed",
+  "stop",
+  "reasoning_effort",
+  "response_format",
+  "tool_choice",
+  "n",
+  "logprobs"
+];
+function extractParams(body) {
+  const out = {};
+  if (!body) return out;
+  for (const key of PARAM_KEYS) {
+    if (body[key] !== void 0) out[key] = body[key];
+  }
+  return out;
+}
+function summarizeRequest(body) {
+  const messages = Array.isArray(body?.messages) ? body.messages : [];
+  const tools = Array.isArray(body?.tools) ? body.tools : [];
+  let systemChars = 0;
+  for (const m of messages) {
+    const msg = m;
+    if (msg?.role === "system" && typeof msg.content === "string") systemChars += msg.content.length;
+  }
+  return { messages: messages.length, tools: tools.length, systemChars };
+}
+var DEFAULT_MAX_BYTES = 32 * 1024 * 1024;
+async function drainOpenAiSseForLog(body, opts = { captureBody: false }) {
+  const reader = body.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  let promptTokens = 0;
+  let completionTokens = 0;
+  let promptTps = null;
+  let genTps = null;
+  let ttftMs = null;
+  let finishReason = null;
+  let responseText = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    const lines = buf.split("\n");
+    buf = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const raw = line.slice(6).trim();
+      if (raw === "[DONE]") continue;
+      let chunk;
+      try {
+        chunk = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      const usage = chunk.usage;
+      if (usage) {
+        if (usage.prompt_tokens) promptTokens = usage.prompt_tokens;
+        if (usage.completion_tokens) completionTokens = usage.completion_tokens;
+      }
+      const timings = chunk.timings;
+      if (timings) {
+        if (timings.prompt_per_second) promptTps = timings.prompt_per_second;
+        if (timings.predicted_per_second) genTps = timings.predicted_per_second;
+      }
+      const delta = chunk.choices?.[0]?.delta;
+      if (delta && (delta.content || delta.reasoning_content)) {
+        if (ttftMs === null && opts.startedAt !== void 0) ttftMs = Date.now() - opts.startedAt;
+        if (opts.captureBody && delta.content) responseText += delta.content;
+      }
+      const reason = chunk.choices?.[0]?.finish_reason;
+      if (reason) finishReason = reason;
+      opts.onChunk?.(chunk);
+    }
+  }
+  return { promptTokens, completionTokens, promptTps, genTps, ttftMs, finishReason, responseText };
+}
+
 // src/chat/chat-upstream.ts
 var DEFAULT_CTX = 4096;
 function resolveChatUpstream(d, requestedModel) {
@@ -293,9 +385,9 @@ function resolveChatUpstream(d, requestedModel) {
     }
   };
 }
-function callChatUpstream(upstream, body, signal, fetchImpl = fetch) {
+function callChatUpstream(upstream, body, signal, fetchImpl = fetch, d) {
   const payload = JSON.stringify(body);
-  if (upstream.remote) {
+  const call = upstream.remote ? (() => {
     const headers = linkHeaders(upstream.remote);
     headers.set("content-type", "application/json");
     return proxyStream(
@@ -305,8 +397,7 @@ function callChatUpstream(upstream, body, signal, fetchImpl = fetch) {
       signal,
       fetchImpl
     );
-  }
-  return fetchImpl(`${upstream.target}/v1/chat/completions`, {
+  }) : () => fetchImpl(`${upstream.target}/v1/chat/completions`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: payload,
@@ -315,10 +406,74 @@ function callChatUpstream(upstream, body, signal, fetchImpl = fetch) {
     // string body and preserved from the call sites this replaced.
     duplex: "half"
   });
+  if (!d?.requestLog || upstream.remote) return call();
+  const rlCfg = requestLogConfig(d);
+  if (!rlCfg.enabled) return call();
+  const reqBody = body;
+  const captureBody = !!rlCfg.captureBodies;
+  const logId = d.requestLog.start({
+    source: "chat",
+    harness: null,
+    codeSessionId: null,
+    modelKey: upstream.modelField || null,
+    remote: null,
+    stream: reqBody?.stream === true,
+    params: extractParams(reqBody),
+    counts: summarizeRequest(reqBody),
+    ...captureBody ? { requestBody: payload } : {}
+  });
+  const startedAt = Date.now();
+  return call().then(
+    (res) => {
+      if (!res.ok || !res.body) {
+        d.requestLog.finalize(logId, { status: res.status, error: { code: "engine_error", message: `Engine returned HTTP ${res.status}.` }, durationMs: Date.now() - startedAt });
+        return res;
+      }
+      const [a, b] = res.body.tee();
+      const drain = reqBody?.stream === true ? drainOpenAiSseForLog(b, { captureBody, startedAt }).then((r) => {
+        d.requestLog.finalize(logId, {
+          status: res.status,
+          promptTokens: r.promptTokens,
+          completionTokens: r.completionTokens,
+          promptTps: r.promptTps,
+          genTps: r.genTps,
+          ttftMs: r.ttftMs,
+          finishReason: r.finishReason,
+          durationMs: Date.now() - startedAt,
+          responseBody: captureBody ? JSON.stringify({ content: r.responseText }) : void 0
+        });
+      }) : new Response(b).text().then((text) => {
+        let usage;
+        let finishReason = null;
+        try {
+          const oai = JSON.parse(text);
+          usage = oai.usage;
+          finishReason = oai.choices?.[0]?.finish_reason ?? null;
+        } catch {
+        }
+        d.requestLog.finalize(logId, {
+          status: res.status,
+          promptTokens: usage?.prompt_tokens,
+          completionTokens: usage?.completion_tokens,
+          finishReason,
+          durationMs: Date.now() - startedAt,
+          responseBody: captureBody ? text : void 0
+        });
+      });
+      drain.catch(() => {
+        d.requestLog.finalize(logId, { status: res.status, error: { code: "drain_error", message: "Failed to read the response for the request log." }, durationMs: Date.now() - startedAt });
+      });
+      return new Response(a, { status: res.status, headers: res.headers });
+    },
+    (e) => {
+      d.requestLog.finalize(logId, { status: null, error: { code: "engine_unreachable", message: e?.message || "Engine unreachable." }, durationMs: Date.now() - startedAt });
+      throw e;
+    }
+  );
 }
 
 // src/auth.ts
-import { createHash, randomBytes, randomUUID as randomUUID2 } from "crypto";
+import { createHash, randomBytes, randomUUID as randomUUID3 } from "crypto";
 import { getConnInfo } from "@hono/node-server/conninfo";
 
 // src/engines/download.ts
@@ -1392,7 +1547,7 @@ async function autoTitle(d, convId, prevMessages, assistantReply, upstream) {
         max_tokens: 32,
         thinking_budget_tokens: 0,
         chat_template_kwargs: { enable_thinking: false }
-      }, AbortSignal.timeout(2e4));
+      }, AbortSignal.timeout(2e4), void 0, d);
     } finally {
       release?.();
     }