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

{langchain_githubcopilot_chat-0.1.0 → langchain_githubcopilot_chat-0.2.0}/PKG-INFO

@@ -1,21 +1,20 @@
 Metadata-Version: 2.1
 Name: langchain-githubcopilot-chat
-Version: 0.1.0
+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.9,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 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.24.0)
-Requires-Dist: langchain-core (>=0.3.15,<0.4.0)
+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

{langchain_githubcopilot_chat-0.1.0 → langchain_githubcopilot_chat-0.2.0}/langchain_githubcopilot_chat/__init__.py

@@ -1,15 +1,11 @@
 from importlib import metadata
 
+from langchain_githubcopilot_chat.auth import get_copilot_token
 from langchain_githubcopilot_chat.chat_models import (
     ChatGithubCopilot,
     ChatGithubcopilotChat,
 )
-from langchain_githubcopilot_chat.document_loaders import GithubcopilotChatLoader
 from langchain_githubcopilot_chat.embeddings import GithubcopilotChatEmbeddings
-from langchain_githubcopilot_chat.retrievers import GithubcopilotChatRetriever
-from langchain_githubcopilot_chat.toolkits import GithubcopilotChatToolkit
-from langchain_githubcopilot_chat.tools import GithubcopilotChatTool
-from langchain_githubcopilot_chat.vectorstores import GithubcopilotChatVectorStore
 
 try:
     __version__ = metadata.version(__package__)
@@ -18,14 +14,15 @@ except metadata.PackageNotFoundError:
     __version__ = ""
 del metadata  # optional, avoids polluting the results of dir(__package__)
 
+get_available_models = ChatGithubCopilot.get_available_models
+get_vscode_token = get_copilot_token
+
 __all__ = [
     "ChatGithubCopilot",
     "ChatGithubcopilotChat",  # backwards-compatible alias
-    "GithubcopilotChatVectorStore",
     "GithubcopilotChatEmbeddings",
-    "GithubcopilotChatLoader",
-    "GithubcopilotChatRetriever",
-    "GithubcopilotChatToolkit",
-    "GithubcopilotChatTool",
+    "get_copilot_token",
+    "get_vscode_token",
+    "get_available_models",
     "__version__",
 ]

langchain_githubcopilot_chat-0.2.0/langchain_githubcopilot_chat/auth.py

@@ -0,0 +1,85 @@
+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

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

@@ -56,10 +56,23 @@ _ROLE_MAP = {
     "tool": "tool",
 }
 
-_GITHUB_MODELS_BASE_URL = "https://models.github.ai"
-_INFERENCE_PATH = "/inference/chat/completions"
-_ORG_INFERENCE_PATH = "/orgs/{org}/inference/chat/completions"
-_API_VERSION = "2026-03-10"
+_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]:
@@ -403,19 +416,8 @@ class ChatGithubCopilot(BaseChatModel):
     is used.
     """
 
-    base_url: str = _GITHUB_MODELS_BASE_URL
-    """Base URL for the GitHub Models REST API."""
-
-    org: Optional[str] = None
-    """Organisation login for attributed inference requests.
-
-    When set, requests are sent to
-    ``/orgs/{org}/inference/chat/completions`` instead of
-    ``/inference/chat/completions``.
-    """
-
-    api_version: str = _API_VERSION
-    """GitHub Models API version sent as the ``X-GitHub-Api-Version`` header."""
+    base_url: str = _GITHUB_COPILOT_BASE_URL
+    """Base URL for the GitHub Copilot API."""
 
     temperature: Optional[float] = None
     """Sampling temperature in ``[0, 1]``."""
@@ -444,6 +446,11 @@ class ChatGithubCopilot(BaseChatModel):
     max_retries: int = 2
     """Number of automatic retries on transient errors."""
 
+    # ------------------------------------------------------------------
+    # Pydantic v2 config — allow the ``model`` alias on construction
+    # ------------------------------------------------------------------
+    model_config = {"populate_by_name": True}
+
     # ------------------------------------------------------------------
     # Validators / setup
     # ------------------------------------------------------------------
@@ -486,19 +493,43 @@ class ChatGithubCopilot(BaseChatModel):
     @property
     def _inference_url(self) -> str:
         """Return the full chat-completions endpoint URL."""
-        if self.org:
-            path = _ORG_INFERENCE_PATH.format(org=self.org)
-        else:
-            path = _INFERENCE_PATH
-        return self.base_url.rstrip("/") + path
+        return self.base_url.rstrip("/") + _INFERENCE_PATH
 
     def _build_headers(self) -> Dict[str, str]:
-        return {
+        headers = {
             "Authorization": f"Bearer {self._token}",
-            "Accept": "application/vnd.github+json",
+            "Accept": "application/json",
             "Content-Type": "application/json",
-            "X-GitHub-Api-Version": self.api_version,
         }
+        headers.update(COPILOT_DEFAULT_HEADERS)
+        return headers
+
+    @classmethod
+    def get_available_models(
+        cls, github_token: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """Get the list of available models from the GitHub Copilot API."""
+        token = github_token or os.environ.get("GITHUB_TOKEN")
+        if not token:
+            raise ValueError(
+                "A GitHub token is required. Set the GITHUB_TOKEN environment "
+                "variable or pass ``github_token``."
+            )
+
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        headers.update(COPILOT_DEFAULT_HEADERS)
+
+        url = f"{_GITHUB_COPILOT_BASE_URL}/models"
+
+        with httpx.Client() as client:
+            response = client.get(url, headers=headers)
+            response.raise_for_status()
+            data = response.json()
+            return data.get("data", [])
 
     def _build_payload(
         self,
@@ -707,7 +738,7 @@ class ChatGithubCopilot(BaseChatModel):
 
     @property
     def _llm_type(self) -> str:
-        return "chat-github-copilot"
+        return "github-copilot"
 
     @property
     def _identifying_params(self) -> Dict[str, Any]:

langchain_githubcopilot_chat-0.2.0/langchain_githubcopilot_chat/embeddings.py

@@ -0,0 +1,321 @@
+"""GitHub Copilot Chat embeddings integration via GitHub Models Embeddings API."""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, Field, SecretStr, model_validator
+
+_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.
+
+    GitHub Models provides access to embedding models (e.g. OpenAI
+    ``text-embedding-3-small``, ``text-embedding-3-large``) through a unified
+    OpenAI-compatible REST API.  This class wraps the ``/inference/embeddings``
+    endpoint so that any embedding model available in the GitHub Models catalog
+    can be used as a drop-in LangChain ``Embeddings`` implementation.
+
+    Setup:
+        Install ``langchain-githubcopilot-chat`` and set the
+        ``GITHUB_TOKEN`` environment variable (a classic or fine-grained PAT
+        with the ``models: read`` scope, or a GitHub Copilot subscription token).
+
+        .. code-block:: bash
+
+            pip install -U langchain-githubcopilot-chat
+            export GITHUB_TOKEN="github_pat_..."
+
+    Key init args:
+        model: str
+            Model ID in the ``{publisher}/{model_name}`` format, e.g.
+            ``"openai/text-embedding-3-small"``.
+        github_token: Optional[SecretStr]
+            GitHub token.  Falls back to ``GITHUB_TOKEN`` env var.
+        base_url: str
+            Base URL of the GitHub Models API.
+            Defaults to ``"https://models.github.ai"``.
+        org: Optional[str]
+            Organisation login.  When set, requests are attributed to that org.
+        api_version: str
+            GitHub Models REST API version header value.
+            Defaults to ``"2026-03-10"``.
+        dimensions: Optional[int]
+            The number of dimensions for the output embeddings.  Only supported
+            by ``text-embedding-3`` and later models.
+        encoding_format: str
+            The format to return embeddings in.  Either ``"float"`` (default)
+            or ``"base64"``.
+        timeout: Optional[float]
+            HTTP request timeout in seconds.
+        max_retries: int
+            Number of automatic retries on transient errors (default ``2``).
+
+    Instantiate:
+        .. code-block:: python
+
+            from langchain_githubcopilot_chat import GithubcopilotChatEmbeddings
+
+            embed = GithubcopilotChatEmbeddings(
+                model="openai/text-embedding-3-small",
+                # github_token="github_pat_...",  # or set GITHUB_TOKEN env var
+            )
+
+    Embed single text:
+        .. code-block:: python
+
+            vector = embed.embed_query("What is the meaning of life?")
+            print(len(vector))   # e.g. 1536
+
+    Embed multiple texts:
+        .. code-block:: python
+
+            vectors = embed.embed_documents(
+                ["Document one.", "Document two."]
+            )
+            print(len(vectors), len(vectors[0]))
+
+    Async:
+        .. code-block:: python
+
+            vector = await embed.aembed_query("What is the meaning of life?")
+
+            vectors = await embed.aembed_documents(
+                ["Document one.", "Document two."]
+            )
+    """
+
+    model_config = {"populate_by_name": True}
+
+    model_name: str = Field(alias="model")
+    """Embedding model ID in the ``{publisher}/{model_name}`` format.
+
+    Examples: ``"openai/text-embedding-3-small"``,
+    ``"openai/text-embedding-3-large"``.
+    """
+
+    github_token: Optional[SecretStr] = Field(default=None)
+    """GitHub token with ``models: read`` scope.
+
+    If not provided, the value of the ``GITHUB_TOKEN`` environment variable
+    is used.
+    """
+
+    base_url: str = _GITHUB_COPILOT_BASE_URL
+    """Base URL for the GitHub Copilot API."""
+
+    dimensions: Optional[int] = None
+    """Number of output embedding dimensions.
+
+    Only supported by ``text-embedding-3`` and later models.
+    """
+
+    encoding_format: str = "float"
+    """Format of the returned embeddings.  Either ``"float"`` or ``"base64"``."""
+
+    timeout: Optional[float] = None
+    """HTTP request timeout in seconds."""
+
+    max_retries: int = 2
+    """Number of automatic retries on transient errors."""
+
+    # ------------------------------------------------------------------
+    # Validators / setup
+    # ------------------------------------------------------------------
+
+    @model_validator(mode="before")
+    @classmethod
+    def _resolve_token(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """Resolve the GitHub token from the environment if not supplied."""
+        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
+        return values
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    @property
+    def _token(self) -> str:
+        """Return the raw GitHub token string."""
+        if self.github_token:
+            return self.github_token.get_secret_value()
+        env_token = os.environ.get("GITHUB_TOKEN", "")
+        if not env_token:
+            raise ValueError(
+                "A GitHub token is required.  Set the GITHUB_TOKEN environment "
+                "variable or pass ``github_token`` when instantiating "
+                "GithubcopilotChatEmbeddings."
+            )
+        return env_token
+
+    @property
+    def _embeddings_url(self) -> str:
+        """Return the full embeddings endpoint URL."""
+        return self.base_url.rstrip("/") + _EMBEDDINGS_PATH
+
+    def _build_headers(self) -> Dict[str, str]:
+        headers = {
+            "Authorization": f"Bearer {self._token}",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        headers.update(COPILOT_DEFAULT_HEADERS)
+        return headers
+
+    def _build_payload(self, input: Union[str, List[str]]) -> Dict[str, Any]:
+        """Assemble the JSON body for the embeddings API."""
+        payload: Dict[str, Any] = {
+            "model": self.model_name,
+            "input": input,
+            "encoding_format": self.encoding_format,
+        }
+        if self.dimensions is not None:
+            payload["dimensions"] = self.dimensions
+        return payload
+
+    def _do_request(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Perform a synchronous HTTP POST with retries."""
+        headers = self._build_headers()
+        last_exc: Optional[Exception] = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = httpx.post(
+                    self._embeddings_url,
+                    headers=headers,
+                    json=payload,
+                    timeout=self.timeout,
+                )
+                response.raise_for_status()
+                return response.json()
+            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
+        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 HTTP POST with retries."""
+        headers = self._build_headers()
+        last_exc: Optional[Exception] = None
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            for attempt in range(self.max_retries + 1):
+                try:
+                    response = await client.post(
+                        self._embeddings_url,
+                        headers=headers,
+                        json=payload,
+                    )
+                    response.raise_for_status()
+                    return response.json()
+                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
+        raise RuntimeError("Unexpected retry loop exit") from last_exc
+
+    @staticmethod
+    def _extract_embeddings(response_data: Dict[str, Any]) -> List[List[float]]:
+        """Extract the list of embedding vectors from an API response."""
+        data = response_data.get("data", [])
+        if not data:
+            raise ValueError(
+                f"GitHub Models Embeddings API returned no data. "
+                f"Response: {response_data}"
+            )
+        # Sort by index to preserve input order (the API may reorder items)
+        sorted_data = sorted(data, key=lambda x: x.get("index", 0))
+        return [item["embedding"] for item in sorted_data]
+
+    # ------------------------------------------------------------------
+    # LangChain Embeddings interface
+    # ------------------------------------------------------------------
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed a list of documents using the GitHub Models Embeddings API.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            A list of embedding vectors, one per input text.
+        """
+        if not texts:
+            return []
+        payload = self._build_payload(texts)
+        response_data = self._do_request(payload)
+        return self._extract_embeddings(response_data)
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a single query text using the GitHub Models Embeddings API.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            An embedding vector.
+        """
+        return self.embed_documents([text])[0]
+
+    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Asynchronously embed a list of documents.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            A list of embedding vectors, one per input text.
+        """
+        if not texts:
+            return []
+        payload = self._build_payload(texts)
+        response_data = await self._do_request_async(payload)
+        return self._extract_embeddings(response_data)
+
+    async def aembed_query(self, text: str) -> List[float]:
+        """Asynchronously embed a single query text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            An embedding vector.
+        """
+        results = await self.aembed_documents([text])
+        return results[0]

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

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "langchain-githubcopilot-chat"
-version = "0.1.0"
+version = "0.2.0"
 description = "An integration package connecting GithubcopilotChat and LangChain"
 authors = ["YIhan Wu <iumm@ibat.ac.cn>"]
 readme = "README.md"
@@ -19,9 +19,9 @@ disallow_untyped_defs = "True"
 "Release Notes" = "https://github.com/langchain-ai/langchain/releases?q=tag%3A%22githubcopilot-chat%3D%3D0%22&expanded=true"
 
 [tool.poetry.dependencies]
-python = ">=3.9,<4.0"
-langchain-core = "^0.3.15"
-httpx = ">=0.24.0"
+python = ">=3.10,<4.0"
+langchain-core = ">=1.1.0,<2.0.0"
+httpx = ">=0.28.1"
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "T201"]
@@ -59,7 +59,7 @@ pytest = "^7.4.3"
 pytest-asyncio = "^0.23.2"
 pytest-socket = "^0.7.0"
 pytest-watcher = "^0.3.4"
-langchain-tests = "^0.3.5"
+langchain-tests = "^1.1.5"
 
 [tool.poetry.group.codespell.dependencies]
 codespell = "^2.2.6"