tactus 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

tactus/primitives/tool_handle.py

@@ -33,6 +33,7 @@ class ToolHandle:
         impl_fn: Callable,
         tool_primitive: Optional["ToolPrimitive"] = None,
         is_async: bool = False,
+        record_calls: bool = True,
     ):
         """
         Initialize a tool handle.
@@ -47,6 +48,7 @@ class ToolHandle:
         self.impl_fn = impl_fn
         self.tool_primitive = tool_primitive
         self.is_async = is_async
+        self.record_calls = record_calls
 
         logger.debug(f"ToolHandle created for '{name}' (async={is_async})")
 
@@ -77,7 +79,7 @@ class ToolHandle:
                 result = self.impl_fn(args)
 
             # Record the call for tracking
-            if self.tool_primitive:
+            if self.tool_primitive and self.record_calls:
                 self.tool_primitive.record_call(self.name, args, result)
 
             logger.debug(f"ToolHandle.call('{self.name}') returned: {result}")

tactus/sandbox/config.py

@@ -7,7 +7,7 @@ Defines the SandboxConfig Pydantic model for controlling container execution.
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 
 class SandboxLimits(BaseModel):
@@ -52,6 +52,12 @@ class SandboxConfig(BaseModel):
         description="Additional environment variables to pass to the container",
     )
 
+    # Volume mount settings
+    mount_current_dir: bool = Field(
+        default=True,
+        description="Mount current directory to /workspace:rw by default. Set false to disable.",
+    )
+
     # Additional volume mounts
     volumes: List[str] = Field(
         default_factory=list,
@@ -60,16 +66,17 @@ class SandboxConfig(BaseModel):
 
     # Network mode
     network: str = Field(
-        default="none",
-        description="Docker network mode (bridge allows outbound, none blocks all)",
+        default="bridge",
+        description="Docker network mode (bridge for broker access, none blocks all network)",
     )
 
     # Broker transport (how the secretless runtime reaches the host broker)
-    # - stdio: local Docker MVP (works on Docker Desktop with --network none)
-    # - tcp/tls: remote-mode spike (for K8s/cloud; requires container networking)
+    # - tcp: Standard mode using TCP sockets (works locally and in K8s/cloud)
+    # - tls: TCP with TLS encryption (for production deployments)
+    # - stdio: Legacy mode using stdin/stdout (deprecated due to buffering issues)
     broker_transport: str = Field(
-        default="stdio",
-        description="Broker transport for the runtime container: stdio, tcp, or tls",
+        default="tcp",
+        description="Broker transport for the runtime container: tcp, tls, or stdio (deprecated)",
     )
     broker_host: str = Field(
         default="host.docker.internal",
@@ -143,6 +150,15 @@ class SandboxConfig(BaseModel):
 
     model_config = {"arbitrary_types_allowed": True}
 
+    @model_validator(mode="after")
+    def add_default_volumes(self):
+        """Add default volume mounts based on config flags."""
+        if self.mount_current_dir:
+            # Insert at beginning so user volumes can override
+            if ".:/workspace:rw" not in self.volumes:
+                self.volumes.insert(0, ".:/workspace:rw")
+        return self
+
 
 def get_default_sandbox_config() -> SandboxConfig:
     """Get the default sandbox configuration."""

tactus/sandbox/container_runner.py

@@ -419,12 +419,40 @@ class ContainerRunner:
             )
 
             # Run container
-            result = await self._run_container(
-                docker_cmd,
-                request,
-                timeout=self.config.timeout,
-                event_handler=event_handler,
-            )
+            # If TCP broker is active, run it concurrently with the container
+            if broker_transport in ("tcp", "tls") and broker_server is not None:
+
+                async def run_broker_server():
+                    """Serve broker connections until explicitly closed."""
+                    try:
+                        await broker_server.serve()
+                    except Exception:
+                        # Broker server was closed (expected on cleanup)
+                        pass
+
+                # Run broker and container concurrently
+                broker_task = asyncio.create_task(run_broker_server())
+                try:
+                    result = await self._run_container(
+                        docker_cmd,
+                        request,
+                        timeout=self.config.timeout,
+                        event_handler=event_handler,
+                    )
+                finally:
+                    # Cancel broker task when container finishes
+                    broker_task.cancel()
+                    try:
+                        await broker_task
+                    except asyncio.CancelledError:
+                        pass
+            else:
+                result = await self._run_container(
+                    docker_cmd,
+                    request,
+                    timeout=self.config.timeout,
+                    event_handler=event_handler,
+                )
 
             result.duration_seconds = time.time() - start_time
             return result

tactus/stdlib/tac/tactus/tools/done.tac

@@ -16,9 +16,9 @@ Usage:
     end
 ]]--
 
--- Use named syntax so the tool has explicit name "done"
--- (required for mock mode where tool calls are recorded by name)
-return Tool "done" {
+-- Provide explicit name so the tool is recorded/mocked as "done"
+return Tool {
+    name = "done",
     description = "Signal task completion",
     input = {
         reason = field.string{required = false, description = "Reason for completion"}

tactus/stdlib/tac/tactus/tools/log.tac

@@ -17,6 +17,7 @@ Note: For direct logging in procedures, use the Log global directly:
 ]]--
 
 local log_tool = Tool {
+    name = "log",
     description = "Log a message during procedure execution",
     input = {
         message = field.string{required = true, description = "Message to log"},

tactus/testing/context.py

@@ -77,7 +77,6 @@ class TactusTestContext:
             storage_backend=storage,
             hitl_handler=hitl,
             tool_primitive=tool_primitive,  # Inject mocked tool if configured
-            skip_agents=bool(self.mock_tools),  # Skip agents in mock mode
             openai_api_key=os.environ.get("OPENAI_API_KEY"),  # Pass API key for real LLM calls
             log_handler=log_handler,  # Enable cost tracking
             source_file_path=str(self.procedure_file.resolve()),  # For require() path resolution

tactus/validation/semantic_visitor.py

@@ -155,6 +155,23 @@ class TactusDSLVisitor(LuaParserVisitor):
                 elif func_name == "Tool":
                     # Extract config from Tool {...}
                     config = self._extract_single_table_arg(func_call)
+                    if (
+                        config
+                        and isinstance(config, dict)
+                        and isinstance(config.get("name"), str)
+                        and config.get("name") != var_name
+                    ):
+                        self.errors.append(
+                            ValidationMessage(
+                                level="error",
+                                message=(
+                                    f"Tool name mismatch: '{var_name} = Tool {{ name = \"{config.get('name')}\" }}'. "
+                                    f"Remove the 'name' field or set it to '{var_name}'."
+                                ),
+                                location=(self.current_line, self.current_col),
+                                declaration="Tool",
+                            )
+                        )
                     self.builder.register_tool(var_name, config if config else {}, None)
                 elif func_name == "Toolset":
                     # Extract config from Toolset {...}
@@ -508,28 +525,21 @@ class TactusDSLVisitor(LuaParserVisitor):
             if args and len(args) >= 1 and isinstance(args[0], dict):
                 self.builder.register_top_level_output(args[0])
         elif func_name == "Tool":  # CamelCase only
-            # Tool("name", {config}, function) - DEPRECATED curried syntax
-            # New syntax: tool_name = Tool { config, function }
-            if args and len(args) >= 1:  # Support curried syntax
-                # First arg must be name (string)
-                if isinstance(args[0], str):
-                    tool_name = args[0]
-                    # Check for special stdlib import syntax: Tool "name" { use = "..." }
-                    # This is still allowed for backwards compatibility
-                    config = args[1] if len(args) >= 2 and isinstance(args[1], dict) else {}
-                    if config.get("use"):
-                        # This is a stdlib import, still allowed
-                        self.builder.register_tool(tool_name, config, None)
-                    else:
-                        # This is deprecated curried syntax
-                        self.errors.append(
-                            ValidationMessage(
-                                level="error",
-                                message=f'Curried syntax Tool "{tool_name}" {{...}} is deprecated. Use assignment syntax: {tool_name} = Tool {{...}}',
-                                location=(self.current_line, self.current_col),
-                                declaration="Tool",
-                            )
-                        )
+            # Curried syntax (Tool "name" {...} / Tool("name", ...)) is not supported.
+            # Use assignment syntax: my_tool = Tool { ... }.
+            if args and len(args) >= 1 and isinstance(args[0], str):
+                tool_name = args[0]
+                self.errors.append(
+                    ValidationMessage(
+                        level="error",
+                        message=(
+                            f'Curried Tool syntax is not supported: Tool "{tool_name}" {{...}}. '
+                            f"Use assignment syntax: {tool_name} = Tool {{...}}."
+                        ),
+                        location=(self.current_line, self.current_col),
+                        declaration="Tool",
+                    )
+                )
         elif func_name == "Toolset":  # CamelCase only
             # Toolset("name", {config})
             # or new curried syntax: Toolset "name" { config }

{tactus-0.27.0.dist-info → tactus-0.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.27.0
+Version: 0.28.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
@@ -636,6 +636,22 @@ researcher({
 
 See `examples/14-feature-per-turn-tools.tac` for a complete working example.
 
+### Checkpointed Steps (Determinism)
+
+For durable execution, any operation that touches external state (randomness, time, APIs not in tools) must be checkpointed. Tactus provides `Step.checkpoint` for this:
+
+```lua
+-- Non-deterministic operation wrapped in checkpoint
+local data = Step.checkpoint(function()
+  return http_get("https://api.example.com/data")
+end)
+
+-- On replay, the function is NOT called again.
+-- The previously saved 'data' is returned immediately.
+```
+
+This ensures that when a procedure resumes after a pause (e.g. waiting for a human), it doesn't re-execute side effects or get different random values.
+
 ### File I/O Operations
 
 Tactus provides safe file I/O operations for reading and writing data files, with all operations restricted to the current working directory for security.
@@ -1085,6 +1101,60 @@ default_provider: openai
 default_model: gpt-4o
 ```
 
+### DSPy Integration
+
+Tactus provides first-class support for **DSPy Modules and Signatures**, enabling you to build declarative, self-optimizing AI components directly within your agent workflows.
+
+**Modules & Signatures:**
+
+Instead of hand-tuning prompts, define what you want the model to do using typed signatures:
+
+```lua
+-- Configure the Language Model for DSPy
+LM("openai/gpt-4o")
+
+-- Define a module with a typed signature
+summarizer = Module {
+  signature = "text -> summary",
+  strategy = "chain_of_thought"  -- Use Chain of Thought reasoning
+}
+
+-- Or define complex signatures with specific fields
+classifier = Module {
+  signature = Signature {
+    input = {
+      text = field.string{description = "The customer email to classify"}
+    },
+    output = {
+      category = field.string{description = "Support category (Billing, Tech, Sales)"},
+      priority = field.string{description = "Priority level (Low, High, Critical)"}
+    }
+  },
+  strategy = "predict"
+}
+```
+
+**Using Modules:**
+
+Modules are callable just like Agents or Tools:
+
+```lua
+Procedure {
+  function(input)
+    -- Call the module
+    local result = classifier({text = input.email})
+    
+    if result.priority == "Critical" then
+      human_escalation({context = result})
+    else
+      auto_responder({category = result.category})
+    end
+  end
+}
+```
+
+This brings the power of DSPy's programmable LLM interfaces into Tactus's durable, orchestrated environment.
+
 ### Asynchronous Execution
 
 Tactus is built on **async I/O** from the ground up, making it ideal for LLM-based workflows where you spend most of your time waiting for API responses.
@@ -1275,6 +1345,21 @@ Then reference them in your procedure:
 local approved = Human.approve("confirm_publish")
 ```
 
+**System Alerts:**
+
+Send alerts to your monitoring infrastructure (Datadog, PagerDuty) directly from the workflow:
+
+```lua
+System.alert({
+  message = "Failure rate exceeded threshold",
+  level = "error",  -- info, warning, error, critical
+  context = {
+    current_rate = 0.15,
+    threshold = 0.05
+  }
+})
+```
+
 ### Cost Tracking & Metrics
 
 Tactus provides **comprehensive cost and performance tracking** for all LLM calls. Every agent interaction is monitored with detailed metrics, giving you complete visibility into costs, performance, and behavior.
@@ -1360,20 +1445,37 @@ The AI agent space is crowded. This section explains how Tactus differs from alt
 
 ### DSPy
 
-[DSPy](https://dspy.ai) (Declarative Self-improving Python) treats prompting as a compilation target. You define typed signatures and let optimizers automatically discover effective prompts, few-shot examples, or fine-tuning strategies. DSPy excels at tasks where you have training data and clear metrics—classification, RAG, information extraction—and want to programmatically iterate on prompt quality without manual tuning.
+[DSPy](https://dspy.ai) (Declarative Self-improving Python) is the engine that powers Tactus's intelligence layer. Tactus integrates DSPy directly, allowing you to define DSPy Modules, Signatures, and Optimizers within your `.tac` files using a clean Lua syntax.
+
+While DSPy provides the primitives for programming with language models (optimizing prompts, few-shot examples, and reasoning steps), Tactus provides the **orchestration layer** that makes these components production-ready:
 
-Tactus takes a different approach: rather than optimizing prompts automatically, it provides a token-efficient, sandboxed language that serves as a safe platform for user-contributed or AI-generated code. Where DSPy hides control flow behind module composition, Tactus makes it explicit—you write the loops, conditionals, and error handling while agents handle intelligence within each turn.
+- **Durability**: Tactus handles checkpointing and resuming DSPy module calls transparently.
+- **Orchestration**: Tactus manages the control flow (loops, conditionals) around your DSPy modules.
+- **Human-in-the-Loop**: Tactus allows humans to inspect, approve, or correct DSPy module outputs.
+- **Sandboxing**: Tactus runs DSPy components in a safe, sandboxed environment suitable for user-contributed code.
+
+You can use Tactus to define standard DSPy modules:
+
+```lua
+-- Define a DSPy Module with a typed signature
+qa = Module {
+  signature = "question -> answer",
+  strategy = "chain_of_thought"
+}
+
+-- Invoke it as part of a durable workflow
+local result = qa({question = "How does this work?"})
+```
 
-The frameworks are complementary: you could use DSPy to optimize the prompts that go into a Tactus agent's `system_prompt`, then use Tactus to orchestrate those optimized agents in a durable, human-in-the-loop workflow.
+Tactus and DSPy work together: DSPy handles the *thinking* (optimizing how to get the best answer), while Tactus handles the *doing* (ensuring the workflow completes reliably, even if it takes days).
 
-| | DSPy | Tactus |
-|-|------|--------|
-| **Core idea** | Programming, not prompting | Token-efficient, AI-manipulable orchestration language |
-| **Optimization** | Automatic (optimizers) | Manual or agent-driven self-evolution |
-| **Control flow** | Declarative composition | Imperative Lua DSL |
-| **Human-in-the-loop** | Not built-in | First-class citizen |
-| **Durability** | Caching | Checkpointing + replay |
-| **Target** | Researchers optimizing prompts | Engineers building production workflows |
+| | DSPy (Python) | Tactus (Lua) |
+|---|---|---|
+| **Role** | Intelligence Engine | Orchestration Engine |
+| **Focus** | Prompt optimization, reasoning | Durability, HITL, Sandboxing |
+| **Definition** | Python classes | Lua DSL primitives |
+| **State** | In-memory | Persisted & Resumable |
+| **Optimization** | Automatic (Teleprompters) | Agent-driven or Manual |
 
 ### LangGraph
 
@@ -1409,17 +1511,18 @@ The major AI companies have released their own agent frameworks:
 
 - **[Meta Llama Stack](https://ai.meta.com/blog/meta-llama-3-1/)** — Standardized interfaces for building agentic applications with Llama models. More of an API specification than a workflow framework.
 
-These frameworks are valuable if you're committed to a specific vendor's ecosystem. Tactus is model-agnostic (via Pydantic-AI) and designed to run anywhere—local, cloud, or AWS Lambda Durable Functions.
+These frameworks are valuable if you're committed to a specific vendor's ecosystem. Tactus is model-agnostic (via [DSPy](https://dspy.ai)) and designed to run anywhere—local, cloud, or AWS Lambda Durable Functions.
 
 ### Other Tools
 
-- **[Pydantic-AI](https://github.com/pydantic/pydantic-ai)** — Type-safe LLM integration that Tactus uses under the hood. Tactus adds orchestration, HITL, and durability on top.
+- **[Pydantic-AI](https://github.com/pydantic/pydantic-ai)** — Used for type-safe tool definitions and message structures.
 
 - **[Guidance](https://github.com/guidance-ai/guidance)** (Microsoft) — Interleaves constrained generation with control flow. Focuses on token-level control during generation rather than workflow orchestration.
 
 ## Complete Feature List
 
 - **Durable Execution**: Automatic position-based checkpointing for all operations (agent turns, model predictions, sub-procedure calls, HITL interactions) with replay-based recovery—resume from exactly where you left off after crashes, timeouts, or pauses
+- **DSPy Integration**: First-class support for DSPy Modules and Signatures, enabling declarative machine learning components and prompt optimization alongside agentic workflows
 - **Model Primitive**: First-class support for ML inference (PyTorch, HTTP, HuggingFace Transformers) with automatic checkpointing—distinct from conversational agents for classification, prediction, and transformation tasks
 - **Script Mode**: Write procedures without explicit `main` definitions—top-level `input`/`output` declarations and code automatically wrapped as the main procedure
 - **State Management**: Typed, schema-validated persistent state with automatic initialization from defaults and runtime validation
@@ -1434,7 +1537,7 @@ These frameworks are valuable if you're committed to a specific vendor's ecosyst
 - **Context Engineering**: Fine-grained control over conversation history per agent
 - **Typed Input/Output**: JSON Schema validation with UI generation support using `input`/`output`/`state` declarations
 - **Pluggable Backends**: Storage, HITL, and chat recording via Pydantic protocols
-- **LLM Integration**: Works with OpenAI and Bedrock via [pydantic-ai](https://github.com/pydantic/pydantic-ai)
+- **LLM Integration**: Works with OpenAI and Bedrock via [DSPy](https://dspy.ai)
 - **Standalone CLI**: Run workflows without any infrastructure
 - **Type-Safe**: Pydantic models throughout for validation and type safety
 

{tactus-0.27.0.dist-info → tactus-0.28.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-tactus/__init__.py,sha256=LUJ5Y8-SP4ux74ptueQkyZMMFke1LA8lJOuummuVh3E,1245
+tactus/__init__.py,sha256=8Tz1eNKHHz9MXIcRw6cUoT1NdeOpUm4R4JjXnudVXZE,1245
 tactus/adapters/__init__.py,sha256=lU8uUxuryFRIpVrn_KeVK7aUhsvOT1tYsuE3FOOIFpI,289
-tactus/adapters/broker_log.py,sha256=Eis5yXdrAkPnYYc49PQzOQfIst98CAO_6gVxjgfq0tw,1789
+tactus/adapters/broker_log.py,sha256=mIjARt1Q6ouWVbVri6zep1e8tzm9y28l4WOEdqiK39Q,2849
 tactus/adapters/cli_hitl.py,sha256=3dH58du0lN4k-OvQrAHrAqHFqBjolqNKFb94JaNHtn8,6964
 tactus/adapters/cli_log.py,sha256=uyTOLY9y26foAr-8COEYP6dejdO_Huur4i0DLaowfAY,8894
 tactus/adapters/cost_collector_log.py,sha256=Ha3pFMdC0HJ8eBnZpM1VRLm-94RKelu5PEPDgFgNKow,1701
@@ -16,15 +16,16 @@ tactus/backends/http_backend.py,sha256=D2N91I5bnjhHMLG84-U-BRS-mIuwoQq72Feffi7At
 tactus/backends/model_backend.py,sha256=P8dCUpDxJmA8_EO1snZuXyIyUZ_BlqReeC6zenO7Kv0,763
 tactus/backends/pytorch_backend.py,sha256=I7H7UTa_Scx9_FtmPWn-G4noadaNVEQj-9Kjtjpgl6E,3305
 tactus/broker/__init__.py,sha256=UTvqLofrgE3c4m6u2iNOg5R7BrS4dmfzMRO4Oq_0A9U,396
-tactus/broker/client.py,sha256=amN36-MHIjM7Sm-pImTGy9rJsf6rjB_BtxgHAIFxw7s,8983
-tactus/broker/server.py,sha256=x7DCf6DpeUSt9wECQTOlPxtNUoCCx9uZzml4RhX2DYo,16138
+tactus/broker/client.py,sha256=sDi1Cimuv0zH5S4n597nnUy_qis7pLBZf5IkwF81oDc,8618
+tactus/broker/protocol.py,sha256=fnVgMKU_R7oK2xBATnrYSH_r2R-yOmV2o_pJYw1JvVk,5238
+tactus/broker/server.py,sha256=ciP6FkPBfenfzrTNzkr6If7kQFs4B7mLU77A0hh7y_8,17154
 tactus/broker/stdio.py,sha256=JXkEz-PCU3IQXNkt16YJtYmwkR43eS6CfjxAHc-YCfQ,439
 tactus/cli/__init__.py,sha256=kVhdCkwWEPdt3vn9si-iKvh6M9817aOH6rLSsNzRuyg,80
-tactus/cli/app.py,sha256=f7LYPLaplroowGvI3dUnc4xh_wUFwko6EEMpvdqKXFA,83495
+tactus/cli/app.py,sha256=97lrjIQxDGM5PuvPZx9CeTZc0CyT1tBhLOl98oej3zE,83496
 tactus/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tactus/core/__init__.py,sha256=TK5rWr3HmOO_igFa5ESGp6teWwS58vnvQhIWqkcgqwk,880
 tactus/core/config_manager.py,sha256=u90XChTeb2reZ3I6c3o_zI2UlzlFCNtL9-NhE1Vm6L0,31577
-tactus/core/dsl_stubs.py,sha256=Q7ASuE3AjBgLNm6s3v6eDEJFWRy_eunl17kd-pcKV-A,67324
+tactus/core/dsl_stubs.py,sha256=-gio8VFQ_8atH3SOPC2s2bimXu1vYZc-I3Z6yJqdhIU,76070
 tactus/core/exceptions.py,sha256=HruvJQ4yIi78hOvvHviNZolcraMwXrlGQzxHqYFQapA,1468
 tactus/core/execution_context.py,sha256=WNd55_JhmkDifA9Td3xIs8to5bwGDlCgPcbvkvLYAv0,16658
 tactus/core/lua_sandbox.py,sha256=WuXRuXSl9ylU0y3ZMvyDWjWiG6GdLVn2csMY-2Zmrbg,18262
@@ -32,15 +33,15 @@ tactus/core/message_history_manager.py,sha256=e3_seV6bWSJVicrZYf2LmaQBvroDXDRc5T
 tactus/core/mocking.py,sha256=1MKtg8FHCYj-Goihi5b8xNNYo-MDuzSpsHEX_e7bnfg,9217
 tactus/core/output_validator.py,sha256=a-a_L-8oondMA4dzJMekhlHUF0vA_G_prMdFaBu5vhU,7823
 tactus/core/registry.py,sha256=1FKjj9wcTbz3VhCBGO6ylSb5WAaN-liLCQFe06nPfU4,20128
-tactus/core/runtime.py,sha256=SwrPgg7WfZuhYja25WmTDG3Wmi9mVvkjUQS58WalDvE,121942
+tactus/core/runtime.py,sha256=4iYe9ONVKTNc9QVf2Z2O99ofk_8shUYm0fn6oSwfzAg,122904
 tactus/core/template_resolver.py,sha256=6zRq4zT1lRHdLoa7M-yoLx4hFZ9RcjH9Y0EdaAtW9FU,4033
 tactus/core/yaml_parser.py,sha256=s7VB5Nijy6ReQE7ixlmvZArqupXs_sWP4EY4pCLv25k,13400
 tactus/core/dependencies/__init__.py,sha256=28-TM7_i-JqTD3hvkq1kMzr__A8VjfIKXymdW9mn5NM,362
 tactus/core/dependencies/registry.py,sha256=bgRdqJJTUrnQlu0wvjv2In1EPq7prZq-b9eBDhE3rmE,6114
 tactus/docker/Dockerfile,sha256=fnK5kZlgM-L7vboiwfTqcs70OsZsvh1ba4YzRxie138,1887
-tactus/docker/entrypoint.sh,sha256=-qYq5RQIGS6KirJ6NO0XiHZf_oAdfmk5HzHOBsiqxRM,1870
+tactus/docker/entrypoint.sh,sha256=pL-1MwMdjD1fGgRZYkBeXmJZg57Knmub9ETLYAANvOg,1985
 tactus/dspy/__init__.py,sha256=beUkvMUFdPvZE9-bEOfRo2TH-FoCvPT_L9_dpJPW324,1226
-tactus/dspy/agent.py,sha256=nY3jATEPuSzYH1b2aSxGgbE1YQ4-YARw6hXs8vd9o0A,42254
+tactus/dspy/agent.py,sha256=-GFvV6d-1ek-IMn-0ML_jFEL2a-2DsEhyKmgpeTdOmQ,43484
 tactus/dspy/broker_lm.py,sha256=EaXlJcUhfM0NV0fD1rASYKSO5gm846KRS5BoT0iO4zs,6239
 tactus/dspy/config.py,sha256=B22ON9Zp-dabI4NYeMbZ5lUL4kqihR7FQ8Z8xKT_eL8,6567
 tactus/dspy/history.py,sha256=0yGi3P5ruRUPoRyaCWsUDeuEYYsfproc_7pMVZuhmUo,5980
@@ -69,7 +70,7 @@ tactus/primitives/state.py,sha256=o3rsz-P8R2O66nsYmXOjn54342NIn6ldqTqp9XvgPLI,56
 tactus/primitives/step.py,sha256=2STt1M_9R0Ga5YHScA5i1eXqqIDI_S_q9E4GSyWhM2Y,7175
 tactus/primitives/system.py,sha256=jIzDLuL8a6owTPokAb7giwKYOxEtxmacntkNzzu8BWU,3350
 tactus/primitives/tool.py,sha256=KppWrbVxPwZ6aRk2Lw5ki1ACwV_65yK2wSFWaH3da88,12643
-tactus/primitives/tool_handle.py,sha256=Mxg5obWTeLvpGlKFPtVvUUJ0_AL8-KX2F3kqikhmsng,8987
+tactus/primitives/tool_handle.py,sha256=x6D4Zi-x-werFVBgB-F3mTtIMRbkYjPq3IBjjs8VSTc,9085
 tactus/primitives/toolset.py,sha256=T9DtULPgDX7CGBnfOtEx6SsKEtJPWrKXMOnHJer_spY,7779
 tactus/protocols/__init__.py,sha256=w5PFgHq8ov7BbNKcgCmbPSQ_E9l6F8xwrtxEQ2YSWO4,783
 tactus/protocols/chat_recorder.py,sha256=dswAHpwlxq30GTGKT-ktCIKCaixn5izEMSb7sbiZARE,2074
@@ -86,8 +87,8 @@ tactus/providers/bedrock.py,sha256=cVNDV7uHhCnnL6BNl7DFF8OwkD9ZYqa9CP2wXMcCJGY,3
 tactus/providers/google.py,sha256=wgZ3eiQif1rq1T8BK5V2kL_QVCmqBQZuWLz37y9cxOQ,3123
 tactus/providers/openai.py,sha256=3qSXfdELTHdU7vuRSxQrtnfNctt0HhrePOLFj3YlViA,2692
 tactus/sandbox/__init__.py,sha256=UCBvPD63szvSdwSzpznLW-cnJOgGkVHiKcmJtsAmnuA,1424
-tactus/sandbox/config.py,sha256=m4YcvulVun2gVZHeXoOfl0VgpoFnvbmYPhnmavXVp7A,4919
-tactus/sandbox/container_runner.py,sha256=drM8FBl7pjfCCm0BE331vGPA_v7KdWEUj2MT8W7Dt6E,38339
+tactus/sandbox/config.py,sha256=KuWtQwxHGVz3P_My5bOvMor3cxZMW8Y-wTLQszXP4Cg,5582
+tactus/sandbox/container_runner.py,sha256=eefK37PoV7hclJdw5uodC32rzuFvNLNDavnob1Wymtk,39561
 tactus/sandbox/docker_manager.py,sha256=SGv0IEN9usgyQRvbonrgOLm6GICel8ifzBAopAwOyt0,13949
 tactus/sandbox/entrypoint.py,sha256=Jbw7ZIOhBygiZa-LHoQAbQg4VJBzK_XrN8wnf1xD5xg,6803
 tactus/sandbox/protocol.py,sha256=1h36423pOFAwwZBgzMkeAIIjan1asgmBiIjN234YlpQ,6060
@@ -102,12 +103,12 @@ tactus/stdlib/io/hdf5.py,sha256=7ELLaQZI1GOsycU1a60J6RTPNLH7EMdaPAYlNx0dQLA,3025
 tactus/stdlib/io/json.py,sha256=P6C6rIwAxY97MivCanxKF8TmRotIUxBlHcuv8etmLu8,2641
 tactus/stdlib/io/parquet.py,sha256=hycr0pjqysjhggHx7_UZJL_jkeP1wz8BCozL39EWk-0,2045
 tactus/stdlib/io/tsv.py,sha256=456V2g-dp0mOTxo0ojM-rQl-LlmeV6WAVh0HmEDd_kQ,2350
-tactus/stdlib/tac/tactus/tools/done.tac,sha256=Byl_G_JJafn7qfqvqOM6x17tkkjcl_XkzUjyOqtHPDI,777
-tactus/stdlib/tac/tactus/tools/log.tac,sha256=FngGUo9kqUzdVdP9cS1Qd4OqPX5yFtd5wSLp655fui4,1374
+tactus/stdlib/tac/tactus/tools/done.tac,sha256=aCQzwL7SXq-rx18QGq3NLKoT_eweoVRObBkCSu4lkzo,732
+tactus/stdlib/tac/tactus/tools/log.tac,sha256=oRwnKxQZsZPXmZcGABZ6zM4NASV54tGAMClfsX8QNGk,1392
 tactus/testing/README.md,sha256=8AI-N9Llw0cQPweVkeUctEPsAOUviHrTZb48mF82EDE,7042
 tactus/testing/__init__.py,sha256=M5b3r9E0vkltfhqfIOSASk-qp6fDnm3FBxc9dDBPUhU,1540
 tactus/testing/behave_integration.py,sha256=mtAM30Uhj57_raGbPxAyMvfT-vnGnTm01UyeUqyE0H8,14887
-tactus/testing/context.py,sha256=2q5iLspN_i2CM1Bsc11JmcayDDcxGFa3EskOZomNMBk,14265
+tactus/testing/context.py,sha256=az7eQi9pZfjIYxIv2j02e9OGPNbr8Hww-UIRCEosvVY,14190
 tactus/testing/eval_models.py,sha256=UI3geZp4vilbn3Jt4Mjy95luRVON3T4sGnAwlpb7jLo,3540
 tactus/testing/evaluation_runner.py,sha256=_wemv2yf-N6wjIyhwxVJyoH4FABlKoBv-OKTcgwNm0Q,6908
 tactus/testing/evaluators.py,sha256=NW_LHhssdMRYCCoYmtJIsst-DEsk8iBVebsxRyHx7I0,20751
@@ -137,7 +138,7 @@ tactus/validation/LuaParserBase.py,sha256=o3klCIY0ANkVCU0VHml0IOYE4CdEledeoyoIAP
 tactus/validation/README.md,sha256=AS6vr4blY7IKWRsj4wuvWBHVMTc5fto7IgNmv-Rjkdo,5366
 tactus/validation/__init__.py,sha256=rnap-YvNievWigYYUewuXBcLtAdjZ8YpeJDYS1T7XZM,153
 tactus/validation/error_listener.py,sha256=ANaQHPzRSGQMgreYqZ4ZvIKGENj55FnrEQYUmqFvGaY,619
-tactus/validation/semantic_visitor.py,sha256=ERhrBDQ9kVCtC5QvjpYEHoCXjtiBE4-2gR8-eOUqwuo,36592
+tactus/validation/semantic_visitor.py,sha256=pQ8WV_9kilY7orDbn7YGFTyX4DrcjWfoApxVL1vwqcU,36882
 tactus/validation/validator.py,sha256=Vut4nWoNVbm1n_RRbdLVLJyBb6S29KjnxXi-SrRQd3Y,4842
 tactus/validation/generated/LuaLexer.interp,sha256=B-Xb6HNXS7YYYQB_cvsWzf8OQLFnEhZHDN5vCOyP3yw,20444
 tactus/validation/generated/LuaLexer.py,sha256=6B-HNB_vAp3bA5iACLvMWw0R4KFENsuiG7bccysxbRQ,67252
@@ -151,8 +152,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.27.0.dist-info/METADATA,sha256=aKGvCAKYFROL_2iq5UiWVLSGyoxbO6EWp5HROpUNsYI,55752
-tactus-0.27.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tactus-0.27.0.dist-info/entry_points.txt,sha256=vWseqty8m3z-Worje0IYxlioMjPDCoSsm0AtY4GghBY,47
-tactus-0.27.0.dist-info/licenses/LICENSE,sha256=ivohBcAIYnaLPQ-lKEeCXSMvQUVISpQfKyxHBHoa4GA,1066
-tactus-0.27.0.dist-info/RECORD,,
+tactus-0.28.0.dist-info/METADATA,sha256=hvZRdVInGcwogSbsULPG4vXf4hNUCAQrT6ByzL6f0VM,58441
+tactus-0.28.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tactus-0.28.0.dist-info/entry_points.txt,sha256=vWseqty8m3z-Worje0IYxlioMjPDCoSsm0AtY4GghBY,47
+tactus-0.28.0.dist-info/licenses/LICENSE,sha256=ivohBcAIYnaLPQ-lKEeCXSMvQUVISpQfKyxHBHoa4GA,1066
+tactus-0.28.0.dist-info/RECORD,,