mycode-sdk 0.5.8__tar.gz → 0.7.0__tar.gz

{mycode_sdk-0.5.8 → mycode_sdk-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-sdk
-Version: 0.5.8
+Version: 0.7.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
@@ -139,4 +139,32 @@ def summarize_file(ctx: ToolContext, path: str) -> str:
     return result.output.splitlines()[0] if result.output else ""
 ```
 
+## 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:
+
+```python
+from mycode import Agent, Hooks, ToolExecutionResult, bash_tool
+
+hooks = Hooks()
+
+
+@hooks.before_tool
+async def block_rm(ctx):
+    cmd = str(ctx.tool_input.get("command") or "")
+    if ctx.tool_name == "bash" and "rm -rf" in cmd:
+        return ToolExecutionResult(output="error: blocked", is_error=True)
+    return None
+
+
+agent = Agent(
+    model="claude-sonnet-4-6",
+    api_key="...",
+    tools=[bash_tool],
+    hooks=hooks,
+)
+```
+
+`@hooks.after_tool` runs after the tool and can replace the result (audit, redact, etc.).
+
 See [docs/sdk.md](../docs/sdk.md) for the event stream, cancellation, sessions, and the full `Agent` / `@tool` reference.

{mycode_sdk-0.5.8 → mycode_sdk-0.7.0}/README.md

@@ -114,4 +114,32 @@ def summarize_file(ctx: ToolContext, path: str) -> str:
     return result.output.splitlines()[0] if result.output else ""
 ```
 
+## 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:
+
+```python
+from mycode import Agent, Hooks, ToolExecutionResult, bash_tool
+
+hooks = Hooks()
+
+
+@hooks.before_tool
+async def block_rm(ctx):
+    cmd = str(ctx.tool_input.get("command") or "")
+    if ctx.tool_name == "bash" and "rm -rf" in cmd:
+        return ToolExecutionResult(output="error: blocked", is_error=True)
+    return None
+
+
+agent = Agent(
+    model="claude-sonnet-4-6",
+    api_key="...",
+    tools=[bash_tool],
+    hooks=hooks,
+)
+```
+
+`@hooks.after_tool` runs after the tool and can replace the result (audit, redact, etc.).
+
 See [docs/sdk.md](../docs/sdk.md) for the event stream, cancellation, sessions, and the full `Agent` / `@tool` reference.

{mycode_sdk-0.5.8 → mycode_sdk-0.7.0}/pyproject.toml

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

{mycode_sdk-0.5.8 → mycode_sdk-0.7.0}/src/mycode/__init__.py

@@ -10,6 +10,7 @@ silently exposing file system and shell access.
 from importlib import metadata
 
 from mycode.agent import Agent, Event, PersistCallback, RunResult
+from mycode.hooks import AfterToolHook, BeforeToolHook, HookResult, Hooks, ToolHookContext
 from mycode.messages import (
     ContentBlock,
     ConversationMessage,
@@ -49,12 +50,17 @@ __all__ = [
     "ConversationMessage",
     "DEFAULT_TOOL_SPECS",
     "Event",
+    "AfterToolHook",
+    "BeforeToolHook",
+    "HookResult",
+    "Hooks",
     "PersistCallback",
     "RunResult",
     "SessionStore",
     "ToolContext",
     "ToolExecutionResult",
     "ToolExecutor",
+    "ToolHookContext",
     "ToolSpec",
     "__version__",
     "assistant_message",

{mycode_sdk-0.5.8 → mycode_sdk-0.7.0}/src/mycode/agent.py

@@ -17,6 +17,7 @@ from pathlib import Path
 from typing import Any, cast
 from uuid import uuid4
 
+from mycode.hooks import Hooks, ToolHookContext
 from mycode.messages import (
     ConversationMessage,
     build_message,
@@ -83,6 +84,7 @@ class Agent:
         supports_pdf_input: bool | None = None,
         system: str = "",
         tools: Sequence[ToolSpec] = (),
+        hooks: Hooks | None = None,
     ):
         self.model = model
         if provider is None:
@@ -109,6 +111,7 @@ class Agent:
         self.reasoning_effort = reasoning_effort
 
         self.system = system
+        self.hooks = hooks or Hooks()
         self._cancel_event = asyncio.Event()
         self._provider_event_task: asyncio.Future[ProviderStreamEvent] | None = None
 
@@ -210,6 +213,8 @@ class Agent:
         raw_args = tool_use.get("input")
         args = raw_args if isinstance(raw_args, dict) else {}
 
+        # Surface the tool to the UI before running hooks so the call is
+        # always visible — even when a hook is awaiting a permission decision.
         yield Event("tool_start", {"tool_call": {"id": tool_id, "name": name, "input": args}})
 
         if self._cancel_event.is_set():
@@ -227,8 +232,38 @@ class Agent:
             )
             return
 
+        hook_ctx = ToolHookContext(
+            session_id=self.session_id,
+            cwd=self.cwd,
+            provider=self.provider,
+            model=self.model,
+            tool_call_id=tool_id,
+            tool_name=name,
+            tool_input=args,
+            tool=spec,
+        )
+        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),
+            )
+            return
+
+        if result is not None:
+            yield await self._finish_tool_call(tool_id, hook_ctx, result)
+            return
+
+        if self._cancel_event.is_set():
+            yield self._tool_done_event(
+                tool_id,
+                ToolExecutionResult(output="error: cancelled", is_error=True),
+            )
+            return
+
         if spec.streams_output:
-            async for event in self._run_streaming_tool(tool_id=tool_id, name=name, args=args):
+            async for event in self._run_streaming_tool(tool_id=tool_id, name=name, args=args, hook_ctx=hook_ctx):
                 yield event
             return
 
@@ -238,7 +273,7 @@ class Agent:
         except Exception as exc:  # pragma: no cover - defensive
             result = ToolExecutionResult(output=f"error: {exc}", is_error=True)
 
-        yield self._tool_done_event(tool_id, result)
+        yield await self._finish_tool_call(tool_id, hook_ctx, result)
 
     async def _run_streaming_tool(
         self,
@@ -246,6 +281,7 @@ class Agent:
         tool_id: str,
         name: str,
         args: dict[str, Any],
+        hook_ctx: ToolHookContext,
     ) -> AsyncIterator[Event]:
         """Run one streaming tool, forwarding ``tool_output`` events live."""
 
@@ -289,13 +325,31 @@ class Agent:
             except Exception:
                 pass
             result = ToolExecutionResult(output="error: cancelled", is_error=True)
+            yield self._tool_done_event(tool_id, result)
+            return
         else:
             try:
                 result = await task
             except Exception as exc:  # pragma: no cover - defensive
                 result = ToolExecutionResult(output=f"error: {exc}", is_error=True)
 
-        yield self._tool_done_event(tool_id, result)
+        yield await self._finish_tool_call(tool_id, hook_ctx, result)
+
+    async def _finish_tool_call(
+        self,
+        tool_id: str,
+        hook_ctx: ToolHookContext,
+        result: ToolExecutionResult,
+    ) -> Event:
+        try:
+            result = await self.hooks.run_after_tool(hook_ctx, result)
+        except Exception:
+            logger.exception(
+                "after_tool hook failed for %s (call %s)",
+                hook_ctx.tool_name,
+                hook_ctx.tool_call_id,
+            )
+        return self._tool_done_event(tool_id, result)
 
     def _ctx_for_call(
         self,
@@ -530,7 +584,7 @@ class Agent:
                         )
                     )
 
-                    if output == "error: cancelled" and self._cancel_event.is_set():
+                    if self._cancel_event.is_set():
                         tool_result_message = build_message("user", tool_results)
                         self.messages.append(tool_result_message)
                         await persist(tool_result_message)

mycode_sdk-0.7.0/src/mycode/hooks.py

@@ -0,0 +1,97 @@
+"""Tool execution hooks for the agent runtime."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Awaitable, Callable, Mapping, Sequence
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Any
+
+from mycode.tools import ToolExecutionResult, ToolSpec
+
+type HookResult = ToolExecutionResult | None
+type BeforeToolHook = Callable[["ToolHookContext"], HookResult | Awaitable[HookResult]]
+type AfterToolHook = Callable[["ToolHookContext", ToolExecutionResult], HookResult | Awaitable[HookResult]]
+
+
+@dataclass(frozen=True)
+class ToolHookContext:
+    """Read-only context passed to tool execution hooks."""
+
+    session_id: str
+    cwd: str
+    provider: str
+    model: str
+    tool_call_id: str
+    tool_name: str
+    tool_input: Mapping[str, Any]
+    tool: ToolSpec
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "tool_input", _freeze(self.tool_input))
+
+
+class Hooks:
+    """Ordered callbacks around model-requested tool execution."""
+
+    def __init__(
+        self,
+        *,
+        before_tool: Sequence[BeforeToolHook] = (),
+        after_tool: Sequence[AfterToolHook] = (),
+    ) -> None:
+        self._before_tool = list(before_tool)
+        self._after_tool = list(after_tool)
+
+    def before_tool(self, hook: BeforeToolHook) -> BeforeToolHook:
+        """Register a hook that can return a tool result before execution."""
+
+        self._before_tool.append(hook)
+        return hook
+
+    def after_tool(self, hook: AfterToolHook) -> AfterToolHook:
+        """Register a hook that can observe or replace a tool result."""
+
+        self._after_tool.append(hook)
+        return hook
+
+    async def run_before_tool(self, ctx: ToolHookContext) -> ToolExecutionResult | None:
+        for hook in self._before_tool:
+            result = await _resolve(hook(ctx))
+            if result is not None:
+                return result
+        return None
+
+    async def run_after_tool(self, ctx: ToolHookContext, result: ToolExecutionResult) -> ToolExecutionResult:
+        for hook in self._after_tool:
+            replacement = await _resolve(hook(ctx, result))
+            if replacement is not None:
+                result = replacement
+        return result
+
+
+async def _resolve(value: object) -> HookResult:
+    if inspect.isawaitable(value):
+        value = await value
+    if value is None or isinstance(value, ToolExecutionResult):
+        return value
+    raise TypeError(f"tool hook returned unsupported value: {type(value).__name__}")
+
+
+def _freeze(value: Any) -> Any:
+    """Recursively wrap mappings in MappingProxyType and lists/tuples in tuples."""
+    if isinstance(value, Mapping):
+        return MappingProxyType({str(k): _freeze(v) for k, v in value.items()})
+    if isinstance(value, (list, tuple)):
+        return tuple(_freeze(item) for item in value)
+    return value
+
+
+__all__ = [
+    "AfterToolHook",
+    "BeforeToolHook",
+    "HookResult",
+    "Hooks",
+    "ToolHookContext",
+]

{mycode_sdk-0.5.8 → mycode_sdk-0.7.0}/src/mycode/models_catalog.json

@@ -177,6 +177,13 @@
       "supports_pdf_input": false,
       "supports_reasoning": true
     },
+    "deepseek-v4-flash": {
+      "context_window": 1000000,
+      "max_output_tokens": 384000,
+      "supports_image_input": false,
+      "supports_pdf_input": false,
+      "supports_reasoning": true
+    },
     "deepseek-v4-pro": {
       "context_window": 1000000,
       "max_output_tokens": 384000,

{mycode_sdk-0.5.8 → mycode_sdk-0.7.0}/src/mycode/session.py

@@ -18,7 +18,7 @@ from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any, TypedDict, cast
 
-from mycode.messages import ConversationMessage, build_message, flatten_message_text, text_block, tool_result_block
+from mycode.messages import ConversationMessage, build_message, flatten_message_text, text_block
 
 # ---------------------------------------------------------------------
 # Session format and compacting defaults
@@ -315,10 +315,10 @@ class SessionStore:
         # Replay order defines the visible conversation state.
         # 1) compact rewrites older history into one summary view
         # 2) rewind truncates that visible list by message index
-        # 3) interrupted tool repair patches the final visible state
+        # Orphan tool_use blocks (e.g. left open by a server crash) are
+        # closed by the provider adapter at replay time, not here.
         visible_messages = apply_compact(raw_messages)
         visible_messages = apply_rewind(visible_messages)
-        self._repair_interrupted_tool_loop(session_id, meta, visible_messages)
 
         return {"session": self._summary(session_id, meta), "messages": visible_messages}
 
@@ -387,94 +387,3 @@ class SessionStore:
         """Return meta augmented with the session id for API responses."""
 
         return {"id": session_id, **meta}
-
-    # ---------------------------------------------------------------------
-    # Interrupted tool repair
-    # ---------------------------------------------------------------------
-
-    def _repair_interrupted_tool_loop(
-        self,
-        session_id: str,
-        meta: SessionMetaDict,
-        messages: list[ConversationMessage],
-    ) -> None:
-        """Append a synthetic tool result when the latest tool loop was interrupted.
-
-        The runtime persists sessions as append-only JSONL. If a previous run was
-        interrupted after an assistant emitted `tool_use` blocks but before a
-        matching `tool_result` user message was written, repair the session by
-        appending one synthetic error result message. ``meta`` is mutated in
-        place so the caller's view stays consistent with the updated file.
-        """
-
-        pending_tool_use_ids: list[str] = []
-        pending_tool_call_index: int | None = None
-
-        # Find the latest assistant message that started a tool loop.
-        for index in range(len(messages) - 1, -1, -1):
-            message = messages[index]
-            if message.get("role") != "assistant":
-                continue
-
-            blocks = message.get("content")
-            if not isinstance(blocks, list):
-                continue
-
-            tool_use_ids = [
-                str(block.get("id") or "")
-                for block in blocks
-                if isinstance(block, dict) and block.get("type") == "tool_use" and block.get("id")
-            ]
-            if not tool_use_ids:
-                continue
-
-            pending_tool_use_ids = tool_use_ids
-            pending_tool_call_index = index
-            break
-
-        if pending_tool_call_index is None:
-            return
-
-        # Collect tool results that were recorded after the assistant message.
-        completed_tool_use_ids: set[str] = set()
-        for message in messages[pending_tool_call_index + 1 :]:
-            if message.get("role") != "user":
-                continue
-
-            blocks = message.get("content")
-            if not isinstance(blocks, list):
-                continue
-
-            for block in blocks:
-                if not isinstance(block, dict) or block.get("type") != "tool_result":
-                    continue
-                tool_use_id = str(block.get("tool_use_id") or "")
-                if tool_use_id:
-                    completed_tool_use_ids.add(tool_use_id)
-
-        missing_tool_use_ids = [
-            tool_use_id for tool_use_id in pending_tool_use_ids if tool_use_id not in completed_tool_use_ids
-        ]
-        if not missing_tool_use_ids:
-            return
-
-        repair_message = build_message(
-            "user",
-            [
-                tool_result_block(
-                    tool_use_id=tool_use_id,
-                    output="error: tool call was interrupted",
-                    is_error=True,
-                )
-                for tool_use_id in missing_tool_use_ids
-            ],
-        )
-
-        with self.messages_path(session_id).open("a", encoding="utf-8") as handle:
-            handle.write(json.dumps(repair_message, ensure_ascii=False))
-            handle.write("\n")
-
-        meta["updated_at"] = _now()
-        self._write_meta(session_id, meta)
-
-        messages.append(repair_message)