copilotx 2.3.2__tar.gz → 2.3.4__tar.gz

{copilotx-2.3.2 → copilotx-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: copilotx
-Version: 2.3.2
+Version: 2.3.4
 Summary: Local GitHub Copilot API proxy — use GPT-4o, Claude, Gemini via OpenAI/Anthropic compatible APIs
 Project-URL: Homepage, https://github.com/Polly2014/CopilotX
 Project-URL: Repository, https://github.com/Polly2014/CopilotX
@@ -72,7 +72,7 @@ copilotx serve
 
 Output:
 ```
-🚀 CopilotX v2.2.1
+🚀 CopilotX v2.3.3
 ✅ Copilot Token valid (28m remaining, auto-refresh)
 � Local mode (localhost only)
 🎯 API: api.enterprise.githubcopilot.com (auto-detected)

{copilotx-2.3.2 → copilotx-2.3.4}/README.md

@@ -47,7 +47,7 @@ copilotx serve
 
 Output:
 ```
-🚀 CopilotX v2.2.1
+🚀 CopilotX v2.3.3
 ✅ Copilot Token valid (28m remaining, auto-refresh)
 � Local mode (localhost only)
 🎯 API: api.enterprise.githubcopilot.com (auto-detected)

{copilotx-2.3.2 → copilotx-2.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "copilotx"
-version = "2.3.2"
+version = "2.3.4"
 description = "Local GitHub Copilot API proxy — use GPT-4o, Claude, Gemini via OpenAI/Anthropic compatible APIs"
 readme = "README.md"
 license = { text = "MIT" }

{copilotx-2.3.2 → copilotx-2.3.4}/src/copilotx/proxy/client.py

@@ -85,11 +85,14 @@ class CopilotClient:
 
     # ── Chat Completions (non-streaming) ────────────────────────────
 
-    async def chat_completions(self, payload: dict) -> dict:
+    async def chat_completions(self, payload: dict, *, vision: bool = False) -> dict:
         """POST /chat/completions — non-streaming."""
         assert self._client is not None
         url = f"{self._api_base}{COPILOT_CHAT_COMPLETIONS_PATH}"
-        resp = await self._client.post(url, json=payload, headers=self._headers())
+        extra: dict[str, str] = {}
+        if vision:
+            extra["copilot-vision-request"] = "true"
+        resp = await self._client.post(url, json=payload, headers=self._headers(extra))
         if resp.status_code >= 400:
             error_body = resp.text
             logger.error(
@@ -105,14 +108,17 @@ class CopilotClient:
 
     # ── Chat Completions (streaming) ────────────────────────────────
 
-    async def chat_completions_stream(self, payload: dict) -> AsyncIterator[bytes]:
+    async def chat_completions_stream(self, payload: dict, *, vision: bool = False) -> AsyncIterator[bytes]:
         """POST /chat/completions with stream=true — yields raw SSE lines."""
         assert self._client is not None
         payload["stream"] = True
         url = f"{self._api_base}{COPILOT_CHAT_COMPLETIONS_PATH}"
+        extra: dict[str, str] = {}
+        if vision:
+            extra["copilot-vision-request"] = "true"
 
         async with self._client.stream(
-            "POST", url, json=payload, headers=self._headers(),
+            "POST", url, json=payload, headers=self._headers(extra),
         ) as resp:
             if resp.status_code >= 400:
                 error_body = await resp.aread()
@@ -126,10 +132,11 @@ class CopilotClient:
                     response=resp,
                 )
             async for line in resp.aiter_lines():
-                if line:
-                    yield (line + "\n").encode("utf-8")
-            # Ensure final newline
-            yield b"\n"
+                # Yield ALL lines including empty ones — empty lines are
+                # SSE event delimiters and MUST be preserved for clients
+                # (e.g. OpenAI Python SDK) that rely on them to separate
+                # JSON chunks.
+                yield (line + "\n").encode("utf-8")
 
     # ── Responses API (non-streaming) ───────────────────────────────
 

{copilotx-2.3.2 → copilotx-2.3.4}/src/copilotx/proxy/translator.py

@@ -209,29 +209,33 @@ def anthropic_to_openai_request(body: dict) -> dict:
 
             # --- Handle user messages with tool_result blocks ---
             elif tool_result_blocks:
-                # If there's also regular text content, add it first
-                if text_parts:
-                    if has_non_text or len(text_parts) > 1:
-                        messages.append({"role": role, "content": text_parts})
-                    else:
-                        text = "\n".join(
-                            p["text"] for p in text_parts if p.get("type") == "text"
-                        )
-                        if text:
-                            messages.append({"role": role, "content": text})
-
-                # Convert each tool_result → OpenAI tool message
+                # Convert each tool_result → OpenAI tool message FIRST
+                # (OpenAI requires tool messages immediately after the
+                #  assistant message with tool_calls — no user message
+                #  in between)
                 for tr in tool_result_blocks:
                     tool_content = tr.get("content", "")
                     # Anthropic tool_result content can be string or list of blocks
                     if isinstance(tool_content, list):
-                        parts = []
+                        text_parts_tr: list[str] = []
+                        image_count = 0
                         for tc_block in tool_content:
                             if isinstance(tc_block, str):
-                                parts.append(tc_block)
+                                text_parts_tr.append(tc_block)
                             elif tc_block.get("type") == "text":
-                                parts.append(tc_block["text"])
-                        tool_content = "\n".join(parts)
+                                text_parts_tr.append(tc_block["text"])
+                            elif tc_block.get("type") == "image":
+                                image_count += 1
+
+                        if text_parts_tr:
+                            tool_content = "\n".join(text_parts_tr)
+                            if image_count:
+                                tool_content += f"\n[+{image_count} image(s) omitted from tool result]"
+                        elif image_count:
+                            # Tool result only has images, no text
+                            tool_content = f"[Tool returned {image_count} image(s) — content processed by the model in a previous turn]"
+                        else:
+                            tool_content = ""
                     elif not isinstance(tool_content, str):
                         tool_content = json.dumps(tool_content)
 
@@ -246,6 +250,17 @@ def anthropic_to_openai_request(body: dict) -> dict:
                         tool_msg["content"] = f"[ERROR] {tool_content}"
                     messages.append(tool_msg)
 
+                # Add any accompanying text content AFTER tool messages
+                if text_parts:
+                    if has_non_text or len(text_parts) > 1:
+                        messages.append({"role": role, "content": text_parts})
+                    else:
+                        text = "\n".join(
+                            p["text"] for p in text_parts if p.get("type") == "text"
+                        )
+                        if text:
+                            messages.append({"role": role, "content": text})
+
             # --- Regular content (no tool blocks) ---
             else:
                 if has_non_text or len(text_parts) > 1:

{copilotx-2.3.2 → copilotx-2.3.4}/src/copilotx/server/routes_anthropic.py

@@ -25,6 +25,23 @@ logger = logging.getLogger(__name__)
 router = APIRouter(tags=["Anthropic"])
 
 
+def _has_vision_content(body: dict) -> bool:
+    """Check if an Anthropic /v1/messages request contains image content.
+    
+    Checks direct image blocks in message content (user/assistant messages).
+    Note: Images in tool_result blocks are replaced with placeholder text
+    during translation, so they don't require the vision header.
+    """
+    for msg in body.get("messages", []):
+        content = msg.get("content")
+        if not isinstance(content, list):
+            continue
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "image":
+                return True
+    return False
+
+
 @router.post("/v1/messages")
 async def messages(request: Request):
     """Anthropic-compatible messages endpoint.
@@ -35,31 +52,40 @@ async def messages(request: Request):
     body = await request.json()
     model = body.get("model", "gpt-4o")
     is_stream = body.get("stream", False)
+    vision = _has_vision_content(body)
 
-    # Log the incoming request for debugging
+    # Log the incoming request
     logger.info(
-        "Anthropic request: model=%s stream=%s max_tokens=%s tools=%d keys=%s",
+        "Anthropic request: model=%s stream=%s max_tokens=%s tools=%d vision=%s msgs=%d",
         model,
         is_stream,
         body.get("max_tokens"),
         len(body.get("tools", [])),
-        list(body.keys()),
+        vision,
+        len(body.get("messages", [])),
     )
 
     # Translate Anthropic request → OpenAI request
     openai_payload = anthropic_to_openai_request(body)
+    mapped_model = openai_payload.get("model", "?")
+    if mapped_model != model:
+        logger.info("Model mapped: %s → %s", model, mapped_model)
 
     client = await get_ready_client(request.app.state)
 
     try:
         if is_stream:
             # Stream: OpenAI SSE → Anthropic SSE
-            openai_stream = client.chat_completions_stream(openai_payload)
+            openai_stream = client.chat_completions_stream(
+                openai_payload, vision=vision,
+            )
             anthropic_stream = openai_stream_to_anthropic_stream(openai_stream, model)
             return sse_response(anthropic_stream)
         else:
             # Non-stream: translate response
-            openai_resp = await client.chat_completions(openai_payload)
+            openai_resp = await client.chat_completions(
+                openai_payload, vision=vision,
+            )
             anthropic_resp = openai_to_anthropic_response(openai_resp, model)
             return JSONResponse(content=anthropic_resp)
     except Exception as e: