mycode-sdk 0.11.2__tar.gz → 0.12.0__tar.gz

{mycode_sdk-0.11.2 → mycode_sdk-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-sdk
-Version: 0.11.2
+Version: 0.12.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
@@ -21,13 +21,14 @@ Requires-Python: >=3.12
 Requires-Dist: anthropic>=0.116.0
 Requires-Dist: google-genai>=2.11.0
 Requires-Dist: griffelib>=2.1.0
+Requires-Dist: httpx>=0.28.0
 Requires-Dist: openai>=2.45.0
 Requires-Dist: pydantic>=2.13.4
 Description-Content-Type: text/markdown
 
 # mycode-sdk
 
-Lightweight Python SDK for building AI agents.
+Lightweight Python SDK for building AI agents. Multi-turn conversations, tool calling, session persistence, and streaming events. Provider adapters for Anthropic, OpenAI, Google, and more.
 
 ## Install
 
@@ -62,16 +63,36 @@ asyncio.run(main())
 
 `Agent(...)` infers the provider from the model id. No tools are registered unless you pass `tools=[...]`.
 
-For a simple synchronous call, use `run()`:
+For a synchronous call, use `run()`:
 
 ```python
 result = agent.run("Read pyproject.toml and tell me the project name.")
 print(result.text)
 ```
 
+## Providers
+
+The SDK infers the provider from the model string (`claude-*` to Anthropic, `gpt-*` to OpenAI, etc.). API keys are auto-discovered from environment variables:
+
+| Provider | id | Env var |
+| --- | --- | --- |
+| Anthropic | `anthropic` | `ANTHROPIC_API_KEY` |
+| OpenAI | `openai` | `OPENAI_API_KEY` |
+| Google Gemini | `google` | `GEMINI_API_KEY` |
+| Moonshot | `moonshotai` | `MOONSHOT_API_KEY` |
+| MiniMax | `minimax` | `MINIMAX_API_KEY` |
+| DeepSeek | `deepseek` | `DEEPSEEK_API_KEY` |
+| Z.AI | `zai` | `ZAI_API_KEY` |
+| OpenRouter | `openrouter` | `OPENROUTER_API_KEY` |
+| Alibaba Cloud | `alibaba` | `DASHSCOPE_API_KEY` |
+| xAI | `xai` | `XAI_API_KEY` |
+| OpenAI-compatible | `openai_chat` | - |
+
+Pass `api_key=` to override the env var, `api_base=` for a custom endpoint. Model metadata is bundled from [models.dev](https://models.dev); pass `context_window`, `supports_reasoning`, `supports_image_input`, or `supports_pdf_input` to override.
+
 ## Multi-turn conversations
 
-Call `achat()` or `run()` again on the same `Agent` to continue the conversation:
+Call `achat()` or `run()` again on the same `Agent` to continue:
 
 ```python
 agent = Agent(model="claude-sonnet-4-6", api_key="...")
@@ -80,6 +101,8 @@ agent.run("What is 2 + 2?")
 agent.run("Now multiply that by 10.")    # remembers the earlier answer
 ```
 
+`agent.clear()` drops in-memory history. `agent.messages` accumulates across calls.
+
 ## Attachments
 
 Pass `attachments` to `achat()` or `run()` to add files alongside the prompt:
@@ -89,7 +112,7 @@ from mycode import Attachment
 
 agent.run("Describe these.", attachments=["diagram.png", "report.pdf", "notes.txt"])
 
-# Or build them explicitly — raw bytes and inline text never touch the disk:
+# Or build them explicitly:
 agent.run(
     "Review.",
     attachments=[
@@ -100,7 +123,7 @@ agent.run(
 )
 ```
 
-Images support `image/png`, `image/jpeg`, `image/gif`, `image/webp`; documents support `application/pdf`. Sending an image or PDF to a model that lacks that capability yields an `error` event; a bad path or unsupported type raises `ValueError` before the model is called.
+Images support `image/png`, `image/jpeg`, `image/gif`, `image/webp`; documents support `application/pdf`. Sending an image or PDF to a model without that capability yields an `error` event. A bad path or unsupported type raises `ValueError` before the provider is called.
 
 ## Saving sessions
 
@@ -197,4 +220,6 @@ agent = Agent(
 
 `@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.
+## Further reading
+
+See [docs/sdk.md](https://github.com/legibet/mycode/blob/main/docs/sdk.md) for the streaming event API, cancellation, retries, compaction, session internals, and the full `Agent` / `@tool` reference.

{mycode_sdk-0.11.2 → mycode_sdk-0.12.0}/README.md

@@ -1,6 +1,6 @@
 # mycode-sdk
 
-Lightweight Python SDK for building AI agents.
+Lightweight Python SDK for building AI agents. Multi-turn conversations, tool calling, session persistence, and streaming events. Provider adapters for Anthropic, OpenAI, Google, and more.
 
 ## Install
 
@@ -35,16 +35,36 @@ asyncio.run(main())
 
 `Agent(...)` infers the provider from the model id. No tools are registered unless you pass `tools=[...]`.
 
-For a simple synchronous call, use `run()`:
+For a synchronous call, use `run()`:
 
 ```python
 result = agent.run("Read pyproject.toml and tell me the project name.")
 print(result.text)
 ```
 
+## Providers
+
+The SDK infers the provider from the model string (`claude-*` to Anthropic, `gpt-*` to OpenAI, etc.). API keys are auto-discovered from environment variables:
+
+| Provider | id | Env var |
+| --- | --- | --- |
+| Anthropic | `anthropic` | `ANTHROPIC_API_KEY` |
+| OpenAI | `openai` | `OPENAI_API_KEY` |
+| Google Gemini | `google` | `GEMINI_API_KEY` |
+| Moonshot | `moonshotai` | `MOONSHOT_API_KEY` |
+| MiniMax | `minimax` | `MINIMAX_API_KEY` |
+| DeepSeek | `deepseek` | `DEEPSEEK_API_KEY` |
+| Z.AI | `zai` | `ZAI_API_KEY` |
+| OpenRouter | `openrouter` | `OPENROUTER_API_KEY` |
+| Alibaba Cloud | `alibaba` | `DASHSCOPE_API_KEY` |
+| xAI | `xai` | `XAI_API_KEY` |
+| OpenAI-compatible | `openai_chat` | - |
+
+Pass `api_key=` to override the env var, `api_base=` for a custom endpoint. Model metadata is bundled from [models.dev](https://models.dev); pass `context_window`, `supports_reasoning`, `supports_image_input`, or `supports_pdf_input` to override.
+
 ## Multi-turn conversations
 
-Call `achat()` or `run()` again on the same `Agent` to continue the conversation:
+Call `achat()` or `run()` again on the same `Agent` to continue:
 
 ```python
 agent = Agent(model="claude-sonnet-4-6", api_key="...")
@@ -53,6 +73,8 @@ agent.run("What is 2 + 2?")
 agent.run("Now multiply that by 10.")    # remembers the earlier answer
 ```
 
+`agent.clear()` drops in-memory history. `agent.messages` accumulates across calls.
+
 ## Attachments
 
 Pass `attachments` to `achat()` or `run()` to add files alongside the prompt:
@@ -62,7 +84,7 @@ from mycode import Attachment
 
 agent.run("Describe these.", attachments=["diagram.png", "report.pdf", "notes.txt"])
 
-# Or build them explicitly — raw bytes and inline text never touch the disk:
+# Or build them explicitly:
 agent.run(
     "Review.",
     attachments=[
@@ -73,7 +95,7 @@ agent.run(
 )
 ```
 
-Images support `image/png`, `image/jpeg`, `image/gif`, `image/webp`; documents support `application/pdf`. Sending an image or PDF to a model that lacks that capability yields an `error` event; a bad path or unsupported type raises `ValueError` before the model is called.
+Images support `image/png`, `image/jpeg`, `image/gif`, `image/webp`; documents support `application/pdf`. Sending an image or PDF to a model without that capability yields an `error` event. A bad path or unsupported type raises `ValueError` before the provider is called.
 
 ## Saving sessions
 
@@ -170,4 +192,6 @@ agent = Agent(
 
 `@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.
+## Further reading
+
+See [docs/sdk.md](https://github.com/legibet/mycode/blob/main/docs/sdk.md) for the streaming event API, cancellation, retries, compaction, session internals, and the full `Agent` / `@tool` reference.

{mycode_sdk-0.11.2 → mycode_sdk-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mycode-sdk"
-version = "0.11.2"
+version = "0.12.0"
 description = "Lightweight Python SDK for building AI agents."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -26,6 +26,7 @@ dependencies = [
     "anthropic>=0.116.0",
     "google-genai>=2.11.0",
     "griffelib>=2.1.0",
+    "httpx>=0.28.0",
     "openai>=2.45.0",
     "pydantic>=2.13.4",
 ]

{mycode_sdk-0.11.2 → mycode_sdk-0.12.0}/src/mycode/__init__.py

@@ -11,6 +11,7 @@ from mycode.messages import (
     ConversationMessage,
     assistant_message,
     build_message,
+    build_usage,
     document_block,
     flatten_message_text,
     image_block,
@@ -20,6 +21,8 @@ from mycode.messages import (
     tool_use_block,
     user_text_message,
 )
+from mycode.models import ModelMetadata, estimate_cost, resolve_model_metadata
+from mycode.providers.base import ProviderError, StreamStartTimeoutError
 from mycode.session import SessionStore
 from mycode.tools import (
     ToolContext,
@@ -46,10 +49,13 @@ __all__ = [
     "BeforeToolHook",
     "HookResult",
     "Hooks",
+    "ModelMetadata",
     "NothingToCompactError",
     "PersistCallback",
+    "ProviderError",
     "RunResult",
     "SessionStore",
+    "StreamStartTimeoutError",
     "ToolContext",
     "ToolExecutionResult",
     "ToolExecutor",
@@ -59,12 +65,15 @@ __all__ = [
     "assistant_message",
     "bash_tool",
     "build_message",
+    "build_usage",
     "cancel_all_tools",
     "document_block",
     "edit_tool",
+    "estimate_cost",
     "flatten_message_text",
     "image_block",
     "read_tool",
+    "resolve_model_metadata",
     "text_block",
     "thinking_block",
     "tool",

{mycode_sdk-0.11.2 → mycode_sdk-0.12.0}/src/mycode/agent.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
+import random
 import tempfile
 import time
 from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
@@ -30,6 +31,7 @@ from mycode.compact import (
 )
 from mycode.hooks import Hooks, ToolHookContext
 from mycode.messages import (
+    USAGE_TOKEN_KEYS,
     ConversationMessage,
     build_message,
     flatten_message_text,
@@ -38,9 +40,16 @@ from mycode.messages import (
     tool_result_block,
     user_text_message,
 )
-from mycode.models import infer_provider_from_model, resolve_model_metadata
+from mycode.models import estimate_cost, infer_provider_from_model, resolve_model_metadata
 from mycode.providers import get_provider_adapter
-from mycode.providers.base import ProviderAdapter, ProviderRequest, ProviderStreamEvent
+from mycode.providers.base import (
+    DEFAULT_REQUEST_TIMEOUT,
+    ProviderAdapter,
+    ProviderError,
+    ProviderRequest,
+    ProviderStreamEvent,
+    StreamStartTimeoutError,
+)
 from mycode.session import SessionStore
 from mycode.tools import ToolContext, ToolExecutionResult, ToolExecutor, ToolSpec
 
@@ -64,6 +73,29 @@ class RunResult:
     text: str = ""
     events: list[Event] = field(default_factory=list)
     error: str | None = None
+    usage: dict[str, Any] | None = None
+
+
+def _accumulate_usage(
+    turn_usage: dict[str, Any],
+    turn_cost: float | None,
+    usage: dict[str, Any],
+    cost: dict[str, Any] | None,
+) -> float | None:
+    """Fold one provider request's usage into the turn accumulator.
+
+    Mutates ``turn_usage`` and returns the updated best-effort turn cost.
+    """
+
+    for key in USAGE_TOKEN_KEYS:
+        value = usage.get(key)
+        if value is None:
+            continue
+        turn_usage[key] = turn_usage.get(key, 0) + value
+    request_cost = estimate_cost(usage, cost)
+    if request_cost is None:
+        return turn_cost
+    return request_cost if turn_cost is None else turn_cost + request_cost
 
 
 class Agent:
@@ -83,6 +115,9 @@ class Agent:
         max_turns: int | None = None,
         max_tokens: int | None = None,
         temperature: float = 1.0,
+        request_timeout: float = DEFAULT_REQUEST_TIMEOUT,
+        stream_start_timeout: float = 60.0,
+        max_retries: int = 2,
         context_window: int | None = None,
         compact_threshold: float | None = None,
         reasoning_effort: str | None = None,
@@ -116,6 +151,15 @@ class Agent:
         self.api_key = api_key
         self.api_base = api_base
         self.max_turns = max_turns
+        if request_timeout <= 0:
+            raise ValueError("request_timeout must be positive")
+        if stream_start_timeout <= 0:
+            raise ValueError("stream_start_timeout must be positive")
+        if max_retries < 0:
+            raise ValueError("max_retries must be >= 0")
+        self.request_timeout = float(request_timeout)
+        self.stream_start_timeout = float(stream_start_timeout)
+        self.max_retries = int(max_retries)
         if not 0 <= temperature <= 1:
             raise ValueError("temperature must be between 0 and 1")
         if (
@@ -200,6 +244,7 @@ class Agent:
         )
         self.max_tokens: int = meta.max_output_tokens or 16_384
         self.context_window: int = meta.context_window or 128_000
+        self.model_cost: dict[str, Any] | None = meta.cost
         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)
@@ -438,9 +483,55 @@ class Agent:
         adapter: ProviderAdapter,
         request: ProviderRequest,
     ) -> AsyncIterator[ProviderStreamEvent]:
-        """Iterate one provider turn with best-effort cancellation support."""
+        """Stream one provider turn, retrying failed attempts before any output.
+
+        Yields an internal ``retry`` event before each new attempt. Once a
+        canonical event (thinking/text delta or message_done) has been yielded,
+        a partially consumed stream cannot be replayed safely, so failures
+        propagate instead of retrying. Adapter ``stream_started`` markers are
+        consumed here and never reach the caller.
+        """
+
+        max_attempts = self.max_retries + 1
+        for attempt in range(1, max_attempts + 1):
+            output_emitted = False
+            try:
+                async for event in self._stream_provider_attempt(adapter, request):
+                    if event.type == "stream_started":
+                        continue
+                    output_emitted = True
+                    yield event
+                return
+            except ProviderError as exc:
+                if output_emitted or not exc.retryable or attempt >= max_attempts:
+                    raise
+                delay = self._retry_delay(attempt, exc)
+                retry_data: dict[str, Any] = {
+                    "attempt": attempt + 1,
+                    "max_attempts": max_attempts,
+                    "delay_seconds": round(delay, 3),
+                    "reason": exc.reason,
+                    "message": str(exc),
+                }
+                if exc.status_code is not None:
+                    retry_data["status_code"] = exc.status_code
+                yield ProviderStreamEvent("retry", retry_data)
+                await self._backoff(delay)
+
+    async def _stream_provider_attempt(
+        self,
+        adapter: ProviderAdapter,
+        request: ProviderRequest,
+    ) -> AsyncIterator[ProviderStreamEvent]:
+        """Iterate one provider attempt with cancellation and the start deadline.
+
+        The deadline covers everything up to the first upstream event: DNS,
+        connect, request upload, response headers, and the wait for the first
+        SSE event or chunk.
+        """
 
         provider_stream: AsyncIterator[ProviderStreamEvent] = adapter.stream_turn(request)
+        started = False
 
         try:
             while True:
@@ -449,17 +540,49 @@ class Agent:
 
                 self._provider_event_task = asyncio.ensure_future(anext(provider_stream))
                 try:
-                    yield await self._provider_event_task
+                    if started:
+                        event = await self._provider_event_task
+                    else:
+                        try:
+                            # wait_for cancels the pending anext and awaits its
+                            # cancellation before raising.
+                            event = await asyncio.wait_for(self._provider_event_task, self.stream_start_timeout)
+                        except TimeoutError:
+                            raise StreamStartTimeoutError(
+                                f"no provider stream event received within {self.stream_start_timeout:g}s"
+                            ) from None
                 except StopAsyncIteration:
                     return
                 finally:
                     self._provider_event_task = None
+
+                started = True
+                yield event
         finally:
+            # Runs before the retry loop backs off, so a failed attempt's
+            # stream is closed before the next attempt starts.
             close = cast(Callable[[], Awaitable[None]] | None, getattr(provider_stream, "aclose", None))
             if close is not None:
                 with suppress(Exception):
                     await close()
 
+    def _retry_delay(self, failed_attempts: int, error: ProviderError) -> float:
+        """Backoff before the next attempt: Retry-After when sane, else exponential."""
+
+        if error.retry_after is not None and 0 < error.retry_after <= 60:
+            return error.retry_after
+        base = min(8.0, 0.5 * 2 ** (failed_attempts - 1))
+        return base * (1 - 0.25 * random.random())
+
+    async def _backoff(self, delay: float) -> None:
+        """Wait between attempts; Agent.cancel() interrupts immediately."""
+
+        try:
+            await asyncio.wait_for(self._cancel_event.wait(), timeout=delay)
+        except TimeoutError:
+            return
+        raise asyncio.CancelledError
+
     def _build_request(
         self,
         *,
@@ -486,6 +609,7 @@ class Agent:
             supports_pdf_input=self.supports_pdf_input,
             transcript_path=self.transcript_path,
             append_messages=list(append_messages),
+            request_timeout=self.request_timeout,
         )
 
     @staticmethod
@@ -504,6 +628,43 @@ class Agent:
             block["meta"] = {**meta, "duration_ms": duration_ms}
             return
 
+    def _partial_assistant_message(
+        self,
+        partial_content: list[dict[str, Any]],
+        duration_ms: int | None,
+        *,
+        stop_reason: str | None = None,
+    ) -> ConversationMessage:
+        """Build the assistant message persisted for an interrupted stream."""
+
+        if duration_ms is not None:
+            self._stamp_thinking_duration(partial_content, duration_ms)
+        meta: dict[str, Any] = {
+            "provider": self.provider,
+            "model": self.model,
+            "context_window": self.context_window,
+        }
+        if stop_reason:
+            meta["stop_reason"] = stop_reason
+        return build_message("assistant", [dict(block) for block in partial_content], meta=meta)
+
+    def _usage_event(
+        self,
+        context_tokens: int | None,
+        turn_usage: dict[str, Any],
+        turn_cost: float | None,
+    ) -> Event:
+        """Build a usage event: turn-cumulative billing facts + context metric."""
+
+        return Event(
+            "usage",
+            {
+                "context_tokens": context_tokens,
+                "turn_usage": dict(turn_usage),
+                "turn_cost_usd": turn_cost,
+            },
+        )
+
     async def _persist_message(
         self,
         message: ConversationMessage,
@@ -575,6 +736,9 @@ class Agent:
 
         adapter = get_provider_adapter(self.provider)
 
+        turn_usage: dict[str, Any] = {}
+        turn_cost: float | None = None
+        context_tokens: int | None = None
         turn_number = 0
         while True:
             if self.max_turns is not None and turn_number >= self.max_turns:
@@ -598,6 +762,10 @@ class Agent:
                         provider_cancelled = True
                         break
 
+                    if provider_event.type == "retry":
+                        yield Event("retry", dict(provider_event.data))
+                        continue
+
                     if provider_event.type == "thinking_delta":
                         delta_text = str(provider_event.data.get("text") or "")
                         if delta_text:
@@ -641,6 +809,17 @@ class Agent:
                 provider_cancelled = True
             except Exception as exc:
                 logger.exception("Provider request failed")
+                if partial_content:
+                    # Output already reached the caller, so the attempt was not
+                    # retried; keep the JSONL consistent with what was shown.
+                    # stop_reason="error" excludes the partial from replay.
+                    if thinking_started_at is not None and thinking_duration_ms is None:
+                        thinking_duration_ms = self._elapsed_ms(thinking_started_at)
+                    failed_message = self._partial_assistant_message(
+                        partial_content, thinking_duration_ms, stop_reason="error"
+                    )
+                    self.messages.append(failed_message)
+                    await persist(failed_message)
                 yield Event("error", {"message": str(exc)})
                 return
 
@@ -648,17 +827,7 @@ class Agent:
                 if partial_content:
                     if thinking_started_at is not None and thinking_duration_ms is None:
                         thinking_duration_ms = self._elapsed_ms(thinking_started_at)
-                    if thinking_duration_ms is not None:
-                        self._stamp_thinking_duration(partial_content, thinking_duration_ms)
-                    cancelled_message = build_message(
-                        "assistant",
-                        [dict(block) for block in partial_content],
-                        meta={
-                            "provider": self.provider,
-                            "model": self.model,
-                            "context_window": self.context_window,
-                        },
-                    )
+                    cancelled_message = self._partial_assistant_message(partial_content, thinking_duration_ms)
                     self.messages.append(cancelled_message)
                     await persist(cancelled_message)
                 yield Event("error", {"message": "cancelled"})
@@ -680,17 +849,10 @@ class Agent:
             self.messages.append(assistant_message)
             await persist(assistant_message)
 
-            total_tokens = meta.get("total_tokens")
-            if total_tokens:
-                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"],
-                    },
-                )
+            request_usage = cast(dict[str, Any], meta.get("usage") or {})
+            context_tokens = request_usage.get("total_tokens")
+            turn_cost = _accumulate_usage(turn_usage, turn_cost, request_usage, self.model_cost)
+            yield self._usage_event(context_tokens, turn_usage, turn_cost)
 
             tool_calls = [
                 block
@@ -728,10 +890,16 @@ class Agent:
 
             if self._cancel_event.is_set():
                 return
-            if should_compact(total_tokens, self.context_window, self.compact_threshold):
+            if should_compact(context_tokens, self.context_window, self.compact_threshold):
                 try:
-                    await self._compact(adapter, on_persist)
+                    compact_marker = await self._compact(adapter, on_persist)
                     yield Event("compact", {})
+                    # The summary call is a billed provider request; its total
+                    # is not the post-compact context size, so context_tokens
+                    # keeps the last normal request's value.
+                    compact_usage = cast(dict[str, Any], (compact_marker.get("meta") or {}).get("usage") or {})
+                    turn_cost = _accumulate_usage(turn_usage, turn_cost, compact_usage, self.model_cost)
+                    yield self._usage_event(context_tokens, turn_usage, turn_cost)
                 except asyncio.CancelledError:
                     yield Event("error", {"message": "cancelled"})
                     return
@@ -768,6 +936,8 @@ class Agent:
                 result.events.append(event)
                 if event.type == "text":
                     result.text += str(event.data.get("delta") or "")
+                elif event.type == "usage":
+                    result.usage = event.data
                 elif event.type == "error" and result.error is None:
                     result.error = str(event.data.get("message") or "")
             return result
@@ -844,12 +1014,12 @@ class Agent:
         if self._cancel_event.is_set():
             raise asyncio.CancelledError
 
-        summary_total_tokens = (summary_message.get("meta") or {}).get("total_tokens")
+        summary_meta = cast(dict[str, Any], summary_message.get("meta") or {})
         compact_event = build_compact_event(
             summary_text,
             provider=self.provider,
             model=self.model,
-            total_tokens=summary_total_tokens,
+            usage=summary_meta.get("usage"),
         )
 
         await self._persist_message(compact_event, on_persist)

{mycode_sdk-0.11.2 → mycode_sdk-0.12.0}/src/mycode/attachments.py

@@ -86,7 +86,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 = Path(resolve_path(str(raw), cwd=cwd))
+                path = resolve_path(raw, cwd=cwd)
                 if not path.exists():
                     raise ValueError(f"attachment not found: {raw}")
                 if path.is_dir():

{mycode_sdk-0.11.2 → mycode_sdk-0.12.0}/src/mycode/compact.py

@@ -89,11 +89,11 @@ def build_compact_event(
     *,
     provider: str,
     model: str,
-    total_tokens: int | None = None,
+    usage: dict[str, Any] | None = None,
 ) -> ConversationMessage:
     meta: dict[str, Any] = {"provider": provider, "model": model}
-    if total_tokens is not None:
-        meta["total_tokens"] = total_tokens
+    if usage:
+        meta["usage"] = dict(usage)
     return build_message("compact", [text_block(summary_text)], meta=meta)