sparkecoder 0.1.67 → 0.1.68

package/dist/{index-DHyVVhJY.d.ts → index-Dm6wGcYv.d.ts}

@@ -480,6 +480,7 @@ declare class Agent {
         prompt: string;
         taskConfig: TaskConfig;
         abortSignal?: AbortSignal;
+        writeSSE?: (data: string) => Promise<void>;
         onText?: (text: string) => void;
         onToolCall?: (toolCall: {
             toolCallId: string;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { R as ResolvedConfig } from './index-DHyVVhJY.js';
-export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, S as SparkcoderConfig, T as ToolApprovalConfig } from './index-DHyVVhJY.js';
+import { R as ResolvedConfig } from './index-Dm6wGcYv.js';
+export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, S as SparkcoderConfig, T as ToolApprovalConfig } from './index-Dm6wGcYv.js';
 export { ServerOptions, createApp, startServer, stopServer } from './server/index.js';
 export { checkpointQueries, closeDatabase, fileBackupQueries, getDb, initDatabase, messageQueries, sessionQueries, skillQueries, todoQueries, toolExecutionQueries } from './db/index.js';
 import { F as FileBackup, C as Checkpoint } from './schema-XcP0dedO.js';

package/dist/index.js

@@ -6473,6 +6473,21 @@ ${this.summary}`
 
 // src/agent/index.ts
 init_webhook();
+var MAX_SSE_FIELD_LENGTH = 8 * 1024;
+var SSE_PREVIEW_LENGTH = 2 * 1024;
+function truncateWriteFileInput(input) {
+  const out = { ...input };
+  for (const key of ["content", "old_string", "new_string"]) {
+    const val = out[key];
+    if (typeof val === "string" && val.length > MAX_SSE_FIELD_LENGTH) {
+      out[key] = `${val.slice(0, SSE_PREVIEW_LENGTH)}
+... (truncated)`;
+      out[`${key}Truncated`] = true;
+      out[`${key}Length`] = val.length;
+    }
+  }
+  return out;
+}
 var approvalResolvers = /* @__PURE__ */ new Map();
 var Agent = class _Agent {
   session;
@@ -6716,8 +6731,11 @@ ${prompt}` });
     };
     let taskRecorder = null;
     const sessionId = this.session.id;
+    const emit = options.writeSSE;
     const bashProgressHandler = (progress) => {
       options.onToolProgress?.({ toolName: "bash", data: progress });
+      if (emit) emit(JSON.stringify({ type: "tool-progress", toolName: "bash", data: progress })).catch(() => {
+      });
       const port = progress.browserStreamPort;
       if (port && progress.status === "started") {
         Promise.resolve().then(() => (init_stream_proxy(), stream_proxy_exports)).then(({ getOrCreateProxy: getOrCreateProxy2 }) => {
@@ -6726,7 +6744,17 @@ ${prompt}` });
             Promise.resolve().then(() => (init_recorder(), recorder_exports)).then(({ FrameRecorder: FrameRecorder2 }) => {
               taskRecorder = new FrameRecorder2(sessionId);
               taskRecorder.start();
-              proxy.on("frame", (frame) => taskRecorder?.addFrame(frame));
+            });
+          }
+          if (proxy.listenerCount("frame") === 0) {
+            proxy.on("frame", (frame) => {
+              taskRecorder?.addFrame(frame);
+              if (emit) emit(JSON.stringify({ type: "browser-frame", data: frame.data, metadata: frame.metadata })).catch(() => {
+              });
+            });
+            proxy.on("status", (s) => {
+              if (emit) emit(JSON.stringify({ type: "browser-status", ...s })).catch(() => {
+              });
             });
           }
         });
@@ -6737,8 +6765,16 @@ ${prompt}` });
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
       onBashProgress: bashProgressHandler,
-      onWriteFileProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "write_file", data: progress }) : void 0,
-      onSearchProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "explore_agent", data: progress }) : void 0,
+      onWriteFileProgress: (progress) => {
+        options.onToolProgress?.({ toolName: "write_file", data: progress });
+        if (emit) emit(JSON.stringify({ type: "tool-progress", toolName: "write_file", data: progress })).catch(() => {
+        });
+      },
+      onSearchProgress: (progress) => {
+        options.onToolProgress?.({ toolName: "explore_agent", data: progress });
+        if (emit) emit(JSON.stringify({ type: "tool-progress", toolName: "explore_agent", data: progress })).catch(() => {
+        });
+      },
       taskTools: {
         outputSchema: options.taskConfig.outputSchema,
         onComplete
@@ -6756,6 +6792,9 @@ ${prompt}` });
 
 ${taskAddendum}`;
     fireWebhook("task.started", { prompt: options.prompt });
+    if (emit) {
+      await emit(JSON.stringify({ type: "data-user-message", data: { id: `user_${Date.now()}`, content: options.prompt } }));
+    }
     await this.context.addUserMessage(options.prompt);
     let iteration = 0;
     while (iteration < maxIterations) {
@@ -6767,7 +6806,15 @@ ${taskAddendum}`;
       }
       const messages = await this.context.getMessages();
       const useAnthropic = isAnthropicModel(this.session.model);
-      const result = await generateText3({
+      if (emit) {
+        await emit(JSON.stringify({ type: "start", messageId: `msg_${Date.now()}` }));
+      }
+      let textStarted = false;
+      let textId = `text_${Date.now()}`;
+      let reasoningId = `reasoning_${Date.now()}`;
+      let reasoningStarted = false;
+      const toolCallStarts = /* @__PURE__ */ new Set();
+      const iterStream = streamText2({
         model: resolveModel(this.session.model),
         system: systemPrompt,
         messages,
@@ -6776,21 +6823,94 @@ ${taskAddendum}`;
         abortSignal: options.abortSignal,
         providerOptions: useAnthropic ? {
           anthropic: {
+            toolStreaming: true,
             thinking: { type: "enabled", budgetTokens: 1e4 }
           }
         } : void 0,
-        onStepFinish: (step) => {
+        onStepFinish: async (step) => {
           options.onStepFinish?.(step);
           fireWebhook("task.step_finished", { iteration, text: step.text });
+          if (emit) {
+            if (textStarted) {
+              await emit(JSON.stringify({ type: "text-end", id: textId }));
+              textStarted = false;
+              textId = `text_${Date.now()}`;
+            }
+            await emit(JSON.stringify({ type: "finish-step" }));
+          }
         }
       });
-      const responseMessages = result.response.messages;
+      for await (const part of iterStream.fullStream) {
+        if (part.type === "text-delta") {
+          if (emit) {
+            if (!textStarted) {
+              await emit(JSON.stringify({ type: "text-start", id: textId }));
+              textStarted = true;
+            }
+            await emit(JSON.stringify({ type: "text-delta", id: textId, delta: part.text }));
+          }
+        } else if (part.type === "reasoning-start") {
+          if (emit) {
+            await emit(JSON.stringify({ type: "reasoning-start", id: reasoningId }));
+            reasoningStarted = true;
+          }
+        } else if (part.type === "reasoning-delta") {
+          if (emit) {
+            await emit(JSON.stringify({ type: "reasoning-delta", id: reasoningId, delta: part.text }));
+          }
+        } else if (part.type === "reasoning-end") {
+          if (emit && reasoningStarted) {
+            await emit(JSON.stringify({ type: "reasoning-end", id: reasoningId }));
+            reasoningStarted = false;
+            reasoningId = `reasoning_${Date.now()}`;
+          }
+        } else if (part.type === "tool-call-streaming-start") {
+          if (emit) {
+            const p = part;
+            await emit(JSON.stringify({ type: "tool-input-start", toolCallId: p.toolCallId, toolName: p.toolName }));
+            toolCallStarts.add(p.toolCallId);
+          }
+        } else if (part.type === "tool-call-delta") {
+          if (emit) {
+            const p = part;
+            await emit(JSON.stringify({ type: "tool-input-delta", toolCallId: p.toolCallId, argsTextDelta: p.argsTextDelta }));
+          }
+        } else if (part.type === "tool-call") {
+          if (emit) {
+            if (!toolCallStarts.has(part.toolCallId)) {
+              await emit(JSON.stringify({ type: "tool-input-start", toolCallId: part.toolCallId, toolName: part.toolName }));
+              toolCallStarts.add(part.toolCallId);
+            }
+            const safeInput = part.toolName === "write_file" && part.input && typeof part.input === "object" ? truncateWriteFileInput(part.input) : part.input;
+            await emit(JSON.stringify({ type: "tool-input-available", toolCallId: part.toolCallId, toolName: part.toolName, input: safeInput }));
+          }
+        } else if (part.type === "tool-result") {
+          if (emit) {
+            await emit(JSON.stringify({ type: "tool-output-available", toolCallId: part.toolCallId, output: part.output }));
+          }
+        } else if (part.type === "error") {
+          console.error("Task stream error:", part.error);
+          if (emit) {
+            await emit(JSON.stringify({ type: "error", errorText: String(part.error) }));
+          }
+        }
+      }
+      if (emit && textStarted) {
+        await emit(JSON.stringify({ type: "text-end", id: textId }));
+      }
+      if (emit && reasoningStarted) {
+        await emit(JSON.stringify({ type: "reasoning-end", id: reasoningId }));
+      }
+      const iterResponse = await iterStream.response;
+      const responseMessages = iterResponse.messages;
       await this.context.addResponseMessages(responseMessages);
-      if (result.text) {
-        options.onText?.(result.text);
-        fireWebhook("task.message", { iteration, text: result.text });
+      const resultText = await iterStream.text;
+      const resultSteps = await iterStream.steps;
+      if (resultText) {
+        options.onText?.(resultText);
+        fireWebhook("task.message", { iteration, text: resultText });
       }
-      for (const step of result.steps) {
+      for (const step of resultSteps) {
         if (step.toolCalls) {
           for (const tc of step.toolCalls) {
             options.onToolCall?.({ toolCallId: tc.toolCallId, toolName: tc.toolName, input: tc.args });
@@ -6843,9 +6963,11 @@ ${taskAddendum}`;
           iterations: iteration
         };
       }
-      await this.context.addUserMessage(
-        "Continue working on the task. Before calling `complete_task`, VERIFY your work is correct \u2014 re-read edited files, run the linter, run tests if applicable, and check the browser/server if you made UI or API changes. Make sure you searched the right directories and found everything relevant. When fully verified, call `complete_task` with the result. If you cannot complete it, call `task_failed` with a reason."
-      );
+      const continuationPrompt = "Continue working on the task. Before calling `complete_task`, VERIFY your work is correct \u2014 re-read edited files, run the linter, run tests if applicable, and check the browser/server if you made UI or API changes. Make sure you searched the right directories and found everything relevant. When fully verified, call `complete_task` with the result. If you cannot complete it, call `task_failed` with a reason.";
+      if (emit) {
+        await emit(JSON.stringify({ type: "data-user-message", data: { id: `user_${Date.now()}`, content: continuationPrompt } }));
+      }
+      await this.context.addUserMessage(continuationPrompt);
     }
     const timeoutError = `Task did not complete within ${maxIterations} iterations`;
     const timeoutRecordingUrls = await this.finishTaskRecording(taskRecorder);
@@ -9497,6 +9619,7 @@ init_db();
 import { Hono as Hono5 } from "hono";
 import { zValidator as zValidator5 } from "@hono/zod-validator";
 import { z as z19 } from "zod";
+import { nanoid as nanoid7 } from "nanoid";
 init_config();
 var tasks = new Hono5();
 var taskAbortControllers = /* @__PURE__ */ new Map();
@@ -9534,45 +9657,74 @@ tasks.post(
     const taskId = agent.sessionId;
     const abortController = new AbortController();
     taskAbortControllers.set(taskId, abortController);
-    (async () => {
-      try {
-        await agent.runTask({
-          prompt: body.prompt,
-          taskConfig,
-          abortSignal: abortController.signal
-        });
-      } catch (err) {
-        if (err.name === "AbortError" || abortController.signal.aborted) {
-          console.log(`[TASK] Task ${taskId} was cancelled`);
-        } else {
-          console.error(`[TASK] Error in task ${taskId}:`, err.message);
-          const errorMsg = err.message || "Unknown error";
-          const failedTask = {
-            ...taskConfig,
-            status: "failed",
-            error: errorMsg
-          };
-          await sessionQueries.update(taskId, {
-            config: {
-              toolApprovals: { bash: false, write_file: false, read_file: false },
-              task: failedTask
-            }
+    const streamId = `stream_${taskId}_${nanoid7(10)}`;
+    await activeStreamQueries.create(taskId, streamId);
+    const taskStreamProducer = () => {
+      const { readable, writable } = new TransformStream();
+      const writer = writable.getWriter();
+      let writerClosed = false;
+      const writeSSE = async (data) => {
+        if (writerClosed) return;
+        try {
+          await writer.write(`data: ${data}
+
+`);
+        } catch {
+          writerClosed = true;
+        }
+      };
+      (async () => {
+        await writeSSE(JSON.stringify({ type: "data-stream-id", streamId }));
+        try {
+          await agent.runTask({
+            prompt: body.prompt,
+            taskConfig,
+            abortSignal: abortController.signal,
+            writeSSE
           });
-          if (taskConfig.webhookUrl) {
-            const { sendWebhook: sendWebhook2 } = await Promise.resolve().then(() => (init_webhook(), webhook_exports));
-            sendWebhook2(taskConfig.webhookUrl, {
-              type: "task.failed",
-              taskId,
-              sessionId: taskId,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              data: { status: "failed", error: errorMsg }
+          await writeSSE(JSON.stringify({ type: "finish" }));
+        } catch (err) {
+          if (err.name === "AbortError" || abortController.signal.aborted) {
+            console.log(`[TASK] Task ${taskId} was cancelled`);
+            await writeSSE(JSON.stringify({ type: "abort" }));
+          } else {
+            console.error(`[TASK] Error in task ${taskId}:`, err.message);
+            const errorMsg = err.message || "Unknown error";
+            await writeSSE(JSON.stringify({ type: "error", errorText: errorMsg }));
+            const failedTask = {
+              ...taskConfig,
+              status: "failed",
+              error: errorMsg
+            };
+            await sessionQueries.update(taskId, {
+              config: {
+                toolApprovals: { bash: false, write_file: false, read_file: false },
+                task: failedTask
+              }
             });
+            if (taskConfig.webhookUrl) {
+              const { sendWebhook: sendWebhook2 } = await Promise.resolve().then(() => (init_webhook(), webhook_exports));
+              sendWebhook2(taskConfig.webhookUrl, {
+                type: "task.failed",
+                taskId,
+                sessionId: taskId,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                data: { status: "failed", error: errorMsg }
+              });
+            }
           }
+        } finally {
+          await writeSSE("[DONE]");
+          writer.close().catch(() => {
+          });
+          await activeStreamQueries.finish(streamId).catch(() => {
+          });
+          taskAbortControllers.delete(taskId);
         }
-      } finally {
-        taskAbortControllers.delete(taskId);
-      }
-    })();
+      })();
+      return readable;
+    };
+    await streamContext.resumableStream(streamId, taskStreamProducer);
     return c.json({ taskId, status: "running" }, 201);
   }
 );