langchain-githubcopilot-chat 0.4.0__tar.gz → 0.5.1__tar.gz

{langchain_githubcopilot_chat-0.4.0 → langchain_githubcopilot_chat-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-githubcopilot-chat
-Version: 0.4.0
+Version: 0.5.1
 Summary: An integration package connecting GithubcopilotChat and LangChain
 Home-page: https://github.com/langchain-ai/langchain
 License: MIT

{langchain_githubcopilot_chat-0.4.0 → langchain_githubcopilot_chat-0.5.1}/langchain_githubcopilot_chat/auth.py

@@ -4,12 +4,16 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 import os
+import threading
 import time
 from typing import Callable, Dict, Optional, Tuple, Union
 
 import httpx
 
+logger = logging.getLogger(__name__)
+
 CLIENT_ID = "Iv1.b507a08c87ecfe98"
 CACHE_PATH = os.path.expanduser("~/.github-copilot-chat.json")
 
@@ -31,7 +35,7 @@ COPILOT_DEFAULT_HEADERS = {
 
 # In-memory lock for token refresh to prevent concurrent refresh attempts
 _token_refresh_lock: Optional[asyncio.Lock] = None
-_sync_token_refresh_lock: bool = False
+_sync_token_refresh_lock: threading.Lock = threading.Lock()
 
 
 def _get_token_refresh_lock() -> asyncio.Lock:
@@ -59,8 +63,8 @@ def save_tokens_to_cache(
                 f,
                 indent=2,
             )
-    except Exception:
-        pass
+    except OSError as exc:
+        logger.warning("Failed to save Copilot token cache to %s: %s", CACHE_PATH, exc)
 
 
 def load_tokens_from_cache() -> Dict[str, str]:
@@ -74,7 +78,12 @@ def load_tokens_from_cache() -> Dict[str, str]:
                     # Token expired, return empty
                     return {}
             return data
-    except Exception:
+    except FileNotFoundError:
+        return {}  # cache doesn't exist yet — silently OK
+    except (OSError, json.JSONDecodeError, KeyError, ValueError) as exc:
+        logger.warning(
+            "Failed to load Copilot token cache from %s: %s", CACHE_PATH, exc
+        )
         return {}
 
 

{langchain_githubcopilot_chat-0.4.0 → langchain_githubcopilot_chat-0.5.1}/langchain_githubcopilot_chat/chat_models.py

@@ -2,8 +2,12 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
+import logging
 import os
+import random
+import time
 from typing import (
     Any,
     AsyncIterator,
@@ -46,17 +50,19 @@ from pydantic import Field, PrivateAttr, SecretStr, model_validator
 
 from langchain_githubcopilot_chat.auth import (
     COPILOT_DEFAULT_HEADERS,
-    COPILOT_EDITOR_VERSION,
-    COPILOT_INTEGRATION_ID,
-    COPILOT_PLUGIN_VERSION,
-    COPILOT_USER_AGENT,
     _get_token_refresh_lock,
+    _sync_token_refresh_lock,
     afetch_copilot_token,
     fetch_copilot_token,
     load_tokens_from_cache,
     save_tokens_to_cache,
 )
 
+logger = logging.getLogger(__name__)
+
+# Buffer (seconds) before token expiry to trigger a proactive refresh
+_TOKEN_REFRESH_BUFFER_SECS: int = 60
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
@@ -204,37 +210,11 @@ def _build_ai_message(
 
     usage_metadata: Optional[UsageMetadata] = None
     if usage:
-        input_token_details: Dict[str, Any] = {}
-        if "prompt_tokens_details" in usage:
-            if "cached_tokens" in usage["prompt_tokens_details"]:
-                input_token_details["cache_read"] = usage["prompt_tokens_details"][
-                    "cached_tokens"
-                ]
-
-        output_token_details: Dict[str, Any] = {}
-        if "reasoning_tokens" in usage:
-            output_token_details["reasoning"] = usage["reasoning_tokens"]
-        if "completion_tokens_details" in usage:
-            if "accepted_prediction_tokens" in usage["completion_tokens_details"]:
-                output_token_details["accepted_prediction"] = usage[
-                    "completion_tokens_details"
-                ]["accepted_prediction_tokens"]
-            if "rejected_prediction_tokens" in usage["completion_tokens_details"]:
-                output_token_details["rejected_prediction"] = usage[
-                    "completion_tokens_details"
-                ]["rejected_prediction_tokens"]
-
-        kwargs = {
-            "input_tokens": usage.get("prompt_tokens", 0),
-            "output_tokens": usage.get("completion_tokens", 0),
-            "total_tokens": usage.get("total_tokens", 0),
-        }
-        if input_token_details:
-            kwargs["input_token_details"] = input_token_details
-        if output_token_details:
-            kwargs["output_token_details"] = output_token_details
-
-        usage_metadata = UsageMetadata(**kwargs)
+        usage_metadata = UsageMetadata(
+            input_tokens=usage.get("prompt_tokens", 0),
+            output_tokens=usage.get("completion_tokens", 0),
+            total_tokens=usage.get("total_tokens", 0),
+        )
 
     response_metadata: Dict[str, Any] = {
         "finish_reason": finish_reason,
@@ -480,6 +460,7 @@ class ChatGithubCopilot(BaseChatModel):
     # ------------------------------------------------------------------
 
     _cached_copilot_token: Optional[str] = PrivateAttr(default=None)
+    _cached_copilot_token_expires_at: Optional[float] = PrivateAttr(default=None)
 
     @model_validator(mode="before")
     @classmethod
@@ -510,8 +491,19 @@ class ChatGithubCopilot(BaseChatModel):
     @property
     def _token(self) -> str:
         """Return the raw GitHub token string."""
-        if self._cached_copilot_token:
-            return self._cached_copilot_token
+        # Use getattr to avoid triggering Pydantic's __getattr__ on PrivateAttr
+        # when instance is created via __new__ without proper initialization
+        cached = getattr(self, "_cached_copilot_token", None)
+        cached_exp = getattr(self, "_cached_copilot_token_expires_at", None)
+        if cached:
+            expires_ok = cached_exp is None or (
+                time.time() < cached_exp - _TOKEN_REFRESH_BUFFER_SECS
+            )
+            if expires_ok:
+                return cached
+            # Token is expired or within the refresh buffer — clear and refresh
+            self._cached_copilot_token = None
+            self._cached_copilot_token_expires_at = None
 
         token = None
         if self.github_token:
@@ -522,6 +514,10 @@ class ChatGithubCopilot(BaseChatModel):
             tokens = load_tokens_from_cache()
             if "copilot_token" in tokens:
                 self._cached_copilot_token = tokens["copilot_token"]
+                raw_exp = tokens.get("expires_at")
+                self._cached_copilot_token_expires_at = (
+                    float(raw_exp) if raw_exp is not None else None
+                )
                 return tokens["copilot_token"]
             elif "github_token" in tokens:
                 token = tokens["github_token"]
@@ -533,20 +529,28 @@ class ChatGithubCopilot(BaseChatModel):
                 "to authenticate."
             )
 
-        # If the token is a standard GitHub token, exchange it
+        # If the token is a standard GitHub token, try to exchange it
+        # for a Copilot token. This may fail in environments without
+        # network access (e.g., CI), so we catch exceptions.
         if token.startswith(("gho_", "ghp_", "ghu_")):
-            self._refresh_token_sync(token)
-            if self._cached_copilot_token:
-                return self._cached_copilot_token
+            try:
+                self._refresh_token_sync(token)
+                cached = getattr(self, "_cached_copilot_token", None)
+                if cached:
+                    return cached
+            except Exception as exc:
+                # Network unavailable, socket blocked, or other transient error.
+                # Fall back to using the raw GitHub token directly.
+                logger.debug(
+                    "Token exchange failed (will use raw GitHub token): %s", exc
+                )
 
         return token
 
     def _refresh_token_sync(self, github_token: Optional[str] = None) -> None:
-        # Use lock to prevent concurrent token refresh
-        global _sync_token_refresh_lock
-        if _sync_token_refresh_lock:
+        # Non-blocking acquire: if another thread is already refreshing, skip
+        if not _sync_token_refresh_lock.acquire(blocking=False):
             return
-        _sync_token_refresh_lock = True
         try:
             token_to_use = github_token or (
                 self.github_token.get_secret_value() if self.github_token else None
@@ -559,9 +563,10 @@ class ChatGithubCopilot(BaseChatModel):
                 new_token, expires_at = fetch_copilot_token(token_to_use)
                 if new_token:
                     self._cached_copilot_token = new_token
+                    self._cached_copilot_token_expires_at = expires_at
                     save_tokens_to_cache(token_to_use, new_token, expires_at)
         finally:
-            _sync_token_refresh_lock = False
+            _sync_token_refresh_lock.release()
 
     async def _refresh_token_async(self, github_token: Optional[str] = None) -> None:
         lock = _get_token_refresh_lock()
@@ -577,6 +582,7 @@ class ChatGithubCopilot(BaseChatModel):
                 new_token, expires_at = await afetch_copilot_token(token_to_use)
                 if new_token:
                     self._cached_copilot_token = new_token
+                    self._cached_copilot_token_expires_at = expires_at
                     save_tokens_to_cache(token_to_use, new_token, expires_at)
 
     @property
@@ -673,8 +679,6 @@ class ChatGithubCopilot(BaseChatModel):
 
     def _do_request(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         """Perform a synchronous (non-streaming) HTTP POST with retries."""
-        import time
-
         headers = self._build_headers()
         last_exc: Optional[Exception] = None
         for attempt in range(self.max_retries + 1):
@@ -710,35 +714,56 @@ class ChatGithubCopilot(BaseChatModel):
                 if attempt == self.max_retries:
                     raise
             if attempt < self.max_retries:
-                time.sleep(2**attempt)
+                backoff = 2**attempt
+                time.sleep(backoff + random.uniform(0, backoff * 0.25))
         raise RuntimeError("Unexpected retry loop exit") from last_exc
 
     def _do_stream(self, payload: Dict[str, Any]) -> Iterator[Dict[str, Any]]:
         """Perform a synchronous streaming HTTP POST and yield parsed SSE chunks."""
         headers = self._build_headers()
-        with httpx.stream(
-            "POST",
-            self._inference_url,
-            headers=headers,
-            json=payload,
-            timeout=self.timeout,
-        ) as response:
-            response.raise_for_status()
-            for line in response.iter_lines():
-                line = line.strip()
-                if not line or line == "data: [DONE]":
-                    continue
-                if line.startswith("data: "):
-                    line = line[len("data: ") :]
-                try:
-                    yield json.loads(line)
-                except json.JSONDecodeError:
-                    continue
+        last_exc: Optional[Exception] = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                with httpx.stream(
+                    "POST",
+                    self._inference_url,
+                    headers=headers,
+                    json=payload,
+                    timeout=self.timeout,
+                ) as response:
+                    if response.status_code == 401:
+                        self._refresh_token_sync()
+                        headers = self._build_headers()
+                        raise httpx.TransportError("401 — token refreshed, retrying")
+                    response.raise_for_status()
+                    for line in response.iter_lines():
+                        line = line.strip()
+                        if not line or line == "data: [DONE]":
+                            continue
+                        if line.startswith("data: "):
+                            line = line[len("data: ") :]
+                        try:
+                            yield json.loads(line)
+                        except json.JSONDecodeError:
+                            continue
+                    return
+            except (httpx.TimeoutException, httpx.TransportError) as exc:
+                last_exc = exc
+                if attempt == self.max_retries:
+                    raise
+            except httpx.HTTPStatusError as exc:
+                if exc.response.status_code < 500:
+                    raise
+                last_exc = exc
+                if attempt == self.max_retries:
+                    raise
+            if attempt < self.max_retries:
+                backoff = 2**attempt
+                time.sleep(backoff + random.uniform(0, backoff * 0.25))
+        raise RuntimeError("Unexpected retry loop exit") from last_exc
 
     async def _do_request_async(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         """Perform an asynchronous (non-streaming) HTTP POST with retries."""
-        import asyncio
-
         headers = self._build_headers()
         last_exc: Optional[Exception] = None
         async with httpx.AsyncClient(timeout=self.timeout) as client:
@@ -772,7 +797,8 @@ class ChatGithubCopilot(BaseChatModel):
                     if attempt == self.max_retries:
                         raise
                 if attempt < self.max_retries:
-                    await asyncio.sleep(2**attempt)
+                    backoff = 2**attempt
+                    await asyncio.sleep(backoff + random.uniform(0, backoff * 0.25))
         raise RuntimeError("Unexpected retry loop exit") from last_exc
 
     async def _do_stream_async(
@@ -780,24 +806,48 @@ class ChatGithubCopilot(BaseChatModel):
     ) -> AsyncIterator[Dict[str, Any]]:
         """Perform an asynchronous streaming HTTP POST and yield parsed SSE chunks."""
         headers = self._build_headers()
-        async with httpx.AsyncClient(timeout=self.timeout) as client:
-            async with client.stream(
-                "POST",
-                self._inference_url,
-                headers=headers,
-                json=payload,
-            ) as response:
-                response.raise_for_status()
-                async for line in response.aiter_lines():
-                    line = line.strip()
-                    if not line or line == "data: [DONE]":
-                        continue
-                    if line.startswith("data: "):
-                        line = line[len("data: ") :]
-                    try:
-                        yield json.loads(line)
-                    except json.JSONDecodeError:
-                        continue
+        last_exc: Optional[Exception] = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                async with httpx.AsyncClient(timeout=self.timeout) as client:
+                    async with client.stream(
+                        "POST",
+                        self._inference_url,
+                        headers=headers,
+                        json=payload,
+                    ) as response:
+                        if response.status_code == 401:
+                            await self._refresh_token_async()
+                            headers = self._build_headers()
+                            raise httpx.TransportError(
+                                "401 — token refreshed, retrying"
+                            )
+                        response.raise_for_status()
+                        async for line in response.aiter_lines():
+                            line = line.strip()
+                            if not line or line == "data: [DONE]":
+                                continue
+                            if line.startswith("data: "):
+                                line = line[len("data: ") :]
+                            try:
+                                yield json.loads(line)
+                            except json.JSONDecodeError:
+                                continue
+                        return
+            except (httpx.TimeoutException, httpx.TransportError) as exc:
+                last_exc = exc
+                if attempt == self.max_retries:
+                    raise
+            except httpx.HTTPStatusError as exc:
+                if exc.response.status_code < 500:
+                    raise
+                last_exc = exc
+                if attempt == self.max_retries:
+                    raise
+            if attempt < self.max_retries:
+                backoff = 2**attempt
+                await asyncio.sleep(backoff + random.uniform(0, backoff * 0.25))
+        raise RuntimeError("Unexpected retry loop exit") from last_exc
 
     # ------------------------------------------------------------------
     # Stream delta → AIMessageChunk helpers
@@ -850,6 +900,21 @@ class ChatGithubCopilot(BaseChatModel):
             usage_metadata=usage_metadata,
         )
 
+    @staticmethod
+    def _make_usage_chunk(usage: Dict[str, Any]) -> ChatGenerationChunk:
+        """Build a usage-only final ``ChatGenerationChunk`` from a usage dict."""
+        return ChatGenerationChunk(
+            message=AIMessageChunk(
+                content="",
+                usage_metadata=UsageMetadata(
+                    input_tokens=usage.get("prompt_tokens", 0),
+                    output_tokens=usage.get("completion_tokens", 0),
+                    total_tokens=usage.get("total_tokens", 0),
+                ),
+                response_metadata={"usage": usage},
+            )
+        )
+
     # ------------------------------------------------------------------
     # LangChain BaseChatModel interface
     # ------------------------------------------------------------------
@@ -924,17 +989,7 @@ class ChatGithubCopilot(BaseChatModel):
 
             if not choices and usage:
                 # Final usage-only chunk
-                chunk = ChatGenerationChunk(
-                    message=AIMessageChunk(
-                        content="",
-                        usage_metadata=UsageMetadata(
-                            input_tokens=usage.get("prompt_tokens", 0),
-                            output_tokens=usage.get("completion_tokens", 0),
-                            total_tokens=usage.get("total_tokens", 0),
-                        ),
-                        response_metadata={"usage": usage},
-                    )
-                )
+                chunk = self._make_usage_chunk(usage)
                 if run_manager:
                     run_manager.on_llm_new_token("", chunk=chunk)
                 yield chunk
@@ -990,17 +1045,7 @@ class ChatGithubCopilot(BaseChatModel):
             usage = raw_chunk.get("usage")
 
             if not choices and usage:
-                chunk = ChatGenerationChunk(
-                    message=AIMessageChunk(
-                        content="",
-                        usage_metadata=UsageMetadata(
-                            input_tokens=usage.get("prompt_tokens", 0),
-                            output_tokens=usage.get("completion_tokens", 0),
-                            total_tokens=usage.get("total_tokens", 0),
-                        ),
-                        response_metadata={"usage": usage},
-                    )
-                )
+                chunk = self._make_usage_chunk(usage)
                 if run_manager:
                     await run_manager.on_llm_new_token("", chunk=chunk)
                 yield chunk

{langchain_githubcopilot_chat-0.4.0 → langchain_githubcopilot_chat-0.5.1}/langchain_githubcopilot_chat/embeddings.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
 import os
+import random
+import time
 from typing import Any, Dict, List, Optional, Union
 
 import httpx
@@ -211,6 +214,9 @@ class GithubcopilotChatEmbeddings(BaseModel, Embeddings):
                 last_exc = exc
                 if attempt == self.max_retries:
                     raise
+            if attempt < self.max_retries:
+                backoff = 2**attempt
+                time.sleep(backoff + random.uniform(0, backoff * 0.25))
         raise RuntimeError("Unexpected retry loop exit") from last_exc
 
     async def _do_request_async(self, payload: Dict[str, Any]) -> Dict[str, Any]:
@@ -237,6 +243,9 @@ class GithubcopilotChatEmbeddings(BaseModel, Embeddings):
                     last_exc = exc
                     if attempt == self.max_retries:
                         raise
+                if attempt < self.max_retries:
+                    backoff = 2**attempt
+                    await asyncio.sleep(backoff + random.uniform(0, backoff * 0.25))
         raise RuntimeError("Unexpected retry loop exit") from last_exc
 
     @staticmethod

{langchain_githubcopilot_chat-0.4.0 → langchain_githubcopilot_chat-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "langchain-githubcopilot-chat"
-version = "0.4.0"
+version = "0.5.1"
 description = "An integration package connecting GithubcopilotChat and LangChain"
 authors = ["YIhan Wu <iumm@ibat.ac.cn>"]
 readme = "README.md"