tactus 0.35.1__py3-none-any.whl → 0.37.0__py3-none-any.whl

tactus/core/registry.py

@@ -6,7 +6,7 @@ procedure declarations from .tac files.
 """
 
 import logging
-from typing import Any
+from typing import Any, Dict, Optional, Union
 
 from pydantic import BaseModel, Field, ValidationError, ConfigDict
 
@@ -19,7 +19,7 @@ class OutputFieldDeclaration(BaseModel):
     name: str
     field_type: str = Field(alias="type")  # string, number, boolean, array, object
     required: bool = False
-    description: str | None = None
+    description: Optional[str] = None
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -31,7 +31,7 @@ class MessageHistoryConfiguration(BaseModel):
     """
 
     source: str = "own"  # "own", "shared", or another agent's name
-    filter: Any | None = None  # Lua function reference or filter name
+    filter: Optional[Any] = None  # Lua function reference or filter name
 
 
 class AgentOutputSchema(BaseModel):
@@ -44,21 +44,21 @@ class AgentDeclaration(BaseModel):
     """Agent declaration from DSL."""
 
     name: str
-    provider: str | None = None
-    model: str | dict[str, Any] = "gpt-4o"
-    system_prompt: str | Any  # String with {markers} or Lua function
-    initial_message: str | None = None
+    provider: Optional[str] = None
+    model: Union[str, Dict[str, Any]] = "gpt-4o"
+    system_prompt: Union[str, Any]  # String with {markers} or Lua function
+    initial_message: Optional[str] = None
     tools: list[Any] = Field(default_factory=list)  # Tool/toolset references and expressions
     inline_tools: list[dict[str, Any]] = Field(default_factory=list)  # Inline tool definitions
-    output: AgentOutputSchema | None = None  # Aligned with pydantic-ai
-    message_history: MessageHistoryConfiguration | None = None
+    output: Optional[AgentOutputSchema] = None  # Aligned with pydantic-ai
+    message_history: Optional[MessageHistoryConfiguration] = None
     max_turns: int = 50
     disable_streaming: bool = (
         False  # Disable streaming for models that don't support tools in streaming mode
     )
-    temperature: float | None = None
-    max_tokens: int | None = None
-    model_type: str | None = None  # e.g., "chat", "responses" for reasoning models
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    model_type: Optional[str] = None  # e.g., "chat", "responses" for reasoning models
 
     model_config = ConfigDict(extra="allow")
 
@@ -69,9 +69,9 @@ class HITLDeclaration(BaseModel):
     name: str
     hitl_type: str = Field(alias="type")  # approval, input, review
     message: str
-    timeout: int | None = None
+    timeout: Optional[int] = None
     default: Any = None
-    options: list[dict[str, Any]] | None = None
+    options: Optional[list[dict[str, Any]]] = None
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -81,9 +81,9 @@ class ScenarioDeclaration(BaseModel):
 
     name: str
     given: dict[str, Any] = Field(default_factory=dict)
-    when: str | None = None  # defaults to "procedure_completes"
-    then_output: dict[str, Any] | None = None
-    then_state: dict[str, Any] | None = None
+    when: Optional[str] = None  # defaults to "procedure_completes"
+    then_output: Optional[Dict[str, Any]] = None
+    then_state: Optional[Dict[str, Any]] = None
     mocks: dict[str, Any] = Field(default_factory=dict)  # tool_name -> response
 
 
@@ -134,7 +134,7 @@ class ProcedureRegistry(BaseModel):
     model_config = {"arbitrary_types_allowed": True}
 
     # Metadata
-    description: str | None = None
+    description: Optional[str] = None
 
     # Declarations
     input_schema: dict[str, Any] = Field(default_factory=dict)
@@ -154,26 +154,26 @@ class ProcedureRegistry(BaseModel):
     message_history_config: dict[str, Any] = Field(default_factory=dict)
 
     # Gherkin BDD Testing
-    gherkin_specifications: str | None = None  # Raw Gherkin text
+    gherkin_specifications: Optional[str] = None  # Raw Gherkin text
     specs_from_references: list[str] = Field(default_factory=list)  # External spec file paths
     custom_steps: dict[str, Any] = Field(default_factory=dict)  # step_text -> lua_function
     evaluation_config: dict[str, Any] = Field(default_factory=dict)  # runs, parallel, etc.
 
     # Pydantic Evals Integration
-    pydantic_evaluations: dict[str, Any] | None = None  # Pydantic Evals configuration
+    pydantic_evaluations: Optional[Dict[str, Any]] = None  # Pydantic Evals configuration
 
     # Prompts
     prompts: dict[str, str] = Field(default_factory=dict)
-    return_prompt: str | None = None
-    error_prompt: str | None = None
-    status_prompt: str | None = None
+    return_prompt: Optional[str] = None
+    error_prompt: Optional[str] = None
+    status_prompt: Optional[str] = None
 
     # Execution settings
     async_enabled: bool = False
     max_depth: int = 5
     max_turns: int = 50
-    default_provider: str | None = None
-    default_model: str | None = None
+    default_provider: Optional[str] = None
+    default_model: Optional[str] = None
 
     # Named procedures (for in-file sub-procedures)
     named_procedures: dict[str, dict[str, Any]] = Field(default_factory=dict)
@@ -193,8 +193,8 @@ class ValidationMessage(BaseModel):
 
     level: str  # "error" or "warning"
     message: str
-    location: tuple[int, int] | None = None
-    declaration: str | None = None
+    location: Optional[tuple[int, int]] = None
+    declaration: Optional[str] = None
 
 
 class ValidationResult(BaseModel):
@@ -203,7 +203,7 @@ class ValidationResult(BaseModel):
     valid: bool
     errors: list[ValidationMessage] = Field(default_factory=list)
     warnings: list[ValidationMessage] = Field(default_factory=list)
-    registry: ProcedureRegistry | None = None
+    registry: Optional["ProcedureRegistry"] = None
 
 
 class RegistryBuilder:
@@ -229,7 +229,7 @@ class RegistryBuilder:
         self,
         name: str,
         config: dict,
-        output_schema: dict | None = None,
+        output_schema: Optional[dict] = None,
     ) -> None:
         """Register an agent declaration."""
         agent_config = dict(config)

tactus/core/runtime.py

@@ -13,7 +13,7 @@ import io
 import logging
 import time
 import uuid
-from typing import Any
+from typing import Any, Dict, List, Optional
 
 from tactus.core.registry import ProcedureRegistry, RegistryBuilder
 from tactus.core.dsl_stubs import create_dsl_stubs, lua_table_to_dict
@@ -68,19 +68,19 @@ class TactusRuntime:
     def __init__(
         self,
         procedure_id: str,
-        storage_backend: StorageBackend | None = None,
-        hitl_handler: HITLHandler | None = None,
-        chat_recorder: ChatRecorder | None = None,
+        storage_backend: Optional[StorageBackend] = None,
+        hitl_handler: Optional[HITLHandler] = None,
+        chat_recorder: Optional[ChatRecorder] = None,
         mcp_server=None,
-        mcp_servers: dict[str, Any] | None = None,
-        openai_api_key: str | None = None,
+        mcp_servers: Optional[Dict[str, Any]] = None,
+        openai_api_key: Optional[str] = None,
         log_handler=None,
-        tool_primitive: ToolPrimitive | None = None,
+        tool_primitive: Optional[ToolPrimitive] = None,
         recursion_depth: int = 0,
-        tool_paths: list[str] | None = None,
-        external_config: dict[str, Any] | None = None,
-        run_id: str | None = None,
-        source_file_path: str | None = None,
+        tool_paths: Optional[List[str]] = None,
+        external_config: Optional[Dict[str, Any]] = None,
+        run_id: Optional[str] = None,
+        source_file_path: Optional[str] = None,
     ):
         """
         Initialize the Tactus runtime.
@@ -144,31 +144,31 @@ class TactusRuntime:
         self.source_file_path = source_file_path
 
         # Will be initialized during setup
-        self.config: dict[str, Any] | None = None  # Legacy YAML support
-        self.registry: ProcedureRegistry | None = None  # New DSL registry
-        self.lua_sandbox: LuaSandbox | None = None
-        self.output_validator: OutputValidator | None = None
-        self.template_resolver: TemplateResolver | None = None
-        self.message_history_manager: MessageHistoryManager | None = None
+        self.config: Optional[Dict[str, Any]] = None  # Legacy YAML support
+        self.registry: Optional[ProcedureRegistry] = None  # New DSL registry
+        self.lua_sandbox: Optional[LuaSandbox] = None
+        self.output_validator: Optional[OutputValidator] = None
+        self.template_resolver: Optional[TemplateResolver] = None
+        self.message_history_manager: Optional[MessageHistoryManager] = None
 
         # Execution context
-        self.execution_context: BaseExecutionContext | None = None
+        self.execution_context: Optional[BaseExecutionContext] = None
 
         # Primitives (shared across all agents)
-        self.state_primitive: StatePrimitive | None = None
-        self.iterations_primitive: IterationsPrimitive | None = None
-        self.stop_primitive: StopPrimitive | None = None
-        self.tool_primitive: ToolPrimitive | None = None
-        self.human_primitive: HumanPrimitive | None = None
-        self.step_primitive: StepPrimitive | None = None
-        self.checkpoint_primitive: CheckpointPrimitive | None = None
-        self.log_primitive: LogPrimitive | None = None
-        self.json_primitive: JsonPrimitive | None = None
-        self.retry_primitive: RetryPrimitive | None = None
-        self.file_primitive: FilePrimitive | None = None
-        self.procedure_primitive: ProcedurePrimitive | None = None
-        self.system_primitive: SystemPrimitive | None = None
-        self.host_primitive: HostPrimitive | None = None
+        self.state_primitive: Optional[StatePrimitive] = None
+        self.iterations_primitive: Optional[IterationsPrimitive] = None
+        self.stop_primitive: Optional[StopPrimitive] = None
+        self.tool_primitive: Optional[ToolPrimitive] = None
+        self.human_primitive: Optional[HumanPrimitive] = None
+        self.step_primitive: Optional[StepPrimitive] = None
+        self.checkpoint_primitive: Optional[CheckpointPrimitive] = None
+        self.log_primitive: Optional[LogPrimitive] = None
+        self.json_primitive: Optional[JsonPrimitive] = None
+        self.retry_primitive: Optional[RetryPrimitive] = None
+        self.file_primitive: Optional[FilePrimitive] = None
+        self.procedure_primitive: Optional[ProcedurePrimitive] = None
+        self.system_primitive: Optional[SystemPrimitive] = None
+        self.host_primitive: Optional[HostPrimitive] = None
 
         # Agent primitives (one per agent)
         self.agents: dict[str, Any] = {}
@@ -181,17 +181,17 @@ class TactusRuntime:
 
         # User dependencies (HTTP clients, DB connections, etc.)
         self.user_dependencies: dict[str, Any] = {}
-        self.dependency_manager: Any | None = None  # ResourceManager for cleanup
+        self.dependency_manager: Optional[Any] = None  # ResourceManager for cleanup
 
         # Mock manager for testing
-        self.mock_manager: Any | None = None  # MockManager instance
-        self.external_agent_mocks: dict[str, list[dict[str, Any]]] | None = None
+        self.mock_manager: Optional[Any] = None  # MockManager instance
+        self.external_agent_mocks: Optional[Dict[str, List[Dict[str, Any]]]] = None
         self.mock_all_agents: bool = False
 
         logger.info("TactusRuntime initialized for procedure %s", procedure_id)
 
     async def execute(
-        self, source: str, context: dict[str, Any] | None = None, format: str = "yaml"
+        self, source: str, context: Optional[Dict[str, Any]] = None, format: str = "yaml"
     ) -> dict[str, Any]:
         """
         Execute a workflow (Lua DSL or legacy YAML format).
@@ -221,17 +221,7 @@ class TactusRuntime:
             logger.info("Step 0: Setting up Lua sandbox")
             strict_determinism = self.external_config.get("strict_determinism", False)
 
-            # Compute base_path for sandbox from source file path if available
-            # This ensures require() works correctly even when running from different directories
-            sandbox_base_path = None
-            if self.source_file_path:
-                from pathlib import Path
-
-                sandbox_base_path = str(Path(self.source_file_path).parent.resolve())
-                logger.debug(
-                    "Using source file directory as sandbox base_path: %s",
-                    sandbox_base_path,
-                )
+            sandbox_base_path = self._resolve_sandbox_base_path()
 
             self.lua_sandbox = LuaSandbox(
                 execution_context=None,
@@ -242,13 +232,7 @@ class TactusRuntime:
             # 0.5. Create execution context EARLY so it's available during DSL parsing
             # This is critical for immediate agent creation during parsing
             logger.info("Step 0.5: Creating execution context (early)")
-            self.execution_context = BaseExecutionContext(
-                procedure_id=self.procedure_id,
-                storage_backend=self.storage_backend,
-                hitl_handler=self.hitl_handler,
-                strict_determinism=strict_determinism,
-                log_handler=self.log_handler,
-            )
+            self.execution_context = self._create_execution_context(strict_determinism)
 
             # Set run_id if provided
             if self.run_id:
@@ -788,9 +772,33 @@ class TactusRuntime:
                 except Exception as e:
                     logger.warning("Error cleaning up dependencies: %s", e)
 
+    def _resolve_sandbox_base_path(self) -> Optional[str]:
+        # Compute base_path for sandbox from source file path if available.
+        # This ensures require() works correctly even when running from different directories.
+        if not self.source_file_path:
+            return None
+
+        from pathlib import Path
+
+        sandbox_base_path = str(Path(self.source_file_path).parent.resolve())
+        logger.debug(
+            "Using source file directory as sandbox base_path: %s",
+            sandbox_base_path,
+        )
+        return sandbox_base_path
+
+    def _create_execution_context(self, strict_determinism: bool) -> BaseExecutionContext:
+        return BaseExecutionContext(
+            procedure_id=self.procedure_id,
+            storage_backend=self.storage_backend,
+            hitl_handler=self.hitl_handler,
+            strict_determinism=strict_determinism,
+            log_handler=self.log_handler,
+        )
+
     async def _initialize_primitives(
         self,
-        placeholder_tool: ToolPrimitive | None = None,
+        placeholder_tool: Optional[ToolPrimitive] = None,
     ):
         """Initialize all primitive objects.
 
@@ -828,7 +836,7 @@ class TactusRuntime:
 
         logger.debug("All primitives initialized")
 
-    def resolve_toolset(self, name: str) -> Any | None:
+    def resolve_toolset(self, name: str) -> Optional[Any]:
         """
         Resolve a toolset by name from runtime's registered toolsets.
 
@@ -1039,7 +1047,7 @@ class TactusRuntime:
         for name, toolset in self.toolset_registry.items():
             logger.debug(f"  - {name}: {type(toolset)} -> {toolset}")
 
-    async def _resolve_tool_source(self, tool_name: str, source: str) -> Any | None:
+    async def _resolve_tool_source(self, tool_name: str, source: str) -> Optional[Any]:
         """
         Resolve a tool from an external source.
 
@@ -1434,7 +1442,7 @@ class TactusRuntime:
 
     async def _create_toolset_from_config(
         self, name: str, definition: dict[str, Any]
-    ) -> Any | None:
+    ) -> Optional[Any]:
         """
         Create toolset from YAML config definition.
 
@@ -2186,7 +2194,7 @@ class TactusRuntime:
             if is_required:
                 fields[field_name] = (field_type, ...)  # Required field
             else:
-                fields[field_name] = (field_type | None, None)  # Optional field
+                fields[field_name] = (Optional[field_type], None)  # Optional field
 
         return create_model(model_name, **fields)
 
@@ -2644,7 +2652,7 @@ class TactusRuntime:
         in_body = False
         brace_depth = 0
         function_depth = 0  # Track function...end blocks
-        long_string_eq: str | None = None
+        long_string_eq: Optional[str] = None
 
         decl_start = re.compile(
             r"^\s*(?:"
@@ -2863,7 +2871,7 @@ class TactusRuntime:
         return False
 
     def _parse_declarations(
-        self, source: str, tool_primitive: ToolPrimitive | None = None
+        self, source: str, tool_primitive: Optional[ToolPrimitive] = None
     ) -> ProcedureRegistry:
         """
         Execute .tac to collect declarations.

tactus/dspy/broker_lm.py

@@ -11,7 +11,7 @@ while still supporting streaming via DSPy's `streamify()` mechanism.
 from __future__ import annotations
 
 import logging
-from typing import Any
+from typing import Any, Dict, List, Optional
 
 import dspy
 import litellm
@@ -42,10 +42,10 @@ class BrokeredLM(dspy.BaseLM):
         model: str,
         *,
         model_type: str = "chat",
-        temperature: float | None = None,
-        max_tokens: int | None = None,
-        cache: bool | None = None,
-        socket_path: str | None = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        cache: Optional[bool] = None,
+        socket_path: Optional[str] = None,
         **kwargs: Any,
     ):
         if model_type != "chat":
@@ -70,12 +70,18 @@ class BrokeredLM(dspy.BaseLM):
         self._client = env_client
 
     def forward(
-        self, prompt: str | None = None, messages: list[dict[str, Any]] | None = None, **kwargs: Any
+        self,
+        prompt: Optional[str] = None,
+        messages: Optional[List[Dict[str, Any]]] = None,
+        **kwargs: Any,
     ):
         return syncify(self.aforward)(prompt=prompt, messages=messages, **kwargs)
 
     async def aforward(
-        self, prompt: str | None = None, messages: list[dict[str, Any]] | None = None, **kwargs: Any
+        self,
+        prompt: Optional[str] = None,
+        messages: Optional[List[Dict[str, Any]]] = None,
+        **kwargs: Any,
     ):
         provider, model_id = _split_provider_model(self.model)
 

tactus/dspy/config.py

@@ -103,10 +103,13 @@ def configure_lm(
 
     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}"
-    )
+    try:
+        adapter = ChatAdapter(use_native_function_calling=True)
+    except TypeError:
+        adapter = ChatAdapter()
+
+    use_native = getattr(adapter, "use_native_function_calling", None)
+    logger.info(f"[ADAPTER] Created ChatAdapter with use_native_function_calling={use_native}")
 
     # Set as global default with adapter
     dspy.configure(lm=lm, adapter=adapter)