feat: add comprehensive test suite for SDK modules

New test files for agent, discovery, evaluate, memory_config, memory_tools,
plan, toolkit, and tracing modules. Updated discovery, tools, and workflow
with improved functionality.

Author: Patel230

src/hawk/discovery.py

@@ -118,9 +118,10 @@ class WellKnownResolver:
         card = await resolver.resolve("assistant")
     """
 
-    def __init__(self, base_urls: list[str] | None = None) -> None:
+    def __init__(self, base_urls: list[str] | None = None, timeout: float = 5.0) -> None:
         self._base_urls = base_urls or []
         self._cache: dict[str, AgentCard] = {}
+        self._timeout = timeout
 
     async def resolve(self, agent_name: str) -> AgentCard | None:
         if agent_name in self._cache:
@@ -151,7 +152,7 @@ async def _fetch_card(self, base_url: str) -> AgentCard | None:
             import httpx
 
             url = f"{base_url.rstrip('/')}/.well-known/agent.json"
-            async with httpx.AsyncClient(timeout=5.0) as client:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
                 resp = await client.get(url)
                 if resp.status_code == 200:
                     data = resp.json()

src/hawk/tools.py

@@ -116,18 +116,44 @@ def chat_with_tools(
     Returns:
         The final ChatResponse after tool execution completes.
     """
-    {t.name: t for t in tools}
-    [t.to_dict() for t in tools]
+    tool_map = {t.name: t for t in tools}
+    tool_schemas = [t.to_dict() for t in tools]
 
     # Initial chat request — we pass tool definitions alongside the prompt.
     # The Hawk API accepts tools in the request body.
     response = client.chat(
         prompt,
         session_id=session_id,
         model=model,
+        tools=tool_schemas,
         **kwargs,
     )
 
+    # Handle tool-call responses in a loop up to max_rounds.
+    for _round in range(max_rounds):
+        if not hasattr(response, "tool_calls") or not response.tool_calls:
+            break
+
+        # Execute each tool call and collect results.
+        tool_results = []
+        for tc in response.tool_calls:
+            tool_name = tc.get("name") if isinstance(tc, dict) else getattr(tc, "name", None)
+            arguments = tc.get("arguments", {}) if isinstance(tc, dict) else getattr(tc, "arguments", {})
+            if tool_name and tool_name in tool_map:
+                result = _execute_tool(tool_map[tool_name], arguments)
+            else:
+                result = json.dumps({"error": f"Unknown tool: {tool_name}"})
+            tool_results.append({"tool_use_id": tc.get("id", "") if isinstance(tc, dict) else getattr(tc, "id", ""), "content": result})
+
+        # Send tool results back to continue the conversation.
+        response = client.chat(
+            prompt,
+            session_id=getattr(response, "session_id", session_id),
+            model=model,
+            tool_results=tool_results,
+            **kwargs,
+        )
+
     # For now, the Hawk daemon handles tool routing internally.
     # This loop structure supports future explicit tool-call responses.
     return cast("ChatResponse", response)
@@ -156,14 +182,38 @@ async def chat_with_tools_async(
     Returns:
         The final ChatResponse after tool execution completes.
     """
-    {t.name: t for t in tools}
-    [t.to_dict() for t in tools]
+    tool_map = {t.name: t for t in tools}
+    tool_schemas = [t.to_dict() for t in tools]
 
     response = await client.chat(
         prompt,
         session_id=session_id,
         model=model,
+        tools=tool_schemas,
         **kwargs,
     )
 
+    # Handle tool-call responses in a loop up to max_rounds.
+    for _round in range(max_rounds):
+        if not hasattr(response, "tool_calls") or not response.tool_calls:
+            break
+
+        tool_results = []
+        for tc in response.tool_calls:
+            tool_name = tc.get("name") if isinstance(tc, dict) else getattr(tc, "name", None)
+            arguments = tc.get("arguments", {}) if isinstance(tc, dict) else getattr(tc, "arguments", {})
+            if tool_name and tool_name in tool_map:
+                result = await _execute_tool_async(tool_map[tool_name], arguments)
+            else:
+                result = json.dumps({"error": f"Unknown tool: {tool_name}"})
+            tool_results.append({"tool_use_id": tc.get("id", "") if isinstance(tc, dict) else getattr(tc, "id", ""), "content": result})
+
+        response = await client.chat(
+            prompt,
+            session_id=getattr(response, "session_id", session_id),
+            model=model,
+            tool_results=tool_results,
+            **kwargs,
+        )
+
     return cast("ChatResponse", response)

src/hawk/workflow.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 from dataclasses import dataclass
 from typing import Any, Callable, TypeVar
 
@@ -87,37 +88,36 @@ def run(self, initial_input: Any = None) -> Any:
         if not self._built:
             raise RuntimeError("Workflow must be built before running")
 
-        import signal
-        import threading
-
         current = initial_input
 
         for s in self._steps:
-            if s.timeout is not None and threading.current_thread() is threading.main_thread():
-                step_name = s.name
-                step_timeout = s.timeout
-
-                # Use signal-based timeout on main thread
-                def _timeout_handler(
-                    signum: int,
-                    frame: Any,
-                    step_name: str = step_name,
-                    step_timeout: float = step_timeout,
-                ) -> None:
-                    raise TimeoutError(f"Step '{step_name}' timed out after {step_timeout}s")
-
-                old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
-                signal.setitimer(signal.ITIMER_REAL, step_timeout)
-                try:
-                    current = self._run_step_sync(s, current)
-                finally:
-                    signal.setitimer(signal.ITIMER_REAL, 0)
-                    signal.signal(signal.SIGALRM, old_handler)
+            if s.timeout is not None:
+                current = self._run_step_with_timeout(s, current)
             else:
                 current = self._run_step_sync(s, current)
 
         return current
 
+    def _run_step_with_timeout(self, s: Step, input_val: Any) -> Any:
+        """Run a step in a worker thread with a timeout.
+
+        Uses a ThreadPoolExecutor so the timeout works on any thread
+        (not just the main thread) and on all platforms (no SIGALRM).
+
+        Note: the worker thread keeps running after a timeout; only the
+        caller is unblocked.  This is inherent to cooperative cancellation
+        in Python and matches asyncio.wait_for semantics.
+        """
+        assert s.timeout is not None
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(self._run_step_sync, s, input_val)
+            try:
+                return future.result(timeout=s.timeout)
+            except TimeoutError:
+                raise TimeoutError(
+                    f"Step '{s.name}' timed out after {s.timeout}s"
+                ) from None
+
     def _run_step_sync(self, s: Step, input_val: Any) -> Any:
         """Run a single step with optional retry."""
         if s.retry_config is not None: