Fixed auto approver and inference continuation

sia/auto_approver.py

@@ -178,7 +178,5 @@ class AutoApprover:
     def _response_approval_thread(self) -> None:
         if self._stop_event.wait(self._response_timeout):
             return
-        if (self._response_enabled and 
+        if self._response_enabled:
-            self.agent.llms[self._llm_name] == LlmState.IDLE):
-            response = self.agent.response_buffer.get_text()
             self.agent.approve_response()

sia/llm_engine/hf_llm_engine.py

@@ -30,13 +30,14 @@ class HfLlmEngine(LlmEngine):
         self._config = AutoConfig.from_pretrained(model, token=api_token)
         self._client = InferenceClient(token=api_token)
                         
-    def infer(self, system_prompt: str, main_context: str, should_stop: Callable[[], bool] = lambda: False) -> Iterator[str]:
+    def infer(self, system_prompt: str, main_context: str, continuation_text: str, should_stop: Callable[[], bool] = lambda: False) -> Iterator[str]:
         """
         Run inference using the system prompt and main context.
 
         Args:
             system_prompt: The system prompt string
             main_context: The main context string after templating
+            continuation_text: Part of the response that is already generated
             should_stop: Callback that returns True when inference should stop
 
         Returns:
@@ -44,13 +45,15 @@ class HfLlmEngine(LlmEngine):
         """
         messages = [
             {"role": "system", "content": system_prompt},
-            {"role": "user", "content": main_context}
+            {"role": "user", "content": main_context},
+            {"role": "assistant", "content": continuation_text},
         ]
         
         stream = self._client.chat_completion(
             model=self._model,
             messages=messages,
             temperature=self._temperature,
+            add_generation_prompt=False,
             stream=True
         )
         

sia/llm_engine/local_llm_engine.py

@@ -63,6 +63,7 @@ class LocalLlmEngine(LlmEngine):
         Args:
             system_prompt: The system prompt string
             main_context: The main context string after templating
+            continuation_text: Part of the response that is already generated
             should_stop: Callback that returns True when inference should stop
 
         Returns:

sia/llm_engine/openai_llm_engine.py

@@ -34,7 +34,9 @@ class OpenAILlmEngine(LlmEngine):
             api_key=api_key,
         )
                         
-    def infer(self, system_prompt: str, main_context: str, should_stop: Callable[[], bool] = lambda: False) -> Iterator[str]:
+    def infer(self, system_prompt: str, main_context: str, continuation_text: str, should_stop: Callable[[], bool] = lambda: False) -> Iterator[str]:
+        if continuation_text:
+            print("OpenAI LLM Engine: continuation_text is not supported")
         messages = [
             {"role": "system", "content": system_prompt},
             {"role": "user", "content": main_context}

sia/llm_engine/qwq_llm_engine.py

@@ -70,6 +70,7 @@ class QwQLlmEngine(LlmEngine):
         Args:
             system_prompt: The system prompt string
             main_context: The main context string after templating
+            continuation_text: Part of the response that is already generated
             should_stop: Callback that returns True when inference should stop
 
         Returns:

sia/web/api.py

@@ -59,20 +59,25 @@ class Api:
 
     async def _run_inference(self, request: web.Request) -> web.Response:
         """Start inference on specified LLM."""
-        llm_name = request.match_info["llm"]
         try:
+            llm_name = request.match_info["llm"]
+            data = await request.json()
+            text = data.get("response")
+            context = data.get("context")
+            self._agent._response_buffer.set_text(text)
+            self._agent.modify_context(context)
             await asyncio.get_event_loop().run_in_executor(None, self._agent.run_inference, llm_name)
             return web.Response(status=200)
-        except (ValueError, RuntimeError) as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _stop_inference(self, request: web.Request) -> web.Response:
         """Stop inference on specified LLM."""
-        llm_name = request.match_info["llm"]
         try:
+            llm_name = request.match_info["llm"]
             self._agent.stop_inference(llm_name)
             return web.Response(status=200)
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _set_response(self, request: web.Request) -> web.Response:
@@ -80,15 +85,10 @@ class Api:
         try:
             data = await request.json()
             text = data.get("response")
-            if text is None:
+            self._agent._response_buffer.set_text(text)
-                return web.Response(status=400, text="Missing response text in request body")
+            return web.Response(status=200)
-            try:
+        except Exception as e:
-                self._agent._response_buffer.set_text(text)
+            return web.Response(status=400, text=str(e))
-                return web.Response(status=200)
-            except ValueError as e:
-                return web.Response(status=400, text=str(e))
-        except json.JSONDecodeError:
-            return web.Response(status=400, text="Invalid JSON in request body")
 
     async def _approve_response(self, request: web.Request) -> web.Response:
         """Approve current buffer content"""
@@ -98,35 +98,37 @@ class Api:
             self._agent.response_buffer.set_text(response)
             self._agent.approve_response()
             return web.Response(status=200)
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _get_response(self, request: web.Request) -> web.Response:
         """Get current buffer content"""
         return web.Response(
             text=json.dumps({
-                "response": self._agent.output_buffer.get_text(),
+                "response": self._agent.response_buffer.get_text(),
             }),
             content_type="application/json"
         )
 
     async def _modify_context(self, request: web.Request) -> web.Response:
         """Modify the current context."""
-        data = await request.json()
+        try:
-        context = data.get("context")
+            data = await request.json()
-        if not context:
+            context = data.get("context")
-            return web.Response(status=400, text="Missing context in request body")
+            self._agent.modify_context(context)
-        self._agent.modify_context(context)
+            return web.Response(status=200)
-        return web.Response(status=200)
+        except Exception as e:
+            return web.Response(status=400, text=str(e))
 
     async def _send_input(self, request: web.Request) -> web.Response:
         """Send input to the IO buffer."""
-        data = await request.json()
+        try:
-        input_text = data.get("input")
+            data = await request.json()
-        if not input_text:
+            input_text = data.get("input")
-            return web.Response(status=400, text="Missing input in request body")
+            self._io_buffer.append_stdin(input_text)
-        self._io_buffer.append_stdin(input_text)
+            return web.Response(status=200)
-        return web.Response(status=200)
+        except Exception as e:
+            return web.Response(status=400, text=str(e))
 
     async def _clear_output(self, request: web.Request) -> web.Response:
         """Clear the stdout buffer."""
@@ -135,14 +137,14 @@ class Api:
 
     async def _get_output(self, request: web.Request) -> web.Response:
         """Get complete output for specified LLM."""
-        llm_name = request.match_info["llm"]
         try:
+            llm_name = request.match_info["llm"]
             output = self._agent.get_output(llm_name)
             return web.Response(
                 text=json.dumps({"output": output}),
                 content_type="application/json"
             )
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _get_llms(self, request: web.Request) -> web.Response:
@@ -165,71 +167,68 @@ class Api:
 
     async def _set_auto_approver_config(self, request: web.Request) -> web.Response:
         """Update auto approver configuration."""
-        data = await request.json()
         try:
+            data = await request.json()
             self._auto_approver.set_config(data)
             return web.Response(status=200)
-        except (ValueError, KeyError) as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _set_context_enabled(self, request: web.Request) -> web.Response:
         """Set context auto-approval enabled state."""
-        data = await request.json()
-        enabled = data.get("enabled")
-        if enabled is None:
-            return web.Response(status=400, text="Missing enabled parameter")
         try:
-            self._auto_approver.context_enabled = enabled
+            data = await request.json()
+            enabled = data.get("enabled")
+            self._auto_approver.context_enabled = enabled or False
             return web.Response(status=200)
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _set_response_enabled(self, request: web.Request) -> web.Response:
         """Set response auto-approval enabled state."""
-        data = await request.json()
-        enabled = data.get("enabled")
-        if enabled is None:
-            return web.Response(status=400, text="Missing enabled parameter")
         try:
-            self._auto_approver.response_enabled = enabled
+            data = await request.json()
+            enabled = data.get("enabled")
+            self._auto_approver.response_enabled = enabled or False
             return web.Response(status=200)
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _set_context_timeout(self, request: web.Request) -> web.Response:
         """Set context auto-approval timeout."""
-        data = await request.json()
-        timeout = data.get("timeout")
-        if timeout is None:
-            return web.Response(status=400, text="Missing timeout parameter")
         try:
+            data = await request.json()
+            timeout = data.get("timeout")
+            if timeout is None:
+                return web.Response(status=400, text="Missing timeout parameter")
             self._auto_approver.context_timeout = float(timeout)
             return web.Response(status=200)
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
  
+
     async def _set_response_timeout(self, request: web.Request) -> web.Response:
         """Set response auto-approval timeout."""
-        data = await request.json()
-        timeout = data.get("timeout")
-        if timeout is None:
-            return web.Response(status=400, text="Missing timeout parameter")
         try:
+            data = await request.json()
+            timeout = data.get("timeout")
+            if timeout is None:
+                return web.Response(status=400, text="Missing timeout parameter")
             self._auto_approver.response_timeout = float(timeout)
             return web.Response(status=200)
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _set_llm_name(self, request: web.Request) -> web.Response:
         """Set LLM name for auto-approval."""
-        data = await request.json()
-        name = data.get("name")
-        if name is None:
-            return web.Response(status=400, text="Missing name parameter")
         try:
+            data = await request.json()
+            name = data.get("name")
+            if name is None:
+                return web.Response(status=400, text="Missing name parameter")
             self._auto_approver.llm_name = name
             return web.Response(status=200)
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _get_memory(self, request: web.Request) -> web.Response:
@@ -244,29 +243,29 @@ class Api:
         )
     async def _create_entry(self, request: web.Request) -> web.Response:
         """Create a new entry in working memory."""
-        data = await request.json()
         try:
+            data = await request.json()
             entry = EntryFactory.create_entry(data, self._work_dir, self._io_buffer)
             self._working_memory.add_entry(entry)
             return web.Response(
                 text=json.dumps({"id": entry.id}),
                 content_type="application/json"
             )
-        except (ValueError, TypeError) as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _save_entry(self, request: web.Request) -> web.Response:
         """Update properties of an existing entry."""
-        entry_id = request.match_info["id"]
-        data = await request.json()
-        entry = self._working_memory.get_entry(entry_id)
-        if not entry:
-            return web.Response(status=404, text="Entry not found")
         try:
+            entry_id = request.match_info["id"]
+            data = await request.json()
+            entry = self._working_memory.get_entry(entry_id)
+            if not entry:
+                return web.Response(status=404, text="Entry not found")
             EntryFactory.update_entry(entry, data)
             entry.notify_change()
             return web.Response(status=200)
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _delete_entry(self, request: web.Request) -> web.Response:
@@ -286,27 +285,30 @@ class Api:
     
     async def _update_entry(self, request: web.Request) -> web.Response:
         """Update an entry's state."""
-        entry_id = request.match_info["id"]
-        entry = self._working_memory.get_entry(entry_id)
-        if not entry:
-            return web.Response(status=404, text="Entry not found")
         try:
+            entry_id = request.match_info["id"]
+            entry = self._working_memory.get_entry(entry_id)
+            if not entry:
+                return web.Response(status=404, text="Entry not found")
             entry.update()
             entry.notify_change()
             return web.Response(status=200)
-        except ValueError as e:
+        except Exception as e:
             return web.Response(status=400, text=str(e))
 
     async def _load_iteration(self, request: web.Request) -> web.Response:
         """Load entries from iteration XML content into working memory"""
-        data = await request.json()
+        try:
-        content = data.get("content")
+            data = await request.json()
-        if not content:
+            content = data.get("content")
-            return web.Response(status=400, text="Missing content in request body")
+            if not content:
+                return web.Response(status=400, text="Missing content in request body")
                 
-        entries = IterationParser.parse_iteration(content, self._work_dir, self._io_buffer)
+            entries = IterationParser.parse_iteration(content, self._work_dir, self._io_buffer)
             
-        for entry in entries:
+            for entry in entries:
-            self._working_memory.add_entry(entry)
+                self._working_memory.add_entry(entry)
                 
-        return web.Response(status=200)
+            return web.Response(status=200)
+        except Exception as e:
+            return web.Response(status=400, text=str(e))

sia/web_agent.py

@@ -97,10 +97,6 @@ class WebAgent(BaseAgent):
         """Update context and reset all LLM states"""
         with self._llm_lock:
             self._context = context
-            self._response_buffer.clear()
-            for llm_name in self._llms:
-                self._set_llm_state(llm_name, LlmState.IDLE)
-            
             for handler in self._context_change_handlers:
                 handler(context, generated)
 
@@ -118,7 +114,6 @@ class WebAgent(BaseAgent):
             return self._stop_flags[llm_name]
         response_token_iter = llm.infer(self.system_prompt, self.context, self._response_buffer.get_text(), should_stop)
         for token in response_token_iter:
-            print(token, end='', flush=True)
             with self._output_lock:
                 self._response_buffer.append_text(token)
         with self._llm_lock:
@@ -132,11 +127,10 @@ class WebAgent(BaseAgent):
 
     def approve_response(self) -> None:
         """Process approved response from specified LLM"""
-        if self.llms.get(llm_name) != LlmState.IDLE:
-            return
         timestamp = datetime.now(timezone.utc)
         self._iteration_logger.log_iteration(timestamp, self._context, self._response_buffer.get_text())
         parse_result = self._parser.parse(timestamp, self._response_buffer.get_text())
+        self._response_buffer.clear()
         if isinstance(parse_result, Command):
             result = parse_result.execute(self._working_memory)
             self._command_result = result

web/src/components/App.jsx

@@ -16,7 +16,6 @@ const App = () => {
   // Editor content state
   const [generatedContext, setGeneratedContext] = useState('');
   const [modifiedContext, setModifiedContext] = useState('');
-  const [contextDirty, setContextDirty] = useState(false);
   const [generatedResponse, setGeneratedResponse] = useState('');
   const [modifiedResponse, setModifiedResponse] = useState('');
   const [input, setInput] = useState('');
@@ -65,7 +64,6 @@ const App = () => {
   // Handle context changes
   useEffect(() => {
     contextWs.addMessageHandler((data) => {
-      setContextDirty(false);
       setModifiedContext(data.context);
       if (data.generated) {
         setGeneratedContext(data.context);
@@ -127,20 +125,13 @@ const App = () => {
   };
 
   const handleInference = () => {
-    fetch('/api/context', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ context: modifiedContext })
-    });
-
-    fetch('/api/response', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ response: modifiedResponse })
-    });
-    
     fetch(`/api/inference/${activeLlm}`, {
       method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        response: modifiedResponse,
+        context: modifiedContext,
+      })
     });
   };
 
@@ -176,10 +167,6 @@ const App = () => {
     }    
     setLlms(resetLlms);
     setModifiedContext(context);
-    
-    // Reset response buffers
-    setGeneratedResponse('');
-    setModifiedResponse('');
   };
 
   const handleResponseEdit = (response) => {

web/src/components/editors/StandardEditor.jsx

@@ -4,58 +4,58 @@ import { Card, CardContent } from '@/components/ui/card';
 import { Alert, AlertDescription } from '@/components/ui/alert';
 
 export const StandardEditor = ({
- content,
+  content,
- onChange,
+  onChange,
- readOnly = false,
+  readOnly = false,
- language = 'xml',
+  language = 'xml',
- validationError = null,
+  validationError = null,
- autoScroll = false,
+  autoScroll = false,
 }) => {
- const editorRef = React.useRef(null);
+  const editorRef = React.useRef(null);
 
- const scrollToBottom = () => {
+  const scrollToBottom = () => {
-   if (editorRef.current && autoScroll) {
+    if (editorRef.current && autoScroll) {
-     const model = editorRef.current.getModel();
+      const model = editorRef.current.getModel();
-     const lineCount = model.getLineCount();
+      const lineCount = model.getLineCount();
-     editorRef.current.revealLine(lineCount, monaco.editor.ScrollType.Smooth);
+      editorRef.current.revealLine(lineCount, monaco.editor.ScrollType.Smooth);
-   }
+    }
- };
+  };
 
- const handleEditorDidMount = (editor) => {
+  const handleEditorDidMount = (editor) => {
-   editorRef.current = editor;
+    editorRef.current = editor;
-   setTimeout(() => {
+    setTimeout(() => {
-     scrollToBottom();
+      scrollToBottom();
-   }, 10);
+    }, 10);
- };
+  };
 
- React.useEffect(() => {
+  React.useEffect(() => {
-   scrollToBottom();
+    scrollToBottom();
- }, [content, autoScroll]);
+  }, [content, autoScroll]);
 
- return (
+  return (
-   <Card className="h-[calc(100vh-8rem)]">
+    <Card className="h-[calc(100vh-8rem)]">
-     <CardContent className="p-0 h-full">
+      <CardContent className="p-0 h-full">
-       {validationError && (
+        {validationError && (
-         <Alert variant="destructive" className="m-4">
+          <Alert variant="destructive" className="m-4">
-           <AlertDescription>{validationError}</AlertDescription>
+            <AlertDescription>{validationError}</AlertDescription>
-         </Alert>
+          </Alert>
-       )}
+        )}
-       <Editor
+        <Editor
-         height="100%"
+          height="100%"
-         language={language}
+          language={language}
-         value={content}
+          value={content}
-         onChange={onChange}
+          onChange={onChange}
-         onMount={handleEditorDidMount}
+          onMount={handleEditorDidMount}
-         options={{
+          options={{
-           minimap: { enabled: false },
+            minimap: { enabled: false },
-           lineNumbers: 'on',
+            lineNumbers: 'on',
-           readOnly,
+            readOnly,
-           fontSize: 14,
+            fontSize: 14,
-           automaticLayout: true,
+            automaticLayout: true,
-           wordWrap: 'on',
+            wordWrap: 'on',
-         }}
+          }}
-       />
+        />
-     </CardContent>
+      </CardContent>
-   </Card>
+    </Card>
- );
+  );
 };