devtorch-core 3.0.1__py3-none-any.whl

devtorch_core/wrapper/anthropic.py

@@ -0,0 +1,487 @@
+"""
+devtorch_core.wrapper.anthropic
+================================
+Drop-in replacement for ``anthropic.Anthropic`` that:
+
+1. Injects the RACP system-prompt prefix into every ``messages.create`` call.
+2. Captures reasoning / RACP blocks from the response to the .GCC/ store.
+3. Returns clean (block-stripped) text to callers.
+4. Degrades gracefully if anthropic is not installed or .GCC/ is missing.
+
+Usage
+-----
+::
+
+    from devtorch_core.wrapper.anthropic import DevTorchAnthropic as Anthropic
+
+    client = Anthropic()           # same constructor signature as anthropic.Anthropic
+    response = client.messages.create(
+        model="claude-opus-4-5",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Hello"}],
+    )
+"""
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any, Iterator
+
+from .base import CaptureOrchestrator, RACPInjector, _reasoning_text, find_gcc_repo, is_disabled
+
+logger = logging.getLogger("devtorch.wrapper.anthropic")
+
+# ---------------------------------------------------------------------------
+# Optional import — degrade gracefully if anthropic is not installed
+# ---------------------------------------------------------------------------
+
+try:
+    import anthropic as _anthropic
+
+    HAS_ANTHROPIC = True
+except ImportError:
+    HAS_ANTHROPIC = False
+    _anthropic = None  # type: ignore[assignment]
+
+
+# ---------------------------------------------------------------------------
+# Wrapper
+# ---------------------------------------------------------------------------
+
+
+class DevTorchAnthropic:
+    """
+    Drop-in replacement for ``anthropic.Anthropic``.
+
+    Adds RACP injection and .GCC/ capture without altering the public API
+    visible to callers.  All DevTorch errors degrade to warnings.
+    """
+
+    def __init__(self, *args: Any, gcc_repo: Any = None, **kwargs: Any) -> None:
+        if not HAS_ANTHROPIC:
+            raise ImportError(
+                "anthropic package not installed. "
+                "pip install devtorch[wrapper]"
+            )
+        self._client = _anthropic.Anthropic(*args, **kwargs)  # type: ignore[union-attr]
+        self._gcc = gcc_repo or find_gcc_repo()
+        self._injector = RACPInjector(self._gcc) if self._gcc else None
+        self._capture = CaptureOrchestrator(self._gcc) if self._gcc else None
+        self.messages = self._Messages(self)
+
+    # Proxy attribute access to the underlying client for anything we
+    # don't explicitly intercept (e.g. .beta, .models, etc.)
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._client, name)
+
+    # ------------------------------------------------------------------
+    # Inner class mirrors anthropic.Anthropic.messages
+    # ------------------------------------------------------------------
+
+    class _Messages:
+        def __init__(self, parent: "DevTorchAnthropic") -> None:
+            self._p = parent
+
+        # --------------------------------------------------------------
+        # create — main intercept point
+        # --------------------------------------------------------------
+
+        def create(
+            self,
+            *,
+            messages: list,
+            system: str = "",
+            stream: bool = False,
+            **kwargs: Any,
+        ) -> Any:
+            """
+            Inject RACP prefix into *system*, call the real API, capture
+            response.
+
+            If ``stream=True`` returns a streaming wrapper that passes chunks
+            through transparently and captures the accumulated response after
+            the stream closes.
+
+            DevTorch errors never propagate to the caller.
+            """
+            session_id = str(uuid.uuid4())[:8]
+            call_id = str(uuid.uuid4())
+            prompt_text = _extract_prompt_text(messages)
+            model_name = kwargs.get("model", "")
+            injected_system = self._inject(system, prompt_text, session_id, call_id, model_name)
+
+            if stream:
+                return self._stream_create(
+                    messages=messages,
+                    system=injected_system,
+                    session_id=session_id,
+                    call_id=call_id,
+                    prompt_text=prompt_text,
+                    model_name=model_name,
+                    **kwargs,
+                )
+
+            # Non-streaming path
+            try:
+                response = self._p._client.messages.create(
+                    messages=messages,
+                    system=injected_system,
+                    stream=False,
+                    **kwargs,
+                )
+            except Exception:
+                # Record failure in the learning layer, then re-raise API errors.
+                self._record_llm_outcome(
+                    prompt_text=prompt_text,
+                    response_text="",
+                    thinking_blocks=[],
+                    session_id=session_id,
+                    call_id=call_id,
+                    model_name=model_name,
+                    outcome="failure",
+                )
+                raise
+
+            text, thinking_blocks = self._capture_response(response, session_id, prompt_text=prompt_text)
+            model_name = getattr(response, "model", None) or model_name
+            self._record_llm_outcome(
+                prompt_text=prompt_text,
+                response_text=text,
+                thinking_blocks=thinking_blocks,
+                session_id=session_id,
+                call_id=call_id,
+                model_name=model_name,
+                outcome="success",
+            )
+
+            # Strip RACP blocks from the visible text in each content block
+            try:
+                response = self._strip_response(response)
+            except Exception as exc:
+                logger.warning("devtorch: strip_response failed — %s", exc)
+
+            return response
+
+        # --------------------------------------------------------------
+        # Streaming helper
+        # --------------------------------------------------------------
+
+        def _stream_create(
+            self,
+            *,
+            messages: list,
+            system: str,
+            session_id: str,
+            call_id: str = "",
+            prompt_text: str = "",
+            model_name: str = "",
+            **kwargs: Any,
+        ) -> "_StreamingWrapper":
+            try:
+                raw_stream = self._p._client.messages.create(
+                    messages=messages,
+                    system=system,
+                    stream=True,
+                    **kwargs,
+                )
+            except Exception:
+                self._record_llm_outcome(
+                    prompt_text=prompt_text,
+                    response_text="",
+                    thinking_blocks=[],
+                    session_id=session_id,
+                    call_id=call_id,
+                    model_name=model_name,
+                    outcome="failure",
+                )
+                raise
+            return _StreamingWrapper(
+                raw_stream, self, session_id,
+                call_id=call_id,
+                prompt_text=prompt_text,
+                model_name=model_name,
+            )
+
+        # --------------------------------------------------------------
+        # Injection helpers
+        # --------------------------------------------------------------
+
+        def _inject(
+            self,
+            system: str,
+            prompt_text: str = "",
+            session_id: str = "",
+            call_id: str = "",
+            model_name: str = "",
+        ) -> str:
+            if self._p._injector and not is_disabled():
+                try:
+                    prefix, _ = self._p._injector.build_system_prefix_with_provenance(
+                        prompt_text=prompt_text or None,
+                        session_id=session_id,
+                        call_id=call_id,
+                        model_name=model_name,
+                    )
+                    if prefix:
+                        return (prefix + "\n\n" + system).strip()
+                except Exception as exc:
+                    logger.warning("devtorch: RACP injection failed — %s", exc)
+            return system
+
+        # --------------------------------------------------------------
+        # Capture helpers
+        # --------------------------------------------------------------
+
+        def _capture_response(
+            self,
+            response: Any,
+            session_id: str,
+            *,
+            prompt_text: str = "",
+        ) -> tuple[str, list]:
+            text = ""
+            thinking: list = []
+            if not self._p._capture or is_disabled():
+                return text, thinking
+            try:
+                # Build a plain dict for the parsers
+                if hasattr(response, "model_dump"):
+                    response_dict = response.model_dump()
+                elif isinstance(response, dict):
+                    response_dict = response
+                else:
+                    response_dict = {}
+
+                # Extract visible text
+                text = _extract_text(response)
+
+                # Extract thinking blocks
+                try:
+                    from devtorch_core.parser.thinking import extract_thinking_blocks
+
+                    thinking = extract_thinking_blocks(response_dict)
+                except Exception:
+                    pass
+
+                # Extract token usage from Anthropic response
+                prompt_tokens = 0
+                completion_tokens = 0
+                usage = response_dict.get("usage") if isinstance(response_dict, dict) else None
+                if usage is None and hasattr(response, "usage"):
+                    usage = getattr(response, "usage", None)
+                if usage is not None:
+                    if isinstance(usage, dict):
+                        prompt_tokens = usage.get("input_tokens", 0)
+                        completion_tokens = usage.get("output_tokens", 0)
+                    else:
+                        prompt_tokens = getattr(usage, "input_tokens", 0)
+                        completion_tokens = getattr(usage, "output_tokens", 0)
+
+                self._p._capture.capture(
+                    text,
+                    thinking,
+                    session_id,
+                    prompt_text=prompt_text,
+                    prompt_tokens=prompt_tokens,
+                    completion_tokens=completion_tokens,
+                )
+            except Exception as exc:
+                logger.warning("devtorch: _capture_response failed — %s", exc)
+            return text, thinking
+
+        def _record_llm_outcome(
+            self,
+            *,
+            prompt_text: str,
+            response_text: str,
+            thinking_blocks: list,
+            session_id: str,
+            call_id: str,
+            model_name: str,
+            outcome: str,
+        ) -> None:
+            if not self._p._capture or is_disabled():
+                return
+            try:
+                reasoning = _reasoning_text(thinking_blocks)
+                self._p._capture.record_learning_call(
+                    call_type="llm",
+                    reasoning=reasoning,
+                    session_id=session_id,
+                    call_id=call_id,
+                    name=model_name,
+                    input=prompt_text,
+                    output=response_text,
+                    outcome=outcome,
+                )
+            except Exception as exc:
+                logger.warning("devtorch: _record_llm_outcome failed — %s", exc)
+
+        # --------------------------------------------------------------
+        # Strip RACP markup from the response object
+        # --------------------------------------------------------------
+
+        def _strip_response(self, response: Any) -> Any:
+            """
+            Return response with RACP blocks and inline <thinking> blocks stripped
+            from text content blocks. Modifies in-place where possible.
+            """
+            from devtorch_core.parser.blocks import strip_racp_blocks
+            from devtorch_core.reasoning_plus.capture import strip_inline_thinking
+
+            content = getattr(response, "content", None)
+            if content is None:
+                return response
+
+            for block in content:
+                if hasattr(block, "text") and isinstance(block.text, str):
+                    try:
+                        text = strip_racp_blocks(block.text)
+                        text = strip_inline_thinking(text)
+                        block.text = text
+                    except Exception:
+                        pass
+
+            return response
+
+
+# ---------------------------------------------------------------------------
+# Streaming wrapper
+# ---------------------------------------------------------------------------
+
+
+class _StreamingWrapper:
+    """
+    Thin wrapper around the raw Anthropic streaming response.
+
+    Passes chunks through transparently while accumulating the full text
+    in a shadow buffer.  Fires capture when the stream closes and records the
+    outcome in the Reasoning Plus Learning layer.
+    """
+
+    def __init__(
+        self,
+        raw_stream: Any,
+        messages_obj: "DevTorchAnthropic._Messages",
+        session_id: str,
+        call_id: str = "",
+        prompt_text: str = "",
+        model_name: str = "",
+    ) -> None:
+        self._raw = raw_stream
+        self._msgs = messages_obj
+        self._session_id = session_id
+        self._call_id = call_id
+        self._prompt_text = prompt_text
+        self._model_name = model_name
+        self._accumulated_text = ""
+        self._recorded = False
+
+    def __iter__(self) -> Iterator[Any]:
+        try:
+            for chunk in self._raw:
+                # Accumulate text from delta events
+                try:
+                    delta = getattr(chunk, "delta", None)
+                    if delta is not None and hasattr(delta, "text"):
+                        self._accumulated_text += delta.text or ""
+                    elif isinstance(chunk, dict):
+                        delta_d = chunk.get("delta", {})
+                        self._accumulated_text += delta_d.get("text", "")
+                except Exception:
+                    pass
+                yield chunk
+        except Exception:
+            self._on_close(outcome="failure")
+            raise
+        finally:
+            if not self._recorded:
+                self._on_close(outcome="success")
+
+    def __enter__(self) -> "_StreamingWrapper":
+        if hasattr(self._raw, "__enter__"):
+            self._raw.__enter__()
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        try:
+            if hasattr(self._raw, "__exit__"):
+                self._raw.__exit__(*args)
+        finally:
+            if not self._recorded:
+                self._on_close(outcome="success")
+
+    def _on_close(self, outcome: str = "success") -> None:
+        if self._recorded:
+            return
+        self._recorded = True
+        if self._accumulated_text:
+            try:
+                self._msgs._p._capture.capture(
+                    self._accumulated_text, [], self._session_id,
+                    prompt_text=self._prompt_text,
+                )
+            except Exception as exc:
+                logger.warning("devtorch: stream capture failed — %s", exc)
+        try:
+            self._msgs._record_llm_outcome(
+                prompt_text=self._prompt_text,
+                response_text=self._accumulated_text,
+                thinking_blocks=[],
+                session_id=self._session_id,
+                call_id=self._call_id,
+                model_name=self._model_name,
+                outcome=outcome,
+            )
+        except Exception as exc:
+            logger.warning("devtorch: stream learning outcome failed — %s", exc)
+
+    # Proxy everything else to the raw stream
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._raw, name)
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _extract_text(response: Any) -> str:
+    """Pull plain text from an Anthropic response object or dict."""
+    text = ""
+    content = getattr(response, "content", None) or (
+        response.get("content") if isinstance(response, dict) else None
+    )
+    if not content:
+        return text
+    for block in content:
+        if isinstance(block, dict):
+            if block.get("type") == "text":
+                text += block.get("text", "")
+        elif hasattr(block, "text"):
+            text += block.text or ""
+    return text
+
+
+def _extract_prompt_text(messages: list) -> str:
+    """Best-effort concatenation of user-visible message text for smart context."""
+    parts: list[str] = []
+    for m in messages or []:
+        if isinstance(m, dict):
+            role = m.get("role", "")
+            content = m.get("content", "")
+            if role in ("user", "system") and content:
+                if isinstance(content, str):
+                    parts.append(content)
+                elif isinstance(content, list):
+                    for item in content:
+                        if isinstance(item, dict) and item.get("type") == "text":
+                            parts.append(item.get("text", ""))
+                        elif isinstance(item, str):
+                            parts.append(item)
+        elif hasattr(m, "role") and hasattr(m, "content"):
+            role = getattr(m, "role", "")
+            content = getattr(m, "content", "")
+            if role in ("user", "system") and content:
+                parts.append(str(content))
+    return "\n".join(parts)[:4000]