agentcompile 0.2.0__tar.gz → 0.3.0__tar.gz

agentcompile-0.3.0/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @kbhatnagar1506

agentcompile-0.3.0/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,23 @@
+name: Bug report
+description: Something in the SDK doesn't work as documented
+labels: [bug]
+body:
+  - type: textarea
+    id: what
+    attributes:
+      label: What happened, and what did you expect?
+    validations: { required: true }
+  - type: textarea
+    id: repro
+    attributes:
+      label: Minimal code to reproduce
+      render: python
+  - type: input
+    id: versions
+    attributes:
+      label: Versions
+      placeholder: agentcompile 0.2.0, openai 2.x, Python 3.12
+  - type: textarea
+    id: trail
+    attributes:
+      label: Trail lines (`agentcompile trail --json`), with secrets removed

agentcompile-0.3.0/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Security problem
+    url: https://github.com/kbhatnagar1506/agentcompile-python/security/advisories/new
+    about: Report vulnerabilities privately, not as an issue.

agentcompile-0.3.0/.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,9 @@
+name: Feature request
+description: Something you'd like the SDK to do
+labels: [enhancement]
+body:
+  - type: textarea
+    id: need
+    attributes:
+      label: What do you need, and why?
+    validations: { required: true }

agentcompile-0.3.0/.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: "/"
+    schedule: { interval: weekly }
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule: { interval: weekly }

agentcompile-0.3.0/.github/pull_request_template.md

@@ -0,0 +1,6 @@
+## What and why
+
+## Checklist
+- [ ] Tests added or updated
+- [ ] Commit messages follow Conventional Commits (`fix:`, `feat:`, ...)
+- [ ] The SDK still never raises into the caller and still fails open

{agentcompile-0.2.0 → agentcompile-0.3.0}/.github/workflows/ci.yml

@@ -12,10 +12,10 @@ jobs:
       matrix:
         python: ["3.9", "3.10", "3.11", "3.12", "3.13"]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
         with:
           fetch-depth: 0  # the version comes from git tags
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v7
         with:
           python-version: ${{ matrix.python }}
       - run: pip install -e ".[dev]" ruff

{agentcompile-0.2.0 → agentcompile-0.3.0}/.github/workflows/release.yml

@@ -23,7 +23,7 @@ jobs:
       released: ${{ steps.rp.outputs.release_created }}
       tag: ${{ steps.rp.outputs.tag_name }}
     steps:
-      - uses: googleapis/release-please-action@v4
+      - uses: googleapis/release-please-action@v5
         id: rp
         with:
           config-file: release-please-config.json
@@ -39,11 +39,11 @@ jobs:
       id-token: write
       contents: read
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
         with:
           ref: ${{ needs.release-please.outputs.tag || github.ref }}
           fetch-depth: 0
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v7
         with:
           python-version: "3.12"
       - run: pip install build && python -m build

agentcompile-0.3.0/.release-please-manifest.json

@@ -0,0 +1 @@
+{".":"0.3.0"}

agentcompile-0.3.0/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## [0.3.0](https://github.com/kbhatnagar1506/agentcompile-python/compare/v0.2.1...v0.3.0) (2026-10-01)
+
+
+### Features
+
+* capture (opt-in) sends each call's request and answer in the background ([#7](https://github.com/kbhatnagar1506/agentcompile-python/issues/7)) ([58f564d](https://github.com/kbhatnagar1506/agentcompile-python/commit/58f564da708c31dbf6d4c11c377dab2e315994de))
+
+## [0.2.1](https://github.com/kbhatnagar1506/agentcompile-python/compare/v0.2.0...v0.2.1) (2026-10-01)
+
+
+### Bug Fixes
+
+* keep AgentCompile's decision events in the trail ([#5](https://github.com/kbhatnagar1506/agentcompile-python/issues/5)) ([944c178](https://github.com/kbhatnagar1506/agentcompile-python/commit/944c178e5121f3389041335e36cee06a7f80e441))
+
+## [0.2.0](https://github.com/kbhatnagar1506/agentcompile-python/compare/agentcompile-v0.1.0...agentcompile-v0.2.0) (2026-10-01)
+
+
+### Features
+
+* agentcompile --version ([c2fea67](https://github.com/kbhatnagar1506/agentcompile-python/commit/c2fea67a3bc9b23457a41545f19f94f8005583ce))

agentcompile-0.3.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,7 @@
+# Code of conduct
+
+Be respectful and constructive. Harassment, personal attacks and discrimination of any kind are not welcome in issues, pull requests or any other project space.
+
+Maintainers may edit or remove comments, and block contributors, who don't follow this.
+
+Report problems to founders@tryagentcompile.com.

agentcompile-0.3.0/CONTRIBUTING.md

@@ -0,0 +1,22 @@
+# Contributing
+
+Thanks for helping. Issues and pull requests are welcome.
+
+## Setup
+
+```
+pip install -e ".[dev]" ruff
+pytest
+ruff check src tests && ruff format --check src tests
+```
+
+## Pull requests
+
+- One change per pull request, with a test.
+- Commit messages follow [Conventional Commits](https://www.conventionalcommits.org): `fix: ...`, `feat: ...`, `docs: ...`, `chore: ...`. They decide the next version and the changelog.
+- CI must pass on Python 3.9 and 3.13 before a pull request can merge.
+- The SDK must stay safe in someone's live path: it never raises into the caller's agent, never edits the caller's prompts, and fails open.
+
+## Releases
+
+Maintainers merge the release pull request that release-please keeps open; that tags the release and publishes it to PyPI.

{agentcompile-0.2.0 → agentcompile-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentcompile
-Version: 0.2.0
+Version: 0.3.0
 Summary: Wrap your agent's model client: repeated jobs run compiled, everything else goes to your model unchanged.
 Project-URL: Homepage, https://tryagentcompile.com
 Author-email: AgentCompile <founders@tryagentcompile.com>
@@ -25,6 +25,8 @@ Description-Content-Type: text/markdown
 
 # agentcompile
 
+[![PyPI](https://img.shields.io/pypi/v/agentcompile)](https://pypi.org/project/agentcompile/) [![Python](https://img.shields.io/pypi/pyversions/agentcompile)](https://pypi.org/project/agentcompile/) [![CI](https://github.com/kbhatnagar1506/agentcompile-python/actions/workflows/ci.yml/badge.svg)](https://github.com/kbhatnagar1506/agentcompile-python/actions/workflows/ci.yml) [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
+
 ```
 pip install agentcompile
 ```

{agentcompile-0.2.0 → agentcompile-0.3.0}/README.md

@@ -1,5 +1,7 @@
 # agentcompile
 
+[![PyPI](https://img.shields.io/pypi/v/agentcompile)](https://pypi.org/project/agentcompile/) [![Python](https://img.shields.io/pypi/pyversions/agentcompile)](https://pypi.org/project/agentcompile/) [![CI](https://github.com/kbhatnagar1506/agentcompile-python/actions/workflows/ci.yml/badge.svg)](https://github.com/kbhatnagar1506/agentcompile-python/actions/workflows/ci.yml) [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
+
 ```
 pip install agentcompile
 ```

agentcompile-0.3.0/SECURITY.md

@@ -0,0 +1,18 @@
+# Security
+
+## Reporting a vulnerability
+
+Please don't open a public issue for security problems. Report them privately through **GitHub → Security → Report a vulnerability** on this repository, or email founders@tryagentcompile.com.
+
+We'll acknowledge your report within 3 business days and keep you updated until it's fixed.
+
+## How the SDK handles your data
+
+- Your model provider key never leaves your process: the SDK calls your provider itself.
+- To decide, the SDK sends the conversation's messages, system prompt, tool definitions and model name to AgentCompile, with your AgentCompile key. Nothing else from the request is sent.
+- If AgentCompile fails, is slow or answers something unusable, your call goes straight to your model (fail-open).
+- The trail is written only to a local file (`~/.agentcompile/trail.jsonl` by default) unless you pass `trail=False`.
+
+## Supported versions
+
+Security fixes go into the latest release.

{agentcompile-0.2.0 → agentcompile-0.3.0}/src/agentcompile/__init__.py

@@ -15,12 +15,13 @@ import inspect
 import os
 from typing import Any
 
+from ._capture import Capturer, flush_all
 from ._conversation import conversation
 from ._core import LIVE, SHADOW, Proxy, Router, async_create, sync_create
 from ._decide import AsyncDecider, Decider, Settings
 from ._trail import OnEvent, Trail
 
-__all__ = ["LIVE", "SHADOW", "conversation", "wrap"]
+__all__ = ["LIVE", "SHADOW", "Settings", "conversation", "flush", "wrap"]
 try:
     from ._version import __version__
 except ImportError:  # running from a source checkout that was never built
@@ -40,6 +41,7 @@ def wrap(
     on_event: OnEvent | None = None,
     company: str | None = None,
     http_client: Any = None,
+    capture: bool | None = None,
 ) -> Any:
     """Wrap an OpenAI- or Anthropic-style client; returns an object you use exactly like it.
 
@@ -47,6 +49,8 @@ def wrap(
     mode: "live" answers known jobs; "shadow" decides but always calls your model, so you can
     see what it would have done. timeout: seconds to wait for a decision before failing open.
     trail: a path, True for ~/.agentcompile/trail.jsonl, or False. on_event: called per call.
+    capture: send each call's request and answer to AgentCompile in the background, so it can
+    find the jobs your agent repeats (opt-in; or AGENTCOMPILE_CAPTURE=1). Never slows a call.
     """
     settings = Settings(
         base_url=base_url or os.environ.get("AGENTCOMPILE_URL", DEFAULT_URL),
@@ -55,6 +59,14 @@ def wrap(
         timeout=timeout,
     )
     the_trail = Trail(trail, on_event)
+    if capture is None:
+        capture = os.environ.get("AGENTCOMPILE_CAPTURE", "") in ("1", "true", "yes")
+    # One sender per wrapped client; it always sends from its own thread (sync client).
+    capturer = (
+        Capturer(settings, http_client if _is_sync_http(http_client) else None)
+        if capture
+        else None
+    )
 
     chat = getattr(client, "chat", None)
     completions = getattr(chat, "completions", None)
@@ -62,6 +74,7 @@ def wrap(
         from . import _openai
 
         router = _router("openai", completions.create, settings, the_trail, mode, http_client)
+        router.capturer = capturer
         create = _create(router, completions.create, _openai.build)
         return Proxy(
             client,
@@ -73,12 +86,18 @@ def wrap(
         from . import _anthropic
 
         router = _router("anthropic", messages.create, settings, the_trail, mode, http_client)
+        router.capturer = capturer
         create = _create(router, messages.create, _anthropic.build)
         return Proxy(client, {"messages": Proxy(messages, {"create": create})})
 
     raise TypeError("agentcompile.wrap expects an OpenAI- or Anthropic-style client")
 
 
+def flush(timeout: float = 5.0) -> None:
+    """Send every captured call still queued (short scripts and tests; also runs at exit)."""
+    flush_all(timeout)
+
+
 def _router(
     provider: str, create: Any, settings: Settings, trail: Trail, mode: str, http_client: Any
 ) -> Router:
@@ -98,6 +117,12 @@ def _create(router: Router, original: Any, build: Any) -> Any:
     )
 
 
+def _is_sync_http(http_client: Any) -> bool:
+    """Any client with a plain (not async) post(): httpx, httpx2, a test client."""
+    post = getattr(http_client, "post", None)
+    return post is not None and not inspect.iscoroutinefunction(inspect.unwrap(post))
+
+
 def _is_async(fn: Any) -> bool:
     """The SDKs wrap create() in decorators; look through them."""
     return inspect.iscoroutinefunction(inspect.unwrap(fn))

agentcompile-0.3.0/src/agentcompile/_capture.py

@@ -0,0 +1,117 @@
+"""Capture: each model call's request and answer, sent to AgentCompile in the background so it
+can find the jobs your agent repeats (opt-in: `wrap(..., capture=True)`).
+
+Never in the way: calls are queued and sent by one background thread in batches; a full queue
+drops the oldest, a failed send is dropped and counted, and nothing here ever raises into your
+agent. Each record is one line in the exchange-log shape AgentCompile's importer reads:
+{"provider", "conversation_id", "timestamp", "request", "response"}.
+"""
+
+from __future__ import annotations
+
+import atexit
+import collections
+import threading
+import time
+from datetime import datetime, timezone
+from typing import Any
+
+import httpx
+
+from ._decide import CONVERSATION_HEADER, Settings, _request
+from ._payload import jsonable, payload
+
+MAX_QUEUE = 2000
+BATCH = 50
+INTERVAL = 1.0
+
+
+_ALL: list[Capturer] = []
+
+
+def flush_all(timeout: float = 5.0) -> None:
+    for capturer in list(_ALL):
+        capturer.flush(timeout)
+
+
+class Capturer:
+    def __init__(self, settings: Settings, http: httpx.Client | None = None) -> None:
+        self.settings = settings
+        self._http = http
+        self._queue: collections.deque[dict[str, Any]] = collections.deque(maxlen=MAX_QUEUE)
+        self._lock = threading.Lock()
+        self._wake = threading.Event()
+        self._thread: threading.Thread | None = None
+        self.sent = 0
+        self.dropped = 0
+        self.failed = 0
+        atexit.register(self.flush, 2.0)
+        _ALL.append(self)
+
+    def add(
+        self,
+        provider: str,
+        conversation_id: str | None,
+        kwargs: dict[str, Any],
+        response: Any,
+        stream: bool = False,
+    ) -> None:
+        """Queue one call. Never raises. A streamed answer is not captured yet: the record
+        keeps the request and says so."""
+        try:
+            record = {
+                "provider": provider,
+                "conversation_id": conversation_id,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "request": payload(kwargs),
+                "response": None if stream else jsonable(response),
+            }
+            if stream:
+                record["stream"] = True
+            with self._lock:
+                if len(self._queue) == self._queue.maxlen:
+                    self.dropped += 1  # the deque drops the oldest
+                self._queue.append(record)
+            self._start()
+            if len(self._queue) >= BATCH:
+                self._wake.set()
+        except Exception:
+            self.dropped += 1
+
+    def flush(self, timeout: float = 5.0) -> None:
+        """Send everything queued now (tests, and at exit)."""
+        deadline = time.monotonic() + timeout
+        while self._queue and time.monotonic() < deadline:
+            self._send_batch()
+
+    def _start(self) -> None:
+        if self._thread is None or not self._thread.is_alive():
+            self._thread = threading.Thread(target=self._run, name="agentcompile-capture")
+            self._thread.daemon = True
+            self._thread.start()
+
+    def _run(self) -> None:
+        while True:
+            self._wake.wait(INTERVAL)
+            self._wake.clear()
+            while self._queue:
+                self._send_batch()
+
+    def _send_batch(self) -> None:
+        with self._lock:
+            batch = [self._queue.popleft() for _ in range(min(BATCH, len(self._queue)))]
+        if not batch:
+            return
+        url, headers, _ = _request(self.settings, batch[0]["provider"], "capture", {})
+        headers.pop(CONVERSATION_HEADER, None)
+        url = url.rsplit("/v1/decide", 1)[0] + "/v1/capture"
+        try:
+            if self._http is None:
+                self._http = httpx.Client(timeout=self.settings.timeout)
+            response = self._http.post(url, headers=headers, json={"exchanges": batch})
+            if response.status_code == 200:
+                self.sent += len(batch)
+            else:
+                self.failed += len(batch)
+        except Exception:
+            self.failed += len(batch)

{agentcompile-0.2.0 → agentcompile-0.3.0}/src/agentcompile/_core.py

@@ -16,9 +16,12 @@ LIVE, SHADOW = "live", "shadow"
 class Router:
     """Holds the decision client, the trail and the mode for one wrapped client."""
 
-    def __init__(self, provider: str, decider: Any, trail: Trail, mode: str) -> None:
+    def __init__(
+        self, provider: str, decider: Any, trail: Trail, mode: str, capturer: Any = None
+    ) -> None:
         if mode not in (LIVE, SHADOW):
             raise ValueError("mode must be 'live' or 'shadow'")
+        self.capturer = capturer
         self.provider = provider
         self.decider = decider
         self.trail = trail
@@ -44,6 +47,12 @@ class Router:
             return "shadow", None
         return "compiled", decision
 
+    def capture(
+        self, conversation_id: str | None, kwargs: dict[str, Any], result: Any, stream: bool
+    ) -> None:
+        if self.capturer is not None:
+            self.capturer.add(self.provider, conversation_id, kwargs, result, stream)
+
     def record(
         self,
         *,
@@ -65,6 +74,7 @@ class Router:
             tool=decision.tool if decision else None,
             reason=(decision.reason if decision and decision.action == "forward" else None)
             or error,
+            events=list(decision.events) if decision and decision.events else None,
             decide_ms=round(decide_ms, 1) if decide_ms is not None else None,
             total_ms=round((time.perf_counter() - started) * 1000, 1),
             stream=stream or None,
@@ -102,8 +112,10 @@ def sync_create(
                     started=started,
                     stream=stream,
                 )
+                router.capture(conversation_id, real_kwargs, result, stream)
                 return result
         result = original(*args, **real_kwargs)
+        router.capture(conversation_id, real_kwargs, result, stream)
         router.record(
             route=route,
             conversation_id=conversation_id,
@@ -148,8 +160,10 @@ def async_create(
                     started=started,
                     stream=stream,
                 )
+                router.capture(conversation_id, real_kwargs, result, stream)
                 return result
         result = await original(*args, **real_kwargs)
+        router.capture(conversation_id, real_kwargs, result, stream)
         router.record(
             route=route,
             conversation_id=conversation_id,

{agentcompile-0.2.0 → agentcompile-0.3.0}/src/agentcompile/_decide.py

@@ -22,12 +22,17 @@ class Decision:
     call_id: str | None = None
     text: str | None = None
     reason: str | None = None
+    # What AgentCompile decided along the way (which job, what it asked, why it handed
+    # off), as the server reported it: kept so the trail can show it.
+    events: tuple[dict[str, Any], ...] = ()
 
     @classmethod
     def parse(cls, body: Any) -> Decision | None:
         if not isinstance(body, dict):
             return None
         action = body.get("action")
+        raw = body.get("events")
+        events = tuple(e for e in (raw if isinstance(raw, list) else []) if isinstance(e, dict))
         if (
             action == "tool_call"
             and isinstance(body.get("tool"), str)
@@ -38,11 +43,12 @@ class Decision:
                 tool=body["tool"],
                 args=body["args"],
                 call_id=str(body.get("call_id") or ""),
+                events=events,
             )
         if action == "say" and isinstance(body.get("text"), str):
-            return cls(action, text=body["text"])
+            return cls(action, text=body["text"], events=events)
         if action == "forward":
-            return cls(action, reason=str(body.get("reason") or ""))
+            return cls(action, reason=str(body.get("reason") or ""), events=events)
         return None
 
 

{agentcompile-0.2.0 → agentcompile-0.3.0}/src/agentcompile/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
 
 __commit_id__ = commit_id = None

agentcompile-0.3.0/tests/test_capture.py

@@ -0,0 +1,150 @@
+"""Capture (wrap(..., capture=True)): each call's request and answer reach AgentCompile in the
+background, in the importer's exchange shape, and never slow or break the call."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+import openai
+import pytest
+
+import agentcompile
+from agentcompile import _capture
+
+MESSAGES = [{"role": "user", "content": "cancel order #W1"}]
+FORWARD = {"action": "forward", "reason": "no job matched"}
+COMPLETION = {
+    "id": "c1",
+    "object": "chat.completion",
+    "created": 0,
+    "model": "gpt-x",
+    "choices": [
+        {
+            "index": 0,
+            "message": {"role": "assistant", "content": "from the model"},
+            "finish_reason": "stop",
+        }
+    ],
+}
+
+
+class Service:
+    """AgentCompile: answers decide with forward, records capture batches."""
+
+    def __init__(self, capture_status: int = 200) -> None:
+        self.batches: list[dict[str, Any]] = []
+        self.capture_status = capture_status
+
+    def __call__(self, request: httpx.Request) -> httpx.Response:
+        if request.url.path == "/v1/capture":
+            self.batches.append(json.loads(request.content))
+            assert request.headers["x-agentcompiler-key"] == "ack_acme.k"
+            assert "x-agentcompiler-conversation" not in request.headers
+            return httpx.Response(self.capture_status, json={"kept": 1})
+        return httpx.Response(200, json=FORWARD)
+
+
+def _client(service: Service, **kw: Any) -> Any:
+    provider = openai.OpenAI(
+        api_key="sk-test",
+        base_url="http://provider.test/v1",
+        http_client=httpx.Client(
+            transport=httpx.MockTransport(lambda r: httpx.Response(200, json=COMPLETION))
+        ),
+    )
+    return agentcompile.wrap(
+        provider,
+        key="ack_acme.k",
+        base_url="http://ac.test",
+        trail=False,
+        http_client=httpx.Client(transport=httpx.MockTransport(service)),
+        **kw,
+    )
+
+
+@pytest.fixture(autouse=True)
+def _no_leftover_senders() -> Any:
+    yield
+    _capture._ALL.clear()
+
+
+def test_capture_is_off_unless_asked(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("AGENTCOMPILE_CAPTURE", raising=False)
+    service = Service()
+    _client(service).chat.completions.create(
+        model="gpt-x", messages=MESSAGES, conversation_id="c1"
+    )
+    agentcompile.flush(2)
+    assert service.batches == []
+
+
+def test_each_call_is_sent_in_the_importers_exchange_shape() -> None:
+    service = Service()
+    client = _client(service, capture=True)
+    for _ in range(3):
+        client.chat.completions.create(model="gpt-x", messages=MESSAGES, conversation_id="c1")
+    agentcompile.flush(5)
+    sent = [x for batch in service.batches for x in batch["exchanges"]]
+    assert len(sent) == 3
+    first = sent[0]
+    assert first["provider"] == "openai" and first["conversation_id"] == "c1"
+    assert first["request"]["messages"] == MESSAGES and first["request"]["model"] == "gpt-x"
+    assert first["response"]["choices"][0]["message"]["content"] == "from the model"
+    assert first["timestamp"]
+    assert "conversation_id" not in first["request"]  # our keyword never reaches the model
+
+
+def test_the_environment_turns_capture_on(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("AGENTCOMPILE_CAPTURE", "1")
+    service = Service()
+    _client(service).chat.completions.create(
+        model="gpt-x", messages=MESSAGES, conversation_id="c1"
+    )
+    agentcompile.flush(5)
+    assert len(service.batches) == 1
+
+
+def test_a_failing_service_never_breaks_the_call() -> None:
+    service = Service(capture_status=500)
+    client = _client(service, capture=True)
+    resp = client.chat.completions.create(
+        model="gpt-x", messages=MESSAGES, conversation_id="c1"
+    )
+    assert resp.choices[0].message.content == "from the model"
+    agentcompile.flush(5)
+    assert _capture._ALL[-1].failed == 1 and _capture._ALL[-1].sent == 0
+
+
+def test_a_full_queue_drops_the_oldest(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(_capture, "MAX_QUEUE", 2)
+    settings = agentcompile.Settings("http://ac.test", "ack_acme.k", None, 1.0)
+    capturer = _capture.Capturer(
+        settings, httpx.Client(transport=httpx.MockTransport(Service()))
+    )
+    capturer._start = lambda: None  # type: ignore[method-assign]
+    for n in range(3):
+        capturer.add("openai", f"c{n}", {"messages": []}, {"n": n})
+    assert capturer.dropped == 1
+    assert [r["conversation_id"] for r in capturer._queue] == ["c1", "c2"]
+
+
+def test_a_streamed_answer_is_marked_not_captured() -> None:
+    settings = agentcompile.Settings("http://ac.test", "ack_acme.k", None, 1.0)
+    capturer = _capture.Capturer(
+        settings, httpx.Client(transport=httpx.MockTransport(Service()))
+    )
+    capturer._start = lambda: None  # type: ignore[method-assign]
+    capturer.add("openai", "c1", {"messages": MESSAGES, "stream": True}, object(), stream=True)
+    [record] = list(capturer._queue)
+    assert record["response"] is None and record["stream"] is True
+
+
+def test_a_record_that_cannot_be_built_is_dropped_quietly() -> None:
+    settings = agentcompile.Settings("http://ac.test", "ack_acme.k", None, 1.0)
+    capturer = _capture.Capturer(
+        settings, httpx.Client(transport=httpx.MockTransport(Service()))
+    )
+    capturer.add("openai", "c1", None, None)  # type: ignore[arg-type]
+    assert capturer.dropped == 1

{agentcompile-0.2.0 → agentcompile-0.3.0}/tests/test_wrap.py

@@ -169,6 +169,27 @@ def test_forward_calls_the_model_with_our_keyword_removed(tmp_path: Path) -> Non
     assert event["route"] == "forwarded" and event["reason"] == "no job matched"
 
 
+def test_the_trail_keeps_what_agentcompile_decided_along_the_way(tmp_path: Path) -> None:
+    events = [
+        {"decision": "activate_recipe", "recipe": "cancel_order"},
+        {"decision": "forward", "reason": "the customer asked a question"},
+    ]
+    fake = Fake({**FORWARD, "events": events})
+    _openai(fake, tmp_path).chat.completions.create(
+        model="gpt-x", messages=MESSAGES, conversation_id="c1"
+    )
+    assert _trail(tmp_path)[0]["events"] == events
+
+
+def test_malformed_events_are_dropped_not_fatal(tmp_path: Path) -> None:
+    fake = Fake({**CALL, "events": ["not a dict", {"decision": "emit_read"}]})
+    _openai(fake, tmp_path).chat.completions.create(
+        model="gpt-x", messages=MESSAGES, conversation_id="c1"
+    )
+    event = _trail(tmp_path)[0]
+    assert event["route"] == "compiled" and event["events"] == [{"decision": "emit_read"}]
+
+
 @pytest.mark.parametrize(
     "fake",
     [

agentcompile-0.2.0/.release-please-manifest.json

@@ -1 +0,0 @@
-{".":"0.2.0"}

agentcompile-0.2.0/CHANGELOG.md

@@ -1,8 +0,0 @@
-# Changelog
-
-## [0.2.0](https://github.com/kbhatnagar1506/agentcompile-python/compare/agentcompile-v0.1.0...agentcompile-v0.2.0) (2026-10-01)
-
-
-### Features
-
-* agentcompile --version ([c2fea67](https://github.com/kbhatnagar1506/agentcompile-python/commit/c2fea67a3bc9b23457a41545f19f94f8005583ce))