@emblemvault/hustle-react 1.3.0 → 1.4.1

package/dist/index.js

@@ -2006,7 +2006,7 @@ var screenshotExecutor = async (args2) => {
     if (!window.html2canvas) {
       await new Promise((resolve, reject) => {
         const script = document.createElement("script");
-        script.src = "https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js";
+        script.src = "https://cdn.jsdelivr.net/npm/html2canvas-pro@1.5.0/dist/html2canvas-pro.min.js";
         script.onload = () => resolve();
         script.onerror = () => reject(new Error("Failed to load html2canvas"));
         document.head.appendChild(script);
@@ -3715,7 +3715,11 @@ var styles = {
     border: "none",
     borderRadius: 0,
     color: tokens.colors.textTertiary,
-    flexShrink: 0
+    flexShrink: 0,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    cursor: "pointer"
   },
   inputWrapper: {
     flex: 1
@@ -3937,6 +3941,7 @@ function HustleChat({
     isLoading,
     error: error2,
     models,
+    client,
     chatStream,
     uploadFile,
     selectedModel,
@@ -3963,6 +3968,8 @@ function HustleChat({
   const [showSettingsPanel, setShowSettingsPanel] = useState(false);
   const messagesEndRef = useRef(null);
   const fileInputRef = useRef(null);
+  const messagesRef = useRef(messages);
+  const pendingAutoContinueRef = useRef(false);
   useEffect(() => {
     if (initialSystemPrompt && !systemPrompt) {
       setSystemPrompt(initialSystemPrompt);
@@ -3971,6 +3978,9 @@ function HustleChat({
   useEffect(() => {
     messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
   }, [messages]);
+  useEffect(() => {
+    messagesRef.current = messages;
+  }, [messages]);
   const handleFileSelect = useCallback(
     async (e) => {
       const files = e.target.files;
@@ -3992,6 +4002,101 @@ function HustleChat({
   const removeAttachment = useCallback((index) => {
     setAttachments((prev) => prev.filter((_, i) => i !== index));
   }, []);
+  const sendContinue = useCallback(async () => {
+    if (isStreaming || !isReady) return;
+    console.log("[AUTO_CONTINUE] Sending continue message...");
+    const userMessage = {
+      id: generateId(),
+      role: "user",
+      content: "continue"
+    };
+    setMessages((prev) => [...prev, userMessage]);
+    onMessage?.(userMessage);
+    const assistantMessage = {
+      id: generateId(),
+      role: "assistant",
+      content: "",
+      isStreaming: true,
+      toolCalls: []
+    };
+    setMessages((prev) => [...prev, assistantMessage]);
+    setIsStreaming(true);
+    setCurrentToolCalls([]);
+    try {
+      const chatMessages = messagesRef.current.filter((m) => !m.isStreaming).map((m) => ({ role: m.role, content: m.content }));
+      chatMessages.push({ role: "user", content: "continue" });
+      const stream = chatStream({
+        messages: chatMessages,
+        processChunks: true
+      });
+      let fullContent = "";
+      const toolCallsAccumulated = [];
+      for await (const chunk of stream) {
+        if (chunk.type === "text") {
+          fullContent += chunk.value;
+          setMessages(
+            (prev) => prev.map(
+              (m) => m.id === assistantMessage.id ? { ...m, content: fullContent } : m
+            )
+          );
+        } else if (chunk.type === "tool_call") {
+          const toolCall = chunk.value;
+          toolCallsAccumulated.push(toolCall);
+          setCurrentToolCalls([...toolCallsAccumulated]);
+          setMessages(
+            (prev) => prev.map(
+              (m) => m.id === assistantMessage.id ? { ...m, toolCalls: [...toolCallsAccumulated] } : m
+            )
+          );
+          onToolCall?.(toolCall);
+        } else if (chunk.type === "error") {
+          console.error("Stream error:", chunk.value);
+        }
+      }
+      const processedResponse = await stream.response;
+      const finalContent = processedResponse?.content || fullContent || "(No response)";
+      setMessages(
+        (prev) => prev.map(
+          (m) => m.id === assistantMessage.id ? { ...m, isStreaming: false, content: finalContent } : m
+        )
+      );
+      onResponse?.(finalContent);
+    } catch (err) {
+      console.error("Continue error:", err);
+      setMessages(
+        (prev) => prev.map(
+          (m) => m.id === assistantMessage.id ? { ...m, isStreaming: false, content: `Error: ${err instanceof Error ? err.message : "Unknown error"}` } : m
+        )
+      );
+    } finally {
+      setIsStreaming(false);
+      setCurrentToolCalls([]);
+    }
+  }, [isStreaming, isReady, chatStream, onMessage, onToolCall, onResponse]);
+  useEffect(() => {
+    if (!client) return;
+    const unsubMaxTools = client.on("max_tools_reached", (event) => {
+      console.log(`[AUTO_CONTINUE] Max tools reached (${event.toolsExecuted}/${event.maxSteps}), queuing auto-continue...`);
+      pendingAutoContinueRef.current = true;
+    });
+    const unsubTimeout = client.on("timeout", (event) => {
+      console.log(`[AUTO_CONTINUE] Timeout: ${event.message}, queuing auto-continue...`);
+      pendingAutoContinueRef.current = true;
+    });
+    return () => {
+      unsubMaxTools();
+      unsubTimeout();
+    };
+  }, [client]);
+  useEffect(() => {
+    if (!isStreaming && pendingAutoContinueRef.current && isReady) {
+      console.log("[AUTO_CONTINUE] Streaming ended, triggering continue...");
+      pendingAutoContinueRef.current = false;
+      setTimeout(() => {
+        sendContinue();
+      }, 50);
+    }
+  }, [isStreaming, isReady, sendContinue]);
   const sendMessage = useCallback(async () => {
     const content = inputValue.trim();
     if (!content || isStreaming || !isReady) return;