mycode-sdk 0.7.4__tar.gz → 0.7.5__tar.gz

{mycode_sdk-0.7.4 → mycode_sdk-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-sdk
-Version: 0.7.4
+Version: 0.7.5
 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.4 → mycode_sdk-0.7.5}/pyproject.toml

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

{mycode_sdk-0.7.4 → mycode_sdk-0.7.5}/src/mycode/agent.py

@@ -183,7 +183,7 @@ class Agent:
             supports_pdf_input=supports_pdf_input,
         )
         self.max_tokens: int = meta.max_output_tokens or 16_384
-        self.context_window: int | None = meta.context_window or 128_000
+        self.context_window: int = meta.context_window or 128_000
         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)
@@ -570,62 +570,83 @@ class Agent:
                     block["meta"] = {**meta, "duration_ms": thinking_duration_ms}
                     break
 
+            # Stamp context_window onto the persisted assistant message so
+            # rewinds and refreshed clients can render token-usage % without
+            # re-resolving model metadata.
+            meta = cast(dict[str, Any], assistant_message.setdefault("meta", {}))
+            meta["context_window"] = self.context_window
+
             self.messages.append(assistant_message)
             await persist(assistant_message)
 
-            # Phase 2: if the assistant requested tools, execute them locally and
-            # append one user-side tool_result message before continuing.
+            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)
+
             tool_calls = [
                 block
                 for block in assistant_message.get("content") or []
                 if isinstance(block, dict) and block.get("type") == "tool_use"
             ]
-            if not tool_calls:
-                break
+            if tool_calls:
+                tool_results: list[dict[str, Any]] = []
+                for tool_call in tool_calls:
+                    async for event in self._run_tool_call(tool_call):
+                        yield event
+
+                        if event.type != "tool_done":
+                            continue
+
+                        d = event.data
+                        output = str(d.get("output") or "")
+                        metadata = d.get("metadata") if isinstance(d.get("metadata"), dict) else None
+                        content = d.get("content")
+                        tool_results.append(
+                            tool_result_block(
+                                tool_use_id=str(d.get("tool_use_id") or ""),
+                                output=output,
+                                metadata=metadata,
+                                is_error=bool(d.get("is_error")),
+                                content=content if isinstance(content, list) else None,
+                            )
+                        )
 
-            tool_results: list[dict[str, Any]] = []
-            for tool_call in tool_calls:
-                async for event in self._run_tool_call(tool_call):
-                    yield event
+                        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 event.type != "tool_done":
-                        continue
+                tool_result_message = build_message("user", tool_results)
+                self.messages.append(tool_result_message)
+                await persist(tool_result_message)
 
-                    d = event.data
-                    output = str(d.get("output") or "")
-                    metadata = d.get("metadata") if isinstance(d.get("metadata"), dict) else None
-                    content = d.get("content")
-                    tool_results.append(
-                        tool_result_block(
-                            tool_use_id=str(d.get("tool_use_id") or ""),
-                            output=output,
-                            metadata=metadata,
-                            is_error=bool(d.get("is_error")),
-                            content=content if isinstance(content, list) else None,
-                        )
+            if self._cancel_event.is_set():
+                return
+            if should_compact(total_tokens, self.context_window, self.compact_threshold):
+                try:
+                    async for event in self._compact(adapter, persist):
+                        yield event
+                except (Exception, asyncio.CancelledError):
+                    logger.warning(
+                        "Context compaction failed, continuing without compaction",
+                        exc_info=True,
                     )
 
-                    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
-
-            tool_result_message = build_message("user", tool_results)
-            self.messages.append(tool_result_message)
-            await persist(tool_result_message)
+            if not tool_calls:
+                break
 
         else:
             # while loop exhausted max_turns without breaking
             yield Event("error", {"message": "max_turns reached"})
             return
 
-        # Turn completed normally (assistant stopped calling tools).
-        # Check whether context compaction is needed.
-        if not self._cancel_event.is_set():
-            async for event in self._compact_if_needed(adapter, persist):
-                yield event
-
     def run(
         self,
         user_input: str | ConversationMessage,
@@ -657,28 +678,6 @@ class Agent:
     # Context compaction
     # ------------------------------------------------------------------
 
-    async def _compact_if_needed(
-        self,
-        adapter: ProviderAdapter,
-        persist: PersistCallback,
-    ) -> AsyncIterator[Event]:
-        """Check token usage and run compaction if above threshold."""
-
-        usage: dict[str, Any] | None = None
-        for message in reversed(self.messages):
-            if message.get("role") == "assistant":
-                usage = (message.get("meta") or {}).get("usage")
-                break
-
-        if not should_compact(usage, self.context_window, self.compact_threshold):
-            return
-
-        try:
-            async for event in self._compact(adapter, persist):
-                yield event
-        except (Exception, asyncio.CancelledError):
-            logger.warning("Context compaction failed, continuing without compaction", exc_info=True)
-
     async def _compact(
         self,
         adapter: ProviderAdapter,
@@ -720,13 +719,13 @@ class Agent:
             logger.warning("Compaction produced empty summary")
             return
 
-        summary_usage = (summary_message.get("meta") or {}).get("usage")
+        summary_total_tokens = (summary_message.get("meta") or {}).get("total_tokens")
         compact_event = build_compact_event(
             summary_text,
             provider=self.provider,
             model=self.model,
             compacted_count=compacted_count,
-            usage=summary_usage,
+            total_tokens=summary_total_tokens,
         )
 
         # Persist the compact event (append-only — original messages stay in JSONL).

{mycode_sdk-0.7.4 → mycode_sdk-0.7.5}/src/mycode/messages.py

@@ -12,7 +12,8 @@ details.
 Metadata contract:
 
 - assistant message `meta` keeps normalized top-level fields only:
-  `provider`, `model`, `provider_message_id`, `stop_reason`, `usage`
+  `provider`, `model`, `provider_message_id`, `stop_reason`, `total_tokens`,
+  `context_window` (see docs/sessions.md for `total_tokens` semantics)
 - provider-specific assistant message extras live under `meta.native`
 - provider-specific block replay hints live under `block.meta.native`
 - local display metadata, such as `block.meta.duration_ms`, is never sent
@@ -146,7 +147,7 @@ def assistant_message(
     model: str | None = None,
     provider_message_id: str | None = None,
     stop_reason: str | None = None,
-    usage: Any = None,
+    total_tokens: int | None = None,
     native_meta: dict[str, Any] | None = None,
 ) -> ConversationMessage:
     """Build a normalized assistant message with shared metadata fields."""
@@ -160,8 +161,8 @@ def assistant_message(
         meta["provider_message_id"] = provider_message_id
     if stop_reason:
         meta["stop_reason"] = stop_reason
-    if usage is not None:
-        meta["usage"] = usage
+    if total_tokens is not None:
+        meta["total_tokens"] = total_tokens
     if native_meta:
         native = omit_none(native_meta)
         if native:

{mycode_sdk-0.7.4 → mycode_sdk-0.7.5}/src/mycode/providers/anthropic_like.py

@@ -219,13 +219,24 @@ class AnthropicLikeAdapter(ProviderAdapter):
             native_meta["stop_sequence"] = stop_sequence
         if service_tier := getattr(message, "service_tier", None):
             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 {}
+        prompt_tokens = (
+            (raw_usage.get("input_tokens") or 0)
+            + (raw_usage.get("cache_creation_input_tokens") or 0)
+            + (raw_usage.get("cache_read_input_tokens") or 0)
+        )
+        output_tokens = raw_usage.get("output_tokens") or 0
+        total_tokens = prompt_tokens + output_tokens or None
+
         return assistant_message(
             blocks,
             provider=self.provider_id,
             model=getattr(message, "model", None),
             provider_message_id=getattr(message, "id", None),
             stop_reason=getattr(message, "stop_reason", None),
-            usage=dump_model(getattr(message, "usage", None)),
+            total_tokens=total_tokens,
             native_meta=native_meta,
         )
 

{mycode_sdk-0.7.4 → mycode_sdk-0.7.5}/src/mycode/providers/gemini.py

@@ -92,6 +92,9 @@ class GoogleGeminiAdapter(ProviderAdapter):
             except Exception:
                 pass
 
+        raw_usage = usage or {}
+        total_tokens = raw_usage.get("total_token_count") or None
+
         yield ProviderStreamEvent(
             "message_done",
             {
@@ -101,7 +104,7 @@ class GoogleGeminiAdapter(ProviderAdapter):
                     model=response_model or request.model,
                     provider_message_id=response_id,
                     stop_reason=str(finish_reason) if finish_reason else None,
-                    usage=usage,
+                    total_tokens=total_tokens,
                     native_meta={"finish_message": str(finish_message)} if finish_message else None,
                 )
             },

{mycode_sdk-0.7.4 → mycode_sdk-0.7.5}/src/mycode/providers/openai_chat.py

@@ -135,13 +135,16 @@ class OpenAIChatAdapter(ProviderAdapter):
                 )
             )
 
+        raw_usage = dump_model(usage) or {}
+        total_tokens = raw_usage.get("total_tokens") or None
+
         final_message = assistant_message(
             blocks,
             provider=self.provider_id,
             model=response_model or request.model,
             provider_message_id=response_id,
             stop_reason=finish_reason,
-            usage=dump_model(usage),
+            total_tokens=total_tokens,
         )
         yield ProviderStreamEvent("message_done", {"message": final_message})
 

{mycode_sdk-0.7.4 → mycode_sdk-0.7.5}/src/mycode/providers/openai_responses.py

@@ -361,12 +361,15 @@ class OpenAIResponsesAdapter(ProviderAdapter):
                     )
                 )
 
+        raw_usage = dump_model(getattr(response, "usage", None)) or {}
+        total_tokens = raw_usage.get("total_tokens") or None
+
         return assistant_message(
             blocks,
             provider=self.provider_id,
             model=getattr(response, "model", None),
             provider_message_id=getattr(response, "id", None),
             stop_reason=getattr(response, "status", None),
-            usage=dump_model(getattr(response, "usage", None)),
+            total_tokens=total_tokens,
             native_meta={"output_items": dumped_output_items} if dumped_output_items else None,
         )

{mycode_sdk-0.7.4 → mycode_sdk-0.7.5}/src/mycode/session.py

@@ -67,20 +67,20 @@ def _now() -> str:
 
 
 def should_compact(
-    last_usage: dict[str, Any] | None,
+    last_total_tokens: int | None,
     context_window: int | None,
     threshold: float,
 ) -> bool:
-    """Return True when the last response input tokens exceed the threshold."""
+    """True when the latest call's `total_tokens` ≥ `context_window × threshold`.
 
-    if not last_usage or not context_window or threshold <= 0:
-        return False
+    `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).
+    """
 
-    # Providers report prompt/input usage under slightly different field names.
-    input_tokens = int(
-        last_usage.get("input_tokens") or last_usage.get("prompt_tokens") or last_usage.get("prompt_token_count") or 0
-    )
-    return input_tokens >= context_window * threshold
+    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(
@@ -89,7 +89,7 @@ def build_compact_event(
     provider: str,
     model: str,
     compacted_count: int,
-    usage: dict[str, Any] | None = None,
+    total_tokens: int | None = None,
 ) -> ConversationMessage:
     """Build the compact event stored in session JSONL."""
 
@@ -98,8 +98,8 @@ def build_compact_event(
         "model": model,
         "compacted_count": compacted_count,
     }
-    if usage is not None:
-        meta["usage"] = usage
+    if total_tokens is not None:
+        meta["total_tokens"] = total_tokens
     return build_message("compact", [text_block(summary_text)], meta=meta)