@alpaca-editor/core 1.0.4037 → 1.0.4039

package/src/editor/services/agentService.ts

@@ -149,11 +149,15 @@ export async function connectToAgentStream(
   onMessage: (message: AgentStreamMessage) => void,
   signal?: AbortSignal,
 ): Promise<void> {
+  console.log("RECONNECT: Starting connectToAgentStream for agent:", agentId);
+
   // Add cache-busting timestamp to prevent browser connection reuse
   const timestamp = Date.now();
   const streamUrl =
     AGENT_BASE_URL + "/stream?agentId=" + agentId + "&t=" + timestamp;
 
+  console.log("RECONNECT: Stream URL:", streamUrl);
+
   // Retry logic to handle potential race conditions
   let retryCount = 0;
   const maxRetries = 3;
@@ -161,6 +165,10 @@ export async function connectToAgentStream(
 
   while (retryCount <= maxRetries) {
     try {
+      console.log(
+        `RECONNECT: Attempting connection ${retryCount + 1}/${maxRetries + 1} to agent ${agentId}`,
+      );
+
       const response = await fetch(streamUrl, {
         headers: {
           Accept: "text/event-stream",
@@ -171,9 +179,22 @@ export async function connectToAgentStream(
         signal,
       });
 
+      console.log(`RECONNECT: Fetch response for agent ${agentId}:`, {
+        status: response.status,
+        statusText: response.statusText,
+        ok: response.ok,
+        headers: Object.fromEntries(response.headers.entries()),
+      });
+
       if (response.ok) {
         // Success - proceed with stream processing
+        console.log(
+          `RECONNECT: Successfully connected to stream for agent ${agentId}, starting to process events`,
+        );
         await processEventStream(response, onMessage);
+        console.log(
+          `RECONNECT: Event stream processing completed for agent ${agentId}`,
+        );
         return;
       }
 
@@ -181,28 +202,34 @@ export async function connectToAgentStream(
       if (response.status === 404 && retryCount < maxRetries) {
         retryCount++;
         console.warn(
-          `Agent stream not ready (404), retrying in ${retryDelay}ms... (${retryCount}/${maxRetries})`,
+          `RECONNECT: Agent stream not ready (404), retrying in ${retryDelay}ms... (${retryCount}/${maxRetries}) for agent ${agentId}`,
         );
         await new Promise((resolve) => setTimeout(resolve, retryDelay));
         continue;
       }
 
       // For other errors or max retries reached, throw
-      throw new Error(
-        `Failed to connect to agent stream: ${response.status} ${response.statusText}`,
-      );
+      const errorMessage = `Failed to connect to agent stream: ${response.status} ${response.statusText}`;
+      console.error(`RECONNECT: ${errorMessage} for agent ${agentId}`);
+      throw new Error(errorMessage);
     } catch (error) {
+      console.log(`RECONNECT: Caught error for agent ${agentId}:`, error);
+
       if (signal?.aborted) {
+        console.log(`RECONNECT: Request aborted for agent ${agentId}`);
         throw error; // Don't retry if cancelled
       }
 
       if (retryCount >= maxRetries) {
+        console.error(
+          `RECONNECT: Max retries reached for agent ${agentId}, giving up`,
+        );
         throw error;
       }
 
       retryCount++;
       console.warn(
-        `Error connecting to agent stream, retrying... (${retryCount}/${maxRetries})`,
+        `RECONNECT: Error connecting to agent stream, retrying... (${retryCount}/${maxRetries}) for agent ${agentId}`,
         error,
       );
       await new Promise((resolve) => setTimeout(resolve, retryDelay));
@@ -217,19 +244,27 @@ async function processEventStream(
   response: Response,
   onMessage: (message: AgentStreamMessage) => void,
 ): Promise<void> {
+  console.log("RECONNECT: Starting to process event stream");
+
   const reader = response.body?.getReader();
   if (!reader) {
-    throw new Error("Failed to get stream reader");
+    const error = "Failed to get stream reader";
+    console.error("RECONNECT:", error);
+    throw new Error(error);
   }
 
   const decoder = new TextDecoder();
   let buffer = "";
+  let messageCount = 0;
 
   try {
     while (true) {
       const { done, value } = await reader.read();
 
       if (done) {
+        console.log(
+          `RECONNECT: Stream reader finished. Total messages processed: ${messageCount}`,
+        );
         break;
       }
 
@@ -253,10 +288,21 @@ async function processEventStream(
           try {
             const data = line.slice(6); // Remove 'data: ' prefix
             if (data.trim()) {
+              messageCount++;
               const message: AgentStreamMessage = JSON.parse(data);
 
+              console.log(
+                `RECONNECT: Processing SSE message #${messageCount}:`,
+                {
+                  type: message.type,
+                  hasData: !!message.data,
+                  error: message.error,
+                },
+              );
+
               // Normalize message type (handle both numeric and string enum values)
               if (typeof message.type === "number") {
+                const originalType = message.type;
                 switch (message.type) {
                   case 0:
                     message.type = AgentStreamMessageType.StatusUpdate;
@@ -282,6 +328,9 @@ async function processEventStream(
                   default:
                     message.type = `Unknown_${message.type}`;
                 }
+                console.log(
+                  `RECONNECT: Normalized message type from ${originalType} to ${message.type}`,
+                );
               }
 
               onMessage(message);
@@ -291,12 +340,18 @@ async function processEventStream(
                 message.type === AgentStreamMessageType.Completed ||
                 message.type === AgentStreamMessageType.Error
               ) {
-                //  console.log("Stream ending due to message type:", message.type);
+                console.log(
+                  `RECONNECT: Stream ending due to message type: ${message.type}. Total messages: ${messageCount}`,
+                );
                 return;
               }
             }
           } catch (error) {
-            console.error("Failed to parse SSE message:", error, line);
+            console.error(
+              "RECONNECT: Failed to parse SSE message:",
+              error,
+              line,
+            );
             // Send error message to the client to notify user
             onMessage({
               type: AgentStreamMessageType.Error,
@@ -305,11 +360,16 @@ async function processEventStream(
               timestamp: new Date().toISOString(),
             });
           }
+        } else if (line.trim() && !line.startsWith(":")) {
+          // Log non-data, non-comment lines for debugging
+          console.log("RECONNECT: Unexpected SSE line format:", line);
         }
       }
     }
   } finally {
-    // console.log("Stream ended, releasing reader lock");
+    console.log(
+      `RECONNECT: Stream ended, releasing reader lock. Final message count: ${messageCount}`,
+    );
     reader.releaseLock();
   }
 }
@@ -457,7 +517,7 @@ export async function cancelAgent(
   agentId: string,
   context: AiContext,
 ): Promise<any> {
-  const response = await fetch(AGENT_BASE_URL + "/cancelAgent", {
+  const response = await fetch(AGENT_BASE_URL + "/cancel", {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -529,14 +589,27 @@ export async function checkAgentState(
   agentId: string,
   context: AiContext,
 ): Promise<{ exists: boolean; agent?: AgentChat; isRunning: boolean }> {
+  console.log("RECONNECT: Checking agent state for:", agentId);
+
   try {
     const agent = await getAgent(agentId, context);
+    console.log("RECONNECT: Agent found:", {
+      id: agent.id,
+      status: agent.status,
+      messageCount: agent.messages?.length || 0,
+      lastMessageDate: agent.lastMessageDate,
+    });
+
+    const isRunning = agent.status === 0;
+    console.log("RECONNECT: Agent running status:", isRunning);
+
     return {
       exists: true,
       agent,
-      isRunning: agent.status === "Active",
+      isRunning,
     };
   } catch (error) {
+    console.log("RECONNECT: Agent not found or error fetching:", error);
     // If agent doesn't exist, return false
     return {
       exists: false,
@@ -572,6 +645,8 @@ export function convertAgentMessagesToTerminalFormat(
           function: {
             name: tc.functionName,
             arguments: tc.functionArguments,
+            result: tc.functionResult,
+            error: tc.functionError,
           },
         }));
       }

package/src/revision.ts

@@ -1,2 +1,2 @@
-export const version = "1.0.4037";
-export const buildDate = "2025-08-10 09:51:50";
+export const version = "1.0.4039";
+export const buildDate = "2025-08-11 14:38:58";