sparkecoder 0.1.121 → 0.1.123

package/dist/agent/index.d.ts

@@ -1,6 +1,6 @@
 import 'ai';
-import '../schema-DxrKyetI.js';
-export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, C as ContextManager, M as MessageAttachment, d as buildSystemPrompt, e as buildTaskPromptAddendum } from '../index-DczYH89U.js';
-import '../search-CVVfuBPZ.js';
+import '../schema-BWbWmfDQ.js';
+export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, C as ContextManager, M as MessageAttachment, d as buildSystemPrompt, e as buildTaskPromptAddendum } from '../index-Bcz0aCAR.js';
+import '../search-DOzC4ojH.js';
 import 'drizzle-orm/sqlite-core';
 import 'zod';

package/dist/agent/index.js

@@ -1894,7 +1894,7 @@ __export(recorder_exports, {
 import { exec as exec5 } from "child_process";
 import { promisify as promisify5 } from "util";
 import { writeFile as writeFile5, mkdir as mkdir4, readFile as readFile11, unlink as unlink2, readdir as readdir5, rm } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { tmpdir } from "os";
 import { nanoid as nanoid7 } from "nanoid";
 async function checkFfmpeg() {
@@ -1951,21 +1951,21 @@ var init_recorder = __esm({
        */
       async encode() {
         if (this.frames.length === 0) return null;
-        const workDir = join10(tmpdir(), `sparkecoder-recording-${nanoid7(8)}`);
+        const workDir = join11(tmpdir(), `sparkecoder-recording-${nanoid7(8)}`);
         await mkdir4(workDir, { recursive: true });
         try {
           for (let i = 0; i < this.frames.length; i++) {
-            const framePath = join10(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
+            const framePath = join11(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
             await writeFile5(framePath, this.frames[i].data);
           }
           const duration = (this.frames[this.frames.length - 1].timestamp - this.frames[0].timestamp) / 1e3;
           const fps = duration > 0 ? Math.round(this.frames.length / duration) : 10;
           const clampedFps = Math.max(1, Math.min(fps, 30));
-          const outputPath = join10(workDir, `recording_${this.sessionId}.mp4`);
+          const outputPath = join11(workDir, `recording_${this.sessionId}.mp4`);
           const hasFfmpeg = await checkFfmpeg();
           if (hasFfmpeg) {
             await execAsync5(
-              `ffmpeg -y -framerate ${clampedFps} -i "${join10(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
+              `ffmpeg -y -framerate ${clampedFps} -i "${join11(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
               { timeout: 12e4 }
             );
           } else {
@@ -1977,7 +1977,7 @@ var init_recorder = __esm({
           const files = await readdir5(workDir);
           for (const f of files) {
             if (f.startsWith("frame_")) {
-              await unlink2(join10(workDir, f)).catch(() => {
+              await unlink2(join11(workDir, f)).catch(() => {
               });
             }
           }
@@ -2835,10 +2835,10 @@ async function resizeImageIfNeeded(buffer, mediaType) {
   const willConvertToJpeg = isPng && (needsShrink || buffer.length > 2 * 1024 * 1024);
   const outputMediaType = willConvertToJpeg || !isPng ? "image/jpeg" : "image/png";
   const ext = outputMediaType === "image/png" ? ".png" : ".jpg";
-  const cachePath = join3(cacheDir, key2 + ext);
-  if (existsSync3(cachePath)) {
+  const cachePath2 = join3(cacheDir, key2 + ext);
+  if (existsSync3(cachePath2)) {
     console.log(`[image-resize] Cache hit for ${width}x${height} image`);
-    return { buffer: readFileSync2(cachePath), mediaType: outputMediaType };
+    return { buffer: readFileSync2(cachePath2), mediaType: outputMediaType };
   }
   let pipeline = sharp(buffer);
   if (needsResize) {
@@ -2863,7 +2863,7 @@ async function resizeImageIfNeeded(buffer, mediaType) {
     }
     finalMediaType = "image/jpeg";
   }
-  writeFileSync2(cachePath, result);
+  writeFileSync2(cachePath2, result);
   const resultMeta = await sharp(result).metadata();
   console.log(
     `[image-resize] ${width}x${height} -> ${resultMeta.width}x${resultMeta.height} (${(buffer.length / 1024).toFixed(0)}KB -> ${(result.length / 1024).toFixed(0)}KB, ${finalMediaType})`
@@ -6865,6 +6865,7 @@ ${summaryContent}`
       ];
     }
     messages = repairToolPairing(messages);
+    messages = ensureToolResultsFollowCalls(messages);
     messages = ensureEndsWithUserOrTool(messages);
     return messages;
   }
@@ -7059,7 +7060,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));
@@ -7104,6 +7105,84 @@ function stripOrphanedToolResults(msg, removedIds) {
   if (parts.length === 0) return null;
   return { ...msg, content: parts };
 }
+function wrapToolsNeverThrow(tools) {
+  if (!tools || typeof tools !== "object") return tools;
+  const wrapped = {};
+  for (const [name, t] of Object.entries(tools)) {
+    if (!t || typeof t.execute !== "function") {
+      wrapped[name] = t;
+      continue;
+    }
+    const original = t.execute;
+    wrapped[name] = {
+      ...t,
+      execute: async (input, opts) => {
+        try {
+          return await original.call(t, input, opts);
+        } catch (err) {
+          const message = err?.message ?? String(err);
+          console.warn(`[tool:${name}] threw \u2014 converted to error result so the tool-call isn't orphaned:`, message);
+          return {
+            __error: true,
+            tool: name,
+            message,
+            note: "Tool execution threw an exception. The agent should treat this as a failed tool call and decide how to recover."
+          };
+        }
+      }
+    };
+  }
+  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();
@@ -7181,6 +7260,100 @@ var webChannel = {
 
 // src/integrations/slack/client.ts
 init_config();
+
+// src/integrations/slack/persistence.ts
+init_config();
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync3, renameSync } from "fs";
+import { join as join9, dirname as dirname6 } from "path";
+var FILENAME = "slack-cache.json";
+var FILE_VERSION = 1;
+var SAVE_DEBOUNCE_MS = 500;
+var MAX_THREADS = 5e3;
+var loaded = false;
+var userMap = /* @__PURE__ */ new Map();
+var threadMap = /* @__PURE__ */ new Map();
+var dirty = false;
+var saveTimer = null;
+function cachePath() {
+  return join9(ensureAppDataDirectory(), FILENAME);
+}
+function load() {
+  if (loaded) return;
+  loaded = true;
+  const path = cachePath();
+  if (!existsSync16(path)) return;
+  try {
+    const raw = readFileSync7(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== FILE_VERSION) return;
+    const now = Date.now();
+    for (const [id, e] of Object.entries(parsed.users || {})) {
+      if (e && typeof e.expiresAt === "number" && e.expiresAt > now) {
+        userMap.set(id, { name: e.name ?? null, expiresAt: e.expiresAt });
+      }
+    }
+    for (const [key2, e] of Object.entries(parsed.threads || {})) {
+      if (e && typeof e.expiresAt === "number" && e.expiresAt > now) {
+        threadMap.set(key2, { owned: !!e.owned, expiresAt: e.expiresAt });
+      }
+    }
+  } catch (err) {
+    console.warn(`[slack] could not load ${FILENAME}:`, err?.message || err);
+  }
+}
+function evictIfOversized(map, max) {
+  if (map.size <= max) return;
+  const sorted = [...map.entries()].sort((a, b) => a[1].expiresAt - b[1].expiresAt);
+  const toRemove = map.size - max;
+  for (let i = 0; i < toRemove; i++) map.delete(sorted[i][0]);
+}
+function scheduleSave() {
+  dirty = true;
+  if (saveTimer) return;
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    if (dirty) saveSync();
+  }, SAVE_DEBOUNCE_MS);
+  saveTimer.unref?.();
+}
+function saveSync() {
+  dirty = false;
+  try {
+    const path = cachePath();
+    const dir = dirname6(path);
+    if (!existsSync16(dir)) mkdirSync6(dir, { recursive: true });
+    const payload = {
+      version: FILE_VERSION,
+      users: Object.fromEntries(userMap),
+      threads: Object.fromEntries(threadMap)
+    };
+    const tmp = `${path}.tmp`;
+    writeFileSync3(tmp, JSON.stringify(payload), "utf-8");
+    renameSync(tmp, path);
+  } catch (err) {
+    console.warn(`[slack] could not persist ${FILENAME}:`, err?.message || err);
+  }
+}
+var exitHooked = false;
+function hookExit() {
+  if (exitHooked) return;
+  exitHooked = true;
+  const flush2 = () => {
+    if (dirty) saveSync();
+  };
+  process.once("beforeExit", flush2);
+  process.once("SIGINT", flush2);
+  process.once("SIGTERM", flush2);
+}
+function setCachedThreadOwnership(key2, entry2) {
+  load();
+  hookExit();
+  threadMap.set(key2, entry2);
+  evictIfOversized(threadMap, MAX_THREADS);
+  scheduleSave();
+}
+
+// src/integrations/slack/client.ts
 function readSlackConfig() {
   try {
     const cfg = getConfig();
@@ -7221,6 +7394,18 @@ function isSlackConfigured() {
 }
 var USER_TTL_MS = 60 * 60 * 1e3;
 var USER_FAIL_TTL_MS = 5 * 60 * 1e3;
+var THREAD_OWNED_TTL_MS = 60 * 60 * 1e3;
+var THREAD_NEG_TTL_MS = 5 * 60 * 1e3;
+function threadCacheKey(channel, threadTs) {
+  return `${channel}\u241F${threadTs}`;
+}
+function noteBotPostedInThread(channel, threadTs) {
+  if (!channel || !threadTs) return;
+  setCachedThreadOwnership(threadCacheKey(channel, threadTs), {
+    owned: true,
+    expiresAt: Date.now() + THREAD_OWNED_TTL_MS
+  });
+}
 
 // src/integrations/channels/slack.ts
 var ownedThreads = /* @__PURE__ */ new Set();
@@ -7245,6 +7430,7 @@ var slackChannel = {
     if (!result.ok) throw new Error(`slack post failed: ${result.error}`);
     if (r.slackChannel && r.threadTs) {
       markThreadOwned(r.slackChannel, r.threadTs);
+      noteBotPostedInThread(r.slackChannel, r.threadTs);
     }
   },
   displayLabel(ref) {
@@ -7761,8 +7947,8 @@ import { createMCPClient } from "@ai-sdk/mcp";
 // src/integrations/mcp/store.ts
 init_config();
 import { nanoid as nanoid6 } from "nanoid";
-import { existsSync as existsSync16, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve10, join as join9 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve10, join as join10 } from "path";
 function readServers() {
   try {
     const cfg = getConfig();
@@ -7774,12 +7960,12 @@ function readServers() {
 function refreshMcpServersFromDisk() {
   const candidates = [
     resolve10(process.cwd(), "sparkecoder.config.json"),
-    join9(ensureAppDataDirectory(), "sparkecoder.config.json")
+    join10(ensureAppDataDirectory(), "sparkecoder.config.json")
   ];
   for (const path of candidates) {
-    if (!existsSync16(path)) continue;
+    if (!existsSync17(path)) continue;
     try {
-      const raw = JSON.parse(readFileSync7(path, "utf-8"));
+      const raw = JSON.parse(readFileSync8(path, "utf-8"));
       const servers2 = Array.isArray(raw?.mcp?.servers) ? raw.mcp.servers : [];
       setMcpServers(servers2);
       return servers2;
@@ -8191,7 +8377,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({
@@ -8217,7 +8403,8 @@ ${personality.trim()}`;
     }
     const messages = await this.context.getMessages();
     const tools = options.onToolProgress ? await this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
-    const wrappedTools = this.wrapToolsWithApproval(options, tools);
+    const approvalWrapped = this.wrapToolsWithApproval(options, tools);
+    const wrappedTools = wrapToolsNeverThrow(approvalWrapped);
     const useAnthropic = isAnthropicModel(this.session.model);
     const stream = streamText2({
       model: resolveModel(this.session.model),
@@ -8231,6 +8418,18 @@ ${personality.trim()}`;
       providerOptions: useAnthropic ? {
         anthropic: getAnthropicProviderOptions(this.session.model, { toolStreaming: true })
       } : void 0,
+      // Run repairToolPairing before EVERY step's model call, not just the
+      // first one. The AI SDK's multi-step loop can otherwise feed the model
+      // a prompt containing an orphan tool-call (e.g. when a previous step's
+      // tool result was lost, dropped during compaction, or the stream was
+      // aborted mid-tool). Repairing in `prepareStep` guarantees no orphan
+      // ever reaches the model and we never hit AI_MissingToolResultsError.
+      prepareStep: async ({ messages: stepMessages }) => {
+        const paired = repairToolPairing(stepMessages);
+        const ordered = ensureToolResultsFollowCalls(paired);
+        if (ordered === stepMessages) return {};
+        return { messages: ordered };
+      },
       onStepFinish: async (step) => {
         options.onStepFinish?.(step);
       },
@@ -8242,7 +8441,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,
@@ -8256,7 +8455,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,
@@ -8266,7 +8465,7 @@ ${personality.trim()}`;
     });
     const messages = await this.context.getMessages();
     const tools = options.onToolProgress ? await this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
-    const wrappedTools = this.wrapToolsWithApproval(options, tools);
+    const wrappedTools = wrapToolsNeverThrow(this.wrapToolsWithApproval(options, tools));
     const useAnthropic = isAnthropicModel(this.session.model);
     const result = await generateText3({
       model: resolveModel(this.session.model),
@@ -8277,10 +8476,17 @@ ${personality.trim()}`;
       // Enable extended thinking/reasoning for models that support it
       providerOptions: useAnthropic ? {
         anthropic: getAnthropicProviderOptions(this.session.model)
-      } : void 0
+      } : void 0,
+      // Repair tool pairing before every step (see `stream()` for full rationale).
+      prepareStep: async ({ messages: stepMessages }) => {
+        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
@@ -8454,12 +8660,20 @@ ${p.text}` : p.text;
         model: resolveModel(this.session.model),
         system: systemPrompt,
         messages,
-        tools: taskTools,
+        tools: wrapToolsNeverThrow(taskTools),
         stopWhen: stepCountIs2(500),
         abortSignal: combinedAbort,
         providerOptions: useAnthropic ? {
           anthropic: getAnthropicProviderOptions(this.session.model, { toolStreaming: true })
         } : void 0,
+        // 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 paired = repairToolPairing(stepMessages);
+          const ordered = ensureToolResultsFollowCalls(paired);
+          if (ordered === stepMessages) return {};
+          return { messages: ordered };
+        },
         onStepFinish: async (step) => {
           options.onStepFinish?.(step);
           fireWebhook("task.step_finished", { iteration, text: step.text });
@@ -8693,11 +8907,11 @@ ${p.text}` : p.text;
       const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
       if (!isRemoteConfigured2()) return [];
       const { readFile: readFile12 } = await import("fs/promises");
-      const { join: join11, basename: basename5 } = await import("path");
+      const { join: join12, basename: basename5 } = await import("path");
       const urls = [];
       for (const filePath of filePaths) {
         try {
-          const fullPath = filePath.startsWith("/") ? filePath : join11(this.session.workingDirectory, filePath);
+          const fullPath = filePath.startsWith("/") ? filePath : join12(this.session.workingDirectory, filePath);
           const fileName = basename5(fullPath);
           const ext = fileName.split(".").pop()?.toLowerCase() || "";
           const mimeMap = {