mycode-sdk 0.7.6__tar.gz → 0.8.1__tar.gz

{mycode_sdk-0.7.6 → mycode_sdk-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-sdk
-Version: 0.7.6
+Version: 0.8.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

{mycode_sdk-0.7.6 → mycode_sdk-0.8.1}/pyproject.toml

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

{mycode_sdk-0.7.6 → mycode_sdk-0.8.1}/src/mycode/agent.py

@@ -18,6 +18,13 @@ from pathlib import Path
 from typing import Any, cast
 from uuid import uuid4
 
+from mycode.compact import (
+    COMPACT_SUMMARY_PROMPT,
+    DEFAULT_COMPACT_THRESHOLD,
+    apply_compact_replay,
+    build_compact_event,
+    should_compact,
+)
 from mycode.hooks import Hooks, ToolHookContext
 from mycode.messages import (
     ConversationMessage,
@@ -29,14 +36,7 @@ from mycode.messages import (
 from mycode.models import infer_provider_from_model, resolve_model_metadata
 from mycode.providers import get_provider_adapter
 from mycode.providers.base import ProviderAdapter, ProviderRequest, ProviderStreamEvent
-from mycode.session import (
-    COMPACT_SUMMARY_PROMPT,
-    DEFAULT_COMPACT_THRESHOLD,
-    SessionStore,
-    apply_compact,
-    build_compact_event,
-    should_compact,
-)
+from mycode.session import SessionStore
 from mycode.tools import ToolContext, ToolExecutionResult, ToolExecutor, ToolSpec
 
 logger = logging.getLogger(__name__)
@@ -104,6 +104,7 @@ class Agent:
         self.session_dir = session_dir
         self.session_id = (session_id or "").strip() or uuid4().hex
         self._store: SessionStore | None = SessionStore(data_dir=session_dir) if session_dir is not None else None
+        self.transcript_path: str | None = str(self._store.messages_path(self.session_id)) if self._store else None
 
         self.api_key = api_key
         self.api_base = api_base
@@ -451,32 +452,29 @@ class Agent:
             await self._store.append_message(self.session_id, message)
 
         self._cancel_event.clear()
-        supports_image_input = self.supports_image_input
-        supports_pdf_input = self.supports_pdf_input
-        self.tool_ctx.supports_image_input = supports_image_input
 
         if isinstance(user_input, str):
-            user_message = user_text_message(user_input)
+            user_message: ConversationMessage = user_text_message(user_input)
         else:
-            user_message: ConversationMessage = {
-                "role": str(user_input.get("role") or "user"),
+            if (user_input.get("role") or "user") != "user":
+                yield Event("error", {"message": "user input must be a user message"})
+                return
+            user_message = {
+                "role": "user",
                 "content": [dict(b) for b in user_input.get("content") or [] if isinstance(b, dict)],
             }
             raw_meta = user_input.get("meta")
             if isinstance(raw_meta, dict):
                 user_message["meta"] = {str(k): v for k, v in raw_meta.items()}
 
-        if user_message.get("role") != "user":
-            yield Event("error", {"message": "user input must be a user message"})
-            return
-
-        if not supports_image_input and any(
-            isinstance(block, dict) and block.get("type") == "image" for block in user_message.get("content") or []
+        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 supports_pdf_input and any(
-            isinstance(block, dict) and block.get("type") == "document" for block in user_message.get("content") or []
+        if not self.supports_pdf_input and any(
+            isinstance(block, dict) and block.get("type") == "document" for block in content_blocks
         ):
             yield Event("error", {"message": "current model does not support PDF input"})
             return
@@ -500,15 +498,15 @@ class Agent:
                 provider=self.provider,
                 model=self.model,
                 session_id=self.session_id,
-                messages=self.messages,
+                messages=apply_compact_replay(self.messages, transcript_path=self.transcript_path),
                 system=self.system,
                 tools=self.tools.definitions,
                 max_tokens=self.max_tokens,
                 api_key=self.api_key,
                 api_base=self.api_base,
                 reasoning_effort=self.reasoning_effort,
-                supports_image_input=supports_image_input,
-                supports_pdf_input=supports_pdf_input,
+                supports_image_input=self.supports_image_input,
+                supports_pdf_input=self.supports_pdf_input,
             )
 
             try:
@@ -631,11 +629,14 @@ class Agent:
                 return
             if should_compact(total_tokens, self.context_window, self.compact_threshold):
                 try:
-                    async for event in self._compact(adapter, persist, continue_now=bool(tool_calls)):
-                        yield event
+                    await self._compact(adapter, persist)
+                    yield Event("compact", {})
                 except asyncio.CancelledError:
-                    raise
+                    yield Event("error", {"message": "cancelled"})
+                    return
                 except Exception:
+                    # Best-effort: transient failures retry next threshold check;
+                    # persistent ones surface from phase 1 of the next turn.
                     logger.warning(
                         "Context compaction failed, continuing without compaction",
                         exc_info=True,
@@ -684,15 +685,12 @@ class Agent:
         self,
         adapter: ProviderAdapter,
         persist: PersistCallback,
-        *,
-        continue_now: bool,
-    ) -> AsyncIterator[Event]:
-        """Generate a conversation summary and replace in-memory messages."""
-
-        compacted_count = len(self.messages)
+    ) -> None:
+        """Ask the provider for a summary, persist the compact event, append it."""
 
-        # Ask the same provider for a summary — no tools, just text generation.
-        compact_messages = list(self.messages) + [user_text_message(COMPACT_SUMMARY_PROMPT)]
+        compact_messages = apply_compact_replay(self.messages, transcript_path=self.transcript_path) + [
+            user_text_message(COMPACT_SUMMARY_PROMPT)
+        ]
         request = ProviderRequest(
             provider=self.provider,
             model=self.model,
@@ -726,24 +724,8 @@ class Agent:
             summary_text,
             provider=self.provider,
             model=self.model,
-            compacted_count=compacted_count,
             total_tokens=summary_total_tokens,
         )
 
-        # Persist the compact event (append-only — original messages stay in JSONL).
         await persist(compact_event)
-
         self.messages.append(compact_event)
-        self.messages = apply_compact(
-            self.messages,
-            transcript_path=str(self._store.messages_path(self.session_id)) if self._store else None,
-            continue_now=continue_now,
-        )
-
-        yield Event(
-            "compact",
-            {
-                "message": f"Context compacted ({compacted_count} messages → summary)",
-                "compacted_count": compacted_count,
-            },
-        )

mycode_sdk-0.8.1/src/mycode/compact.py

@@ -0,0 +1,120 @@
+"""Context compaction: summarize past history when nearing the context window."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mycode.messages import ConversationMessage, build_message, text_block
+
+DEFAULT_COMPACT_THRESHOLD = 0.8
+
+COMPACT_SUMMARY_PROMPT = """\
+Summarize this conversation to create a continuation document. \
+This summary will replace the full conversation history, so it must \
+capture everything needed to continue the work seamlessly.
+
+Include:
+
+1. **Task and Intent**: Describe the user's overall goal — what is being \
+built, fixed, or investigated, and why.
+2. **Decisions and Constraints**: List the decisions made, constraints \
+discovered, and approaches chosen or rejected, with the reasoning behind \
+each.
+3. **User Requests**: Every distinct request or instruction the user gave, \
+in chronological order. Preserve the user's original wording for ambiguous \
+or nuanced requests.
+4. **Files and Changes**: Enumerate every file read, modified, or created \
+— paths, what changed, and any code snippets the next turn will need to \
+reason about, quoted verbatim.
+5. **Errors and Fixes**: List errors encountered with the original message \
+verbatim, the cause if known, and the resolution — or that it remains open.
+6. **Current State**: What is verified working, what is known broken, what \
+is in progress.
+7. **Next Step**: The next step to take, with a direct quote from the most \
+recent conversation showing where the work left off.
+
+Rules:
+- Be specific: reproduce file paths, function names, error messages, and \
+other identifiers verbatim — never paraphrase them.
+- Do not add suggestions or opinions — only summarize what happened.
+- Keep it concise but complete.\
+"""
+
+CONTINUATION_HEADER = "This session is being continued from a previous conversation that was compacted to fit the context window. The summary below covers the earlier portion of the conversation."
+
+TRANSCRIPT_HINT = "For verbatim details not captured in this summary (exact code snippets, error messages, or earlier output), read the original conversation log at: {path}"
+
+CONTINUATION_FOOTER = 'Resume directly from where the work left off. Do not acknowledge this summary, do not recap, and do not preface with "I\'ll continue" or similar.'
+
+COMPACT_ACK = "Acknowledged."
+
+
+def should_compact(
+    last_total_tokens: int | None,
+    context_window: int | None,
+    threshold: float,
+) -> bool:
+    """True when ``last_total_tokens`` ≥ ``context_window × threshold``.
+
+    The ``(1 - threshold)`` headroom is reserved for the compact LLM call
+    itself (see docs/sessions.md).
+    """
+
+    if not last_total_tokens or not context_window or threshold <= 0:
+        return False
+    return last_total_tokens >= context_window * threshold
+
+
+def build_compact_event(
+    summary_text: str,
+    *,
+    provider: str,
+    model: str,
+    total_tokens: int | None = None,
+) -> ConversationMessage:
+    meta: dict[str, Any] = {"provider": provider, "model": model}
+    if total_tokens is not None:
+        meta["total_tokens"] = total_tokens
+    return build_message("compact", [text_block(summary_text)], meta=meta)
+
+
+def apply_compact_replay(
+    messages: list[ConversationMessage],
+    *,
+    transcript_path: str | None = None,
+) -> list[ConversationMessage]:
+    """Replace pre-compact history with a summary continuation.
+
+    Returns ``messages`` unchanged when no compact event is present.
+    """
+
+    last_compact = -1
+    for i, message in enumerate(messages):
+        if message.get("role") == "compact":
+            last_compact = i
+
+    if last_compact < 0:
+        return messages
+
+    summary_text = ""
+    for block in messages[last_compact].get("content") or []:
+        if isinstance(block, dict) and block.get("type") == "text":
+            summary_text = str(block.get("text") or "")
+            break
+
+    tail = [m for m in messages[last_compact + 1 :] if m.get("role") != "compact"]
+    # No tail or assistant-led tail = mid-loop; resume directly. A user-led
+    # tail needs an "Acknowledged." assistant turn to keep role alternation.
+    continue_now = not tail or tail[0].get("role") == "assistant"
+
+    parts = [CONTINUATION_HEADER, summary_text]
+    if transcript_path:
+        parts.append(TRANSCRIPT_HINT.format(path=transcript_path))
+    if continue_now:
+        parts.append(CONTINUATION_FOOTER)
+
+    projected = [build_message("user", [text_block("\n\n".join(parts))])]
+    if not continue_now:
+        projected.append(build_message("assistant", [text_block(COMPACT_ACK)]))
+    projected.extend(tail)
+    return projected

{mycode_sdk-0.7.6 → mycode_sdk-0.8.1}/src/mycode/providers/anthropic_like.py

@@ -214,11 +214,11 @@ class AnthropicLikeAdapter(ProviderAdapter):
                 )
                 continue
 
-        native_meta: dict[str, Any] = {}
+        message_native_meta: dict[str, Any] = {}
         if stop_sequence := getattr(message, "stop_sequence", None):
-            native_meta["stop_sequence"] = stop_sequence
+            message_native_meta["stop_sequence"] = stop_sequence
         if service_tier := getattr(message, "service_tier", None):
-            native_meta["service_tier"] = service_tier
+            message_native_meta["service_tier"] = service_tier
 
         # No `total_tokens` field — compute it from input + cache + output parts.
         raw_usage = dump_model(getattr(message, "usage", None)) or {}
@@ -237,7 +237,7 @@ class AnthropicLikeAdapter(ProviderAdapter):
             provider_message_id=getattr(message, "id", None),
             stop_reason=getattr(message, "stop_reason", None),
             total_tokens=total_tokens,
-            native_meta=native_meta,
+            native_meta=message_native_meta,
         )
 
     def _serialize_tool(self, tool: dict[str, Any]) -> dict[str, Any]:

{mycode_sdk-0.7.6 → mycode_sdk-0.8.1}/src/mycode/providers/openai_chat.py

@@ -119,7 +119,7 @@ class OpenAIChatAdapter(ProviderAdapter):
             state = tool_calls[index]
             raw_arguments = state.arguments_text
             parsed_arguments = parse_tool_arguments(raw_arguments)
-            if isinstance(parsed_arguments, str):
+            if parsed_arguments is None:
                 tool_input = {}
                 meta = {"native": {"raw_arguments": raw_arguments}}
             else:
@@ -301,41 +301,23 @@ class OpenAIChatAdapter(ProviderAdapter):
         # We check both the delta root and model_extra to cover both patterns.
         # Known fields: reasoning, reasoning_content, reasoning_details.
         for source in (delta, getattr(delta, "model_extra", None) or {}):
-            if isinstance(source, dict):
-                has_reasoning = "reasoning" in source
-                reasoning = source.get("reasoning")
-                has_reasoning_content = "reasoning_content" in source
-                reasoning_content = source.get("reasoning_content")
-                has_reasoning_details = "reasoning_details" in source
-                reasoning_details = source.get("reasoning_details")
-            else:
-                has_reasoning = hasattr(source, "reasoning")
-                reasoning = getattr(source, "reasoning", None)
-                has_reasoning_content = hasattr(source, "reasoning_content")
-                reasoning_content = getattr(source, "reasoning_content", None)
-                has_reasoning_details = hasattr(source, "reasoning_details")
-                reasoning_details = getattr(source, "reasoning_details", None)
-
-            if has_reasoning:
-                return (
-                    reasoning if isinstance(reasoning, str) else "",
-                    {"reasoning_field": "reasoning"},
-                )
+            for field in ("reasoning", "reasoning_content", "reasoning_details"):
+                if isinstance(source, dict):
+                    if field not in source:
+                        continue
+                    value = source[field]
+                elif hasattr(source, field):
+                    value = getattr(source, field, None)
+                else:
+                    continue
 
-            if has_reasoning_content:
-                return (
-                    reasoning_content if isinstance(reasoning_content, str) else "",
-                    {"reasoning_field": "reasoning_content"},
-                )
+                if field == "reasoning_details":
+                    if not isinstance(value, list):
+                        continue
+                    text = "".join(str(item.get("text") or "") for item in value if isinstance(item, dict))
+                    return text, {"reasoning_field": "reasoning_details", "reasoning_details": value}
 
-            if has_reasoning_details and isinstance(reasoning_details, list):
-                reasoning_text = "".join(
-                    str(item.get("text") or "") for item in reasoning_details if isinstance(item, dict)
-                )
-                return reasoning_text, {
-                    "reasoning_field": "reasoning_details",
-                    "reasoning_details": reasoning_details,
-                }
+                return (value if isinstance(value, str) else "", {"reasoning_field": field})
 
         return "", {}
 

{mycode_sdk-0.7.6 → mycode_sdk-0.8.1}/src/mycode/providers/openai_responses.py

@@ -339,7 +339,7 @@ class OpenAIResponsesAdapter(ProviderAdapter):
             if item_type == "function_call":
                 raw_arguments = getattr(item, "arguments", "") or ""
                 parsed_arguments = parse_tool_arguments(raw_arguments)
-                if isinstance(parsed_arguments, str):
+                if parsed_arguments is None:
                     tool_input = {}
                     raw_args_entry: dict[str, Any] = {"raw_arguments": raw_arguments}
                 else:

{mycode_sdk-0.7.6 → mycode_sdk-0.8.1}/src/mycode/session.py

@@ -16,61 +16,20 @@ import shutil
 from dataclasses import asdict, dataclass
 from datetime import UTC, datetime
 from pathlib import Path
-from typing import Any, TypedDict, cast
+from typing import TypedDict, cast
 
-from mycode.messages import ConversationMessage, build_message, flatten_message_text, text_block
+from mycode.messages import ConversationMessage, flatten_message_text
 
 # ---------------------------------------------------------------------
-# Session format and compacting defaults
+# Session format defaults
 # ---------------------------------------------------------------------
 
-MESSAGE_FORMAT_VERSION = 6
-DEFAULT_COMPACT_THRESHOLD = 0.8
+MESSAGE_FORMAT_VERSION = 7
 DEFAULT_SESSION_TITLE = "New chat"
 
-COMPACT_SUMMARY_PROMPT = """\
-Summarize this conversation to create a continuation document. \
-This summary will replace the full conversation history, so it must \
-capture everything needed to continue the work seamlessly.
-
-Include:
-
-1. **Task and Intent**: Describe the user's overall goal — what is being \
-built, fixed, or investigated, and why.
-2. **Decisions and Constraints**: List the decisions made, constraints \
-discovered, and approaches chosen or rejected, with the reasoning behind \
-each.
-3. **User Requests**: Every distinct request or instruction the user gave, \
-in chronological order. Preserve the user's original wording for ambiguous \
-or nuanced requests.
-4. **Files and Changes**: Enumerate every file read, modified, or created \
-— paths, what changed, and any code snippets the next turn will need to \
-reason about, quoted verbatim.
-5. **Errors and Fixes**: List errors encountered with the original message \
-verbatim, the cause if known, and the resolution — or that it remains open.
-6. **Current State**: What is verified working, what is known broken, what \
-is in progress.
-7. **Next Step**: The next step to take, with a direct quote from the most \
-recent conversation showing where the work left off.
-
-Rules:
-- Be specific: reproduce file paths, function names, error messages, and \
-other identifiers verbatim — never paraphrase them.
-- Do not add suggestions or opinions — only summarize what happened.
-- Keep it concise but complete.\
-"""
-
-_CONTINUATION_HEADER = "This session is being continued from a previous conversation that was compacted to fit the context window. The summary below covers the earlier portion of the conversation."
-
-_TRANSCRIPT_HINT = "For verbatim details not captured in this summary (exact code snippets, error messages, or earlier output), read the original conversation log at: {path}"
-
-_CONTINUATION_FOOTER = 'Resume directly from where the work left off. Do not acknowledge this summary, do not recap, and do not preface with "I\'ll continue" or similar.'
-
-_COMPACT_ACK = "Acknowledged."
-
 
 # ---------------------------------------------------------------------
-# Compact and rewind session events
+# Rewind session events
 # ---------------------------------------------------------------------
 
 
@@ -78,90 +37,6 @@ def _now() -> str:
     return datetime.now(UTC).isoformat()
 
 
-def should_compact(
-    last_total_tokens: int | None,
-    context_window: int | None,
-    threshold: float,
-) -> bool:
-    """True when the latest call's `total_tokens` ≥ `context_window × threshold`.
-
-    `total_tokens` already covers the next API call's prompt floor, so it is
-    the right input here. The `(1 - threshold)` headroom is reserved for the
-    compact LLM call itself (see docs/sessions.md).
-    """
-
-    if not last_total_tokens or not context_window or threshold <= 0:
-        return False
-    return last_total_tokens >= context_window * threshold
-
-
-def build_compact_event(
-    summary_text: str,
-    *,
-    provider: str,
-    model: str,
-    compacted_count: int,
-    total_tokens: int | None = None,
-) -> ConversationMessage:
-    """Build the compact event stored in session JSONL."""
-
-    meta: dict[str, Any] = {
-        "provider": provider,
-        "model": model,
-        "compacted_count": compacted_count,
-    }
-    if total_tokens is not None:
-        meta["total_tokens"] = total_tokens
-    return build_message("compact", [text_block(summary_text)], meta=meta)
-
-
-def apply_compact(
-    messages: list[ConversationMessage],
-    *,
-    transcript_path: str | None = None,
-    continue_now: bool | None = None,
-) -> list[ConversationMessage]:
-    """Replace the latest compact event with a synthetic summary view.
-
-    ``continue_now`` omits the ack and leaves a user instruction last so the
-    agent loop can immediately request the next assistant response.
-    """
-
-    # Only the newest compact event matters. Older history before it is no
-    # longer visible once the summary replaces that earlier conversation.
-    last_compact_index: int | None = None
-    for index, message in enumerate(messages):
-        if message.get("role") == "compact":
-            last_compact_index = index
-
-    if last_compact_index is None:
-        return messages
-
-    summary_text = ""
-    for block in messages[last_compact_index].get("content") or []:
-        if isinstance(block, dict) and block.get("type") == "text":
-            summary_text = str(block.get("text") or "")
-            break
-
-    tail = messages[last_compact_index + 1 :]
-    if continue_now is None:
-        # During live tool-loop compaction the next persisted message is the
-        # assistant continuation. Waiting compaction has no tail yet.
-        continue_now = bool(tail and tail[0].get("role") == "assistant")
-
-    parts = [_CONTINUATION_HEADER, summary_text]
-    if transcript_path:
-        parts.append(_TRANSCRIPT_HINT.format(path=transcript_path))
-    if continue_now:
-        parts.append(_CONTINUATION_FOOTER)
-
-    result = [build_message("user", [text_block("\n\n".join(parts))], meta={"synthetic": True})]
-    if not continue_now:
-        result.append(build_message("assistant", [text_block(_COMPACT_ACK)], meta={"synthetic": True}))
-    result.extend(tail)
-    return result
-
-
 def build_rewind_event(rewind_to: int) -> ConversationMessage:
     """Build a rewind marker to append to session JSONL."""
 
@@ -341,16 +216,11 @@ class SessionStore:
         except FileNotFoundError:
             pass
 
-        # 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
+        # Visible state = raw JSONL minus rewound tails. `compact` markers
+        # stay inline; the agent substitutes them when calling the provider.
         # 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,
-            transcript_path=str(self.messages_path(session_id)),
-        )
-        visible_messages = apply_rewind(visible_messages)
+        visible_messages = apply_rewind(raw_messages)
 
         return {"session": self._summary(session_id, meta), "messages": visible_messages}
 

{mycode_sdk-0.7.6 → mycode_sdk-0.8.1}/src/mycode/utils.py

@@ -21,10 +21,10 @@ def omit_none(d: dict[str, Any]) -> dict[str, Any]:
     return {k: v for k, v in d.items() if v is not None}
 
 
-def parse_tool_arguments(raw: str | None) -> dict[str, Any] | str:
+def parse_tool_arguments(raw: str | None) -> dict[str, Any] | None:
     """Parse a JSON tool-arguments string.
 
-    Returns the parsed dict, or an error string if the input is invalid.
+    Returns the parsed dict, or None when the input is missing/invalid/non-object.
     Empty / None input is treated as an empty argument set.
     """
     if not raw or not raw.strip():
@@ -32,7 +32,5 @@ def parse_tool_arguments(raw: str | None) -> dict[str, Any] | str:
     try:
         parsed = json.loads(raw)
     except json.JSONDecodeError:
-        return "error: invalid JSON arguments"
-    if not isinstance(parsed, dict):
-        return "error: tool arguments must decode to a JSON object"
-    return parsed
+        return None
+    return parsed if isinstance(parsed, dict) else None