tactus 0.33.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

tactus/adapters/file_storage.py

@@ -82,6 +82,26 @@ class FileStorage:
         except (IOError, OSError) as e:
             raise RuntimeError(f"Failed to write procedure file {file_path}: {e}")
 
+    def _deserialize_result(self, result: Any) -> Any:
+        """Deserialize checkpoint result, reconstructing Pydantic models."""
+        if result is None:
+            return None
+        # Check if result is a serialized Pydantic model
+        if isinstance(result, dict) and result.get("__pydantic__"):
+            from tactus.protocols.models import HITLResponse
+
+            model_name = result.get("__model__")
+            # Remove metadata fields
+            data = {k: v for k, v in result.items() if not k.startswith("__")}
+            # Reconstruct based on model name
+            if model_name == "HITLResponse":
+                # Need to parse datetime string back to datetime
+                if "responded_at" in data and isinstance(data["responded_at"], str):
+                    data["responded_at"] = datetime.fromisoformat(data["responded_at"])
+                return HITLResponse(**data)
+            # Add other model types as needed
+        return result
+
     def load_procedure_metadata(self, procedure_id: str) -> ProcedureMetadata:
         """Load procedure metadata from file."""
         data = self._read_file(procedure_id)
@@ -102,7 +122,7 @@ class FileStorage:
                 CheckpointEntry(
                     position=entry_data["position"],
                     type=entry_data["type"],
-                    result=entry_data["result"],
+                    result=self._deserialize_result(entry_data["result"]),
                     timestamp=datetime.fromisoformat(entry_data["timestamp"]),
                     duration_ms=entry_data.get("duration_ms"),
                     input_hash=entry_data.get("input_hash"),
@@ -122,6 +142,19 @@ class FileStorage:
             waiting_on_message_id=data.get("waiting_on_message_id"),
         )
 
+    def _serialize_result(self, result: Any) -> Any:
+        """Serialize checkpoint result, handling Pydantic models."""
+        if result is None:
+            return None
+        # Check if result is a Pydantic model (has model_dump method)
+        if hasattr(result, "model_dump"):
+            return {
+                "__pydantic__": True,
+                "__model__": result.__class__.__name__,
+                **result.model_dump(),
+            }
+        return result
+
     def save_procedure_metadata(self, procedure_id: str, metadata: ProcedureMetadata) -> None:
         """Save procedure metadata to file."""
         # Convert to serializable dict
@@ -131,7 +164,7 @@ class FileStorage:
                 {
                     "position": entry.position,
                     "type": entry.type,
-                    "result": entry.result,
+                    "result": self._serialize_result(entry.result),
                     "timestamp": entry.timestamp.isoformat(),
                     "duration_ms": entry.duration_ms,
                     "input_hash": entry.input_hash,

tactus/adapters/ide_log.py

@@ -21,6 +21,8 @@ class IDELogHandler:
     for retrieval and streaming to the IDE frontend.
     """
 
+    supports_streaming = True
+
     def __init__(self):
         """Initialize IDE log handler."""
         self.events = queue.Queue()
@@ -34,6 +36,9 @@ class IDELogHandler:
         Args:
             event: Structured log event
         """
+        # CRITICAL DEBUG: Log every call to this method
+        logger.info(f"[IDE_LOG] log() called with event type: {type(event).__name__}")
+
         # Track cost events for aggregation
         from tactus.protocols.models import CostEvent, AgentStreamChunkEvent
 
@@ -47,7 +52,8 @@ class IDELogHandler:
             )
 
         self.events.put(event)
-        logger.debug(
+        # Use INFO level to ensure we see this in logs
+        logger.info(
             f"[IDE_LOG] Event queued: type={type(event).__name__}, queue_size={self.events.qsize()}"
         )
 

tactus/backends/http_backend.py

@@ -7,7 +7,6 @@ from typing import Any
 
 import httpx
 
-
 logger = logging.getLogger(__name__)
 
 

tactus/broker/client.py

@@ -9,6 +9,7 @@ Uses a broker transport selected at runtime:
 
 import asyncio
 import json
+import logging
 import os
 import ssl
 import sys
@@ -20,6 +21,8 @@ from typing import Any, AsyncIterator, Optional
 from tactus.broker.protocol import read_message, write_message
 from tactus.broker.stdio import STDIO_REQUEST_PREFIX, STDIO_TRANSPORT_VALUE
 
+logger = logging.getLogger(__name__)
+
 
 def _json_dumps(obj: Any) -> str:
     return json.dumps(obj, ensure_ascii=False, separators=(",", ":"))
@@ -162,7 +165,15 @@ class BrokerClient:
                     ssl_ctx.verify_mode = ssl.CERT_NONE
 
             reader, writer = await asyncio.open_connection(host, port, ssl=ssl_ctx)
-            await write_message(writer, {"id": req_id, "method": method, "params": params})
+            logger.info(
+                f"[BROKER_CLIENT] Writing message to broker, params keys: {list(params.keys())}"
+            )
+            try:
+                await write_message(writer, {"id": req_id, "method": method, "params": params})
+            except TypeError as e:
+                logger.error(f"[BROKER_CLIENT] JSON serialization error: {e}")
+                logger.error(f"[BROKER_CLIENT] Params: {params}")
+                raise
 
             try:
                 while True:
@@ -207,6 +218,8 @@ class BrokerClient:
         temperature: Optional[float] = None,
         max_tokens: Optional[int] = None,
         stream: bool,
+        tools: Optional[list[dict[str, Any]]] = None,
+        tool_choice: Optional[str] = None,
     ) -> AsyncIterator[dict[str, Any]]:
         params: dict[str, Any] = {
             "provider": provider,
@@ -218,6 +231,23 @@ class BrokerClient:
             params["temperature"] = temperature
         if max_tokens is not None:
             params["max_tokens"] = max_tokens
+        if tools is not None:
+            params["tools"] = tools
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.info(f"[BROKER_CLIENT] Adding {len(tools)} tools to params")
+        else:
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.warning("[BROKER_CLIENT] No tools to add to params")
+        if tool_choice is not None:
+            params["tool_choice"] = tool_choice
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.info(f"[BROKER_CLIENT] Adding tool_choice={tool_choice} to params")
         return self._request("llm.chat", params)
 
     async def call_tool(self, *, name: str, args: dict[str, Any]) -> Any: