turbollm 0.7.0 → 0.7.1

package/dist/cli.js

@@ -2311,6 +2311,21 @@ function mlxEntryFor(dir) {
     if (existsSync9(tc)) hasChatTemplate = readFileSync3(tc, "utf8").includes("chat_template");
   } catch {
   }
+  let incomplete = false;
+  try {
+    const indexPath = join7(dir, "model.safetensors.index.json");
+    if (existsSync9(indexPath)) {
+      const index = JSON.parse(readFileSync3(indexPath, "utf8"));
+      const shards = new Set(Object.values(index.weight_map ?? {}));
+      for (const shard of shards) {
+        if (!existsSync9(join7(dir, shard))) {
+          incomplete = true;
+          break;
+        }
+      }
+    }
+  } catch {
+  }
   const expertCount = cfg2.num_local_experts ?? cfg2.num_experts ?? 0;
   const bits = cfg2.quantization?.bits;
   const quant = bits ? `${bits}bit` : "fp16";
@@ -2336,7 +2351,7 @@ function mlxEntryFor(dir) {
     mmprojPath: null,
     hasChatTemplate,
     embedding: isEmbeddingModel(arch2, basename(dir)),
-    incomplete: false,
+    incomplete,
     parseError,
     loaded: false,
     hasProfile: false,
@@ -5584,7 +5599,7 @@ function inferRepoFromPath(filePath, modelDirs) {
     const root = norm(dir);
     if (!fp.toLowerCase().startsWith(root.toLowerCase() + "/")) continue;
     const parts = fp.slice(root.length + 1).split("/");
-    if (parts.length >= 3 && seg.test(parts[0]) && seg.test(parts[1])) {
+    if (parts.length >= 2 && seg.test(parts[0]) && seg.test(parts[1])) {
       return `${parts[0]}/${parts[1]}`;
     }
     return null;
@@ -5864,6 +5879,11 @@ function buildConnectSnippets(cli, base2, apiKey, modelName) {
 // src/chat/chat-routes.ts
 import { streamSSE as streamSSE2 } from "hono/streaming";
 var inflight = /* @__PURE__ */ new Map();
+var THINK_OPEN = "<think>";
+var THINK_CLOSE = "</think>";
+var CHAN_ANALYSIS_OPEN = "<|channel|>analysis<|message|>";
+var CHAN_CLOSE = "<|end|>";
+var CHAN_FINAL_SKIP = "<|start|>assistant<|channel|>final<|message|>";
 var EXPERT_SYSTEM_PROMPT = `You are the TurboLLM in-app expert assistant \u2014 a knowledgeable, friendly guide built into TurboLLM, a local-first desktop app for running large language models on the user's own machine.
 
 Your job is to help the user get the most out of TurboLLM:
@@ -6126,9 +6146,9 @@ async function runGeneration(d, stream, ctx) {
         ac.signal.addEventListener("abort", cancelReader, { once: true });
       }
       let roundContent = "";
-      let inThink = false;
-      let pendingThinkBuf = "";
-      let firstDelta = false;
+      let parsePhase = "initial";
+      let parseIsChannel = false;
+      let parseBuf = "";
       let finishReason = "";
       const pendingToolCalls = /* @__PURE__ */ new Map();
       roundLoop: while (true) {
@@ -6172,8 +6192,8 @@ async function runGeneration(d, stream, ctx) {
             }
             continue;
           }
-          if (delta.reasoning_content) {
-            const rc = delta.reasoning_content;
+          const rc = delta.reasoning_content ?? delta.reasoning;
+          if (rc) {
             if (!thinkStart) thinkStart = Date.now();
             thinkEnd = Date.now();
             fullReasoning += rc;
@@ -6182,88 +6202,109 @@ async function runGeneration(d, stream, ctx) {
           }
           const raw_content = delta.content ?? "";
           if (!raw_content) continue;
-          let toProcess = raw_content;
-          while (toProcess.length > 0) {
-            if (!inThink && !firstDelta) {
-              pendingThinkBuf += toProcess;
-              const openIdx = pendingThinkBuf.indexOf("<think>");
+          parseBuf += raw_content;
+          while (parseBuf.length > 0) {
+            if (parsePhase === "initial") {
+              const thinkIdx = parseBuf.indexOf(THINK_OPEN);
+              const chanIdx = parseBuf.indexOf(CHAN_ANALYSIS_OPEN);
+              const hasThink = thinkIdx >= 0;
+              const hasChan = chanIdx >= 0;
+              const useThink = hasThink && (!hasChan || thinkIdx <= chanIdx);
+              const openIdx = useThink ? thinkIdx : hasChan ? chanIdx : -1;
+              const openTag = useThink ? THINK_OPEN : CHAN_ANALYSIS_OPEN;
               if (openIdx === 0) {
-                inThink = true;
+                parseIsChannel = !useThink;
+                parsePhase = "reasoning";
                 if (!thinkStart) thinkStart = Date.now();
-                pendingThinkBuf = pendingThinkBuf.slice(7);
-                toProcess = "";
+                parseBuf = parseBuf.slice(openTag.length);
               } else if (openIdx > 0) {
-                const before = pendingThinkBuf.slice(0, openIdx);
+                const before = parseBuf.slice(0, openIdx);
                 fullContent += before;
                 roundContent += before;
-                firstDelta = true;
                 if (!ttftMs) ttftMs = Date.now() - requestStart;
                 await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: before }) });
-                inThink = true;
+                parseIsChannel = !useThink;
+                parsePhase = "reasoning";
                 if (!thinkStart) thinkStart = Date.now();
-                pendingThinkBuf = pendingThinkBuf.slice(openIdx + 7);
-                toProcess = "";
-              } else if (pendingThinkBuf.length > 20) {
-                const flush = pendingThinkBuf;
-                pendingThinkBuf = "";
-                fullContent += flush;
-                roundContent += flush;
-                firstDelta = true;
-                if (!ttftMs) ttftMs = Date.now() - requestStart;
-                await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: flush }) });
-                toProcess = "";
+                parseBuf = parseBuf.slice(openIdx + openTag.length);
               } else {
-                toProcess = "";
+                const safeLen = parseBuf.length - (CHAN_ANALYSIS_OPEN.length - 1);
+                if (safeLen > 0) {
+                  const flush = parseBuf.slice(0, safeLen);
+                  parseBuf = parseBuf.slice(safeLen);
+                  fullContent += flush;
+                  roundContent += flush;
+                  if (!ttftMs) ttftMs = Date.now() - requestStart;
+                  d.manager.setLiveGen({ phase: "gen", pct: 0, outputTokens: ++liveOut });
+                  await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: flush }) });
+                  parsePhase = "content";
+                } else {
+                  break;
+                }
               }
-            } else if (inThink) {
-              pendingThinkBuf += toProcess;
-              const closeIdx = pendingThinkBuf.indexOf("</think>");
+            } else if (parsePhase === "reasoning") {
+              const closeTag = parseIsChannel ? CHAN_CLOSE : THINK_CLOSE;
+              const closeIdx = parseBuf.indexOf(closeTag);
               if (closeIdx >= 0) {
-                const thinkChunk = pendingThinkBuf.slice(0, closeIdx);
-                if (thinkChunk) {
-                  thinkEnd = Date.now();
-                  fullReasoning += thinkChunk;
-                  await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: thinkChunk }) });
+                if (closeIdx > 0) {
+                  const chunk2 = parseBuf.slice(0, closeIdx);
+                  fullReasoning += chunk2;
+                  await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: chunk2 }) });
                 }
-                inThink = false;
                 thinkEnd = Date.now();
-                pendingThinkBuf = pendingThinkBuf.slice(closeIdx + 8);
-                toProcess = "";
-                if (pendingThinkBuf) {
-                  fullContent += pendingThinkBuf;
-                  roundContent += pendingThinkBuf;
-                  firstDelta = true;
+                const wasChannel = parseIsChannel;
+                parseBuf = parseBuf.slice(closeIdx + closeTag.length);
+                parsePhase = wasChannel ? "skipFinal" : "content";
+                if (!wasChannel && parseBuf) {
+                  fullContent += parseBuf;
+                  roundContent += parseBuf;
                   if (!ttftMs) ttftMs = Date.now() - requestStart;
-                  await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: pendingThinkBuf }) });
-                  pendingThinkBuf = "";
+                  await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: parseBuf }) });
+                  parseBuf = "";
                 }
-              } else {
+              } else if (parseBuf.length >= closeTag.length) {
+                const safe = parseBuf.length - (closeTag.length - 1);
+                const chunk2 = parseBuf.slice(0, safe);
+                parseBuf = parseBuf.slice(safe);
                 thinkEnd = Date.now();
-                fullReasoning += pendingThinkBuf;
-                await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: pendingThinkBuf }) });
-                pendingThinkBuf = "";
-                toProcess = "";
+                fullReasoning += chunk2;
+                await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: chunk2 }) });
+              } else {
+                break;
+              }
+            } else if (parsePhase === "skipFinal") {
+              if (parseBuf.startsWith(CHAN_FINAL_SKIP)) {
+                parseBuf = parseBuf.slice(CHAN_FINAL_SKIP.length);
+                parsePhase = "content";
+              } else if (CHAN_FINAL_SKIP.startsWith(parseBuf) && parseBuf.length < CHAN_FINAL_SKIP.length) {
+                break;
+              } else {
+                const skipIdx = parseBuf.indexOf(CHAN_FINAL_SKIP);
+                parseBuf = skipIdx >= 0 ? parseBuf.slice(skipIdx + CHAN_FINAL_SKIP.length) : "";
+                parsePhase = "content";
               }
             } else {
               if (!ttftMs) ttftMs = Date.now() - requestStart;
-              firstDelta = true;
-              fullContent += toProcess;
-              roundContent += toProcess;
+              fullContent += parseBuf;
+              roundContent += parseBuf;
               d.manager.setLiveGen({ phase: "gen", pct: 0, outputTokens: ++liveOut });
-              await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: toProcess }) });
-              toProcess = "";
+              await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: parseBuf }) });
+              parseBuf = "";
+              break;
             }
           }
         }
       }
       ac.signal.removeEventListener("abort", cancelReader);
-      if (pendingThinkBuf && inThink) {
-        fullReasoning += pendingThinkBuf;
-        await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: pendingThinkBuf }) });
-      } else if (pendingThinkBuf) {
-        fullContent += pendingThinkBuf;
-        roundContent += pendingThinkBuf;
-        await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: pendingThinkBuf }) });
+      if (parseBuf) {
+        if (parsePhase === "reasoning") {
+          fullReasoning += parseBuf;
+          await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: parseBuf }) });
+        } else {
+          fullContent += parseBuf;
+          roundContent += parseBuf;
+          await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: parseBuf }) });
+        }
       }
       if ((finishReason === "tool_calls" || pendingToolCalls.size > 0) && d.tools && toolIter <= MAX_TOOL_ITER) {
         const roundToolCalls = Array.from(pendingToolCalls.values());