sparkecoder 0.1.142 → 0.1.143

package/dist/agent/index.d.ts

@@ -1,6 +1,6 @@
 import 'ai';
-import '../schema-BSz4MzhJ.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-Cl_eUatM.js';
-import '../search-DOzC4ojH.js';
+import '../schema-Dz-wABVY.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-BAsQWqZj.js';
+import '../search-CVVfuBPZ.js';
 import 'drizzle-orm/sqlite-core';
 import 'zod';

package/dist/agent/index.js

@@ -2478,8 +2478,31 @@ function formatBytes(n) {
   if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
   return `${(n / 1024 / 1024).toFixed(2)} MB`;
 }
-function sleep(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+function abortError() {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortError();
+}
+function isAbortLike(err) {
+  return err?.name === "AbortError" || String(err?.message || err).toLowerCase().includes("aborted");
+}
+function sleep(ms, signal) {
+  throwIfAborted(signal);
+  return new Promise((resolve11, reject) => {
+    const t = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve11();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      signal?.removeEventListener("abort", onAbort);
+      reject(abortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
 }
 function imageMagic(bytes) {
   if (bytes.length < 12) return null;
@@ -2499,19 +2522,21 @@ function validateDownloadedBytes(bytes, declaredContentType) {
   if (!actual) return "invalid_image_bytes";
   return null;
 }
-async function fetchSlackPrivateFile(sourceUrl, botToken) {
+async function fetchSlackPrivateFile(sourceUrl, botToken, signal) {
   let lastError = "unknown";
   for (let attempt = 0; attempt < 3; attempt++) {
     try {
+      throwIfAborted(signal);
       const res = await fetch(sourceUrl, {
-        headers: { Authorization: `Bearer ${botToken}` }
+        headers: { Authorization: `Bearer ${botToken}` },
+        signal
       });
       if (res.status === 429 || res.status >= 500) {
         lastError = `slack_fetch_${res.status}`;
         const retryAfter = Number(res.headers.get("retry-after"));
         const waitMs = Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter * 1e3, 2e3) : 250 * (attempt + 1);
         if (attempt < 2) {
-          await sleep(waitMs);
+          await sleep(waitMs, signal);
           continue;
         }
       }
@@ -2522,25 +2547,58 @@ async function fetchSlackPrivateFile(sourceUrl, botToken) {
       if (Number.isFinite(contentLength) && contentLength > MAX_BYTES) {
         return { ok: false, error: "size_exceeded" };
       }
-      const ab = await res.arrayBuffer();
-      if (ab.byteLength > MAX_BYTES) {
-        return { ok: false, error: "size_exceeded" };
-      }
-      return { ok: true, bytes: Buffer.from(ab) };
+      return await readResponseBodyWithCap(res, signal);
     } catch (err) {
+      if (isAbortLike(err) || signal?.aborted) {
+        return { ok: false, error: "aborted" };
+      }
       lastError = `slack_fetch_error:${err?.message || "unknown"}`;
       if (attempt < 2) {
-        await sleep(250 * (attempt + 1));
+        await sleep(250 * (attempt + 1), signal);
         continue;
       }
     }
   }
   return { ok: false, error: lastError };
 }
-function withTimeout(p, ms, label) {
+async function readResponseBodyWithCap(res, signal) {
+  const body = res.body;
+  if (!body) {
+    const ab = await res.arrayBuffer();
+    if (ab.byteLength > MAX_BYTES) return { ok: false, error: "size_exceeded" };
+    return { ok: true, bytes: Buffer.from(ab) };
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      throwIfAborted(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > MAX_BYTES) {
+        await reader.cancel().catch(() => void 0);
+        return { ok: false, error: "size_exceeded" };
+      }
+      chunks.push(Buffer.from(value));
+    }
+  } catch (err) {
+    await reader.cancel().catch(() => void 0);
+    if (isAbortLike(err) || signal?.aborted) return { ok: false, error: "aborted" };
+    throw err;
+  }
+  return { ok: true, bytes: Buffer.concat(chunks, total) };
+}
+function withAbortTimeout(run, ms, label) {
   return new Promise((resolve11, reject) => {
-    const t = setTimeout(() => reject(new Error(`${label}_timeout`)), ms);
-    p.then(
+    const controller = new AbortController();
+    const t = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`${label}_timeout`));
+    }, ms);
+    run(controller.signal).then(
       (v) => {
         clearTimeout(t);
         resolve11(v);
@@ -2552,7 +2610,8 @@ function withTimeout(p, ms, label) {
     );
   });
 }
-async function ingestOne(file, sessionId, botToken) {
+async function ingestOne(file, sessionId, botToken, signal) {
+  throwIfAborted(signal);
   const fileName = inferFileName(file);
   const contentType = inferContentType(file);
   const declaredSize = typeof file.size === "number" ? file.size : 0;
@@ -2570,7 +2629,8 @@ async function ingestOne(file, sessionId, botToken) {
     return { ...base, shortUrl: null, error: "size_exceeded" };
   }
   let bytes;
-  const fetched = await fetchSlackPrivateFile(sourceUrl, botToken);
+  const fetched = await fetchSlackPrivateFile(sourceUrl, botToken, signal);
+  throwIfAborted(signal);
   if (!fetched.ok) {
     return { ...base, shortUrl: null, error: fetched.error };
   }
@@ -2583,18 +2643,27 @@ async function ingestOne(file, sessionId, botToken) {
     return { ...base, sizeBytes: bytes.length, shortUrl: null, error: byteError };
   }
   const { storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
-  let upload;
+  let upload = null;
   try {
+    throwIfAborted(signal);
     upload = await storageQueries2.getUploadUrl(sessionId, fileName, contentType, "slack");
+    throwIfAborted(signal);
   } catch (err) {
+    if (isAbortLike(err) || signal.aborted) {
+      if (upload?.fileId) await cleanupAbortedUpload(storageQueries2, upload.fileId);
+      throw err;
+    }
     return { ...base, sizeBytes: bytes.length, shortUrl: null, error: `presign_failed:${err?.message || "unknown"}` };
   }
   try {
+    throwIfAborted(signal);
     const putRes = await fetch(upload.uploadUrl, {
       method: "PUT",
       headers: { "Content-Type": contentType },
-      body: bytes
+      body: bytes,
+      signal
     });
+    throwIfAborted(signal);
     if (!putRes.ok) {
       return {
         ...base,
@@ -2604,6 +2673,10 @@ async function ingestOne(file, sessionId, botToken) {
       };
     }
   } catch (err) {
+    if (isAbortLike(err) || signal.aborted) {
+      await cleanupAbortedUpload(storageQueries2, upload.fileId);
+      throw err;
+    }
     return {
       ...base,
       sizeBytes: bytes.length,
@@ -2612,8 +2685,13 @@ async function ingestOne(file, sessionId, botToken) {
     };
   }
   try {
+    throwIfAborted(signal);
     await storageQueries2.updateFile(upload.fileId, { sizeBytes: bytes.length });
   } catch (err) {
+    if (isAbortLike(err) || signal.aborted) {
+      await cleanupAbortedUpload(storageQueries2, upload.fileId);
+      throw err;
+    }
     console.warn(`[slack-files] sizeBytes patch failed for ${upload.fileId}:`, err?.message || err);
   }
   const shortUrl = upload.shortUrl || // Defensive fallback: build it from the upload URL's origin if the
@@ -2625,6 +2703,14 @@ async function ingestOne(file, sessionId, botToken) {
     shortUrl
   };
 }
+async function cleanupAbortedUpload(storageQueries2, fileId) {
+  if (typeof storageQueries2?.deleteFile !== "function") return;
+  try {
+    await storageQueries2.deleteFile(fileId);
+  } catch (err) {
+    console.warn(`[slack-files] cleanup after aborted upload failed for ${fileId}:`, err?.message || err);
+  }
+}
 function inferShortUrlFromUploadUrl(uploadUrl, fileId) {
   try {
     const u = new URL(uploadUrl);
@@ -2664,7 +2750,7 @@ async function ingestSlackFiles(files, sessionId, options = {}) {
   const startedAt = Date.now();
   const pipeline = Promise.allSettled(
     files.map(
-      (f) => withTimeout(ingestOne(f, sessionId, botToken), timeoutMs, `ingest:${f.id}`).catch((err) => {
+      (f) => withAbortTimeout((signal) => ingestOne(f, sessionId, botToken, signal), timeoutMs, `ingest:${f.id}`).catch((err) => {
         if (String(err?.message || err).includes("_timeout")) {
           return {
             slackFileId: f.id,