tactus 0.22.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

tactus/__init__.py

@@ -5,7 +5,7 @@ Tactus provides a declarative workflow engine for AI agents with pluggable
 backends for storage, HITL, and chat recording.
 """
 
-__version__ = "0.22.0"
+__version__ = "0.23.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

tactus/dspy/agent.py

@@ -82,6 +82,7 @@ class DSPyAgentHandle:
             module: DSPy module type to use (default: "Predict"). Options:
                 - "Predict": Simple pass-through prediction (no reasoning traces)
                 - "ChainOfThought": Adds step-by-step reasoning before response
+                - "Raw": Minimal formatting, direct LM calls (lowest token overhead)
             initial_message: Initial message to send on first turn if no inject
             registry: Optional Registry instance for accessing mocks
             mock_manager: Optional MockManager instance for checking mocks
@@ -288,6 +289,7 @@ class DSPyAgentHandle:
         mapping = {
             "Predict": "predict",
             "ChainOfThought": "chain_of_thought",
+            "Raw": "raw",
             # Future modules can be added here:
             # "ReAct": "react",
             # "ProgramOfThought": "program_of_thought",

tactus/dspy/config.py

@@ -131,3 +131,69 @@ def reset_lm_configuration() -> None:
     _current_lm = None
     # Also reset DSPy's global configuration
     dspy.configure(lm=None)
+
+
+def create_lm(
+    model: str,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    temperature: float = 0.7,
+    max_tokens: Optional[int] = None,
+    model_type: Optional[str] = None,
+    **kwargs: Any,
+) -> dspy.LM:
+    """
+    Create a Language Model instance WITHOUT setting it as global default.
+
+    This is useful for creating LMs in async contexts where dspy.configure()
+    cannot be called (e.g., in different event loops or async tasks).
+
+    Use with dspy.context(lm=...) to set the LM for a specific scope:
+        lm = create_lm("openai/gpt-4o")
+        with dspy.context(lm=lm):
+            # Use DSPy operations here
+
+    Args:
+        model: Model identifier in LiteLLM format (e.g., "openai/gpt-4o")
+        api_key: API key (optional, can use environment variables)
+        api_base: Custom API base URL (optional)
+        temperature: Sampling temperature (default: 0.7)
+        max_tokens: Maximum tokens in response (optional)
+        model_type: Model type (e.g., "chat", "responses" for reasoning models)
+        **kwargs: Additional LiteLLM parameters
+
+    Returns:
+        dspy.LM instance (not configured globally)
+    """
+    # Validate model parameter
+    if model is None or not model:
+        raise ValueError("model is required for LM configuration")
+
+    if not isinstance(model, str) or not model.startswith(
+        ("openai/", "anthropic/", "bedrock/", "gemini/", "ollama/")
+    ):
+        # Check if it's at least formatted correctly
+        if "/" not in model:
+            raise ValueError(
+                f"Invalid model format: {model}. Expected format like 'provider/model-name'"
+            )
+
+    # Build configuration
+    lm_kwargs = {
+        "temperature": temperature,
+        # IMPORTANT: Disable caching to enable streaming
+        "cache": False,
+        **kwargs,
+    }
+
+    if api_key:
+        lm_kwargs["api_key"] = api_key
+    if api_base:
+        lm_kwargs["api_base"] = api_base
+    if max_tokens:
+        lm_kwargs["max_tokens"] = max_tokens
+    if model_type:
+        lm_kwargs["model_type"] = model_type
+
+    # Create LM without setting as global default
+    return dspy.LM(model, **lm_kwargs)

tactus/dspy/module.py

@@ -5,12 +5,135 @@ This module provides the Module primitive that maps to DSPy modules,
 supporting various prediction strategies like Predict, ChainOfThought, etc.
 """
 
+import logging
 from typing import Any, Dict, Optional, Union
 
 import dspy
 
 from tactus.dspy.signature import create_signature
 
+logger = logging.getLogger(__name__)
+
+
+class RawModule(dspy.Module):
+    """
+    Minimal DSPy module for raw LM calls without formatting delimiters.
+
+    This module calls the LM directly without using dspy.Predict, eliminating
+    the formatting delimiters like [[ ## response ## ]] that Predict adds.
+
+    Key features:
+    - No DSPy formatting delimiters in output
+    - Works correctly with dspy.streamify() for streaming
+    - Maintains DSPy's optimization and tracing capabilities
+    - Supports dynamic signatures (with or without tool_calls)
+
+    Usage:
+        # Without tools
+        raw = RawModule(signature="system_prompt, history, user_message -> response")
+        result = raw(user_message="Hello", history="")
+
+        # With tools
+        raw = RawModule(signature="system_prompt, history, user_message, available_tools -> response, tool_calls")
+        result = raw(user_message="Hello", history="", available_tools="...")
+    """
+
+    def __init__(
+        self,
+        signature: str = "system_prompt, history, user_message -> response",
+        system_prompt: str = "",
+    ):
+        """
+        Initialize raw module.
+
+        Args:
+            signature: DSPy signature string defining inputs and outputs
+            system_prompt: System prompt to prepend to all conversations
+        """
+        super().__init__()
+        self.system_prompt = system_prompt
+        self.signature = signature
+        # Parse signature to determine output fields
+        self.output_fields = self._parse_output_fields(signature)
+
+    def _parse_output_fields(self, signature: str) -> list:
+        """Extract output field names from signature string."""
+        if "->" not in signature:
+            return ["response"]
+        output_part = signature.split("->")[1].strip()
+        return [field.strip() for field in output_part.split(",")]
+
+    def forward(
+        self, system_prompt: str, history, user_message: str, available_tools: str = "", **kwargs
+    ):
+        """
+        Forward pass with direct LM call (no formatting delimiters).
+
+        Args:
+            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)
+            **kwargs: Additional args passed to LM
+
+        Returns:
+            dspy.Prediction with response field (and tool_calls if signature includes it)
+        """
+        # Use provided system_prompt or fall back to init value
+        sys_prompt = system_prompt or self.system_prompt
+
+        # Build messages array for direct LM call
+        messages = []
+
+        # Add system prompt if provided
+        if sys_prompt:
+            messages.append({"role": "system", "content": sys_prompt})
+
+        # Add history messages
+        if history:
+            if hasattr(history, "messages"):
+                # It's a History object - use messages directly
+                messages.extend(history.messages)
+            elif isinstance(history, str) and history.strip():
+                # It's a formatted string - parse it
+                for line in history.strip().split("\n"):
+                    if line.startswith("User: "):
+                        messages.append({"role": "user", "content": line[6:]})
+                    elif line.startswith("Assistant: "):
+                        messages.append({"role": "assistant", "content": line[11:]})
+
+        # Add current user message
+        if user_message:
+            # If tools are available, 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})
+            else:
+                messages.append({"role": "user", "content": user_message})
+
+        # Get the configured LM
+        lm = dspy.settings.lm
+        if lm is None:
+            raise RuntimeError("No LM configured. Call dspy.configure(lm=...) first.")
+
+        # 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)
+
+        # 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 "tool_calls" in self.output_fields:
+            prediction_kwargs["tool_calls"] = "No tools were used."
+
+        # Return as Prediction for DSPy compatibility
+        return dspy.Prediction(**prediction_kwargs)
+
 
 class TactusModule:
     """
@@ -100,6 +223,18 @@ class TactusModule:
             return dspy.Predict(self.signature, **self.kwargs)
         elif self.strategy == "chain_of_thought":
             return dspy.ChainOfThought(self.signature, **self.kwargs)
+        elif self.strategy == "raw":
+            # Raw module for minimal formatting
+            # Pass the signature so RawModule can support tool_calls when needed
+            if isinstance(self.signature, str):
+                signature_str = self.signature
+            else:
+                # It's a DSPy Signature object - reconstruct the signature string
+                # from input_fields and output_fields
+                input_names = list(self.signature.input_fields.keys())
+                output_names = list(self.signature.output_fields.keys())
+                signature_str = f"{', '.join(input_names)} -> {', '.join(output_names)}"
+            return RawModule(signature=signature_str, system_prompt="")
         elif self.strategy == "react":
             # ReAct requires tools - will be implemented in Step 5.1
             raise NotImplementedError("ReAct strategy not yet implemented. Coming in Step 5.1.")
@@ -110,7 +245,7 @@ class TactusModule:
             )
         else:
             raise ValueError(
-                f"Unknown strategy '{self.strategy}'. Supported: predict, chain_of_thought"
+                f"Unknown strategy '{self.strategy}'. Supported: predict, chain_of_thought, raw"
             )
 
     def __call__(self, **kwargs: Any) -> dspy.Prediction:

tactus/ide/server.py

@@ -2070,73 +2070,85 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
     @app.route("/api/chat/stream", methods=["POST"])
     def chat_stream():
         """
-        Stream chat responses with SSE.
+        Stream chat responses with SSE using our working implementation.
 
         Request body:
+        - workspace_root: Workspace path
         - message: User's message
+        - config: Optional config with provider, model, etc.
         """
-        data = request.json or {}
-        message = data.get("message")
+        try:
+            import sys
+            import os
+            import uuid
+            import asyncio
+
+            # Add backend directory to path so we can import our modules
+            backend_dir = os.path.join(
+                os.path.dirname(__file__), "..", "..", "tactus-ide", "backend"
+            )
+            if backend_dir not in sys.path:
+                sys.path.insert(0, backend_dir)
 
-        if not message:
-            return jsonify({"error": "Missing 'message' parameter"}), 400
+            from assistant_service import AssistantService
 
-        if not WORKSPACE_ROOT:
-            return jsonify({"error": "No workspace folder selected"}), 400
+            data = request.json or {}
+            workspace_root = data.get("workspace_root") or WORKSPACE_ROOT
+            user_message = data.get("message")
+            config = data.get(
+                "config",
+                {"provider": "openai", "model": "gpt-4o", "temperature": 0.7, "max_tokens": 4000},
+            )
 
-        def generate_events():
-            """Generator function that yields SSE chat events."""
-            try:
-                import json
-                from datetime import datetime
+            if not workspace_root or not user_message:
+                return jsonify({"error": "workspace_root and message required"}), 400
 
-                # Get or create assistant
-                assistant = get_or_create_assistant()
+            # Create service instance
+            conversation_id = str(uuid.uuid4())
+            service = AssistantService(workspace_root, config)
 
-                # Send start event
-                start_event = {
-                    "event_type": "chat_start",
-                    "timestamp": datetime.utcnow().isoformat() + "Z",
-                }
-                yield f"data: {json.dumps(start_event)}\n\n"
+            def generate():
+                """Generator function that yields SSE events."""
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
 
-                # Process message
-                result = assistant.process_message(message)
+                try:
+                    # Start conversation (configures DSPy LM internally)
+                    loop.run_until_complete(service.start_conversation(conversation_id))
 
-                # Send response event
-                response_event = {
-                    "event_type": "chat_response",
-                    "timestamp": datetime.utcnow().isoformat() + "Z",
-                    "response": result["response"],
-                    "tool_calls": result.get("tool_calls", []),
-                }
-                yield f"data: {json.dumps(response_event)}\n\n"
+                    # Send immediate thinking indicator
+                    yield f"data: {json.dumps({'type': 'thinking', 'content': 'Processing your request...'})}\n\n"
 
-                # Send completion event
-                complete_event = {
-                    "event_type": "chat_complete",
-                    "timestamp": datetime.utcnow().isoformat() + "Z",
-                }
-                yield f"data: {json.dumps(complete_event)}\n\n"
+                    # Create async generator
+                    async_gen = service.send_message(user_message)
 
-            except Exception as e:
-                logger.error(f"Error in chat streaming: {e}", exc_info=True)
-                error_event = {
-                    "event_type": "chat_error",
-                    "timestamp": datetime.utcnow().isoformat() + "Z",
-                    "error": str(e),
-                }
-                yield f"data: {json.dumps(error_event)}\n\n"
-
-        return Response(
-            stream_with_context(generate_events()),
-            mimetype="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "X-Accel-Buffering": "no",
-                "Connection": "keep-alive",
-            },
-        )
+                    # Consume events one at a time and yield immediately
+                    while True:
+                        try:
+                            event = loop.run_until_complete(async_gen.__anext__())
+                            yield f"data: {json.dumps(event)}\n\n"
+                        except StopAsyncIteration:
+                            break
+
+                except Exception as e:
+                    logger.error(f"Error streaming message: {e}", exc_info=True)
+                    yield f"data: {json.dumps({'type': 'error', 'error': str(e)})}\n\n"
+                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",
+                },
+            )
+
+        except Exception as e:
+            logger.error(f"Error in stream endpoint: {e}", exc_info=True)
+            return jsonify({"error": str(e)}), 500
 
     @app.route("/api/chat/reset", methods=["POST"])
     def chat_reset():

tactus/sandbox/container_runner.py

@@ -16,6 +16,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from .config import SandboxConfig
+from .docker_manager import DockerManager, calculate_source_hash
 from .protocol import (
     ExecutionRequest,
     ExecutionResult,
@@ -80,6 +81,76 @@ class ContainerRunner:
         """
         self.config = config
 
+        # Parse image name and tag from config.image (e.g., "tactus-sandbox:local")
+        image_parts = config.image.split(":")
+        image_name = image_parts[0] if len(image_parts) > 0 else "tactus-sandbox"
+        image_tag = image_parts[1] if len(image_parts) > 1 else "local"
+
+        self.docker_manager = DockerManager(
+            image_name=image_name,
+            image_tag=image_tag,
+        )
+
+    def _ensure_sandbox_up_to_date(self, skip_for_ide: bool = False) -> None:
+        """
+        Automatically rebuild sandbox if code has changed.
+
+        This enables fast, automatic rebuilds during development without
+        requiring manual `tactus sandbox rebuild` commands. Uses source
+        hash for change detection with Docker layer caching for speed.
+
+        Can be disabled by setting TACTUS_AUTO_REBUILD_SANDBOX=false or
+        when running from IDE (to avoid blocking UI).
+
+        Args:
+            skip_for_ide: If True, skip rebuild (used when called from IDE)
+
+        Raises:
+            RuntimeError: If rebuild is needed but fails.
+        """
+        # Skip auto-rebuild in IDE to avoid blocking UI
+        if skip_for_ide:
+            logger.debug("Auto-rebuild skipped for IDE execution")
+            return
+
+        # Check if auto-rebuild is disabled
+        auto_rebuild = os.environ.get("TACTUS_AUTO_REBUILD_SANDBOX", "true").lower()
+        if auto_rebuild not in ("true", "1", "yes"):
+            logger.debug("Auto-rebuild disabled via TACTUS_AUTO_REBUILD_SANDBOX")
+            return
+
+        # Get current version and source hash
+        from tactus import __version__
+
+        # Calculate tactus root from this file's location
+        # container_runner.py is in tactus/sandbox/, so root is 2 levels up
+        tactus_root = Path(__file__).parent.parent.parent
+
+        current_hash = calculate_source_hash(tactus_root)
+
+        # Check if rebuild is needed
+        if self.docker_manager.needs_rebuild(__version__, current_hash):
+            logger.info("Code changes detected, rebuilding sandbox...")
+
+            # Get paths
+            dockerfile_path = tactus_root / "tactus" / "docker" / "Dockerfile"
+
+            # Build with source hash
+            success, msg = self.docker_manager.build_image(
+                dockerfile_path=dockerfile_path,
+                context_path=tactus_root,
+                version=__version__,
+                source_hash=current_hash,
+                verbose=False,
+            )
+
+            if not success:
+                raise RuntimeError(f"Failed to rebuild sandbox: {msg}")
+
+            logger.info("Sandbox rebuilt successfully")
+        else:
+            logger.debug("Sandbox is up to date")
+
     def _build_docker_command(
         self,
         working_dir: Path,
@@ -203,6 +274,11 @@ class ContainerRunner:
         Returns:
             ExecutionResult with status, result/error, and metadata.
         """
+        # Ensure sandbox is up to date (auto-rebuild if code changed)
+        # Skip for IDE to avoid blocking UI - IDE has its own rebuild mechanism
+        skip_rebuild_for_ide = callback_url is not None
+        self._ensure_sandbox_up_to_date(skip_for_ide=skip_rebuild_for_ide)
+
         execution_id = str(uuid.uuid4())[:8]
         start_time = time.time()
 

tactus/sandbox/docker_manager.py

@@ -4,6 +4,7 @@ Docker management utilities for sandbox execution.
 Handles Docker availability detection, image building, and version management.
 """
 
+import hashlib
 import logging
 import shutil
 import subprocess
@@ -17,6 +18,49 @@ DEFAULT_IMAGE_NAME = "tactus-sandbox"
 DEFAULT_IMAGE_TAG = "local"
 
 
+def calculate_source_hash(tactus_root: Path) -> str:
+    """
+    Calculate hash of Tactus source files for change detection.
+
+    This enables fast, automatic rebuilds when code changes without
+    requiring manual version bumps or rebuild commands.
+
+    Args:
+        tactus_root: Root directory of the Tactus package
+
+    Returns:
+        Short hash (16 chars) representing the current state of source code
+    """
+    # Key paths that affect sandbox behavior
+    paths_to_hash = [
+        tactus_root / "tactus" / "dspy",
+        tactus_root / "tactus" / "core",
+        tactus_root / "tactus" / "primitives",
+        tactus_root / "tactus" / "sandbox",
+        tactus_root / "pyproject.toml",  # Dependencies affect sandbox
+    ]
+
+    hasher = hashlib.sha256()
+
+    for path in sorted(paths_to_hash):
+        if not path.exists():
+            continue
+
+        if path.is_file():
+            # Hash file contents
+            hasher.update(path.read_bytes())
+        elif path.is_dir():
+            # Hash all Python files in directory (recursively)
+            for py_file in sorted(path.rglob("*.py")):
+                # Hash relative path + contents for reproducibility
+                rel_path = str(py_file.relative_to(tactus_root))
+                hasher.update(rel_path.encode())
+                hasher.update(py_file.read_bytes())
+
+    # Return short hash (16 chars is plenty for collision avoidance)
+    return hasher.hexdigest()[:16]
+
+
 def is_docker_available() -> Tuple[bool, str]:
     """
     Check if Docker is available and running.
@@ -123,12 +167,45 @@ class DockerManager:
         except Exception:
             return None
 
-    def needs_rebuild(self, current_version: str) -> bool:
+    def get_image_source_hash(self) -> Optional[str]:
+        """
+        Get the source hash label from the existing image.
+
+        Returns:
+            Source hash string if found, None otherwise.
+        """
+        try:
+            result = subprocess.run(
+                [
+                    "docker",
+                    "image",
+                    "inspect",
+                    "--format",
+                    '{{index .Config.Labels "tactus.source_hash"}}',
+                    self.full_image_name,
+                ],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+            return None
+        except Exception:
+            return None
+
+    def needs_rebuild(self, current_version: str, current_hash: Optional[str] = None) -> bool:
         """
         Check if the image needs to be rebuilt.
 
+        Checks both version and source hash (if provided) to determine
+        if a rebuild is necessary. This enables automatic rebuilds when
+        code changes without requiring manual version bumps.
+
         Args:
             current_version: Current Tactus version.
+            current_hash: Optional source hash of current code. If provided,
+                         will trigger rebuild when hash doesn't match.
 
         Returns:
             True if image should be rebuilt.
@@ -136,17 +213,34 @@ class DockerManager:
         if not self.image_exists():
             return True
 
+        # Check version mismatch
         image_version = self.get_image_version()
         if image_version is None:
             return True
 
-        return image_version != current_version
+        if image_version != current_version:
+            return True
+
+        # Check source hash mismatch (if hash checking is enabled)
+        if current_hash is not None:
+            image_hash = self.get_image_source_hash()
+            if image_hash is None:
+                # Old image without hash label - rebuild to add it
+                logger.debug("Image missing source hash label, rebuild needed")
+                return True
+
+            if image_hash != current_hash:
+                logger.debug(f"Source hash mismatch: {image_hash} != {current_hash}")
+                return True
+
+        return False
 
     def build_image(
         self,
         dockerfile_path: Path,
         context_path: Path,
         version: str,
+        source_hash: Optional[str] = None,
         verbose: bool = False,
     ) -> Tuple[bool, str]:
         """
@@ -156,6 +250,7 @@ class DockerManager:
             dockerfile_path: Path to the Dockerfile
             context_path: Build context path (usually the Tactus package root)
             version: Tactus version to label the image with
+            source_hash: Optional source hash to label the image with for change detection
             verbose: If True, stream build output
 
         Returns:
@@ -178,9 +273,14 @@ class DockerManager:
             str(dockerfile_path),
             "--label",
             f"tactus.version={version}",
-            str(context_path),
         ]
 
+        # Add source hash label if provided
+        if source_hash:
+            cmd.extend(["--label", f"tactus.source_hash={source_hash}"])
+
+        cmd.append(str(context_path))
+
         try:
             if verbose:
                 # Stream output in real-time

{tactus-0.22.0.dist-info → tactus-0.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.22.0
+Version: 0.23.0
 Summary: Tactus: Lua-based DSL for agentic workflows
 Project-URL: Homepage, https://github.com/AnthusAI/Tactus
 Project-URL: Documentation, https://github.com/AnthusAI/Tactus/tree/main/docs

{tactus-0.22.0.dist-info → tactus-0.23.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tactus/__init__.py,sha256=JgkDSchEs5m2RE9qP_hqbjCJG2E5vaV5f2TCj-Z9nrw,1245
+tactus/__init__.py,sha256=bYU1q6ssy4qyaU4ywptrmHurU9Y5gaCei8LiigteA2I,1245
 tactus/adapters/__init__.py,sha256=lU8uUxuryFRIpVrn_KeVK7aUhsvOT1tYsuE3FOOIFpI,289
 tactus/adapters/cli_hitl.py,sha256=l8jKU3y99g8z2vS11td0JXLVG77SF01nO-Ss4pRFXO0,6962
 tactus/adapters/cli_log.py,sha256=JKD693goi_wT_Kei4mTc2KJ-0QfgFZTpV3Prb8zfNZo,9779
@@ -34,15 +34,15 @@ tactus/core/dependencies/registry.py,sha256=bgRdqJJTUrnQlu0wvjv2In1EPq7prZq-b9eB
 tactus/docker/Dockerfile,sha256=Lo1erljpHSw9O-uOj0mn47gtg6abqzBvhbChAb-GQhI,1720
 tactus/docker/entrypoint.sh,sha256=-qYq5RQIGS6KirJ6NO0XiHZf_oAdfmk5HzHOBsiqxRM,1870
 tactus/dspy/__init__.py,sha256=beUkvMUFdPvZE9-bEOfRo2TH-FoCvPT_L9_dpJPW324,1226
-tactus/dspy/agent.py,sha256=0NmggxO25wArROKPSx0GKFsMTqCi3sIRTcP_Pvm_2-c,37560
-tactus/dspy/config.py,sha256=r6XfEkXg1NZWTXDuWCT1DG7BRv4mvty1T-VqgjkKXLk,3833
+tactus/dspy/agent.py,sha256=lWb71_EyM_VrgFE4XQ3LPW3Sl5rIir0ndAZHZoh23U4,37671
+tactus/dspy/config.py,sha256=oXwYzfVCTBHRnbH_vvm591FhE0zKep7wgmujLSXKf_c,6013
 tactus/dspy/history.py,sha256=0yGi3P5ruRUPoRyaCWsUDeuEYYsfproc_7pMVZuhmUo,5980
-tactus/dspy/module.py,sha256=73lD10t6StsIGLDidaMraIygicrSV50UuaeOfMHBz2k,9734
+tactus/dspy/module.py,sha256=sJdFS-5A4SpuiMLjbwiZJCvg3pTtEx8x8MRVaqjCQ2I,15423
 tactus/dspy/prediction.py,sha256=AFtkmKQafOcA4Pzdty0dvZ62lmfS3wgIj4Bc3Awhb2c,7228
 tactus/dspy/signature.py,sha256=jdLHBa5BOEBwXTfmLui6fjViEDQDhdUzQm2__STHquU,6053
 tactus/ide/__init__.py,sha256=1fSC0xWP-Lq5wl4FgDq7SMnkvZ0DxXupreTl3ZRX1zw,143
 tactus/ide/coding_assistant.py,sha256=GgmspWIn9IPgBK0ZYapeISIOrcDfRyK7yyPDPV85r8g,12184
-tactus/ide/server.py,sha256=uguiIXsR8bzYTj9Ek257uXF2akmeR5pUmct6-RfgBwo,96846
+tactus/ide/server.py,sha256=Wp2-lpbYp8u-xPDUjGVNX08Rvgx-9umwxrVlWfAce0c,97575
 tactus/primitives/__init__.py,sha256=2NHEGBCuasVJlD5bHE6OSYivZ3WEp90DJDTvoKehVzg,1712
 tactus/primitives/control.py,sha256=PjRt_Pegcj2L1Uy-IUBQKTYFRMXy7b9q1z2kzJNH8qw,4683
 tactus/primitives/file.py,sha256=-kz0RCst_i_3V860-LtGntYpE0Mm371U_KGHqELbMx0,7186
@@ -79,8 +79,8 @@ tactus/providers/google.py,sha256=wgZ3eiQif1rq1T8BK5V2kL_QVCmqBQZuWLz37y9cxOQ,31
 tactus/providers/openai.py,sha256=3qSXfdELTHdU7vuRSxQrtnfNctt0HhrePOLFj3YlViA,2692
 tactus/sandbox/__init__.py,sha256=UCBvPD63szvSdwSzpznLW-cnJOgGkVHiKcmJtsAmnuA,1424
 tactus/sandbox/config.py,sha256=zbv2ewzwN381HuJRaPnDgzdbZlxNIUYIWAbj9udYf0A,3713
-tactus/sandbox/container_runner.py,sha256=WW4zEQHMipVFVY9TwGbkS7wrGhadBcmhdjXPJRK5NIY,13122
-tactus/sandbox/docker_manager.py,sha256=B7ZA7UrPZe-C4fkwHyQwnT-WtEecdhZ-eYLLqGRw5-o,9972
+tactus/sandbox/container_runner.py,sha256=GUY460O8oTREzpc7NWUHcCqSrLapovDT0yWpA0hRV9Q,16161
+tactus/sandbox/docker_manager.py,sha256=fqSlLpanL4zdgj0NopCc0Du-Ac1TlbgswQJ5N3CNfrs,13535
 tactus/sandbox/entrypoint.py,sha256=wqfHP3EKVEJJBJuAR859xQu9UvP4oU8qENCMxwV0yi8,5122
 tactus/sandbox/protocol.py,sha256=hk8yYj6hDmGA32bet4AJ3d3CKiFLMBGoJnc1OrD3nLc,6397
 tactus/stdlib/__init__.py,sha256=26AUJ2IGp6OuhWaUeGSRwTa1r7W4e6-fhoLa4u7RjLQ,288
@@ -142,8 +142,8 @@ tactus/validation/generated/LuaParserVisitor.py,sha256=ageKSmHPxnO3jBS2fBtkmYBOd
 tactus/validation/generated/__init__.py,sha256=5gWlwRI0UvmHw2fnBpj_IG6N8oZeabr5tbj1AODDvjc,196
 tactus/validation/grammar/LuaLexer.g4,sha256=t2MXiTCr127RWAyQGvamkcU_m4veqPzSuHUtAKwalw4,2771
 tactus/validation/grammar/LuaParser.g4,sha256=ceZenb90BdiZmVdOxMGj9qJk3QbbWVZe5HUqPgoePfY,3202
-tactus-0.22.0.dist-info/METADATA,sha256=Ag0B4BYOcgBP9AxI_w4uOz7zT-Sn-FycdbuhWdtkw3E,55250
-tactus-0.22.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tactus-0.22.0.dist-info/entry_points.txt,sha256=vWseqty8m3z-Worje0IYxlioMjPDCoSsm0AtY4GghBY,47
-tactus-0.22.0.dist-info/licenses/LICENSE,sha256=ivohBcAIYnaLPQ-lKEeCXSMvQUVISpQfKyxHBHoa4GA,1066
-tactus-0.22.0.dist-info/RECORD,,
+tactus-0.23.0.dist-info/METADATA,sha256=Kvj_FpO-1s2v2VwKCLr8OKvaKO51OO4SRGe5KWxhLUI,55250
+tactus-0.23.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tactus-0.23.0.dist-info/entry_points.txt,sha256=vWseqty8m3z-Worje0IYxlioMjPDCoSsm0AtY4GghBY,47
+tactus-0.23.0.dist-info/licenses/LICENSE,sha256=ivohBcAIYnaLPQ-lKEeCXSMvQUVISpQfKyxHBHoa4GA,1066
+tactus-0.23.0.dist-info/RECORD,,