aury-agent 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

aury/agents/context_providers/message.py

@@ -82,11 +82,14 @@ class MessageContextProvider(BaseContextProvider):
                 type="truncated",
                 limit=self.max_messages,
             )
-            # Convert to LLM format
-            return [
-                {"role": m["role"], "content": m["content"]}
-                for m in messages
-            ]
+            # Convert to LLM format (include tool_call_id for tool messages)
+            result = []
+            for m in messages:
+                msg = {"role": m["role"], "content": m["content"]}
+                if m.get("tool_call_id"):
+                    msg["tool_call_id"] = m["tool_call_id"]
+                result.append(msg)
+            return result
         
         # No backend available
         logger.warning(

aury/agents/core/base.py

@@ -18,6 +18,8 @@ from dataclasses import dataclass, field
 from enum import Enum
 from typing import Any, AsyncIterator, Callable, ClassVar, Literal, TYPE_CHECKING
 
+from .logging import logger
+
 
 class ToolInjectionMode(Enum):
     """How tools are provided to LLM.
@@ -139,6 +141,7 @@ class BaseAgent(ABC):
         """
         self._ctx = ctx
         self.config = config or AgentConfig()
+        logger.debug(f"{self.agent_type}Agent init, name={self.config.name}, invocation_id={ctx.invocation_id}, max_steps={self.config.max_steps}")
         
         # Abort signal (delegates to ctx.abort_*)
         self._abort = asyncio.Event()
@@ -237,12 +240,14 @@ class BaseAgent(ABC):
             "stream_thinking": stream_thinking,
             "llm": llm,
         }
+        logger.info(f"{self.agent_type}Agent run start, invocation_id={self._ctx.invocation_id}, name={self.config.name}")
         
         # Auto-detect parent queue (nested agent call)
         # Skip if _force_own_queue is True (delegate tool needs to capture events)
         if not _force_own_queue:
             try:
                 parent_queue = _emit_queue_var.get()
+                logger.debug(f"{self.agent_type}Agent: nested call detected, reusing parent queue, invocation_id={self._ctx.invocation_id}")
                 # Has parent - passthrough mode, reuse parent queue
                 # Still set our ctx (child agent has its own ctx)
                 ctx_token = _set_current_ctx(self._ctx)
@@ -254,6 +259,7 @@ class BaseAgent(ABC):
             except LookupError:
                 pass
         
+        logger.debug(f"{self.agent_type}Agent: creating own queue for this run, invocation_id={self._ctx.invocation_id}")
         # No parent - create own queue and yield events
         queue: asyncio.Queue[BlockEvent | ActionEvent] = asyncio.Queue()
         queue_token = _emit_queue_var.set(queue)
@@ -331,7 +337,11 @@ class BaseAgent(ABC):
             
             # Check for exceptions in execution
             await exec_task
+            logger.info(f"{self.agent_type}Agent run completed successfully, invocation_id={self._ctx.invocation_id}")
             
+        except Exception as e:
+            logger.error(f"{self.agent_type}Agent run error, error={type(e).__name__}, invocation_id={self._ctx.invocation_id}", exc_info=True)
+            raise
         finally:
             _reset_current_ctx(ctx_token)
             _emit_queue_var.reset(queue_token)
@@ -354,6 +364,7 @@ class BaseAgent(ABC):
         Args:
             abort_chain: If True, abort entire invocation chain (SubAgents too)
         """
+        logger.warning(f"{self.agent_type}Agent cancel requested, abort_chain={abort_chain}, invocation_id={self._ctx.invocation_id if self._ctx else 'N/A'}")
         self._abort.set()
         if self._ctx:
             if abort_chain:

aury/agents/core/factory.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 from typing import Any, TYPE_CHECKING
 
 from .base import AgentConfig
+from .logging import context_logger as logger
 
 if TYPE_CHECKING:
     from .base import BaseAgent
@@ -51,6 +52,7 @@ class AgentFactory:
             name: Name to register under
             agent_class: Agent class (must have unified constructor)
         """
+        logger.debug(f"AgentFactory.register: registering agent, name={name}, class={agent_class.__name__}")
         self._registry[name] = agent_class
     
     def register_class(self, agent_class: type["BaseAgent"]) -> None:
@@ -60,6 +62,7 @@ class AgentFactory:
             agent_class: Agent class with 'name' class attribute
         """
         name = getattr(agent_class, 'name', agent_class.__name__)
+        logger.debug(f"AgentFactory.register_class: registering agent, name={name}, class={agent_class.__name__}")
         self._registry[name] = agent_class
     
     def register_all(self, *agent_classes: type["BaseAgent"]) -> None:
@@ -68,6 +71,7 @@ class AgentFactory:
         Args:
             agent_classes: Agent classes with 'name' class attribute
         """
+        logger.debug(f"AgentFactory.register_all: registering {len(agent_classes)} agents")
         for agent_class in agent_classes:
             self.register_class(agent_class)
     
@@ -95,11 +99,13 @@ class AgentFactory:
         """
         if agent_type not in self._registry:
             available = ", ".join(self._registry.keys()) or "none"
+            logger.error(f"AgentFactory.create: unknown agent type, type={agent_type}, available={available}, invocation_id={ctx.invocation_id}")
             raise KeyError(
                 f"Unknown agent type: {agent_type}. Available: {available}"
             )
         
         agent_class = self._registry[agent_type]
+        logger.debug(f"AgentFactory.create: creating agent, type={agent_type}, class={agent_class.__name__}, invocation_id={ctx.invocation_id}")
         return agent_class(ctx, config)
     
     def create_subagent(
@@ -122,7 +128,9 @@ class AgentFactory:
         Returns:
             Agent instance with child context
         """
+        logger.debug(f"AgentFactory.create_subagent: creating subagent, type={agent_type}, mode={mode}, parent_invocation_id={parent_ctx.invocation_id}")
         child_ctx = parent_ctx.create_child(agent_id=agent_type, mode=mode)
+        logger.debug(f"AgentFactory.create_subagent: child context created, child_invocation_id={child_ctx.invocation_id}")
         return self.create(agent_type, child_ctx, config)
     
     def list_types(self) -> list[str]:

aury/agents/core/parallel.py

@@ -8,6 +8,8 @@ from __future__ import annotations
 import asyncio
 from typing import Any, AsyncGenerator, TYPE_CHECKING
 
+from .logging import context_logger as logger
+
 if TYPE_CHECKING:
     from .types.block import BlockEvent
 
@@ -36,41 +38,51 @@ async def merge_agent_runs(
             print(event)
     """
     if not agent_runs:
+        logger.debug("merge_agent_runs: no agent runs provided")
         return
     
+    logger.debug(f"merge_agent_runs: starting merge with {len(agent_runs)} agent runs")
     sentinel = object()
     queue: asyncio.Queue[tuple[Any, asyncio.Event | None]] = asyncio.Queue()
     
-    async def process_agent(events: AsyncGenerator["BlockEvent", None]) -> None:
+    async def process_agent(events: AsyncGenerator["BlockEvent", None], agent_idx: int) -> None:
         """Process single agent's events."""
+        event_count = 0
         try:
             async for event in events:
+                event_count += 1
                 # Create resume signal to wait for consumer
                 resume_signal = asyncio.Event()
                 await queue.put((event, resume_signal))
                 # Wait for upstream to consume before generating more
                 await resume_signal.wait()
         finally:
+            logger.debug(f"merge_agent_runs: agent #{agent_idx} completed with {event_count} events")
             # Mark this agent as finished
             await queue.put((sentinel, None))
     
     # Use TaskGroup for parallel execution (Python 3.11+)
     async with asyncio.TaskGroup() as tg:
-        for events in agent_runs:
-            tg.create_task(process_agent(events))
+        for idx, events in enumerate(agent_runs):
+            tg.create_task(process_agent(events, idx))
         
         sentinel_count = 0
+        total_events = 0
         # Run until all agents finished
         while sentinel_count < len(agent_runs):
             item, resume_signal = await queue.get()
             
             if item is sentinel:
                 sentinel_count += 1
+                logger.debug(f"merge_agent_runs: agent finished, {sentinel_count}/{len(agent_runs)} agents done")
             else:
+                total_events += 1
                 yield item
                 # Signal agent to continue
                 if resume_signal:
                     resume_signal.set()
+    
+    logger.debug(f"merge_agent_runs: merge completed, total_events={total_events}")
 
 
 async def run_agents_parallel(
@@ -105,24 +117,30 @@ async def run_agents_parallel(
             timeout=60.0,
         )
     """
+    logger.debug(f"run_agents_parallel: starting {len(agent_tasks)} agents, timeout={timeout}")
     results: dict[str, Any] = {}
     
     async def run_one(name: str, input: Any) -> tuple[str, Any]:
         try:
+            logger.debug(f"run_agents_parallel: running agent, name={name}")
             result = await agent_runner(name, input)
+            logger.info(f"run_agents_parallel: agent completed, name={name}")
             return (name, result)
         except Exception as e:
+            logger.error(f"run_agents_parallel: agent failed, name={name}, error={type(e).__name__}", exc_info=True)
             return (name, {"error": str(e)})
     
     tasks = [run_one(name, input) for name, input in agent_tasks]
     
     if timeout:
         try:
+            logger.debug(f"run_agents_parallel: waiting for agents with timeout={timeout}s")
             completed = await asyncio.wait_for(
                 asyncio.gather(*tasks, return_exceptions=True),
                 timeout=timeout,
             )
         except asyncio.TimeoutError:
+            logger.warning(f"run_agents_parallel: timeout after {timeout}s, marking incomplete agents as timed out")
             # Return partial results with timeout error for incomplete
             for name, _ in agent_tasks:
                 if name not in results:
@@ -137,8 +155,9 @@ async def run_agents_parallel(
             results[name] = result
         elif isinstance(item, Exception):
             # Exception from gather
-            pass
+            logger.warning(f"run_agents_parallel: gathered exception: {type(item).__name__}")
     
+    logger.info(f"run_agents_parallel: completed, total_agents={len(agent_tasks)}, success={len(results)}, errors={len([r for r in results.values() if isinstance(r, dict) and 'error' in r])}")
     return results
 
 
@@ -164,17 +183,20 @@ class ParallelSubAgentContext:
         """Create isolated branch for sub-agent."""
         branch_id = f"{self.parent_invocation_id}.{agent_name}"
         self.branches[agent_name] = branch_id
+        logger.debug(f"ParallelSubAgentContext: created branch, agent={agent_name}, branch_id={branch_id}")
         return branch_id
     
     def mark_completed(self, agent_name: str, result: Any) -> None:
         """Mark agent as completed with result."""
         self._completed.add(agent_name)
         self.results[agent_name] = result
+        logger.info(f"ParallelSubAgentContext: agent completed, agent={agent_name}, pending={len(self.pending_agents)}")
     
     def mark_failed(self, agent_name: str, error: str) -> None:
         """Mark agent as failed with error."""
         self._completed.add(agent_name)
         self.errors[agent_name] = error
+        logger.warning(f"ParallelSubAgentContext: agent failed, agent={agent_name}, error={error}")
     
     @property
     def all_completed(self) -> bool:

aury/agents/core/state.py

@@ -273,8 +273,18 @@ class State:
         if not self._dirty:
             return
         
+        from ..core.logging import context_logger as logger
+        
         # Use invocation_id if set, otherwise fall back to session_id
         key = self._invocation_id or self._session_id
+        logger.debug(
+            "Checkpointing state",
+            extra={
+                "session_id": self._session_id,
+                "invocation_id": self._invocation_id,
+                "partitions": list(self._data.keys()),
+            },
+        )
         await self._backend.set("state", key, self._data)
         self._dirty = False
     
@@ -287,9 +297,19 @@ class State:
         Returns:
             True if state was restored, False if no saved state
         """
+        from ..core.logging import context_logger as logger
+        
         key = invocation_id or self._invocation_id or self._session_id
         data = await self._backend.get("state", key)
         if data:
+            logger.info(
+                "State restored from backend",
+                extra={
+                    "session_id": self._session_id,
+                    "invocation_id": invocation_id or self._invocation_id,
+                    "partitions": list(data.keys()),
+                },
+            )
             self._data = data
             # Ensure all partitions exist
             for partition in ("vars", "data", "execution"):
@@ -299,6 +319,11 @@ class State:
             if invocation_id:
                 self._invocation_id = invocation_id
             return True
+        else:
+            logger.debug(
+                "No saved state found",
+                extra={"session_id": self._session_id, "key": key},
+            )
         return False
     
     # ========== Utility ==========

aury/agents/core/types/tool.py

@@ -198,6 +198,7 @@ class ToolConfig:
     timeout: float | None = None  # Execution timeout in seconds
     requires_permission: bool = False  # Needs HITL approval
     permission_message: str | None = None
+    stream_arguments: bool = False  # Stream tool arguments to client
     
     # Retry configuration
     max_retries: int = 0  # 0 = no retry

aury/agents/hitl/ask_user.py

@@ -85,8 +85,19 @@ class AskUserTool(BaseTool):
             # If no context, return error (should not happen in normal use)
             return ToolResult.error("Cannot ask user without execution context")
         
+        from ..core.logging import tool_logger as logger
+        
         # Generate request ID
         request_id = generate_id("req")
+        logger.info(
+            "ask_user HITL request",
+            extra={
+                "invocation_id": ctx.invocation_id,
+                "request_id": request_id,
+                "question": question[:100],
+                "has_options": options is not None,
+            },
+        )
         
         # Create HITL request data
         request = HITLRequest(
@@ -100,6 +111,10 @@ class AskUserTool(BaseTool):
         
         # Checkpoint current state
         if hasattr(ctx, "state") and ctx.state is not None:
+            logger.debug(
+                "Checkpointing state before HITL suspend",
+                extra={"invocation_id": ctx.invocation_id},
+            )
             await ctx.state.checkpoint()
         
         # Update invocation status to SUSPENDED
@@ -124,6 +139,13 @@ class AskUserTool(BaseTool):
         ))
         
         # Raise signal to suspend execution
+        logger.info(
+            "Suspending execution for HITL ask_user",
+            extra={
+                "invocation_id": ctx.invocation_id,
+                "request_id": request_id,
+            },
+        )
         raise HITLSuspend(
             request_id=request_id,
             request_type="ask_user",
@@ -184,7 +206,18 @@ class ConfirmTool(BaseTool):
         if ctx is None:
             return ToolResult.error("Cannot confirm without execution context")
         
+        from ..core.logging import tool_logger as logger
+        
         request_id = generate_id("req")
+        logger.info(
+            "confirm HITL request",
+            extra={
+                "invocation_id": ctx.invocation_id,
+                "request_id": request_id,
+                "action": action[:100],
+                "risk_level": risk_level,
+            },
+        )
         
         message = f"Confirm: {action}"
         if details:
@@ -205,6 +238,10 @@ class ConfirmTool(BaseTool):
         
         # Checkpoint
         if hasattr(ctx, "state") and ctx.state is not None:
+            logger.debug(
+                "Checkpointing state before confirm suspend",
+                extra={"invocation_id": ctx.invocation_id},
+            )
             await ctx.state.checkpoint()
         
         # Update invocation
@@ -229,6 +266,13 @@ class ConfirmTool(BaseTool):
             },
         ))
         
+        logger.info(
+            "Suspending execution for confirm",
+            extra={
+                "invocation_id": ctx.invocation_id,
+                "request_id": request_id,
+            },
+        )
         raise HITLSuspend(
             request_id=request_id,
             request_type="confirm",

aury/agents/llm/adapter.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import json
 from typing import Any, AsyncIterator
 
+from ..core.logging import context_logger as logger
 from .provider import (
     LLMProvider,
     LLMEvent,
@@ -75,6 +76,7 @@ class ModelClientProvider:
                 "Please install it: pip install aury-ai-model[all]"
             )
         
+        logger.debug(f"ModelClientProvider init, provider={provider}, model={model}")
         self._provider_name = provider
         self._model_name = model
         self._capabilities = capabilities or Capabilities()
@@ -100,6 +102,7 @@ class ModelClientProvider:
             if k not in client_kwargs
         }
         self._call_count = 0
+        logger.debug(f"ModelClientProvider initialized, provider={provider}, model={model}")
     
     @property
     def provider(self) -> str:
@@ -119,9 +122,15 @@ class ModelClientProvider:
         """Get model capabilities."""
         return self._capabilities
     
-    def _convert_messages(self, messages: list[LLMMessage]) -> list[Message]:
+    def _convert_messages(
+        self,
+        messages: list[LLMMessage],
+        enable_thinking: bool = False,
+    ) -> list[Message]:
         """Convert LLMMessage to aury-ai-model Message.
         
+        Use simple OpenAI format - let API gateway handle Claude conversion.
+        
         Supports all message types from aury.ai.model:
         - system: msg.system(text)
         - user: msg.user(text, images=[])
@@ -157,45 +166,65 @@ class ModelClientProvider:
                     ))
             
             elif m.role == "assistant":
+                # Extract text, thinking, and tool_calls from content
+                # IMPORTANT: For Claude thinking mode, thinking must be included in history
+                # Claude API requires assistant messages to start with thinking block when thinking is enabled
+                text_content = None
+                thinking_content = None
+                tool_calls = None
+                
                 if isinstance(m.content, str):
-                    result.append(msg.assistant(m.content))
-                else:
-                    # Handle tool calls in assistant message
+                    text_content = m.content
+                elif isinstance(m.content, list):
+                    # Extract text, thinking, and tool_use from content parts
                     text_parts = []
-                    tool_calls = []
+                    thinking_parts = []
+                    tool_call_list = []
                     for part in m.content:
                         if isinstance(part, dict):
                             if part.get("type") == "text":
                                 text_parts.append(part.get("text", ""))
+                            elif part.get("type") == "thinking":
+                                # Include thinking for Claude API compatibility
+                                thinking_parts.append(part.get("thinking", ""))
                             elif part.get("type") == "tool_use":
-                                tool_calls.append(ModelToolCall(
+                                tool_call_list.append(ModelToolCall(
                                     id=part.get("id", ""),
                                     name=part.get("name", ""),
                                     arguments_json=json.dumps(part.get("input", {})),
                                 ))
-                    result.append(msg.assistant(
-                        text=" ".join(text_parts) if text_parts else None,
-                        tool_calls=tool_calls if tool_calls else None,
-                    ))
+                    text_content = " ".join(text_parts) if text_parts else None
+                    thinking_content = "".join(thinking_parts) if thinking_parts else None
+                    tool_calls = tool_call_list if tool_call_list else None
+                
+                result.append(msg.assistant(
+                    text=text_content,
+                    thinking=thinking_content,
+                    tool_calls=tool_calls,
+                ))
             
             elif m.role == "tool":
-                # Tool result message - two formats supported:
-                # 1. Simple: LLMMessage(role="tool", content="result", tool_call_id="xxx")
-                # 2. List format: content=[{"type": "tool_result", "content": "...", "tool_use_id": "..."}]
-                if m.tool_call_id and isinstance(m.content, str):
-                    # Simple format
+                # Tool result message
+                # Handle both string content (OpenAI) and list content (Anthropic)
+                tool_call_id = m.tool_call_id
+                tool_content = None
+                
+                if isinstance(m.content, str):
+                    tool_content = m.content
+                elif isinstance(m.content, list) and len(m.content) > 0:
+                    # Anthropic format: [{'type': 'tool_result', 'tool_use_id': '...', 'content': '...'}]
+                    first_item = m.content[0]
+                    if isinstance(first_item, dict):
+                        tool_content = first_item.get("content", "")
+                        # Also extract tool_call_id if not already set
+                        if not tool_call_id:
+                            tool_call_id = first_item.get("tool_use_id") or first_item.get("tool_call_id")
+                
+                if tool_call_id and tool_content is not None:
                     result.append(msg.tool(
-                        result=m.content,
-                        tool_call_id=m.tool_call_id,
+                        result=tool_content,
+                        tool_call_id=tool_call_id,
                     ))
-                elif isinstance(m.content, list):
-                    # List format (for compatibility)
-                    for part in m.content:
-                        if isinstance(part, dict) and part.get("type") == "tool_result":
-                            result.append(msg.tool(
-                                result=str(part.get("content", "")),
-                                tool_call_id=part.get("tool_use_id", ""),
-                            ))
         
         return result
     
@@ -309,7 +338,7 @@ class ModelClientProvider:
             LLMEvent: Streaming events (content, thinking, tool_call, usage, completed, error)
         """
         # Convert messages and tools
-        model_messages = self._convert_messages(messages)
+        model_messages = self._convert_messages(messages, enable_thinking=enable_thinking)
         model_tools = self._convert_tools(tools)
         
         # Merge kwargs

aury/agents/llm/openai.py

@@ -121,9 +121,13 @@ class OpenAIProvider:
             LLMEvent objects
         """
         # Build request payload
+        converted_msgs = self._convert_messages(messages)
+        print(f"[DEBUG OpenAIProvider] Sending {len(converted_msgs)} messages to {self._model}")
+        for i, msg in enumerate(converted_msgs):
+            print(f"[DEBUG]   Message {i}: role={msg.get('role')}, content={str(msg.get('content'))[:100]}")
         payload: dict[str, Any] = {
             "model": self._model,
-            "messages": self._convert_messages(messages),
+            "messages": converted_msgs,
             "stream": True,
             "stream_options": {"include_usage": True},
         }

aury/agents/memory/manager.py

@@ -77,6 +77,15 @@ class MemoryManager:
         if not messages:
             return
         
+        logger.info(
+            "Memory auto-save on invocation end",
+            extra={
+                "invocation_id": payload.get("invocation_id"),
+                "session_id": payload.get("session_id"),
+                "message_count": len(messages),
+            },
+        )
+        
         content = self._format_messages(messages)
         
         await self.add(
@@ -120,9 +129,14 @@ class MemoryManager:
         
         Returns entry ID or None if filtered out.
         """
-        logger.debug(
+        logger.info(
             "Adding to memory",
-            extra={"trigger": trigger.value, "session_id": session_id}
+            extra={
+                "trigger": trigger.value,
+                "session_id": session_id,
+                "invocation_id": invocation_id,
+                "content_length": len(content),
+            },
         )
         entry = MemoryEntry(
             id=str(uuid4()),
@@ -141,9 +155,17 @@ class MemoryManager:
         
         # 1. Apply filters
         for filter in self.write_filters:
+            logger.debug(
+                "Applying memory write filter",
+                extra={"filter": type(filter).__name__, "invocation_id": invocation_id},
+            )
             result = await filter.filter(entries, write_context)
             
             if result.decision == WriteDecision.SKIP:
+                logger.debug(
+                    "Memory entry skipped by filter",
+                    extra={"filter": type(filter).__name__, "invocation_id": invocation_id},
+                )
                 return None
             elif result.decision == WriteDecision.TRANSFORM:
                 entries = result.entries or []
@@ -179,6 +201,15 @@ class MemoryManager:
         
         Searches all configured sources and merges results.
         """
+        logger.info(
+            "Searching memory",
+            extra={
+                "query_length": len(query),
+                "limit": limit,
+                "source_count": len(self.retrieval_config),
+            },
+        )
+        
         # 1. Search all sources
         all_results: dict[str, list[ScoredEntry]] = {}