@alpaca-editor/core 1.0.4173 → 1.0.4174

package/dist/editor/ai/AgentTerminal.js

@@ -489,7 +489,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
     const [isListening, setIsListening] = useState(false);
     const recognitionRef = useRef(null);
     const prevPlaceholderRef = useRef(null);
-    const [voiceError, setVoiceError] = useState(null);
     const [isWaitingForResponse, setIsWaitingForResponse] = useState(false);
     const isWaitingRef = useRef(false);
     useEffect(() => {
@@ -549,6 +548,30 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
     const [activeProfile, setActiveProfile] = useState(undefined);
     const [selectedModelId, setSelectedModelId] = useState(undefined);
     const [mode, setMode] = useState("supervised");
+    // Remove deprecated cost limit fields from metadata to avoid confusion with agent/profile settings
+    const sanitizeAgentMetadata = useCallback((meta) => {
+        try {
+            if (!meta)
+                return meta;
+            const clean = { ...meta };
+            delete clean.costLimit;
+            delete clean.CostLimit;
+            delete clean.initialCostLimit;
+            delete clean.InitialCostLimit;
+            if (clean.additionalData && typeof clean.additionalData === "object") {
+                const ad = { ...clean.additionalData };
+                delete ad.costLimit;
+                delete ad.CostLimit;
+                delete ad.initialCostLimit;
+                delete ad.InitialCostLimit;
+                clean.additionalData = ad;
+            }
+            return clean;
+        }
+        catch {
+            return meta;
+        }
+    }, []);
     // Read deterministic flags from query string once
     const deterministicFlags = React.useMemo(() => {
         try {
@@ -637,7 +660,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             const SR = window.SpeechRecognition ||
                 window.webkitSpeechRecognition;
             if (!SR) {
-                setVoiceError("Voice input is not supported in this browser");
                 return;
             }
             const r = new SR();
@@ -647,7 +669,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             r.onstart = () => {
                 setIsListening(true);
                 prevPlaceholderRef.current = inputPlaceholder;
-                setVoiceError(null);
                 setInputPlaceholder("Listening...");
             };
             r.onresult = (event) => {
@@ -683,7 +704,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             };
             r.onerror = (e) => {
                 console.warn("Speech recognition error", e);
-                setVoiceError(e?.error || "Voice input error");
             };
             r.onend = () => {
                 setIsListening(false);
@@ -698,7 +718,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         }
         catch (e) {
             console.error("Failed to start voice input", e);
-            setVoiceError("Failed to start voice input");
         }
     }, [
         editContext?.currentItemDescriptor?.language,
@@ -814,21 +833,21 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         isWaitingRef.current = false;
         // Any content chunk is an incremental update -> reset idle timer
         resetDotsTimer();
-        // Extract cost/token data from content chunk if present
-        const data = message.data;
-        if (data &&
-            (data.totalCost !== undefined || data.totalTokens !== undefined)) {
+        // Extract cost/token data from message.cost (new structure)
+        const cost = message.cost;
+        if (cost &&
+            (cost.total !== undefined || cost.tokens?.total !== undefined)) {
             const nextTotals = {
-                input: Number(data.totalInputTokens) || 0,
-                output: Number(data.totalOutputTokens) || 0,
-                cached: Number(data.totalCachedTokens) || 0,
-                cacheWrite: Number(data.totalCacheWriteTokens) || 0,
-                inputCost: Number(data.totalInputTokenCost) || 0,
-                outputCost: Number(data.totalOutputTokenCost) || 0,
-                cachedCost: Number(data.totalCachedTokenCost) || 0,
-                cacheWriteCost: Number(data.totalCacheWriteTokenCost) || 0,
-                totalCost: Number(data.totalCost) || 0,
-                currency: data.currency || "USD",
+                input: Number(cost.tokens?.input) || 0,
+                output: Number(cost.tokens?.output) || 0,
+                cached: Number(cost.tokens?.cached) || 0,
+                cacheWrite: Number(cost.tokens?.cacheWrite) || 0,
+                inputCost: Number(cost.input) || 0,
+                outputCost: Number(cost.output) || 0,
+                cachedCost: Number(cost.cached) || 0,
+                cacheWriteCost: Number(cost.cacheWrite) || 0,
+                totalCost: Number(cost.total) || 0,
+                currency: "USD",
             };
             const anyNonZero = (nextTotals.totalCost || 0) > 0 ||
                 (nextTotals.input || 0) > 0 ||
@@ -838,6 +857,18 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             if (anyNonZero) {
                 setLiveTotals(nextTotals);
             }
+            // Check cost limit if available
+            if (cost.limit &&
+                cost.total &&
+                Number(cost.total) > Number(cost.limit)) {
+                setCostLimitExceeded({
+                    totalCost: Number(cost.total),
+                    costLimit: Number(cost.limit),
+                    initialCostLimit: Number(cost.limit),
+                });
+                setIsWaitingForResponse(false);
+                shouldCreateNewMessage.current = false;
+            }
         }
         // Always call setMessages and handle all logic in the callback with latest messages
         setMessages((prev) => {
@@ -981,20 +1012,20 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             }
         }
         // Extract cost/token data from tool result if present
-        const data = message.data;
-        if (data &&
-            (data.totalCost !== undefined || data.totalTokens !== undefined)) {
+        const cost = message.cost;
+        if (cost &&
+            (cost.total !== undefined || cost.tokens?.total !== undefined)) {
             const nextTotals = {
-                input: Number(data.totalInputTokens) || 0,
-                output: Number(data.totalOutputTokens) || 0,
-                cached: Number(data.totalCachedTokens) || 0,
-                cacheWrite: Number(data.totalCacheWriteTokens) || 0,
-                inputCost: Number(data.totalInputTokenCost) || 0,
-                outputCost: Number(data.totalOutputTokenCost) || 0,
-                cachedCost: Number(data.totalCachedTokenCost) || 0,
-                cacheWriteCost: Number(data.totalCacheWriteTokenCost) || 0,
-                totalCost: Number(data.totalCost) || 0,
-                currency: data.currency || "USD",
+                input: Number(cost.tokens?.input) || 0,
+                output: Number(cost.tokens?.output) || 0,
+                cached: Number(cost.tokens?.cached) || 0,
+                cacheWrite: Number(cost.tokens?.cacheWrite) || 0,
+                inputCost: Number(cost.input) || 0,
+                outputCost: Number(cost.output) || 0,
+                cachedCost: Number(cost.cached) || 0,
+                cacheWriteCost: Number(cost.cacheWrite) || 0,
+                totalCost: Number(cost.total) || 0,
+                currency: "USD",
             };
             const anyNonZero = (nextTotals.totalCost || 0) > 0 ||
                 (nextTotals.input || 0) > 0 ||
@@ -1005,6 +1036,33 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                 setLiveTotals(nextTotals);
             }
         }
+        else {
+            // Fallback: legacy aggregated totals included in the tool result data
+            const data = message.data;
+            if (data &&
+                (data.totalCost !== undefined || data.totalTokens !== undefined)) {
+                const nextTotals = {
+                    input: Number(data.totalInputTokens) || 0,
+                    output: Number(data.totalOutputTokens) || 0,
+                    cached: Number(data.totalCachedTokens) || 0,
+                    cacheWrite: Number(data.totalCacheWriteTokens) || 0,
+                    inputCost: Number(data.totalInputTokenCost) || 0,
+                    outputCost: Number(data.totalOutputTokenCost) || 0,
+                    cachedCost: Number(data.totalCachedTokenCost) || 0,
+                    cacheWriteCost: Number(data.totalCacheWriteTokenCost) || 0,
+                    totalCost: Number(data.totalCost) || 0,
+                    currency: data.currency || "USD",
+                };
+                const anyNonZero = (nextTotals.totalCost || 0) > 0 ||
+                    (nextTotals.input || 0) > 0 ||
+                    (nextTotals.output || 0) > 0 ||
+                    (nextTotals.cached || 0) > 0 ||
+                    (nextTotals.cacheWrite || 0) > 0;
+                if (anyNonZero) {
+                    setLiveTotals(nextTotals);
+                }
+            }
+        }
         // Update tool result directly in the messages array
         if (!resultMessageId) {
             return;
@@ -1076,492 +1134,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         // Tool result activity; reset idle timer
         resetDotsTimer();
     }, [resetDotsTimer]);
-    // DEPRECATED: SSE-based streaming has been replaced by WebSocket
-    // All streaming functionality is now handled by handleAgentWebSocketMessage
-    // This function is kept commented for reference but is no longer used
-    /*
-    const connectToStream = useCallback(
-      async (agentData?: AgentDetails) => {
-        const currentAgent = agentData || agent;
-        if (!currentAgent) return;
-  
-        // Cancel any existing connection
-        if (abortControllerRef.current) {
-          abortControllerRef.current.abort();
-        }
-  
-        const abortController = new AbortController();
-        abortControllerRef.current = abortController;
-  
-        try {
-          setIsConnecting(true);
-  
-          // Reduced: minimal logging
-  
-          // Expose agent id globally for approval actions
-          (window as any).currentAgentId = currentAgent.id;
-          // Expose id for approval actions
-  
-          // Connecting to agent stream
-          await connectToAgentStream_DEPRECATED(
-            currentAgent.id,
-            (message: AgentStreamMessage) => {
-              switch (message.type) {
-                case "contentChunk":
-                  handleContentChunk(message, currentAgent);
-                  break;
-  
-                case "toolCall":
-                  handleToolCall(message, currentAgent);
-                  break;
-  
-                case "toolResult":
-                  handleToolResult(message, currentAgent);
-                  break;
-  
-                case "statusUpdate":
-                  try {
-                    // Check both 'kind' and 'state' for backward compatibility
-                    const kind =
-                      (message as any)?.data?.kind ||
-                      (message as any)?.data?.state;
-                    if (kind === "streamOpen") {
-                      setIsConnecting(false);
-                      // Don't clear waiting state here - let it be cleared when first content arrives
-                      break;
-                    }
-                    // Live token usage totals update from backend
-                    if (kind === "tokenUsage") {
-                      const totals = (message as any)?.data?.totals;
-                      if (totals) {
-                        const totalCost = Number(totals.totalCost) || 0;
-                        const nextTotals = {
-                          input: Number(totals.totalInputTokens) || 0,
-                          output: Number(totals.totalOutputTokens) || 0,
-                          cached: Number(totals.totalCachedInputTokens) || 0,
-                          cacheWrite: Number(totals.totalCacheWriteTokens) || 0,
-                          inputCost: Number(totals.totalInputTokenCost) || 0,
-                          outputCost: Number(totals.totalOutputTokenCost) || 0,
-                          cachedCost:
-                            Number(totals.totalCachedInputTokenCost) || 0,
-                          cacheWriteCost:
-                            Number(totals.totalCacheWriteTokenCost) || 0,
-                          totalCost: totalCost,
-                          currency: totals.currency,
-                        };
-                        const anyNonZero =
-                          (nextTotals.totalCost || 0) > 0 ||
-                          (nextTotals.input || 0) > 0 ||
-                          (nextTotals.output || 0) > 0 ||
-                          (nextTotals.cached || 0) > 0 ||
-                          (nextTotals.cacheWrite || 0) > 0;
-                        if (anyNonZero) {
-                          setLiveTotals(nextTotals);
-                        }
-  
-                        // Check if cost limit exceeded
-                        if (agent?.costLimit && totalCost > agent.costLimit) {
-                          setCostLimitExceeded({
-                            totalCost: totalCost,
-                            costLimit: agent.costLimit,
-                            initialCostLimit: agent.costLimit,
-                          });
-                          setIsWaitingForResponse(false);
-                          shouldCreateNewMessage.current = false;
-                        }
-  
-                        // Force a re-render to update cost display immediately
-                        setMessages((prev) => [...prev]);
-                      }
-                      break;
-                    }
-                    if (kind === "toolApprovalsRequired") {
-                      const data = (message as any).data || {};
-                      const msgId: string | undefined = data.messageId;
-                      const ids: string[] = data.toolCallIds || [];
-                      // Pause stream until approval
-  
-                      // Annotate tool calls with a temporary pending marker so UI can reflect paused state on reload
-                      if (msgId && Array.isArray(ids) && ids.length > 0) {
-                        setMessages((prev) => {
-                          const updated = prev.map((m) => {
-                            if (m.id !== msgId) return m;
-                            const existingToolCalls = m.toolCalls || [];
-                            const updatedToolCalls = existingToolCalls.map(
-                              (tc) => {
-                                if (!ids.includes(tc.toolCallId)) return tc;
-                                const fn = tc.functionName || "";
-                                return {
-                                  ...tc,
-                                  functionName: fn.includes("(pending approval)")
-                                    ? fn
-                                    : fn + " (pending approval)",
-                                };
-                              },
-                            );
-                            return { ...m, toolCalls: updatedToolCalls };
-                          });
-                          messagesRef.current = updated;
-                          return updated;
-                        });
-                      }
-  
-                      // Keep the stream open; just clear waiting flags so UI reflects pause state
-                      try {
-                        setIsConnecting(false);
-                        setIsWaitingForResponse(false);
-                      } catch {}
-                      break;
-                    }
-                    if (kind === "contextWindow") {
-                      const data = (message as any).data || {};
-                      // Store last context window status in a ref so we can render it below
-                      (window as any).__agentContextWindowStatus = {
-                        model: data.model,
-                        normalizedModel: data.normalizedModel,
-                        contextWindowTokens: data.contextWindowTokens,
-                        maxCompletionTokens: data.maxCompletionTokens,
-                        estimatedInputTokens: data.estimatedInputTokens,
-                        messageCount: data.messageCount,
-                        contextUsedPercent: data.contextUsedPercent,
-                      };
-                      // Force a re-render by toggling state (cheap no-op)
-                      setMessages((prev) => [...prev]);
-                    } else if (kind === "contextChanged") {
-                      const data = (message as any).data || {};
-                      const nextContext = data.context || {};
-                      // Merge incoming context into local metadata
-                      setAgentMetadata((prev) => {
-                        const current = (prev || {}) as AgentMetadata;
-                        // Exclude top-level context to avoid duplicate keys when spreading
-                        const currentWithoutContext = { ...current };
-                        delete (currentWithoutContext as any).context;
-                        const next: AgentMetadata = {
-                          ...currentWithoutContext,
-                          additionalData: {
-                            ...(current.additionalData || {}),
-                            context: nextContext,
-                          },
-                        } as AgentMetadata;
-                        return next;
-                      });
-                      // Also reflect in agent metadata string for consistency
-                      setAgent((prevAgent) => {
-                        if (!prevAgent) return prevAgent;
-                        try {
-                          const currentMeta: AgentMetadata | null = (() => {
-                            try {
-                              return prevAgent.agentContext
-                                ? (JSON.parse(
-                                    prevAgent.agentContext,
-                                  ) as AgentMetadata)
-                                : null;
-                            } catch {
-                              return null;
-                            }
-                          })();
-                          const nextMeta: AgentMetadata = {
-                            ...(currentMeta || ({} as AgentMetadata)),
-                            ...nextContext,
-                          } as AgentMetadata;
-                          return {
-                            ...prevAgent,
-                            agentContext: JSON.stringify(nextMeta),
-                          };
-                        } catch {
-                          return prevAgent;
-                        }
-                      });
-                    } else if (kind === "cost_limit_reached") {
-                      // Cost limit has been reached - show banner and stop waiting
-                      // NOTE: Stream stays connected so user can extend limit and continue immediately
-                      console.log(
-                        "[AgentTerminal] Cost limit reached notification received",
-                        message,
-                      );
-                      const data = (message as any).data || {};
-                      const totalCost = Number(data.totalCost) || 0;
-                      // Use costLimit from the notification data, or fall back to agent.costLimit
-                      const costLimit =
-                        Number(data.costLimit) || agent?.costLimit || 0;
-  
-                      console.log(
-                        "[AgentTerminal] Setting cost limit exceeded state:",
-                        {
-                          totalCost,
-                          costLimit,
-                          agentCostLimit: agent?.costLimit,
-                          dataCostLimit: data.costLimit,
-                          dataValues: data,
-                        },
-                      );
-  
-                      // Set the state with values from the notification
-                      setCostLimitExceeded({
-                        totalCost: totalCost,
-                        costLimit: costLimit,
-                        initialCostLimit: costLimit,
-                      });
-  
-                      // Clear waiting states but keep stream connected
-                      setIsWaitingForResponse(false);
-                      setIsConnecting(false);
-                      shouldCreateNewMessage.current = false;
-                      break;
-                    } else if (
-                      kind === "toolApprovalGranted" ||
-                      kind === "toolApprovalRejected"
-                    ) {
-                      const data = (message as any).data || {};
-                      const toolCallId: string | undefined = data.toolCallId;
-                      const msgId: string | undefined = data.messageId;
-                      // Processing tool approval
-                      if (toolCallId && msgId) {
-                        setMessages((prev) => {
-                          const updated = prev.map((m) => {
-                            if (m.id !== msgId) return m;
-                            const existingToolCalls = m.toolCalls || [];
-                            const updatedToolCalls = existingToolCalls.map(
-                              (tc) => {
-                                if (tc.toolCallId !== toolCallId) return tc;
-                                const suffix =
-                                  kind === "toolApprovalGranted"
-                                    ? " (approved)"
-                                    : " (rejected)";
-                                // Remove "(pending approval)" suffix before adding new suffix
-                                const baseFunctionName = (tc.functionName || "")
-                                  .replace(" (pending approval)", "")
-                                  .trim();
-                                const newFunctionName = baseFunctionName + suffix;
-                                // Update function name with approval suffix
-                                return {
-                                  ...tc,
-                                  functionName: newFunctionName,
-                                };
-                              },
-                            );
-                            return { ...m, toolCalls: updatedToolCalls };
-                          });
-                          messagesRef.current = updated;
-                          return updated;
-                        });
-                      }
-                      break;
-                    }
-                  } catch {}
-                  break;
-  
-                case "completed":
-                  const completedMessageId = message.data?.messageId;
-  
-                  // If the completed event carries full messages, merge them into state
-                  try {
-                    const completionMessages = (message as any)?.data
-                      ?.messages as any[] | undefined;
-                    if (
-                      completionMessages &&
-                      Array.isArray(completionMessages) &&
-                      completionMessages.length > 0
-                    ) {
-                      setMessages((prev) => {
-                        // Mark all completion messages as completed
-                        const dbMessages = completionMessages.map((msg) => ({
-                          ...msg,
-                          isCompleted: true,
-                          messageType: "completed" as const,
-                        })) as AgentChatMessage[];
-  
-                        // Use ID-based merge to prevent duplicates
-                        const merged = mergeMessagesById(dbMessages, prev);
-                        messagesRef.current = merged;
-                        return merged;
-                      });
-                    }
-                  } catch (e) {
-                    console.warn("⚠️ Failed to merge completion messages:", e);
-                  }
-  
-                  // Mark the specific message as completed by messageId
-                  if (completedMessageId) {
-                    setMessages((prev) => {
-                      const updated = prev.map((msg) => {
-                        if (msg.id === completedMessageId) {
-                          const updatedMessage = {
-                            ...msg,
-                            isCompleted: true,
-                            messageType: "completed" as const,
-                          };
-  
-                          // Update token usage data if provided in the completed event
-                          if (message.data) {
-                            const data = message.data;
-                            if (data.numInputTokens !== undefined) {
-                              updatedMessage.inputTokens = data.numInputTokens;
-                            }
-                            if (data.numOutputTokens !== undefined) {
-                              updatedMessage.outputTokens = data.numOutputTokens;
-                            }
-                            if (data.numCachedTokens !== undefined) {
-                              updatedMessage.cachedInputTokens =
-                                data.numCachedTokens;
-                            }
-                            // Update total tokens used
-                            updatedMessage.tokensUsed =
-                              (updatedMessage.inputTokens || 0) +
-                              (updatedMessage.outputTokens || 0);
-  
-                            // Update cost data if provided in the completed event
-                            if (data.inputTokenCost !== undefined) {
-                              updatedMessage.inputTokenCost = data.inputTokenCost;
-                            }
-                            if (data.outputTokenCost !== undefined) {
-                              updatedMessage.outputTokenCost =
-                                data.outputTokenCost;
-                            }
-                            if (
-                              data.cachedInputTokenCost !== undefined ||
-                              data.cachedTokenCost !== undefined
-                            ) {
-                              updatedMessage.cachedInputTokenCost =
-                                data.cachedInputTokenCost ?? data.cachedTokenCost;
-                            }
-                            if (data.totalCost !== undefined) {
-                              updatedMessage.totalCost = data.totalCost;
-                            }
-  
-                            // Handle content that might only be sent in the completed event
-                            if (data.deltaContent && data.deltaContent.trim()) {
-                              if (!data.isIncremental) {
-                                // Non-incremental: replace the entire content
-                                updatedMessage.content = data.deltaContent;
-                              } else {
-                                // Incremental: append to existing content
-                                updatedMessage.content =
-                                  (updatedMessage.content || "") +
-                                  data.deltaContent;
-                              }
-                            }
-                          }
-  
-                          return updatedMessage;
-                        }
-                        return msg;
-                      });
-                      messagesRef.current = updated;
-                      return updated;
-                    });
-                  } else {
-                    // Fallback: Mark any streaming messages as completed (old behavior)
-                    console.warn(
-                      "⚠️ No messageId in completed event, falling back to marking all streaming messages as completed",
-                    );
-                    setMessages((prev) => {
-                      const updated = prev.map((msg) =>
-                        !msg.isCompleted && msg.messageType === "streaming"
-                          ? {
-                              ...msg,
-                              isCompleted: true,
-                              messageType: "completed",
-                            }
-                          : msg,
-                      );
-                      messagesRef.current = updated;
-                      return updated;
-                    });
-                  }
-                  // Ensure waiting state is cleared when stream completes
-                  setIsWaitingForResponse(false);
-                  isWaitingRef.current = false;
-                  shouldCreateNewMessage.current = false;
-                  // Streaming finished; update indicator
-                  resetDotsTimer();
-                  break;
-  
-                case "contextUpdate":
-                  // Update agent context when backend sends context update
-                  try {
-                    console.log("📥 Received contextUpdate message:", message);
-                    const updatedContext = message.data as AgentMetadata;
-                    if (updatedContext) {
-                      console.log(
-                        "📝 Updating agent metadata with:",
-                        updatedContext,
-                      );
-  
-                      // Check if there's a todo list in the context
-                      if (updatedContext.additionalData?.todoList) {
-                        console.log(
-                          "✅ Todo list found in context update:",
-                          updatedContext.additionalData.todoList,
-                        );
-                      }
-  
-                      // Update local metadata state
-                      setAgentMetadata((prev) => ({
-                        ...prev,
-                        ...updatedContext,
-                      }));
-  
-                      // Update agent state with new context
-                      setAgent((prevAgent) => {
-                        if (!prevAgent) return prevAgent;
-                        return {
-                          ...prevAgent,
-                          agentContext: JSON.stringify(updatedContext),
-                        };
-                      });
-  
-                      console.log("✅ Context updated from backend successfully");
-                    } else {
-                      console.warn(
-                        "⚠️ Context update received but updatedContext is null/undefined",
-                      );
-                    }
-                  } catch (err) {
-                    console.error("❌ Error handling context update:", err);
-                  }
-                  break;
-  
-                case "error":
-                  console.error("❌ Stream error:", message.error);
-                  setError(message.error || "Stream error occurred");
-                  setIsWaitingForResponse(false);
-                  isWaitingRef.current = false;
-                  shouldCreateNewMessage.current = false;
-                  // Error ends streaming; update indicator
-                  resetDotsTimer();
-                  break;
-  
-                default:
-                  console.warn("❓ Unhandled message type:", {
-                    type: message.type,
-                    typeOf: typeof message.type,
-                    length: message.type?.length,
-                    charCodes: message.type
-                      ?.split("")
-                      .map((c) => c.charCodeAt(0)),
-                    message: message,
-                  });
-                  break;
-              }
-            },
-            abortController.signal,
-            clientSessionIdRef.current || undefined,
-          );
-        } catch (err) {
-          if (!abortController.signal.aborted) {
-            console.error("Stream connection failed:", err);
-            setError("Failed to connect to agent stream");
-          }
-        } finally {
-          setIsConnecting(false);
-          // Guard: clear waiting state if connection finished without content
-          setIsWaitingForResponse(false);
-        }
-      },
-      [agent?.id, handleContentChunk, handleToolCall, handleToolResult],
-    );
-    */
     // Listen for local approval resolution to update UI
     useEffect(() => {
         const onApprovalResolved = (ev) => {
@@ -1750,7 +1322,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                     nextMetadata = localCtx;
                 }
                 if (nextMetadata) {
-                    setAgentMetadata(nextMetadata);
+                    setAgentMetadata(sanitizeAgentMetadata(nextMetadata));
                     // If an initial prompt is provided via metadata, seed the input once
                     try {
                         const maybePrompt = nextMetadata?.additionalData
@@ -1807,12 +1379,17 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                     agentData.totalCost &&
                     agentData.totalCost > agentData.costLimit) {
                     // Fallback: check if current cost exceeds limit
+                    console.log(`[AgentTerminal] Cost limit exceeded on load: $${agentData.totalCost.toFixed(4)} > $${agentData.costLimit.toFixed(4)}`);
                     setCostLimitExceeded({
                         totalCost: agentData.totalCost,
                         costLimit: agentData.costLimit,
                         initialCostLimit: agentData.costLimit,
                     });
                 }
+                else {
+                    // Debug: log why banner wasn't set
+                    console.log(`[AgentTerminal] Cost limit check on load: costLimit=${agentData.costLimit}, totalCost=${agentData.totalCost}, exceeds=${agentData.totalCost && agentData.costLimit ? agentData.totalCost > agentData.costLimit : false}`);
+                }
             }
             catch (e) {
                 console.error("Failed to check cost limit on load:", e);
@@ -1835,21 +1412,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                 }
             })();
             // For existing agents, use database metadata or none
-            setAgentMetadata(parsedMeta);
-            // Connect to stream if agent is running
-            // Keep stream open for: running, waiting for approval, or cost limit reached
-            const isRunning = agentData.status === "running" || agentData.status === 1;
-            const isWaitingForApproval = agentData.status === "waitingForApproval" ||
-                agentData.status === 2;
-            const isCostLimitReached = agentData.status === "costLimitReached" ||
-                agentData.status === 7;
-            // NOTE: SSE reconnection logic removed - no longer needed with WebSocket
-            // The WebSocket subscription (in the useEffect below) handles reconnection automatically
-            // Just set the streaming state if agent is running
-            if (isRunning && isActive) {
-                shouldCreateNewMessage.current = false;
-                // State will be set by the WebSocket subscription useEffect
-            }
+            setAgentMetadata(sanitizeAgentMetadata(parsedMeta));
         }
         catch (err) {
             console.error("❌ Failed to load agent:", err);
@@ -1886,6 +1449,37 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             loadAgent();
         }
     }, [isActive, agent?.id, loadAgent]);
+    // Watch for cost limit exceeded based on agent status or cost values
+    useEffect(() => {
+        if (!agent) {
+            setCostLimitExceeded(null);
+            return;
+        }
+        // Check if cost limit exceeded based on status or cost values
+        const statusIndicatesLimit = agent.status === "costLimitReached" || agent.status === 7;
+        const costExceedsLimit = agent.costLimit && agent.totalCost && agent.totalCost > agent.costLimit;
+        if (statusIndicatesLimit || costExceedsLimit) {
+            // Only set if not already set to avoid unnecessary re-renders
+            setCostLimitExceeded((prev) => {
+                const totalCost = agent.totalCost || 0;
+                const costLimit = agent.costLimit || 0;
+                // Check if values actually changed
+                if (prev?.totalCost === totalCost && prev?.costLimit === costLimit) {
+                    return prev;
+                }
+                console.log(`[AgentTerminal] Cost limit exceeded detected: $${totalCost.toFixed(4)} / $${costLimit.toFixed(4)}`);
+                return {
+                    totalCost,
+                    costLimit,
+                    initialCostLimit: costLimit,
+                };
+            });
+        }
+        else {
+            // Clear cost limit exceeded if status changed back
+            setCostLimitExceeded((prev) => (prev ? null : prev));
+        }
+    }, [agent?.status, agent?.totalCost, agent?.costLimit]);
     // WebSocket message handler for agent streaming
     const handleAgentWebSocketMessage = useCallback((message) => {
         if (!agent)
@@ -1966,7 +1560,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         }
         // Handle agent:run:delta (content, tools, etc.)
         if (messageType === "agent:run:delta") {
-            const { seq, type, data } = message.payload;
+            const { seq, type, data, cost } = message.payload;
             // Deduplicate by sequence
             if (seq && seq <= lastSeqRef.current) {
                 return; // Already processed
@@ -1978,6 +1572,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             const agentStreamMessage = {
                 type,
                 data,
+                cost,
                 timestamp: new Date().toISOString(),
             };
             if (type === "ContentChunk" || type === "contentChunk") {
@@ -1991,9 +1586,9 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             }
             return;
         }
-        // Handle agent:run:status
+        // Unified: agent:run:status (state only)
         if (messageType === "agent:run:status") {
-            const { seq, kind, data: statusData } = message.payload;
+            const { seq, data: statusData } = message.payload;
             // Deduplicate by sequence
             if (seq && seq <= lastSeqRef.current) {
                 return;
@@ -2001,16 +1596,28 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             if (seq) {
                 lastSeqRef.current = seq;
             }
-            // Route based on status kind
+            // Route based on statusData.state
             try {
-                if (kind === "streamOpen") {
+                if (statusData?.state === "streamOpen") {
                     setIsConnecting(false);
                     return;
                 }
-                if (kind === "tokenUsage") {
+                if (statusData?.state === "tokenUsage") {
                     const totals = statusData?.totals;
                     if (totals) {
                         const totalCost = Number(totals.totalCost) || 0;
+                        const statusCostLimit = (() => {
+                            try {
+                                const v = statusData?.costLimit;
+                                const n = v != null ? Number(v) : undefined;
+                                return Number.isFinite(n) && n > 0
+                                    ? n
+                                    : undefined;
+                            }
+                            catch {
+                                return undefined;
+                            }
+                        })();
                         const nextTotals = {
                             input: Number(totals.totalInputTokens) || 0,
                             output: Number(totals.totalOutputTokens) || 0,
@@ -2031,6 +1638,13 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                         if (anyNonZero) {
                             setLiveTotals(nextTotals);
                         }
+                        // If server provides costLimit along with totals, persist it locally
+                        if (statusCostLimit) {
+                            setAgent((prev) => prev &&
+                                (!prev.costLimit || prev.costLimit !== statusCostLimit)
+                                ? { ...prev, costLimit: statusCostLimit }
+                                : prev);
+                        }
                         if (agent?.costLimit && totalCost > agent.costLimit) {
                             setCostLimitExceeded({
                                 totalCost: totalCost,
@@ -2044,7 +1658,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                     }
                     return;
                 }
-                if (kind === "toolApprovalsRequired") {
+                if (statusData?.state === "ToolApprovalsRequired") {
                     const msgId = statusData.messageId;
                     const ids = statusData.toolCallIds || [];
                     if (msgId && Array.isArray(ids) && ids.length > 0) {
@@ -2074,7 +1688,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                     setIsWaitingForResponse(false);
                     return;
                 }
-                if (kind === "cost_limit_reached") {
+                if (statusData?.state === "CostLimitReached") {
                     const totalCost = Number(statusData.totalCost) || 0;
                     const costLimit = Number(statusData.costLimit) || agent?.costLimit || 0;
                     setCostLimitExceeded({
@@ -2086,7 +1700,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                     setIsConnecting(false);
                     return;
                 }
-                if (kind === "contextWindow") {
+                if (statusData?.state === "contextWindow") {
                     window.__agentContextWindowStatus = {
                         model: statusData.model,
                         normalizedModel: statusData.normalizedModel,
@@ -2099,7 +1713,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                     setMessages((prev) => [...prev]);
                     return;
                 }
-                if (kind === "contextChanged") {
+                if (statusData?.state === "contextChanged") {
                     const nextContext = statusData.context || {};
                     setAgentMetadata((prev) => {
                         const current = (prev || {});
@@ -2122,7 +1736,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             }
             return;
         }
-        // Handle agent:run:complete
+        // Lifecycle: agent:run:complete
         if (messageType === "agent:run:complete") {
             console.log("[AgentTerminal] Agent run completed via WebSocket:", agentId);
             // Reset deduplication for the next run
@@ -2146,7 +1760,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             resetDotsTimer();
             return;
         }
-        // Handle agent:run:error
+        // Lifecycle: agent:run:error
         if (messageType === "agent:run:error") {
             const errorMsg = message.payload?.error || "Unknown error";
             console.error("[AgentTerminal] Agent run error via WebSocket:", errorMsg);
@@ -2159,6 +1773,20 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             resetDotsTimer();
             return;
         }
+        // Backward-compat: map agent:status:changed to unified status event
+        if (messageType === "agent:status:changed") {
+            try {
+                const { agentId: aid, status } = message.payload || {};
+                if (!aid || aid !== agentId)
+                    return;
+                // Treat as unified statusChanged kind
+                setAgent((prev) => (prev ? { ...prev, status } : prev));
+            }
+            catch (err) {
+                console.error("[AgentTerminal] Error handling legacy agent:status:changed:", err);
+            }
+            return;
+        }
     }, [
         agent,
         handleContentChunk,
@@ -2257,33 +1885,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             subscribedAgentIdRef.current = null;
         };
     }, [isActive, agentStub.id, editContext?.addSocketMessageListener]);
-    // Handle stream connection when agent becomes active/inactive
-    // NOTE: SSE connection disabled - now using WebSocket exclusively
-    // Keeping this code commented for easy rollback if needed
-    /*
-    useEffect(() => {
-      if (!agent) return;
-  
-      const isRunning = agent.status === "running" || (agent.status as any) === 1;
-      const isWaitingForApproval =
-        agent.status === "waitingForApproval" || (agent.status as any) === 2;
-      const isCostLimitReached =
-        agent.status === "costLimitReached" || (agent.status as any) === 7;
-  
-      const shouldBeConnected =
-        isRunning || isWaitingForApproval || isCostLimitReached;
-  
-      if (isActive && shouldBeConnected && !abortControllerRef.current) {
-        // Agent became active and should be connected - connect to stream
-        connectToStream();
-      } else if (!isActive && abortControllerRef.current) {
-        // Agent became inactive - disconnect from stream
-        abortControllerRef.current.abort();
-        abortControllerRef.current = null;
-        setIsConnecting(false);
-      }
-    }, [isActive, agent?.status, connectToStream]);
-    */
     // Focus prompt when requested globally (from AI command)
     useEffect(() => {
         const focusHandler = () => {
@@ -2361,30 +1962,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         }
         catch { }
     }, [agentMetadata, agent?.mode]);
-    const updateMode = useCallback(async (nextMode) => {
-        setMode(nextMode);
-        const current = agentMetadata || {};
-        const nextMeta = {
-            ...current,
-            mode: nextMode,
-        };
-        try {
-            if (!agent?.id) {
-                setAgentMetadata(nextMeta);
-                return;
-            }
-            if (agent.status === "new") {
-                setAgentMetadata(nextMeta);
-                return;
-            }
-            await updateAgentContext(agent.id, nextMeta);
-            setAgentMetadata(nextMeta);
-            setAgent((prev) => prev ? { ...prev, metadata: JSON.stringify(nextMeta) } : prev);
-        }
-        catch (e) {
-            console.error("Failed to persist mode change", e);
-        }
-    }, [agent?.id, agent?.status, agentMetadata]);
     // Auto-scroll when messages change (only if user hasn't manually scrolled up)
     useLayoutEffect(() => {
         if (shouldAutoScroll) {
@@ -2578,8 +2155,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             const selectionFromCtx = metaCtx?.componentIds?.length
                 ? metaCtx.componentIds
                 : undefined;
-            const effectiveSelection = selectionFromCtx;
-            const selectedTextFromCtx = metaCtx?.comment?.selectedText || undefined;
             const request = {
                 agentId: agent.id,
                 message: text.trim(),
@@ -2838,118 +2413,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             console.error("Failed to update agent metadata (add items/pages)", e);
         }
     };
-    const handleContextDragOver = (e) => {
-        e.preventDefault();
-        e.dataTransfer.dropEffect = "copy";
-        if (!isContextDragOver)
-            setIsContextDragOver(true);
-    };
-    const handleContextDragLeave = () => {
-        setIsContextDragOver(false);
-    };
-    const handleContextDrop = async (e) => {
-        e.preventDefault();
-        setIsContextDragOver(false);
-        try {
-            const dragObj = editContext?.dragObject;
-            if (dragObj?.type === "component") {
-                const idsFromComponents = (dragObj.components || [])
-                    .map((c) => c.id)
-                    .filter((x) => !!x);
-                const idFromData = e.dataTransfer.getData("componentId");
-                const allIds = Array.from(new Set([...idsFromComponents, idFromData].filter((x) => !!x)));
-                if (allIds.length) {
-                    await addComponentIdsToContext(allIds);
-                    if (isContextCollapsed)
-                        setIsContextCollapsed(false);
-                    return;
-                }
-            }
-            if (dragObj?.type === "items" && dragObj.items?.length) {
-                await addPagesToContextFromItems(dragObj.items);
-                if (isContextCollapsed)
-                    setIsContextCollapsed(false);
-                return;
-            }
-            // Fallback: try to parse JSON payload for items/components if provided
-            try {
-                const textData = e.dataTransfer.getData("text/plain");
-                if (textData) {
-                    const parsed = JSON.parse(textData);
-                    if (Array.isArray(parsed)) {
-                        await addPagesToContextFromItems(parsed);
-                        if (isContextCollapsed)
-                            setIsContextCollapsed(false);
-                        return;
-                    }
-                    else if (parsed?.id) {
-                        await addPagesToContextFromItems([parsed]);
-                        if (isContextCollapsed)
-                            setIsContextCollapsed(false);
-                        return;
-                    }
-                }
-            }
-            catch { }
-        }
-        catch (err) {
-            console.error("Context drop failed", err);
-        }
-    };
-    const addCommentToContext = async (comment) => {
-        if (!agent?.id)
-            return;
-        const selectedText = (() => {
-            if (typeof comment.rangeStart === "number" &&
-                typeof comment.rangeEnd === "number" &&
-                comment.fieldValue) {
-                try {
-                    return comment.fieldValue.substring(Math.max(0, comment.rangeStart), Math.max(comment.rangeStart, comment.rangeEnd));
-                }
-                catch {
-                    return undefined;
-                }
-            }
-            return undefined;
-        })();
-        const current = agentMetadata || {};
-        // Exclude top-level context to avoid duplicate keys when spreading
-        const currentWithoutContext = { ...current };
-        delete currentWithoutContext.context;
-        const next = {
-            ...currentWithoutContext,
-            additionalData: {
-                ...(current.additionalData || {}),
-                context: {
-                    ...((current.additionalData &&
-                        current.additionalData.context) ||
-                        {}),
-                    comment: {
-                        id: comment.id,
-                        text: comment.text,
-                        fieldName: comment.fieldName,
-                        itemName: comment.itemName,
-                        author: comment.author,
-                        selectedText,
-                        rangeStart: comment.rangeStart,
-                        rangeEnd: comment.rangeEnd,
-                    },
-                },
-            },
-        };
-        try {
-            if (agent.status === "new") {
-                setAgentMetadata(next);
-                return;
-            }
-            await updateAgentContext(agent.id, next);
-            setAgentMetadata(next);
-            setAgent((prev) => prev ? { ...prev, metadata: JSON.stringify(next) } : prev);
-        }
-        catch (e) {
-            console.error("Failed to update agent metadata (add comment)", e);
-        }
-    };
     // Resolve display names when metadata or editor state changes
     useEffect(() => {
         const metaCtx = agentMetadata?.additionalData?.context;
@@ -3064,12 +2527,23 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             console.error("Failed to stop agent execution", e);
         }
     }, [agentStub?.id, resetDotsTimer]);
-    // Waiting state is explicitly managed by stream events:
-    // - Cleared when first content arrives
-    // - Cleared on stream completion
-    // - Cleared on errors
-    // - Cleared when stopped by user
-    // No need for an automatic cleanup effect that can fire prematurely
+    // Determine effective cost limit from agent, profile, or metadata so the cost display
+    // is visible immediately even before any messages or server-side persistence.
+    const effectiveCostLimit = useMemo(() => {
+        try {
+            const candidates = [
+                agent?.costLimit,
+                activeProfile?.costLimit,
+            ];
+            for (const c of candidates) {
+                const n = c != null ? Number(c) : 0;
+                if (Number.isFinite(n) && n > 0)
+                    return n;
+            }
+        }
+        catch { }
+        return undefined;
+    }, [agent?.costLimit, activeProfile?.costLimit]);
     if (isLoading) {
         return (_jsx("div", { className: "flex h-full items-center justify-center", children: _jsxs("div", { className: "flex items-center gap-2 text-xs text-gray-500", children: [_jsx(Loader2, { className: "h-4 w-4 animate-spin", strokeWidth: 1 }), "Loading agent..."] }) }));
     }
@@ -3295,7 +2769,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                                         cacheWriteCost: liveTotals.cacheWriteCost ?? 0,
                                         totalCost: liveTotals.totalCost,
                                     }
-                                    : totalTokens, costLimit: agent?.costLimit }), (() => {
+                                    : totalTokens, costLimit: effectiveCostLimit }), (() => {
                                 try {
                                     const s = window.__agentContextWindowStatus;
                                     if (!s || !s.contextWindowTokens)