mycode-sdk 0.13.0__tar.gz → 0.13.2__tar.gz

{mycode_sdk-0.13.0 → mycode_sdk-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mycode-sdk
-Version: 0.13.0
+Version: 0.13.2
 Summary: Lightweight Python SDK for building AI agents.
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode

{mycode_sdk-0.13.0 → mycode_sdk-0.13.2}/pyproject.toml

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

{mycode_sdk-0.13.0 → mycode_sdk-0.13.2}/src/mycode/agent.py

@@ -9,9 +9,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import os
 import random
-import tempfile
 import threading
 import time
 from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
@@ -204,7 +202,6 @@ class Agent:
         self,
         *,
         model: str,
-        cwd: str | None = None,
         provider: str | None = None,
         session_dir: Path | None = None,
         session_id: str | None = None,
@@ -227,6 +224,7 @@ class Agent:
         system: str = "",
         tools: Sequence[ToolSpec] = (),
         hooks: Hooks | None = None,
+        deps: object | None = None,
     ):
         self.model = model
         if provider is None:
@@ -236,8 +234,9 @@ class Agent:
             provider = inferred
         self.provider = provider
 
-        resolved_cwd = cwd if cwd is not None else os.getcwd()
-        self.cwd = str(Path(resolved_cwd).resolve(strict=False))
+        # Opaque application context handed to every tool and hook; the SDK
+        # never reads it.
+        self.deps = deps
 
         # Persistence is opt-in: a store is only created when ``session_dir``
         # is supplied. ``session_id`` is always populated (uuid when absent)
@@ -286,11 +285,7 @@ class Agent:
         # - messages is None → auto-resume from disk if the session exists
         # - messages is [] or [...] → use as-is; refuse if it would overwrite disk
         if messages is None:
-            if self._store is not None:
-                data = self._store.load_session_sync(self.session_id)
-                messages = list(data["messages"]) if data is not None else []
-            else:
-                messages = []
+            messages = self._store.load_messages_sync(self.session_id) if self._store is not None else []
         elif self._store is not None and self._store.session_exists(self.session_id):
             msg = (
                 f"session {self.session_id!r} already exists on disk; "
@@ -299,13 +294,6 @@ class Agent:
             raise ValueError(msg)
         self.messages: list[ConversationMessage] = list(messages)
 
-        # ``tool_output_dir`` defaults to a session-adjacent directory so logs
-        # (e.g. bash spill files) live next to the session JSONL; without a
-        # session, fall back to a tempdir scoped to ``session_id``.
-        if session_dir is not None:
-            self.tool_output_dir = session_dir / self.session_id / "tool-output"
-        else:
-            self.tool_output_dir = Path(tempfile.gettempdir()) / "mycode" / self.session_id / "tool-output"
         self.tools = ToolExecutor(tools)
 
         self.refresh_capabilities(
@@ -382,7 +370,7 @@ class Agent:
         self,
         spec: ToolSpec,
         args: dict[str, Any],
-        ctx: ToolContext,
+        ctx: ToolContext[Any],
     ) -> ToolExecutionResult:
         return await self.tools.aexecute(spec.name, args, ctx)
 
@@ -430,8 +418,7 @@ class Agent:
 
         hook_ctx = ToolHookContext(
             session_id=self.session_id,
-            cwd=self.cwd,
-            tool_output_dir=self.tool_output_dir,
+            deps=self.deps,
             provider=self.provider,
             model=self.model,
             tool_call_id=tool_id,
@@ -488,7 +475,7 @@ class Agent:
         tool_id: str,
         spec: ToolSpec,
         args: dict[str, Any],
-        hook_ctx: ToolHookContext,
+        hook_ctx: ToolHookContext[Any],
     ) -> AsyncIterator[Event]:
         """Run one streaming tool, forwarding ``tool_output`` events live."""
 
@@ -545,7 +532,7 @@ class Agent:
     async def _finish_tool_call(
         self,
         tool_id: str,
-        hook_ctx: ToolHookContext,
+        hook_ctx: ToolHookContext[Any],
         result: ToolExecutionResult,
     ) -> Event:
         try:
@@ -563,11 +550,10 @@ class Agent:
         tool_id: str,
         *,
         emit: Callable[[str], None] | None = None,
-    ) -> ToolContext:
+    ) -> ToolContext[Any]:
         return ToolContext(
             executor=self.tools,
-            cwd=self.cwd,
-            tool_output_dir=self.tool_output_dir,
+            deps=self.deps,
             supports_image_input=self.supports_image_input,
             tool_call_id=tool_id,
             emit=emit,
@@ -811,8 +797,6 @@ class Agent:
             await on_persist(message)
         if self._store is None:
             return
-        if not self._store.session_exists(self.session_id):
-            await self._store.create_session(self.session_id, cwd=self.cwd)
         await self._store.append_message(self.session_id, message)
 
     # ------------------------------------------------------------------
@@ -850,7 +834,7 @@ class Agent:
                 user_message["meta"] = {str(k): v for k, v in raw_meta.items()}
 
         if attachments:
-            blocks = await asyncio.to_thread(build_attachment_blocks, attachments, cwd=self.cwd)
+            blocks = await asyncio.to_thread(build_attachment_blocks, attachments)
             user_message["content"] = list(user_message.get("content") or []) + blocks
 
         content_blocks = user_message.get("content") or []

{mycode_sdk-0.13.0 → mycode_sdk-0.13.2}/src/mycode/attachments.py

@@ -16,7 +16,6 @@ from pathlib import Path
 from typing import Self
 
 from mycode.messages import ContentBlock, document_block, image_block, text_block
-from mycode.utils import resolve_path
 
 SUPPORTED_IMAGE_MIME_TYPES = frozenset({"image/png", "image/jpeg", "image/gif", "image/webp"})
 SUPPORTED_DOCUMENT_MIME_TYPES = frozenset({"application/pdf"})
@@ -60,16 +59,14 @@ class Attachment:
 AttachmentLike = str | Path | Attachment
 
 
-def build_attachment_blocks(
-    attachments: Sequence[AttachmentLike],
-    *,
-    cwd: str,
-) -> list[ContentBlock]:
+def build_attachment_blocks(attachments: Sequence[AttachmentLike]) -> list[ContentBlock]:
     """Return one content block per attachment, in input order.
 
-    ``str`` / ``Path`` items are treated as ``Attachment.path``. Raises
-    ``ValueError`` on a missing path, a directory, a binary file that is
-    neither image nor PDF, undecodable text, or an unsupported ``media_type``.
+    ``str`` / ``Path`` items are treated as ``Attachment.path``; ``~`` is
+    expanded and relative paths resolve against the process working
+    directory, like any other file API. Raises ``ValueError`` on a missing
+    path, a directory, a binary file that is neither image nor PDF,
+    undecodable text, or an unsupported ``media_type``.
     """
 
     blocks: list[ContentBlock] = []
@@ -86,7 +83,7 @@ def build_attachment_blocks(
                     supported = sorted(SUPPORTED_IMAGE_MIME_TYPES | SUPPORTED_DOCUMENT_MIME_TYPES)
                     raise ValueError(f"unsupported media_type {media_type!r}; want one of {supported}")
             case Path() as raw:
-                path = resolve_path(raw, cwd=cwd)
+                path = raw.expanduser()
                 if not path.exists():
                     raise ValueError(f"attachment not found: {raw}")
                 if path.is_dir():

{mycode_sdk-0.13.0 → mycode_sdk-0.13.2}/src/mycode/hooks.py

@@ -5,24 +5,27 @@ from __future__ import annotations
 import inspect
 from collections.abc import Awaitable, Callable, Mapping, Sequence
 from dataclasses import dataclass
-from pathlib import Path
 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]]
+type BeforeToolHook = Callable[["ToolHookContext[Any]"], HookResult | Awaitable[HookResult]]
+type AfterToolHook = Callable[["ToolHookContext[Any]", ToolExecutionResult], HookResult | Awaitable[HookResult]]
 
 
 @dataclass(frozen=True)
-class ToolHookContext:
-    """Read-only context passed to tool execution hooks."""
+class ToolHookContext[DepsT]:
+    """Read-only context passed to tool execution hooks.
+
+    ``deps`` is the same application context object handed to tools via
+    ``ToolContext.deps``; annotate hooks as ``ToolHookContext[MyDeps]`` for
+    typed access.
+    """
 
     session_id: str
-    cwd: str
-    tool_output_dir: Path
+    deps: DepsT
     provider: str
     model: str
     tool_call_id: str
@@ -58,14 +61,14 @@ class Hooks:
         self._after_tool.append(hook)
         return hook
 
-    async def run_before_tool(self, ctx: ToolHookContext) -> ToolExecutionResult | None:
+    async def run_before_tool(self, ctx: ToolHookContext[Any]) -> 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:
+    async def run_after_tool(self, ctx: ToolHookContext[Any], result: ToolExecutionResult) -> ToolExecutionResult:
         for hook in self._after_tool:
             replacement = await _resolve(hook(ctx, result))
             if replacement is not None:

{mycode_sdk-0.13.0 → mycode_sdk-0.13.2}/src/mycode/messages.py

@@ -19,8 +19,6 @@ from __future__ import annotations
 
 from typing import Any
 
-from mycode.utils import omit_none
-
 ContentBlock = dict[str, Any]
 ConversationMessage = dict[str, Any]
 
@@ -155,16 +153,15 @@ def build_usage(
 
     if total_tokens is None and input_tokens is not None and output_tokens is not None:
         total_tokens = input_tokens + output_tokens
-    return omit_none(
-        {
-            "total_tokens": total_tokens,
-            "input_tokens": input_tokens,
-            "cache_read_tokens": cache_read_tokens,
-            "cache_write_tokens": cache_write_tokens,
-            "output_tokens": output_tokens,
-            "reasoning_tokens": reasoning_tokens,
-        }
-    )
+    usage = {
+        "total_tokens": total_tokens,
+        "input_tokens": input_tokens,
+        "cache_read_tokens": cache_read_tokens,
+        "cache_write_tokens": cache_write_tokens,
+        "output_tokens": output_tokens,
+        "reasoning_tokens": reasoning_tokens,
+    }
+    return {key: value for key, value in usage.items() if value is not None}
 
 
 def assistant_message(
@@ -194,7 +191,7 @@ def assistant_message(
     if cost is not None:
         meta["cost"] = dict(cost)
     if native_meta:
-        native = omit_none(native_meta)
+        native = {key: value for key, value in native_meta.items() if value is not None}
         if native:
             meta["native"] = native
     return build_message("assistant", blocks, meta=meta or None)