tactus 0.21.1__tar.gz → 0.23.0__tar.gz

{tactus-0.21.1 → tactus-0.23.0}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 <!-- version list -->
 
+## v0.23.0 (2026-01-11)
+
+### Features
+
+- Add AI chat assistant to Tactus IDE with streaming and tool execution
+  ([`81f544a`](https://github.com/AnthusAI/Tactus/commit/81f544a16e86a8f26b328583b432ad2f1ad26504))
+
+
+## v0.22.0 (2026-01-10)
+
+### Features
+
+- **agent**: Add configurable `module` parameter for DSPy module selection (#21)
+  ([#21](https://github.com/AnthusAI/Tactus/pull/21),
+  [`0c93af0`](https://github.com/AnthusAI/Tactus/commit/0c93af0575d191be58ed0635ed236e359d8b35af))
+
+
 ## v0.21.1 (2026-01-10)
 
 ### Bug Fixes

{tactus-0.21.1 → tactus-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.21.1
+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.21.1 → tactus-0.23.0}/SPECIFICATION.md

@@ -1633,6 +1633,72 @@ bedrock_agent = Agent {
 }
 ```
 
+### Module Configuration
+
+Agents can specify which DSPy module strategy to use via the `module` parameter. This controls how prompts are formatted and whether reasoning steps are included.
+
+**Default module** (Predict):
+
+```lua
+local done = require("tactus.tools.done")
+
+simple_agent = Agent {
+    provider = "openai",
+    model = "gpt-4o-mini",
+    system_prompt = "You are a helpful assistant.",
+    tools = {done}
+}
+```
+
+**ChainOfThought module** (adds reasoning steps):
+
+```lua
+local done = require("tactus.tools.done")
+
+thinking_agent = Agent {
+    provider = "openai",
+    model = "gpt-4o",
+    module = "ChainOfThought",
+    system_prompt = "You are a careful analyst.",
+    tools = {done}
+}
+```
+
+**Raw module** (minimal formatting for cost optimization):
+
+```lua
+local done = require("tactus.tools.done")
+
+efficient_agent = Agent {
+    provider = "openai",
+    model = "gpt-4o-mini",
+    module = "Raw",
+    system_prompt = "You are concise.",
+    tools = {done}
+}
+```
+
+**Available module options:**
+
+- **`"Predict"`** (default): Simple prediction without reasoning traces. Uses DSPy's standard field delimiters (~300-400 characters overhead per call).
+
+- **`"ChainOfThought"`**: Adds step-by-step reasoning before generating the final response. Useful for complex tasks requiring explicit reasoning. Increases token usage due to reasoning output (~500-2000 additional tokens depending on complexity).
+
+- **`"Raw"`**: Minimal formatting with direct LM calls. No DSPy delimiter overhead. Best for simple interactions, cost optimization, or when prompt space is constrained.
+
+**Token overhead comparison:**
+
+For a simple "Hello, World!" interaction:
+- **Raw**: 29 tokens total (20 prompt + 9 completion)
+- **Predict**: 230 tokens total (210 prompt + 19 completion)
+- **Difference**: ~8x more tokens with Predict due to delimiter formatting
+
+**When to use each module:**
+
+- Use **`Raw`** for simple interactions, high-volume API calls, or when minimizing cost is a priority
+- Use **`Predict`** when you need structured outputs or are using DSPy's optimization features (bootstrapping, etc.)
+- Use **`ChainOfThought`** for complex reasoning tasks where you want to see the agent's thought process
+
 ---
 
 ## DSPy Integration

tactus-0.23.0/examples/01-basics-hello-world.tac

@@ -0,0 +1,8 @@
+World = Agent {
+    provider = "openai",
+    model = "gpt-4o-mini",
+    system_prompt = "Your name is World.",
+    module = "Raw"  -- No DSPy delimiter formatting
+}
+
+return World("Hello, World!")

tactus-0.23.0/examples/test-raw-module.tac

@@ -0,0 +1,11 @@
+-- Test Raw module with minimal formatting
+WorldRaw = Agent {
+    provider = "openai",
+    model = "gpt-4o-mini",
+    system_prompt = "Your name is World.",
+    module = "Raw"  -- Use raw module for minimal overhead
+}
+
+return {
+    WorldRaw("Hello, World!")
+}

tactus-0.23.0/examples/test-raw-streaming.tac

@@ -0,0 +1,11 @@
+-- Test Raw module streaming
+Story = Agent {
+    provider = "openai",
+    model = "gpt-4o-mini",
+    system_prompt = "You are a storyteller.",
+    module = "Raw"  -- Use raw module for minimal overhead
+}
+
+return {
+    Story("Tell me a very short story about a robot.")
+}

tactus-0.23.0/features/57_chat_assistant.feature

@@ -0,0 +1,60 @@
+Feature: Chat Assistant with File Tools
+  As a developer using the Tactus IDE
+  I want to chat with an AI assistant that can read files
+  So that I can get help understanding my codebase
+
+  Background:
+    Given a workspace at "examples/"
+    And the chat assistant is configured with:
+      | parameter   | value    |
+      | provider    | openai   |
+      | model       | gpt-4o   |
+      | temperature | 0.7      |
+
+  Scenario: Basic chat without tools
+    When I send the message "Hello"
+    Then the assistant should respond
+    And the response should contain text
+    And no tools should be called
+
+  Scenario: View a file
+    When I send the message "Show me 01-basics-hello-world.tac"
+    Then the assistant should call tool "str_replace_based_edit_tool"
+    And the tool should be called with:
+      | parameter | value                          |
+      | command   | view                           |
+      | path      | 01-basics-hello-world.tac      |
+    And the tool result should contain line numbers
+    And the response should describe the file contents
+
+  Scenario: List directory contents
+    When I send the message "What files are in this directory?"
+    Then the assistant should call tool "str_replace_based_edit_tool"
+    And the tool should be called with:
+      | parameter | value |
+      | command   | view  |
+      | path      | .     |
+    And the tool result should show directories and files
+    And the response should list the files
+
+  Scenario: View specific line range
+    Given a workspace at "."
+    And the chat assistant is configured with:
+      | parameter   | value    |
+      | provider    | openai   |
+      | model       | gpt-4o   |
+      | temperature | 0.7      |
+    When I send the message "Show me lines 10-20 of tactus/validation/validator.py"
+    Then the assistant should call tool "str_replace_based_edit_tool"
+    And the tool should be called with:
+      | parameter  | value                            |
+      | command    | view                             |
+      | path       | tactus/validation/validator.py   |
+      | view_range | [10, 20]                         |
+    And the tool result should contain exactly 11 lines
+
+  Scenario: Security - reject path outside workspace
+    When I send the message "Show me /etc/passwd"
+    Then the assistant should call tool "str_replace_based_edit_tool"
+    And the tool result should contain "Error"
+    And the tool result should contain "outside workspace"

tactus-0.23.0/features/steps/chat_assistant_steps.py

@@ -0,0 +1,160 @@
+"""
+Step definitions for chat assistant feature.
+"""
+
+from behave import given, when, then
+from features.steps.support.harnesses import ChatAssistantHarness
+import ast
+
+
+@given('a workspace at "{path}"')
+def step_workspace_at(context, path):
+    """Set up workspace for chat assistant."""
+    context.workspace_root = path
+    context.chat = ChatAssistantHarness(workspace_root=path)
+
+
+@given("the chat assistant is configured with:")
+def step_configure_assistant(context):
+    """Configure assistant with parameters from table."""
+    config = {row["parameter"]: row["value"] for row in context.table}
+    context.chat.configure(config)
+
+
+@when('I send the message "{message}"')
+def step_send_message(context, message):
+    """Send a message to the assistant."""
+    context.chat.send_message(message)
+
+
+@then("the assistant should respond")
+def step_assistant_responds(context):
+    """Verify assistant generated a response."""
+    assert context.chat.has_response(), "No response from assistant"
+
+
+@then("the response should contain text")
+def step_response_contains_text(context):
+    """Verify response has text content."""
+    response = context.chat.get_response()
+    assert response, "Response is empty"
+    assert len(response.strip()) > 0, "Response contains no text"
+
+
+@then("no tools should be called")
+def step_no_tools_called(context):
+    """Verify no tools were invoked."""
+    tool_calls = context.chat.get_tool_calls()
+    assert len(tool_calls) == 0, f"Expected no tool calls, but got: {tool_calls}"
+
+
+@then('the assistant should call tool "{tool_name}"')
+def step_tool_called(context, tool_name):
+    """Verify a specific tool was called."""
+    assert context.chat.tool_was_called(
+        tool_name
+    ), f"Tool '{tool_name}' was not called. Called: {context.chat.get_tool_calls()}"
+
+
+@then("the tool should be called with:")
+def step_tool_called_with(context):
+    """Verify tool was called with specific parameters."""
+    expected_params = {row["parameter"]: row["value"] for row in context.table}
+
+    # Get the last tool call
+    tool_calls = context.chat.get_tool_calls()
+    assert len(tool_calls) > 0, "No tool calls found"
+
+    last_call = tool_calls[-1]
+    actual_params = last_call["params"]
+
+    for param, expected_value in expected_params.items():
+        assert (
+            param in actual_params
+        ), f"Parameter '{param}' not found in tool call. Available: {actual_params.keys()}"
+
+        actual_value = actual_params[param]
+
+        # Handle list parameters (like view_range)
+        if expected_value.startswith("["):
+            expected_value = ast.literal_eval(expected_value)
+
+        assert (
+            actual_value == expected_value
+        ), f"Parameter '{param}': expected {expected_value}, got {actual_value}"
+
+
+@then("the tool result should contain line numbers")
+def step_tool_result_has_line_numbers(context):
+    """Verify tool result includes line numbers."""
+    tool_calls = context.chat.get_tool_calls()
+    assert len(tool_calls) > 0, "No tool calls found"
+
+    last_call = tool_calls[-1]
+    result = last_call["result"]
+
+    # Check for line number format: "1: content"
+    lines = result.split("\n")
+    has_line_numbers = any(
+        line.strip() and line.split(":")[0].strip().isdigit() for line in lines if ":" in line
+    )
+
+    assert has_line_numbers, f"Tool result does not contain line numbers:\n{result}"
+
+
+@then("the response should describe the file contents")
+def step_response_describes_file(context):
+    """Verify response mentions file contents."""
+    response = context.chat.get_response()
+    assert response, "No response from assistant"
+    # Basic check - response should be non-empty
+    assert len(response.strip()) > 0, "Response is empty"
+
+
+@then("the tool result should show directories and files")
+def step_tool_result_shows_dirs_and_files(context):
+    """Verify tool result shows directory listing."""
+    tool_calls = context.chat.get_tool_calls()
+    assert len(tool_calls) > 0, "No tool calls found"
+
+    last_call = tool_calls[-1]
+    result = last_call["result"]
+
+    # Check for [DIR] or [FILE] markers
+    has_markers = "[DIR]" in result or "[FILE]" in result
+    assert has_markers, f"Tool result does not show directory markers:\n{result}"
+
+
+@then("the response should list the files")
+def step_response_lists_files(context):
+    """Verify response mentions files."""
+    response = context.chat.get_response()
+    assert response, "No response from assistant"
+    assert len(response.strip()) > 0, "Response is empty"
+
+
+@then("the tool result should contain exactly {count:d} lines")
+def step_tool_result_line_count(context, count):
+    """Verify tool result has specific number of lines."""
+    tool_calls = context.chat.get_tool_calls()
+    assert len(tool_calls) > 0, "No tool calls found"
+
+    last_call = tool_calls[-1]
+    result = last_call["result"]
+
+    lines = [line for line in result.split("\n") if line.strip()]
+    actual_count = len(lines)
+
+    assert actual_count == count, f"Expected {count} lines, got {actual_count}:\n{result}"
+
+
+@then('the tool result should contain "{text}"')
+def step_tool_result_contains(context, text):
+    """Verify tool result contains specific text."""
+    tool_calls = context.chat.get_tool_calls()
+    assert len(tool_calls) > 0, "No tool calls found"
+
+    last_call = tool_calls[-1]
+    result = last_call["result"]
+
+    assert text in result, f"Tool result does not contain '{text}':\n{result}"

{tactus-0.21.1 → tactus-0.23.0}/features/steps/support/harnesses.py

@@ -515,3 +515,161 @@ class FakeSessionStore:
             for session in self.sessions.values()
             if session.context.get("task_type") == task_type
         ]
+
+
+# ---------------------------------------------------------------------------
+# Chat assistant helpers
+# ---------------------------------------------------------------------------
+
+
+class ChatAssistantHarness:
+    """
+    Test harness for chat assistant that captures tool calls and responses.
+
+    Mocks the LLM to return deterministic tool calls based on message patterns,
+    but calls the actual tool implementations to verify they work correctly.
+    """
+
+    def __init__(self, workspace_root: str):
+        import os
+
+        # Convert to absolute path if relative
+        if not os.path.isabs(workspace_root):
+            # Resolve relative to project root (where behave is run from)
+            workspace_root = os.path.abspath(workspace_root)
+        self.workspace_root = workspace_root
+        self.config = {}
+        self.messages = []
+        self.tool_calls = []
+        self.response = None
+
+    def configure(self, config: Dict[str, Any]):
+        """Configure assistant (provider, model, etc.)"""
+        self.config = config
+
+    def send_message(self, message: str):
+        """
+        Send message and simulate assistant behavior.
+
+        For testing, we mock the LLM's decision-making but call real tools.
+        """
+        self.messages.append({"role": "user", "content": message})
+
+        # Mock LLM behavior based on message patterns
+        message_lower = message.lower()
+
+        if "hello" in message_lower and "show" not in message_lower:
+            # Simple greeting - no tools
+            self.response = "Hello! How can I help you today?"
+
+        elif "show me" in message_lower or "what files" in message_lower:
+            # File operation - simulate tool call
+            self._simulate_file_tool_call(message)
+
+        else:
+            # Default response
+            self.response = "I'm not sure how to help with that."
+
+    def _simulate_file_tool_call(self, message: str):
+        """
+        Simulate LLM deciding to call the file tool.
+
+        Parse the message to extract file path and determine command,
+        then call the actual tool implementation.
+        """
+        # Extract file path from message
+        # Simple pattern matching for testing
+        import re
+
+        # Check for line range first (more specific pattern)
+        view_range = None
+        range_match = re.search(r"lines (\d+)-(\d+) of (.+)", message.lower())
+        if range_match:
+            start = int(range_match.group(1))
+            end = int(range_match.group(2))
+            view_range = [start, end]
+            path = range_match.group(3).strip()
+        else:
+            # Pattern: "show me <path>" or "what files in <path>"
+            path_match = re.search(r"show me ([^\s]+)", message.lower())
+            if not path_match:
+                # Pattern: "what files are in this directory"
+                if "in this directory" in message.lower():
+                    path = "."
+                else:
+                    # Pattern: "what files are in the <path> directory"
+                    path_match = re.search(r"in the ([^\s]+) directory", message.lower())
+                    if path_match:
+                        # Add trailing slash for directory
+                        path = path_match.group(1) + "/"
+                    else:
+                        self.response = "I couldn't find a file path in your message."
+                        return
+            else:
+                path = path_match.group(1)
+
+        # Determine if it's a directory or file
+        command = "view"
+
+        # Call the actual tool (will be implemented later)
+        try:
+            # For now, just record the call - tool implementation comes next
+            tool_result = self._call_tool(command, path, view_range)
+
+            self.tool_calls.append(
+                {
+                    "tool": "str_replace_based_edit_tool",
+                    "params": {
+                        "command": command,
+                        "path": path,
+                        **({"view_range": view_range} if view_range else {}),
+                    },
+                    "result": tool_result,
+                }
+            )
+
+            # Generate response based on tool result
+            if "Error" in tool_result:
+                self.response = f"I encountered an error: {tool_result}"
+            else:
+                self.response = f"Here's what I found:\n\n{tool_result}"
+
+        except Exception as e:
+            self.response = f"Error calling tool: {str(e)}"
+
+    def _call_tool(self, command: str, path: str, view_range: Optional[List[int]] = None) -> str:
+        """
+        Call the actual tool implementation.
+        """
+        # Import the real tool
+        import sys
+        import os
+
+        backend_path = os.path.join(
+            os.path.dirname(__file__), "..", "..", "..", "tactus-ide", "backend"
+        )
+        if backend_path not in sys.path:
+            sys.path.insert(0, backend_path)
+
+        from text_editor_tool import str_replace_based_edit_tool
+
+        # Call the real tool
+        return str_replace_based_edit_tool(
+            workspace_root=self.workspace_root, command=command, path=path, view_range=view_range
+        )
+
+    def has_response(self) -> bool:
+        """Check if assistant generated a response."""
+        return self.response is not None
+
+    def get_response(self) -> str:
+        """Get the assistant's response."""
+        return self.response or ""
+
+    def get_tool_calls(self) -> List[Dict[str, Any]]:
+        """Get list of tool calls made."""
+        return self.tool_calls
+
+    def tool_was_called(self, tool_name: str) -> bool:
+        """Check if a specific tool was called."""
+        return any(call["tool"] == tool_name for call in self.tool_calls)

{tactus-0.21.1 → tactus-0.23.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tactus"
-version = "0.21.1"
+version = "0.23.0"
 description = "Tactus: Lua-based DSL for agentic workflows"
 readme = "README.md"
 requires-python = ">=3.11"

{tactus-0.21.1 → tactus-0.23.0}/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.21.1"
+__version__ = "0.23.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

{tactus-0.21.1 → tactus-0.23.0}/tactus/dspy/agent.py

@@ -6,7 +6,7 @@ This module provides an Agent implementation built on top of DSPy primitives
 as the original pydantic_ai-based Agent while using DSPy for LLM interactions.
 
 The Agent uses:
-- Module with chain_of_thought strategy for reasoning
+- Configurable DSPy module (default: Predict for simple pass-through, or ChainOfThought for reasoning)
 - History for conversation management
 - Tool handling similar to DSPy's ReAct pattern
 - Unified mocking via Mocks {} primitive
@@ -56,6 +56,7 @@ class DSPyAgentHandle:
         temperature: float = 0.7,
         max_tokens: Optional[int] = None,
         model_type: Optional[str] = None,
+        module: str = "Predict",
         initial_message: Optional[str] = None,
         registry: Any = None,
         mock_manager: Any = None,
@@ -78,6 +79,10 @@ class DSPyAgentHandle:
             temperature: Model temperature (default: 0.7)
             max_tokens: Maximum tokens for response
             model_type: Model type for DSPy (e.g., "chat", "responses" for reasoning models)
+            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
@@ -98,6 +103,7 @@ class DSPyAgentHandle:
         self.temperature = temperature
         self.max_tokens = max_tokens
         self.model_type = model_type
+        self.module = module
         self.initial_message = initial_message
         self.registry = registry
         self.mock_manager = mock_manager
@@ -267,6 +273,32 @@ class DSPyAgentHandle:
             cost_stats=cost_stats,
         )
 
+    def _module_to_strategy(self, module: str) -> str:
+        """
+        Map DSPy module name to internal strategy name.
+
+        Args:
+            module: DSPy module name (e.g., "Predict", "ChainOfThought")
+
+        Returns:
+            Internal strategy name for create_module()
+
+        Raises:
+            ValueError: If module name is not recognized
+        """
+        mapping = {
+            "Predict": "predict",
+            "ChainOfThought": "chain_of_thought",
+            "Raw": "raw",
+            # Future modules can be added here:
+            # "ReAct": "react",
+            # "ProgramOfThought": "program_of_thought",
+        }
+        strategy = mapping.get(module)
+        if strategy is None:
+            raise ValueError(f"Unknown module '{module}'. Supported: {list(mapping.keys())}")
+        return strategy
+
     def _build_module(self) -> TactusModule:
         """Build the internal DSPy module for this agent."""
         # Create a signature for agent turns
@@ -284,7 +316,7 @@ class DSPyAgentHandle:
             f"{self.name}_module",
             {
                 "signature": signature,
-                "strategy": "chain_of_thought",
+                "strategy": self._module_to_strategy(self.module),
             },
         )
 
@@ -874,6 +906,7 @@ def create_dspy_agent(
             - model: Model name (LiteLLM format)
             - tools: List of tools
             - toolsets: List of toolset names
+            - module: DSPy module type (default: "Predict"). Options: "Predict", "ChainOfThought"
             - Other optional configuration
         registry: Optional Registry instance for accessing mocks
         mock_manager: Optional MockManager instance for checking mocks
@@ -901,6 +934,7 @@ def create_dspy_agent(
         temperature=config.get("temperature", 0.7),
         max_tokens=config.get("max_tokens"),
         model_type=config.get("model_type"),
+        module=config.get("module", "Predict"),
         initial_message=config.get("initial_message"),
         registry=registry,
         mock_manager=mock_manager,
@@ -921,6 +955,7 @@ def create_dspy_agent(
                 "temperature",
                 "max_tokens",
                 "model_type",
+                "module",
                 "initial_message",
                 "log_handler",
                 "disable_streaming",