devtorch-core 3.0.1__py3-none-any.whl

devtorch_core/proxy/routes/anthropic.py

@@ -0,0 +1,264 @@
+"""
+DevTorch proxy route: Anthropic
+
+/anthropic/{path} → https://api.anthropic.com/{path}
+
+Request pipeline:
+  1. Parse body as JSON.
+  2. Inject RACP system prefix into body["system"].
+  3. Forward to api.anthropic.com with original headers (x-api-key passed through).
+  4. Stream chunks back while buffering.
+  5. After stream closes, schedule .GCC/ capture as non-blocking asyncio task.
+
+All errors degrade gracefully — the original LLM response is always returned.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+import uuid
+from typing import Any
+
+logger = logging.getLogger("devtorch.proxy.anthropic")
+
+UPSTREAM = "https://api.anthropic.com"
+
+
+# ---------------------------------------------------------------------------
+# Lightweight RACP prefix builder (no import from wrapper.base to avoid circulars)
+# ---------------------------------------------------------------------------
+
+def _build_racp_prefix(gcc_repo: Any) -> str:
+    """
+    Build the RACP system prefix from a GCCRepository instance.
+    Returns empty string on any error so callers can safely concatenate.
+    """
+    if gcc_repo is None:
+        return ""
+
+    parts: list[str] = []
+
+    # 1. RACP canonical system prompt
+    try:
+        racp_prompt = gcc_repo.prompt_get()
+        if racp_prompt:
+            parts.append(racp_prompt.strip())
+    except Exception as exc:
+        logger.debug("devtorch proxy: prompt_get failed — %s", exc)
+
+    # 2. Θ top-10 concepts by mean_confidence
+    try:
+        theta = gcc_repo.get_theta()
+        cv = theta.get("coordination_vector", {})
+        if cv:
+            def _mean_conf(entry: Any) -> float:
+                if isinstance(entry, dict):
+                    return float(entry.get("mean_confidence", 0.0))
+                return 0.0
+
+            top = sorted(cv.items(), key=lambda kv: _mean_conf(kv[1]), reverse=True)[:10]
+            if top:
+                lines = ["[DevTorch Θ — top concepts]"]
+                for concept, data in top:
+                    conf = _mean_conf(data)
+                    lines.append(f"  {concept}: mean_confidence={conf:.3f}")
+                parts.append("\n".join(lines))
+    except Exception as exc:
+        logger.debug("devtorch proxy: theta_summary failed — %s", exc)
+
+    # 3. Context bundle summary
+    try:
+        bundle = gcc_repo.context_bundle(
+            k_tokens=8000,
+            policy={"sensitivity_policy": "default"},
+        )
+        artifacts = bundle.get("artifacts", [])
+        if artifacts:
+            lines = ["[DevTorch context bundle]"]
+            for art in artifacts:
+                path = art.get("path", "?")
+                reason = art.get("reason", "")
+                lines.append(f"  - {path}: {reason}" if reason else f"  - {path}")
+            parts.append("\n".join(lines))
+    except Exception as exc:
+        logger.debug("devtorch proxy: context_bundle failed — %s", exc)
+
+    return "\n\n".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Capture helper
+# ---------------------------------------------------------------------------
+
+def _schedule_capture(gcc_repo: Any, response_text: str, session_id: str) -> None:
+    """Schedule .GCC/ capture as a fire-and-forget asyncio task."""
+    async def _do_capture() -> None:
+        try:
+            from devtorch_core.wrapper.base import CaptureOrchestrator
+            orchestrator = CaptureOrchestrator(gcc_repo)
+            orchestrator.capture(
+                response_text=response_text,
+                thinking_blocks=[],
+                session_id=session_id,
+            )
+        except Exception as exc:
+            logger.warning("devtorch proxy: capture failed — %s", exc)
+
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            asyncio.ensure_future(_do_capture())
+        else:
+            loop.run_until_complete(_do_capture())
+    except Exception as exc:
+        logger.warning("devtorch proxy: could not schedule capture — %s", exc)
+
+
+# ---------------------------------------------------------------------------
+# Route handler
+# ---------------------------------------------------------------------------
+
+async def proxy_anthropic(path: str, request: "Any", gcc_repo: Any) -> "Any":
+    """
+    Proxy /anthropic/{path} → https://api.anthropic.com/{path}
+    """
+    try:
+        from fastapi import Response
+        from fastapi.responses import StreamingResponse
+        import httpx
+    except ImportError:
+        raise RuntimeError("proxy deps not installed: pip install devtorch[proxy]")
+
+    # -----------------------------------------------------------------------
+    # 1. Read request body
+    # -----------------------------------------------------------------------
+    try:
+        body_bytes = await request.body()
+        body: dict = json.loads(body_bytes) if body_bytes else {}
+    except Exception:
+        body = {}
+        body_bytes = b""
+
+    # -----------------------------------------------------------------------
+    # 2. Inject RACP prefix into body["system"]
+    # -----------------------------------------------------------------------
+    modified_body = body
+    injection_failed = False
+    try:
+        if gcc_repo is not None and gcc_repo.is_initialized():
+            prefix = _build_racp_prefix(gcc_repo)
+            if prefix:
+                existing = body.get("system", "")
+                separator = "\n\n" if existing else ""
+                modified_body = {**body, "system": prefix + separator + existing}
+    except Exception as exc:
+        logger.warning("devtorch proxy: RACP injection failed — %s", exc)
+        injection_failed = True
+        modified_body = body
+
+    send_body = json.dumps(modified_body).encode() if modified_body else body_bytes
+
+    # -----------------------------------------------------------------------
+    # 3. Build forwarding headers (replace host, keep everything else)
+    # -----------------------------------------------------------------------
+    forward_headers = {
+        k: v for k, v in request.headers.items()
+        if k.lower() not in ("host", "content-length", "transfer-encoding")
+    }
+    forward_headers["host"] = "api.anthropic.com"
+    if send_body:
+        forward_headers["content-length"] = str(len(send_body))
+
+    upstream_url = f"{UPSTREAM}/{path}"
+    if request.url.query:
+        upstream_url = f"{upstream_url}?{request.url.query}"
+
+    session_id = str(uuid.uuid4())[:8]
+    is_streaming = bool(modified_body.get("stream", False))
+
+    # -----------------------------------------------------------------------
+    # 4 & 5. Stream or buffer response; schedule capture after completion
+    # -----------------------------------------------------------------------
+    if is_streaming:
+        async def _stream_generator():
+            buffer_parts: list[bytes] = []
+            try:
+                async with httpx.AsyncClient(timeout=300.0) as client:
+                    async with client.stream(
+                        method=request.method,
+                        url=upstream_url,
+                        headers=forward_headers,
+                        content=send_body,
+                    ) as upstream_resp:
+                        async for chunk in upstream_resp.aiter_bytes():
+                            buffer_parts.append(chunk)
+                            yield chunk
+            except Exception as exc:
+                logger.warning("devtorch proxy: streaming error — %s", exc)
+
+            # After stream done, fire capture
+            full_text = b"".join(buffer_parts).decode("utf-8", errors="replace")
+            _schedule_capture(gcc_repo, full_text, session_id)
+
+        response_headers = {}
+        # We can't get upstream status before streaming; return 200 with streamed content
+        return StreamingResponse(
+            _stream_generator(),
+            media_type="text/event-stream",
+            headers=response_headers,
+        )
+    else:
+        # Non-streaming: buffer the full response
+        try:
+            async with httpx.AsyncClient(timeout=300.0) as client:
+                upstream_resp = await client.request(
+                    method=request.method,
+                    url=upstream_url,
+                    headers=forward_headers,
+                    content=send_body,
+                )
+
+            # Schedule capture after receiving full response
+            try:
+                resp_text = upstream_resp.text
+                _schedule_capture(gcc_repo, resp_text, session_id)
+            except Exception:
+                pass
+
+            # Filter hop-by-hop headers
+            excluded = {"transfer-encoding", "content-encoding", "content-length"}
+            resp_headers = {
+                k: v for k, v in upstream_resp.headers.items()
+                if k.lower() not in excluded
+            }
+            return Response(
+                content=upstream_resp.content,
+                status_code=upstream_resp.status_code,
+                headers=resp_headers,
+                media_type=upstream_resp.headers.get("content-type", "application/json"),
+            )
+        except Exception as exc:
+            logger.warning("devtorch proxy: upstream request failed — %s", exc)
+            # Forward original unmodified request as fallback
+            try:
+                async with httpx.AsyncClient(timeout=300.0) as client:
+                    fallback_resp = await client.request(
+                        method=request.method,
+                        url=upstream_url,
+                        headers=forward_headers,
+                        content=body_bytes,
+                    )
+                return Response(
+                    content=fallback_resp.content,
+                    status_code=fallback_resp.status_code,
+                    media_type=fallback_resp.headers.get("content-type", "application/json"),
+                )
+            except Exception as exc2:
+                logger.error("devtorch proxy: fallback also failed — %s", exc2)
+                return Response(
+                    content=json.dumps({"error": "proxy error", "detail": str(exc2)}).encode(),
+                    status_code=502,
+                    media_type="application/json",
+                )

devtorch_core/proxy/routes/azure_openai.py

@@ -0,0 +1,336 @@
+"""
+DevTorch proxy route: Azure OpenAI
+
+/azure-openai/{path} → {AZURE_OPENAI_ENDPOINT}/{path}?api-version={...}
+
+The Azure OpenAI endpoint and API version are resolved from request headers
+first, then environment variables:
+  - AZURE_OPENAI_ENDPOINT (e.g. https://myresource.openai.azure.com)
+  - AZURE_OPENAI_API_VERSION (e.g. 2024-06-01)
+
+If the caller passes X-Azure-OpenAI-Endpoint and X-Azure-OpenAI-Api-Version
+headers, those override the environment. The api-key header is passed through
+unchanged.
+
+RACP is injected as a system message at position 0 in body["messages"], just
+like the OpenAI route.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import uuid
+from typing import Any
+
+logger = logging.getLogger("devtorch.proxy.azure_openai")
+
+DEFAULT_API_VERSION = "2024-06-01"
+
+
+# ---------------------------------------------------------------------------
+# Endpoint resolution
+# ---------------------------------------------------------------------------
+
+def _resolve_endpoint(request: "Any") -> tuple[str, str]:
+    """
+    Resolve (endpoint, api_version) from headers or environment.
+    """
+    headers = {k.lower(): v for k, v in request.headers.items()}
+    endpoint = headers.get("x-azure-openai-endpoint", "")
+    api_version = headers.get("x-azure-openai-api-version", "")
+
+    if not endpoint:
+        endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT", "")
+    if not api_version:
+        api_version = os.environ.get("AZURE_OPENAI_API_VERSION", DEFAULT_API_VERSION)
+
+    return endpoint.rstrip("/"), api_version
+
+
+# ---------------------------------------------------------------------------
+# Lightweight RACP prefix builder
+# ---------------------------------------------------------------------------
+
+def _build_racp_prefix(gcc_repo: Any) -> str:
+    if gcc_repo is None:
+        return ""
+
+    parts: list[str] = []
+
+    try:
+        racp_prompt = gcc_repo.prompt_get()
+        if racp_prompt:
+            parts.append(racp_prompt.strip())
+    except Exception as exc:
+        logger.debug("devtorch proxy[azure_openai]: prompt_get failed — %s", exc)
+
+    try:
+        theta = gcc_repo.get_theta()
+        cv = theta.get("coordination_vector", {})
+        if cv:
+            def _mean_conf(entry: Any) -> float:
+                if isinstance(entry, dict):
+                    return float(entry.get("mean_confidence", 0.0))
+                return 0.0
+
+            top = sorted(cv.items(), key=lambda kv: _mean_conf(kv[1]), reverse=True)[:10]
+            if top:
+                lines = ["[DevTorch Θ — top concepts]"]
+                for concept, data in top:
+                    conf = _mean_conf(data)
+                    lines.append(f"  {concept}: mean_confidence={conf:.3f}")
+                parts.append("\n".join(lines))
+    except Exception as exc:
+        logger.debug("devtorch proxy[azure_openai]: theta_summary failed — %s", exc)
+
+    try:
+        bundle = gcc_repo.context_bundle(
+            k_tokens=8000,
+            policy={"sensitivity_policy": "default"},
+        )
+        artifacts = bundle.get("artifacts", [])
+        if artifacts:
+            lines = ["[DevTorch context bundle]"]
+            for art in artifacts:
+                path = art.get("path", "?")
+                reason = art.get("reason", "")
+                lines.append(f"  - {path}: {reason}" if reason else f"  - {path}")
+            parts.append("\n".join(lines))
+    except Exception as exc:
+        logger.debug("devtorch proxy[azure_openai]: context_bundle failed — %s", exc)
+
+    return "\n\n".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Capture helper
+# ---------------------------------------------------------------------------
+
+def _schedule_capture(gcc_repo: Any, response_text: str, session_id: str) -> None:
+    async def _do_capture() -> None:
+        try:
+            from devtorch_core.wrapper.base import CaptureOrchestrator
+            orchestrator = CaptureOrchestrator(gcc_repo)
+            orchestrator.capture(
+                response_text=response_text,
+                thinking_blocks=[],
+                session_id=session_id,
+            )
+        except Exception as exc:
+            logger.warning("devtorch proxy[azure_openai]: capture failed — %s", exc)
+
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            asyncio.ensure_future(_do_capture())
+        else:
+            loop.run_until_complete(_do_capture())
+    except Exception as exc:
+        logger.warning("devtorch proxy[azure_openai]: could not schedule capture — %s", exc)
+
+
+# ---------------------------------------------------------------------------
+# SSE accumulator: extract assistant text from streamed chunks
+# ---------------------------------------------------------------------------
+
+def _extract_text_from_sse(raw: str) -> str:
+    """
+    Parse SSE stream and concatenate content delta text for capture.
+    """
+    parts: list[str] = []
+    for line in raw.splitlines():
+        line = line.strip()
+        if not line.startswith("data:"):
+            continue
+        data_str = line[5:].strip()
+        if data_str == "[DONE]":
+            break
+        try:
+            obj = json.loads(data_str)
+            for choice in obj.get("choices", []):
+                delta = choice.get("delta", {})
+                content = delta.get("content", "")
+                if content:
+                    parts.append(content)
+        except Exception:
+            pass
+    return "".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Route handler
+# ---------------------------------------------------------------------------
+
+async def proxy_azure_openai(path: str, request: "Any", gcc_repo: Any) -> "Any":
+    """
+    Proxy /azure-openai/{path} → Azure OpenAI endpoint.
+    """
+    try:
+        from fastapi import Response
+        from fastapi.responses import StreamingResponse
+        import httpx
+    except ImportError:
+        raise RuntimeError("proxy deps not installed: pip install devtorch[proxy]")
+
+    # -----------------------------------------------------------------------
+    # 1. Read request body
+    # -----------------------------------------------------------------------
+    try:
+        body_bytes = await request.body()
+        body: dict = json.loads(body_bytes) if body_bytes else {}
+    except Exception:
+        body = {}
+        body_bytes = b""
+
+    # -----------------------------------------------------------------------
+    # 2. Resolve endpoint and inject RACP
+    # -----------------------------------------------------------------------
+    endpoint, api_version = _resolve_endpoint(request)
+    if not endpoint:
+        return Response(
+            content=json.dumps(
+                {"error": "missing Azure OpenAI endpoint", "detail": "Set AZURE_OPENAI_ENDPOINT or X-Azure-OpenAI-Endpoint header"}
+            ).encode(),
+            status_code=400,
+            media_type="application/json",
+        )
+
+    modified_body = body
+    try:
+        if gcc_repo is not None and gcc_repo.is_initialized():
+            prefix = _build_racp_prefix(gcc_repo)
+            if prefix:
+                messages = list(body.get("messages", []))
+                racp_msg = {"role": "system", "content": prefix}
+                if messages and messages[0].get("role") == "system":
+                    existing_content = messages[0].get("content", "")
+                    messages[0] = {
+                        "role": "system",
+                        "content": prefix + "\n\n" + existing_content,
+                    }
+                else:
+                    messages.insert(0, racp_msg)
+                modified_body = {**body, "messages": messages}
+    except Exception as exc:
+        logger.warning("devtorch proxy[azure_openai]: RACP injection failed — %s", exc)
+        modified_body = body
+
+    send_body = json.dumps(modified_body).encode() if modified_body else body_bytes
+
+    # -----------------------------------------------------------------------
+    # 3. Build forwarding headers
+    # -----------------------------------------------------------------------
+    forward_headers = {
+        k: v for k, v in request.headers.items()
+        if k.lower() not in (
+            "host",
+            "content-length",
+            "transfer-encoding",
+            "x-azure-openai-endpoint",
+            "x-azure-openai-api-version",
+        )
+    }
+    try:
+        host = endpoint.split("//", 1)[1].split("/", 1)[0]
+    except Exception:
+        host = endpoint
+    forward_headers["host"] = host
+    if send_body:
+        forward_headers["content-length"] = str(len(send_body))
+
+    upstream_url = f"{endpoint}/{path}" if path else endpoint
+    if request.url.query:
+        upstream_url = f"{upstream_url}?{request.url.query}"
+    else:
+        upstream_url = f"{upstream_url}?api-version={api_version}"
+
+    session_id = str(uuid.uuid4())[:8]
+    is_streaming = bool(modified_body.get("stream", False))
+
+    # -----------------------------------------------------------------------
+    # 4 & 5. Stream or buffer
+    # -----------------------------------------------------------------------
+    if is_streaming:
+        async def _stream_generator():
+            buffer_parts: list[bytes] = []
+            try:
+                async with httpx.AsyncClient(timeout=300.0) as client:
+                    async with client.stream(
+                        method=request.method,
+                        url=upstream_url,
+                        headers=forward_headers,
+                        content=send_body,
+                    ) as upstream_resp:
+                        async for chunk in upstream_resp.aiter_bytes():
+                            buffer_parts.append(chunk)
+                            yield chunk
+            except Exception as exc:
+                logger.warning("devtorch proxy[azure_openai]: streaming error — %s", exc)
+
+            raw_text = b"".join(buffer_parts).decode("utf-8", errors="replace")
+            extracted = _extract_text_from_sse(raw_text)
+            _schedule_capture(gcc_repo, extracted or raw_text, session_id)
+
+        return StreamingResponse(
+            _stream_generator(),
+            media_type="text/event-stream",
+        )
+    else:
+        try:
+            async with httpx.AsyncClient(timeout=300.0) as client:
+                upstream_resp = await client.request(
+                    method=request.method,
+                    url=upstream_url,
+                    headers=forward_headers,
+                    content=send_body,
+                )
+
+            try:
+                resp_json = upstream_resp.json()
+                text_parts: list[str] = []
+                for choice in resp_json.get("choices", []):
+                    msg = choice.get("message", {})
+                    content = msg.get("content", "")
+                    if content:
+                        text_parts.append(content)
+                resp_text = "\n".join(text_parts) or upstream_resp.text
+            except Exception:
+                resp_text = upstream_resp.text
+
+            _schedule_capture(gcc_repo, resp_text, session_id)
+
+            excluded = {"transfer-encoding", "content-encoding", "content-length"}
+            resp_headers = {
+                k: v for k, v in upstream_resp.headers.items()
+                if k.lower() not in excluded
+            }
+            return Response(
+                content=upstream_resp.content,
+                status_code=upstream_resp.status_code,
+                headers=resp_headers,
+                media_type=upstream_resp.headers.get("content-type", "application/json"),
+            )
+        except Exception as exc:
+            logger.warning("devtorch proxy[azure_openai]: upstream request failed — %s", exc)
+            try:
+                async with httpx.AsyncClient(timeout=300.0) as client:
+                    fallback_resp = await client.request(
+                        method=request.method,
+                        url=upstream_url,
+                        headers=forward_headers,
+                        content=body_bytes,
+                    )
+                return Response(
+                    content=fallback_resp.content,
+                    status_code=fallback_resp.status_code,
+                    media_type=fallback_resp.headers.get("content-type", "application/json"),
+                )
+            except Exception as exc2:
+                logger.error("devtorch proxy[azure_openai]: fallback also failed — %s", exc2)
+                return Response(
+                    content=json.dumps({"error": "proxy error", "detail": str(exc2)}).encode(),
+                    status_code=502,
+                    media_type="application/json",
+                )