tactus 0.32.2__py3-none-any.whl → 0.34.0__py3-none-any.whl

tactus/dspy/config.py

@@ -9,7 +9,6 @@ from typing import Optional, Any
 
 import dspy
 
-
 # Global reference to the current LM configuration
 _current_lm: Optional[dspy.BaseLM] = None
 
@@ -98,8 +97,20 @@ def configure_lm(
         # Create and configure the standard DSPy LM (LiteLLM-backed)
         lm = dspy.LM(model, **lm_kwargs)
 
-    # Set as global default
-    dspy.configure(lm=lm)
+    # Create adapter with native function calling enabled
+    from dspy.adapters.chat_adapter import ChatAdapter
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    adapter = ChatAdapter(use_native_function_calling=True)
+    logger.info(
+        f"[ADAPTER] Created ChatAdapter with use_native_function_calling={adapter.use_native_function_calling}"
+    )
+
+    # Set as global default with adapter
+    dspy.configure(lm=lm, adapter=adapter)
+    logger.info(f"[ADAPTER] Configured DSPy with adapter: {adapter}")
     _current_lm = lm
 
     return lm

tactus/dspy/history.py

@@ -79,7 +79,8 @@ class TactusHistory:
             raise ValueError("Message must include 'content' key")
 
         # Validate role
-        valid_roles = ["system", "user", "assistant"]
+        # Note: "tool" role is required for OpenAI function calling responses
+        valid_roles = ["system", "user", "assistant", "tool"]
         if message["role"] not in valid_roles:
             raise ValueError(f"Invalid role. Must be one of {valid_roles}")
 

tactus/dspy/module.py

@@ -64,7 +64,13 @@ class RawModule(dspy.Module):
         return [field.strip() for field in output_part.split(",")]
 
     def forward(
-        self, system_prompt: str, history, user_message: str, available_tools: str = "", **kwargs
+        self,
+        system_prompt: str,
+        history,
+        user_message: str,
+        available_tools: str = "",
+        tools=None,
+        **kwargs,
     ):
         """
         Forward pass with direct LM call (no formatting delimiters).
@@ -73,7 +79,8 @@ class RawModule(dspy.Module):
             system_prompt: System prompt (overrides init if provided)
             history: Conversation history (dspy.History, TactusHistory, or string)
             user_message: Current user message
-            available_tools: Optional tools description (for agents with tools)
+            available_tools: Optional tools description (for agents with tools) - legacy, prefer tools param
+            tools: Optional list of dspy.Tool objects for native function calling
             **kwargs: Additional args passed to LM
 
         Returns:
@@ -92,8 +99,52 @@ class RawModule(dspy.Module):
         # Add history messages
         if history:
             if hasattr(history, "messages"):
-                # It's a History object - use messages directly
-                messages.extend(history.messages)
+                # It's a History object - sanitize messages to ensure JSON serializability
+                for msg in history.messages:
+                    logger.debug(f"[RAWMODULE] Sanitizing history message: role={msg.get('role')}")
+                    sanitized_msg = {"role": msg.get("role"), "content": msg.get("content")}
+
+                    # If message is a tool result, preserve tool_call_id and name
+                    if msg.get("role") == "tool":
+                        if "tool_call_id" in msg:
+                            sanitized_msg["tool_call_id"] = msg["tool_call_id"]
+                            logger.debug("[RAWMODULE] Preserved tool_call_id for tool message")
+                        if "name" in msg:
+                            sanitized_msg["name"] = msg["name"]
+
+                    # If message has tool_calls, ensure they're plain dicts
+                    if "tool_calls" in msg:
+                        tool_calls = msg["tool_calls"]
+                        # Convert any non-dict tool calls to dicts
+                        if tool_calls and not isinstance(tool_calls, list):
+                            tool_calls = [tool_calls]
+                        if tool_calls:
+                            sanitized_tool_calls = []
+                            for tc in tool_calls:
+                                if isinstance(tc, dict):
+                                    sanitized_tool_calls.append(tc)
+                                else:
+                                    # It's a typed object - convert to dict
+                                    tc_dict = {
+                                        "id": getattr(tc, "id", ""),
+                                        "type": getattr(tc, "type", "function"),
+                                        "function": {
+                                            "name": (
+                                                getattr(tc.function, "name", "")
+                                                if hasattr(tc, "function")
+                                                else ""
+                                            ),
+                                            "arguments": (
+                                                getattr(tc.function, "arguments", "{}")
+                                                if hasattr(tc, "function")
+                                                else "{}"
+                                            ),
+                                        },
+                                    }
+                                    logger.debug("[RAWMODULE] Converted typed tool call to dict")
+                                    sanitized_tool_calls.append(tc_dict)
+                            sanitized_msg["tool_calls"] = sanitized_tool_calls
+                    messages.append(sanitized_msg)
             elif isinstance(history, str) and history.strip():
                 # It's a formatted string - parse it
                 for line in history.strip().split("\n"):
@@ -104,7 +155,7 @@ class RawModule(dspy.Module):
 
         # Add current user message
         if user_message:
-            # If tools are available, include them in the user message
+            # If tools are available (legacy string format), include them in the user message
             if available_tools and "available_tools" in self.signature:
                 user_content = f"{user_message}\n\nAvailable tools:\n{available_tools}"
                 messages.append({"role": "user", "content": user_content})
@@ -116,20 +167,94 @@ class RawModule(dspy.Module):
         if lm is None:
             raise RuntimeError("No LM configured. Call dspy.configure(lm=...) first.")
 
+        # Convert DSPy Tool objects to LiteLLM format for native function calling
+        if tools and isinstance(tools, list) and len(tools) > 0:
+            litellm_tools = []
+            for tool in tools:
+                if hasattr(tool, "format_as_litellm_function_call"):
+                    litellm_tools.append(tool.format_as_litellm_function_call())
+            if litellm_tools:
+                kwargs["tools"] = litellm_tools
+                # Ensure tool_choice is passed if set on the LM
+                if (
+                    hasattr(lm, "kwargs")
+                    and "tool_choice" in lm.kwargs
+                    and "tool_choice" not in kwargs
+                ):
+                    kwargs["tool_choice"] = lm.kwargs["tool_choice"]
+                logger.debug(
+                    f"[RAWMODULE] Passing {len(litellm_tools)} tools to LM with tool_choice={kwargs.get('tool_choice')}"
+                )
+
+        # Log summary of messages being sent
+        logger.debug(f"[RAWMODULE] Sending {len(messages)} messages to LM")
+
         # Call LM directly - streamify() will intercept this call if streaming is enabled
         response = lm(messages=messages, **kwargs)
 
-        # Extract response text from LM result
-        # LM returns a list of strings - take the first one
-        response_text = response[0] if isinstance(response, list) else str(response)
+        # Extract response text and tool calls from LM result
+        # LM returns either:
+        # - list of strings (when no tool calls): ["response text"]
+        # - list of dicts (when tool calls present): [{"text": "...", "tool_calls": [...]}]
+        response_text = ""
+        tool_calls_from_lm = None
+
+        if isinstance(response, list) and len(response) > 0:
+            first_output = response[0]
+            if isinstance(first_output, dict):
+                # Response is a dict with text and possibly tool_calls
+                response_text = first_output.get("text", "")
+                tool_calls_from_lm = first_output.get("tool_calls")
+                logger.debug(
+                    f"[RAWMODULE] Extracted response with {len(tool_calls_from_lm) if tool_calls_from_lm else 0} tool calls"
+                )
+            else:
+                # Response is a plain string
+                response_text = str(first_output)
+        else:
+            response_text = str(response)
 
         # Build prediction result based on signature
         prediction_kwargs = {"response": response_text}
 
-        # If signature includes tool_calls, add a placeholder
-        # (Real tool call parsing would happen here in a full implementation)
+        # If signature includes tool_calls, use the tool_calls we extracted from the LM response
         if "tool_calls" in self.output_fields:
-            prediction_kwargs["tool_calls"] = "No tools were used."
+            if tool_calls_from_lm:
+                # Convert to DSPy ToolCalls format
+                # tool_calls_from_lm is a list of ChatCompletionMessageToolCall objects from LiteLLM
+                from dspy.adapters.types.tool import ToolCalls
+                import json
+
+                tool_calls_list = []
+                for tc in tool_calls_from_lm:
+                    # Handle both dict and object access patterns
+                    func_name = (
+                        tc.get("function", {}).get("name")
+                        if isinstance(tc, dict)
+                        else tc.function.name
+                    )
+                    func_args = (
+                        tc.get("function", {}).get("arguments")
+                        if isinstance(tc, dict)
+                        else tc.function.arguments
+                    )
+                    tool_calls_list.append(
+                        {
+                            "name": func_name,
+                            "args": (
+                                json.loads(func_args) if isinstance(func_args, str) else func_args
+                            ),
+                        }
+                    )
+                prediction_kwargs["tool_calls"] = ToolCalls.from_dict_list(tool_calls_list)
+                logger.debug(
+                    f"[RAWMODULE] Converted {len(tool_calls_list)} tool calls to DSPy format"
+                )
+            else:
+                # No tool calls in response
+                from dspy.adapters.types.tool import ToolCalls
+
+                prediction_kwargs["tool_calls"] = ToolCalls.from_dict_list([])
 
         # Return as Prediction for DSPy compatibility
         return dspy.Prediction(**prediction_kwargs)

tactus/dspy/signature.py

@@ -9,7 +9,6 @@ from typing import Dict, Any, Optional, Union
 
 import dspy
 
-
 # Map Tactus types to Python types for DSPy fields
 TYPE_MAP = {
     "string": str,

tactus/ide/server.py

@@ -770,11 +770,34 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                     tool_paths = merged_config.get("tool_paths")
                     mcp_servers = merged_config.get("mcp_servers", {})
 
+                    # Create HITL handler with SSE channel for IDE integration
+                    from tactus.adapters.control_loop import (
+                        ControlLoopHandler,
+                        ControlLoopHITLAdapter,
+                    )
+                    from tactus.adapters.channels import load_default_channels
+
+                    # Load default channels (CLI + IPC) and add SSE channel
+                    channels = load_default_channels(procedure_id=procedure_id)
+                    sse_channel = get_sse_channel()
+
+                    # Add SSE channel to the list
+                    channels.append(sse_channel)
+
+                    # Create control loop handler with all channels
+                    control_handler = ControlLoopHandler(
+                        channels=channels,
+                        storage=storage_backend,
+                    )
+
+                    # Wrap in adapter for backward compatibility
+                    hitl_handler = ControlLoopHITLAdapter(control_handler)
+
                     # Create runtime with log handler, run_id, and loaded config
                     runtime = TactusRuntime(
                         procedure_id=procedure_id,
                         storage_backend=storage_backend,
-                        hitl_handler=None,  # No HITL in IDE streaming mode
+                        hitl_handler=hitl_handler,  # Now includes SSE channel!
                         log_handler=log_handler,
                         run_id=run_id,
                         source_file_path=str(path),
@@ -830,6 +853,78 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                     # Capture inputs in closure scope for the thread
                     procedure_inputs = inputs
 
+                    async def handle_container_control_request(request_data: dict) -> dict:
+                        """
+                        Bridge container HITL requests to host's SSE channel.
+
+                        This handler is called by the broker when the container sends
+                        a control.request. It forwards the request to the SSE channel,
+                        waits for the user response in the IDE, and returns the response
+                        data back to the container.
+                        """
+                        import threading
+                        from tactus.protocols.control import ControlRequest
+
+                        # Parse the request
+                        request = ControlRequest.model_validate(request_data)
+                        logger.info(
+                            f"[HITL] Container control request {request.request_id} "
+                            f"for procedure {request.procedure_id}"
+                        )
+
+                        # Get SSE channel
+                        sse_channel = get_sse_channel()
+
+                        # Create a threading event to wait for response
+                        response_event = threading.Event()
+                        response_data = {}
+
+                        # Register pending request
+                        _pending_hitl_requests[request.request_id] = {
+                            "event": response_event,
+                            "response": response_data,
+                        }
+
+                        try:
+                            # Send to SSE channel (delivers to IDE UI)
+                            delivery = await sse_channel.send(request)
+                            if not delivery.success:
+                                raise RuntimeError(
+                                    f"Failed to deliver HITL request to IDE: {delivery.error_message}"
+                                )
+
+                            logger.info(
+                                f"[HITL] Request {request.request_id} delivered to IDE, waiting for response..."
+                            )
+
+                            # Wait for response (with timeout) - run blocking wait in thread pool
+                            timeout_seconds = request.timeout_seconds or 300  # 5 min default
+                            logger.info(
+                                f"[HITL] Starting wait for response (timeout={timeout_seconds}s)..."
+                            )
+                            result = await asyncio.to_thread(
+                                response_event.wait, timeout=timeout_seconds
+                            )
+                            logger.info(f"[HITL] Wait completed, result={result}")
+
+                            if result:
+                                logger.info(
+                                    f"[HITL] Received response for {request.request_id}: "
+                                    f"{response_data.get('value')}"
+                                )
+                                return response_data
+                            else:
+                                # Timeout
+                                logger.warning(f"[HITL] Timeout for {request.request_id}")
+                                return {
+                                    "value": request.default_value,
+                                    "timed_out": True,
+                                    "channel_id": "sse",
+                                }
+                        finally:
+                            # Clean up pending request
+                            _pending_hitl_requests.pop(request.request_id, None)
+
                     def run_procedure():
                         try:
                             # Create new event loop for this thread
@@ -839,6 +934,13 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             if use_sandbox:
                                 # Use sandbox execution (events streamed via broker over UDS)
                                 runner = ContainerRunner(sandbox_config)
+
+                                # Pass async control handler directly (broker calls it in async context)
+                                # Build LLM backend config (provider-agnostic)
+                                llm_backend_config = {}
+                                if openai_api_key:
+                                    llm_backend_config["openai_api_key"] = openai_api_key
+
                                 exec_result = loop.run_until_complete(
                                     runner.run(
                                         source=source,
@@ -848,6 +950,9 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                                         event_handler=(
                                             sandbox_event_queue.put if sandbox_event_queue else None
                                         ),
+                                        run_id=run_id,
+                                        control_handler=handle_container_control_request,
+                                        llm_backend_config=llm_backend_config,
                                     )
                                 )
 
@@ -888,19 +993,31 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         yield f"data: {json.dumps(container_running_event)}\n\n"
 
                     # Stream events based on execution mode
+                    # Poll aggressively to stream events in real-time
                     while not result_container["done"]:
+                        events_sent = False
+
                         if use_sandbox and sandbox_event_queue:
                             # Stream from sandbox callback queue
                             try:
-                                event_dict = sandbox_event_queue.get(timeout=0.1)
+                                event_dict = sandbox_event_queue.get(timeout=0.01)
                                 all_events.append(event_dict)
                                 yield f"data: {json.dumps(event_dict)}\n\n"
+                                events_sent = True
                             except queue.Empty:
                                 pass
+
+                            # Also check for HITL events from SSE channel (container HITL)
+                            hitl_event = sse_channel.get_next_event(timeout=0.001)
+                            if hitl_event:
+                                all_events.append(hitl_event)
+                                yield f"data: {json.dumps(hitl_event)}\n\n"
+                                events_sent = True
                         else:
                             # Stream from IDELogHandler (direct execution)
-                            events = log_handler.get_events(timeout=0.1)
-                            for event in events:
+                            # Get one event at a time to stream immediately
+                            try:
+                                event = log_handler.events.get(timeout=0.001)
                                 try:
                                     # Serialize with ISO format for datetime
                                     event_dict = event.model_dump(mode="json")
@@ -915,22 +1032,43 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                                     event_dict["timestamp"] = iso_string
                                     all_events.append(event_dict)
                                     yield f"data: {json.dumps(event_dict)}\n\n"
+                                    events_sent = True
                                 except Exception as e:
                                     logger.error(f"Error serializing event: {e}", exc_info=True)
                                     logger.error(f"Event type: {type(event)}, Event: {event}")
+                            except queue.Empty:
+                                pass
 
-                        time.sleep(0.05)
+                            # Also check for HITL events from SSE channel
+                            hitl_event = sse_channel.get_next_event(timeout=0.001)
+                            if hitl_event:
+                                all_events.append(hitl_event)
+                                yield f"data: {json.dumps(hitl_event)}\n\n"
+                                events_sent = True
+
+                        # Only sleep if no events were sent to maintain responsiveness
+                        if not events_sent:
+                            time.sleep(0.01)
 
                     # Get any remaining events
                     if use_sandbox and sandbox_event_queue:
-                        # Drain sandbox event queue
-                        while True:
+                        # Drain sandbox event queue with retries to catch late-arriving events
+                        # Agent streaming events and ExecutionSummaryEvent may still be in flight
+                        max_wait = 2.0  # Wait up to 2 seconds for final events
+                        poll_interval = 0.05  # Poll every 50ms
+                        elapsed = 0.0
+                        consecutive_empty = 0
+                        max_consecutive_empty = 4  # Stop after 4 empty polls (200ms of no events)
+
+                        while elapsed < max_wait and consecutive_empty < max_consecutive_empty:
                             try:
-                                event_dict = sandbox_event_queue.get_nowait()
+                                event_dict = sandbox_event_queue.get(timeout=poll_interval)
                                 all_events.append(event_dict)
                                 yield f"data: {json.dumps(event_dict)}\n\n"
+                                consecutive_empty = 0  # Reset counter when we get an event
                             except queue.Empty:
-                                break
+                                consecutive_empty += 1
+                                elapsed += poll_interval
 
                         # Emit container stopped event
                         container_stopped_event = {
@@ -1863,6 +2001,34 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
             logger.error(f"Error getting checkpoint {run_id}@{position}: {e}", exc_info=True)
             return jsonify({"error": str(e)}), 500
 
+    @app.route("/api/procedures/<procedure_id>/checkpoints", methods=["DELETE"])
+    def clear_checkpoints(procedure_id: str):
+        """Clear all checkpoints for a procedure to force fresh execution."""
+        try:
+            from pathlib import Path as PathLib
+            import os
+
+            # Build the checkpoint file path
+            storage_dir = (
+                PathLib(WORKSPACE_ROOT) / ".tac" / "storage"
+                if WORKSPACE_ROOT
+                else PathLib.home() / ".tactus" / "storage"
+            )
+            checkpoint_file = storage_dir / f"{procedure_id}.json"
+
+            if checkpoint_file.exists():
+                os.remove(checkpoint_file)
+                logger.info(f"Cleared checkpoints for procedure: {procedure_id}")
+                return jsonify(
+                    {"success": True, "message": f"Checkpoints cleared for {procedure_id}"}
+                )
+            else:
+                return jsonify({"success": True, "message": "No checkpoints found"}), 200
+
+        except Exception as e:
+            logger.error(f"Error clearing checkpoints for {procedure_id}: {e}", exc_info=True)
+            return jsonify({"error": str(e)}), 500
+
     @app.route("/api/traces/runs/<run_id>/statistics", methods=["GET"])
     def get_run_statistics(run_id: str):
         """Get statistics for a run by filtering checkpoints by run_id."""
@@ -2196,6 +2362,131 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
         logger.warning(f"Could not register config routes: {e}")
 
     # Serve frontend if dist directory is provided
+    # =========================================================================
+    # HITL (Human-in-the-Loop) Control Channel Endpoints
+    # =========================================================================
+
+    # Global SSE channel instance (shared across requests)
+    _sse_channel = None
+    # Pending HITL requests (for container control handler)
+    _pending_hitl_requests: dict[str, dict] = {}
+
+    def get_sse_channel():
+        """Get or create the global SSE channel instance."""
+        nonlocal _sse_channel
+        if _sse_channel is None:
+            from tactus.adapters.channels.sse import SSEControlChannel
+
+            _sse_channel = SSEControlChannel()
+        return _sse_channel
+
+    @app.route("/api/hitl/response/<request_id>", methods=["POST"])
+    def hitl_response(request_id: str):
+        """
+        Handle HITL response from IDE.
+
+        Called when user responds to a HITL request in the IDE UI.
+        Pushes response to SSEControlChannel which forwards to control loop.
+
+        Request body:
+        - value: The response value (boolean, string, dict, etc.)
+        """
+        try:
+            data = request.json or {}
+            value = data.get("value")
+
+            logger.info(f"Received HITL response for {request_id}: {value}")
+
+            # Check if this is a container HITL request (pending in our dict)
+            if request_id in _pending_hitl_requests:
+                pending = _pending_hitl_requests[request_id]
+                pending["response"]["value"] = value
+                pending["response"]["timed_out"] = False
+                pending["response"]["channel_id"] = "sse"
+                pending["event"].set()  # Signal the waiting thread
+                logger.info(f"[HITL] Signaled container handler for {request_id}")
+            else:
+                # Push to SSE channel's response queue (for non-container HITL)
+                channel = get_sse_channel()
+                channel.handle_ide_response(request_id, value)
+
+            return jsonify({"status": "ok", "request_id": request_id})
+
+        except Exception as e:
+            logger.exception(f"Error handling HITL response for {request_id}")
+            return jsonify({"status": "error", "message": str(e)}), 400
+
+    @app.route("/api/hitl/stream", methods=["GET"])
+    def hitl_stream():
+        """
+        SSE stream for HITL requests.
+
+        Clients connect to this endpoint to receive hitl.request events
+        in real-time. Events include:
+        - hitl.request: New HITL request with full context
+        - hitl.cancel: Request cancelled (another channel responded)
+        """
+        logger.info("[HITL-SSE] Client connected to /api/hitl/stream")
+
+        def generate():
+            """Generator that yields SSE events from the channel."""
+            import asyncio
+            import json
+
+            channel = get_sse_channel()
+
+            # Create event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                # Send initial connection event
+                connection_event = {
+                    "type": "connection",
+                    "status": "connected",
+                    "timestamp": datetime.utcnow().isoformat() + "Z",
+                }
+                logger.info("[HITL-SSE] Sending connection event to client")
+                yield f"data: {json.dumps(connection_event)}\n\n"
+
+                # Stream events from channel
+                while True:
+                    # Get next event from channel (non-blocking with timeout)
+                    event = loop.run_until_complete(channel.get_next_event())
+
+                    if event:
+                        logger.info(
+                            f"[HITL-SSE] Sending event to client: {event.get('type', 'unknown')}"
+                        )
+                        yield f"data: {json.dumps(event)}\n\n"
+                    else:
+                        # Send keepalive comment every second if no events
+                        yield ": keepalive\n\n"
+                        import time
+
+                        time.sleep(1)
+
+            except GeneratorExit:
+                logger.info("HITL SSE client disconnected")
+            except Exception as e:
+                logger.error(f"Error in HITL SSE stream: {e}", exc_info=True)
+            finally:
+                loop.close()
+
+        return Response(
+            stream_with_context(generate()),
+            mimetype="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "X-Accel-Buffering": "no",
+                "Connection": "keep-alive",
+            },
+        )
+
+    # =========================================================================
+    # Frontend Serving (if enabled)
+    # =========================================================================
+
     if frontend_dist_dir:
 
         @app.route("/")