mycode-sdk 0.9.0__tar.gz → 0.9.1__tar.gz

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-sdk
-Version: 0.9.0
+Version: 0.9.1
 Summary: Lightweight Python SDK for building AI agents.
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode
@@ -18,11 +18,11 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
 Requires-Python: >=3.12
-Requires-Dist: anthropic>=0.102.0
-Requires-Dist: google-genai>=2.3.0
-Requires-Dist: griffelib>=2.0.2
-Requires-Dist: openai>=2.36.0
-Requires-Dist: pydantic>=2.13.4
+Requires-Dist: anthropic>=0.106.0
+Requires-Dist: google-genai>=2.8.0
+Requires-Dist: griffelib>=2.0.0
+Requires-Dist: openai>=2.41.0
+Requires-Dist: pydantic>=2.13.0
 Description-Content-Type: text/markdown
 
 # mycode-sdk

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mycode-sdk"
-version = "0.9.0"
+version = "0.9.1"
 description = "Lightweight Python SDK for building AI agents."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -23,11 +23,11 @@ classifiers = [
 ]
 keywords = ["agent", "llm", "anthropic", "openai", "gemini", "sdk"]
 dependencies = [
-    "anthropic>=0.102.0",
-    "google-genai>=2.3.0",
-    "griffelib>=2.0.2",
-    "openai>=2.36.0",
-    "pydantic>=2.13.4",
+    "anthropic>=0.106.0",
+    "google-genai>=2.8.0",
+    "griffelib>=2.0.0",
+    "openai>=2.41.0",
+    "pydantic>=2.13.0",
 ]
 
 [project.urls]

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/__init__.py

@@ -1,11 +1,4 @@
-"""mycode — multi-turn tool-calling agent runtime.
-
-Public API for embedding the agent loop in other Python applications. The
-runtime ships four built-in coding tools (``read``, ``write``, ``edit``,
-``bash``) exposed as :data:`read_tool`, :data:`write_tool`, :data:`edit_tool`,
-:data:`bash_tool` — pick the ones you want via ``tools=[...]`` rather than
-silently exposing file system and shell access.
-"""
+"""mycode — multi-turn tool-calling agent runtime."""
 
 from importlib import metadata
 

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/agent.py

@@ -13,6 +13,7 @@ import os
 import tempfile
 import time
 from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
+from contextlib import suppress
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, cast
@@ -232,18 +233,12 @@ class Agent:
         yield Event("tool_start", {"tool_call": {"id": tool_id, "name": name, "input": args}})
 
         if self._cancel_event.is_set():
-            yield self._tool_done_event(
-                tool_id,
-                ToolExecutionResult(output="error: cancelled", is_error=True),
-            )
+            yield self._error_done(tool_id, "error: cancelled")
             return
 
         spec = self.tools.get(name)
         if spec is None:
-            yield self._tool_done_event(
-                tool_id,
-                ToolExecutionResult(output=f"error: unknown tool: {name}", is_error=True),
-            )
+            yield self._error_done(tool_id, f"error: unknown tool: {name}")
             return
 
         hook_ctx = ToolHookContext(
@@ -259,10 +254,7 @@ class Agent:
         try:
             result = await self.hooks.run_before_tool(hook_ctx)
         except Exception as exc:
-            yield self._tool_done_event(
-                tool_id,
-                ToolExecutionResult(output=f"error: tool hook failed: {exc}", is_error=True),
-            )
+            yield self._error_done(tool_id, f"error: tool hook failed: {exc}")
             return
 
         if result is not None:
@@ -270,10 +262,7 @@ class Agent:
             return
 
         if self._cancel_event.is_set():
-            yield self._tool_done_event(
-                tool_id,
-                ToolExecutionResult(output="error: cancelled", is_error=True),
-            )
+            yield self._error_done(tool_id, "error: cancelled")
             return
 
         if spec.streams_output:
@@ -336,13 +325,10 @@ class Agent:
                 yield Event("tool_output", {"tool_use_id": tool_id, "output": output})
 
         if was_cancelled:
-            try:
+            with suppress(Exception):
                 await task
-            except Exception:
-                pass
             output = "\n".join([*output_parts, "error: cancelled"]) if output_parts else "error: cancelled"
-            result = ToolExecutionResult(output=output, is_error=True)
-            yield self._tool_done_event(tool_id, result)
+            yield self._error_done(tool_id, output)
             return
         else:
             try:
@@ -398,6 +384,11 @@ class Agent:
             data["content"] = result.content
         return Event("tool_done", data)
 
+    def _error_done(self, tool_id: str, message: str) -> Event:
+        """Build a tool_done event carrying an error result."""
+
+        return self._tool_done_event(tool_id, ToolExecutionResult(output=message, is_error=True))
+
     # ------------------------------------------------------------------
     # Provider streaming
     # ------------------------------------------------------------------
@@ -429,10 +420,52 @@ class Agent:
         finally:
             close = cast(Callable[[], Awaitable[None]] | None, getattr(provider_stream, "aclose", None))
             if close is not None:
-                try:
+                with suppress(Exception):
                     await close()
-                except Exception:
-                    pass
+
+    def _build_request(
+        self,
+        *,
+        tools: list[dict[str, Any]] | None = None,
+        max_tokens: int | None = None,
+        reasoning_effort: str | None = None,
+        append_messages: Sequence[ConversationMessage] = (),
+    ) -> ProviderRequest:
+        """Build a ProviderRequest from the agent's current state."""
+
+        return ProviderRequest(
+            provider=self.provider,
+            model=self.model,
+            session_id=self.session_id,
+            messages=self.messages,
+            system=self.system,
+            tools=self.tools.definitions if tools is None else tools,
+            max_tokens=self.max_tokens if max_tokens is None else max_tokens,
+            temperature=self.temperature,
+            api_key=self.api_key,
+            api_base=self.api_base,
+            reasoning_effort=reasoning_effort,
+            supports_image_input=self.supports_image_input,
+            supports_pdf_input=self.supports_pdf_input,
+            transcript_path=self.transcript_path,
+            append_messages=list(append_messages),
+        )
+
+    @staticmethod
+    def _elapsed_ms(start: float) -> int:
+        return max(0, int((time.monotonic() - start) * 1000))
+
+    @staticmethod
+    def _stamp_thinking_duration(content: list[Any], duration_ms: int) -> None:
+        """Merge duration_ms onto the last thinking block in content, if any."""
+
+        for block in reversed(content):
+            if not isinstance(block, dict) or block.get("type") != "thinking":
+                continue
+            raw_meta = block.get("meta")
+            meta = raw_meta if isinstance(raw_meta, dict) else {}
+            block["meta"] = {**meta, "duration_ms": duration_ms}
+            return
 
     # ------------------------------------------------------------------
     # Public entry points
@@ -460,8 +493,9 @@ class Agent:
 
         self._cancel_event.clear()
 
+        user_message: ConversationMessage
         if isinstance(user_input, str):
-            user_message: ConversationMessage = user_text_message(user_input)
+            user_message = user_text_message(user_input)
         else:
             if (user_input.get("role") or "user") != "user":
                 yield Event("error", {"message": "user input must be a user message"})
@@ -479,16 +513,15 @@ class Agent:
             user_message["content"] = list(user_message.get("content") or []) + blocks
 
         content_blocks = user_message.get("content") or []
-        if not self.supports_image_input and any(
-            isinstance(block, dict) and block.get("type") == "image" for block in content_blocks
-        ):
-            yield Event("error", {"message": "current model does not support image input"})
-            return
-        if not self.supports_pdf_input and any(
-            isinstance(block, dict) and block.get("type") == "document" for block in content_blocks
+        for block_type, supported, label in (
+            ("image", self.supports_image_input, "image input"),
+            ("document", self.supports_pdf_input, "PDF input"),
         ):
-            yield Event("error", {"message": "current model does not support PDF input"})
-            return
+            if not supported and any(
+                isinstance(block, dict) and block.get("type") == block_type for block in content_blocks
+            ):
+                yield Event("error", {"message": f"current model does not support {label}"})
+                return
 
         self.messages.append(user_message)
         await persist(user_message)
@@ -507,22 +540,7 @@ class Agent:
             thinking_started_at: float | None = None
             thinking_duration_ms: int | None = None
             provider_cancelled = False
-            request = ProviderRequest(
-                provider=self.provider,
-                model=self.model,
-                session_id=self.session_id,
-                messages=self.messages,
-                system=self.system,
-                tools=self.tools.definitions,
-                max_tokens=self.max_tokens,
-                temperature=self.temperature,
-                api_key=self.api_key,
-                api_base=self.api_base,
-                reasoning_effort=self.reasoning_effort,
-                supports_image_input=self.supports_image_input,
-                supports_pdf_input=self.supports_pdf_input,
-                transcript_path=self.transcript_path,
-            )
+            request = self._build_request(reasoning_effort=self.reasoning_effort)
 
             try:
                 async for provider_event in self._stream_provider_turn(adapter, request):
@@ -546,7 +564,7 @@ class Agent:
                         delta_text = str(provider_event.data.get("text") or "")
                         if delta_text:
                             if thinking_started_at is not None and thinking_duration_ms is None:
-                                thinking_duration_ms = max(0, int((time.monotonic() - thinking_started_at) * 1000))
+                                thinking_duration_ms = self._elapsed_ms(thinking_started_at)
                                 yield Event("reasoning_done", {"duration_ms": thinking_duration_ms})
                             if partial_content and partial_content[-1].get("type") == "text":
                                 partial_content[-1]["text"] = f"{partial_content[-1].get('text') or ''}{delta_text}"
@@ -562,7 +580,7 @@ class Agent:
                         continue
 
                     if thinking_started_at is not None and thinking_duration_ms is None:
-                        thinking_duration_ms = max(0, int((time.monotonic() - thinking_started_at) * 1000))
+                        thinking_duration_ms = self._elapsed_ms(thinking_started_at)
                         yield Event("reasoning_done", {"duration_ms": thinking_duration_ms})
 
                     message = provider_event.data.get("message")
@@ -579,15 +597,9 @@ class Agent:
             if provider_cancelled:
                 if partial_content:
                     if thinking_started_at is not None and thinking_duration_ms is None:
-                        thinking_duration_ms = max(0, int((time.monotonic() - thinking_started_at) * 1000))
+                        thinking_duration_ms = self._elapsed_ms(thinking_started_at)
                     if thinking_duration_ms is not None:
-                        for block in reversed(partial_content):
-                            if block.get("type") != "thinking":
-                                continue
-                            raw_meta = block.get("meta")
-                            meta = cast(dict[str, Any], raw_meta) if isinstance(raw_meta, dict) else {}
-                            block["meta"] = {**meta, "duration_ms": thinking_duration_ms}
-                            break
+                        self._stamp_thinking_duration(partial_content, thinking_duration_ms)
                     cancelled_message = build_message(
                         "assistant",
                         [dict(block) for block in partial_content],
@@ -607,13 +619,7 @@ class Agent:
                 return
 
             if thinking_duration_ms is not None:
-                for block in reversed(assistant_message.get("content") or []):
-                    if not isinstance(block, dict) or block.get("type") != "thinking":
-                        continue
-                    raw_meta = block.get("meta")
-                    meta = cast(dict[str, Any], raw_meta) if isinstance(raw_meta, dict) else {}
-                    block["meta"] = {**meta, "duration_ms": thinking_duration_ms}
-                    break
+                self._stamp_thinking_duration(assistant_message.get("content") or [], thinking_duration_ms)
 
             # Stamp context_window onto the persisted assistant message so
             # rewinds and refreshed clients can render token-usage % without
@@ -649,16 +655,13 @@ class Agent:
                             continue
 
                         d = event.data
-                        output = str(d.get("output") or "")
-                        metadata = d.get("metadata") if isinstance(d.get("metadata"), dict) else None
-                        content = d.get("content")
                         tool_results.append(
                             tool_result_block(
-                                tool_use_id=str(d.get("tool_use_id") or ""),
-                                output=output,
-                                metadata=metadata,
-                                is_error=bool(d.get("is_error")),
-                                content=content if isinstance(content, list) else None,
+                                tool_use_id=d["tool_use_id"],
+                                output=d["output"],
+                                metadata=d.get("metadata"),
+                                is_error=d["is_error"],
+                                content=d.get("content"),
                             )
                         )
 
@@ -735,20 +738,9 @@ class Agent:
     ) -> None:
         """Ask the provider for a summary, persist the compact event, append it."""
 
-        request = ProviderRequest(
-            provider=self.provider,
-            model=self.model,
-            session_id=self.session_id,
-            messages=self.messages,
-            system=self.system,
+        request = self._build_request(
             tools=[],
             max_tokens=min(self.max_tokens, 8192),
-            temperature=self.temperature,
-            api_key=self.api_key,
-            api_base=self.api_base,
-            supports_image_input=self.supports_image_input,
-            supports_pdf_input=self.supports_pdf_input,
-            transcript_path=self.transcript_path,
             append_messages=[user_text_message(COMPACT_SUMMARY_PROMPT)],
         )
 

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/attachments.py

@@ -6,6 +6,7 @@ same content blocks for the same input.
 
 from __future__ import annotations
 
+import builtins
 import html
 from base64 import b64encode
 from collections.abc import Sequence
@@ -29,7 +30,7 @@ class Attachment:
     bare ``Attachment("notes.txt")`` from silently becoming text instead of a path.
     """
 
-    source: Path | bytes | str
+    source: Path | builtins.bytes | str
     media_type: str | None = None
     name: str | None = None
 
@@ -40,7 +41,7 @@ class Attachment:
         return cls(source=Path(path), name=name)
 
     @classmethod
-    def bytes(cls, data: bytes, *, media_type: str, name: str | None = None) -> Self:
+    def bytes(cls, data: builtins.bytes, *, media_type: str, name: str | None = None) -> Self:
         """``media_type`` must be a supported image type or ``application/pdf``."""
 
         if not media_type:

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/providers/anthropic_like.py

@@ -24,6 +24,7 @@ from mycode.providers.base import (
     get_native_meta,
     load_document_block_payload,
     load_image_block_payload,
+    native_block_meta,
     tool_result_content_blocks,
 )
 
@@ -133,25 +134,27 @@ class AnthropicLikeAdapter(ProviderAdapter):
         api_key = self.require_api_key(request.api_key)
 
         try:
-            async with AsyncAnthropic(
-                api_key=api_key,
-                base_url=self.resolve_base_url(request.api_base),
-                timeout=DEFAULT_REQUEST_TIMEOUT,
-            ) as client:
-                async with client.messages.stream(**self._build_request_payload(request)) as stream:
-                    async for event in stream:
-                        event_type = getattr(event, "type", None)
-                        if event_type == "thinking":
-                            thinking = cast(str | None, getattr(event, "thinking", None))
-                            if thinking:
-                                yield ProviderStreamEvent("thinking_delta", {"text": thinking})
-                            continue
-                        if event_type == "text":
-                            text = cast(str | None, getattr(event, "text", None))
-                            if text:
-                                yield ProviderStreamEvent("text_delta", {"text": text})
-
-                    final_message = await stream.get_final_message()
+            async with (
+                AsyncAnthropic(
+                    api_key=api_key,
+                    base_url=self.resolve_base_url(request.api_base),
+                    timeout=DEFAULT_REQUEST_TIMEOUT,
+                ) as client,
+                client.messages.stream(**self._build_request_payload(request)) as stream,
+            ):
+                async for event in stream:
+                    event_type = getattr(event, "type", None)
+                    if event_type == "thinking":
+                        thinking = cast(str | None, getattr(event, "thinking", None))
+                        if thinking:
+                            yield ProviderStreamEvent("thinking_delta", {"text": thinking})
+                        continue
+                    if event_type == "text":
+                        text = cast(str | None, getattr(event, "text", None))
+                        if text:
+                            yield ProviderStreamEvent("text_delta", {"text": text})
+
+                final_message = await stream.get_final_message()
         except APIError as exc:
             raise ValueError(str(exc)) from exc
 
@@ -175,7 +178,7 @@ class AnthropicLikeAdapter(ProviderAdapter):
                 blocks.append(
                     thinking_block(
                         getattr(block, "thinking", ""),
-                        meta={"native": native_meta} if native_meta else None,
+                        meta=native_block_meta(native_meta),
                     )
                 )
                 continue
@@ -185,9 +188,7 @@ class AnthropicLikeAdapter(ProviderAdapter):
                 citations = getattr(block, "citations", None)
                 if citations:
                     native_meta["citations"] = dump_model(citations)
-                blocks.append(
-                    text_block(getattr(block, "text", ""), meta={"native": native_meta} if native_meta else None)
-                )
+                blocks.append(text_block(getattr(block, "text", ""), meta=native_block_meta(native_meta)))
                 continue
 
             if block_type == "tool_use":
@@ -200,7 +201,7 @@ class AnthropicLikeAdapter(ProviderAdapter):
                         tool_id=getattr(block, "id", ""),
                         name=getattr(block, "name", ""),
                         input=getattr(block, "input", None),
-                        meta={"native": native_meta} if native_meta else None,
+                        meta=native_block_meta(native_meta),
                     )
                 )
                 continue

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/providers/base.py

@@ -68,6 +68,12 @@ def get_native_meta(block: dict[str, Any]) -> dict[str, Any]:
     return {}
 
 
+def native_block_meta(native: dict[str, Any]) -> dict[str, Any] | None:
+    """Wrap accumulated native values as block meta, or None when empty."""
+
+    return {"native": native} if native else None
+
+
 class ProviderAdapter(ABC):
     """Base class for provider adapters.
 

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/providers/gemini.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import AsyncIterator
+from contextlib import suppress
 from typing import Any, override
 from urllib.parse import urlparse
 
@@ -88,10 +89,8 @@ class GoogleGeminiAdapter(ProviderAdapter):
         except APIError as exc:
             raise ValueError(str(exc)) from exc
         finally:
-            try:
+            with suppress(Exception):
                 await client.aio.aclose()
-            except Exception:
-                pass
 
         raw_usage = usage or {}
         total_tokens = raw_usage.get("total_token_count") or None

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/providers/openai_chat.py

@@ -19,6 +19,7 @@ from mycode.providers.base import (
     get_native_meta,
     load_document_block_payload,
     load_image_block_payload,
+    native_block_meta,
 )
 from mycode.utils import omit_none, parse_tool_arguments
 
@@ -109,7 +110,7 @@ class OpenAIChatAdapter(ProviderAdapter):
             blocks.append(
                 thinking_block(
                     "".join(thinking_parts),
-                    meta={"native": thinking_native_meta} if thinking_native_meta else None,
+                    meta=native_block_meta(thinking_native_meta),
                 )
             )
         if text_parts:
@@ -248,13 +249,15 @@ class OpenAIChatAdapter(ProviderAdapter):
         if role != "assistant":
             return []
 
-        text_parts = [str(block.get("text") or "") for block in blocks if block.get("type") == "text"]
+        text_parts = [
+            str(block.get("text") or "") for block in blocks if block.get("type") == "text" and block.get("text")
+        ]
         thinking_blocks = [block for block in blocks if block.get("type") == "thinking"]
         tool_use_blocks = [block for block in blocks if block.get("type") == "tool_use"]
 
         payload: dict[str, Any] = {
             "role": "assistant",
-            "content": "\n".join(part for part in text_parts if part),
+            "content": "\n".join(text_parts),
         }
 
         if tool_use_blocks:

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/providers/openai_responses.py

@@ -18,6 +18,7 @@ from mycode.providers.base import (
     dump_model,
     load_document_block_payload,
     load_image_block_payload,
+    native_block_meta,
     tool_result_content_blocks,
 )
 from mycode.utils import omit_none, parse_tool_arguments
@@ -285,7 +286,7 @@ class OpenAIResponsesAdapter(ProviderAdapter):
                 blocks.append(
                     thinking_block(
                         "".join(text_parts),
-                        meta={"native": item_meta} if item_meta else None,
+                        meta=native_block_meta(item_meta),
                     )
                 )
                 continue
@@ -301,7 +302,7 @@ class OpenAIResponsesAdapter(ProviderAdapter):
                     blocks.append(
                         text_block(
                             getattr(part, "text", ""),
-                            meta={"native": native_meta} if native_meta else None,
+                            meta=native_block_meta(native_meta),
                         )
                     )
                 continue
@@ -327,7 +328,7 @@ class OpenAIResponsesAdapter(ProviderAdapter):
                         tool_id=getattr(item, "call_id", ""),
                         name=getattr(item, "name", ""),
                         input=tool_input,
-                        meta={"native": item_meta} if item_meta else None,
+                        meta=native_block_meta(item_meta),
                     )
                 )
 

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/session.py

@@ -85,6 +85,12 @@ SessionMetaDict = dict[str, object]
 SessionIndex = dict[str, SessionMetaDict]
 
 
+def _project_meta(raw: dict[str, object]) -> SessionMetaDict:
+    """Keep only the known session-meta keys."""
+
+    return {key: raw[key] for key in META_KEYS if key in raw}
+
+
 class SessionData(TypedDict):
     session: SessionMetaDict
     messages: list[ConversationMessage]
@@ -138,10 +144,10 @@ class SessionStore:
             return None
         if not isinstance(raw, dict):
             return None
-        return {key: raw[key] for key in META_KEYS if key in raw}
+        return _project_meta(raw)
 
     def _write_meta(self, session_id: str, meta: SessionMetaDict) -> None:
-        meta = {key: meta[key] for key in META_KEYS if key in meta}
+        meta = _project_meta(meta)
         self.meta_path(session_id).write_text(json.dumps(meta, indent=2, ensure_ascii=False), encoding="utf-8")
         index = self._read_index()
         index[session_id] = dict(meta)
@@ -154,11 +160,7 @@ class SessionStore:
             return self._rebuild_index()
         if not isinstance(raw, dict):
             return self._rebuild_index()
-        return {
-            str(session_id): {key: meta[key] for key in META_KEYS if key in meta}
-            for session_id, meta in raw.items()
-            if isinstance(meta, dict)
-        }
+        return {str(session_id): _project_meta(meta) for session_id, meta in raw.items() if isinstance(meta, dict)}
 
     def _write_index(self, index: SessionIndex) -> None:
         self.index_path().write_text(json.dumps(index, indent=2, ensure_ascii=False), encoding="utf-8")
@@ -228,7 +230,6 @@ class SessionStore:
         if meta is None:
             return None
 
-        # Read the raw append-only log first. Replay happens after that.
         raw_messages: list[ConversationMessage] = []
         try:
             with self.messages_path(session_id).open("r", encoding="utf-8") as handle:
@@ -238,10 +239,10 @@ class SessionStore:
                         continue
                     try:
                         msg = json.loads(line)
-                        if isinstance(msg, dict):
-                            raw_messages.append(cast(ConversationMessage, msg))
                     except ValueError:
                         continue
+                    if isinstance(msg, dict):
+                        raw_messages.append(cast(ConversationMessage, msg))
         except FileNotFoundError:
             pass
 

{mycode_sdk-0.9.0 → mycode_sdk-0.9.1}/src/mycode/tools.py

@@ -26,9 +26,11 @@ import typing
 from base64 import b64encode
 from collections import deque
 from collections.abc import Callable, Mapping, Sequence
+from contextlib import suppress
 from dataclasses import dataclass
 from difflib import SequenceMatcher, unified_diff
 from pathlib import Path
+from types import FunctionType
 from typing import Any, TextIO, cast, overload
 
 from griffe import Docstring, DocstringSectionKind, Parser
@@ -222,10 +224,8 @@ def _kill_proc_tree(proc: subprocess.Popen[str]) -> None:
         else:
             proc.kill()
     except Exception:
-        try:
+        with suppress(Exception):
             proc.kill()
-        except Exception:
-            pass
 
 
 # ---------------------------------------------------------------------------
@@ -235,7 +235,7 @@ def _kill_proc_tree(proc: subprocess.Popen[str]) -> None:
 
 @overload
 def tool(
-    function: Callable[..., Any],
+    function: FunctionType,
     *,
     name: str | None = None,
     description: str | None = None,
@@ -252,17 +252,17 @@ def tool(
     description: str | None = None,
     parameters: Mapping[str, str] | None = None,
     streams_output: bool = False,
-) -> Callable[[Callable[..., Any]], ToolSpec]: ...
+) -> Callable[[FunctionType], ToolSpec]: ...
 
 
 def tool(
-    function: Callable[..., Any] | None = None,
+    function: FunctionType | None = None,
     *,
     name: str | None = None,
     description: str | None = None,
     parameters: Mapping[str, str] | None = None,
     streams_output: bool = False,
-) -> ToolSpec | Callable[[Callable[..., Any]], ToolSpec]:
+) -> ToolSpec | Callable[[FunctionType], ToolSpec]:
     """Wrap a sync or async Python function as a :class:`ToolSpec`."""
 
     current_frame = inspect.currentframe()
@@ -271,7 +271,7 @@ def tool(
     del current_frame
     del caller_frame
 
-    def wrap(fn: Callable[..., Any]) -> ToolSpec:
+    def wrap(fn: FunctionType) -> ToolSpec:
         tool_name = name or fn.__name__
         signature = inspect.signature(fn)
         signature_parameters = list(signature.parameters.values())
@@ -421,7 +421,7 @@ def _coerce_tool_result(value: Any) -> ToolExecutionResult:
     if isinstance(value, str):
         return ToolExecutionResult(output=value)
     try:
-        text = json.dumps(value, ensure_ascii=False)
+        text = json.dumps(value, ensure_ascii=False, default=str)
     except TypeError:
         text = str(value)
     return ToolExecutionResult(output=text)
@@ -901,10 +901,8 @@ def bash_tool(ctx: ToolContext, command: str, timeout: int | None = None) -> Too
         return ToolExecutionResult(output=f"error: {exc}", is_error=True)
     finally:
         if log_file is not None:
-            try:
+            with suppress(Exception):
                 log_file.close()
-            except Exception:
-                pass
         if proc is not None:
             ctx.untrack_proc(proc)
             if proc.poll() is None: