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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-sdk
-Version: 0.9.4
+Version: 0.10.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
@@ -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.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
+Requires-Dist: anthropic>=0.116.0
+Requires-Dist: google-genai>=2.11.0
+Requires-Dist: griffelib>=2.1.0
+Requires-Dist: openai>=2.45.0
+Requires-Dist: pydantic>=2.13.4
 Description-Content-Type: text/markdown
 
 # mycode-sdk

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

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling>=1.31.0"]
 build-backend = "hatchling.build"
 
 [project]
 name = "mycode-sdk"
-version = "0.9.4"
+version = "0.10.0"
 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.106.0",
-    "google-genai>=2.8.0",
-    "griffelib>=2.0.0",
-    "openai>=2.41.0",
-    "pydantic>=2.13.0",
+    "anthropic>=0.116.0",
+    "google-genai>=2.11.0",
+    "griffelib>=2.1.0",
+    "openai>=2.45.0",
+    "pydantic>=2.13.4",
 ]
 
 [project.urls]

{mycode_sdk-0.9.4 → mycode_sdk-0.10.0}/src/mycode/__init__.py

@@ -4,6 +4,7 @@ from importlib import metadata
 
 from mycode.agent import Agent, Event, PersistCallback, RunResult
 from mycode.attachments import Attachment
+from mycode.compact import NothingToCompactError
 from mycode.hooks import AfterToolHook, BeforeToolHook, HookResult, Hooks, ToolHookContext
 from mycode.messages import (
     ContentBlock,
@@ -45,6 +46,7 @@ __all__ = [
     "BeforeToolHook",
     "HookResult",
     "Hooks",
+    "NothingToCompactError",
     "PersistCallback",
     "RunResult",
     "SessionStore",

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

@@ -23,7 +23,9 @@ from mycode.attachments import AttachmentLike, build_attachment_blocks
 from mycode.compact import (
     COMPACT_SUMMARY_PROMPT,
     DEFAULT_COMPACT_THRESHOLD,
+    NothingToCompactError,
     build_compact_event,
+    has_compactable_history,
     should_compact,
 )
 from mycode.hooks import Hooks, ToolHookContext
@@ -152,16 +154,10 @@ class Agent:
         # (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:
-            tool_output_dir = session_dir / self.session_id / "tool-output"
+            self.tool_output_dir = session_dir / self.session_id / "tool-output"
         else:
-            tool_output_dir = Path(tempfile.gettempdir()) / "mycode" / self.session_id / "tool-output"
+            self.tool_output_dir = Path(tempfile.gettempdir()) / "mycode" / self.session_id / "tool-output"
         self.tools = ToolExecutor(tools)
-        self.tool_ctx = ToolContext(
-            executor=self.tools,
-            cwd=self.cwd,
-            tool_output_dir=tool_output_dir,
-            supports_image_input=False,
-        )
 
         self.refresh_capabilities(
             max_tokens=max_tokens,
@@ -201,7 +197,6 @@ class Agent:
         self.supports_reasoning: bool | None = meta.supports_reasoning
         self.supports_image_input: bool = bool(meta.supports_image_input)
         self.supports_pdf_input: bool = bool(meta.supports_pdf_input)
-        self.tool_ctx.supports_image_input = self.supports_image_input
 
     def cancel(self) -> None:
         """Request cancellation of the in-flight turn."""
@@ -330,11 +325,11 @@ class Agent:
             output = "\n".join([*output_parts, "error: cancelled"]) if output_parts else "error: cancelled"
             yield self._error_done(tool_id, output)
             return
-        else:
-            try:
-                result = await task
-            except Exception as exc:  # pragma: no cover - defensive
-                result = ToolExecutionResult(output=f"error: {exc}", is_error=True)
+
+        try:
+            result = await task
+        except Exception as exc:  # pragma: no cover - defensive
+            result = ToolExecutionResult(output=f"error: {exc}", is_error=True)
 
         yield await self._finish_tool_call(tool_id, hook_ctx, result)
 
@@ -360,13 +355,11 @@ class Agent:
         *,
         emit: Callable[[str], None] | None = None,
     ) -> ToolContext:
-        """Build a per-call ToolContext from the base context."""
-
         return ToolContext(
             executor=self.tools,
-            cwd=self.tool_ctx.cwd,
-            tool_output_dir=self.tool_ctx.tool_output_dir,
-            supports_image_input=self.tool_ctx.supports_image_input,
+            cwd=self.cwd,
+            tool_output_dir=self.tool_output_dir,
+            supports_image_input=self.supports_image_input,
             tool_call_id=tool_id,
             emit=emit,
         )
@@ -402,15 +395,12 @@ class Agent:
 
         provider_stream: AsyncIterator[ProviderStreamEvent] = adapter.stream_turn(request)
 
-        async def next_provider_event() -> ProviderStreamEvent:
-            return await anext(provider_stream)
-
         try:
             while True:
                 if self._cancel_event.is_set():
                     raise asyncio.CancelledError
 
-                self._provider_event_task = asyncio.create_task(next_provider_event())
+                self._provider_event_task = asyncio.ensure_future(anext(provider_stream))
                 try:
                     yield await self._provider_event_task
                 except StopAsyncIteration:
@@ -467,6 +457,23 @@ class Agent:
             block["meta"] = {**meta, "duration_ms": duration_ms}
             return
 
+    async def _persist_message(
+        self,
+        message: ConversationMessage,
+        on_persist: PersistCallback | None,
+    ) -> None:
+        """Persist one message: caller callback first, then the SDK session store."""
+
+        if on_persist is not None:
+            # Callers may need to write related records before the SDK
+            # appends this message to its own session log.
+            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)
+
     # ------------------------------------------------------------------
     # Public entry points
     # ------------------------------------------------------------------
@@ -481,15 +488,7 @@ class Agent:
         """Run the full agent loop for one user message."""
 
         async def persist(message: ConversationMessage) -> None:
-            if on_persist is not None:
-                # Callers may need to write related records before the SDK
-                # appends this message to its own session log.
-                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)
+            await self._persist_message(message, on_persist)
 
         self._cancel_event.clear()
 
@@ -529,7 +528,10 @@ class Agent:
         adapter = get_provider_adapter(self.provider)
 
         turn_number = 0
-        while self.max_turns is None or turn_number < self.max_turns:
+        while True:
+            if self.max_turns is not None and turn_number >= self.max_turns:
+                yield Event("error", {"message": "max_turns reached"})
+                return
             turn_number += 1
             if self._cancel_event.is_set():
                 yield Event("error", {"message": "cancelled"})
@@ -632,13 +634,15 @@ class Agent:
 
             total_tokens = meta.get("total_tokens")
             if total_tokens:
-                payload: dict[str, Any] = {
-                    "total_tokens": total_tokens,
-                    "model": meta.get("model") or self.model,
-                    "provider": meta.get("provider") or self.provider,
-                    "context_window": meta["context_window"],
-                }
-                yield Event("usage", payload)
+                yield Event(
+                    "usage",
+                    {
+                        "total_tokens": total_tokens,
+                        "model": meta.get("model") or self.model,
+                        "provider": meta.get("provider") or self.provider,
+                        "context_window": meta["context_window"],
+                    },
+                )
 
             tool_calls = [
                 block
@@ -665,11 +669,10 @@ class Agent:
                             )
                         )
 
-                        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)
-                            return
+                    if self._cancel_event.is_set():
+                        # Skip remaining tool calls; the results collected so
+                        # far are still persisted below.
+                        break
 
                 tool_result_message = build_message("user", tool_results)
                 self.messages.append(tool_result_message)
@@ -679,7 +682,7 @@ class Agent:
                 return
             if should_compact(total_tokens, self.context_window, self.compact_threshold):
                 try:
-                    await self._compact(adapter, persist)
+                    await self._compact(adapter, on_persist)
                     yield Event("compact", {})
                 except asyncio.CancelledError:
                     yield Event("error", {"message": "cancelled"})
@@ -693,11 +696,7 @@ class Agent:
                     )
 
             if not tool_calls:
-                break
-
-        else:
-            yield Event("error", {"message": "max_turns reached"})
-            return
+                return
 
     def run(
         self,
@@ -731,12 +730,47 @@ class Agent:
     # Context compaction
     # ------------------------------------------------------------------
 
+    async def acompact(
+        self,
+        *,
+        on_persist: PersistCallback | None = None,
+    ) -> ConversationMessage:
+        """Compact the conversation now and return the persisted compact marker.
+
+        Raises :class:`NothingToCompactError` when no new context follows the
+        latest compact marker, and :class:`asyncio.CancelledError` when
+        :meth:`cancel` stops the summary request.
+        """
+
+        self._cancel_event.clear()
+        adapter = get_provider_adapter(self.provider)
+        return await self._compact(adapter, on_persist)
+
+    def compact(
+        self,
+        *,
+        on_persist: PersistCallback | None = None,
+    ) -> ConversationMessage:
+        """Compact the conversation synchronously; see :meth:`acompact`."""
+
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            pass
+        else:
+            raise RuntimeError("Agent.compact() cannot run inside an active event loop; use Agent.acompact() instead")
+
+        return asyncio.run(self.acompact(on_persist=on_persist))
+
     async def _compact(
         self,
         adapter: ProviderAdapter,
-        persist: PersistCallback,
-    ) -> None:
-        """Ask the provider for a summary, persist the compact event, append it."""
+        on_persist: PersistCallback | None,
+    ) -> ConversationMessage:
+        """Ask the provider for a summary, persist and append the compact marker."""
+
+        if not has_compactable_history(self.messages):
+            raise NothingToCompactError("nothing to compact")
 
         request = self._build_request(
             tools=[],
@@ -758,6 +792,9 @@ class Agent:
         if not summary_text:
             raise ValueError("compaction produced empty summary")
 
+        if self._cancel_event.is_set():
+            raise asyncio.CancelledError
+
         summary_total_tokens = (summary_message.get("meta") or {}).get("total_tokens")
         compact_event = build_compact_event(
             summary_text,
@@ -766,5 +803,6 @@ class Agent:
             total_tokens=summary_total_tokens,
         )
 
-        await persist(compact_event)
+        await self._persist_message(compact_event, on_persist)
         self.messages.append(compact_event)
+        return compact_event

{mycode_sdk-0.9.4 → mycode_sdk-0.10.0}/src/mycode/compact.py

@@ -8,6 +8,11 @@ from mycode.messages import ConversationMessage, build_message, text_block
 
 DEFAULT_COMPACT_THRESHOLD = 0.8
 
+
+class NothingToCompactError(ValueError):
+    """Raised when there is no new context to compact past the latest marker."""
+
+
 COMPACT_SUMMARY_PROMPT = """\
 Summarize this conversation to create a continuation document. \
 This summary will replace the full conversation history, so it must \
@@ -65,6 +70,20 @@ def should_compact(
     return last_total_tokens >= context_window * threshold
 
 
+def has_compactable_history(messages: list[ConversationMessage]) -> bool:
+    """True when at least one non-empty user/assistant message follows the latest compact marker."""
+
+    last_compact = -1
+    for i, message in enumerate(messages):
+        if message.get("role") == "compact":
+            last_compact = i
+
+    return any(
+        message.get("role") in ("user", "assistant") and message.get("content")
+        for message in messages[last_compact + 1 :]
+    )
+
+
 def build_compact_event(
     summary_text: str,
     *,

{mycode_sdk-0.9.4 → mycode_sdk-0.10.0}/src/mycode/messages.py

@@ -165,8 +165,8 @@ def flatten_message_text(message: ConversationMessage, *, include_thinking: bool
             continue
         raw_meta = block.get("meta")
         meta = raw_meta if isinstance(raw_meta, dict) else {}
-        # Attached file snapshots should not become session titles or history labels.
-        if meta.get("attachment"):
+        # Local payload blocks should not become session titles or history labels.
+        if meta.get("attachment") or meta.get("skill_snapshot"):
             continue
         btype = block.get("type")
         if btype == "text" or (include_thinking and btype == "thinking"):

{mycode_sdk-0.9.4 → mycode_sdk-0.10.0}/src/mycode/models.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-import functools
 import json
 from dataclasses import dataclass, replace
+from functools import cache
 from pathlib import Path
 from typing import Any
 
@@ -30,14 +30,14 @@ class ModelMetadata:
     supports_pdf_input: bool | None = None
 
 
-@functools.cache
+@cache
 def load_models_catalog() -> dict[str, Any] | None:
     """Load the bundled model catalog from disk once per process."""
 
     try:
         data = json.loads(_MODELS_CATALOG_PATH.read_text(encoding="utf-8"))
-    except Exception:
-        data = None
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return None
     return data if isinstance(data, dict) else None
 
 
@@ -66,16 +66,26 @@ def resolve_model_metadata(
     *,
     provider: str,
     model: str,
-    **overrides: Any,
+    context_window: int | None = None,
+    max_output_tokens: int | None = None,
+    supports_reasoning: bool | None = None,
+    supports_image_input: bool | None = None,
+    supports_pdf_input: bool | None = None,
 ) -> ModelMetadata:
     """Return catalog metadata for ``(provider, model)`` with non-None overrides layered on top.
 
-    Override keys must match :class:`ModelMetadata` fields. Missing overrides
-    and an absent catalog entry both leave the corresponding fields at ``None``
-    so callers can apply their own fallback defaults.
+    Missing overrides and an absent catalog entry both leave the corresponding
+    fields at ``None`` so callers can apply their own fallback defaults.
     """
 
     base = lookup_model_metadata(provider_type=provider, model=model) or ModelMetadata(provider=provider, model=model)
+    overrides = {
+        "context_window": context_window,
+        "max_output_tokens": max_output_tokens,
+        "supports_reasoning": supports_reasoning,
+        "supports_image_input": supports_image_input,
+        "supports_pdf_input": supports_pdf_input,
+    }
     return replace(base, **{k: v for k, v in overrides.items() if v is not None})