tactus 0.25.0__tar.gz → 0.26.0__tar.gz

{tactus-0.25.0 → tactus-0.26.0}/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 <!-- version list -->
 
+## v0.26.0 (2026-01-11)
+
+### Features
+
+- Improve logging UX and fs helpers (#26) ([#26](https://github.com/AnthusAI/Tactus/pull/26),
+  [`a2a8704`](https://github.com/AnthusAI/Tactus/commit/a2a8704c1a0ab3b2cad45b9514af2152d12faa3b))
+
+
 ## v0.25.0 (2026-01-11)
 
 ### Features

{tactus-0.25.0 → tactus-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.25.0
+Version: 0.26.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
@@ -1488,6 +1488,21 @@ tactus run workflow.tac  # If procedure has required inputs, you'll be prompted
 tactus run workflow.tac --storage file --storage-path ./data
 ```
 
+#### Logging Options
+
+The `run` command supports filtering and formatting logs:
+
+```bash
+# Show less/more output
+tactus run workflow.tac --log-level warning
+tactus run workflow.tac --log-level debug
+
+# Choose a log format
+tactus run workflow.tac --log-format rich      # default, grouped timestamps
+tactus run workflow.tac --log-format terminal  # no timestamps, higher-signal terminal output
+tactus run workflow.tac --log-format raw       # one-line-per-record, timestamped (CloudWatch-friendly)
+```
+
 The CLI automatically parses parameter types:
 - **Strings**: Direct values or quoted strings
 - **Numbers**: Integers or floats are auto-detected

{tactus-0.25.0 → tactus-0.26.0}/README.md

@@ -1437,6 +1437,21 @@ tactus run workflow.tac  # If procedure has required inputs, you'll be prompted
 tactus run workflow.tac --storage file --storage-path ./data
 ```
 
+#### Logging Options
+
+The `run` command supports filtering and formatting logs:
+
+```bash
+# Show less/more output
+tactus run workflow.tac --log-level warning
+tactus run workflow.tac --log-level debug
+
+# Choose a log format
+tactus run workflow.tac --log-format rich      # default, grouped timestamps
+tactus run workflow.tac --log-format terminal  # no timestamps, higher-signal terminal output
+tactus run workflow.tac --log-format raw       # one-line-per-record, timestamped (CloudWatch-friendly)
+```
+
 The CLI automatically parses parameter types:
 - **Strings**: Direct values or quoted strings
 - **Numbers**: Integers or floats are auto-detected

{tactus-0.25.0 → tactus-0.26.0}/SPECIFICATION.md

@@ -2457,6 +2457,24 @@ File.write(path, contents)
 File.exists(path)
 ```
 
+### Filesystem Helpers (stdlib)
+
+Workflows sometimes need to enumerate files within the sandboxed working directory (for example, iterating over documents to lint or review). Use the filesystem helper module:
+
+```lua
+local fs = require("tactus.io.fs")
+
+-- List entries in a directory (relative paths)
+local entries = fs.list_dir("chapters", {files_only = true, sort = true})
+
+-- Glob files (relative paths)
+local qmd_files = fs.glob("chapters/*.qmd", {sort = true})
+```
+
+**Security model:** Paths are restricted to the procedure working directory; absolute paths and path traversal (`..`) are rejected.
+
+**Determinism:** Filesystem contents can change between runs; wrap file enumeration and reads in `Step.checkpoint()` for durable workflows.
+
 ---
 
 ## Matchers

{tactus-0.25.0 → tactus-0.26.0}/pyproject.toml

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

{tactus-0.25.0 → tactus-0.26.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.25.0"
+__version__ = "0.26.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

{tactus-0.25.0 → tactus-0.26.0}/tactus/adapters/cli_hitl.py

@@ -32,7 +32,7 @@ class CLIHITLHandler:
             console: Rich Console instance (creates new one if not provided)
         """
         self.console = console or Console()
-        logger.info("CLIHITLHandler initialized")
+        logger.debug("CLIHITLHandler initialized")
 
     def request_interaction(self, procedure_id: str, request: HITLRequest) -> HITLResponse:
         """
@@ -45,7 +45,7 @@ class CLIHITLHandler:
         Returns:
             HITLResponse with user's response
         """
-        logger.info(f"HITL request: {request.request_type} - {request.message}")
+        logger.debug(f"HITL request: {request.request_type} - {request.message}")
 
         # Display the request in a panel
         self.console.print()

tactus-0.26.0/tactus/adapters/cost_collector_log.py

@@ -0,0 +1,56 @@
+"""
+Cost-only log handler for headless/sandbox runs.
+
+Collects CostEvent instances so the runtime can report total_cost/total_tokens,
+without enabling streaming UI behavior.
+"""
+
+from __future__ import annotations
+
+import logging
+import json
+from typing import List
+
+from tactus.protocols.models import CostEvent, LogEvent
+
+logger = logging.getLogger(__name__)
+
+
+class CostCollectorLogHandler:
+    """
+    Minimal LogHandler for sandbox runs.
+
+    This is useful in environments like Docker sandboxes where stdout is reserved
+    for protocol output, but we still want:
+    - accurate cost accounting (CostEvent)
+    - basic procedure logging (LogEvent) via stderr/Python logging
+    """
+
+    supports_streaming = False
+
+    def __init__(self):
+        self.cost_events: List[CostEvent] = []
+        logger.debug("CostCollectorLogHandler initialized")
+
+    def log(self, event: LogEvent) -> None:
+        if isinstance(event, CostEvent):
+            self.cost_events.append(event)
+            return
+
+        # Preserve useful procedure logs even when no IDE callback is present.
+        if isinstance(event, LogEvent):
+            event_logger = logging.getLogger(event.logger_name or "procedure")
+
+            msg = event.message
+            if event.context:
+                msg = f"{msg}\nContext: {json.dumps(event.context, indent=2, default=str)}"
+
+            level = (event.level or "INFO").upper()
+            if level == "DEBUG":
+                event_logger.debug(msg)
+            elif level in ("WARN", "WARNING"):
+                event_logger.warning(msg)
+            elif level == "ERROR":
+                event_logger.error(msg)
+            else:
+                event_logger.info(msg)

{tactus-0.25.0 → tactus-0.26.0}/tactus/cli/app.py

@@ -134,15 +134,92 @@ def load_tactus_config():
         return {}
 
 
-def setup_logging(verbose: bool = False):
-    """Setup logging with rich handler."""
-    level = logging.DEBUG if verbose else logging.INFO
-
-    logging.basicConfig(
-        level=level,
-        format="%(message)s",
-        handlers=[RichHandler(console=console, show_path=False, rich_tracebacks=True)],
-    )
+_LOG_LEVELS = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warning": logging.WARNING,
+    "warn": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
+_LOG_FORMATS = {"rich", "terminal", "raw"}
+
+
+class _TerminalLogHandler(logging.Handler):
+    """Minimal, high-signal terminal logger (no timestamps/levels)."""
+
+    def __init__(self, console: Console):
+        super().__init__()
+        self._console = console
+        self.setFormatter(logging.Formatter("%(message)s"))
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            message = self.format(record)
+
+            # Make procedure-level logs the most prominent.
+            if record.name.startswith("procedure"):
+                style = "bold"
+            elif record.levelno >= logging.ERROR:
+                style = "bold red"
+            elif record.levelno >= logging.WARNING:
+                style = "yellow"
+            elif record.levelno <= logging.DEBUG:
+                style = "dim"
+            else:
+                style = ""
+
+            self._console.print(message, style=style, markup=False, highlight=False)
+        except Exception:
+            self.handleError(record)
+
+
+def setup_logging(
+    verbose: bool = False,
+    log_level: Optional[str] = None,
+    log_format: str = "rich",
+) -> None:
+    """Setup CLI logging (level + format)."""
+    if log_level is None:
+        level = logging.DEBUG if verbose else logging.INFO
+    else:
+        key = str(log_level).strip().lower()
+        if key not in _LOG_LEVELS:
+            raise typer.BadParameter(
+                f"Invalid --log-level '{log_level}'. "
+                f"Use one of: {', '.join(sorted(_LOG_LEVELS.keys()))}"
+            )
+        level = _LOG_LEVELS[key]
+
+    fmt = (log_format or "rich").strip().lower()
+    if fmt not in _LOG_FORMATS:
+        raise typer.BadParameter(
+            f"Invalid --log-format '{log_format}'. Use one of: {', '.join(sorted(_LOG_FORMATS))}"
+        )
+
+    # Default: rich logs (group repeated timestamps).
+    if fmt == "rich":
+        handler: logging.Handler = RichHandler(
+            console=console,
+            show_path=False,
+            rich_tracebacks=True,
+            omit_repeated_times=True,
+        )
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        logging.basicConfig(level=level, format="%(message)s", handlers=[handler], force=True)
+        return
+
+    # Raw logs: one line per entry, CloudWatch-friendly.
+    if fmt == "raw":
+        handler = logging.StreamHandler(stream=sys.stderr)
+        handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
+        logging.basicConfig(level=level, handlers=[handler], force=True)
+        return
+
+    # Terminal logs: no timestamps/levels, color by signal.
+    handler = _TerminalLogHandler(console)
+    logging.basicConfig(level=level, handlers=[handler], force=True)
 
 
 def _parse_value(value_str: str, field_type: str) -> Any:
@@ -352,6 +429,12 @@ def run(
         None, envvar="OPENAI_API_KEY", help="OpenAI API key"
     ),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+    log_level: Optional[str] = typer.Option(
+        None, "--log-level", help="Log level: debug, info, warning, error, critical"
+    ),
+    log_format: str = typer.Option(
+        "rich", "--log-format", help="Log format: rich (default), terminal, raw"
+    ),
     param: Optional[list[str]] = typer.Option(None, help="Parameters in format key=value"),
     interactive: bool = typer.Option(
         False, "--interactive", "-i", help="Interactively prompt for all inputs"
@@ -399,7 +482,7 @@ def run(
         # Use real implementation for specific tools while mocking others
         tactus run workflow.tac --mock-all --real done
     """
-    setup_logging(verbose)
+    setup_logging(verbose=verbose, log_level=log_level, log_format=log_format)
 
     # Check if file exists
     if not workflow_file.exists():
@@ -530,6 +613,12 @@ def run(
         sandbox_config_dict["enabled"] = sandbox
     sandbox_config = SandboxConfig(**sandbox_config_dict)
 
+    # Pass logging preferences through to the sandbox container so container stderr matches CLI UX.
+    sandbox_config.env.setdefault(
+        "TACTUS_LOG_LEVEL", str(log_level or ("debug" if verbose else "info"))
+    )
+    sandbox_config.env.setdefault("TACTUS_LOG_FORMAT", str(log_format))
+
     # Check Docker availability
     docker_available, docker_reason = is_docker_available()
 

{tactus-0.25.0 → tactus-0.26.0}/tactus/core/config_manager.py

@@ -150,7 +150,7 @@ class ConfigManager:
             sidecar_config = self._load_yaml_file(sidecar_path)
             if sidecar_config:
                 configs.append(("sidecar", sidecar_config))
-                logger.info(f"Loaded sidecar config: {sidecar_path}")
+                logger.debug(f"Loaded sidecar config: {sidecar_path}")
 
         # Store for debugging
         self.loaded_configs = configs
@@ -158,7 +158,7 @@ class ConfigManager:
         # Merge all configs (later configs override earlier ones)
         merged = self._merge_configs([c[1] for c in configs])
 
-        logger.info(f"Merged configuration from {len(configs)} source(s)")
+        logger.debug(f"Merged configuration from {len(configs)} source(s)")
         return merged
 
     def _find_sidecar_config(self, tac_path: Path) -> Optional[Path]:

{tactus-0.25.0 → tactus-0.26.0}/tactus/core/dsl_stubs.py

@@ -915,43 +915,49 @@ def create_dsl_stubs(
             if not isinstance(mock_config, dict):
                 continue
 
-            # Check if this is an agent mock (has tool_calls key)
-            if "tool_calls" in mock_config:
-                # Agent mock - specifies what tool calls the agent should simulate
+            # Tool mocks use explicit keys.
+            tool_mock_keys = {"returns", "temporal", "conditional", "error"}
+            if any(k in mock_config for k in tool_mock_keys):
+                # Convert DSL syntax to MockConfig format
+                processed_config = {}
+
+                # Static mocking with 'returns' key
+                if "returns" in mock_config:
+                    processed_config["output"] = mock_config["returns"]
+
+                # Temporal mocking
+                elif "temporal" in mock_config:
+                    processed_config["temporal"] = mock_config["temporal"]
+
+                # Conditional mocking
+                elif "conditional" in mock_config:
+                    # Convert DSL conditional format to MockManager format
+                    conditionals = []
+                    for cond in mock_config["conditional"]:
+                        if isinstance(cond, dict) and "when" in cond and "returns" in cond:
+                            conditionals.append({"when": cond["when"], "return": cond["returns"]})
+                    processed_config["conditional_mocks"] = conditionals
+
+                # Error simulation
+                elif "error" in mock_config:
+                    processed_config["error"] = mock_config["error"]
+
+                # Register the tool mock configuration
+                builder.register_mock(name, processed_config)
+                continue
+
+            # Agent mocks can be message-only, tool_calls-only, or both.
+            if any(k in mock_config for k in ("tool_calls", "message", "data")):
                 agent_config = {
                     "tool_calls": mock_config.get("tool_calls", []),
                     "message": mock_config.get("message", ""),
+                    "data": mock_config.get("data"),
                 }
                 builder.register_agent_mock(name, agent_config)
                 continue
 
-            # Otherwise, it's a tool mock
-            # Convert DSL syntax to MockConfig format
-            processed_config = {}
-
-            # Static mocking with 'returns' key
-            if "returns" in mock_config:
-                processed_config["output"] = mock_config["returns"]
-
-            # Temporal mocking
-            elif "temporal" in mock_config:
-                processed_config["temporal"] = mock_config["temporal"]
-
-            # Conditional mocking
-            elif "conditional" in mock_config:
-                # Convert DSL conditional format to MockManager format
-                conditionals = []
-                for cond in mock_config["conditional"]:
-                    if isinstance(cond, dict) and "when" in cond and "returns" in cond:
-                        conditionals.append({"when": cond["when"], "return": cond["returns"]})
-                processed_config["conditional_mocks"] = conditionals
-
-            # Error simulation
-            elif "error" in mock_config:
-                processed_config["error"] = mock_config["error"]
-
-            # Register the tool mock configuration
-            builder.register_mock(name, processed_config)
+            # Otherwise, ignore unknown mock config.
+            continue
 
     def _history(messages=None):
         """
@@ -1413,14 +1419,14 @@ def create_dsl_stubs(
 
         logger = logging.getLogger(__name__)
 
-        logger.info(
+        logger.debug(
             f"[AGENT_CREATION] Agent '{agent_name}': runtime_context={bool(_runtime_context)}, skip_agents={_runtime_context.get('skip_agents', 'N/A') if _runtime_context else 'N/A'}, has_log_handler={('log_handler' in _runtime_context) if _runtime_context else False}"
         )
 
         if _runtime_context and not _runtime_context.get("skip_agents", False):
             from tactus.dspy.agent import create_dspy_agent
 
-            logger.info(f"[AGENT_CREATION] Attempting immediate creation for agent '{agent_name}'")
+            logger.debug(f"[AGENT_CREATION] Attempting immediate creation for agent '{agent_name}'")
 
             try:
                 # Create the actual agent primitive NOW
@@ -1450,7 +1456,7 @@ def create_dsl_stubs(
                 handle._set_primitive(
                     agent_primitive, execution_context=_runtime_context.get("execution_context")
                 )
-                logger.info(
+                logger.debug(
                     f"[AGENT_CREATION] Agent '{agent_name}' created immediately during declaration, has_log_handler={hasattr(agent_primitive, 'log_handler') and agent_primitive.log_handler is not None}"
                 )
 
@@ -1458,7 +1464,9 @@ def create_dsl_stubs(
                 if "_created_agents" not in _runtime_context:
                     _runtime_context["_created_agents"] = {}
                 _runtime_context["_created_agents"][agent_name] = agent_primitive
-                logger.info(f"[AGENT_CREATION] Stored agent '{agent_name}' in _created_agents dict")
+                logger.debug(
+                    f"[AGENT_CREATION] Stored agent '{agent_name}' in _created_agents dict"
+                )
 
             except Exception as e:
                 logger.error(
@@ -1567,14 +1575,14 @@ def create_dsl_stubs(
 
         logger = logging.getLogger(__name__)
 
-        logger.info(
+        logger.debug(
             f"[AGENT_CREATION] Agent '{temp_name}': runtime_context={bool(_runtime_context)}, skip_agents={_runtime_context.get('skip_agents', 'N/A') if _runtime_context else 'N/A'}, has_log_handler={('log_handler' in _runtime_context) if _runtime_context else False}"
         )
 
         if _runtime_context and not _runtime_context.get("skip_agents", False):
             from tactus.dspy.agent import create_dspy_agent
 
-            logger.info(f"[AGENT_CREATION] Attempting immediate creation for agent '{temp_name}'")
+            logger.debug(f"[AGENT_CREATION] Attempting immediate creation for agent '{temp_name}'")
 
             try:
                 # Create the actual agent primitive NOW
@@ -1593,7 +1601,7 @@ def create_dsl_stubs(
                 if "log_handler" in _runtime_context:
                     agent_config["log_handler"] = _runtime_context["log_handler"]
 
-                logger.info(
+                logger.debug(
                     f"[AGENT_CREATION] Creating agent immediately: name={temp_name}, has_log_handler={'log_handler' in agent_config}"
                 )
                 agent_primitive = create_dspy_agent(
@@ -1607,7 +1615,7 @@ def create_dsl_stubs(
                 handle._set_primitive(
                     agent_primitive, execution_context=_runtime_context.get("execution_context")
                 )
-                logger.info(
+                logger.debug(
                     f"[AGENT_CREATION] Agent '{temp_name}' created immediately during declaration, has_log_handler={hasattr(agent_primitive, 'log_handler') and agent_primitive.log_handler is not None}"
                 )
 
@@ -1615,7 +1623,7 @@ def create_dsl_stubs(
                 if "_created_agents" not in _runtime_context:
                     _runtime_context["_created_agents"] = {}
                 _runtime_context["_created_agents"][temp_name] = agent_primitive
-                logger.info(f"[AGENT_CREATION] Stored agent '{temp_name}' in _created_agents dict")
+                logger.debug(f"[AGENT_CREATION] Stored agent '{temp_name}' in _created_agents dict")
 
             except Exception as e:
                 import traceback
@@ -1757,13 +1765,13 @@ def _make_binding_callback(
             old_name = value.name
             if old_name.startswith("_temp_agent_"):
                 # Rename the agent handle
-                callback_logger.info(f"[AGENT_RENAME] Renaming agent '{old_name}' to '{name}'")
+                callback_logger.debug(f"[AGENT_RENAME] Renaming agent '{old_name}' to '{name}'")
                 value.name = name
 
                 # Also rename the underlying primitive if it exists
                 if value._primitive is not None:
                     value._primitive.name = name
-                    callback_logger.info(
+                    callback_logger.debug(
                         f"[AGENT_RENAME] Updated primitive name: '{old_name}' -> '{name}'"
                     )
 
@@ -1777,7 +1785,7 @@ def _make_binding_callback(
                 if hasattr(builder, "registry") and old_name in builder.registry.agents:
                     agent_data = builder.registry.agents.pop(old_name)
                     builder.registry.agents[name] = agent_data
-                    callback_logger.info(
+                    callback_logger.debug(
                         f"[AGENT_RENAME] Re-registered agent '{name}' in builder.registry.agents"
                     )
 
@@ -1786,7 +1794,7 @@ def _make_binding_callback(
                     if old_name in runtime_context["_created_agents"]:
                         agent_primitive = runtime_context["_created_agents"].pop(old_name)
                         runtime_context["_created_agents"][name] = agent_primitive
-                        callback_logger.info(
+                        callback_logger.debug(
                             f"[AGENT_RENAME] Updated _created_agents dict: '{old_name}' -> '{name}'"
                         )
 

{tactus-0.25.0 → tactus-0.26.0}/tactus/core/execution_context.py

@@ -187,7 +187,7 @@ class BaseExecutionContext(ExecutionContext):
         On replay, returns cached result from execution log.
         On first execution, runs fn(), records in log, and returns result.
         """
-        logger.info(
+        logger.debug(
             f"[CHECKPOINT] checkpoint() called, type={checkpoint_type}, has_log_handler={self.log_handler is not None}"
         )
         current_position = self.metadata.replay_index
@@ -259,7 +259,7 @@ class BaseExecutionContext(ExecutionContext):
                     source_location=source_location,
                     procedure_id=self.procedure_id,
                 )
-                logger.info(
+                logger.debug(
                     f"[CHECKPOINT] Emitting CheckpointCreatedEvent: position={current_position}, type={checkpoint_type}, duration_ms={duration_ms}"
                 )
                 self.log_handler.log(event)

{tactus-0.25.0 → tactus-0.26.0}/tactus/core/lua_sandbox.py

@@ -73,7 +73,7 @@ class LuaSandbox:
         # Setup safe globals
         self._setup_safe_globals()
 
-        logger.info("Lua sandbox initialized successfully")
+        logger.debug("Lua sandbox initialized successfully")
 
     def _attribute_filter(self, obj, attr_name, is_setting):
         """
@@ -274,7 +274,7 @@ class LuaSandbox:
             self.lua.globals()["math"] = safe_math_table
             self.lua.globals()["os"] = safe_os_table
 
-            logger.info("Installed safe math and os libraries with determinism checking")
+            logger.debug("Installed safe math and os libraries with determinism checking")
             return  # Skip default os.date setup below
 
         # Add safe subset of os module (only date function for timestamps)

{tactus-0.25.0 → tactus-0.26.0}/tactus/docker/Dockerfile

@@ -36,6 +36,10 @@ COPY pyproject.toml ./
 COPY README.md ./
 COPY tactus/ ./tactus/
 
+# Ensure the non-root runtime user can read the codebase even if the host
+# working tree has restrictive permissions (e.g., umask 077).
+RUN chmod -R a+rX /app/tactus
+
 # Install Tactus and its dependencies
 RUN pip install --no-cache-dir -e .
 

{tactus-0.25.0 → tactus-0.26.0}/tactus/dspy/agent.py

@@ -191,11 +191,19 @@ class DSPyAgentHandle:
             if response and hasattr(response, "_hidden_params"):
                 total_cost = response._hidden_params.get("response_cost")
 
-            if total_cost is None and response:
+            if total_cost is None and total_tokens > 0:
                 try:
-                    import litellm
-
-                    total_cost = litellm.completion_cost(completion_response=response)
+                    # We already have token counts, so compute cost from tokens to avoid relying
+                    # on provider-specific response object shapes.
+                    from litellm.cost_calculator import cost_per_token
+
+                    prompt_cost, completion_cost = cost_per_token(
+                        model=str(model) if model is not None else "",
+                        prompt_tokens=prompt_tokens,
+                        completion_tokens=completion_tokens,
+                        call_type="completion",
+                    )
+                    total_cost = float(prompt_cost) + float(completion_cost)
                 except Exception as e:
                     logger.warning(f"[COST] Agent '{self.name}': failed to calculate cost: {e}")
                     total_cost = 0.0
@@ -326,6 +334,7 @@ class DSPyAgentHandle:
 
         Streaming is enabled when:
         - log_handler is available (for emitting events)
+        - log_handler supports streaming events
         - disable_streaming is False
         - No structured output schema (streaming only works with plain text)
 
@@ -337,6 +346,14 @@ class DSPyAgentHandle:
             logger.debug(f"[STREAMING] Agent '{self.name}': no log_handler, streaming disabled")
             return False
 
+        # Allow log handlers to opt out of streaming (e.g., cost-only collectors)
+        supports_streaming = getattr(self.log_handler, "supports_streaming", True)
+        if not supports_streaming:
+            logger.debug(
+                f"[STREAMING] Agent '{self.name}': log_handler supports_streaming=False, streaming disabled"
+            )
+            return False
+
         # Respect explicit disable flag
         if self.disable_streaming:
             logger.debug(
@@ -673,9 +690,7 @@ class DSPyAgentHandle:
             result = worker({message = "Process this task"})
             print(result.response)
         """
-        logger.info(
-            f"[CHECKPOINT] DSPyAgentHandle.__call__ invoked directly for agent '{self.name}' - THIS BYPASSES AgentHandle checkpoint logic!"
-        )
+        logger.debug(f"Agent '{self.name}' invoked via __call__()")
         inputs = inputs or {}
 
         # Handle string input as a convenience: Agent("message") -> Agent({message="message"})