@alpaca-editor/core 1.0.4037 → 1.0.4039

package/src/editor/ai/AiTerminal.tsx

@@ -72,6 +72,8 @@ export type ToolCall = {
   function: {
     name: string;
     arguments: string;
+    result?: string;
+    error?: string;
   };
 };
 
@@ -202,17 +204,35 @@ export function AiTerminal({
   // Agent reconnection logic
   useEffect(() => {
     async function checkAndReconnectAgent() {
-      if (!editContext || !agentId) return;
+      if (!editContext || !editContext.sessionId || !agentId) {
+        console.log(
+          "RECONNECT: Skipping reconnection - missing editContext or agentId",
+          {
+            editContext: !!editContext,
+            sessionId: editContext?.sessionId,
+            agentId,
+          },
+        );
+        return;
+      }
 
       const context = createAiContext({ editContext });
 
       try {
-        console.log("Checking agent state for reconnection:", agentId);
+        console.log(
+          "RECONNECT: Checking agent state for reconnection:",
+          agentId,
+        );
         const agentState = await checkAgentState(agentId, context);
+        console.log("RECONNECT: Agent state check result:", {
+          exists: agentState.exists,
+          isRunning: agentState.isRunning,
+          status: agentState.agent?.status,
+        });
 
         if (agentState.exists && agentState.agent) {
           console.log(
-            "Found existing agent, restoring state:",
+            "RECONNECT: Found existing agent, restoring state:",
             agentState.agent,
           );
 
@@ -226,13 +246,32 @@ export function AiTerminal({
             const terminalMessages = convertAgentMessagesToTerminalFormat(
               agent.messages,
             );
-            console.log("Restoring messages:", terminalMessages);
+            console.log(
+              "RECONNECT: Restoring messages:",
+              terminalMessages.length,
+              "messages",
+            );
             setMessages(terminalMessages);
             setResponseMessages(terminalMessages);
+          } else {
+            console.log(
+              "RECONNECT: Skipping message restoration - no messages or already initialized",
+              {
+                hasAgentMessages: !!agent.messages,
+                agentMessageCount: agent.messages?.length || 0,
+                hasInitialMessages: !!options?.initialMessages,
+                initialMessageCount: options?.initialMessages?.length || 0,
+              },
+            );
           }
 
           // Set cost information if available
           if (agent.totalCost !== undefined) {
+            console.log("RECONNECT: Setting cost information:", {
+              totalCost: agent.totalCost,
+              totalInputTokens: agent.totalInputTokens,
+              totalOutputTokens: agent.totalOutputTokens,
+            });
             setResponse(
               (prev) =>
                 ({
@@ -250,30 +289,52 @@ export function AiTerminal({
 
           // If agent is still running, reconnect to the stream
           if (agentState.isRunning) {
-            console.log("Agent is still running, reconnecting to stream");
+            console.log(
+              "RECONNECT: Agent is still running, attempting to reconnect to stream",
+            );
+            setIsRunning(true);
             await reconnectToRunningAgent(agentId, context);
           } else {
             console.log(
-              "Agent completed while disconnected, showing final state",
+              "RECONNECT: Agent completed while disconnected, showing final state",
             );
           }
         } else {
-          console.log("No existing agent found or agent doesn't exist");
+          console.log(
+            "RECONNECT: No existing agent found or agent doesn't exist",
+          );
         }
       } catch (error) {
-        console.error("Failed to check agent state:", error);
-        // Don't show error to user for reconnection failures - just continue as normal
+        console.error("RECONNECT: Failed to check agent state:", error);
+        setTerminalError(
+          `Reconnection failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        );
       }
     }
 
-    // Only try to reconnect if we have an agentId and haven't already initialized with messages
-    if (agentId && editContext) {
+    // Only try to reconnect if we have an agentId and edit context
+    if (agentId && editContext && editContext.sessionId) {
+      console.log("RECONNECT: Starting reconnection check for agent:", agentId);
       checkAndReconnectAgent();
+    } else {
+      console.log(
+        "RECONNECT: Skipping reconnection check - conditions not met",
+        {
+          hasAgentId: !!agentId,
+          hasEditContext: !!editContext,
+          hasSessionId: !!editContext?.sessionId,
+        },
+      );
     }
-  }, [agentId]); // Only run when agentId changes
+  }, [agentId, editContext?.sessionId]); // Run when agentId or session becomes available
 
   // Function to reconnect to a running agent stream
   async function reconnectToRunningAgent(agentId: string, context: AiContext) {
+    console.log(
+      "RECONNECT: Starting reconnectToRunningAgent for agent:",
+      agentId,
+    );
+
     try {
       const abortController = new AbortController();
       abortControllerRef.current = abortController;
@@ -289,34 +350,84 @@ export function AiTerminal({
       };
       let completionProcessed = false;
 
-      console.log("Reconnecting to agent stream:", agentId);
+      console.log("RECONNECT: Attempting to connect to agent stream:", agentId);
+      console.log(
+        "RECONNECT: Current messages state:",
+        messages.length,
+        "messages",
+      );
+
       await connectToAgentStream(
         agentId,
         context,
         (streamMessage) => {
           console.log(
-            "Reconnected stream message:",
+            "RECONNECT: Received stream message:",
             streamMessage.type,
             streamMessage,
           );
 
-          // Use the same stream message handling logic as the original startAgent function
-          // (This is the same logic that was already in the component)
-          handleStreamMessage(
-            streamMessage,
-            accumulatedResponse,
-            completionProcessed,
-            context,
-          );
+          if (!streamMessage || !streamMessage.type) {
+            console.error(
+              "RECONNECT: Invalid stream message received:",
+              streamMessage,
+            );
+            return;
+          }
+
+          // Reuse stream message handling, but pipe updates into Terminal via TerminalService
+          try {
+            const terminalCallback = (
+              text: React.ReactNode,
+              finished: boolean,
+            ) => {
+              TerminalService.emit("response", { text, finished });
+            };
+
+            const result = handleStreamMessage(
+              streamMessage,
+              accumulatedResponse,
+              completionProcessed,
+              context,
+              terminalCallback,
+            );
+            if (result) {
+              accumulatedResponse = result.accumulatedResponse;
+              completionProcessed = result.completionProcessed;
+            }
+          } catch (error) {
+            console.error(
+              "RECONNECT: Error handling stream message:",
+              error,
+              streamMessage,
+            );
+          }
         },
         abortController.signal,
       );
+
+      console.log(
+        "RECONNECT: Successfully completed reconnection to agent stream:",
+        agentId,
+      );
+      setIsRunning(false);
     } catch (error) {
-      console.error("Failed to reconnect to agent stream:", error);
+      console.error("RECONNECT: Failed to reconnect to agent stream:", error);
       setIsRunning(false);
-      setTerminalError(
-        `Failed to reconnect to agent: ${error instanceof Error ? error.message : "Unknown error"}`,
-      );
+
+      // Check if it's an abort error (user cancelled)
+      const isAbortError =
+        error instanceof Error &&
+        (error.name === "AbortError" ||
+          error.message.toLowerCase().includes("abort"));
+
+      if (!isAbortError) {
+        const errorMessage = `Failed to reconnect to agent: ${error instanceof Error ? error.message : "Unknown error"}`;
+        console.error("RECONNECT: Setting terminal error:", errorMessage);
+        setTerminalError(errorMessage);
+      } else {
+        console.log("RECONNECT: Connection was aborted (user cancelled)");
+      }
     }
   }
 
@@ -326,7 +437,8 @@ export function AiTerminal({
     accumulatedResponse: any,
     completionProcessed: boolean,
     context: AiContext,
-  ) {
+    terminalCallback: (text: React.ReactNode, finished: boolean) => void,
+  ): { accumulatedResponse: any; completionProcessed: boolean } | void {
     // Safety check for valid stream message
     if (!streamMessage || !streamMessage.type) {
       console.error("Invalid stream message received:", streamMessage);
@@ -392,7 +504,7 @@ export function AiTerminal({
             };
 
             // Update accumulated response with incremental content
-            accumulatedResponse = {
+            const newAccumulated = {
               ...accumulatedResponse,
               ...streamMessage.data,
               messages: updatedMessages,
@@ -400,45 +512,132 @@ export function AiTerminal({
                 streamMessage.data.editOperations ||
                 accumulatedResponse.editOperations,
             };
+            accumulatedResponse = newAccumulated;
           } else {
             // Non-incremental update - use as provided
-            accumulatedResponse = {
+            const newAccumulated = {
               ...accumulatedResponse,
               ...streamMessage.data,
               editOperations:
                 streamMessage.data.editOperations ||
                 accumulatedResponse.editOperations,
             };
+            accumulatedResponse = newAccumulated;
           }
 
           // Always trigger UI update for content chunks
-          handleResponse(accumulatedResponse, () => {}, false);
+          handleResponse(accumulatedResponse, terminalCallback, false);
         }
-        break;
+        return { accumulatedResponse, completionProcessed };
 
       case AgentStreamMessageType.ToolCall:
-        // Handle tool calls - simplified for reconnection
         if (streamMessage.data && typeof streamMessage.data === "object") {
-          console.log(
-            "Tool call received during reconnection:",
-            streamMessage.data,
+          // Find or create the assistant message that contains this tool call
+          const updatedMessages = [...(accumulatedResponse.messages || [])];
+          let lastAssistantMessage = null;
+          let lastAssistantIndex = -1;
+
+          for (let i = updatedMessages.length - 1; i >= 0; i--) {
+            if (updatedMessages[i].role === "assistant") {
+              lastAssistantMessage = updatedMessages[i];
+              lastAssistantIndex = i;
+              break;
+            }
+          }
+
+          // If no assistant message exists, create one
+          if (!lastAssistantMessage) {
+            lastAssistantMessage = {
+              id: crypto.randomUUID(),
+              role: "assistant",
+              name: "assistant",
+              content: "",
+              tool_calls: [],
+            } as Message;
+            updatedMessages.push(lastAssistantMessage);
+            lastAssistantIndex = updatedMessages.length - 1;
+          }
+
+          const toolCall = {
+            id: streamMessage.data.id,
+            displayName: streamMessage.data.displayName,
+            function: {
+              name:
+                streamMessage.data.function?.name || streamMessage.data.name,
+              arguments:
+                streamMessage.data.function?.arguments ||
+                streamMessage.data.arguments,
+            },
+          } as any;
+
+          const existingToolCalls = lastAssistantMessage.tool_calls || [];
+          const existingIndex = existingToolCalls.findIndex(
+            (tc: any) => tc.id === toolCall.id,
           );
-          // For reconnection, we mainly need to update the UI
-          // The detailed tool call logic can be handled the same as in the original
+          let updatedToolCalls;
+          if (existingIndex >= 0) {
+            updatedToolCalls = [...existingToolCalls];
+            updatedToolCalls[existingIndex] = toolCall;
+          } else {
+            updatedToolCalls = [...existingToolCalls, toolCall];
+          }
+
+          updatedMessages[lastAssistantIndex] = {
+            ...lastAssistantMessage,
+            tool_calls: updatedToolCalls,
+          } as Message;
+
+          const newAccumulated = {
+            ...accumulatedResponse,
+            messages: updatedMessages,
+          };
+          accumulatedResponse = newAccumulated;
+
+          handleResponse(accumulatedResponse, terminalCallback, false);
         }
-        break;
+        return { accumulatedResponse, completionProcessed };
 
       case AgentStreamMessageType.ToolResult:
-        // Handle tool results - simplified for reconnection
         if (streamMessage.data && typeof streamMessage.data === "object") {
-          console.log(
-            "Tool result received during reconnection:",
-            streamMessage.data,
-          );
-          // For reconnection, we mainly need to update the UI
-          // The detailed tool result logic can be handled the same as in the original
+          const updatedMessages = [...(accumulatedResponse.messages || [])];
+          // Find the assistant message with the matching tool call ID
+          for (let i = updatedMessages.length - 1; i >= 0; i--) {
+            if (
+              updatedMessages[i].role === "assistant" &&
+              updatedMessages[i].tool_calls
+            ) {
+              const toolCalls = updatedMessages[i].tool_calls || [];
+              const toolCallIndex = toolCalls.findIndex(
+                (tc: any) => tc.id === streamMessage.data.toolCallId,
+              );
+              if (toolCallIndex >= 0) {
+                const updatedToolCalls = [...toolCalls];
+                updatedToolCalls[toolCallIndex] = {
+                  ...updatedToolCalls[toolCallIndex],
+                  function: {
+                    ...updatedToolCalls[toolCallIndex].function,
+                    result: streamMessage.data.result,
+                    error: streamMessage.data.error,
+                  },
+                };
+                updatedMessages[i] = {
+                  ...updatedMessages[i],
+                  tool_calls: updatedToolCalls,
+                } as Message;
+                break;
+              }
+            }
+          }
+
+          const newAccumulated = {
+            ...accumulatedResponse,
+            messages: updatedMessages,
+          };
+          accumulatedResponse = newAccumulated;
+
+          handleResponse(accumulatedResponse, terminalCallback, false);
         }
-        break;
+        return { accumulatedResponse, completionProcessed };
 
       case AgentStreamMessageType.Completed:
         if (!completionProcessed) {
@@ -446,16 +645,16 @@ export function AiTerminal({
           console.log("Agent execution completed");
           setIsRunning(false);
           if (streamMessage.data) {
-            handleResponse(streamMessage.data, () => {}, true);
+            handleResponse(streamMessage.data, terminalCallback, true);
           }
         }
-        break;
+        return { accumulatedResponse, completionProcessed };
 
       case AgentStreamMessageType.Error:
         console.error("Agent execution error:", streamMessage);
         setIsRunning(false);
         setTerminalError(streamMessage.error || "Agent execution failed");
-        break;
+        return { accumulatedResponse, completionProcessed };
 
       default:
         console.warn("Unknown stream message type:", streamMessage.type);
@@ -967,13 +1166,14 @@ export function AiTerminal({
                       );
 
                       if (toolCallIndex >= 0) {
-                        // Update the tool call with the result
+                        // Update the tool call with the result or error
                         const updatedToolCalls = [...toolCalls];
                         updatedToolCalls[toolCallIndex] = {
                           ...updatedToolCalls[toolCallIndex],
                           function: {
                             ...updatedToolCalls[toolCallIndex].function,
                             result: streamMessage.data.result,
+                            error: streamMessage.data.error,
                           },
                         };
 

package/src/editor/field-types/SingleLineText.tsx

@@ -10,6 +10,7 @@ import {
 import { useFieldModification } from "../client/fieldModificationStore";
 
 import { useEffect, useRef, useState, useMemo } from "react";
+import { RefreshCw } from "lucide-react";
 
 import { Field } from "../pageModel";
 
@@ -152,6 +153,12 @@ export function SingleLineText({
     }, 500);
   }, [editContext?.focusedField]);
 
+  const customSource = (field as any)?.customProperties?.source as
+    | string
+    | undefined;
+  const isManualRefreshEnabled =
+    typeof customSource === "string" && customSource.includes("manual-refresh");
+
   return (
     <div className="relative">
       {/* <div
@@ -168,12 +175,22 @@ export function SingleLineText({
         key={fieldItem.id + field.id + fieldItem.language + fieldItem.version}
         value={value || ""}
         disabled={readOnly}
-        className="focus-shadow bg-gray-5 p-1.5 text-xs"
+        className="focus-shadow bg-gray-5 p-1.5 pr-7 text-xs"
         style={{ width: "100%" }}
         onChange={handleChange}
         onSelect={handleSelect}
         onBlur={editContextRef.current?.operations.onFieldBlur}
       />
+      {isManualRefreshEnabled && (
+        <button
+          type="button"
+          title="Re-render"
+          className="absolute right-1 top-1/2 -translate-y-1/2 rounded p-1 text-gray-600 hover:text-gray-900"
+          onClick={() => editContext?.requestRefresh("immediate")}
+        >
+          <RefreshCw className="h-4 w-4" strokeWidth={1} />
+        </button>
+      )}
     </div>
   );
 }