agentcompile 0.2.1__tar.gz → 0.3.0__tar.gz

{agentcompile-0.2.1 → 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.1 → 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.2.1 → agentcompile-0.3.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentcompile
-Version: 0.2.1
+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>

{agentcompile-0.2.1 → 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.1 → 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,
         *,
@@ -103,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,
@@ -149,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.1 → 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.1'
-__version_tuple__ = version_tuple = (0, 2, 1)
+__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.1/.release-please-manifest.json

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