sparkecoder 0.1.122 → 0.1.124

package/dist/cli.js

@@ -8202,6 +8202,55 @@ function wrapToolsNeverThrow(tools) {
   }
   return wrapped;
 }
+function ensureToolResultsFollowCalls(messages) {
+  if (!Array.isArray(messages) || messages.length < 3) return messages;
+  let mutated = false;
+  const result = messages.slice();
+  let i = 0;
+  while (i < result.length) {
+    const msg = result[i];
+    if (msg?.role !== "assistant" || !Array.isArray(msg.content)) {
+      i++;
+      continue;
+    }
+    const callIds = /* @__PURE__ */ new Set();
+    for (const part of msg.content) {
+      if (part?.type === "tool-call" && typeof part.toolCallId === "string") {
+        callIds.add(part.toolCallId);
+      }
+    }
+    if (callIds.size === 0) {
+      i++;
+      continue;
+    }
+    let toolIdx = -1;
+    for (let j = i + 1; j < result.length; j++) {
+      const m = result[j];
+      if (m?.role === "assistant" && Array.isArray(m.content) && m.content.some((p) => p?.type === "tool-call")) {
+        break;
+      }
+      if (m?.role === "tool" && Array.isArray(m.content)) {
+        const answersOne = m.content.some(
+          (p) => p?.type === "tool-result" && typeof p.toolCallId === "string" && callIds.has(p.toolCallId)
+        );
+        if (answersOne) {
+          toolIdx = j;
+          break;
+        }
+      }
+    }
+    if (toolIdx > i + 1) {
+      const [toolMsg] = result.splice(toolIdx, 1);
+      result.splice(i + 1, 0, toolMsg);
+      mutated = true;
+      console.warn(
+        `[tool-repair] Reordered tool-result message from index ${toolIdx} to ${i + 1} to immediately follow assistant tool-call(s) (${[...callIds].join(", ")}). ${toolIdx - i - 1} message(s) were wedged between them.`
+      );
+    }
+    i++;
+  }
+  return mutated ? result : messages;
+}
 function repairToolPairing(messages) {
   const toolCallIds = /* @__PURE__ */ new Set();
   const toolResultIds = /* @__PURE__ */ new Set();
@@ -8321,6 +8370,7 @@ ${summaryContent}`
           ];
         }
         messages = repairToolPairing(messages);
+        messages = ensureToolResultsFollowCalls(messages);
         messages = ensureEndsWithUserOrTool(messages);
         return messages;
       }
@@ -8515,7 +8565,7 @@ ${summaryContent}`
         }
       }
       async addResponseMessages(messages) {
-        const safe = repairToolPairing(messages);
+        const safe = ensureToolResultsFollowCalls(repairToolPairing(messages));
         await messageQueries.addMany(this.sessionId, safe);
         try {
           const { appendTurn: appendTurn2, flattenContent: flattenContent2 } = await Promise.resolve().then(() => (init_conversation_archive(), conversation_archive_exports));
@@ -10626,7 +10676,7 @@ ${prompt}` });
         const config = getConfig();
         const userContent = this.buildUserMessageContent(options.prompt, options.attachments);
         if (!options.skipSaveUserMessage) {
-          this.context.addUserMessage(userContent);
+          await this.context.addUserMessage(userContent);
         }
         await sessionQueries.updateStatus(this.session.id, "active");
         let systemPrompt = await buildSystemPrompt({
@@ -10674,9 +10724,10 @@ ${personality.trim()}`;
           // aborted mid-tool). Repairing in `prepareStep` guarantees no orphan
           // ever reaches the model and we never hit AI_MissingToolResultsError.
           prepareStep: async ({ messages: stepMessages }) => {
-            const repaired = repairToolPairing(stepMessages);
-            if (repaired === stepMessages) return {};
-            return { messages: repaired };
+            const paired = repairToolPairing(stepMessages);
+            const ordered = ensureToolResultsFollowCalls(paired);
+            if (ordered === stepMessages) return {};
+            return { messages: ordered };
           },
           onStepFinish: async (step) => {
             options.onStepFinish?.(step);
@@ -10689,7 +10740,7 @@ ${personality.trim()}`;
           const result = await stream;
           const response = await result.response;
           const responseMessages = response.messages;
-          this.context.addResponseMessages(responseMessages);
+          await this.context.addResponseMessages(responseMessages);
         };
         return {
           sessionId: this.session.id,
@@ -10703,7 +10754,7 @@ ${personality.trim()}`;
        */
       async run(options) {
         const config = getConfig();
-        this.context.addUserMessage(options.prompt);
+        await this.context.addUserMessage(options.prompt);
         const systemPrompt = await buildSystemPrompt({
           workingDirectory: this.session.workingDirectory,
           skillsDirectories: config.resolvedSkillsDirectories,
@@ -10727,13 +10778,14 @@ ${personality.trim()}`;
           } : void 0,
           // Repair tool pairing before every step (see `stream()` for full rationale).
           prepareStep: async ({ messages: stepMessages }) => {
-            const repaired = repairToolPairing(stepMessages);
-            if (repaired === stepMessages) return {};
-            return { messages: repaired };
+            const paired = repairToolPairing(stepMessages);
+            const ordered = ensureToolResultsFollowCalls(paired);
+            if (ordered === stepMessages) return {};
+            return { messages: ordered };
           }
         });
         const responseMessages = result.response.messages;
-        this.context.addResponseMessages(responseMessages);
+        await this.context.addResponseMessages(responseMessages);
         return {
           text: result.text,
           steps: result.steps
@@ -10916,9 +10968,10 @@ ${p.text}` : p.text;
             // See the matching note in `stream()` — repair tool pairing before
             // every step so we never feed the model an orphan tool-call.
             prepareStep: async ({ messages: stepMessages }) => {
-              const repaired = repairToolPairing(stepMessages);
-              if (repaired === stepMessages) return {};
-              return { messages: repaired };
+              const paired = repairToolPairing(stepMessages);
+              const ordered = ensureToolResultsFollowCalls(paired);
+              if (ordered === stepMessages) return {};
+              return { messages: ordered };
             },
             onStepFinish: async (step) => {
               options.onStepFinish?.(step);
@@ -13014,31 +13067,44 @@ async function recoverFromMissingToolResults(sessionId, error) {
   } catch (err) {
     console.warn("[missing-tool-recovery] could not load messages:", err?.message || err);
   }
-  const toolNameByCallId = /* @__PURE__ */ new Map();
+  const toolInfoByCallId = /* @__PURE__ */ new Map();
+  const resultMessageIndexByCallId = /* @__PURE__ */ new Map();
   const existingResultIds = /* @__PURE__ */ new Set();
-  for (const msg of history) {
+  for (let idx = 0; idx < history.length; idx++) {
+    const msg = history[idx];
     if (!Array.isArray(msg.content)) continue;
     for (const part of msg.content) {
       if (part?.type === "tool-call" && typeof part.toolCallId === "string") {
-        if (typeof part.toolName === "string") toolNameByCallId.set(part.toolCallId, part.toolName);
+        if (typeof part.toolName === "string") {
+          toolInfoByCallId.set(part.toolCallId, { toolName: part.toolName, callMessageIndex: idx });
+        }
       }
       if (part?.type === "tool-result" && typeof part.toolCallId === "string") {
         existingResultIds.add(part.toolCallId);
+        resultMessageIndexByCallId.set(part.toolCallId, idx);
       }
     }
   }
-  const resolved = toolCallIds.map((id) => ({
-    toolCallId: id,
-    toolName: toolNameByCallId.get(id) ?? "unknown",
-    foundInAssistantMessage: toolNameByCallId.has(id)
-  }));
+  const resolved = toolCallIds.map((id) => {
+    const info = toolInfoByCallId.get(id);
+    const resultIdx = resultMessageIndexByCallId.get(id);
+    const wedgedRoles = info && typeof resultIdx === "number" && resultIdx > info.callMessageIndex + 1 ? history.slice(info.callMessageIndex + 1, resultIdx).map((m) => m.role) : void 0;
+    return {
+      toolCallId: id,
+      toolName: info?.toolName ?? "unknown",
+      foundInAssistantMessage: !!info,
+      callMessageIndex: info?.callMessageIndex,
+      resultMessageIndex: resultIdx,
+      wedgedMessageRoles: wedgedRoles
+    };
+  });
   const stillOrphaned = toolCallIds.filter((id) => !existingResultIds.has(id));
   let syntheticToolMessageSaved = false;
   if (stillOrphaned.length > 0) {
     const syntheticParts = stillOrphaned.map((id) => ({
       type: "tool-result",
       toolCallId: id,
-      toolName: toolNameByCallId.get(id) ?? "unknown",
+      toolName: toolInfoByCallId.get(id)?.toolName ?? "unknown",
       output: {
         type: "text",
         value: "[Auto-recovered: the original tool execution never produced a result (crash, timeout, or message stripped during context compaction). This synthetic placeholder lets the conversation continue.]"
@@ -13055,15 +13121,49 @@ async function recoverFromMissingToolResults(sessionId, error) {
     }
   }
   const lastFewMessageRoles = history.slice(-6).map((m) => m.role);
+  const first = resolved.find((r) => r.callMessageIndex !== void 0);
+  let contextSnapshot;
+  if (first?.callMessageIndex !== void 0) {
+    const start = Math.max(0, first.callMessageIndex - 1);
+    const end = Math.min(
+      history.length,
+      Math.max(first.callMessageIndex, first.resultMessageIndex ?? first.callMessageIndex) + 2
+    );
+    contextSnapshot = history.slice(start, end).map((m, offset) => ({
+      index: start + offset,
+      role: m.role,
+      summary: summarizeContent(m.content)
+    }));
+  }
+  const anyWedged = resolved.some((r) => r.wedgedMessageRoles && r.wedgedMessageRoles.length > 0);
   return {
     kind: "missing_tool_results",
     toolCallIds,
     resolved,
     syntheticToolMessageSaved,
     lastFewMessageRoles,
-    hint: syntheticToolMessageSaved ? "Synthetic tool-result(s) saved. Re-send your message to continue." : "Could not auto-recover; please reset the session or revert to the previous checkpoint."
+    contextSnapshot,
+    hint: anyWedged ? "A non-tool message was wedged between the assistant tool-call and its tool-result (likely a Slack/system inbox event that arrived mid-turn). " + (syntheticToolMessageSaved ? "Synthetic tool-result was added as a fallback, but the proper fix (now in place) is the reordering pass that moves tool-results to immediately follow their tool-calls." : "The reordering pass should fix this on the next turn; if not, revert to the previous checkpoint.") : syntheticToolMessageSaved ? "Synthetic tool-result(s) saved. Re-send your message to continue." : "Could not auto-recover; please reset the session or revert to the previous checkpoint."
   };
 }
+function summarizeContent(content) {
+  if (typeof content === "string") {
+    return content.length > 160 ? content.slice(0, 160) + "\u2026" : content;
+  }
+  if (!Array.isArray(content)) return String(content);
+  const parts = content.map((p) => {
+    if (!p || typeof p !== "object") return String(p);
+    if (p.type === "text") {
+      const t = String(p.text ?? "");
+      return `text(${t.length > 80 ? t.slice(0, 80) + "\u2026" : t})`;
+    }
+    if (p.type === "tool-call") return `tool-call(${p.toolName}:${p.toolCallId})`;
+    if (p.type === "tool-result") return `tool-result(${p.toolName ?? "?"}:${p.toolCallId})`;
+    if (p.type === "reasoning") return "reasoning";
+    return p.type ?? "unknown";
+  });
+  return parts.join(", ");
+}
 
 // src/server/routes/agents.ts
 init_agent();
@@ -16924,7 +17024,7 @@ function generateOpenAPISpec() {
 init_config();
 init_semantic();
 init_db();
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync8, readFileSync as readFileSync11, existsSync as existsSync23, statSync as statSync4 } from "fs";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync8, readFileSync as readFileSync11, existsSync as existsSync23, statSync as statSync4, unlinkSync as unlinkSync3 } from "fs";
 import { resolve as resolve13, join as join18 } from "path";
 function getCliVersion() {
   const here = dirname11(fileURLToPath5(import.meta.url));
@@ -18534,7 +18634,9 @@ program.command("request-permissions").description("Open System Settings to the
   console.log();
 });
 {
-  let stateFilePath = function() {
+  let shellEscape2 = function(str) {
+    return `'${str.replace(/'/g, "'\\''")}'`;
+  }, stateFilePath = function() {
     return join18(ensureAppDataDirectory(), "recordings.json");
   }, readState = function() {
     const p = stateFilePath();
@@ -18556,21 +18658,81 @@ program.command("request-permissions").description("Open System Settings to the
   }, pruneDead = function(rows) {
     return rows.filter((r) => isAlive(r.pid));
   };
-  stateFilePath2 = stateFilePath, readState2 = readState, writeState2 = writeState, isAlive2 = isAlive, pruneDead2 = pruneDead;
+  shellEscape3 = shellEscape2, stateFilePath2 = stateFilePath, readState2 = readState, writeState2 = writeState, isAlive2 = isAlive, pruneDead2 = pruneDead;
+  async function stopRecorderPid(pid) {
+    if (!isAlive(pid)) return;
+    try {
+      process.kill(pid, "SIGINT");
+    } catch {
+      return;
+    }
+    for (let i = 0; i < 40; i++) {
+      if (!isAlive(pid)) break;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (isAlive(pid)) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+  }
+  async function convertCaptureToMp4(capturePath, mp4Path) {
+    try {
+      const { exec: exec8 } = await import("child_process");
+      const { promisify: promisify8 } = await import("util");
+      const execAsync8 = promisify8(exec8);
+      await execAsync8(
+        `ffmpeg -y -i ${shellEscape2(capturePath)} -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 -movflags +faststart ${shellEscape2(mp4Path)}`,
+        { timeout: 12e4, maxBuffer: 10 * 1024 * 1024 }
+      );
+      return existsSync23(mp4Path) && statSync4(mp4Path).size > 0;
+    } catch {
+      return false;
+    }
+  }
+  async function finalizeRecording(row) {
+    await stopRecorderPid(row.pid);
+    let finalPath = row.path;
+    let warning;
+    if (row.capturePath) {
+      for (let i = 0; i < 20; i++) {
+        if (existsSync23(row.capturePath) && statSync4(row.capturePath).size > 0) break;
+        await new Promise((r) => setTimeout(r, 200));
+      }
+      if (existsSync23(row.capturePath)) {
+        const converted = await convertCaptureToMp4(row.capturePath, row.path);
+        if (converted) {
+          try {
+            unlinkSync3(row.capturePath);
+          } catch {
+          }
+        } else {
+          finalPath = row.capturePath;
+          warning = "ffmpeg conversion to mp4 failed; kept .mov capture file";
+        }
+      }
+    }
+    const ok = existsSync23(finalPath);
+    const sizeMb = ok ? Math.round(statSync4(finalPath).size / (1024 * 1024) * 10) / 10 : 0;
+    return { path: finalPath, ok, sizeMb, warning };
+  }
   const record = program.command("record").description("Start/stop screen recordings");
   record.command("start").description("Start a screen recording (returns id, path, pid as JSON)").option("--name <slug>", "Optional human-readable label for the recording").option("--dir <path>", "Output directory (default: ~/recordings)").action(async (opts) => {
     const { homedir: homedir2, platform: osPlatform } = await import("os");
     const outDir = opts.dir ? resolve13(opts.dir.replace(/^~/, homedir2())) : join18(homedir2(), "recordings");
     mkdirSync11(outDir, { recursive: true });
     const id = `rec-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
-    const ext = osPlatform() === "darwin" ? "mov" : "mp4";
+    const ext = "mp4";
     const filename = `${id}${opts.name ? `-${String(opts.name).replace(/[^a-z0-9-]+/gi, "-").toLowerCase()}` : ""}.${ext}`;
     const path = join18(outDir, filename);
     let cmd;
     let args;
+    let capturePath;
     if (osPlatform() === "darwin") {
+      capturePath = path.replace(/\.mp4$/i, ".mov");
       cmd = existsSync23("/usr/sbin/screencapture") ? "/usr/sbin/screencapture" : "screencapture";
-      args = ["-v", "-C", "-k", path];
+      args = ["-v", "-C", "-k", capturePath];
     } else if (osPlatform() === "linux") {
       const display = process.env.DISPLAY || ":0.0";
       const size = process.env.SPARKECODER_RECORD_SIZE || "1920x1080";
@@ -18615,6 +18777,7 @@ program.command("request-permissions").description("Open System Settings to the
     });
     await new Promise((r) => setTimeout(r, 600));
     if (spawnError || exited || !child.pid) {
+      child.stderr?.destroy();
       const diagnosis = [
         spawnError && `spawn error: ${spawnError}`,
         exited && `recorder exited code=${exitCode} within 600ms`,
@@ -18633,11 +18796,13 @@ program.command("request-permissions").description("Open System Settings to the
       }));
       process.exit(1);
     }
+    child.stderr?.destroy();
     child.unref();
     const row = {
       id,
       name: opts.name,
       path,
+      capturePath,
       pid: child.pid,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       platform: osPlatform()
@@ -18655,31 +18820,15 @@ program.command("request-permissions").description("Open System Settings to the
       process.exit(1);
     }
     const startedAt = new Date(row.startedAt).getTime();
-    if (isAlive(row.pid)) {
-      try {
-        process.kill(row.pid, "SIGINT");
-      } catch {
-      }
-      for (let i = 0; i < 40; i++) {
-        if (!isAlive(row.pid)) break;
-        await new Promise((r) => setTimeout(r, 200));
-      }
-      if (isAlive(row.pid)) {
-        try {
-          process.kill(row.pid, "SIGTERM");
-        } catch {
-        }
-      }
-    }
+    const { path: finalPath, ok, sizeMb, warning } = await finalizeRecording(row);
     writeState(rows.filter((r) => r.id !== id));
-    const fileExists = existsSync23(row.path);
-    const sizeMb = fileExists ? Math.round(statSync4(row.path).size / (1024 * 1024) * 10) / 10 : 0;
     console.log(JSON.stringify({
       id,
-      path: row.path,
+      path: finalPath,
       durationSec: Math.round((Date.now() - startedAt) / 1e3),
       sizeMb,
-      ok: fileExists
+      ok,
+      ...warning ? { warning } : {}
     }));
   });
   record.command("list").description("List active recordings").action(() => {
@@ -18691,28 +18840,14 @@ program.command("request-permissions").description("Open System Settings to the
     const rows = readState();
     const stopped = [];
     for (const r of rows) {
-      if (isAlive(r.pid)) {
-        try {
-          process.kill(r.pid, "SIGINT");
-        } catch {
-        }
-        for (let i = 0; i < 30; i++) {
-          if (!isAlive(r.pid)) break;
-          await new Promise((res) => setTimeout(res, 200));
-        }
-        if (isAlive(r.pid)) {
-          try {
-            process.kill(r.pid, "SIGTERM");
-          } catch {
-          }
-        }
-      }
-      stopped.push({ id: r.id, path: r.path, ok: existsSync23(r.path) });
+      const { path: finalPath, ok, warning } = await finalizeRecording(r);
+      stopped.push({ id: r.id, path: finalPath, ok, ...warning ? { warning } : {} });
     }
     writeState([]);
     console.log(JSON.stringify({ stopped }));
   });
 }
+var shellEscape3;
 var stateFilePath2;
 var readState2;
 var writeState2;