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

langchain_githubcopilot_chat-0.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YIhan Wu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_githubcopilot_chat-0.4.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.1
+Name: langchain-githubcopilot-chat
+Version: 0.4.0
+Summary: An integration package connecting GithubcopilotChat and LangChain
+Home-page: https://github.com/langchain-ai/langchain
+License: MIT
+Author: YIhan Wu
+Author-email: iumm@ibat.ac.cn
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: httpx (>=0.28.1)
+Requires-Dist: langchain-core (>=1.1.0,<2.0.0)
+Project-URL: Repository, https://github.com/langchain-ai/langchain
+Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22githubcopilot-chat%3D%3D0%22&expanded=true
+Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/partners/githubcopilot-chat
+Description-Content-Type: text/markdown
+
+# LangChain GitHub Copilot Chat
+
+This package provides a LangChain integration for **GitHub Copilot**, allowing you to use Copilot's models (including GPT-4o, Claude 3.5 Sonnet, etc.) as standard LangChain `BaseChatModel` components.
+
+Unlike other integrations, this package mimics the official VS Code Copilot Chat extension behavior, providing access to the full suite of models available to Copilot subscribers.
+
+## 🚀 Features
+
+- **Real Copilot API**: Connects to `api.githubcopilot.com` using official VS Code headers.
+- **Easy Auth**: Built-in GitHub Device Flow for acquiring a valid Copilot Token.
+- **Model Discovery**: Dynamic fetching of all models authorized for your account.
+- **LangChain Native**: Full support for Streaming, Tool Calling, and Async operations.
+
+## 📦 Installation
+
+```bash
+pip install -U langchain-githubcopilot-chat
+```
+
+## 🔐 Authentication
+
+To use GitHub Copilot, you need a valid Copilot Token. You can obtain one interactively using the built-in helper:
+
+```python
+from langchain_githubcopilot_chat import get_vscode_token
+
+# This will prompt you to visit a GitHub URL and enter a code
+token = get_vscode_token()
+print(f"Your Token: {token}")
+```
+
+For custom output handling (e.g., in GUI applications), pass a callback:
+
+```python
+from langchain_githubcopilot_chat import get_copilot_token
+
+def on_message(msg):
+    # Handle status messages (e.g., display in UI)
+    print(f"[Copilot] {msg}")
+
+token = get_vscode_token(callback=on_message)
+```
+
+Alternatively, set it as an environment variable:
+```bash
+export GITHUB_TOKEN="your_copilot_token_here"
+```
+
+## 🛠 Usage
+
+### Chat Models
+
+Access any model supported by Copilot (e.g., `gpt-4o`, `gpt-4o-mini`, `claude-3.5-sonnet`).
+
+```python
+from langchain_githubcopilot_chat import ChatGithubCopilot
+
+# Initialize with a specific model
+llm = ChatGithubCopilot(
+    model="gpt-4o", 
+    temperature=0.7
+)
+
+# Simple invocation
+response = llm.invoke("Explain Quantum Entanglement in one sentence.")
+print(response.content)
+
+# Streaming
+for chunk in llm.stream("Write a short poem about coding."):
+    print(chunk.content, end="", flush=True)
+```
+
+### Discovery Available Models
+
+GitHub Copilot periodically updates its available models. You can list what's currently available for your token:
+
+```python
+from langchain_githubcopilot_chat import get_available_models
+
+models = get_available_models()
+for model in models:
+    print(f"ID: {model['id']} - Name: {model.get('name')}")
+```
+
+### Embeddings
+
+Use Copilot's embedding models for RAG or semantic search:
+
+```python
+from langchain_githubcopilot_chat import GithubcopilotChatEmbeddings
+
+embeddings = GithubcopilotChatEmbeddings(model="text-embedding-3-small")
+vector = embeddings.embed_query("GitHub Copilot is awesome!")
+```
+
+## 📖 Advanced: Tool Calling
+
+```python
+from pydantic import BaseModel, Field
+from langchain_githubcopilot_chat import ChatGithubCopilot
+
+class GetWeather(BaseModel):
+    """Get the current weather in a given location."""
+    location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+
+llm = ChatGithubCopilot(model="gpt-4o")
+llm_with_tools = llm.bind_tools([GetWeather])
+
+ai_msg = llm_with_tools.invoke("What's the weather like in Tokyo?")
+print(ai_msg.tool_calls)
+```
+
+## ⚖️ Disclaimer
+
+This project is an independent community integration and is not affiliated with, endorsed by, or supported by GitHub, Inc. Usage of this package must comply with GitHub's [Terms of Service](https://docs.github.com/en/site-policy/github-terms/github-terms-of-service).

langchain_githubcopilot_chat-0.4.0/README.md

@@ -0,0 +1,115 @@
+# LangChain GitHub Copilot Chat
+
+This package provides a LangChain integration for **GitHub Copilot**, allowing you to use Copilot's models (including GPT-4o, Claude 3.5 Sonnet, etc.) as standard LangChain `BaseChatModel` components.
+
+Unlike other integrations, this package mimics the official VS Code Copilot Chat extension behavior, providing access to the full suite of models available to Copilot subscribers.
+
+## 🚀 Features
+
+- **Real Copilot API**: Connects to `api.githubcopilot.com` using official VS Code headers.
+- **Easy Auth**: Built-in GitHub Device Flow for acquiring a valid Copilot Token.
+- **Model Discovery**: Dynamic fetching of all models authorized for your account.
+- **LangChain Native**: Full support for Streaming, Tool Calling, and Async operations.
+
+## 📦 Installation
+
+```bash
+pip install -U langchain-githubcopilot-chat
+```
+
+## 🔐 Authentication
+
+To use GitHub Copilot, you need a valid Copilot Token. You can obtain one interactively using the built-in helper:
+
+```python
+from langchain_githubcopilot_chat import get_vscode_token
+
+# This will prompt you to visit a GitHub URL and enter a code
+token = get_vscode_token()
+print(f"Your Token: {token}")
+```
+
+For custom output handling (e.g., in GUI applications), pass a callback:
+
+```python
+from langchain_githubcopilot_chat import get_copilot_token
+
+def on_message(msg):
+    # Handle status messages (e.g., display in UI)
+    print(f"[Copilot] {msg}")
+
+token = get_vscode_token(callback=on_message)
+```
+
+Alternatively, set it as an environment variable:
+```bash
+export GITHUB_TOKEN="your_copilot_token_here"
+```
+
+## 🛠 Usage
+
+### Chat Models
+
+Access any model supported by Copilot (e.g., `gpt-4o`, `gpt-4o-mini`, `claude-3.5-sonnet`).
+
+```python
+from langchain_githubcopilot_chat import ChatGithubCopilot
+
+# Initialize with a specific model
+llm = ChatGithubCopilot(
+    model="gpt-4o", 
+    temperature=0.7
+)
+
+# Simple invocation
+response = llm.invoke("Explain Quantum Entanglement in one sentence.")
+print(response.content)
+
+# Streaming
+for chunk in llm.stream("Write a short poem about coding."):
+    print(chunk.content, end="", flush=True)
+```
+
+### Discovery Available Models
+
+GitHub Copilot periodically updates its available models. You can list what's currently available for your token:
+
+```python
+from langchain_githubcopilot_chat import get_available_models
+
+models = get_available_models()
+for model in models:
+    print(f"ID: {model['id']} - Name: {model.get('name')}")
+```
+
+### Embeddings
+
+Use Copilot's embedding models for RAG or semantic search:
+
+```python
+from langchain_githubcopilot_chat import GithubcopilotChatEmbeddings
+
+embeddings = GithubcopilotChatEmbeddings(model="text-embedding-3-small")
+vector = embeddings.embed_query("GitHub Copilot is awesome!")
+```
+
+## 📖 Advanced: Tool Calling
+
+```python
+from pydantic import BaseModel, Field
+from langchain_githubcopilot_chat import ChatGithubCopilot
+
+class GetWeather(BaseModel):
+    """Get the current weather in a given location."""
+    location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+
+llm = ChatGithubCopilot(model="gpt-4o")
+llm_with_tools = llm.bind_tools([GetWeather])
+
+ai_msg = llm_with_tools.invoke("What's the weather like in Tokyo?")
+print(ai_msg.tool_calls)
+```
+
+## ⚖️ Disclaimer
+
+This project is an independent community integration and is not affiliated with, endorsed by, or supported by GitHub, Inc. Usage of this package must comply with GitHub's [Terms of Service](https://docs.github.com/en/site-policy/github-terms/github-terms-of-service).

langchain_githubcopilot_chat-0.4.0/langchain_githubcopilot_chat/auth.py

@@ -0,0 +1,216 @@
+"""Authentication utilities for GitHub Copilot."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import time
+from typing import Callable, Dict, Optional, Tuple, Union
+
+import httpx
+
+CLIENT_ID = "Iv1.b507a08c87ecfe98"
+CACHE_PATH = os.path.expanduser("~/.github-copilot-chat.json")
+
+# Shared Copilot headers
+COPILOT_EDITOR_VERSION = "vscode/1.104.1"
+COPILOT_PLUGIN_VERSION = "copilot-chat/0.26.7"
+COPILOT_INTEGRATION_ID = "vscode-chat"
+COPILOT_USER_AGENT = "GitHubCopilotChat/0.26.7"
+
+COPILOT_DEFAULT_HEADERS = {
+    "Copilot-Integration-Id": COPILOT_INTEGRATION_ID,
+    "User-Agent": COPILOT_USER_AGENT,
+    "Editor-Version": COPILOT_EDITOR_VERSION,
+    "Editor-Plugin-Version": COPILOT_PLUGIN_VERSION,
+    "editor-version": COPILOT_EDITOR_VERSION,
+    "editor-plugin-version": COPILOT_PLUGIN_VERSION,
+    "copilot-vision-request": "true",
+}
+
+# In-memory lock for token refresh to prevent concurrent refresh attempts
+_token_refresh_lock: Optional[asyncio.Lock] = None
+_sync_token_refresh_lock: bool = False
+
+
+def _get_token_refresh_lock() -> asyncio.Lock:
+    """Get or create the async token refresh lock."""
+    global _token_refresh_lock
+    if _token_refresh_lock is None:
+        _token_refresh_lock = asyncio.Lock()
+    return _token_refresh_lock
+
+
+def save_tokens_to_cache(
+    github_token: str,
+    copilot_token: str,
+    expires_at: Optional[float] = None,
+) -> None:
+    """Save tokens to cache with optional expiration time."""
+    try:
+        with open(CACHE_PATH, "w") as f:
+            json.dump(
+                {
+                    "github_token": github_token,
+                    "copilot_token": copilot_token,
+                    "expires_at": expires_at,
+                },
+                f,
+                indent=2,
+            )
+    except Exception:
+        pass
+
+
+def load_tokens_from_cache() -> Dict[str, str]:
+    """Load tokens from cache, checking expiration if present."""
+    try:
+        with open(CACHE_PATH, "r") as f:
+            data = json.load(f)
+            # Check if token has expired
+            if data.get("expires_at"):
+                if time.time() > data["expires_at"]:
+                    # Token expired, return empty
+                    return {}
+            return data
+    except Exception:
+        return {}
+
+
+def fetch_copilot_token(github_token: str) -> Tuple[Optional[str], Optional[float]]:
+    """Fetch copilot token and return it with expiration time.
+
+    Returns:
+        Tuple of (token, expires_at_timestamp). expires_at is None if not provided.
+    """
+    headers = {
+        "Authorization": f"token {github_token}",
+        "Accept": "application/json",
+        **COPILOT_DEFAULT_HEADERS,
+    }
+    with httpx.Client() as client:
+        res = client.get(
+            "https://api.github.com/copilot_internal/v2/token",
+            headers=headers,
+        )
+        if res.status_code == 200:
+            data = res.json()
+            token = data.get("token")
+            # Copilot tokens typically expire in a few hours
+            # The API may return 'expires_at' as a Unix timestamp
+            expires_at = data.get("expires_at")
+            return token, expires_at
+    return None, None
+
+
+async def afetch_copilot_token(
+    github_token: str,
+) -> Tuple[Optional[str], Optional[float]]:
+    """Async fetch copilot token and return it with expiration time.
+
+    Returns:
+        Tuple of (token, expires_at_timestamp). expires_at is None if not provided.
+    """
+    headers = {
+        "Authorization": f"token {github_token}",
+        "Accept": "application/json",
+        **COPILOT_DEFAULT_HEADERS,
+    }
+    async with httpx.AsyncClient() as client:
+        res = await client.get(
+            "https://api.github.com/copilot_internal/v2/token",
+            headers=headers,
+        )
+        if res.status_code == 200:
+            data = res.json()
+            token = data.get("token")
+            expires_at = data.get("expires_at")
+            return token, expires_at
+    return None, None
+
+
+def get_copilot_token(
+    client_id: str = CLIENT_ID,
+    callback: Optional[Callable[[str], None]] = None,
+    return_both: bool = False,
+) -> Union[Optional[str], Tuple[Optional[str], Optional[str]]]:
+    """
+    Authenticate via GitHub Device Flow to get a Copilot Token.
+    This function will block and wait for the user to complete the
+    authorization in their browser.
+
+    Args:
+        client_id: The GitHub OAuth App Client ID to use. Defaults
+            to the VS Code Copilot Chat client ID.
+        callback: Optional callable that receives status messages instead of
+            printing them. If None, messages are printed to stdout.
+
+    Returns:
+        The fetched Copilot Token string, or None if authentication failed.
+    """
+
+    def _print(msg: str) -> None:
+        if callback:
+            callback(msg)
+        else:
+            print(msg)  # noqa: T201
+
+    _print("1. Requesting device code from GitHub...")
+    with httpx.Client() as client:
+        res = client.post(
+            "https://github.com/login/device/code",
+            headers={"Accept": "application/json"},
+            data={"client_id": client_id, "scope": "read:user"},
+        )
+        res.raise_for_status()
+        data = res.json()
+
+    device_code = data.get("device_code")
+    user_code = data.get("user_code")
+    verification_uri = data.get("verification_uri")
+    interval = data.get("interval", 5)
+
+    _print("\n==========================================")
+    _print(f"Please open your browser to: {verification_uri}")
+    _print(f"And enter the authorization code: {user_code}")
+    _print("==========================================\n")
+    _print(f"Waiting for authorization (checking every {interval} seconds)...")
+
+    access_token = None
+    with httpx.Client() as client:
+        while True:
+            token_res = client.post(
+                "https://github.com/login/oauth/access_token",
+                headers={"Accept": "application/json"},
+                data={
+                    "client_id": client_id,
+                    "device_code": device_code,
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                },
+            ).json()
+
+            if "access_token" in token_res:
+                access_token = token_res["access_token"]
+                _print("\n✅ Authorization successful! Exchanging for Copilot Token...")
+                break
+            elif token_res.get("error") == "authorization_pending":
+                time.sleep(interval)
+            else:
+                _print(f"\n❌ Authorization failed: {token_res}")
+                return None
+
+        # Exchange the standard access token for a Copilot internal token
+        copilot_token, expires_at = fetch_copilot_token(access_token)
+
+        if copilot_token:
+            save_tokens_to_cache(access_token, copilot_token, expires_at)
+            _print("🎉 Successfully acquired Copilot Token!")
+            if return_both:
+                return access_token, copilot_token
+            return copilot_token
+        else:
+            _print("❌ Failed to acquire Copilot Token!")
+            if return_both:
+                return access_token, None
+            return None

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

@@ -42,7 +42,20 @@ from langchain_core.output_parsers.openai_tools import (
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
 from langchain_core.tools import BaseTool
 from langchain_core.utils.function_calling import convert_to_openai_tool
-from pydantic import Field, SecretStr, model_validator
+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,
+    afetch_copilot_token,
+    fetch_copilot_token,
+    load_tokens_from_cache,
+    save_tokens_to_cache,
+)
 
 # ---------------------------------------------------------------------------
 # Helpers
@@ -59,21 +72,6 @@ _ROLE_MAP = {
 _GITHUB_COPILOT_BASE_URL = "https://api.githubcopilot.com"
 _INFERENCE_PATH = "/chat/completions"
 
-COPILOT_EDITOR_VERSION = "vscode/1.104.1"
-COPILOT_PLUGIN_VERSION = "copilot-chat/0.26.7"
-COPILOT_INTEGRATION_ID = "vscode-chat"
-COPILOT_USER_AGENT = "GitHubCopilotChat/0.26.7"
-
-COPILOT_DEFAULT_HEADERS = {
-    "Copilot-Integration-Id": COPILOT_INTEGRATION_ID,
-    "User-Agent": COPILOT_USER_AGENT,
-    "Editor-Version": COPILOT_EDITOR_VERSION,
-    "Editor-Plugin-Version": COPILOT_PLUGIN_VERSION,
-    "editor-version": COPILOT_EDITOR_VERSION,
-    "editor-plugin-version": COPILOT_PLUGIN_VERSION,
-    "copilot-vision-request": "true",
-}
-
 
 def _message_to_dict(message: BaseMessage) -> Dict[str, Any]:
     """Convert a LangChain message to the GitHub Models API message format."""
@@ -206,11 +204,37 @@ def _build_ai_message(
 
     usage_metadata: Optional[UsageMetadata] = None
     if usage:
-        usage_metadata = UsageMetadata(
-            input_tokens=usage.get("prompt_tokens", 0),
-            output_tokens=usage.get("completion_tokens", 0),
-            total_tokens=usage.get("total_tokens", 0),
-        )
+        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)
 
     response_metadata: Dict[str, Any] = {
         "finish_reason": finish_reason,
@@ -455,21 +479,28 @@ class ChatGithubCopilot(BaseChatModel):
     # Validators / setup
     # ------------------------------------------------------------------
 
+    _cached_copilot_token: Optional[str] = PrivateAttr(default=None)
+
     @model_validator(mode="before")
     @classmethod
     def _validate_token(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        """Resolve the GitHub token from the environment if not supplied.
+        """Resolve the GitHub token from the environment or cache if not supplied.
 
         Priority order:
         1. Explicitly passed ``github_token``
         2. Explicitly passed ``api_key`` alias
         3. ``GITHUB_TOKEN`` environment variable
+        4. ``~/.github-copilot-chat.json`` cache file
         """
         token = values.get("github_token") or values.get("api_key")
         if not token:
             token = os.environ.get("GITHUB_TOKEN")
             if token:
                 values["github_token"] = token
+            else:
+                tokens = load_tokens_from_cache()
+                if "github_token" in tokens:
+                    values["github_token"] = tokens["github_token"]
         return values
 
     # ------------------------------------------------------------------
@@ -479,16 +510,74 @@ class ChatGithubCopilot(BaseChatModel):
     @property
     def _token(self) -> str:
         """Return the raw GitHub token string."""
+        if self._cached_copilot_token:
+            return self._cached_copilot_token
+
+        token = None
         if self.github_token:
-            return self.github_token.get_secret_value()
-        env_token = os.environ.get("GITHUB_TOKEN", "")
-        if not env_token:
+            token = self.github_token.get_secret_value()
+        elif os.environ.get("GITHUB_TOKEN"):
+            token = os.environ.get("GITHUB_TOKEN")
+        else:
+            tokens = load_tokens_from_cache()
+            if "copilot_token" in tokens:
+                self._cached_copilot_token = tokens["copilot_token"]
+                return tokens["copilot_token"]
+            elif "github_token" in tokens:
+                token = tokens["github_token"]
+
+        if not token:
             raise ValueError(
-                "A GitHub token is required.  Set the GITHUB_TOKEN environment "
-                "variable or pass ``github_token`` when instantiating "
-                "ChatGithubCopilot."
+                "A GitHub token is required. Set the GITHUB_TOKEN environment "
+                "variable, pass ``github_token``, or run ``get_copilot_token()`` "
+                "to authenticate."
             )
-        return env_token
+
+        # If the token is a standard GitHub token, exchange it
+        if token.startswith(("gho_", "ghp_", "ghu_")):
+            self._refresh_token_sync(token)
+            if self._cached_copilot_token:
+                return self._cached_copilot_token
+
+        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:
+            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
+            )
+            if not token_to_use:
+                tokens = load_tokens_from_cache()
+                token_to_use = tokens.get("github_token")
+
+            if token_to_use:
+                new_token, expires_at = fetch_copilot_token(token_to_use)
+                if new_token:
+                    self._cached_copilot_token = new_token
+                    save_tokens_to_cache(token_to_use, new_token, expires_at)
+        finally:
+            _sync_token_refresh_lock = False
+
+    async def _refresh_token_async(self, github_token: Optional[str] = None) -> None:
+        lock = _get_token_refresh_lock()
+        async with lock:
+            token_to_use = github_token or (
+                self.github_token.get_secret_value() if self.github_token else None
+            )
+            if not token_to_use:
+                tokens = load_tokens_from_cache()
+                token_to_use = tokens.get("github_token")
+
+            if token_to_use:
+                new_token, expires_at = await afetch_copilot_token(token_to_use)
+                if new_token:
+                    self._cached_copilot_token = new_token
+                    save_tokens_to_cache(token_to_use, new_token, expires_at)
 
     @property
     def _inference_url(self) -> str:
@@ -584,6 +673,8 @@ 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):
@@ -594,6 +685,18 @@ class ChatGithubCopilot(BaseChatModel):
                     json=payload,
                     timeout=self.timeout,
                 )
+
+                # Handle 401 Unauthorized for token refresh
+                if response.status_code == 401:
+                    self._refresh_token_sync()
+                    headers = self._build_headers()
+                    response = httpx.post(
+                        self._inference_url,
+                        headers=headers,
+                        json=payload,
+                        timeout=self.timeout,
+                    )
+
                 response.raise_for_status()
                 return response.json()
             except (httpx.TimeoutException, httpx.TransportError) as exc:
@@ -601,12 +704,13 @@ class ChatGithubCopilot(BaseChatModel):
                 if attempt == self.max_retries:
                     raise
             except httpx.HTTPStatusError as exc:
-                # Don't retry on 4xx client errors
                 if exc.response.status_code < 500:
                     raise
                 last_exc = exc
                 if attempt == self.max_retries:
                     raise
+            if attempt < self.max_retries:
+                time.sleep(2**attempt)
         raise RuntimeError("Unexpected retry loop exit") from last_exc
 
     def _do_stream(self, payload: Dict[str, Any]) -> Iterator[Dict[str, Any]]:
@@ -633,6 +737,8 @@ class ChatGithubCopilot(BaseChatModel):
 
     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:
@@ -643,6 +749,16 @@ class ChatGithubCopilot(BaseChatModel):
                         headers=headers,
                         json=payload,
                     )
+
+                    if response.status_code == 401:
+                        await self._refresh_token_async()
+                        headers = self._build_headers()
+                        response = await client.post(
+                            self._inference_url,
+                            headers=headers,
+                            json=payload,
+                        )
+
                     response.raise_for_status()
                     return response.json()
                 except (httpx.TimeoutException, httpx.TransportError) as exc:
@@ -655,6 +771,8 @@ class ChatGithubCopilot(BaseChatModel):
                     last_exc = exc
                     if attempt == self.max_retries:
                         raise
+                if attempt < self.max_retries:
+                    await asyncio.sleep(2**attempt)
         raise RuntimeError("Unexpected retry loop exit") from last_exc
 
     async def _do_stream_async(

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

@@ -9,24 +9,13 @@ import httpx
 from langchain_core.embeddings import Embeddings
 from pydantic import BaseModel, Field, SecretStr, model_validator
 
+from langchain_githubcopilot_chat.auth import (
+    COPILOT_DEFAULT_HEADERS,
+)
+
 _GITHUB_COPILOT_BASE_URL = "https://api.githubcopilot.com"
 _EMBEDDINGS_PATH = "/embeddings"
 
-COPILOT_EDITOR_VERSION = "vscode/1.104.1"
-COPILOT_PLUGIN_VERSION = "copilot-chat/0.26.7"
-COPILOT_INTEGRATION_ID = "vscode-chat"
-COPILOT_USER_AGENT = "GitHubCopilotChat/0.26.7"
-
-COPILOT_DEFAULT_HEADERS = {
-    "Copilot-Integration-Id": COPILOT_INTEGRATION_ID,
-    "User-Agent": COPILOT_USER_AGENT,
-    "Editor-Version": COPILOT_EDITOR_VERSION,
-    "Editor-Plugin-Version": COPILOT_PLUGIN_VERSION,
-    "editor-version": COPILOT_EDITOR_VERSION,
-    "editor-plugin-version": COPILOT_PLUGIN_VERSION,
-    "copilot-vision-request": "true",
-}
-
 
 class GithubcopilotChatEmbeddings(BaseModel, Embeddings):
     """GitHub Copilot Chat embedding model integration via the GitHub Models API.

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

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

langchain_githubcopilot_chat-0.2.0/PKG-INFO

@@ -1,69 +0,0 @@
-Metadata-Version: 2.1
-Name: langchain-githubcopilot-chat
-Version: 0.2.0
-Summary: An integration package connecting GithubcopilotChat and LangChain
-Home-page: https://github.com/langchain-ai/langchain
-License: MIT
-Author: YIhan Wu
-Author-email: iumm@ibat.ac.cn
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: httpx (>=0.28.1)
-Requires-Dist: langchain-core (>=1.1.0,<2.0.0)
-Project-URL: Repository, https://github.com/langchain-ai/langchain
-Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22githubcopilot-chat%3D%3D0%22&expanded=true
-Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/partners/githubcopilot-chat
-Description-Content-Type: text/markdown
-
-# langchain-githubcopilot-chat
-
-This package contains the LangChain integration with GithubcopilotChat
-
-## Installation
-
-```bash
-pip install -U langchain-githubcopilot-chat
-```
-
-And you should configure credentials by setting the following environment variables:
-
-* TODO: fill this out
-
-## Chat Models
-
-`ChatGithubcopilotChat` class exposes chat models from GithubcopilotChat.
-
-```python
-from langchain_githubcopilot_chat import ChatGithubcopilotChat
-
-llm = ChatGithubcopilotChat()
-llm.invoke("Sing a ballad of LangChain.")
-```
-
-## Embeddings
-
-`GithubcopilotChatEmbeddings` class exposes embeddings from GithubcopilotChat.
-
-```python
-from langchain_githubcopilot_chat import GithubcopilotChatEmbeddings
-
-embeddings = GithubcopilotChatEmbeddings()
-embeddings.embed_query("What is the meaning of life?")
-```
-
-## LLMs
-
-`GithubcopilotChatLLM` class exposes LLMs from GithubcopilotChat.
-
-```python
-from langchain_githubcopilot_chat import GithubcopilotChatLLM
-
-llm = GithubcopilotChatLLM()
-llm.invoke("The meaning of life is")
-```
-

langchain_githubcopilot_chat-0.2.0/README.md

@@ -1,46 +0,0 @@
-# langchain-githubcopilot-chat
-
-This package contains the LangChain integration with GithubcopilotChat
-
-## Installation
-
-```bash
-pip install -U langchain-githubcopilot-chat
-```
-
-And you should configure credentials by setting the following environment variables:
-
-* TODO: fill this out
-
-## Chat Models
-
-`ChatGithubcopilotChat` class exposes chat models from GithubcopilotChat.
-
-```python
-from langchain_githubcopilot_chat import ChatGithubcopilotChat
-
-llm = ChatGithubcopilotChat()
-llm.invoke("Sing a ballad of LangChain.")
-```
-
-## Embeddings
-
-`GithubcopilotChatEmbeddings` class exposes embeddings from GithubcopilotChat.
-
-```python
-from langchain_githubcopilot_chat import GithubcopilotChatEmbeddings
-
-embeddings = GithubcopilotChatEmbeddings()
-embeddings.embed_query("What is the meaning of life?")
-```
-
-## LLMs
-
-`GithubcopilotChatLLM` class exposes LLMs from GithubcopilotChat.
-
-```python
-from langchain_githubcopilot_chat import GithubcopilotChatLLM
-
-llm = GithubcopilotChatLLM()
-llm.invoke("The meaning of life is")
-```

langchain_githubcopilot_chat-0.2.0/langchain_githubcopilot_chat/auth.py

@@ -1,85 +0,0 @@
-import time
-from typing import Optional
-
-import httpx
-
-CLIENT_ID = "Iv1.b507a08c87ecfe98"
-
-
-def get_copilot_token(client_id: str = CLIENT_ID) -> Optional[str]:
-    """
-    Authenticate via GitHub Device Flow to get a Copilot Token.
-    This function will block and wait for the user to complete the
-    authorization in their browser.
-
-    Args:
-        client_id: The GitHub OAuth App Client ID to use. Defaults
-            to the VS Code Copilot Chat client ID.
-
-    Returns:
-        The fetched Copilot Token string, or None if authentication failed.
-    """
-    print("1. Requesting device code from GitHub...")  # noqa: T201  # noqa: T201
-    with httpx.Client() as client:
-        res = client.post(
-            "https://github.com/login/device/code",
-            headers={"Accept": "application/json"},
-            data={"client_id": client_id, "scope": "read:user"},
-        )
-        res.raise_for_status()
-        data = res.json()
-
-    device_code = data.get("device_code")
-    user_code = data.get("user_code")
-    verification_uri = data.get("verification_uri")
-    interval = data.get("interval", 5)
-
-    print("\n==========================================")  # noqa: T201
-    print(f"Please open your browser to: {verification_uri}")  # noqa: T201
-    print(f"And enter the authorization code: {user_code}")  # noqa: T201
-    print("==========================================\n")  # noqa: T201
-    print(f"Waiting for authorization (checking every {interval} seconds)...")  # noqa: T201
-
-    access_token = None
-    with httpx.Client() as client:
-        while True:
-            token_res = client.post(
-                "https://github.com/login/oauth/access_token",
-                headers={"Accept": "application/json"},
-                data={
-                    "client_id": client_id,
-                    "device_code": device_code,
-                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
-                },
-            ).json()
-
-            if "access_token" in token_res:
-                access_token = token_res["access_token"]
-                print(  # noqa: T201  # noqa: T201
-                    "\n✅ Authorization successful! Exchanging for Copilot Token..."
-                )
-                break
-            elif token_res.get("error") == "authorization_pending":
-                time.sleep(interval)
-            else:
-                print(f"\n❌ Authorization failed: {token_res}")  # noqa: T201  # noqa: T201
-                return None
-
-        # Exchange the standard access token for a Copilot internal token
-        copilot_res = client.get(
-            "https://api.github.com/copilot_internal/v2/token",
-            headers={
-                "Authorization": f"token {access_token}",
-                "Accept": "application/json",
-                "Editor-Version": "vscode/1.104.1",
-                "Editor-Plugin-Version": "copilot-chat/0.26.7",
-            },
-        )
-
-        if copilot_res.status_code == 200:
-            copilot_token = copilot_res.json().get("token")
-            print("🎉 Successfully acquired Copilot Token!")  # noqa: T201  # noqa: T201
-            return copilot_token
-        else:
-            print(f"❌ Failed to acquire Copilot Token: {copilot_res.text}")  # noqa: T201  # noqa: T201
-            return None