sparkecoder 0.1.67 → 0.1.69

package/dist/cli.js

@@ -2556,10 +2556,15 @@ import WebSocket from "ws";
 import { EventEmitter } from "events";
 function getOrCreateProxy(sessionId, port) {
   const existing = activeProxies.get(sessionId);
-  if (existing) return existing;
+  if (existing) {
+    console.log(`[BROWSER-WS] Reusing existing proxy for session ${sessionId} (connected=${existing.connected})`);
+    return existing;
+  }
+  console.log(`[BROWSER-WS] Creating new proxy for session ${sessionId} on port ${port} (active proxies: ${activeProxies.size})`);
   const proxy = new BrowserStreamProxy(port);
   activeProxies.set(sessionId, proxy);
   proxy.on("close", () => {
+    console.log(`[BROWSER-WS] Proxy closed for session ${sessionId}, removing from registry`);
     activeProxies.delete(sessionId);
   });
   proxy.connect();
@@ -2571,8 +2576,11 @@ function getProxy(sessionId) {
 function destroyProxy(sessionId) {
   const proxy = activeProxies.get(sessionId);
   if (proxy) {
+    console.log(`[BROWSER-WS] destroyProxy() called for session ${sessionId}`);
     proxy.destroy();
     activeProxies.delete(sessionId);
+  } else {
+    console.log(`[BROWSER-WS] destroyProxy() called but no proxy exists for session ${sessionId}`);
   }
 }
 var RECONNECT_DELAY_MS, MAX_RECONNECT_ATTEMPTS, FRAME_THROTTLE_MS, BrowserStreamProxy, activeProxies;
@@ -2603,18 +2611,22 @@ var init_stream_proxy = __esm({
       }
       connect() {
         if (this.destroyed) return;
+        console.log(`[BROWSER-WS] connect() called for port ${this.port}`);
         this.doConnect();
       }
       doConnect() {
         if (this.destroyed) return;
         const url = `ws://localhost:${this.port}`;
+        console.log(`[BROWSER-WS] Attempting WebSocket connection to ${url} (attempt ${this.reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS})`);
         try {
           this.ws = new WebSocket(url);
-        } catch {
+        } catch (err) {
+          console.warn(`[BROWSER-WS] WebSocket constructor threw for ${url}:`, err);
           this.scheduleReconnect();
           return;
         }
         this.ws.on("open", () => {
+          console.log(`[BROWSER-WS] Connected to ${url} (after ${this.reconnectAttempts} retries)`);
           this.reconnectAttempts = 0;
           this._connected = true;
           this.emit("status", {
@@ -2626,12 +2638,14 @@ var init_stream_proxy = __esm({
           try {
             const msg = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
             this.handleMessage(msg);
-          } catch {
+          } catch (err) {
+            console.warn(`[BROWSER-WS] Malformed message from ${url}:`, err);
           }
         });
-        this.ws.on("close", () => {
+        this.ws.on("close", (code, reason) => {
           const wasConnected = this._connected;
           this._connected = false;
+          console.log(`[BROWSER-WS] Connection closed: code=${code} reason="${reason?.toString() || ""}" wasConnected=${wasConnected} destroyed=${this.destroyed}`);
           if (wasConnected) {
             this.emit("status", { connected: false, screencasting: false });
           }
@@ -2639,14 +2653,26 @@ var init_stream_proxy = __esm({
             this.scheduleReconnect();
           }
         });
-        this.ws.on("error", () => {
+        this.ws.on("error", (err) => {
+          console.warn(`[BROWSER-WS] WebSocket error on port ${this.port}:`, err.message);
         });
       }
+      frameCount = 0;
+      throttledCount = 0;
+      lastFrameLogTime = 0;
       handleMessage(msg) {
         if (msg.type === "frame") {
           const now = Date.now();
-          if (now - this.lastFrameTime < FRAME_THROTTLE_MS) return;
+          if (now - this.lastFrameTime < FRAME_THROTTLE_MS) {
+            this.throttledCount++;
+            return;
+          }
           this.lastFrameTime = now;
+          this.frameCount++;
+          if (now - this.lastFrameLogTime > 5e3) {
+            console.log(`[BROWSER-WS] Frame stats: emitted=${this.frameCount} throttled=${this.throttledCount} listeners=${this.listenerCount("frame")} dataSize=${msg.data?.length ?? 0}`);
+            this.lastFrameLogTime = now;
+          }
           const frame = {
             data: msg.data,
             metadata: msg.metadata ?? {
@@ -2662,21 +2688,26 @@ var init_stream_proxy = __esm({
           this._latestFrame = frame;
           this.emit("frame", frame);
         } else if (msg.type === "status") {
+          console.log(`[BROWSER-WS] Status message received:`, JSON.stringify(msg));
           this.emit("status", {
             connected: msg.connected ?? true,
             screencasting: msg.screencasting ?? true,
             viewportWidth: msg.viewportWidth,
             viewportHeight: msg.viewportHeight
           });
+        } else {
+          console.log(`[BROWSER-WS] Unknown message type: ${msg.type}`);
         }
       }
       scheduleReconnect() {
         if (this.destroyed || this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+          console.log(`[BROWSER-WS] Giving up reconnection: destroyed=${this.destroyed} attempts=${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}`);
           this.emit("close");
           return;
         }
         this.reconnectAttempts++;
         const delay = this.reconnectAttempts <= 5 ? RECONNECT_DELAY_MS : RECONNECT_DELAY_MS * (this.reconnectAttempts - 4);
+        console.log(`[BROWSER-WS] Scheduling reconnect in ${delay}ms (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
         this.reconnectTimer = setTimeout(() => this.doConnect(), delay);
       }
       /**
@@ -2688,6 +2719,7 @@ var init_stream_proxy = __esm({
         }
       }
       destroy() {
+        console.log(`[BROWSER-WS] Destroying proxy for port ${this.port} (emitted ${this.frameCount} frames, throttled ${this.throttledCount})`);
         this.destroyed = true;
         if (this.reconnectTimer) {
           clearTimeout(this.reconnectTimer);
@@ -7256,6 +7288,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;
@@ -7499,8 +7546,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 }) => {
@@ -7509,7 +7559,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(() => {
+              });
             });
           }
         });
@@ -7520,8 +7580,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
@@ -7539,6 +7607,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) {
@@ -7550,7 +7621,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,
@@ -7559,21 +7638,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 });
@@ -7626,9 +7778,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);
@@ -8719,11 +8873,19 @@ var cleanupInterval = setInterval(() => {
   }
 }, 6e4);
 cleanupInterval.unref();
+var publishCount = 0;
+var lastPublishLog = 0;
 var publisher = {
   connect: async () => {
   },
   publish: async (channel, message) => {
     const subscribers = channels.get(channel);
+    publishCount++;
+    const now = Date.now();
+    if (now - lastPublishLog > 1e4) {
+      console.log(`[ResumableStream] Publish stats: total=${publishCount}, channels=${channels.size}, store=${store.size}`);
+      lastPublishLog = now;
+    }
     if (subscribers) {
       for (const callback of subscribers) {
         setImmediate(() => callback(message));
@@ -8762,9 +8924,12 @@ var subscriber = {
       channels.set(channel, /* @__PURE__ */ new Set());
     }
     channels.get(channel).add(callback);
+    console.log(`[ResumableStream] Subscribe to channel "${channel}" (total subscribers: ${channels.get(channel).size})`);
   },
   unsubscribe: async (channel) => {
+    const count = channels.get(channel)?.size ?? 0;
     channels.delete(channel);
+    console.log(`[ResumableStream] Unsubscribe from channel "${channel}" (removed ${count} subscribers)`);
   }
 };
 var streamContext = createResumableStreamContext({
@@ -8950,19 +9115,28 @@ function createAgentStreamProducer(sessionId, prompt, streamId, attachments) {
     const toolCallStarts = /* @__PURE__ */ new Set();
     const abortController = new AbortController();
     streamAbortControllers.set(streamId, abortController);
+    let sseEventCount = 0;
+    let sseBrowserFrameCount = 0;
+    let sseWriteErrors = 0;
     const writeSSE = async (data) => {
       if (writerClosed) return;
       try {
+        sseEventCount++;
         await writer.write(`data: ${data}
 
 `);
       } catch (err) {
+        sseWriteErrors++;
+        if (sseWriteErrors === 1) {
+          console.log(`[SSE:${streamId}] Writer closed (client disconnected). Total events sent: ${sseEventCount}, browser frames: ${sseBrowserFrameCount}`);
+        }
         writerClosed = true;
       }
     };
     const safeClose = async () => {
       if (writerClosed) return;
       try {
+        console.log(`[SSE:${streamId}] Stream closing. Total events: ${sseEventCount}, browser frames: ${sseBrowserFrameCount}, write errors: ${sseWriteErrors}`);
         writerClosed = true;
         await writer.close();
       } catch {
@@ -9085,35 +9259,47 @@ ${prompt}` });
             const browserPort = progress.data?.browserStreamPort;
             const browserClosed = progress.data?.browserClosed;
             if (progress.toolName === "bash" && browserClosed) {
-              console.log(`[BROWSER-STREAM] agent-browser close detected, destroying proxy`);
+              console.log(`[BROWSER-STREAM:${streamId}] agent-browser close detected, destroying proxy for session ${sessionId}`);
               destroyProxy(sessionId);
             } else if (progress.toolName === "bash" && browserPort) {
-              console.log(`[BROWSER-STREAM] agent-browser command detected, ensuring proxy on port ${browserPort}`);
+              console.log(`[BROWSER-STREAM:${streamId}] agent-browser command detected, ensuring proxy on port ${browserPort} for session ${sessionId}`);
               const proxy = getOrCreateProxy(sessionId, browserPort);
+              console.log(`[BROWSER-STREAM:${streamId}] Proxy state: connected=${proxy.connected}, frameListeners=${proxy.listenerCount("frame")}, statusListeners=${proxy.listenerCount("status")}`);
               if (!sessionRecorders.has(sessionId)) {
                 const recorder = new FrameRecorder(sessionId);
                 recorder.start();
                 sessionRecorders.set(sessionId, recorder);
               }
               if (proxy.listenerCount("frame") === 0) {
+                console.log(`[BROWSER-STREAM:${streamId}] Attaching frame+status listeners to proxy`);
                 proxy.on("frame", (frame) => {
+                  sseBrowserFrameCount++;
+                  if (sseBrowserFrameCount === 1) {
+                    console.log(`[BROWSER-STREAM:${streamId}] First browser frame received! dataSize=${frame.data?.length ?? 0} writerClosed=${writerClosed}`);
+                  } else if (sseBrowserFrameCount % 50 === 0) {
+                    console.log(`[BROWSER-STREAM:${streamId}] Browser frame #${sseBrowserFrameCount} (writerClosed=${writerClosed})`);
+                  }
                   const rec = sessionRecorders.get(sessionId);
                   rec?.addFrame(frame);
                   writeSSE(JSON.stringify({
                     type: "browser-frame",
                     data: frame.data,
                     metadata: frame.metadata
-                  })).catch(() => {
+                  })).catch((err) => {
+                    console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-frame via SSE:`, err);
                   });
                 });
                 proxy.on("status", (s) => {
-                  console.log(`[BROWSER-STREAM] Status:`, s);
+                  console.log(`[BROWSER-STREAM:${streamId}] Browser status event: connected=${s.connected} screencasting=${s.screencasting} viewport=${s.viewportWidth}x${s.viewportHeight}`);
                   writeSSE(JSON.stringify({
                     type: "browser-status",
                     ...s
-                  })).catch(() => {
+                  })).catch((err) => {
+                    console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-status via SSE:`, err);
                   });
                 });
+              } else {
+                console.log(`[BROWSER-STREAM:${streamId}] Frame listeners already attached (count=${proxy.listenerCount("frame")}), skipping`);
               }
             }
           },
@@ -9303,14 +9489,17 @@ ${prompt}` });
     }
     await messageQueries.create(id, { role: "user", content: userMessageContent });
     const streamId = `stream_${id}_${nanoid6(10)}`;
+    console.log(`[STREAM] Creating stream ${streamId} for session ${id}`);
     await activeStreamQueries.create(id, streamId);
     const stream = await streamContext.resumableStream(
       streamId,
       createAgentStreamProducer(id, prompt, streamId, streamAttachments)
     );
     if (!stream) {
+      console.error(`[STREAM] Failed to create resumable stream ${streamId}`);
       return c.json({ error: "Failed to create stream" }, 500);
     }
+    console.log(`[STREAM] Stream ${streamId} created successfully`);
     const encodedStream = stream.pipeThrough(new TextEncoderStream());
     return new Response(encodedStream, {
       headers: {
@@ -9339,17 +9528,20 @@ agents.get("/:id/watch", async (c) => {
     }
     streamId = activeStream.streamId;
   }
+  console.log(`[STREAM] Watch request for session ${sessionId}, streamId=${streamId}, resumeAt=${resumeAt || "none"}`);
   const stream = await streamContext.resumeExistingStream(
     streamId,
     resumeAt ? parseInt(resumeAt, 10) : void 0
   );
   if (!stream) {
+    console.log(`[STREAM] Watch failed \u2014 stream ${streamId} is no longer active`);
     return c.json({
       error: "Stream is no longer active",
       streamId,
       hint: "The stream may have finished. Check /agents/:id/approvals or start a new run."
     }, 422);
   }
+  console.log(`[STREAM] Client watching stream ${streamId}`);
   const encodedStream = stream.pipeThrough(new TextEncoderStream());
   return new Response(encodedStream, {
     headers: {
@@ -9511,19 +9703,28 @@ agents.post(
       const toolCallStarts = /* @__PURE__ */ new Set();
       const abortController = new AbortController();
       streamAbortControllers.set(streamId, abortController);
+      let sseEventCount = 0;
+      let sseBrowserFrameCount = 0;
+      let sseWriteErrors = 0;
       const writeSSE = async (data) => {
         if (writerClosed) return;
         try {
+          sseEventCount++;
           await writer.write(`data: ${data}
 
 `);
         } catch (err) {
+          sseWriteErrors++;
+          if (sseWriteErrors === 1) {
+            console.log(`[SSE:${streamId}] Writer closed (client disconnected). Total events sent: ${sseEventCount}, browser frames: ${sseBrowserFrameCount}`);
+          }
           writerClosed = true;
         }
       };
       const safeClose = async () => {
         if (writerClosed) return;
         try {
+          console.log(`[SSE:${streamId}] Stream closing. Total events: ${sseEventCount}, browser frames: ${sseBrowserFrameCount}, write errors: ${sseWriteErrors}`);
           writerClosed = true;
           await writer.close();
         } catch {
@@ -9583,35 +9784,47 @@ agents.post(
               const browserPort = progress.data?.browserStreamPort;
               const browserClosed = progress.data?.browserClosed;
               if (progress.toolName === "bash" && browserClosed) {
-                console.log(`[BROWSER-STREAM] agent-browser close detected`);
+                console.log(`[BROWSER-STREAM:${streamId}] agent-browser close detected, destroying proxy for session ${session.id}`);
                 destroyProxy(session.id);
               } else if (progress.toolName === "bash" && browserPort) {
-                console.log(`[BROWSER-STREAM] agent-browser command detected, port ${browserPort}`);
+                console.log(`[BROWSER-STREAM:${streamId}] agent-browser command detected, port ${browserPort} for session ${session.id}`);
                 const proxy = getOrCreateProxy(session.id, browserPort);
+                console.log(`[BROWSER-STREAM:${streamId}] Proxy state: connected=${proxy.connected}, frameListeners=${proxy.listenerCount("frame")}, statusListeners=${proxy.listenerCount("status")}`);
                 if (!sessionRecorders.has(session.id)) {
                   const recorder = new FrameRecorder(session.id);
                   recorder.start();
                   sessionRecorders.set(session.id, recorder);
                 }
                 if (proxy.listenerCount("frame") === 0) {
+                  console.log(`[BROWSER-STREAM:${streamId}] Attaching frame+status listeners to proxy`);
                   proxy.on("frame", (frame) => {
+                    sseBrowserFrameCount++;
+                    if (sseBrowserFrameCount === 1) {
+                      console.log(`[BROWSER-STREAM:${streamId}] First browser frame received! dataSize=${frame.data?.length ?? 0} writerClosed=${writerClosed}`);
+                    } else if (sseBrowserFrameCount % 50 === 0) {
+                      console.log(`[BROWSER-STREAM:${streamId}] Browser frame #${sseBrowserFrameCount} (writerClosed=${writerClosed})`);
+                    }
                     const rec = sessionRecorders.get(session.id);
                     rec?.addFrame(frame);
                     writeSSE(JSON.stringify({
                       type: "browser-frame",
                       data: frame.data,
                       metadata: frame.metadata
-                    })).catch(() => {
+                    })).catch((err) => {
+                      console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-frame via SSE:`, err);
                     });
                   });
                   proxy.on("status", (s) => {
-                    console.log(`[BROWSER-STREAM] Status:`, s);
+                    console.log(`[BROWSER-STREAM:${streamId}] Browser status event: connected=${s.connected} screencasting=${s.screencasting} viewport=${s.viewportWidth}x${s.viewportHeight}`);
                     writeSSE(JSON.stringify({
                       type: "browser-status",
                       ...s
-                    })).catch(() => {
+                    })).catch((err) => {
+                      console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-status via SSE:`, err);
                     });
                   });
+                } else {
+                  console.log(`[BROWSER-STREAM:${streamId}] Frame listeners already attached (count=${proxy.listenerCount("frame")}), skipping`);
                 }
               }
             },
@@ -10260,6 +10473,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();
@@ -10297,45 +10511,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);
   }
 );