chuk-tool-processor 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

chuk_tool_processor/core/processor.py

@@ -13,7 +13,7 @@ from chuk_tool_processor.execution.wrappers.caching import CacheInterface, InMem
 from chuk_tool_processor.execution.wrappers.rate_limiting import RateLimiter, RateLimitedToolExecutor
 from chuk_tool_processor.execution.wrappers.retry import RetryConfig, RetryableToolExecutor
 from chuk_tool_processor.plugins.discovery import plugin_registry, discover_default_plugins
-from chuk_tool_processor.utils.logging import get_logger, log_context_span, request_logging, log_tool_call, metrics
+from chuk_tool_processor.logging import get_logger, log_context_span, request_logging, log_tool_call, metrics
 
 
 class ToolProcessor:

chuk_tool_processor/execution/strategies/inprocess_strategy.py

@@ -1,206 +1,168 @@
-# chuk_tool_processor/execution/inprocess_strategy.py
+"""
+In-process execution strategy with sync/async support.
+
+This version prefers the public `execute()` wrapper (with validation and
+defaults) over the private `_execute` implementation, fixing missing-argument
+errors for `ValidatedTool` subclasses.
+"""
+
+from __future__ import annotations
+
 import asyncio
+import inspect
 import os
 from datetime import datetime, timezone
-from typing import List, Optional, Dict, Any
+from typing import Any, List, Optional
 
-# imports
+from chuk_tool_processor.core.exceptions import ToolExecutionError
+from chuk_tool_processor.models.execution_strategy import ExecutionStrategy
 from chuk_tool_processor.models.tool_call import ToolCall
 from chuk_tool_processor.models.tool_result import ToolResult
-from chuk_tool_processor.models.execution_strategy import ExecutionStrategy
 from chuk_tool_processor.registry.interface import ToolRegistryInterface
-from chuk_tool_processor.core.exceptions import ToolNotFoundError, ToolTimeoutError, ToolExecutionError
-from chuk_tool_processor.utils.logging import get_logger
+from chuk_tool_processor.logging import get_logger
 
 logger = get_logger("chuk_tool_processor.execution.inprocess_strategy")
 
+
 class InProcessStrategy(ExecutionStrategy):
-    """
-    In-process execution strategy with concurrent execution support.
-    """
+    """Run tools inside the current interpreter, concurrently."""
+
     def __init__(
-        self, 
-        registry: ToolRegistryInterface, 
-        default_timeout: Optional[float] = None,
-        max_concurrency: Optional[int] = None
-    ):
-        """
-        Initialize the strategy.
-        
-        Args:
-            registry: Tool registry to look up tools.
-            default_timeout: Default timeout for tool executions.
-            max_concurrency: Maximum number of concurrent tool executions (default: None = unlimited).
-        """
+        self,
+        registry: ToolRegistryInterface,
+        default_timeout: float | None = None,
+        max_concurrency: int | None = None,
+    ) -> None:
         self.registry = registry
         self.default_timeout = default_timeout
-        self.max_concurrency = max_concurrency
-        self._semaphore = asyncio.Semaphore(max_concurrency) if max_concurrency else None
+        self._sem = asyncio.Semaphore(max_concurrency) if max_concurrency else None
 
+    # ------------------------------------------------------------------ #
+    # public API
+    # ------------------------------------------------------------------ #
     async def run(
         self,
         calls: List[ToolCall],
-        timeout: Optional[float] = None
+        timeout: float | None = None,
     ) -> List[ToolResult]:
-        """
-        Execute tool calls concurrently with timeout.
-        
-        Args:
-            calls: List of tool calls to execute.
-            timeout: Optional timeout that overrides the default.
-            
-        Returns:
-            List of tool results in the same order as the calls.
-        """
-        # Create tasks for each call
-        tasks = []
-        for call in calls:
-            task = self._execute_single_call(call, timeout if timeout is not None else self.default_timeout)
-            tasks.append(task)
-        
-        # Run all tasks concurrently and gather results
-        results = await asyncio.gather(*tasks)
-        return results
+        tasks = [
+            self._execute_single_call(call, timeout or self.default_timeout)
+            for call in calls
+        ]
+        return await asyncio.gather(*tasks)
 
+    # ------------------------------------------------------------------ #
+    # helpers
+    # ------------------------------------------------------------------ #
     async def _execute_single_call(
-        self, 
-        call: ToolCall, 
-        timeout: Optional[float]
+        self,
+        call: ToolCall,
+        timeout: float | None,
     ) -> ToolResult:
-        """
-        Execute a single tool call with timeout.
-        
-        Args:
-            call: Tool call to execute.
-            timeout: Optional timeout in seconds.
-            
-        Returns:
-            Tool result with execution metadata.
-        """
-        # Get execution metadata
         pid = os.getpid()
         machine = os.uname().nodename
-        start_time = datetime.now(timezone.utc)
-        
-        # Look up the tool
-        tool_impl = self.registry.get_tool(call.tool)
-        if not tool_impl:
-            end_time = datetime.now(timezone.utc)
+        start = datetime.now(timezone.utc)
+
+        impl = self.registry.get_tool(call.tool)
+        if impl is None:
             return ToolResult(
                 tool=call.tool,
                 result=None,
-                error="Tool not found",  # Keep this message exactly as "Tool not found" for test compatibility
-                start_time=start_time,
-                end_time=end_time,
+                error="Tool not found",
+                start_time=start,
+                end_time=datetime.now(timezone.utc),
                 machine=machine,
-                pid=pid
+                pid=pid,
             )
-        
-        # Execute with concurrency control if needed
+
         try:
-            if self._semaphore:
-                async with self._semaphore:
-                    return await self._run_with_timeout(tool_impl, call, timeout, start_time, machine, pid)
-            else:
-                return await self._run_with_timeout(tool_impl, call, timeout, start_time, machine, pid)
-        except Exception as e:
-            # Catch any uncaught exceptions
-            end_time = datetime.now(timezone.utc)
+            run = self._run_with_timeout
+            if self._sem is None:
+                return await run(impl, call, timeout, start, machine, pid)
+            async with self._sem:
+                return await run(impl, call, timeout, start, machine, pid)
+        except Exception as exc:  # pragma: no cover – safety net
+            logger.exception("Unexpected error while executing %s", call.tool)
             return ToolResult(
                 tool=call.tool,
                 result=None,
-                error=f"Unexpected error: {str(e)}",
-                start_time=start_time,
-                end_time=end_time,
+                error=f"Unexpected error: {exc}",
+                start_time=start,
+                end_time=datetime.now(timezone.utc),
                 machine=machine,
-                pid=pid
+                pid=pid,
             )
 
+    # ------------------------------------------------------------------ #
+    # core execution with timeout
+    # ------------------------------------------------------------------ #
     async def _run_with_timeout(
         self,
-        tool_impl: Any,
+        impl: Any,
         call: ToolCall,
-        timeout: Optional[float],
-        start_time: datetime,
+        timeout: float | None,
+        start: datetime,
         machine: str,
-        pid: int
+        pid: int,
     ) -> ToolResult:
-        """
-        Execute a tool with timeout handling.
-        """
-        try:
-            # Determine if we need to instantiate the tool
-            # If tool_impl is a class (not an instance), instantiate it
-            if isinstance(tool_impl, type):
-                tool_instance = tool_impl()
-            else:
-                tool_instance = tool_impl
-                
-            # Get the tool metadata to check if it's async
-            metadata = self.registry.get_metadata(call.tool) if hasattr(self.registry, "get_metadata") else None
-            is_async = metadata.is_async if metadata else asyncio.iscoroutinefunction(tool_instance.execute)
-            
-            # Call the tool implementation
+        tool = impl() if isinstance(impl, type) else impl
+
+        # ------------------------------------------------------------------
+        # Entry-point selection order:
+        # 1. `_aexecute` (async special case)
+        # 2. `execute`   (public wrapper WITH validation & defaults)
+        # 3. `_execute`  (fallback / legacy)
+        # ------------------------------------------------------------------
+        if hasattr(tool, "_aexecute") and inspect.iscoroutinefunction(tool._aexecute):
+            fn = tool._aexecute
+            is_async = True
+        elif hasattr(tool, "execute"):
+            fn = tool.execute
+            is_async = inspect.iscoroutinefunction(fn)
+        elif hasattr(tool, "_execute"):
+            fn = tool._execute
+            is_async = inspect.iscoroutinefunction(fn)
+        else:
+            raise ToolExecutionError(
+                f"Tool '{call.tool}' must implement _execute, execute or _aexecute"
+            )
+
+        async def _invoke():
             if is_async:
-                # Direct async call
-                if timeout:
-                    result_value = await asyncio.wait_for(
-                        tool_instance.execute(**call.arguments), 
-                        timeout
-                    )
-                else:
-                    result_value = await tool_instance.execute(**call.arguments)
-            else:
-                # Run sync function in executor
-                loop = asyncio.get_running_loop()
-                if timeout:
-                    result_value = await asyncio.wait_for(
-                        loop.run_in_executor(
-                            None, 
-                            lambda: tool_instance.execute(**call.arguments)
-                        ),
-                        timeout
-                    )
-                else:
-                    result_value = await loop.run_in_executor(
-                        None,
-                        lambda: tool_instance.execute(**call.arguments)
-                    )
-            
-            # Create successful result
-            end_time = datetime.now(timezone.utc)
+                return await fn(**call.arguments)
+            loop = asyncio.get_running_loop()
+            return await loop.run_in_executor(None, lambda: fn(**call.arguments))
+
+        try:
+            result_val = (
+                await asyncio.wait_for(_invoke(), timeout) if timeout else await _invoke()
+            )
             return ToolResult(
                 tool=call.tool,
-                result=result_value,
+                result=result_val,
                 error=None,
-                start_time=start_time,
-                end_time=end_time,
+                start_time=start,
+                end_time=datetime.now(timezone.utc),
                 machine=machine,
-                pid=pid
+                pid=pid,
             )
-            
         except asyncio.TimeoutError:
-            # Handle timeout
-            end_time = datetime.now(timezone.utc)
             return ToolResult(
                 tool=call.tool,
                 result=None,
                 error=f"Timeout after {timeout}s",
-                start_time=start_time,
-                end_time=end_time,
+                start_time=start,
+                end_time=datetime.now(timezone.utc),
                 machine=machine,
-                pid=pid
+                pid=pid,
             )
-            
-        except Exception as e:
-            # Handle execution error
-            end_time = datetime.now(timezone.utc)
+        except Exception as exc:
             return ToolResult(
                 tool=call.tool,
                 result=None,
-                error=str(e),
-                start_time=start_time,
-                end_time=end_time,
+                error=str(exc),
+                start_time=start,
+                end_time=datetime.now(timezone.utc),
                 machine=machine,
-                pid=pid
-            )
+                pid=pid,
+            )

chuk_tool_processor/execution/strategies/subprocess_strategy.py

@@ -12,7 +12,7 @@ from concurrent.futures import ProcessPoolExecutor
 from chuk_tool_processor.models.execution_strategy import ExecutionStrategy
 from chuk_tool_processor.models.tool_call import ToolCall
 from chuk_tool_processor.models.tool_result import ToolResult
-from chuk_tool_processor.utils.logging import get_logger
+from chuk_tool_processor.logging import get_logger
 
 logger = get_logger("chuk_tool_processor.execution.subprocess_strategy")
 

chuk_tool_processor/logging/__init__.py

@@ -0,0 +1,35 @@
+# chuk_tool_processor/logging/__init__.py
+"""
+Public façade for chuk_tool_processor structured logging.
+
+Other modules can continue to import:
+
+    from chuk_tool_processor.logging import get_logger, log_context_span, ...
+"""
+
+from __future__ import annotations
+import logging
+import sys
+
+from .formatter import StructuredFormatter
+from .context import get_logger, log_context, StructuredAdapter
+from .helpers import log_context_span, request_logging, log_tool_call, metrics
+
+__all__ = [
+    "get_logger",
+    "log_context_span",
+    "request_logging",
+    "log_tool_call",
+    "metrics",
+]
+
+# --------------------------------------------------------------------------- #
+# root logger & handler wiring (done once at import time)
+# --------------------------------------------------------------------------- #
+root_logger = logging.getLogger("chuk_tool_processor")
+root_logger.setLevel(logging.INFO)
+
+_handler = logging.StreamHandler(sys.stderr)
+_handler.setLevel(logging.INFO)
+_handler.setFormatter(StructuredFormatter())
+root_logger.addHandler(_handler)

chuk_tool_processor/logging/context.py

@@ -0,0 +1,47 @@
+# chuk_tool_processor/logging/context.py
+from __future__ import annotations
+import logging
+import uuid
+from typing import Any, Dict, Optional
+
+__all__ = ["log_context", "StructuredAdapter", "get_logger"]
+
+
+class LogContext:
+    """Thread-local dict for request / span ids."""
+
+    def __init__(self):
+        self.context: Dict[str, Any] = {}
+        self.request_id: str | None = None
+
+    # simple helpers ----------------------------------------------------
+    def update(self, kv: Dict[str, Any]):      self.context.update(kv)
+    def clear(self):                           self.context.clear()
+    def get_copy(self) -> Dict[str, Any]:      return self.context.copy()
+
+    # convenience -------------------------------------------------------
+    def start_request(self, request_id: str | None = None) -> str:
+        self.request_id = request_id or str(uuid.uuid4())
+        self.context["request_id"] = self.request_id
+        return self.request_id
+
+    def end_request(self): self.clear()
+
+
+log_context = LogContext()
+
+
+class StructuredAdapter(logging.LoggerAdapter):
+    """Inject `log_context.context` into every log record."""
+
+    def process(self, msg, kwargs):
+        kwargs = kwargs or {}
+        extra = kwargs.get("extra", {})
+        if log_context.context:
+            extra.setdefault("context", {}).update(log_context.get_copy())
+        kwargs["extra"] = extra
+        return msg, kwargs
+
+
+def get_logger(name: str) -> StructuredAdapter:
+    return StructuredAdapter(logging.getLogger(name), {})

chuk_tool_processor/logging/formatter.py

@@ -0,0 +1,55 @@
+# chuk_tool_processor/logging/formatter.py
+from __future__ import annotations
+import json
+import logging
+from datetime import datetime, timezone
+from typing import Any
+
+__all__ = ["StructuredFormatter"]
+
+
+class StructuredFormatter(logging.Formatter):
+    """
+    JSON formatter that can serialise BaseModels, datetimes, sets, etc.
+    """
+
+    @staticmethod
+    def _json_default(obj: Any):
+        # pydantic models → dict
+        try:
+            from pydantic import BaseModel
+            if isinstance(obj, BaseModel):
+                return obj.model_dump()
+        except ImportError:
+            pass
+        # datetimes → ISO
+        from datetime import date
+        if isinstance(obj, (datetime, date)):
+            return obj.isoformat()
+        # sets → list
+        if isinstance(obj, (set, frozenset)):
+            return list(obj)
+        # fall back
+        return str(obj)
+
+    def format(self, record: logging.LogRecord) -> str:  # noqa: D401
+        data = {
+            "timestamp": datetime.fromtimestamp(record.created, timezone.utc)
+            .isoformat()
+            .replace("+00:00", "Z"),
+            "level": record.levelname,
+            "message": record.getMessage(),
+            "logger": record.name,
+            "pid": record.process,
+            "thread": record.thread,
+            "file": record.filename,
+            "line": record.lineno,
+            "function": record.funcName,
+        }
+        if record.exc_info:
+            data["traceback"] = self.formatException(record.exc_info)
+        if hasattr(record, "extra"):
+            data.update(record.extra)
+        if hasattr(record, "context"):
+            data["context"] = record.context
+        return json.dumps(data, default=self._json_default)

chuk_tool_processor/logging/helpers.py

@@ -0,0 +1,112 @@
+# chuk_tool_processor/logging/helpers.py
+from __future__ import annotations
+import time
+import uuid
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from typing import Dict, Optional
+
+from .context import get_logger, log_context
+from .metrics import metrics  # re-export convenience
+
+__all__ = [
+    "log_context_span",
+    "request_logging",
+    "log_tool_call",
+    "metrics",
+]
+
+# --------------------------------------------------------------------------- #
+# context-manager helpers
+# --------------------------------------------------------------------------- #
+@contextmanager
+def log_context_span(operation: str, extra: Dict | None = None, *, log_duration=True):
+    logger = get_logger(f"chuk_tool_processor.span.{operation}")
+    start = time.time()
+    span_id = str(uuid.uuid4())
+    span_ctx = {
+        "span_id": span_id,
+        "operation": operation,
+        "start_time": datetime.fromtimestamp(start, timezone.utc)
+        .isoformat()
+        .replace("+00:00", "Z"),
+    }
+    if extra:
+        span_ctx.update(extra)
+    prev = log_context.get_copy()
+    log_context.update(span_ctx)
+
+    logger.info("Starting %s", operation)
+    try:
+        yield
+        if log_duration:
+            logger.info(
+                "Completed %s", operation, extra={"context": {"duration": time.time() - start}}
+            )
+        else:
+            logger.info("Completed %s", operation)
+    except Exception as exc:
+        logger.exception(
+            "Error in %s: %s", operation, exc, extra={"context": {"duration": time.time() - start}}
+        )
+        raise
+    finally:
+        log_context.clear()
+        if prev:
+            log_context.update(prev)
+
+
+@contextmanager
+def request_logging(request_id: str | None = None):
+    logger = get_logger("chuk_tool_processor.request")
+    request_id = log_context.start_request(request_id)
+    start = time.time()
+    logger.info("Starting request %s", request_id)
+    try:
+        yield request_id
+        logger.info(
+            "Completed request %s",
+            request_id,
+            extra={"context": {"duration": time.time() - start}},
+        )
+    except Exception as exc:
+        logger.exception(
+            "Error in request %s: %s",
+            request_id,
+            exc,
+            extra={"context": {"duration": time.time() - start}},
+        )
+        raise
+    finally:
+        log_context.end_request()
+
+
+# --------------------------------------------------------------------------- #
+# high-level helper
+# --------------------------------------------------------------------------- #
+def log_tool_call(tool_call, tool_result):
+    logger = get_logger("chuk_tool_processor.tool_call")
+    dur = (tool_result.end_time - tool_result.start_time).total_seconds()
+
+    ctx = {
+        "tool": tool_call.tool,
+        "arguments": tool_call.arguments,
+        "result": (
+            tool_result.result.model_dump()
+            if hasattr(tool_result.result, "model_dump")
+            else tool_result.result
+        ),
+        "error": tool_result.error,
+        "duration": dur,
+        "machine": tool_result.machine,
+        "pid": tool_result.pid,
+    }
+    if getattr(tool_result, "cached", False):
+        ctx["cached"] = True
+    if getattr(tool_result, "attempts", 0):
+        ctx["attempts"] = tool_result.attempts
+
+    if tool_result.error:
+        logger.error("Tool %s failed: %s", tool_call.tool, tool_result.error, extra={"context": ctx})
+    else:
+        logger.info("Tool %s succeeded in %.3fs", tool_call.tool, dur, extra={"context": ctx})

chuk_tool_processor/logging/metrics.py

@@ -0,0 +1,59 @@
+# chuk_tool_processor/logging/metrics.py
+from __future__ import annotations
+from .context import get_logger
+
+__all__ = ["metrics", "MetricsLogger"]
+
+
+class MetricsLogger:
+    def __init__(self):
+        self.logger = get_logger("chuk_tool_processor.metrics")
+
+    # ------------------------------------------------------------------
+    def log_tool_execution(
+        self,
+        tool: str,
+        success: bool,
+        duration: float,
+        *,
+        error: str | None = None,
+        cached: bool = False,
+        attempts: int = 1,
+    ):
+        self.logger.info(
+            f"Tool execution metric: {tool}",
+            extra={
+                "context": {
+                    "metric_type": "tool_execution",
+                    "tool": tool,
+                    "success": success,
+                    "duration": duration,
+                    "error": error,
+                    "cached": cached,
+                    "attempts": attempts,
+                }
+            },
+        )
+
+    def log_parser_metric(
+        self,
+        parser: str,
+        success: bool,
+        duration: float,
+        num_calls: int,
+    ):
+        self.logger.info(
+            f"Parser metric: {parser}",
+            extra={
+                "context": {
+                    "metric_type": "parser",
+                    "parser": parser,
+                    "success": success,
+                    "duration": duration,
+                    "num_calls": num_calls,
+                }
+            },
+        )
+
+
+metrics = MetricsLogger()

chuk_tool_processor/models/execution_strategy.py

@@ -1,4 +1,4 @@
-# chuk_tool_processor/execution/execution_strategy.py
+# chuk_tool_processor/models/execution_strategy.py
 from abc import ABC, abstractmethod
 from typing import List, Optional