mycode-sdk 0.10.0__tar.gz → 0.11.0__tar.gz

{mycode_sdk-0.10.0 → mycode_sdk-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-sdk
-Version: 0.10.0
+Version: 0.11.0
 Summary: Lightweight Python SDK for building AI agents.
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode
@@ -71,7 +71,7 @@ print(result.text)
 
 ## Multi-turn conversations
 
-Call `achat()` or `run()` again on the same `Agent` — history accumulates automatically:
+Call `achat()` or `run()` again on the same `Agent` to continue the conversation:
 
 ```python
 agent = Agent(model="claude-sonnet-4-6", api_key="...")
@@ -117,7 +117,7 @@ agent = Agent(
 )
 ```
 
-Construct another `Agent` with the same `(session_dir, session_id)` later to resume the conversation — the history is loaded automatically.
+Construct another `Agent` with the same `(session_dir, session_id)` to load the conversation history.
 
 ## Built-in tools
 
@@ -167,6 +167,8 @@ def summarize_file(ctx: ToolContext, path: str) -> str:
     return result.output.splitlines()[0] if result.output else ""
 ```
 
+Async tools use `await ctx.aread()`, `await ctx.awrite()`, `await ctx.aedit()`, and `await ctx.abash()`. Use `await ctx.acall(name, args)` to call another registered tool by name.
+
 ## Tool hooks
 
 Inspect or replace tool calls before they run. Return `None` from `before_tool` to let the tool execute, or a `ToolExecutionResult` to skip it:

{mycode_sdk-0.10.0 → mycode_sdk-0.11.0}/README.md

@@ -44,7 +44,7 @@ print(result.text)
 
 ## Multi-turn conversations
 
-Call `achat()` or `run()` again on the same `Agent` — history accumulates automatically:
+Call `achat()` or `run()` again on the same `Agent` to continue the conversation:
 
 ```python
 agent = Agent(model="claude-sonnet-4-6", api_key="...")
@@ -90,7 +90,7 @@ agent = Agent(
 )
 ```
 
-Construct another `Agent` with the same `(session_dir, session_id)` later to resume the conversation — the history is loaded automatically.
+Construct another `Agent` with the same `(session_dir, session_id)` to load the conversation history.
 
 ## Built-in tools
 
@@ -140,6 +140,8 @@ def summarize_file(ctx: ToolContext, path: str) -> str:
     return result.output.splitlines()[0] if result.output else ""
 ```
 
+Async tools use `await ctx.aread()`, `await ctx.awrite()`, `await ctx.aedit()`, and `await ctx.abash()`. Use `await ctx.acall(name, args)` to call another registered tool by name.
+
 ## Tool hooks
 
 Inspect or replace tool calls before they run. Return `None` from `before_tool` to let the tool execute, or a `ToolExecutionResult` to skip it:

{mycode_sdk-0.10.0 → mycode_sdk-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mycode-sdk"
-version = "0.10.0"
+version = "0.11.0"
 description = "Lightweight Python SDK for building AI agents."
 readme = "README.md"
 requires-python = ">=3.12"

{mycode_sdk-0.10.0 → mycode_sdk-0.11.0}/src/mycode/agent.py

@@ -131,7 +131,9 @@ class Agent:
         self.system = system
         self.hooks = hooks or Hooks()
         self._cancel_event = asyncio.Event()
+        self._event_loop: asyncio.AbstractEventLoop | None = None
         self._provider_event_task: asyncio.Future[ProviderStreamEvent] | None = None
+        self._active_tool_task: asyncio.Task[ToolExecutionResult] | None = None
 
         # History resolution:
         # - messages is None → auto-resume from disk if the session exists
@@ -201,10 +203,24 @@ class Agent:
     def cancel(self) -> None:
         """Request cancellation of the in-flight turn."""
 
+        try:
+            running_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            running_loop = None
+
+        loop = self._event_loop
+        if loop is not None and loop.is_running() and running_loop is not loop:
+            loop.call_soon_threadsafe(self._cancel_in_loop)
+            return
+        self._cancel_in_loop()
+
+    def _cancel_in_loop(self) -> None:
         self._cancel_event.set()
         self.tools.cancel_active()
         if self._provider_event_task and not self._provider_event_task.done():
             self._provider_event_task.cancel()
+        if self._active_tool_task and not self._active_tool_task.done():
+            self._active_tool_task.cancel()
 
     def clear(self) -> None:
         """Drop the in-memory conversation history."""
@@ -215,6 +231,23 @@ class Agent:
     # Tool execution
     # ------------------------------------------------------------------
 
+    async def _execute_tool(
+        self,
+        spec: ToolSpec,
+        args: dict[str, Any],
+        ctx: ToolContext,
+    ) -> ToolExecutionResult:
+        if not spec.is_async:
+            return await self.tools.aexecute(spec.name, args, ctx)
+
+        task = asyncio.create_task(self.tools.aexecute(spec.name, args, ctx))
+        self._active_tool_task = task
+        try:
+            return await task
+        finally:
+            if self._active_tool_task is task:
+                self._active_tool_task = None
+
     async def _run_tool_call(self, tool_use: dict[str, Any]) -> AsyncIterator[Event]:
         """Run one tool call and emit the standard tool events."""
 
@@ -261,13 +294,23 @@ class Agent:
             return
 
         if spec.streams_output:
-            async for event in self._run_streaming_tool(tool_id=tool_id, name=name, args=args, hook_ctx=hook_ctx):
+            async for event in self._run_streaming_tool(
+                tool_id=tool_id,
+                spec=spec,
+                args=args,
+                hook_ctx=hook_ctx,
+            ):
                 yield event
             return
 
         try:
             ctx = self._ctx_for_call(tool_id)
-            result = await asyncio.to_thread(self.tools.execute, name, args, ctx)
+            result = await self._execute_tool(spec, args, ctx)
+        except asyncio.CancelledError:
+            if self._cancel_event.is_set():
+                yield self._error_done(tool_id, "error: cancelled")
+                return
+            raise
         except Exception as exc:  # pragma: no cover - defensive
             result = ToolExecutionResult(output=f"error: {exc}", is_error=True)
 
@@ -277,7 +320,7 @@ class Agent:
         self,
         *,
         tool_id: str,
-        name: str,
+        spec: ToolSpec,
         args: dict[str, Any],
         hook_ctx: ToolHookContext,
     ) -> AsyncIterator[Event]:
@@ -291,13 +334,13 @@ class Agent:
 
         ctx = self._ctx_for_call(tool_id, emit=on_output)
 
-        async def run_in_thread() -> ToolExecutionResult:
+        async def run_tool() -> ToolExecutionResult:
             try:
-                return await asyncio.to_thread(self.tools.execute, name, args, ctx)
+                return await self._execute_tool(spec, args, ctx)
             finally:
                 loop.call_soon_threadsafe(output_queue.put_nowait, None)
 
-        task = asyncio.create_task(run_in_thread())
+        task = asyncio.create_task(run_tool())
         was_cancelled = False
         output_parts: list[str] = []
 
@@ -319,8 +362,8 @@ class Agent:
                 output_parts.append(output)
                 yield Event("tool_output", {"tool_use_id": tool_id, "output": output})
 
-        if was_cancelled:
-            with suppress(Exception):
+        if was_cancelled or (self._cancel_event.is_set() and task.cancelled()):
+            with suppress(asyncio.CancelledError, Exception):
                 await task
             output = "\n".join([*output_parts, "error: cancelled"]) if output_parts else "error: cancelled"
             yield self._error_done(tool_id, output)
@@ -490,6 +533,7 @@ class Agent:
         async def persist(message: ConversationMessage) -> None:
             await self._persist_message(message, on_persist)
 
+        self._event_loop = asyncio.get_running_loop()
         self._cancel_event.clear()
 
         user_message: ConversationMessage
@@ -742,6 +786,7 @@ class Agent:
         :meth:`cancel` stops the summary request.
         """
 
+        self._event_loop = asyncio.get_running_loop()
         self._cancel_event.clear()
         adapter = get_provider_adapter(self.provider)
         return await self._compact(adapter, on_persist)

{mycode_sdk-0.10.0 → mycode_sdk-0.11.0}/src/mycode/tools.py

@@ -13,6 +13,7 @@ facades on :class:`ToolContext`::
 from __future__ import annotations
 
 import asyncio
+import functools
 import inspect
 import json
 import os
@@ -25,7 +26,7 @@ import time
 import typing
 from base64 import b64encode
 from collections import deque
-from collections.abc import Callable, Mapping, Sequence
+from collections.abc import Callable, Coroutine, Mapping, Sequence
 from contextlib import suppress
 from dataclasses import dataclass
 from difflib import SequenceMatcher, unified_diff
@@ -71,7 +72,19 @@ class ToolExecutionResult:
     is_error: bool = False
 
 
-ToolRunner = Callable[["ToolContext", dict[str, Any]], ToolExecutionResult]
+SyncToolRunner = Callable[["ToolContext", dict[str, Any]], ToolExecutionResult]
+AsyncToolRunner = Callable[["ToolContext", dict[str, Any]], Coroutine[Any, Any, ToolExecutionResult]]
+ToolRunner = SyncToolRunner | AsyncToolRunner
+
+
+def _is_async_callable(runner: ToolRunner) -> bool:
+    current: Any = runner
+    while True:
+        current = inspect.unwrap(current)
+        if isinstance(current, functools.partial):
+            current = current.func
+            continue
+        return inspect.iscoroutinefunction(current) or inspect.iscoroutinefunction(type(current).__call__)
 
 
 @dataclass(frozen=True)
@@ -85,6 +98,10 @@ class ToolSpec:
     # Streaming tools push incremental output through ToolContext.emit.
     streams_output: bool = False
 
+    @property
+    def is_async(self) -> bool:
+        return _is_async_callable(self.runner)
+
 
 # ---------------------------------------------------------------------------
 # ToolContext
@@ -115,20 +132,48 @@ class ToolContext:
     ) -> ToolExecutionResult:
         return self.call("read", {"path": path, "offset": offset, "limit": limit})
 
+    async def aread(
+        self,
+        path: str,
+        *,
+        offset: int | None = None,
+        limit: int | None = None,
+    ) -> ToolExecutionResult:
+        return await self.acall("read", {"path": path, "offset": offset, "limit": limit})
+
     def write(self, path: str, content: str) -> ToolExecutionResult:
         return self.call("write", {"path": path, "content": content})
 
+    async def awrite(self, path: str, content: str) -> ToolExecutionResult:
+        return await self.acall("write", {"path": path, "content": content})
+
     def edit(self, path: str, edits: list[dict[str, str]]) -> ToolExecutionResult:
         return self.call("edit", {"path": path, "edits": edits})
 
+    async def aedit(self, path: str, edits: list[dict[str, str]]) -> ToolExecutionResult:
+        return await self.acall("edit", {"path": path, "edits": edits})
+
     def bash(self, command: str, *, timeout: int | None = None) -> ToolExecutionResult:
         return self.call("bash", {"command": command, "timeout": timeout})
 
+    async def abash(
+        self,
+        command: str,
+        *,
+        timeout: int | None = None,  # noqa: ASYNC109
+    ) -> ToolExecutionResult:
+        return await self.acall("bash", {"command": command, "timeout": timeout})
+
     def call(self, name: str, args: dict[str, Any]) -> ToolExecutionResult:
         """Dispatch through the registry, including from custom tool wrappers."""
 
         return self.executor.execute(name, args, self)
 
+    async def acall(self, name: str, args: dict[str, Any]) -> ToolExecutionResult:
+        """Asynchronously dispatch through the registry."""
+
+        return await self.executor.aexecute(name, args, self)
+
 
 # ---------------------------------------------------------------------------
 # ToolExecutor
@@ -160,7 +205,21 @@ class ToolExecutor:
         spec = self._tools.get(name)
         if spec is None:
             return ToolExecutionResult(output=f"error: unknown tool: {name}", is_error=True)
-        return spec.runner(ctx, args)
+        if spec.is_async:
+            runner = cast(AsyncToolRunner, spec.runner)
+            return asyncio.run(runner(ctx, args))
+        runner = cast(SyncToolRunner, spec.runner)
+        return runner(ctx, args)
+
+    async def aexecute(self, name: str, args: dict[str, Any], ctx: ToolContext) -> ToolExecutionResult:
+        spec = self._tools.get(name)
+        if spec is None:
+            return ToolExecutionResult(output=f"error: unknown tool: {name}", is_error=True)
+        if spec.is_async:
+            runner = cast(AsyncToolRunner, spec.runner)
+            return await runner(ctx, args)
+        runner = cast(SyncToolRunner, spec.runner)
+        return await asyncio.to_thread(runner, ctx, args)
 
     # Subprocess tracking: register with both this executor (per-session
     # cancel) and the process-global set (shutdown cleanup).
@@ -319,7 +378,7 @@ def tool(
 
         is_async = inspect.iscoroutinefunction(fn)
 
-        def runner(context: ToolContext, args: dict[str, Any]) -> ToolExecutionResult:
+        def prepare_args(args: dict[str, Any]) -> dict[str, Any] | ToolExecutionResult:
             # Strict providers send explicit null for an omitted optional field;
             # drop it so the parameter default applies instead of failing validation.
             validation_args = {
@@ -332,14 +391,29 @@ def tool(
             except ValidationError as exc:
                 return ToolExecutionResult(output=f"error: invalid tool input: {exc}", is_error=True)
 
-            call_args = {name: getattr(parsed_args, name) for name in tool_param_names}
-            if is_async:
-                # The executor runs on a worker thread, so spinning a fresh
-                # event loop here is safe.
-                value = asyncio.run(fn(context, **call_args) if wants_context else fn(**call_args))
-            else:
+            return {name: getattr(parsed_args, name) for name in tool_param_names}
+
+        if is_async:
+
+            async def async_runner(context: ToolContext, args: dict[str, Any]) -> ToolExecutionResult:
+                call_args = prepare_args(args)
+                if isinstance(call_args, ToolExecutionResult):
+                    return call_args
+                value = await (fn(context, **call_args) if wants_context else fn(**call_args))
+                return _coerce_tool_result(value)
+
+            runner: ToolRunner = async_runner
+
+        else:
+
+            def sync_runner(context: ToolContext, args: dict[str, Any]) -> ToolExecutionResult:
+                call_args = prepare_args(args)
+                if isinstance(call_args, ToolExecutionResult):
+                    return call_args
                 value = fn(context, **call_args) if wants_context else fn(**call_args)
-            return _coerce_tool_result(value)
+                return _coerce_tool_result(value)
+
+            runner = sync_runner
 
         return ToolSpec(
             name=tool_name,