tactus 0.23.0__py3-none-any.whl → 0.25.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.23.0"
+__version__ = "0.25.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

tactus/cli/app.py

@@ -41,6 +41,30 @@ app = typer.Typer(
 )
 
 
+@app.callback(invoke_without_command=True)
+def main_callback(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show version and exit",
+        is_eager=True,
+    ),
+):
+    """Tactus CLI callback for global options."""
+    if version:
+        from tactus import __version__
+
+        console.print(f"Tactus version: [bold]{__version__}[/bold]")
+        raise typer.Exit()
+
+    # If no subcommand was invoked and version flag not set, show help
+    if ctx.invoked_subcommand is None:
+        console.print(ctx.get_help())
+        raise typer.Exit()
+
+
 def load_tactus_config():
     """
     Load Tactus configuration from standard config locations.
@@ -1155,6 +1179,7 @@ def test(
             ("aws", "access_key_id"): "AWS_ACCESS_KEY_ID",
             ("aws", "secret_access_key"): "AWS_SECRET_ACCESS_KEY",
             ("aws", "default_region"): "AWS_DEFAULT_REGION",
+            ("aws", "profile"): "AWS_PROFILE",
         }
 
         for config_key, env_key in env_mappings.items():

tactus/core/config_manager.py

@@ -8,12 +8,60 @@ import logging
 import os
 import yaml
 from pathlib import Path
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional, List, Tuple
 from copy import deepcopy
+from dataclasses import dataclass, field
 
 logger = logging.getLogger(__name__)
 
 
+@dataclass
+class ConfigValue:
+    """
+    Represents a configuration value with source tracking metadata.
+
+    This class wraps config values with information about where they came from
+    and how they were overridden through the cascade system.
+    """
+
+    value: Any
+    """The actual configuration value"""
+
+    source: str
+    """Source identifier (e.g., 'user:/path/to/config.yml', 'environment:OPENAI_API_KEY')"""
+
+    source_type: str
+    """Normalized source type: 'system', 'user', 'project', 'parent', 'local', 'sidecar', 'environment'"""
+
+    path: str
+    """Config path (e.g., 'aws.region', 'ide.theme')"""
+
+    overridden_by: Optional[str] = None
+    """If overridden, what source did the override? None if this is the final value."""
+
+    override_chain: List[Tuple[str, Any]] = field(default_factory=list)
+    """History of overrides: [(source, value), ...] in chronological order"""
+
+    is_env_override: bool = False
+    """True if currently overridden by an environment variable"""
+
+    original_env_var: Optional[str] = None
+    """Original environment variable name if value came from env (e.g., 'OPENAI_API_KEY')"""
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "value": self.value,
+            "source": self.source,
+            "source_type": self.source_type,
+            "path": self.path,
+            "overridden_by": self.overridden_by,
+            "override_chain": self.override_chain,
+            "is_env_override": self.is_env_override,
+            "original_env_var": self.original_env_var,
+        }
+
+
 class ConfigManager:
     """
     Manages configuration loading and merging from multiple sources.
@@ -32,11 +80,15 @@ class ConfigManager:
     def __init__(self):
         """Initialize configuration manager."""
         self.loaded_configs = []  # Track loaded configs for debugging
+        self.env_var_mapping = {}  # Track which env var each config key came from
 
     def load_cascade(self, procedure_path: Path) -> Dict[str, Any]:
         """
         Load and merge all configuration sources in priority order.
 
+        Priority order (lowest to highest):
+        System → User → Project → Parent → Local → Environment → Sidecar → CLI
+
         Args:
             procedure_path: Path to the .tac procedure file
 
@@ -45,13 +97,7 @@ class ConfigManager:
         """
         configs = []
 
-        # 1. Environment variables (lowest priority)
-        env_config = self._load_from_environment()
-        if env_config:
-            configs.append(("environment", env_config))
-            logger.debug("Loaded config from environment variables")
-
-        # 2. System config (lowest precedence among config files)
+        # 1. System config (lowest precedence)
         for system_path in self._get_system_config_paths():
             if system_path.exists():
                 system_config = self._load_yaml_file(system_path)
@@ -59,7 +105,7 @@ class ConfigManager:
                     configs.append((f"system:{system_path}", system_config))
                     logger.debug(f"Loaded system config: {system_path}")
 
-        # 3. User config (~/.tactus/config.yml, XDG, etc.)
+        # 2. User config (~/.tactus/config.yml, XDG, etc.)
         for user_path in self._get_user_config_paths():
             if user_path.exists():
                 user_config = self._load_yaml_file(user_path)
@@ -67,7 +113,7 @@ class ConfigManager:
                     configs.append((f"user:{user_path}", user_config))
                     logger.debug(f"Loaded user config: {user_path}")
 
-        # 4. Project config (.tactus/config.yml in cwd)
+        # 3. Project config (.tactus/config.yml in cwd)
         root_config_path = Path.cwd() / ".tactus" / "config.yml"
         if root_config_path.exists():
             root_config = self._load_yaml_file(root_config_path)
@@ -75,7 +121,7 @@ class ConfigManager:
                 configs.append(("root", root_config))
                 logger.debug(f"Loaded root config: {root_config_path}")
 
-        # 5. Parent directory configs (walk up from procedure directory)
+        # 4. Parent directory configs (walk up from procedure directory)
         procedure_dir = procedure_path.parent.resolve()
         parent_configs = self._find_directory_configs(procedure_dir)
         for config_path in parent_configs:
@@ -84,7 +130,7 @@ class ConfigManager:
                 configs.append((f"parent:{config_path}", config))
                 logger.debug(f"Loaded parent config: {config_path}")
 
-        # 6. Local directory config (.tactus/config.yml in procedure's directory)
+        # 5. Local directory config (.tactus/config.yml in procedure's directory)
         local_config_path = procedure_dir / ".tactus" / "config.yml"
         if local_config_path.exists() and local_config_path not in parent_configs:
             local_config = self._load_yaml_file(local_config_path)
@@ -92,6 +138,12 @@ class ConfigManager:
                 configs.append(("local", local_config))
                 logger.debug(f"Loaded local config: {local_config_path}")
 
+        # 6. Environment variables (override config files)
+        env_config = self._load_from_environment()
+        if env_config:
+            configs.append(("environment", env_config))
+            logger.debug("Loaded config from environment variables")
+
         # 7. Sidecar config (highest priority, except CLI args)
         sidecar_path = self._find_sidecar_config(procedure_path)
         if sidecar_path:
@@ -187,18 +239,22 @@ class ConfigManager:
         """
         Load configuration from environment variables.
 
+        Also populates self.env_var_mapping to track which env var each config key came from.
+
         Returns:
             Configuration dictionary from environment
         """
         config = {}
 
         # Load known config keys from environment
+        # NOTE: Keys must match the config file structure (nested under provider name)
         env_mappings = {
-            "OPENAI_API_KEY": "openai_api_key",
-            "GOOGLE_API_KEY": "google_api_key",
+            "OPENAI_API_KEY": ("openai", "api_key"),
+            "GOOGLE_API_KEY": ("google", "api_key"),
             "AWS_ACCESS_KEY_ID": ("aws", "access_key_id"),
             "AWS_SECRET_ACCESS_KEY": ("aws", "secret_access_key"),
             "AWS_DEFAULT_REGION": ("aws", "default_region"),
+            "AWS_PROFILE": ("aws", "profile"),
             "TOOL_PATHS": "tool_paths",
             # Sandbox configuration
             "TACTUS_SANDBOX_ENABLED": ("sandbox", "enabled"),
@@ -220,16 +276,21 @@ class ConfigManager:
                     if config_key[0] not in config:
                         config[config_key[0]] = {}
                     config[config_key[0]][config_key[1]] = value
+                    # Track env var name for this nested key
+                    path = f"{config_key[0]}.{config_key[1]}"
+                    self.env_var_mapping[path] = env_key
                 elif config_key == "tool_paths":
                     # Parse JSON list
                     import json
 
                     try:
                         config[config_key] = json.loads(value)
+                        self.env_var_mapping[config_key] = env_key
                     except json.JSONDecodeError:
                         logger.warning(f"Failed to parse TOOL_PATHS as JSON: {value}")
                 else:
                     config[config_key] = value
+                    self.env_var_mapping[config_key] = env_key
 
         return config
 
@@ -335,3 +396,395 @@ class ConfigManager:
                 result[key] = deepcopy(value)
 
         return result
+
+    def _deep_merge_with_tracking(
+        self,
+        base: Dict[str, Any],
+        override: Dict[str, Any],
+        base_source: str,
+        override_source: str,
+        path_prefix: str = "",
+        base_source_map: Optional[Dict[str, ConfigValue]] = None,
+    ) -> Tuple[Dict[str, Any], Dict[str, ConfigValue]]:
+        """
+        Deep merge with source tracking at every level.
+
+        This method performs the same merge logic as _deep_merge() but also
+        tracks where each value came from and builds a complete override chain.
+
+        Args:
+            base: Base dictionary
+            override: Override dictionary (takes precedence)
+            base_source: Source identifier for base config
+            override_source: Source identifier for override config
+            path_prefix: Current path prefix for nested keys
+            base_source_map: Existing source map from base (for nested merges)
+
+        Returns:
+            Tuple of (merged_dict, source_map)
+            - merged_dict: The merged configuration
+            - source_map: Dict mapping paths to ConfigValue objects
+        """
+        result = deepcopy(base)
+        source_map: Dict[str, ConfigValue] = base_source_map.copy() if base_source_map else {}
+
+        # Normalize source types
+        base_source_type = base_source.split(":")[0] if ":" in base_source else base_source
+        override_source_type = (
+            override_source.split(":")[0] if ":" in override_source else override_source
+        )
+
+        for key, value in override.items():
+            current_path = f"{path_prefix}.{key}" if path_prefix else key
+
+            if key in result:
+                base_value = result[key]
+
+                # If both are dicts, deep merge recursively with tracking
+                if isinstance(base_value, dict) and isinstance(value, dict):
+                    # Get nested source map for base
+                    nested_base_source_map = {
+                        k: v for k, v in source_map.items() if k.startswith(current_path + ".")
+                    }
+
+                    # Ensure all base dict values are tracked before merge
+                    # This handles cases where base dict has values that aren't yet tracked
+                    # Use overwrite=False to preserve existing source info from earlier merges
+                    self._track_nested_values(
+                        base_value,
+                        base_source,
+                        base_source_type,
+                        current_path,
+                        nested_base_source_map,
+                        overwrite=False,
+                    )
+
+                    merged_dict, nested_source_map = self._deep_merge_with_tracking(
+                        base_value,
+                        value,
+                        base_source,
+                        override_source,
+                        current_path,
+                        nested_base_source_map,
+                    )
+                    result[key] = merged_dict
+
+                    # Update source map with nested results
+                    source_map.update(nested_source_map)
+
+                    # Track the dict itself
+                    if current_path in source_map:
+                        # Build override chain
+                        override_chain = source_map[current_path].override_chain.copy()
+                        override_chain.append((override_source, value))
+                    else:
+                        override_chain = [(base_source, base_value), (override_source, value)]
+
+                    # Get env var name if from environment
+                    env_var_name = None
+                    if override_source_type == "environment":
+                        env_var_name = self.env_var_mapping.get(current_path)
+
+                    source_map[current_path] = ConfigValue(
+                        value=merged_dict,
+                        source=override_source,
+                        source_type=override_source_type,
+                        path=current_path,
+                        overridden_by=None,  # Final value
+                        override_chain=override_chain,
+                        is_env_override=(override_source_type == "environment"),
+                        original_env_var=env_var_name,
+                    )
+
+                # If both are lists, extend (combine)
+                elif isinstance(base_value, list) and isinstance(value, list):
+                    # Combine lists, removing duplicates while preserving order
+                    combined = base_value.copy()
+                    for item in value:
+                        if item not in combined:
+                            combined.append(item)
+                    result[key] = combined
+
+                    # Track list override
+                    if current_path in source_map:
+                        override_chain = source_map[current_path].override_chain.copy()
+                        override_chain.append((override_source, value))
+                    else:
+                        override_chain = [(base_source, base_value), (override_source, value)]
+
+                    # Get env var name if from environment
+                    env_var_name = None
+                    if override_source_type == "environment":
+                        env_var_name = self.env_var_mapping.get(current_path)
+
+                    source_map[current_path] = ConfigValue(
+                        value=combined,
+                        source=override_source,
+                        source_type=override_source_type,
+                        path=current_path,
+                        overridden_by=None,
+                        override_chain=override_chain,
+                        is_env_override=(override_source_type == "environment"),
+                        original_env_var=env_var_name,
+                    )
+
+                # Otherwise, override takes precedence
+                else:
+                    result[key] = deepcopy(value)
+
+                    # Track simple value override
+                    if current_path in source_map:
+                        override_chain = source_map[current_path].override_chain.copy()
+                        override_chain.append((override_source, value))
+                    else:
+                        override_chain = [(base_source, base_value), (override_source, value)]
+
+                    # Get env var name if from environment
+                    env_var_name = None
+                    if override_source_type == "environment":
+                        env_var_name = self.env_var_mapping.get(current_path)
+
+                    source_map[current_path] = ConfigValue(
+                        value=value,
+                        source=override_source,
+                        source_type=override_source_type,
+                        path=current_path,
+                        overridden_by=None,
+                        override_chain=override_chain,
+                        is_env_override=(override_source_type == "environment"),
+                        original_env_var=env_var_name,
+                    )
+            else:
+                # New key, not an override
+                result[key] = deepcopy(value)
+
+                # Get env var name if from environment
+                env_var_name = None
+                if override_source_type == "environment":
+                    env_var_name = self.env_var_mapping.get(current_path)
+
+                # Track as new value
+                source_map[current_path] = ConfigValue(
+                    value=value,
+                    source=override_source,
+                    source_type=override_source_type,
+                    path=current_path,
+                    overridden_by=None,
+                    override_chain=[(override_source, value)],
+                    is_env_override=(override_source_type == "environment"),
+                    original_env_var=env_var_name,
+                )
+
+                # For nested dicts/lists in new keys, track their children
+                if isinstance(value, dict):
+                    self._track_nested_values(
+                        value, override_source, override_source_type, current_path, source_map
+                    )
+
+        return result, source_map
+
+    def _track_nested_values(
+        self,
+        obj: Any,
+        source: str,
+        source_type: str,
+        path_prefix: str,
+        source_map: Dict[str, ConfigValue],
+        overwrite: bool = True,
+    ) -> None:
+        """
+        Recursively track nested values in dicts and lists.
+
+        This is used to populate source_map for values that don't have overrides.
+
+        Args:
+            obj: The object to track values from
+            source: Source identifier (e.g., "user:/path" or "environment")
+            source_type: Normalized type (e.g., "user", "environment")
+            path_prefix: Current path prefix for nested keys
+            source_map: Dict to populate with ConfigValue entries
+            overwrite: If False, won't overwrite existing source_map entries
+        """
+        if isinstance(obj, dict):
+            for key, value in obj.items():
+                current_path = f"{path_prefix}.{key}" if path_prefix else key
+
+                # Skip if we shouldn't overwrite and already have source info
+                if not overwrite and current_path in source_map:
+                    # Still recurse for nested structures
+                    if isinstance(value, (dict, list)):
+                        self._track_nested_values(
+                            value, source, source_type, current_path, source_map, overwrite
+                        )
+                    continue
+
+                # For environment variables, look up the specific env var name
+                env_var_name = None
+                if source_type == "environment" and current_path in self.env_var_mapping:
+                    env_var_name = self.env_var_mapping[current_path]
+                    # Update source to include env var name
+                    effective_source = f"environment:{env_var_name}"
+                else:
+                    effective_source = source
+
+                source_map[current_path] = ConfigValue(
+                    value=value,
+                    source=effective_source,
+                    source_type=source_type,
+                    path=current_path,
+                    overridden_by=None,
+                    override_chain=[(effective_source, value)],
+                    is_env_override=(source_type == "environment"),
+                    original_env_var=env_var_name,
+                )
+                if isinstance(value, (dict, list)):
+                    self._track_nested_values(
+                        value, source, source_type, current_path, source_map, overwrite
+                    )
+        elif isinstance(obj, list):
+            for i, item in enumerate(obj):
+                current_path = f"{path_prefix}[{i}]"
+                # Skip if we shouldn't overwrite and already have source info
+                if not overwrite and current_path in source_map:
+                    # Still recurse for nested structures
+                    if isinstance(item, (dict, list)):
+                        self._track_nested_values(
+                            item, source, source_type, current_path, source_map, overwrite
+                        )
+                    continue
+
+                source_map[current_path] = ConfigValue(
+                    value=item,
+                    source=source,
+                    source_type=source_type,
+                    path=current_path,
+                    overridden_by=None,
+                    override_chain=[(source, item)],
+                    is_env_override=(source_type == "environment"),
+                    original_env_var=None,  # List items don't have individual env vars
+                )
+                if isinstance(item, (dict, list)):
+                    self._track_nested_values(
+                        item, source, source_type, current_path, source_map, overwrite
+                    )
+
+    def _extract_env_var_name(self, source: str) -> Optional[str]:
+        """
+        Extract environment variable name from source string.
+
+        Args:
+            source: Source identifier like "environment:OPENAI_API_KEY"
+
+        Returns:
+            Environment variable name or None if not an env source
+        """
+        if source.startswith("environment:"):
+            return source.split(":", 1)[1]
+        return None
+
+    def load_cascade_with_sources(
+        self, procedure_path: Path
+    ) -> Tuple[Dict[str, Any], Dict[str, ConfigValue]]:
+        """
+        Load cascade and return both merged config and detailed source map.
+
+        This is the enhanced version of load_cascade() that provides complete
+        transparency into where each configuration value came from.
+
+        Priority order (lowest to highest):
+        System → User → Project → Parent → Local → Environment → Sidecar → CLI
+
+        Args:
+            procedure_path: Path to the .tac procedure file
+
+        Returns:
+            Tuple of (merged_config, source_map)
+            - merged_config: Traditional flat merged config (backward compatible)
+            - source_map: Dict mapping paths to ConfigValue objects with full metadata
+        """
+        configs = []
+
+        # 1. System config (lowest precedence)
+        for system_path in self._get_system_config_paths():
+            if system_path.exists():
+                system_config = self._load_yaml_file(system_path)
+                if system_config:
+                    configs.append((f"system:{system_path}", system_config))
+                    logger.debug(f"Loaded system config: {system_path}")
+
+        # 2. User config (~/.tactus/config.yml, XDG, etc.)
+        for user_path in self._get_user_config_paths():
+            if user_path.exists():
+                user_config = self._load_yaml_file(user_path)
+                if user_config:
+                    configs.append((f"user:{user_path}", user_config))
+                    logger.debug(f"Loaded user config: {user_path}")
+
+        # 3. Project config (.tactus/config.yml in cwd)
+        root_config_path = Path.cwd() / ".tactus" / "config.yml"
+        if root_config_path.exists():
+            root_config = self._load_yaml_file(root_config_path)
+            if root_config:
+                configs.append((f"project:{root_config_path}", root_config))
+                logger.debug(f"Loaded root config: {root_config_path}")
+
+        # 4. Parent directory configs (walk up from procedure directory)
+        procedure_dir = procedure_path.parent.resolve()
+        parent_configs = self._find_directory_configs(procedure_dir)
+        for config_path in parent_configs:
+            config = self._load_yaml_file(config_path)
+            if config:
+                configs.append((f"parent:{config_path}", config))
+                logger.debug(f"Loaded parent config: {config_path}")
+
+        # 5. Local directory config (.tactus/config.yml in procedure's directory)
+        local_config_path = procedure_dir / ".tactus" / "config.yml"
+        if (
+            local_config_path.exists()
+            and local_config_path not in [root_config_path] + parent_configs
+        ):
+            local_config = self._load_yaml_file(local_config_path)
+            if local_config:
+                configs.append((f"local:{local_config_path}", local_config))
+                logger.debug(f"Loaded local config: {local_config_path}")
+
+        # 6. Environment variables (override config files)
+        env_config = self._load_from_environment()
+        if env_config:
+            # We use "environment" as source, but individual var names are in self.env_var_mapping
+            configs.append(("environment", env_config))
+            logger.debug(
+                f"Loaded config from environment variables: {list(self.env_var_mapping.keys())}"
+            )
+
+        # 7. Sidecar config (highest priority, except CLI args)
+        sidecar_path = self._find_sidecar_config(procedure_path)
+        if sidecar_path:
+            sidecar_config = self._load_yaml_file(sidecar_path)
+            if sidecar_config:
+                configs.append((f"sidecar:{sidecar_path}", sidecar_config))
+                logger.info(f"Loaded sidecar config: {sidecar_path}")
+
+        # Store for debugging
+        self.loaded_configs = configs
+
+        # Merge all configs with source tracking
+        if not configs:
+            return {}, {}
+
+        # Start with first config
+        source, config = configs[0]
+        result = deepcopy(config)
+        source_map: Dict[str, ConfigValue] = {}
+
+        # Track initial values
+        self._track_nested_values(config, source, source.split(":")[0], "", source_map)
+
+        # Merge remaining configs with tracking
+        for source, config in configs[1:]:
+            result, source_map = self._deep_merge_with_tracking(
+                result, config, "merged", source, "", source_map
+            )
+
+        logger.info(f"Merged configuration from {len(configs)} source(s) with full tracking")
+        return result, source_map

tactus/dspy/agent.py

@@ -724,7 +724,9 @@ class DSPyAgentHandle:
 
         if get_current_lm() is None and self.model:
             # Convert model format from "provider:model" to "provider/model" for LiteLLM
-            model_for_litellm = self.model.replace(":", "/") if ":" in self.model else self.model
+            # Only replace the FIRST colon (provider separator), not all colons
+            # Bedrock model IDs like "us.anthropic.claude-haiku-4-5-20251001-v1:0" have a version suffix
+            model_for_litellm = self.model.replace(":", "/", 1) if ":" in self.model else self.model
             logger.info(f"Auto-configuring DSPy LM with model: {model_for_litellm}")
 
             # Build kwargs for configure_lm

tactus/ide/server.py

@@ -197,6 +197,24 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
             return jsonify({"cwd": WORKSPACE_ROOT})
         return jsonify({"cwd": str(Path.cwd())})
 
+    @app.route("/api/about", methods=["GET"])
+    def get_about_info():
+        """Get application version and metadata."""
+        from tactus import __version__
+
+        return jsonify(
+            {
+                "version": __version__,
+                "name": "Tactus IDE",
+                "description": "A Lua-based DSL for agentic workflows",
+                "author": "Ryan Porter",
+                "license": "MIT",
+                "repository": "https://github.com/AnthusAI/Tactus",
+                "documentation": "https://github.com/AnthusAI/Tactus/tree/main/docs",
+                "issues": "https://github.com/AnthusAI/Tactus/issues",
+            }
+        )
+
     @app.route("/api/workspace", methods=["GET", "POST"])
     def workspace_operations():
         """Handle workspace operations."""
@@ -2241,6 +2259,23 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
             logger.error(f"Error handling LSP notification: {e}")
             return jsonify({"error": str(e)}), 500
 
+    # Register config API routes
+    try:
+        import sys
+
+        # Add tactus-ide/backend to path for imports
+        # Path from tactus/ide/server.py -> project root -> tactus-ide/backend
+        backend_dir = Path(__file__).parent.parent.parent / "tactus-ide" / "backend"
+        if backend_dir.exists():
+            sys.path.insert(0, str(backend_dir))
+            from config_server import register_config_routes
+
+            register_config_routes(app)
+        else:
+            logger.warning(f"Config server backend directory not found: {backend_dir}")
+    except ImportError as e:
+        logger.warning(f"Could not register config routes: {e}")
+
     # Serve frontend if dist directory is provided
     if frontend_dist_dir:
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.23.0
+Version: 0.25.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.23.0.dist-info → tactus-0.25.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tactus/__init__.py,sha256=bYU1q6ssy4qyaU4ywptrmHurU9Y5gaCei8LiigteA2I,1245
+tactus/__init__.py,sha256=j3GKQg-FI6kEa8_EqgcxzyTLusQ6dIuqe0LHH9DOYgI,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
@@ -14,10 +14,10 @@ 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/cli/__init__.py,sha256=kVhdCkwWEPdt3vn9si-iKvh6M9817aOH6rLSsNzRuyg,80
-tactus/cli/app.py,sha256=2BpV4LHoXg9d03NvgqAgPT9om-68XRL5yK3BzBI-b9A,77927
+tactus/cli/app.py,sha256=aBpZ4IUka-y1HV4oHyBvydnX8XI5JRo6WwMgLji2Df4,78595
 tactus/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tactus/core/__init__.py,sha256=TK5rWr3HmOO_igFa5ESGp6teWwS58vnvQhIWqkcgqwk,880
-tactus/core/config_manager.py,sha256=at6oA2vqNBMR4kVkdRbPL04x6_wRvki3pLfQAoU8KXU,11917
+tactus/core/config_manager.py,sha256=DXWQs__rD4fXo4KPJb24hyXGdUBiiEv1mV_h4yu0vKU,31575
 tactus/core/dsl_stubs.py,sha256=naF27E1-zzDtuuYAKo1uThwQfLgaQOP35vBlGs6QsyY,66871
 tactus/core/exceptions.py,sha256=HruvJQ4yIi78hOvvHviNZolcraMwXrlGQzxHqYFQapA,1468
 tactus/core/execution_context.py,sha256=DJuy3sU2fS6n3Rp_GK7nIOFOLob23uTenZaIXXDm7Sk,16656
@@ -34,7 +34,7 @@ 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=lWb71_EyM_VrgFE4XQ3LPW3Sl5rIir0ndAZHZoh23U4,37671
+tactus/dspy/agent.py,sha256=sIvi4ySumUXL9bPnMNLhFODOhYbEMlElnqHv57IaFrs,37859
 tactus/dspy/config.py,sha256=oXwYzfVCTBHRnbH_vvm591FhE0zKep7wgmujLSXKf_c,6013
 tactus/dspy/history.py,sha256=0yGi3P5ruRUPoRyaCWsUDeuEYYsfproc_7pMVZuhmUo,5980
 tactus/dspy/module.py,sha256=sJdFS-5A4SpuiMLjbwiZJCvg3pTtEx8x8MRVaqjCQ2I,15423
@@ -42,7 +42,7 @@ tactus/dspy/prediction.py,sha256=AFtkmKQafOcA4Pzdty0dvZ62lmfS3wgIj4Bc3Awhb2c,722
 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=Wp2-lpbYp8u-xPDUjGVNX08Rvgx-9umwxrVlWfAce0c,97575
+tactus/ide/server.py,sha256=KALEdXcoUHLjJPWFrbyMbPkQeoHKfhSu7J22HeXx7yA,98912
 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
@@ -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.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,,
+tactus-0.25.0.dist-info/METADATA,sha256=WGpOx64_mmNzszKF7PRCYrzCZqwUSkwn9HlC98xUj4E,55250
+tactus-0.25.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tactus-0.25.0.dist-info/entry_points.txt,sha256=vWseqty8m3z-Worje0IYxlioMjPDCoSsm0AtY4GghBY,47
+tactus-0.25.0.dist-info/licenses/LICENSE,sha256=ivohBcAIYnaLPQ-lKEeCXSMvQUVISpQfKyxHBHoa4GA,1066
+tactus-0.25.0.dist-info/RECORD,,