langchain-githubcopilot-chat 0.3.0__tar.gz → 0.5.0__tar.gz

{langchain_githubcopilot_chat-0.3.0 → langchain_githubcopilot_chat-0.5.0}/PKG-INFO

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

langchain_githubcopilot_chat-0.5.0/langchain_githubcopilot_chat/auth.py

@@ -0,0 +1,225 @@
+"""Authentication utilities for GitHub Copilot."""
+
+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")
+
+# 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: threading.Lock = threading.Lock()
+
+
+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 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]:
+    """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 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 {}
+
+
+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.3.0 → langchain_githubcopilot_chat-0.5.0}/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,
@@ -42,7 +46,22 @@ 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,
+    _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
@@ -59,21 +78,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."""
@@ -455,21 +459,29 @@ class ChatGithubCopilot(BaseChatModel):
     # Validators / setup
     # ------------------------------------------------------------------
 
+    _cached_copilot_token: Optional[str] = PrivateAttr(default=None)
+    _cached_copilot_token_expires_at: Optional[float] = 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 +491,99 @@ class ChatGithubCopilot(BaseChatModel):
     @property
     def _token(self) -> str:
         """Return the raw GitHub token string."""
+        # 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:
-            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"]
+                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"]
+
+        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."
+            )
+
+        # 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_")):
+            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:
+        # Non-blocking acquire: if another thread is already refreshing, skip
+        if not _sync_token_refresh_lock.acquire(blocking=False):
+            return
+        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
+                    self._cached_copilot_token_expires_at = expires_at
+                    save_tokens_to_cache(token_to_use, new_token, expires_at)
+        finally:
+            _sync_token_refresh_lock.release()
+
+    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
             )
-        return env_token
+            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
+                    self._cached_copilot_token_expires_at = expires_at
+                    save_tokens_to_cache(token_to_use, new_token, expires_at)
 
     @property
     def _inference_url(self) -> str:
@@ -594,6 +689,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 +708,14 @@ 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:
+                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]]:
@@ -643,6 +752,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 +774,9 @@ class ChatGithubCopilot(BaseChatModel):
                     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
 
     async def _do_stream_async(
@@ -732,6 +854,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
     # ------------------------------------------------------------------
@@ -806,17 +943,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
@@ -872,17 +999,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.3.0 → langchain_githubcopilot_chat-0.5.0}/langchain_githubcopilot_chat/embeddings.py

@@ -2,31 +2,23 @@
 
 from __future__ import annotations
 
+import asyncio
 import os
+import random
+import time
 from typing import Any, Dict, List, Optional, Union
 
 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.
@@ -222,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]:
@@ -248,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.3.0 → langchain_githubcopilot_chat-0.5.0}/pyproject.toml

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

langchain_githubcopilot_chat-0.3.0/langchain_githubcopilot_chat/auth.py

@@ -1,96 +0,0 @@
-import time
-from typing import Callable, Optional
-
-import httpx
-
-CLIENT_ID = "Iv1.b507a08c87ecfe98"
-
-
-def get_copilot_token(
-    client_id: str = CLIENT_ID, callback: Optional[Callable[[str], None]] = None
-) -> 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_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!")
-            return copilot_token
-        else:
-            _print(f"❌ Failed to acquire Copilot Token: {copilot_res.text}")
-            return None