Fixed auto approver and inference continuation

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:
-                return web.Response(status=400, text="Missing response text in request body")
-            try:
-                self._agent._response_buffer.set_text(text)
-                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")
+            self._agent._response_buffer.set_text(text)
+            return web.Response(status=200)
+        except Exception as e:
+            return web.Response(status=400, text=str(e))
 
     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()
-        context = data.get("context")
-        if not context:
-            return web.Response(status=400, text="Missing context in request body")
-        self._agent.modify_context(context)
-        return web.Response(status=200)
+        try:
+            data = await request.json()
+            context = data.get("context")
+            self._agent.modify_context(context)
+            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()
-        input_text = data.get("input")
-        if not input_text:
-            return web.Response(status=400, text="Missing input in request body")
-        self._io_buffer.append_stdin(input_text)
-        return web.Response(status=200)
+        try:
+            data = await request.json()
+            input_text = data.get("input")
+            self._io_buffer.append_stdin(input_text)
+            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()
-        content = data.get("content")
-        if not content:
-            return web.Response(status=400, text="Missing content in request body")
+        try:
+            data = await request.json()
+            content = data.get("content")
+            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:
-            self._working_memory.add_entry(entry)
-            
-        return web.Response(status=200)
+            for entry in entries:
+                self._working_memory.add_entry(entry)
+                
+            return web.Response(status=200)
+        except Exception as e:
+            return web.Response(status=400, text=str(e))