vantasnerdan-claude-code-xai-21-22

84a8c1d base

"""Claude Code xAI Bridge -- Anthropic Messages API to xAI Grok proxy.

Receives Claude Code traffic on /v1/messages, translates to OpenAI format,
forwards to xAI, translates response back. Enrichment hooks inject Agentic
API Standard context.
"""

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, StreamingResponse
import httpx
import os
import json

import time
import logging
from dotenv import load_dotenv

from translation.forward import anthropic_to_openai, strip_thinking
from translation.reverse import translate_response
from translation.streaming import OpenAIToAnthropicStreamAdapter
from translation.tools import set_tool_enrichment_hook
from enrichment.factory import create_enricher

load_dotenv()
logger = logging.getLogger(__name__)

app = FastAPI(title="xai-agentic-claude-bridge")
XAI_API_KEY = os.getenv("XAI_API_KEY", "")
if not XAI_API_KEY:
    
…[3059 chars omitted]…
 'unknown')}\ndata: {json.dumps(event)}\n\n"

    response_headers = {}
    if bridge_warnings:
        response_headers["X-Bridge-Warning"] = "; ".join(bridge_warnings)
    return StreamingResponse(gen(), media_type="text/event-stream", headers=response_headers)


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host=os.getenv("HOST", "0.0.0.0"), port=int(os.getenv("PORT", "4000")))

"""Tool enrichment engine.

Applies the Agentic API Standard patterns and behavioral training transfer
to tool definitions before they're sent to the model. This is what makes
the bridge a universal upgrade layer rather than just a format translator.

Architecture:
  Layer 1 — Structural: Independent pattern applicators from the API standard
  Layer 2 — Behavioral: WHAT/WHY/WHEN knowledge from Claude Code's training

Both layers are composable and configurable via EnrichmentConfig.
"""

import copy
from typing import Any

from enrichment.config import EnrichmentConfig
from enrichment.structural.base import PatternApplicator
from enrichment.behavioral.base import BehavioralEnricher


class ToolEnricher:
    """Pipeline orchestrator for tool enrichment.

    Applies structural patterns (API standard) and behavioral knowledge
    (training transfer) to tool definitions in sequence.
    ""
…[1748 chars omitted]…
ioral(self, enricher: BehavioralEnricher) -> bool:
        """Check if a behavioral enricher is enabled in config."""
        dimension = enricher.dimension
        if dimension == "what":
            return self.config.enable_what
        elif dimension == "why":
            return self.config.enable_why
        elif dimension == "when":
            return self.config.enable_when
        return False

[project]
name = "claude-code-xai"
version = "0.1.0"
description = "Claude Code to xAI bridge with Agentic API Standard enrichment"
requires-python = ">=3.11"

[tool.pytest.ini_options]
pythonpath = ["."]
testpaths = ["tests"]
fastapi==0.115.0
uvicorn[standard]==0.30.6
httpx==0.27.0

python-dotenv==1.0.1
pytest==8.3.4
pytest-asyncio==0.24.0
XAI_API_KEY=sk-...
GROK_MODEL=grok-4-1-fast-reasoning
HOST=0.0.0.0
PORT=4000
ENRICHMENT_MODE=full           # passthrough | structural | full
PREAMBLE_ENABLED=true          # false to disable system prompt behavioral injection

"""Integration test: enrichment engine wired into the translation pipeline."""
import pytest
from enrichment.factory import create_enricher
from translation.tools import set_tool_enrichment_hook, translate_tools


class TestEnrichmentIntegration:
    """Verify enrichment engine integrates with translation layer."""

    def setup_method(self):
        """Reset the enrichment hook before each test."""
        set_tool_enrichment_hook(None)

    def test_enricher_wires_into_translation_hook(self):
        """ToolEnricher.enrich can be used as the enrichment hook."""
        enricher = create_enricher(mode="full")
        set_tool_enrichment_hook(enricher.enrich)

        tools = [{"name": "Read", "description": "Reads files", "input_schema": {"type": "object", "properties": {"file_path": {"type": "string"}}}}]
        result = translate_tools(tools)

        assert len(result) == 1
    
…[8629 chars omitted]…
["input"]["file_path"] == "/tmp/test.py"


class TestEnrichmentModeToggle:
    """Verify enrichment modes produce different results."""

    def test_passthrough_adds_no_fields(self) -> None:
        from enrichment.factory import create_enricher
        enricher = create_enricher(mode="passthrough")
        tools = [{"name": "Read", "description": "Reads a file.", "input_schema": {"type": "object"}}]

"""Root conftest.py — shared pytest fixtures for all test modules.

Provides foundational fixtures used across the entire test suite:
tool definitions, sample requests, and sample responses.
"""

import pytest
from typing import Any


@pytest.fixture
def sample_tools() -> list[dict[str, Any]]:

    """Claude Code tool definitions with name, description, and input_schema.

    These mirror the actual tool schemas that Claude Code sends in the
    Anthropic Messages API. They are the contract that the translation
    layer must preserve.
    """
    return [
        {
            "name": "Read",
            "description": "Reads a file from the local filesystem.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "file_path": {
                        "type": "string",
                        "description": "The absolute p
…[8629 chars omitted]…
= True
    enable_why: bool = True
    enable_when: bool = True

    @property
    def is_passthrough(self) -> bool:
        """True if enrichment is completely disabled (benchmark mode)."""
        return self.mode == "passthrough"

    @property
    def include_behavioral(self) -> bool:
        """True if behavioral enrichment should be applied (full mode only)."""
        return self.mode == "full"

"""End-to-end tests for the bridge application.

Tests bridge startup, endpoint responses, enrichment mode toggling,
error handling, and request translation — all without requiring a live
xAI API key.
"""

from __future__ import annotations

import json
import os
from unittest.mock import AsyncMock, MagicMock, patch

import pytest
from fastapi.testclient import TestClient

from main import app


@pytest.fixture
def client():
    """TestClient for the bridge app."""
    return TestClient(app)


def _mock_xai_response(data: dict, status_code: int = 200):
    """Create a mock httpx response that works with async client."""
    mock_resp = MagicMock()
    mock_resp.status_code = status_code
    mock_resp.json.return_value = data

    async def mock_post(*args, **kwargs):
        return mock_resp

    return mock_post, mock_resp


class TestBridgeStartup:
    """Verify the bridge starts an
…[8629 chars omitted]…
ENTITY_ENABLED", None)
            import importlib
            import enrichment.system_preamble
            importlib.reload(enrichment.system_preamble)
            from enrichment.system_preamble import get_system_preamble
            result = get_system_preamble()
            assert len(result) > 0
            assert "Tool Preference Hierarchy" in result
            assert "You are Grok" in result

# claude-code-xai

**A universal upgrade layer for model tool calling, proven across two frontier models.**

Claude Code runs natively on Grok through bidirectional protocol translation and structured tool enrichment. The same enrichment applied to any model — including Claude itself — measurably improves tool calling accuracy.

Built on the [Agentic API Standard](https://github.com/nexus-marbell/agentic-api-standard): 20 design patterns for self-describing, machine-first interfaces.

---

## The Problem

Large language models learn tool calling through reinforcement learning. The learned behaviors are implicit — baked into weights, not visible in the API. When a model encounters a new tool ecosystem, it has no training signal to draw on. Tool definitions ship as minimal JSON Schema: a name, a description, a parameter list. No sequencing rules. No failure modes. No context about when 
…[8629 chars omitted]…
     "use_before": ["Edit", "Write"],
            "use_instead_of": ["Bash cat", "Bash head", "Bash tail"],
            "sequencing": "Use after Glob/Grep to find files, before Edit to modify them."
        }
    }
}
```

The model now knows *what* the tool does, *why* it matters, and *when* to use it — the same knowledge that Claude learns through RL training, made explicit and portable.

## Testing

def test_preamble_contains_parallel_rules(self) -> None:
        """Behavioral preamble covers parallel vs sequential execution."""
        assert "Parallel vs Sequential" in _PREAMBLE
        assert "INDEPENDENT" in _PREAMBLE
        assert "DEPENDENT" in _PREAMBLE

    def test_preamble_contains_safety_patterns(self) -> None:
        """Behavioral preamble covers safety patterns."""
        assert "Safety Patterns" in _PREAMBLE
        assert "force push" in _PREAMBLE
        assert "credentials" in _PREAMBLE

    def test_preamble_contains_output_conventions(self) -> None:
        """Behavioral preamble covers output conventions."""
        assert "Output Conventions" in _PREAMBLE
        assert "source of truth" in _PREAMBLE


class TestStripAnthropicIdentity:
    """Tests for strip_anthropic_identity()."""

    def test_strips_powered_by_model_named(self) -> None:
        ""
…[8629 chars omitted]…
havioral preamble covers parallel vs sequential execution."""
        assert "Parallel vs Sequential" in _PREAMBLE
        assert "INDEPENDENT" in _PREAMBLE
        assert "DEPENDENT" in _PREAMBLE

    def test_preamble_contains_safety_patterns(self) -> None:
        """Behavioral preamble covers safety patterns."""
        assert "Safety Patterns" in _PREAMBLE
        assert "force push" in _PREAMBLE

Refused: `find /` walks the whole container FS. Scope under /repo.

'You are powered by the model named Claude Opus 4.5.' -> '5.'
'You are powered by the model named Claude Opus 4.5. The exact model ID is claude-opus-4-5-20251101.' -> '5.'
'You are powered by Claude Opus 4.5. The exact model ID is claude-opus-4-5-20251101.' -> '5.'
'You are Claude, version claude-sonnet-4-20250514.' -> 'You are Claude, version claude-sonnet-4-20250514.'
'You are Claude Code, version 2.0.0.' -> 'You are Claude Code, version 2.0.0.'
'You are powered by the model named Claude Opus 4.6 (model ID: claude-opus-4-6).' -> '6 (model ID: claude-opus-4-6).'
'You are powered by Claude 3.5 Sonnet.' -> '5 Sonnet.'
'You are Claude Opus 4.6, made by Anthropic.' -> 'You are Claude Opus 4.6, made by Anthropic.'
'Claude Opus 4.6' -> 'Claude Opus 4.6'

timeout: failed to run command ‘curl’: No such file or directory

URLError <urlopen error [Errno -3] Temporary failure in name resolution>

"""Streaming SSE: OpenAI delta stream -> Anthropic event stream."""
from __future__ import annotations
import json, uuid
from typing import Any, AsyncIterator
from translation.config import STOP_REASON_MAP


def _msg_start(chunk: dict[str, Any] | None = None) -> dict[str, Any]:
    c = chunk or {}
    cid = c.get("id", f"msg_{uuid.uuid4().hex[:24]}")
    return {"type": "message_start", "message": {
        "id": f"msg_{cid}" if not cid.startswith("msg_") else cid,

        "type": "message", "role": "assistant", "content": [],
        "model": c.get("model", "grok-4-1-fast-reasoning"),
        "stop_reason": None, "stop_sequence": None,
        "usage": {"input_tokens": 0, "output_tokens": 1}}}


def _close(reason: str, usage: dict[str, Any] | None = None) -> list[dict[str, Any]]:
    return [{"type": "message_delta", "delta": {"stop_reason": STOP_REASON_MAP.get(reason, "end_turn"),
 
…[8629 chars omitted]…
"
        async def failing_source() -> AsyncIterator[str]:
            yield 'data: {"id":"test","object":"chat.completion.chunk","created":1709000300,"model":"grok-4-1-fast-reasoning","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}'
            raise ConnectionError("Connection reset by peer")

        adapter = OpenAIToAnthropicStreamAdapter(failing_source())

/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
........................................................................ [ 23%]
........................................................................ [ 46%]
........................................................................ [ 69%]
........................................................................ [ 92%]
.......................                                                  [100%]
311 passed, 1 warning in 2.33s

operating through the Claude Code interface.
"""

# Patterns that assert Anthropic/Claude model identity in system prompts.
# These are stripped from the system text before forwarding to Grok.
_ANTHROPIC_IDENTITY_PATTERNS: list[re.Pattern[str]] = [
    # "You are powered by the model named Claude Opus 4.6..."
    # The sentence-ending period is matched only when followed by whitespace
    # or the end of the string.  This keeps periods inside version numbers
    # (e.g. "Opus 4.5") from being mistaken for the end of the claim and
    # leaving residual text such as "5." behind.
    re.compile(

        r"You are powered by the model named[^\n]*?\.(?=\s|$)\s*"
        r"(?:The exact model ID is[^\n]*?\.(?=\s|$)\s*)?",
        re.IGNORECASE,
    ),
    # "You are powered by Claude Opus 4.6" (shorter variant)
    re.compile(
        r"You are powered by Claude[^\n]*?\.(?=\s|$)\s*",
      
…[4456 chars omitted]…
e text to inject. If empty, returns messages unchanged.

    Returns:
        A new message list with the preamble injected. Never mutates the input.
    """
    if not preamble:
        return messages

    result = list(messages)

    if result and result[0].get("role") == "system":
        existing = result[0].get("content", "")
        merged = f"{preamble}\n\n{existing}" if existing else preamble

"""Forward translation: Anthropic Messages API -> OpenAI Chat Completions API.

Handles system prompt extraction, content block flattening, tool_use
to tool_calls, and tool_result to tool role messages.
"""

from __future__ import annotations

import json
from typing import Any

from bridge.logging_config import get_logger

from translation.config import TranslationConfig, UNSUPPORTED_FEATURES, STRIPPED_FEATURES
from translation.tools import translate_tools as _translate_tools
from enrichment.system_preamble import strip_anthropic_identity

# Re-export so tests can import from translation.forward
translate_tools = _translate_tools

_config = TranslationConfig()
logger = get_logger("forward")

# Content block types that belong to Anthropic's thinking feature.
# These are stripped from messages when forwarding to xAI.
_THINKING_BLOCK_TYPES: frozenset[str] = frozenset({
    "thinking",
  
…[3480 chars omitted]…
    "max_tokens": request.get("max_tokens", _config.default_max_tokens),
        "temperature": request.get("temperature", _config.default_temperature),
        "stream": bool(request.get("stream")),
    }

    tools = request.get("tools")
    result["tools"] = _translate_tools(tools) if tools else None
    return result


def translate_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:

OK

"""Claude Code xAI Bridge -- Anthropic Messages API to xAI Grok proxy.

Receives Claude Code traffic on /v1/messages, translates to OpenAI format,
forwards to xAI, translates response back. Enrichment hooks inject Agentic
API Standard context.
"""

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, StreamingResponse
import httpx
import os
import json

import time
from dotenv import load_dotenv

from bridge.logging_config import (
    configure_logging,
    dump_json,
    get_logger,
    is_dump_enabled,
    sanitize_request,
)
from translation.forward import anthropic_to_openai, strip_thinking
from translation.reverse import translate_response
from translation.streaming import OpenAIToAnthropicStreamAdapter
from translation.tools import set_tool_enrichment_hook
from enrichment.factory import create_enricher

load_dotenv()
configure_logging()
logger = get_l
…[4761 chars omitted]…
 'unknown')}\ndata: {json.dumps(event)}\n\n"

    response_headers = {}
    if bridge_warnings:
        response_headers["X-Bridge-Warning"] = "; ".join(bridge_warnings)
    return StreamingResponse(gen(), media_type="text/event-stream", headers=response_headers)


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host=os.getenv("HOST", "0.0.0.0"), port=int(os.getenv("PORT", "4000")))

"""Tool enrichment engine.

Applies the Agentic API Standard patterns and behavioral training transfer
to tool definitions before they're sent to the model. This is what makes
the bridge a universal upgrade layer rather than just a format translator.

Architecture:
  Layer 1 — Structural: Independent pattern applicators from the API standard
  Layer 2 — Behavioral: WHAT/WHY/WHEN knowledge from Claude Code's training

Both layers are composable and configurable via EnrichmentConfig.
"""

import copy
from typing import Any

from bridge.logging_config import get_logger
from enrichment.config import EnrichmentConfig
from enrichment.structural.base import PatternApplicator
from enrichment.behavioral.base import BehavioralEnricher

logger = get_logger("enrichment")


class ToolEnricher:
    """Pipeline orchestrator for tool enrichment.

    Applies structural patterns (API standard) and beha
…[3723 chars omitted]…
] = {
    429: "Rate limited by xAI. Wait and retry, or reduce request frequency.",
    500: "xAI internal error. Retry the request. If persistent, simplify tool schemas.",
    400: "Invalid request format. Check message structure and tool definitions.",
    401: "Authentication failed. Verify XAI_API_KEY is set correctly.",
    403: "Access denied. Check API key permissions for the requested model.",

/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
........................................................................ [ 23%]
........................................................................ [ 46%]
........................................................................ [ 69%]
........................................................................ [ 92%]
.......................                                                  [100%]
311 passed, 1 warning in 1.54s

list result: [{'type': 'text', 'text': 'Keep me.', 'cache_control': {'type': 'ephemeral'}}, {'type': 'image', 'source': {'data': 'abc'}, 'cache_control': {'type': 'ephemeral'}}]
# Identity

You are Grok (xAI), running inside the Claude Code environment via the xAI bridge. The system prompt below comes from Claude Code and will refer to Claude, Anthropic, and specific Anthropi
Traceback (most recent call last):
  File "<stdin>", line 55, in <module>
AssertionError

'e current branch before committing\n- Confirm before irreversible actions — measure twice, cut once\n\n## 6. Output Conventions\n\n- Use tool results as the source of truth — never fabricate file contents or command output\n- Keep responses concise and focused on the task\n- Include file paths with line numbers when referencing code\n- Do not add comments, docstrings, or type annotations to code you did not change\n- Do not add emojis unless the user explicitly requests them\n\n\nFirst block.\n\nSecond block.'
False False True

('startswith', False)
('hier', True)
('blocks', True)
('4.5 absent', True)
('claude-opus absent', True)
system
'annotations to code you did not change\n- Do not add emojis unless the user explicitly requests them\n'
False

{'model': 'm', 'api_key': '[REDACTED]', 'headers': {'Authorization': '[REDACTED]', 'X-Api-Key': '[REDACTED]', 'Content-Type': 'application/json'}, 'nested': {'keep': 1}}
logging config tests OK

load_ssl_context verify=True cert=None trust_env=True http2=False
load_verify_locations cafile='/usr/local/lib/python3.12/site-packages/certifi/cacert.pem'
Enrichment mode: full
Using selector: EpollSelector
POST /v1/messages model=claude-sonnet-4-20250514 messages=1 tools=2
Enriching 2 tools: Read, Edit
Enrichment complete: structural_patterns=[1, 2, 3, 5, 6, 8, 14, 15]
Read fields added: ['_anti_patterns', '_error_format', '_links', '_manifest', '_near_miss', '_quality', '_registration', 'behavioral_what', 'behavioral_when', 'behavioral_why', 'outputSchema']
Edit fields added: ['_anti_patterns', '_error_format', '_links', '_manifest', '_near_miss', '_quality', '_registration', 'behavioral_what', 'behavioral_when', 'behavioral_why', 'outputSchema']
Translated request: {"model": "grok-4-1-fast-reasoning", "messages": [{"role": "system", "content": "# Identity\n\nYou are Grok (xAI), ru
…[599 chars omitted]…
 [{"id": "call_1", "type": "function", "function": {"name": "Read", "arguments": "{\"file_path\": \"/tmp/x\"}"}}]}, "finish_reason": "tool_calls"}], "usage": {"prompt_tokens": 20, "completion_tokens": 15, "total_tokens": 35}}

HTTP Request: POST http://testserver/v1/messages "HTTP/1.1 200 OK"
['request_20261106_214921_109128.json', 'response_20261106_214921_109716.json']
endpoint observability tests OK

./bridge/logging_config.py:125:    """Write *data* to a timestamped JSON file when dumping is enabled.
./bridge/logging_config.py:135:    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S_%f")
./bridge/logging_config.py:136:    path = directory / f"{kind}_{timestamp}.json"

2026-11-06 21:49:38,980 INFO [bridge.main] Enrichment mode: full
2026-11-06 21:49:38,993 INFO [bridge.main] POST /v1/messages model=claude-opus-4-5-20251101 messages=1 tools=0
2026-11-06 21:49:38,993 INFO [bridge.main] xAI response in 0.00s status=200 stop=stop tool_calls=0 tokens=1/2/3
2026-11-06 21:49:38,995 INFO [httpx] HTTP Request: POST http://testserver/v1/messages "HTTP/1.1 200 OK"
200 {'id': 'msg_x', 'type': 'message', 'role': 'assistant', 'content': [{'type': 'text', 'text': 'Hello!'}], 'model': 'grok-4-1-fast-reasoning', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 1, 'output_tokens': 2}}
# Identity

You are Grok (xAI), running inside the Claude Code environment via t
list system endpoint OK

"model": os.getenv("GROK_MODEL", "grok-4-1-fast-reasoning"),
        "enrichment_mode": enricher.config.mode,
    }


@app.post("/v1/messages", response_model=None)
async def messages(request: Request):
    body = await request.json()
    start = time.time()

    # Log the incoming Anthropic request as received (before translation).
    incoming_messages = body.get("messages") or []

    incoming_tools = body.get("tools") or []
    logger.info(
        "POST /v1/messages model=%s messages=%d tools=%d thinking=%s stream=%s",
        body.get("model", ""),
        len(incoming_messages),
        len(incoming_tools),
        bool(body.get("thinking")),
        bool(body.get("stream")),
    )

    try:
        bridge_warnings = strip_thinking(body)
        if bridge_warnings:
            for w in bridge_warnings:
                logger.info("Degraded feature: %s", w)

        openai_body = anthropic_to_openai(body)
        headers = {"Authorization": f"Bearer {XAI_API_KEY}", "Content-Type": "application/json"}

50:        assert "streaming" in data["capabilities"]
            assert len(captured_request["tools"]) == 1
            tool = captured_request["tools"][0]
            assert tool["type"] == "function"
            assert tool["function"]["name"] == "Read"

    def test_tool_use_response_translated(self, client: TestClient) -> None:
        """Verify tool_calls from Grok become Anthropic tool_use blocks."""
        mock_post, _ = _mock_xai_response({
            "id": "chatcmpl-789",
            "object": "chat.completion",
            "choices": [{

                "index": 0,
                "message": {
                    "role": "assistant",
                    "content": None,
                    "tool_calls": [{
                        "id": "call_abc123",
                        "type": "function",
                        "function": {
                            "name": "Read"
…[3904 chars omitted]…
ENTITY_ENABLED", None)
            import importlib
            import enrichment.system_preamble
            importlib.reload(enrichment.system_preamble)
            from enrichment.system_preamble import get_system_preamble
            result = get_system_preamble()
            assert len(result) > 0
            assert "Tool Preference Hierarchy" in result
            assert "You are Grok" in result

grep: tests/__pycache__/test_e2e.cpython-312-pytest-8.3.4.pyc: binary file matches

'You are powered by the model named Claude Opus 4.5.' -> ''
'You are powered by the model named Claude Opus 4.5. The exact model ID is claude-opus-4-5-20251101.' -> ''
'You are powered by Claude Opus 4.5. The exact model ID is claude-opus-4-5-20251101.' -> ''
'You are powered by Claude 3.5 Sonnet.' -> ''
'You are powered by the model named Claude 3.7 Sonnet. The exact model ID is claude-3-7-sonnet-20250219.' -> ''
'Before. You are powered by the model named Claude Opus 4.5. After.' -> 'Before. After.'
'Assistant knowledge cutoff is May 2025.' -> ''

async def gen():
        start = time.time()
        status_code = None
        finish_reason = None
        tool_call_indices: set = set()
        usage: dict = {}
        chunks: list[dict] = []

        async with client.stream("POST", "/chat/completions", json=openai_body, headers=headers) as resp:
            status_code = resp.status_code

            async def lines():

                nonlocal finish_reason
                async for line in resp.aiter_lines():
                    if not line:
                        continue
                    if line.startswith("data: "):
                        payload = line[6:].strip()
                        if payload and payload != "[DONE]":
                            try:
                                chunk = json.loads(payload)
                            except json.JSONDecodeError:
                                chunk = None
…[1911 chars omitted]…
            dump_json("response", chunks)

    response_headers = {}
    if bridge_warnings:
        response_headers["X-Bridge-Warning"] = "; ".join(bridge_warnings)
    return StreamingResponse(gen(), media_type="text/event-stream", headers=response_headers)


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host=os.getenv("HOST", "0.0.0.0"), port=int(os.getenv("PORT", "4000")))
OK

/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
........................................................................ [ 23%]
........................................................................ [ 46%]
........................................................................ [ 69%]
........................................................................ [ 92%]
.......................                                                  [100%]
311 passed, 1 warning in 1.45s

# Python bytecode
__pycache__/
__pycache__
*.pyc
*.pyo
*.pyd

# Distribution / packaging
*.egg-info/
*.egg
dist/
build/

.eggs/

# Virtual environments
.venv/
venv/

# Testing
.pytest_cache/

# Environment variables
.env
version: '3.9'
services:
  bridge:
    build: .
    ports:
      - "4000:4000"
    env_file: .env
    restart: unless-stopped
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "4000"]

'Be helpful.'
'Be helpful.'
'Be helpful.'

OK

# Layer 2: Behavioral enrichment (training transfer)
        if self.config.include_behavioral:
            for i, tool in enumerate(enriched):
                for enricher in self.behavioral_enrichers:
                    if self._should_apply_behavioral(enricher):
                        enriched[i] = enricher.enrich(enriched[i])

        applied_patterns = [
            type(pattern).__name__
            for pattern in self.structural_patterns
            if pattern.pattern_number in self.config.enabled_structural
        ]

        logger.debug(
            "Enrichment complete: structural_patterns=%s (%s)",
            sorted(self.config.enabled_structural),
            ", ".join(applied_patterns),
        )
        if self.config.include_behavioral:
            for i, tool in enumerate(enriched):
                before = original_fields[i] if i < len(original_fields) els
…[294 chars omitted]…
st[dict[str, Any]]) -> list[dict[str, Any]]:
        """Check tools for compliance with all enabled patterns.

        Returns list of issue dicts.
        """
        issues: list[dict[str, Any]] = []
        for pattern in self.structural_patterns:
            if pattern.pattern_number in self.config.enabled_structural:
                issues.extend(pattern.validate(tools))
        return issues

OK

/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
........................................................................ [ 23%]
........................................................................ [ 46%]
........................................................................ [ 69%]
........................................................................ [ 92%]
.......................                                                  [100%]
311 passed, 1 warning in 1.45s

/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
....                                                                     [100%]
4 passed, 1 warning in 0.34s

/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
.                                                                        [100%]
1 passed, 1 warning in 0.32s

GROK_MODEL=grok-4-1-fast-reasoning
HOST=0.0.0.0
PORT=4000
ENRICHMENT_MODE=full           # passthrough | structural | full
PREAMBLE_ENABLED=true          # false to disable system prompt behavioral injection
LOG_LEVEL=INFO                # DEBUG | INFO | WARNING | ERROR | CRITICAL
DUMP_REQUESTS=false            # true to write JSON request/response dumps
DUMP_DIR=dumps                 # directory for dumps when DUMP_REQUESTS=true
181:| `LOG_LEVEL` | `INFO` | Bridge log verbosity (`DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`) |
182:| `DUMP_REQUESTS` | `false` | Write sanitised JSON request/response dumps (`true`/`1`/`yes`) |
183:| `DUMP_DIR` | `dumps` | Directory for request/response dumps |

tests/smoke.py:10:  - Mock mode (default, no XAI_API_KEY): Uses mocked xAI responses for CI
tests/smoke.py:11:  - Live mode (XAI_API_KEY set): Sends real requests to xAI API
tests/smoke.py:15:    XAI_API_KEY=sk-... python tests/smoke.py  # live mode
tests/smoke.py:336:    api_key = os.getenv("XAI_API_KEY", "")
tests/smoke.py:337:    live = bool(api_key)
tests/smoke.py:341:    print(f"  Mode: {'LIVE (XAI_API_KEY set)' if live else 'MOCK (no XAI_API_KEY)'}")
tests/smoke.py:383:        r.skip("live.simple", "no XAI_API_KEY")
tests/smoke.py:384:        r.skip("live.with_tools", "no XAI_API_KEY")

diff --git a/.env.example b/.env.example
index a0d695b..6015fd1 100644
--- a/.env.example
+++ b/.env.example
@@ -4,3 +4,6 @@ HOST=0.0.0.0
 PORT=4000
 ENRICHMENT_MODE=full           # passthrough | structural | full
 PREAMBLE_ENABLED=true          # false to disable system prompt behavioral injection
+LOG_LEVEL=INFO                # DEBUG | INFO | WARNING | ERROR | CRITICAL
+DUMP_REQUESTS=false            # true to write JSON request/response dumps
+DUMP_DIR=dumps                 # directory for dumps when DUMP_REQUESTS=true
diff --git a/README.md b/README.md

index 5dcd995..3554ccf 100644
--- a/README.md
+++ b/README.md
@@ -178,6 +178,9 @@ python -m benchmarks --output-dir results/  # Save to directory
 | `GROK_MODEL` | `grok-4-1-fast-reasoning` | Grok model to use |
 | `ENRICHMENT_MODE` | `full` | `passthrough` / `structural` / `full` |
 | `PREAMBLE_ENABLED` | `true` | System prompt b
…[8629 chars omitted]…
24aef53 100644
--- a/translation/reverse.py
+++ b/translation/reverse.py
@@ -10,9 +10,11 @@ import json
 import uuid
 from typing import Any
 
+from bridge.logging_config import get_logger
 from translation.config import TranslationConfig, STOP_REASON_MAP
 
 _config = TranslationConfig()
+logger = get_logger("reverse")
 
 _ERROR_TYPE_MAP: dict[str, str] = {
     "rate_limit_error": "rate_limit_error",

/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
.                                                                        [100%]
1 passed, 1 warning in 0.33s

./manifest.json
 M .env.example
 M README.md
 M enrichment/engine.py
 M enrichment/system_preamble.py
 M main.py
 M translation/forward.py
 M translation/reverse.py
?? bridge/

warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
........................................................................ [ 23%]
........................................................................ [ 46%]
........................................................................ [ 69%]
........................................................................ [ 92%]
.......................                                                  [100%]
311 passed, 1 warning in 1.69s
/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
......                                                                   [100%]

6 passed, 1 warning in 0.38s

COMPILE_OK
 M .env.example
 M README.md
 M enrichment/engine.py
 M enrichment/system_preamble.py
 M main.py
 M translation/forward.py
 M translation/reverse.py
?? bridge/

2026-11-06 21:56:05,230 INFO [bridge.main] Enrichment mode: full
2026-11-06 21:56:05,244 INFO [bridge.main] POST /v1/messages model=m messages=1 tools=0 thinking=False stream=False
2026-11-06 21:56:05,245 ERROR [bridge.main] Bridge error: Expected str or list for system prompt, got int
Traceback (most recent call last):
  File "/repo/main.py", line 83, in messages
    openai_body = anthropic_to_openai(body)
                  ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/translation/forward.py", line 105, in anthropic_to_openai
    system = strip_anthropic_identity(request.get("system", ""))
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/enrichment/system_preamble.py", line 190, in strip_anthropic_identity
    raise TypeError(

TypeError: Expected str or list for system prompt, got int
2026-11-06 21:56:05,252 INFO [httpx] HTTP Request: POST http://testserver/v1/messages "HTTP/1.1 500 Internal Server Error"
500 {'type': 'error', 'error': {'type': 'api_error', 'message': 'Expected str or list for system prompt, got int', 'suggestion': 'Retry the request. Check XAI_API_KEY.'}, '_links': {'retry': {'href': '/v1/messages', 'method': 'POST'}, 'manifest': {'href': '/manifest'}}}
unsupported type response OK

tests/enrichment/test_system_preamble.py:219:    def test_strips_full_realistic_system_prompt(self) -> None:
tests/enrichment/test_system_preamble.py:288:    def test_prepends_to_existing_system_message(self) -> None:
tests/enrichment/test_system_preamble.py:299:    def test_inserts_system_message_when_none_exists(self) -> None:
tests/enrichment/test_system_preamble.py:323:    def test_empty_system_content_uses_preamble_only(self) -> None:
tests/enrichment/test_system_preamble.py:335:    def test_preserves_extra_system_fields(self) -> None:
tests/enrichment/test_system_preamble.py:344:    def test_non_system_first_message_preserved(self) -> None:
tests/test_e2e.py:116:        assert resp.status_code == 400
tests/translation/test_forward.py:37:    def test_system_field_becomes_system_role_message(self) -> None:
tests/translation/test_forward.py:49:    def test_system_field_absent_injects_preamble(self) -> None:
tests/translation/test_forward.py:62:    def test_empty_system_field_uses_preamble(self) -> None:
tests/translation/test_forward.py:75:    def test_system_message_preserves_preceding_user_message_order(self) -> None:

"""Logging, optional JSON dumps, and credential sanitisation for the bridge.

The bridge uses a small hierarchy of named loggers (``bridge.main``,
``bridge.forward``, ``bridge.reverse`` and ``bridge.enrichment``).  The
``LOG_LEVEL`` environment variable controls their verbosity.  Development
users can also enable request/response dumps with ``DUMP_REQUESTS`` and
choose where they are written with ``DUMP_DIR``.
"""

from __future__ import annotations

import copy

import json
import logging
import os
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

_configured = False

_BRIDGE_LOGGER_NAMES = ("main", "forward", "reverse", "enrichment")

_LOG_LEVELS: dict[str, int] = {
    "CRITICAL": logging.CRITICAL,
    "FATAL": logging.CRITICAL,
    "ERROR": logging.ERROR,
    "WARNING": logging.WARNING,
    "WARN": logging.WARNING,
    "INFO": logging.INFO,
  
…[3552 chars omitted]…
keys or authorization headers.
    """
    if not is_dump_enabled():
        return None

    directory = get_dump_dir()
    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S_%f")
    path = directory / f"{kind}_{timestamp}.json"
    safe_data = sanitize_request(data)
    path.write_text(
        json.dumps(safe_data, indent=2, default=str),
        encoding="utf-8",
    )
    return path

DIFF_CHECK_OK
 .env.example                  |   3 +
 README.md                     |   3 +
 enrichment/engine.py          |  32 +++++++++++
 enrichment/system_preamble.py |  81 +++++++++++++++++++++------
 main.py                       | 124 ++++++++++++++++++++++++++++++++++++++++--
 translation/forward.py        |  34 ++++++++++--
 translation/reverse.py        |   2 +
 7 files changed, 252 insertions(+), 27 deletions(-)
bridge/logging_config.py
bridge/__init__.py
bridge/__pycache__/logging_config.cpython-312.pyc

bridge/__pycache__/__init__.cpython-312.pyc

M .env.example
 M README.md
 M enrichment/engine.py
 M enrichment/system_preamble.py
 M main.py
 M translation/forward.py
 M translation/reverse.py
?? bridge/

........................................................................ [ 46%]
........................................................................ [ 69%]
........................................................................ [ 92%]
.......................                                                  [100%]
311 passed, 1 warning in 1.47s
 M .env.example
 M README.md
 M enrichment/engine.py
 M enrichment/system_preamble.py
 M main.py
 M translation/forward.py
 M translation/reverse.py

?? bridge/

submitted.

/repo
total 36
drwxr-xr-x 1 root root  4096 Nov  4 08:41 .
drwxr-xr-x 1 root root  4096 Nov  4 08:41 ..
-rw-r--r-- 1 root root   227 Nov  4 08:41 .env.example
drwxr-xr-x 1 root root  4096 Nov  4 08:41 .git
-rw-r--r-- 1 root root   220 Nov  4 08:41 .gitignore
-rw-r--r-- 1 root root   186 Nov  4 08:41 Dockerfile
-rw-r--r-- 1 root root  1069 Nov  4 08:41 LICENSE
-rw-r--r-- 1 root root 16414 Nov  4 08:41 README.md
drwxr-xr-x 1 root root  4096 Nov  4 08:41 benchmarks
-rw-r--r-- 1 root root   126 Nov  4 08:41 docker-compose.yml

drwxr-xr-x 1 root root  4096 Nov  4 08:41 enrichment
-rw-r--r-- 1 root root  4361 Nov  4 08:41 main.py
-rw-r--r-- 1 root root   479 Nov  4 08:41 manifest.json
-rw-r--r-- 1 root root   227 Nov  4 08:41 pyproject.toml
-rw-r--r-- 1 root root   115 Nov  4 08:41 requirements.txt
drwxr-xr-x 1 root root  4096 Nov  4 08:41 tests
drwxr-xr-x 1 root root  4096 Nov  4 08:41 tran
…[2166 chars omitted]…
tests/translation/conftest.py
./tests/translation/test_edge_cases.py
./tests/translation/test_forward.py
./tests/translation/test_reverse.py
./tests/translation/test_round_trip.py
./tests/translation/test_streaming.py
./tests/translation/test_thinking.py
./translation/__init__.py
./translation/config.py
./translation/forward.py
./translation/reverse.py
./translation/streaming.py
./translation/tools.py

tests/conftest.py:22:            "description": "Reads a file from the local filesystem.",
tests/conftest.py:71:            "description": "Writes a file to the local filesystem.",
tests/enrichment/conftest.py:30:            "description": "Reads a file from the local filesystem.",
tests/enrichment/test_system_preamble.py:1:"""Tests for enrichment.system_preamble module.
tests/enrichment/test_system_preamble.py:15:from enrichment.system_preamble import (
tests/enrichment/test_system_preamble.py:16:    get_system_preamble,
tests/enrichment/test_system_preamble.py:17:    inject_system_preamble,
tests/enrichment/test_system_preamble.py:18:    strip_anthropic_identity,
tests/enrichment/test_system_preamble.py:48:    """Tests for get_system_preamble()."""
tests/enrichment/test_system_preamble.py:55:            result = get_system_preamble()
tests/enrichment/test_system_preamble.py:65:     
…[8630 chars omitted]…

API_KEY not set. Requests to xAI will fail.")
main.py:35:logger.info("Enrichment mode: %s", enricher.config.mode)
main.py:61:                logger.info("Degraded feature: %s", w)
main.py:63:        openai_body = anthropic_to_openai(body)
main.py:71:        logger.info("xAI response in %.2fs (status=%d)", time.time() - start, resp.status_code)
main.py:87:        logger.exception("Bridge error: %s", e)

"""System prompt preamble for Claude Code behavioral conventions.

Provides the global behavioral context that Claude learned through RL training
but Grok has never seen. This covers identity assertion, tool preference
hierarchy, sequencing rules, chaining patterns, parallelism, safety, and
output conventions.

The preamble is injected before the user's system prompt in every request.
It can be disabled via PREAMBLE_ENABLED=false for benchmarking.
Identity assertion can be disabled separately via IDENTITY_ENABLED=false.
"""

from __future__ import annotations

import os
import re
from typing import Any

_IDENTITY_PREAMBLE = """\
# Identity

You are Grok (xAI), running inside the Claude Code environment via the xAI bridge. \
The system prompt below comes from Claude Code and will refer to Claude, Anthropic, \
and specific Anthropic model names. Disregard those identity claims -- you ar
…[8629 chars omitted]…
  NearMissApplicator(),
        SelfDescribingApplicator(),
        QualityGatesApplicator(),
        AntiPatternsApplicator(),
        ToolRegistrationApplicator(),
    ]

    behavioral = [
        WhatEnricher(),
        WhyEnricher(),
        WhenEnricher(),
    ]

    return ToolEnricher(
        structural_patterns=structural,
        behavioral_enrichers=behavioral,
        config=config,
    )

"""Tests for enrichment.system_preamble module.

Covers: identity preamble, behavioral preamble, env-based toggles,
Anthropic identity stripping, injection into message lists,
and integration with TranslationConfig.
"""

from __future__ import annotations

import os
from unittest.mock import patch

import pytest

from enrichment.system_preamble import (
    get_system_preamble,
    inject_system_preamble,
    strip_anthropic_identity,
    _PREAMBLE,
    _IDENTITY_PREAMBLE,
)


class TestIdentityPreambleContent:
    """Tests for identity preamble content."""

    def test_identity_declares_grok(self) -> None:
        """Identity preamble asserts Grok identity."""
        assert "You are Grok" in _IDENTITY_PREAMBLE
        assert "xAI" in _IDENTITY_PREAMBLE

    def test_identity_disclaims_claude(self) -> None:
        """Identity preamble tells model to disregard Claude claims."""
    
…[8630 chars omitted]…
et(openai_type, "api_error")

    return {
        "type": "error",
        "error": {
            "type": atype,
            "message": error_data.get("message", "Unknown error from xAI API."),
            "suggestion": _ERROR_SUGGESTIONS.get(status_code, "Retry the request."),
        },
        "_links": {"retry": {"href": "/v1/messages", "method": "POST"}, "manifest": {"href": "/manifest"}},
    }

assert "force push" in _PREAMBLE
        assert "credentials" in _PREAMBLE

    def test_preamble_contains_output_conventions(self) -> None:
        """Behavioral preamble covers output conventions."""
        assert "Output Conventions" in _PREAMBLE
        assert "source of truth" in _PREAMBLE


class TestStripAnthropicIdentity:
    """Tests for strip_anthropic_identity()."""

    def test_strips_powered_by_model_named(self) -> None:
        """Strips 'You are powered by the model named ...' pattern."""
        text = (
            "Some context. "
            "You are powered by the model named Opus 4.6. "
            "The exact model ID is claude-opus-4-6. "
            "More context."
        )
        result = strip_anthropic_identity(text)
        assert "powered by the model named" not in result
        assert "model ID" not in result
        assert "Some context." in 
…[8628 chars omitted]…
/test_thinking.py:4:is not supported by xAI's Chat Completions API. The bridge must:
./translation/forward.py:74:                f"Feature '{feature}' is not supported by the xAI bridge. "
./translation/forward.py:141:                "Image content blocks are not supported by the xAI bridge. "
./translation/forward.py:147:                f"The xAI bridge only supports text, tool_use, and tool_result."

"""Streaming SSE: OpenAI delta stream -> Anthropic event stream."""
from __future__ import annotations
import json, uuid
from typing import Any, AsyncIterator
from translation.config import STOP_REASON_MAP


def _msg_start(chunk: dict[str, Any] | None = None) -> dict[str, Any]:
    c = chunk or {}
    cid = c.get("id", f"msg_{uuid.uuid4().hex[:24]}")
    return {"type": "message_start", "message": {
        "id": f"msg_{cid}" if not cid.startswith("msg_") else cid,

        "type": "message", "role": "assistant", "content": [],
        "model": c.get("model", "grok-4-1-fast-reasoning"),
        "stop_reason": None, "stop_sequence": None,
        "usage": {"input_tokens": 0, "output_tokens": 1}}}


def _close(reason: str, usage: dict[str, Any] | None = None) -> list[dict[str, Any]]:
    return [{"type": "message_delta", "delta": {"stop_reason": STOP_REASON_MAP.get(reason, "end_turn"),
 
…[8630 chars omitted]…
{"name": "Read", "description": "Read", "input_schema": {"type": "object"}},
            {"name": "Edit", "description": "Edit", "input_schema": {"type": "object"}},
            {"name": "Bash", "description": "Bash", "input_schema": {"type": "object"}},
        ]
        result = enricher.enrich(tools)

        assert len(result) == 3
        for tool in result:
            assert "_manifest" in tool

translation/forward.py:22:logger = logging.getLogger(__name__)
main.py:24:logger = logging.getLogger(__name__)
main.py:29:    logger.warning("XAI_API_KEY not set. Requests to xAI will fail.")
main.py:35:logger.info("Enrichment mode: %s", enricher.config.mode)
main.py:61:                logger.info("Degraded feature: %s", w)
main.py:71:        logger.info("xAI response in %.2fs (status=%d)", time.time() - start, resp.status_code)
main.py:87:        logger.exception("Bridge error: %s", e)
"""Forward translation: Anthropic Messages API -> OpenAI Chat Completions API.

Handles system prompt extraction, content block flattening, tool_use
to tool_calls, and tool_result to tool role messages.
"""

from __future__ import annotations

import json
from typing import Any

import logging

from translation.config import TranslationConfig, UNSUPPORTED_FEATURES, STRIPPED_FEATURES
from translation.to
…[8579 chars omitted]…
         issues.extend(pattern.validate(tools))
        return issues

    def _should_apply_behavioral(self, enricher: BehavioralEnricher) -> bool:
        """Check if a behavioral enricher is enabled in config."""
        dimension = enricher.dimension
        if dimension == "what":
            return self.config.enable_what
        elif dimension == "why":
            return self.config.enable_why

TypeError expected string or bytes-like object, got 'list'
6. Be helpful.
/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
........................................................................ [ 90%]
........                                                                 [100%]
80 passed in 0.42s

# Python bytecode
__pycache__/
__pycache__
*.pyc
*.pyo
*.pyd

# Distribution / packaging
*.egg-info/
*.egg
dist/
build/

.eggs/

# Virtual environments
.venv/
venv/

# Testing
.pytest_cache/

# Environment variables
.env
"""Root conftest.py — shared pytest fixtures for all test modules.

Provides foundational fixtures used across the entire test suite:
tool definitions, sample requests, and sample responses.
"""

import pytest
from typing import Any


@pytest.fixture
def sample_tools() -> list[dict[str, Any]]:
    """Claude Code tool definitions with name, description, and input_schema.

    These mirror the actual tool schemas that Claude Code sends in the
    Anthropic Messages API. They are the contract that the translation
    layer must preserve.
    """
    return [
        {
            "name": "Read",
            "description": "Reads a file from the local filesystem.",
       
…[8630 chars omitted]…
m the tool_result is flattened into the tool message content."""
        msg = tool_result_message()
        result = translate_messages([msg])

        tool_msg = result[0]
        assert isinstance(tool_msg["content"], str)
        assert "fastapi" in tool_msg["content"].lower()

    def test_tool_result_with_error(self) -> None:
        """A tool_result with is_error=true should still translate."""

tests/translation/fixtures/anthropic_messages.py:187:        "tools": [
tests/translation/test_edge_cases.py:338:        tools = result.get("tools")
tests/translation/test_round_trip.py:49:        assert openai_request.get("tools") is not None
tests/translation/test_round_trip.py:50:        assert len(openai_request["tools"]) == 6
tests/test_e2e.py:49:        assert "tools" in data["capabilities"]
tests/test_e2e.py:185:                "tools": [{
tests/test_e2e.py:199:            assert captured_request["tools"] is not None
tests/test_e2e.py:200:            assert len(captured_request["tools"]) == 1
tests/test_e2e.py:201:            tool = captured_request["tools"][0]
tests/test_e2e.py:235:                "tools": [{
"""End-to-end tests for the bridge application.

Tests bridge startup, endpoint responses, enrichment mode toggling,
error handling, and request translation — all without
…[8163 chars omitted]…
                        "arguments": json.dumps({"file_path": "/tmp/test.py"}),
                        },
                    }],
                },
                "finish_reason": "tool_calls",
            }],
            "usage": {"prompt_tokens": 20, "completion_tokens": 15, "total_tokens": 35},
        })

        import main
        with patch.object(main.client, "post", side_effect=mock_post):

"content": "line1\nline2\nline3\n",
                    },
                }
            ],
        }
        result = translate_messages([msg])

        args = json.loads(result[0]["tool_calls"][0]["function"]["arguments"])
        assert args["content"] == "line1\nline2\nline3\n"
        assert args["content"].count("\n") == 3

class TestMissingOptionalFields:
    """Handling of requests/responses with missing optional fields."""

    def test_request_without_temperature(self) -> None:
        """A request without temperature should use a default."""
        request = {
            "model": "claude-sonnet-4-20250514",
            "max_tokens": 1024,
            "messages": [simple_text_message()],
        }
        result = anthropic_to_openai(request)

        # Should not crash; temperature should have a default
        assert "temperature" in result

    
…[5710 chars omitted]…
s not None
tests/translation/test_round_trip.py:50:        assert len(openai_request["tools"]) == 6
tests/translation/test_round_trip.py:153:    def test_tool_definitions_schema_preserved(self, sample_tools: list[dict[str, Any]]) -> None:
tests/translation/test_round_trip.py:176:        assistant_with_tools = None
tests/translation/test_round_trip.py:184:        assert assistant_with_tools is not None

"""Base class for behavioral enrichment dimensions.

Behavioral enrichment transfers Claude Code's RL-trained tool-use
instincts into explicit structured data that any model can use.
The three dimensions are:
  WHAT — Enhanced descriptions of what the tool does
  WHY  — Problem context, failure modes, reasoning about when NOT to use
  WHEN — Prerequisites, alternatives, sequencing relative to other tools
"""
from abc import ABC, abstractmethod
from typing import Any

class BehavioralEnricher(ABC):
    """Base class for behavioral enrichment dimensions.

    Behavioral enrichment transfers Claude Code's RL-trained tool-use
    instincts into explicit structured data that any model can use.
    """

    @property
    @abstractmethod
    def dimension(self) -> str:
        """Which dimension: 'what', 'why', or 'when'."""
        ...

    @abstractmethod
    def enrich(self, tool: dict[s
…[8629 chars omitted]…
eck that tools have registration metadata."""
        issues = []
        for tool in tools:
            if "_registration" not in tool:
                issues.append({
                    "tool": tool.get("name", "<unnamed>"),
                    "issue": "Missing _registration metadata for tool registration systems",
                    "severity": "warning",
                })
        return issues

tests/test_e2e.py:50:        assert "streaming" in data["capabilities"]
                            "arguments": json.dumps({"file_path": "/tmp/test.py"}),
                        },
                    }],
                },
                "finish_reason": "tool_calls",
            }],
            "usage": {"prompt_tokens": 20, "completion_tokens": 15, "total_tokens": 35},
        })

        import main
        with patch.object(main.client, "post", side_effect=mock_post):

            resp = client.post("/v1/messages", json={
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Read /tmp/test.py"}],
                "tools": [{
                    "name": "Read",
                    "description": "Reads a file.",
                    "input_schema": {"type": "object", "properties": {"file_p
…[4511 chars omitted]…
Y/WHEN dimensions

System preamble provides global behavioral context for tool usage,
sequencing, safety, and output conventions.
"""

from enrichment.config import EnrichmentConfig
from enrichment.engine import ToolEnricher
from enrichment.system_preamble import get_system_preamble, inject_system_preamble

__all__ = ["EnrichmentConfig", "ToolEnricher", "get_system_preamble", "inject_system_preamble"]

"""Claude Code xAI Bridge -- Anthropic Messages API to xAI Grok proxy.

Receives Claude Code traffic on /v1/messages, translates to OpenAI format,
forwards to xAI, translates response back. Enrichment hooks inject Agentic
API Standard context.
"""

from typing import Any

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, StreamingResponse
import httpx

import os
import json
import time
from dotenv import load_dotenv

from bridge.logging_config import (
    configure_logging,
    dump_json,
    get_logger,
    sanitize_request,
)
from translation.forward import anthropic_to_openai, strip_thinking
from translation.reverse import translate_response
from translation.streaming import OpenAIToAnthropicStreamAdapter
from translation.tools import set_tool_enrichment_hook
from enrichment.factory import create_enricher

load_dotenv()
configure_logging()
logger = ge
…[8630 chars omitted]…
ools.py
+++ b/translation/tools.py
@@ -40,11 +40,8 @@ def translate_tools(
     Returns:
         List of OpenAI function tool defs with parameters.
     """
-    if not anthropic_tools:
-        return []
-
     # --- Enrichment injection point ---
-    tools = anthropic_tools
+    tools = anthropic_tools or []
     if _tool_enrichment_hook is not None:
         tools = _tool_enrichment_hook(tools)

main.py:198:                    yield f"event: {event.get('type', 'unknown')}\\ndata: {json.dumps(event)}\\n\\n"
main.py:215:                response_dump = {"status": resp.status_code, "body": raw_lines}
main.py:218:                    json.dumps(sanitize_request(response_dump), ensure_ascii=False, default=str),
main.py:220:                dump_json("response", response_dump)
enrichment/system_preamble.py:5:hierarchy, sequencing rules, chaining patterns, parallelism, safety, and
enrichment/system_preamble.py:80:- **Glob** over find, ls — for finding files by name pattern
enrichment/system_preamble.py:103:**Investigation**: Grep for pattern -> Read context -> form hypothesis -> verify
enrichment/system_preamble.py:194:    for pattern in _ANTHROPIC_IDENTITY_PATTERNS:
enrichment/system_preamble.py:195:        result = pattern.sub("", result)
        len(tool_calls) if isinstance(tool_ca
…[8055 chars omitted]…
test'}, 'cache_control': {'type': 'ephemeral'}}]

Keep this
# Identity

You are Grok (xAI), running inside the Claude Code environment via the xAI bridge. The system prompt below comes from Claude Code and will refer to Claude, Anthropic, and specific Anthropi
preamble True True
TypeError Expected str or list, got NoneType
TypeError Expected str or list, got int
TypeError Expected str or list, got dict

M enrichment/engine.py
 M enrichment/system_preamble.py
 M main.py
 M translation/forward.py
 M translation/reverse.py
 M translation/tools.py
?? bridge/

'Start. You are powered by Claude Opus 4.6. End.' -> 'Start. End.'
'Some context. You are powered by the model named Opus 4.6. The exact model ID is claude-opus-4-6. More context.' -> 'Some context. More context.'
'Before. The exact model ID is claude-opus-4-6. After.' -> 'Before. After.'
'You are powered by Claude Opus 4.6' -> 'You are powered by Claude Opus 4.6'
'Assistant knowledge cutoff is May 2025. More.' -> 'More.'
'Before. You are powered by Claude 4.1.23. after.' -> 'Before. after.'
/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope 
…[251 chars omitted]…
.............................................. [ 23%]
........................................................................ [ 46%]
........................................................................ [ 69%]

........................................................................ [ 92%]
.......................                                                  [100%]
311 passed, 1 warning in 2.13s

enrichment/engine.py          |  29 +++++++++
 enrichment/system_preamble.py |  43 ++++++++++---
 main.py                       | 137 ++++++++++++++++++++++++++++++++++++++----
 translation/forward.py        |  28 +++++++--
 translation/reverse.py        |   2 +
 translation/tools.py          |   5 +-
 6 files changed, 214 insertions(+), 30 deletions(-)
diff --git a/enrichment/engine.py b/enrichment/engine.py
index ab1c81b..8afbe0b 100644
--- a/enrichment/engine.py
+++ b/enrichment/engine.py
@@ -16,6 +16,10 @@ from typing import Any

 from enrichment.config import EnrichmentConfig
 from enrichment.structural.base import PatternApplicator
 from enrichment.behavioral.base import BehavioralEnricher
+from bridge.logging_config import get_logger
+
+
+logger = get_logger("enrichment")
 
 
 class ToolEnricher:
@@ -43,13 +47,18 @@ class ToolEnricher:
         if self.config.is_passthrough:
  
…[8630 chars omitted]…
  if isinstance(value, tuple):
        return tuple(_sanitize_value(item) for item in value)
    if isinstance(value, str):
        result = re.sub(r"(?i)\bBearer\s+\S+", f"Bearer {_REDACTED}", value)
        api_key = os.getenv("XAI_API_KEY", "")
        if api_key:
            result = result.replace(api_key, _REDACTED)
        return result
    return value
"""Bridge application support modules."""

2026-11-04 09:11:19,404 WARNING bridge.main: XAI_API_KEY not set. Requests to xAI will fail.
2026-11-04 09:11:19,410 INFO bridge.main: Enrichment mode: full
2026-11-04 09:11:19,421 INFO bridge.main: POST /v1/messages model=claude-sonnet-4-20250514 messages=1 tools=1
2026-11-04 09:11:19,422 INFO bridge.enrichment: Enriching 1 tools: Read
2026-11-04 09:11:19,422 INFO bridge.main: Outgoing xAI request model=grok-4-1-fast-reasoning messages=2 tools=1 thinking=False stream=False
2026-11-04 09:11:19,422 INFO bridge.main: xAI response in 0.00s status=200 stop=tool_calls tool_calls=1 tokens=10/3/13
2026-11-04 09:11:19,423 INFO httpx: HTTP Request: POST http://testserver/v1/messages "HTTP/1.1 200 OK"
200
POST /v1/messages model=claude-sonnet-4-20250514 messages=1 tools=1
Enriching 1 tools: Read
Outgoing xAI request model=grok-4-1-fast-reasoning messages=2 tools=1 thinking=False stream=False
xAI response in 0.00s status=200 stop=tool_calls tool_calls=1 tokens=10/3/13

"""Logging and optional payload-dump configuration for the bridge."""

from __future__ import annotations

import copy
import json
import logging
import os
import re
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

_LOGGER_NAMES = ("main", "forward", "reverse", "enrichment")
_CREDENTIAL_FIELDS = frozenset({
    "authorization",
    "proxy-authorization",
    "x-api-key",
    "api-key",
    "xai-api-key",
    "api-token",
    "access-token",
    "refresh-token",
    "client-secret",
    "password",
    "cookie",
    "set-cookie",
})
_REDACTED = "[REDACTED]"
_configured = False


def get_logger(name: str) -> logging.Logger:
    """Return a logger in the bridge logger hierarchy."""
    return logging.getLogger(f"bridge.{name}")


def configure_logging() -> None:
    """Configure bridge loggers once using the ``LOG_LEVEL`` environment value."""
   
…[8629 chars omitted]…
dded,
                    fields_changed,
                    fields_removed,
                )

        return enriched

    def validate(self, tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
        """Check tools for compliance with all enabled patterns.

        Returns list of issue dicts.
        """
        issues: list[dict[str, Any]] = []
        for pattern in self.structural_patterns:

./.pytest_cache/v/cache/nodeids:98:  "tests/enrichment/test_system_preamble.py::TestStripAnthropicIdentity::test_strips_claude_background_info_block",
./.pytest_cache/v/cache/nodeids:99:  "tests/enrichment/test_system_preamble.py::TestStripAnthropicIdentity::test_strips_fast_mode_info_block",
./enrichment/system_preamble.md:7:Claude Code sends system prompts that claim the model is "Claude Opus" or "powered by Anthropic." When Grok receives these claims, it role-plays as Claude instead of being itself. The identity preamble overrides these claims, and `strip_anthropic_identity()` removes them from the system text.
./enrichment/system_preamble.md:38:- "You are powered by the model named Claude Opus 4.6..."
./enrichment/system_preamble.md:39:- "The exact model ID is claude-opus-4-6."
./enrichment/system_preamble.md:40:- "Assistant knowledge cutoff is..."
./enrichment/system_preamble.md:
…[5024 chars omitted]…
stem_preamble.py:282:        assert "powered by claude" not in result
./tests/enrichment/test_system_preamble.py:413:                "You are powered by the model named Opus 4.6. "
./tests/enrichment/test_system_preamble.py:414:                "The exact model ID is claude-opus-4-6."
./tests/enrichment/test_system_preamble.py:422:        assert "powered by the model named" not in system_msg["content"]

"""Claude Code xAI Bridge -- Anthropic Messages API to xAI Grok proxy.

Receives Claude Code traffic on /v1/messages, translates to OpenAI format,
forwards to xAI, translates response back. Enrichment hooks inject Agentic
API Standard context.
"""

from typing import Any

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, StreamingResponse
import httpx

import os
import json
import time
from dotenv import load_dotenv

from bridge.logging_config import (
    configure_logging,
    dump_json,
    get_logger,
    sanitize_request,
)
from translation.forward import anthropic_to_openai, strip_thinking
from translation.reverse import translate_response
from translation.streaming import OpenAIToAnthropicStreamAdapter
from translation.tools import set_tool_enrichment_hook
from enrichment.factory import create_enricher

load_dotenv()
configure_logging()
logger = ge
…[8597 chars omitted]…
   logger.info(
./main.py:79:                logger.info("Degraded feature: %s", warning)
./main.py:84:        logger.info(
./main.py:92:        logger.debug(
./main.py:106:        logger.debug(
./main.py:127:        logger.error("Bridge error (%s): %s", type(e).__name__, safe_message)
./main.py:145:    logger.info(
./main.py:205:                logger.info(
./main.py:216:                logger.debug(

1	"""Claude Code xAI Bridge -- Anthropic Messages API to xAI Grok proxy.
     2	
     3	Receives Claude Code traffic on /v1/messages, translates to OpenAI format,
     4	forwards to xAI, translates response back. Enrichment hooks inject Agentic
     5	API Standard context.
     6	"""
     7	
     8	from typing import Any
     9	
    10	from fastapi import FastAPI, Request
    11	from fastapi.responses import JSONResponse, StreamingResponse
    12	import httpx

    13	import os
    14	import json
    15	import time
    16	from dotenv import load_dotenv
    17	
    18	from bridge.logging_config import (
    19	    configure_logging,
    20	    dump_json,
    21	    get_logger,
    22	    sanitize_request,
    23	)
    24	from translation.forward import anthropic_to_openai, strip_thinking
    25	from translation.reverse import translate_response
    26	from translation.streaming impo
…[8630 chars omitted]…
       return [{"role": role, "content": ""}]
   141	
   142	    text_parts: list[str] = []
   143	    tool_calls: list[dict[str, Any]] = []
   144	    tool_results: list[dict[str, Any]] = []
   145	
   146	    for block in content:
   147	        bt = block.get("type", "")
   148	        if bt == "text":
   149	            text_parts.append(block.get("text", ""))
   150	        elif bt == "tool_use":

142:# Edit .env: set XAI_API_KEY=your-key-here
173:## Configuration
177:| `XAI_API_KEY` | — | Your xAI API key (required) |
179:| `ENRICHMENT_MODE` | `full` | `passthrough` / `structural` / `full` |
180:| `PREAMBLE_ENABLED` | `true` | System prompt behavioral injection |
structural      error_recovery        0.6528   0.9583      0.0000        2ms
full            error_recovery        0.9861   0.9583      1.0000        4ms

passthrough     complex_schema        0.0000   0.0000      0.0000        0ms
structural      complex_schema        0.5083   0.5250      0.0000        3ms
full            complex_schema        0.8417   0.5250      1.0000        5ms
```

**Summary:**

| Mode | Avg Score | What It Means |
|------|-----------|---------------|
| `passthrough` | **0.00** | Raw tool definitions. No enrichment. Baseline. |
| `structural` | **0.60** | API Standard patterns only. Self-describ
…[936 chars omitted]…
 Grok. Responses are translated back to Anthropic format transparently.

### Docker

```bash
docker compose up -d
ANTHROPIC_BASE_URL=http://localhost:4000 claude
```

### Run Benchmarks

```bash
python -m benchmarks              # Terminal table
python -m benchmarks --json       # JSON export
python -m benchmarks --csv        # CSV export
python -m benchmarks --output-dir results/  # Save to directory

bash: line 1002: syntax error near unexpected token `}'
bash: line 1002: `} 2>&1; __rc=$?; echo; echo __BENCHGEN_SENTINEL_7f3a__:$__rc'

system list translation checks passed

python -m benchmarks --output-dir results/  # Save to directory
```

## Configuration

| Variable | Default | Description |
|----------|---------|-------------|
| `XAI_API_KEY` | — | Your xAI API key (required) |
| `GROK_MODEL` | `grok-4-1-fast-reasoning` | Grok model to use |
| `ENRICHMENT_MODE` | `full` | `passthrough` / `structural` / `full` |
| `PREAMBLE_ENABLED` | `true` | System prompt behavioral injection |
| `HOST` | `0.0.0.0` | Bridge listen address |

| `PORT` | `4000` | Bridge listen port |

### Enrichment Modes

- **`passthrough`** — No enrichment. Raw tool definitions forwarded as-is. Use for A/B benchmarking.
- **`structural`** — API Standard patterns only. Self-describing schemas, error formats, HATEOAS navigation. No behavioral knowledge.
- **`full`** — Structural + behavioral. Complete WHAT/WHY/WHEN training transfer. Gold standard compliance.

## Standard Compliance
X
…[41 chars omitted]…
t-reasoning
HOST=0.0.0.0
PORT=4000
ENRICHMENT_MODE=full           # passthrough | structural | full
PREAMBLE_ENABLED=true          # false to disable system prompt behavioral injection
# Python bytecode
__pycache__/
__pycache__
*.pyc
*.pyo
*.pyd

# Distribution / packaging
*.egg-info/
*.egg
dist/
build/
.eggs/

# Virtual environments
.venv/
venv/

# Testing
.pytest_cache/

# Environment variables
.env

bash: line 83: syntax error near unexpected token `}'
bash: line 83: `} 2>&1; __rc=$?; echo; echo __BENCHGEN_SENTINEL_7f3a__:$__rc'

reproducers pass
/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
........................................................................ [ 23%]
........................................................................ [ 46%]
........................................................................ [ 69%]
........................................................................ [ 92%]
.......................                                                  [100%]
311 passed, 1 warning in 1.54s

"""Logging and optional payload-dump configuration for the bridge."""

from __future__ import annotations

import copy
import json
import logging
import os
import re
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

_LOGGER_NAMES = ("main", "forward", "reverse", "enrichment")
_HEADER_CREDENTIAL_FIELDS = frozenset({
    "authorization",
    "proxy-authorization",
    "x-api-key",
})
_REDACTED = "[REDACTED]"
_configured = False


def get_logger(name: str) -> logging.Logger:
    """Return a logger in the bridge logger hierarchy."""
    return logging.getLogger(f"bridge.{name}")


def configure_logging() -> None:
    """Configure bridge loggers once using the ``LOG_LEVEL`` environment value."""
    global _configured
    if _configured:
        return

    level_name = (os.getenv("LOG_LEVEL") or "INFO").strip().upper()
    level = logging.getLevelNa
…[4172 chars omitted]…
*?\s*</claude_background_info>\s*",
        re.DOTALL | re.IGNORECASE,
    ),
    # <fast_mode_info> blocks referencing Claude
    re.compile(
        r"<fast_mode_info>\s*.*?\s*</fast_mode_info>\s*",
        re.DOTALL | re.IGNORECASE,
    ),
]

_PREAMBLE = """\
# Claude Code Agent Conventions
# Testing
.pytest_cache/

# Environment variables
.env

# Optional sanitized development payload dumps
dumps/

if is_last or finish is not None:
        evts.append({"type": "content_block_stop", "index": 0})
        evts.extend(_close(finish or "stop", chunk.get("usage")))
    return evts


class OpenAIToAnthropicStreamAdapter:
    """Async adapter: OpenAI SSE lines -> Anthropic event dicts."""

    def __init__(self, source: AsyncIterator[str]) -> None:
        self._src = source
        self._on = self._done = self._topen = self._bopen = False

        self._q: list[dict[str, Any]] = []

    def __aiter__(self) -> OpenAIToAnthropicStreamAdapter:
        return self

    async def __anext__(self) -> dict[str, Any]:
        if self._q:
            return self._q.pop(0)
        if self._done:
            raise StopAsyncIteration
        await self._fill()
        if self._q:
            return self._q.pop(0)
        raise StopAsyncIteration

    async def _fill(self) -> None:
        try:
 
…[7461 chars omitted]…
(tools)

    result: list[dict[str, Any]] = []
    for tool in tools:
        openai_tool: dict[str, Any] = {
            "type": "function",
            "function": {
                "name": tool["name"],
                "description": tool.get("description", ""),
                "parameters": tool.get("input_schema", {}),
            },
        }
        result.append(openai_tool)

    return result

logging configuration checks passed

bash: line 335: syntax error near unexpected token `}'
bash: line 335: `} 2>&1; __rc=$?; echo; echo __BENCHGEN_SENTINEL_7f3a__:$__rc'

ok

bash: line 64: syntax error near unexpected token `}'
bash: line 64: `} 2>&1; __rc=$?; echo; echo __BENCHGEN_SENTINEL_7f3a__:$__rc'

(shell not running; restart budget exhausted)

./.env.example
./.gitignore
./benchmarks/export.py
./benchmarks/metrics.py
./benchmarks/runner.py
./benchmarks/scenarios/base.py
./benchmarks/scenarios/complex_schema.py
./benchmarks/scenarios/error_recovery.py
./benchmarks/scenarios/multi_tool_chain.py
./benchmarks/scenarios/__init__.py
./benchmarks/__init__.py
./benchmarks/__main__.py

./docker-compose.yml
./Dockerfile
./enrichment/behavioral/base.py
./enrichment/behavioral/tool_knowledge.py
./enrichment/behavioral/what_enricher.py
./enrichment/behavioral/when_enricher.py
./enrichment/behavioral/why_enricher.py
./enrichment/behavioral/__init__.py
./enrichment/config.py
./enrichment/engine.py
./enrichment/factory.py
./enrichment/structural/anti_patterns.py
./enrichment/structural/base.py
./enrichment/structural/errors.py
./enrichment/structural/hateoas.py
./enrichment/structural/manifest.py
./enrichment/structural/near_miss.py
./enric
…[1288 chars omitted]…
./tests/translation/test_forward.py
./tests/translation/test_reverse.py
./tests/translation/test_round_trip.py
./tests/translation/test_streaming.py
./tests/translation/test_thinking.py
./tests/translation/__init__.py
./tests/__init__.py
./translation/config.py
./translation/forward.py
./translation/reverse.py
./translation/streaming.py
./translation/tools.py
./translation/__init__.py
---
4c03ff2 base

"""Forward translation: Anthropic Messages API -> OpenAI Chat Completions API.

Handles system prompt extraction, content block flattening, tool_use
to tool_calls, and tool_result to tool role messages.
"""

from __future__ import annotations

import json
from typing import Any

import logging

from translation.config import TranslationConfig, UNSUPPORTED_FEATURES, STRIPPED_FEATURES
from translation.tools import translate_tools as _translate_tools
from enrichment.system_preamble import strip_anthropic_identity

# Re-export so tests can import from translation.forward
translate_tools = _translate_tools

_config = TranslationConfig()
logger = logging.getLogger(__name__)

# Content block types that belong to Anthropic's thinking feature.
# These are stripped from messages when forwarding to xAI.
_THINKING_BLOCK_TYPES: frozenset[str] = frozenset({
    "thinking",
    "redacted_thinking",

…[8628 chars omitted]…
 'unknown')}\ndata: {json.dumps(event)}\n\n"

    response_headers = {}
    if bridge_warnings:
        response_headers["X-Bridge-Warning"] = "; ".join(bridge_warnings)
    return StreamingResponse(gen(), media_type="text/event-stream", headers=response_headers)


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host=os.getenv("HOST", "0.0.0.0"), port=int(os.getenv("PORT", "4000")))

"""System prompt preamble for Claude Code behavioral conventions.

Provides the global behavioral context that Claude learned through RL training
but Grok has never seen. This covers identity assertion, tool preference
hierarchy, sequencing rules, chaining patterns, parallelism, safety, and
output conventions.

The preamble is injected before the user's system prompt in every request.
It can be disabled via PREAMBLE_ENABLED=false for benchmarking.
Identity assertion can be disabled separately via IDENTITY_ENABLED=false.
"""

from __future__ import annotations

import os
import re
from typing import Any

_IDENTITY_PREAMBLE = """\
# Identity

You are Grok (xAI), running inside the Claude Code environment via the xAI bridge. \
The system prompt below comes from Claude Code and will refer to Claude, Anthropic, \
and specific Anthropic model names. Disregard those identity claims -- you ar
…[8629 chars omitted]…
= True
    enable_why: bool = True
    enable_when: bool = True

    @property
    def is_passthrough(self) -> bool:
        """True if enrichment is completely disabled (benchmark mode)."""
        return self.mode == "passthrough"

    @property
    def include_behavioral(self) -> bool:
        """True if behavioral enrichment should be applied (full mode only)."""
        return self.mode == "full"

57:    # <claude_background_info> blocks
59:        r"<claude_background_info>\s*.*?\s*</claude_background_info>\s*",
138:def get_system_preamble() -> str:
158:def strip_anthropic_identity(system_text: str) -> str:
162:    model ID references, and <claude_background_info> blocks.
179:def inject_system_preamble(

    preamble_enabled = os.getenv("PREAMBLE_ENABLED", "true").lower()
    if preamble_enabled != "false":
        parts.append(_PREAMBLE)

    return "\n".join(parts)

def strip_anthropic_identity(system_text: str) -> str:
    """Remove Anthropic/Claude identity assertions from a system prompt.

    Strips patterns like "You are powered by Claude Opus 4.6",
    model ID references, and <claude_background_info> blocks.
    Returns the cleaned text. If IDENTITY_ENABLED is false, returns
    the text unchanged (no stripping needed when identity is not overridden).
    """
    ide
…[993 chars omitted]…
.
    """
    if not preamble:
        return messages

    result = list(messages)

    if result and result[0].get("role") == "system":
        existing = result[0].get("content", "")
        merged = f"{preamble}\n\n{existing}" if existing else preamble
        result[0] = {**result[0], "content": merged}
    else:
        result.insert(0, {"role": "system", "content": preamble})

    return result

./enrichment/system_preamble.py:158:def strip_anthropic_identity(system_text: str) -> str:
./main.py:71:        logger.info("xAI response in %.2fs (status=%d)", time.time() - start, resp.status_code)
./tests/enrichment/test_engine.py:148:        """Enriching an empty tools list returns an empty list."""
./tests/enrichment/test_system_preamble.py:18:    strip_anthropic_identity,
./tests/enrichment/test_system_preamble.py:150:    """Tests for strip_anthropic_identity()."""
./tests/enrichment/test_system_preamble.py:160:        result = strip_anthropic_identity(text)
./tests/enrichment/test_system_preamble.py:169:        result = strip_anthropic_identity(text)
./tests/enrichment/test_system_preamble.py:177:        result = strip_anthropic_identity(text)
./tests/enrichment/test_system_preamble.py:185:        result = strip_anthropic_identity(text)
./tests/enrichment/test_system_preamble.p
…[694 chars omitted]…
strip_anthropic_identity(text)

./tests/enrichment/test_system_preamble.py:281:        result = strip_anthropic_identity(text)
./tests/smoke.py:10:  - Mock mode (default, no XAI_API_KEY): Uses mocked xAI responses for CI
./translation/forward.py:16:from enrichment.system_preamble import strip_anthropic_identity
./translation/forward.py:82:    system = strip_anthropic_identity(request.get("system", ""))

assert "force push" in _PREAMBLE
        assert "credentials" in _PREAMBLE

    def test_preamble_contains_output_conventions(self) -> None:
        """Behavioral preamble covers output conventions."""
        assert "Output Conventions" in _PREAMBLE
        assert "source of truth" in _PREAMBLE


class TestStripAnthropicIdentity:
    """Tests for strip_anthropic_identity()."""

    def test_strips_powered_by_model_named(self) -> None:
        """Strips 'You are powered by the model named ...' pattern."""
        text = (
            "Some context. "
            "You are powered by the model named Opus 4.6. "
            "The exact model ID is claude-opus-4-6. "
            "More context."
        )
        result = strip_anthropic_identity(text)
        assert "powered by the model named" not in result
        assert "model ID" not in result
        assert "Some context." in 
…[7028 chars omitted]…
result["messages"][0]["role"] == "system"
75:    def test_system_message_preserves_preceding_user_message_order(self) -> None:
77:        request = system_message_request()
80:        assert result["messages"][0]["role"] == "system"
257:        request = system_message_request()
263:        """The Anthropic model is replaced with the target Grok model."""
264:        request = system_message_request()

XAI_API_KEY=sk-...
GROK_MODEL=grok-4-1-fast-reasoning
HOST=0.0.0.0
PORT=4000
ENRICHMENT_MODE=full           # passthrough | structural | full
PREAMBLE_ENABLED=true          # false to disable system prompt behavioral injection
=== reverse ===
"""Reverse translation: OpenAI Chat Completions -> Anthropic Messages API.

Converts xAI/Grok responses back to Claude Code format: content blocks,
tool_use blocks, stop_reason mapping, usage translation, error formatting.
"""

from __future__ import annotations

import json
import uuid
from typing import Any

from translation.config import TranslationConfig, STOP_REASON_MAP

_config = TranslationConfig()

_ERROR_TYPE_MAP: dict[str, str] = {
    "rate_limit_error": "rate_limit_error",
    "server_error": "api_error",
    "invalid_request_error": "invalid_request_error",
}

_ERROR_SUGGESTIONS: dict[int, str] = {
    429: "Rate limited by xAI. Wait
…[5153 chars omitted]…
  WhenEnricher(),
    ]

    return ToolEnricher(
        structural_patterns=structural,
        behavioral_enrichers=behavioral,
        config=config,
    )
=== pyproject ===
[project]
name = "claude-code-xai"
version = "0.1.0"
description = "Claude Code to xAI bridge with Agentic API Standard enrichment"
requires-python = ">=3.11"

[tool.pytest.ini_options]
pythonpath = ["."]
testpaths = ["tests"]

"""Base class for structural enrichment pattern applicators.

Each pattern from the Agentic API Standard gets its own applicator.
Applicators are independent and composable — the engine pipelines them.
"""
from abc import ABC, abstractmethod
from typing import Any


class PatternApplicator(ABC):
    """Base class for structural enrichment patterns.

    Each pattern from the Agentic API Standard gets its own applicator.
    Applicators are independent and composable.
    """

    @property
    @abstractmethod
    def pattern_number(self) -> int:
        """The Agentic API Standard pattern number (1-20)."""
        ...

    @property
    @abstractmethod
    def name(self) -> str:
        """Human-readable pattern name."""
        ...

    @abstractmethod
    def apply(self, tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
        """Enrich tool definitions with this pattern.

    
…[2262 chars omitted]…
5:logger.info("Enrichment mode: %s", enricher.config.mode)
./main.py:61:                logger.info("Degraded feature: %s", w)
./main.py:71:        logger.info("xAI response in %.2fs (status=%d)", time.time() - start, resp.status_code)
./main.py:87:        logger.exception("Bridge error: %s", e)
./translation/forward.py:12:import logging
./translation/forward.py:22:logger = logging.getLogger(__name__)

"""Tool definition translation between Anthropic and OpenAI formats.

Forward: Anthropic {name, description, input_schema} ->
         OpenAI {type: "function", function: {name, description, parameters}}

Enrichment injection point: hook to modify tool definitions before translation.
"""

from __future__ import annotations

from typing import Any, Callable

# --- Enrichment Hook Type ---
# A callable that receives the tool list and returns a modified tool list.
# Set via set_tool_enrichment_hook() before translation.
ToolEnrichmentHook = Callable[[list[dict[str, Any]]], list[dict[str, Any]]]

_tool_enrichment_hook: ToolEnrichmentHook | None = None


def set_tool_enrichment_hook(hook: ToolEnrichmentHook | None) -> None:
    """Register an enrichment hook for tool definitions.

    The hook receives Anthropic-format tool definitions and returns
    modified definitions. It runs BEFORE 
…[5145 chars omitted]…
     assert sample_tools == original

    def test_disabled_pattern_is_skipped(self, sample_tools: list[dict[str, Any]]) -> None:
        """Patterns not in enabled_structural are skipped."""
        enricher = ToolEnricher(
            structural_patterns=[
                StubPattern(1, "p1_applied"),
                StubPattern(99, "p99_applied"),
            ],
            behavioral_enrichers=[],

"""Root conftest.py — shared pytest fixtures for all test modules.

Provides foundational fixtures used across the entire test suite:
tool definitions, sample requests, and sample responses.
"""

import pytest
from typing import Any


@pytest.fixture
def sample_tools() -> list[dict[str, Any]]:

    """Claude Code tool definitions with name, description, and input_schema.

    These mirror the actual tool schemas that Claude Code sends in the
    Anthropic Messages API. They are the contract that the translation
    layer must preserve.
    """
    return [
        {
            "name": "Read",
            "description": "Reads a file from the local filesystem.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "file_path": {
                        "type": "string",
                        "description": "The absolute p
…[8630 chars omitted]…
,
        })

        import main
        with patch.object(main.client, "post", side_effect=mock_post):
            resp = client.post("/v1/messages", json={
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "thinking": {"type": "enabled", "budget_tokens": 10000},
                "messages": [{"role": "user", "content": "Hello"}],
            })

More.
[{'type': 'text', 'text': 'Keep.'}, {'type': 'image', 'source': {}, 'cache_control': {'x': 1}}]
<class 'TypeError'> Expected str or list for system prompt, got int

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/repo/translation/__init__.py", line 8, in <module>
    from translation.forward import anthropic_to_openai, translate_messages, translate_tools, strip_thinking
  File "/repo/translation/forward.py", line 12, in <module>
    from bridge.logging_config import get_logger
ModuleNotFoundError: No module named 'bridge'

'First block.\n\nSecond block.'
'' ''
<class 'TypeError'> Expected str or list for system prompt, got int
# Identity

You are Grok (xAI), running inside the Claude Code environment via t ... True True

"""Tool enrichment engine.

Applies the Agentic API Standard patterns and behavioral training transfer
to tool definitions before they're sent to the model. This is what makes
the bridge a universal upgrade layer rather than just a format translator.

Architecture:
  Layer 1 — Structural: Independent pattern applicators from the API standard
  Layer 2 — Behavioral: WHAT/WHY/WHEN knowledge from Claude Code's training

Both layers are composable and configurable via EnrichmentConfig.
"""

import copy
from typing import Any

from bridge.logging_config import get_logger
from enrichment.config import EnrichmentConfig
from enrichment.structural.base import PatternApplicator
from enrichment.behavioral.base import BehavioralEnricher

logger = get_logger("enrichment")


class ToolEnricher:
    """Pipeline orchestrator for tool enrichment.

    Applies structural patterns (API standard) and beha
…[2651 chars omitted]…
ioral(self, enricher: BehavioralEnricher) -> bool:
        """Check if a behavioral enricher is enabled in config."""
        dimension = enricher.dimension
        if dimension == "what":
            return self.config.enable_what
        elif dimension == "why":
            return self.config.enable_why
        elif dimension == "when":
            return self.config.enable_when
        return False

"""Claude Code xAI Bridge -- Anthropic Messages API to xAI Grok proxy.

Receives Claude Code traffic on /v1/messages, translates to OpenAI format,
forwards to xAI, translates response back. Enrichment hooks inject Agentic
API Standard context.
"""

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, StreamingResponse
import httpx
import os
import json

import time
from dotenv import load_dotenv

from bridge.logging_config import configure_logging, dump_json, get_logger
from translation.forward import anthropic_to_openai, strip_thinking
from translation.reverse import translate_response
from translation.streaming import OpenAIToAnthropicStreamAdapter
from translation.tools import set_tool_enrichment_hook
from enrichment.factory import create_enricher

load_dotenv()
configure_logging()
logger = get_logger("main")

app = FastAPI(title="xai-agentic-claude-bridg
…[3193 chars omitted]…
: "error", "error": {"type": "api_error", "message": str(e),
                                        "suggestion": "Retry the request. Check XAI_API_KEY."},
            "_links": {"retry": {"href": "/v1/messages", "method": "POST"}, "manifest": {"href": "/manifest"}}})


async def _stream(
    openai_body: dict, headers: dict[str, str], bridge_warnings: list[str] | None = None,
) -> StreamingResponse:

/usr/local/lib/python3.12/site-packages/pytest_asyncio/plugin.py:208: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the fixture caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to function scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"

  warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
........................................................................ [ 23%]
........................................................................ [ 46%]
........................................................................ [ 69%]
................................
…[257 chars omitted]…
tte/testclient.py:40
  /usr/local/lib/python3.12/site-packages/starlette/testclient.py:40: DeprecationWarning: The anyio.abc.BlockingPortal alias is deprecated, use anyio.from_thread.BlockingPortal instead.
    _PortalFactoryType = typing.Callable[[], typing.ContextManager[anyio.abc.BlockingPortal]]

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
311 passed, 1 warning in 2.50s

main 10 10
forward 10 10
reverse 10 10
enrichment 10 10
after 10
False
/tmp/tmpk1iu4zhw/request_20261101_235046_908211.json {
  "headers": {
    "Authorization": "[REDACTED]",
    "X-Api-Key": "[REDACTED]"
  },
  "api_key": "[REDACTED]",

  "other": 1
}
{'headers': {'Authorization': '[REDACTED]'}, 'api_key': '[REDACTED]', 'other': 1} {'headers': {'Authorization': 'Bearer secret'}, 'api_key': 'x', 'other': 1}

XAI_API_KEY not set. Requests to xAI will fail.
200
bridge.main INFO POST /v1/messages model=claude messages=1 tools=1
bridge.enrichment INFO Enriching 1 tools: Read
bridge.enrichment DEBUG Enrichment complete structural_patterns=Manifest, HATEOAS, Error Format, Near-Miss, Self-Describing, Quality Gates, Anti-Patterns, Tool Registration
bridge.enrichment DEBUG Tool Read fields added: _anti_patterns, _error_format, _links, _manifest, _near_miss, _quality, _registration, behavioral_what, behavioral_when, behavioral_why, outputSchema
bridge.main DEBUG Translated request: {"model": "grok-4-1-fast-reasoning", "messages": [{"role": "system", "content": "# Identity\n\nYou are Grok (xAI), running inside the Claude Code environment via the xAI bridge. The system prompt below comes from Claude Code and will refer to Claude, Anthropic, and specific Anthropic model names. Disregard those identity
…[3379 chars omitted]…
ect"}}}]}
bridge.main INFO xAI response in 0.00s status=200 stop=tool_calls tool_calls=1 tokens=10/5/15
bridge.main DEBUG xAI response body: {"id": "x", "choices": [{"message": {"role": "assistant", "content": "hi", "tool_calls": [{"id": "1", "function": {"name": "Read", "arguments": "{}"}}]}, "finish_reason": "tool_calls"}], "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}}

/usr/local/lib/python3.12/site-packages/starlette/testclient.py:40: DeprecationWarning: The anyio.abc.BlockingPortal alias is deprecated, use anyio.from_thread.BlockingPortal instead.
    _PortalFactoryType = typing.Callable[[], typing.ContextManager[anyio.abc.BlockingPortal]]

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
311 passed, 1 warning in 1.66s
 enrichment/engine.py          | 23 +++++++++++++++++
 enrichment/system_preamble.py | 59 ++++++++++++++++++++++++++++++++-----------
 main.py                       | 30 +++++++++++++++++++---
 translation/forward.py        | 28 +++++++++++++++++---
 translation/reverse.py        |  2 ++
 5 files changed, 120 insertions(+), 22 deletions(-)

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
311 passed, 1 warning in 1.68s

diff --git a/enrichment/engine.py b/enrichment/engine.py
index ab1c81b..716dc87 100644
--- a/enrichment/engine.py
+++ b/enrichment/engine.py
@@ -13,10 +13,13 @@ Both layers are composable and configurable via EnrichmentConfig.
 import copy
 from typing import Any
 
+from bridge.logging_config import get_logger
 from enrichment.config import EnrichmentConfig
 from enrichment.structural.base import PatternApplicator
 from enrichment.behavioral.base import BehavioralEnricher

 
+logger = get_logger("enrichment")
+
 
 class ToolEnricher:
     """Pipeline orchestrator for tool enrichment.
@@ -43,13 +46,19 @@ class ToolEnricher:
         if self.config.is_passthrough:
             return tools
 
+        tool_names = [tool.get("name", "<unnamed>") for tool in tools]
+        logger.info("Enriching %d tools: %s", len(tools), ", ".join(tool_names))
+
         # Deep copy to avoid mutation
    
…[8629 chars omitted]…
void collisions between rapid requests while
    # keeping the filename in the simple ``<kind>_<timestamp>.json`` form.
    timestamp = time.strftime("%Y%m%d%H%M%S", time.localtime())
    timestamp = f"{timestamp}{int(time.time() * 1_000_000) % 1_000_000:06d}"
    path = dump_dir / f"{kind}_{timestamp}.json"
    path.write_text(json.dumps(data, indent=2, default=str), encoding="utf-8")
    return path

[{'type': 'image', 'source': {'data': 'x'}, 'cache_control': {'type': 'ephemeral'}}, {'type': 'text', 'text': 'Keep me.', 'cache_control': {'type': 'ephemeral'}}]
Traceback (most recent call last):
  File "<stdin>", line 15, in <module>
AssertionError

'Keep me.'

r [{'type': 'image', 'source': {'data': 'x'}, 'cache_control': {'type': 'ephemeral'}}, {'type': 'text', 'text': 'Keep me.', 'cache_control': {'type': 'ephemeral'}}]
empty []
flat 'Keep me.'
# Identity

You are Grok (xAI), running inside the
True

grep: tests/translation/__pycache__/test_forward.cpython-312-pytest-8.3.4.pyc: binary file matches
tests/translation/test_forward.py:40:        When preamble is enabled (default), the system content includes
tests/translation/test_forward.py:41:        the preamble prepended to the original system text.
tests/translation/test_forward.py:49:    def test_system_field_absent_injects_preamble(self) -> None:
tests/translation/test_forward.py:50:        """When no system field is present but preamble is enabled, a system message is injected."""
tests/translation/test_forward.py:60:        assert "Tool Preference Hierarchy" in result["messages"][0]["content"]
tests/translation/test_forward.py:62:    def test_empty_system_field_uses_preamble(self) -> None:
tests/translation/test_forward.py:63:        """An empty system field still produces a system message from preamble."""
tests/translation/
…[1144 chars omitted]…
chment.system_preamble
tests/test_e2e.py:310:            importlib.reload(enrichment.system_preamble)

tests/test_e2e.py:311:            from enrichment.system_preamble import get_system_preamble
tests/test_e2e.py:312:            result = get_system_preamble()
tests/test_e2e.py:314:            assert "Tool Preference Hierarchy" in result
tests/test_e2e.py:315:            assert "You are Grok" in result

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
311 passed, 1 warning in 1.64s
 M enrichment/engine.py
 M enrichment/system_preamble.py
 M main.py
 M translation/forward.py
 M translation/reverse.py
?? bridge/

bridge/logging_config.py
bridge/__init__.py
bridge/__pycache__/logging_config.cpython-312.pyc
bridge/__pycache__/__init__.cpython-312.pyc
# Python bytecode
__pycache__/
__pycache__
*.pyc
*.pyo
*.pyd

# Distribution / packaging

*.egg-info/
*.egg
dist/
build/
.eggs/

# Virtual environments
.venv/
venv/

# Testing
.pytest_cache/

# Environment variables
.env

submitted.