devtorch-core 3.0.1__py3-none-any.whl

devtorch_core/wrapper/openai.py

@@ -0,0 +1,461 @@
+"""
+devtorch_core.wrapper.openai
+=============================
+Drop-in replacement for ``openai.OpenAI`` that:
+
+1. Injects the RACP system-prompt prefix as the first message in every
+   ``chat.completions.create`` call.
+2. Captures reasoning / RACP blocks from the response to the .GCC/ store.
+3. Returns clean (block-stripped) content to callers.
+4. Degrades gracefully if openai is not installed or .GCC/ is missing.
+
+Usage
+-----
+::
+
+    from devtorch_core.wrapper.openai import DevTorchOpenAI as OpenAI
+
+    client = OpenAI()
+    response = client.chat.completions.create(
+        model="gpt-4o",
+        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.openai")
+
+# ---------------------------------------------------------------------------
+# Optional import
+# ---------------------------------------------------------------------------
+
+try:
+    import openai as _openai
+
+    HAS_OPENAI = True
+except ImportError:
+    HAS_OPENAI = False
+    _openai = None  # type: ignore[assignment]
+
+
+# ---------------------------------------------------------------------------
+# Wrapper
+# ---------------------------------------------------------------------------
+
+
+class DevTorchOpenAI:
+    """
+    Drop-in replacement for ``openai.OpenAI``.
+
+    Intercepts ``client.chat.completions.create`` to inject RACP context
+    and capture LLM reasoning.  All other attribute access is proxied to
+    the underlying ``openai.OpenAI`` client transparently.
+    """
+
+    def __init__(self, *args: Any, gcc_repo: Any = None, **kwargs: Any) -> None:
+        if not HAS_OPENAI:
+            raise ImportError(
+                "openai package not installed. "
+                "pip install devtorch[wrapper]"
+            )
+        self._client = _openai.OpenAI(*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.chat = self._Chat(self)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._client, name)
+
+    # ------------------------------------------------------------------
+    # Inner classes mirroring openai.OpenAI.chat.completions
+    # ------------------------------------------------------------------
+
+    class _Chat:
+        def __init__(self, parent: "DevTorchOpenAI") -> None:
+            self._p = parent
+            self.completions = DevTorchOpenAI._Completions(parent)
+
+    class _Completions:
+        def __init__(self, parent: "DevTorchOpenAI") -> None:
+            self._p = parent
+
+        def create(
+            self,
+            *,
+            messages: list,
+            stream: bool = False,
+            **kwargs: Any,
+        ) -> Any:
+            """
+            Inject RACP prefix as the first system message, call real API,
+            capture response.
+
+            For streaming responses returns a wrapper that passes chunks
+            through and captures the accumulated text on completion.
+            """
+            session_id = str(uuid.uuid4())[:8]
+            call_id = str(uuid.uuid4())
+            prompt_text = _extract_prompt_text(messages)
+            model_name = kwargs.get("model", "")
+            injected_messages = self._inject(list(messages), prompt_text, session_id, call_id, model_name)
+
+            if stream:
+                return self._stream_create(
+                    messages=injected_messages,
+                    session_id=session_id,
+                    call_id=call_id,
+                    prompt_text=prompt_text,
+                    model_name=model_name,
+                    **kwargs,
+                )
+
+            # Non-streaming
+            try:
+                response = self._p._client.chat.completions.create(
+                    messages=injected_messages,
+                    stream=False,
+                    **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
+
+            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 choice message content
+            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,
+            session_id: str,
+            call_id: str = "",
+            prompt_text: str = "",
+            model_name: str = "",
+            **kwargs: Any,
+        ) -> "_OpenAIStreamingWrapper":
+            try:
+                raw_stream = self._p._client.chat.completions.create(
+                    messages=messages,
+                    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 _OpenAIStreamingWrapper(
+                raw_stream, self, session_id,
+                call_id=call_id,
+                prompt_text=prompt_text,
+                model_name=model_name,
+            )
+
+        # --------------------------------------------------------------
+        # Injection
+        # --------------------------------------------------------------
+
+        def _inject(
+            self,
+            messages: list,
+            prompt_text: str = "",
+            session_id: str = "",
+            call_id: str = "",
+            model_name: str = "",
+        ) -> list:
+            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:
+                        system_msg = {"role": "system", "content": prefix}
+                        return [system_msg] + messages
+                except Exception as exc:
+                    logger.warning("devtorch: RACP injection failed — %s", exc)
+            return messages
+
+        # --------------------------------------------------------------
+        # Capture
+        # --------------------------------------------------------------
+
+        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:
+                text = _extract_text(response)
+
+                # Thinking blocks — build a response dict for the parser
+                response_dict: dict = {}
+                try:
+                    from devtorch_core.parser.thinking import extract_thinking_blocks
+
+                    if hasattr(response, "model_dump"):
+                        response_dict = response.model_dump()
+                    elif isinstance(response, dict):
+                        response_dict = response
+                    thinking = extract_thinking_blocks(response_dict)
+                except Exception:
+                    pass
+
+                # Extract token usage from OpenAI 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("prompt_tokens", 0)
+                        completion_tokens = usage.get("completion_tokens", 0)
+                    else:
+                        prompt_tokens = getattr(usage, "prompt_tokens", 0)
+                        completion_tokens = getattr(usage, "completion_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
+        # --------------------------------------------------------------
+
+        def _strip_response(self, response: Any) -> Any:
+            from devtorch_core.parser.blocks import strip_racp_blocks
+            from devtorch_core.reasoning_plus.capture import strip_inline_thinking
+
+            try:
+                choices = getattr(response, "choices", None)
+                if choices:
+                    for choice in choices:
+                        msg = getattr(choice, "message", None)
+                        if msg and isinstance(getattr(msg, "content", None), str):
+                            msg.content = strip_inline_thinking(strip_racp_blocks(msg.content))
+            except Exception as exc:
+                logger.warning("devtorch: strip_response failed — %s", exc)
+            return response
+
+
+# ---------------------------------------------------------------------------
+# Streaming wrapper
+# ---------------------------------------------------------------------------
+
+
+class _OpenAIStreamingWrapper:
+    """
+    Thin wrapper around the raw OpenAI streaming response.
+    Accumulates text while yielding chunks, then fires capture and records the
+    outcome in the Reasoning Plus Learning layer on close.
+    """
+
+    def __init__(
+        self,
+        raw_stream: Any,
+        completions_obj: "DevTorchOpenAI._Completions",
+        session_id: str,
+        call_id: str = "",
+        prompt_text: str = "",
+        model_name: str = "",
+    ) -> None:
+        self._raw = raw_stream
+        self._comps = completions_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:
+                try:
+                    delta = chunk.choices[0].delta if chunk.choices else None
+                    if delta and hasattr(delta, "content") and delta.content:
+                        self._accumulated_text += delta.content
+                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) -> "_OpenAIStreamingWrapper":
+        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._comps._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._comps._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)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._raw, name)
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _extract_text(response: Any) -> str:
+    """Pull plain text from an OpenAI chat completion response."""
+    text = ""
+    try:
+        choices = getattr(response, "choices", None)
+        if choices:
+            msg = choices[0].message
+            if isinstance(getattr(msg, "content", None), str):
+                text += msg.content
+            # o1/o3 reasoning_content
+            reasoning = getattr(msg, "reasoning_content", None)
+            if isinstance(reasoning, str):
+                text += "\n" + reasoning
+    except Exception:
+        pass
+    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]