@emblemvault/hustle-react 1.3.0 → 1.4.1

package/dist/browser/hustle-react.js

@@ -1,3 +1,4 @@
+'use client';
 import { createContext, useState, useEffect, useCallback, useRef, useMemo, useContext } from 'react';
 import { HustleIncognitoClient } from 'hustle-incognito';
 import { useEmblemAuthOptional } from '@emblemvault/emblem-auth-react';
@@ -3547,7 +3548,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);
@@ -14870,7 +14871,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
@@ -15092,6 +15097,7 @@ function HustleChat({
     isLoading,
     error: error2,
     models,
+    client,
     chatStream,
     uploadFile,
     selectedModel,
@@ -15118,6 +15124,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);
@@ -15126,6 +15134,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;
@@ -15147,6 +15158,101 @@ function HustleChat({
   const removeAttachment = useCallback((index) => {
     setAttachments((prev) => prev.filter((_2, 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((m2) => !m2.isStreaming).map((m2) => ({ role: m2.role, content: m2.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(
+              (m2) => m2.id === assistantMessage.id ? { ...m2, content: fullContent } : m2
+            )
+          );
+        } else if (chunk.type === "tool_call") {
+          const toolCall = chunk.value;
+          toolCallsAccumulated.push(toolCall);
+          setCurrentToolCalls([...toolCallsAccumulated]);
+          setMessages(
+            (prev) => prev.map(
+              (m2) => m2.id === assistantMessage.id ? { ...m2, toolCalls: [...toolCallsAccumulated] } : m2
+            )
+          );
+          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(
+          (m2) => m2.id === assistantMessage.id ? { ...m2, isStreaming: false, content: finalContent } : m2
+        )
+      );
+      onResponse?.(finalContent);
+    } catch (err) {
+      console.error("Continue error:", err);
+      setMessages(
+        (prev) => prev.map(
+          (m2) => m2.id === assistantMessage.id ? { ...m2, isStreaming: false, content: `Error: ${err instanceof Error ? err.message : "Unknown error"}` } : m2
+        )
+      );
+    } 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;