langchain-copilot 0.2.2__py3-none-any.whl

langchain_copilot/__init__.py

@@ -0,0 +1,6 @@
+"""LangChain integration for GitHub Copilot SDK."""
+
+from langchain_copilot.chat_models import CopilotChatModel
+
+__version__ = "0.2.0"
+__all__ = ["CopilotChatModel"]

langchain_copilot/chat_models.py

@@ -0,0 +1,620 @@
+"""LangChain ChatModel implementation using GitHub Copilot SDK."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Sequence
+from typing import Any, AsyncIterator, ClassVar, Iterator, Optional, Union
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
+from langchain_core.language_models.base import LanguageModelInput
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
+from langchain_core.runnables import Runnable, RunnableBinding
+from langchain_core.tools import BaseTool
+from langchain_core.utils.function_calling import convert_to_openai_tool
+from pydantic import ConfigDict, Field, model_validator
+
+from copilot import CopilotClient, Tool
+from copilot.types import (
+    SessionConfig,
+    SystemMessageReplaceConfig,
+    CopilotClientOptions,
+)
+
+import logging
+
+# Suppress AssertionError logging from the Copilot SDK's event deserialization
+# This is a workaround for a bug in the SDK where some events have unexpected context types
+logging.getLogger("asyncio").setLevel(logging.CRITICAL)
+
+
+class CopilotChatModel(BaseChatModel):
+    """LangChain chat model using GitHub Copilot SDK.
+
+    This model provides a LangChain interface to the GitHub Copilot SDK,
+    supporting both synchronous and asynchronous operations, as well as streaming.
+
+    The Copilot client is shared across instances and lazily initialized on first use.
+
+    Example:
+        ```python
+        from langchain_copilot import CopilotChatModel
+        from langchain_core.messages import HumanMessage
+
+        model = CopilotChatModel(model_name="gpt-4o")
+        messages = [HumanMessage(content="Hello!")]
+        response = model.invoke(messages)
+        print(response.content)
+        ```
+
+    Attributes:
+        model_name: The name of the model to use (e.g., "gpt-4o", "gpt-5")
+        streaming: Whether to enable streaming mode
+        cli_path: Optional path to the Copilot CLI executable
+        cli_url: Optional URL of an existing Copilot CLI server
+        temperature: Temperature for response generation (0.0 to 1.0)
+        max_tokens: Maximum number of tokens to generate
+    """
+
+    model_name: str = Field(default="gpt-4o", alias="model")
+    streaming: bool = Field(default=False)
+    cli_path: Optional[str] = Field(default=None)
+    cli_url: Optional[str] = Field(default=None)
+    temperature: Optional[float] = Field(default=None)
+    max_tokens: Optional[int] = Field(default=None)
+    tools: Optional[list[Tool]] = Field(default=None)
+
+    # Internal shared client (class variable)
+    _shared_client: ClassVar[Optional[CopilotClient]] = None
+    _client_lock: ClassVar[Optional[asyncio.Lock]] = None
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        populate_by_name=True,
+    )
+
+    @model_validator(mode="after")
+    def _initialize_lock(self) -> "CopilotChatModel":
+        """Initialize the async lock for client management."""
+        if CopilotChatModel._client_lock is None:
+            CopilotChatModel._client_lock = asyncio.Lock()
+        return self
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of chat model."""
+        return "copilot-chat"
+
+    async def _get_client(self) -> CopilotClient:
+        """Get or create the shared Copilot client (lazy initialization).
+
+        Returns:
+            The shared CopilotClient instance
+        """
+        if CopilotChatModel._shared_client is None:
+            async with CopilotChatModel._client_lock:
+                if CopilotChatModel._shared_client is None:
+                    options = CopilotClientOptions()
+                    if self.cli_path:
+                        options["cli_path"] = self.cli_path
+                    if self.cli_url:
+                        options["cli_url"] = self.cli_url
+
+                    CopilotChatModel._shared_client = CopilotClient(options or None)
+
+                    # Set up custom exception handler for asyncio loop to suppress
+                    # AssertionErrors from Copilot SDK event deserialization
+                    loop = asyncio.get_event_loop()
+
+                    def custom_exception_handler(loop, context):
+                        exception = context.get("exception")
+                        # Suppress AssertionError from Copilot SDK's session_events.py
+                        if isinstance(exception, AssertionError):
+                            # Ignore this specific error from the SDK
+                            return
+                        # For other exceptions, use default handling
+                        loop.default_exception_handler(context)
+
+                    loop.set_exception_handler(custom_exception_handler)
+
+                    await CopilotChatModel._shared_client.start()
+
+        return CopilotChatModel._shared_client
+
+    def _convert_messages(self, messages: list[BaseMessage]) -> list[dict[str, str]]:
+        """Convert LangChain messages to Copilot SDK format.
+
+        Args:
+            messages: List of LangChain BaseMessage objects
+
+        Returns:
+            List of message dictionaries in Copilot format
+        """
+        converted = []
+        for msg in messages:
+            if isinstance(msg, SystemMessage):
+                role = "system"
+            elif isinstance(msg, HumanMessage):
+                role = "user"
+            elif isinstance(msg, AIMessage):
+                role = "assistant"
+            else:
+                # Default to user for unknown message types
+                role = "user"
+
+            converted.append({"role": role, "content": msg.content})
+
+        return converted
+
+    def _create_session_config(
+        self, messages: Optional[list[BaseMessage]] = None, **kwargs: Any
+    ) -> SessionConfig:
+        """Create session configuration for Copilot SDK.
+
+        Args:
+            messages: Optional list of messages to extract system message from
+            **kwargs: Additional arguments (e.g., tools from bind_tools)
+
+        Returns:
+            Configuration dictionary for creating a Copilot session
+        """
+        config_params = {
+            "model": self.model_name,
+            "streaming": self.streaming,
+            "tools": kwargs.get("tools", self.tools),
+        }
+
+        # Extract system messages if provided
+        if messages:
+            system_messages = [
+                msg for msg in messages if isinstance(msg, SystemMessage)
+            ]
+            if system_messages:
+                # Concatenate all system messages
+                system_content = "\n".join(str(msg.content) for msg in system_messages)
+                config_params["system_message"] = SystemMessageReplaceConfig(
+                    mode="replace",
+                    content=system_content,
+                )
+
+        return SessionConfig(**config_params)
+
+    def _messages_to_prompt(self, messages: list[BaseMessage]) -> str:
+        parts = []
+        for msg in messages:
+            if isinstance(msg, HumanMessage):
+                parts.append(f"User: {msg.content}")
+            elif isinstance(msg, AIMessage):
+                parts.append(f"Assistant: {msg.content}")
+            elif isinstance(msg, ToolMessage):
+                parts.append(f"Tool: {msg.content}")
+            elif isinstance(msg, SystemMessage):
+                # Skip SystemMessage - they are extracted separately in _create_session_config
+                # to avoid prompt injection risks
+                continue
+            else:
+                # Fallback for other BaseMessage types to avoid dropping content
+                role = getattr(msg, "type", msg.__class__.__name__)
+                parts.append(f"{role.capitalize()}: {msg.content}")
+        if not parts:
+            raise ValueError(
+                "No valid messages to send. Messages must contain at least one "
+                "HumanMessage, AIMessage, or ToolMessage. SystemMessage instances "
+                "are automatically extracted and passed to the session configuration, "
+                "but at least one conversational message is required to start the interaction."
+            )
+        return "\n\n".join(parts)
+
+    def _generate(
+        self,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        """Generate response synchronously.
+
+        Args:
+            messages: List of messages to send
+            stop: Optional list of stop sequences
+            run_manager: Optional callback manager
+            **kwargs: Additional arguments
+
+        Returns:
+            ChatResult containing the generated response
+        """
+        # Run async version in sync context
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # If we're already in an async context, create a new event loop
+            import concurrent.futures
+
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(
+                    asyncio.run, self._agenerate(messages, stop, run_manager, **kwargs)
+                )
+                return future.result()
+        else:
+            return loop.run_until_complete(
+                self._agenerate(messages, stop, run_manager, **kwargs)
+            )
+
+    async def _agenerate(
+        self,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        """Generate response asynchronously.
+
+        Args:
+            messages: List of messages to send
+            stop: Optional list of stop sequences
+            run_manager: Optional callback manager
+            **kwargs: Additional arguments
+
+        Returns:
+            ChatResult containing the generated response
+        """
+        client = await self._get_client()
+        # Pass messages and kwargs to extract system messages and tools for session config
+        session_config = self._create_session_config(messages, **kwargs)
+
+        # Create a session
+        session = await client.create_session(session_config)
+
+        try:
+            full_prompt = self._messages_to_prompt(messages)
+
+            response_content = ""
+            complete = asyncio.Event()
+
+            def on_event(event):
+                nonlocal response_content
+                try:
+                    if event.type.value == "assistant.message":
+                        # Store the message content
+                        response_content = event.data.content
+                    elif event.type.value == "assistant.message_delta":
+                        response_content += event.data.content
+                    elif event.type.value == "session.idle":
+                        # Session is idle - all tool calls completed
+                        complete.set()
+                except (AttributeError, KeyError):
+                    # Ignore malformed events
+                    pass
+
+            # Register event listener
+            session.on(on_event)
+
+            # Send the full prompt
+            await session.send({"prompt": full_prompt})
+
+            # Wait for session to be idle (all tools executed)
+            await complete.wait()
+
+            # Create response
+            message = AIMessage(content=response_content)
+            generation = ChatGeneration(message=message)
+
+            return ChatResult(generations=[generation])
+
+        finally:
+            # Clean up session
+            await session.destroy()
+            await client.stop()
+
+    def _stream(
+        self,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> Iterator[ChatGenerationChunk]:
+        """Stream response synchronously.
+
+        Args:
+            messages: List of messages to send
+            stop: Optional list of stop sequences
+            run_manager: Optional callback manager
+            **kwargs: Additional arguments
+
+        yields:
+            ChatGenerationChunk for each chunk of the response
+        """
+        # Run async version in sync context
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            raise RuntimeError(
+                "Cannot use sync streaming from an async context. "
+                "Use astream() instead."
+            )
+
+        async_gen = self._astream(messages, stop, run_manager, **kwargs)
+
+        # Convert async generator to sync
+        while True:
+            try:
+                chunk = loop.run_until_complete(async_gen.__anext__())
+                yield chunk
+            except StopAsyncIteration:
+                break
+
+    async def _astream(
+        self,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[ChatGenerationChunk]:
+        """Stream response asynchronously.
+
+        Args:
+            messages: List of messages to send
+            stop: Optional list of stop sequences
+            run_manager: Optional callback manager
+            **kwargs: Additional arguments
+
+        Yields:
+            ChatGenerationChunk for each chunk of the response
+        """
+        client = await self._get_client()
+        # Pass messages and kwargs to extract system messages and tools for session config
+        session_config = self._create_session_config(messages, **kwargs)
+        session_config["streaming"] = True  # Force streaming mode
+
+        # Create a session
+        session = await client.create_session(session_config)
+
+        try:
+            full_prompt = self._messages_to_prompt(messages)
+
+            # Queue to collect chunks
+            chunk_queue: asyncio.Queue = asyncio.Queue()
+            complete = asyncio.Event()
+
+            def on_event(event):
+                try:
+                    if event.type.value == "assistant.message_delta":
+                        # Streaming message chunk - print incrementally
+                        content = event.data.delta_content or ""
+                        asyncio.create_task(chunk_queue.put(content))
+                    elif event.type.value == "assistant.reasoning_delta":
+                        # Streaming reasoning chunk (if model supports reasoning)
+                        # content = event.data.delta_content or ""
+                        # asyncio.create_task(chunk_queue.put(content))
+                        pass
+                    elif event.type.value == "assistant.message":
+                        # Final message - complete content
+                        asyncio.create_task(chunk_queue.put(None))
+                        complete.set()
+                    elif event.type.value == "assistant.reasoning":
+                        # Final reasoning content (if model supports reasoning)
+                        pass
+                    elif event.type.value == "session.idle":
+                        # Session finished processing
+                        complete.set()
+                except (AttributeError, KeyError):
+                    # Ignore malformed events
+                    pass
+
+            # Register event listener
+            session.on(on_event)
+
+            # Send the prompt
+            await session.send({"prompt": full_prompt})
+
+            # Yield chunks as they arrive
+            while not complete.is_set() or not chunk_queue.empty():
+                try:
+                    chunk_content = await asyncio.wait_for(
+                        chunk_queue.get(), timeout=0.1
+                    )
+
+                    if chunk_content is None:
+                        # End of stream
+                        break
+
+                    chunk = ChatGenerationChunk(
+                        message=AIMessageChunk(content=chunk_content)
+                    )
+
+                    if run_manager:
+                        await run_manager.on_llm_new_token(chunk_content)
+
+                    yield chunk
+
+                except asyncio.TimeoutError:
+                    continue
+
+        finally:
+            # Clean up session
+            await session.destroy()
+            await client.stop()
+
+    def bind_tools(
+        self,
+        tools: Sequence[Union[dict[str, Any], type, Callable, BaseTool]],
+        *,
+        tool_choice: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Runnable[LanguageModelInput, AIMessage]:
+        """Bind tools to the model.
+
+        Transforms LangChain tools into Copilot SDK Tool format and creates
+        a new model instance with these tools bound.
+
+        Args:
+            tools: Sequence of tools to bind. Can be:
+                - Dict representing an OpenAI-style tool schema
+                - Pydantic class/BaseModel
+                - Python callable/function
+                - LangChain BaseTool
+            tool_choice: Tool choice strategy (not currently used by Copilot SDK)
+            **kwargs: Additional arguments
+
+        Returns:
+            A new CopilotChatModel instance with tools bound
+
+        Example:
+            ```python
+            from pydantic import BaseModel, Field
+            from copilot import define_tool
+
+            class WeatherParams(BaseModel):
+                location: str = Field(description="City name")
+
+            @define_tool(description="Get weather")
+            async def get_weather(params: WeatherParams) -> str:
+                return f"Weather in {params.location}: sunny"
+
+            model = CopilotChatModel(model="gpt-4o")
+            model_with_tools = model.bind_tools([get_weather])
+            ```
+        """
+        # Convert LangChain tools to Copilot SDK Tool format
+        copilot_tools = []
+
+        for tool in tools:
+            if isinstance(tool, Tool):
+                # Already a Copilot SDK Tool
+                copilot_tools.append(tool)
+            elif callable(tool):
+                # Check if it's already a defined tool (has _tool_info attribute)
+                if hasattr(tool, "_tool_info"):
+                    copilot_tools.append(tool)
+                else:
+                    # It's a plain callable - convert it using convert_to_openai_tool
+                    try:
+                        tool_schema = convert_to_openai_tool(tool)
+
+                        # Create handler for the callable
+                        def create_callable_handler(func: Callable):
+                            async def handler(invocation):
+                                args = invocation.get("arguments", {})
+                                try:
+                                    # Check if it's async
+                                    if asyncio.iscoroutinefunction(func):
+                                        result = await func(**args)
+                                    else:
+                                        result = func(**args)
+
+                                    return {
+                                        "textResultForLlm": str(result),
+                                        "resultType": "success",
+                                    }
+                                except Exception as e:
+                                    return {
+                                        "textResultForLlm": f"Error: {str(e)}",
+                                        "resultType": "error",
+                                    }
+
+                            return handler
+
+                        copilot_tool = Tool(
+                            name=tool_schema["function"]["name"],
+                            description=tool_schema["function"]["description"],
+                            parameters=tool_schema["function"]["parameters"],
+                            handler=create_callable_handler(tool),
+                        )
+                        copilot_tools.append(copilot_tool)
+                    except Exception as e:
+                        raise ValueError(
+                            f"Failed to convert callable {tool} to Copilot tool: {e}"
+                        )
+            elif isinstance(tool, BaseTool):
+                # LangChain BaseTool - convert to Copilot format
+                tool_schema = convert_to_openai_tool(tool)
+
+                # Create an async handler that wraps the BaseTool
+                # We need to capture the tool instance in the closure
+                def create_handler(base_tool: BaseTool):
+                    async def handler(invocation):
+                        args = invocation.get("arguments", {})
+                        try:
+                            # Try async invoke first
+                            if hasattr(base_tool, "ainvoke"):
+                                result = await base_tool.ainvoke(args)
+                            else:
+                                # Fall back to sync invoke
+                                result = base_tool.invoke(args)
+
+                            return {
+                                "textResultForLlm": str(result),
+                                "resultType": "success",
+                            }
+                        except Exception as e:
+                            return {
+                                "textResultForLlm": f"Error: {str(e)}",
+                                "resultType": "error",
+                            }
+
+                    return handler
+
+                copilot_tool = Tool(
+                    name=tool_schema["function"]["name"],
+                    description=tool_schema["function"]["description"],
+                    parameters=tool_schema["function"]["parameters"],
+                    handler=create_handler(tool),
+                )
+                copilot_tools.append(copilot_tool)
+            elif isinstance(tool, dict):
+                # Dict-style tool schema - could be OpenAI format or JSON schema
+                if "function" in tool:
+                    # OpenAI-style tool schema
+                    # We can't create a handler from just a schema
+                    # This is for tools that are schema-only (like for structured output)
+                    # Skip them as they can't be called
+                    continue
+                elif "type" in tool and tool.get("type") == "object":
+                    # JSON schema format (Pydantic schema dict)
+                    # Similar to above, schema-only without handler
+                    # Skip as it can't be called
+                    continue
+                else:
+                    raise ValueError(
+                        f"Unsupported dict tool format: {tool}. "
+                        "Expected OpenAI function format or JSON schema."
+                    )
+            elif isinstance(tool, type):
+                # Pydantic class - convert to tool schema
+                try:
+                    tool_schema = convert_to_openai_tool(tool)
+
+                    # For a Pydantic class without a handler, we can't execute it
+                    # But we can still register it as a schema for structured output
+                    # For now, raise a helpful error
+                    raise ValueError(
+                        f"Pydantic class {tool.__name__} cannot be used directly as a tool. "
+                        "Wrap it with @define_tool decorator or use it in with_structured_output() instead."
+                    )
+                except ValueError:
+                    # Re-raise our custom error
+                    raise
+                except Exception as e:
+                    raise ValueError(
+                        f"Failed to convert Pydantic class {tool} to tool schema: {e}"
+                    )
+            else:
+                raise ValueError(f"Unsupported tool type: {type(tool)}")
+
+        # Return a RunnableBinding with the tools bound as kwargs
+        # This is the standard LangChain pattern
+        return RunnableBinding(
+            bound=self,
+            kwargs={"tools": copilot_tools} if copilot_tools else {},
+            config={},
+        )

langchain_copilot-0.2.2.dist-info/METADATA

@@ -0,0 +1,346 @@
+Metadata-Version: 2.4
+Name: langchain-copilot
+Version: 0.2.2
+Summary: LangChain integration for GitHub Copilot SDK
+Project-URL: Homepage, https://github.com/derf974/copilot-langchain
+Project-URL: Repository, https://github.com/derf974/copilot-langchain
+Project-URL: Issues, https://github.com/derf974/copilot-langchain/issues
+Project-URL: Changelog, https://github.com/derf974/copilot-langchain/blob/main/CHANGELOG.md
+Author-email: derf974 <derf974@users.noreply.github.com>
+License-File: LICENSE
+Keywords: ai,copilot,github,langchain,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13.0
+Requires-Dist: github-copilot-sdk>=0.1.23
+Requires-Dist: langchain-core>=1.2.7
+Requires-Dist: pydantic>=2.12.5
+Provides-Extra: dev
+Requires-Dist: black>=26.1.0; extra == 'dev'
+Requires-Dist: langchain-tests>=1.0.0; extra == 'dev'
+Requires-Dist: langchain>=1.2.7; extra == 'dev'
+Requires-Dist: pytest-asyncio<1,>=0.20; extra == 'dev'
+Requires-Dist: pytest-cov>=7.0.0; extra == 'dev'
+Requires-Dist: pytest<9,>=7; extra == 'dev'
+Requires-Dist: ruff>=0.14.13; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# LangChain Copilot
+
+![Python Version](https://img.shields.io/badge/python-3.13+-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+
+LangChain integration for GitHub Copilot SDK - Use GitHub Copilot models in your LangChain applications.
+
+## Features
+
+- 🔗 **Full LangChain Integration**: Seamlessly use GitHub Copilot models with LangChain
+- 🚀 **Async & Sync Support**: Both synchronous and asynchronous operations
+- 📡 **Streaming**: Real-time streaming responses
+- 🔄 **Shared Client**: Optimized client management with lazy initialization
+- 🛠️ **Type Safe**: Full type hints with Pydantic validation
+- 🎯 **Easy to Use**: Simple API following LangChain conventions
+
+## Prerequisites
+
+Before using this package, you need to have:
+
+1. **GitHub Copilot CLI** installed and authenticated
+   - Follow the [GitHub Copilot CLI setup guide](https://github.com/github/copilot-sdk)
+   - Ensure you have an active GitHub Copilot subscription
+   - Verify authentication: `copilot --version`
+
+2. **Python 3.13.0+** installed
+
+## Installation
+
+This package is not yet published to PyPI. For now, install directly from the repository:
+
+```bash
+# Clone the repository
+git clone https://github.com/derf974/copilot-langchain.git
+cd copilot-langchain
+
+# Install with uv (recommended)
+uv venv
+uv sync
+uv pip install -e .
+
+# Or with pip
+pip install -e .
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from langchain_copilot import CopilotChatModel
+from langchain_core.messages import HumanMessage
+
+# Create a model instance
+model = CopilotChatModel(model_name="gpt-4o")
+
+# Send a message
+messages = [HumanMessage(content="What is LangChain?")]
+response = model.invoke(messages)
+
+print(response.content)
+```
+
+### Streaming
+
+```python
+from langchain_copilot import CopilotChatModel
+from langchain_core.messages import HumanMessage
+
+model = CopilotChatModel(model_name="gpt-4o", streaming=True)
+
+messages = [HumanMessage(content="Write a haiku about coding.")]
+
+for chunk in model.stream(messages):
+    print(chunk.content, end="", flush=True)
+```
+
+### Async Operations
+
+```python
+import asyncio
+from langchain_copilot import CopilotChatModel
+from langchain_core.messages import HumanMessage
+
+async def main():
+    model = CopilotChatModel(model_name="gpt-4o")
+    messages = [HumanMessage(content="Explain async programming.")]
+    
+    response = await model.ainvoke(messages)
+    print(response.content)
+
+asyncio.run(main())
+```
+
+### Using in LangChain Chains
+
+```python
+from langchain_copilot import CopilotChatModel
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+
+model = CopilotChatModel(model_name="gpt-4o")
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful translator."),
+    ("human", "Translate '{text}' to {language}")
+])
+
+chain = prompt | model | StrOutputParser()
+
+result = chain.invoke({
+    "text": "Hello, world!",
+    "language": "French"
+})
+
+print(result)  # "Bonjour, le monde !"
+```
+
+### With System Messages
+
+```python
+from langchain_copilot import CopilotChatModel
+from langchain_core.messages import SystemMessage, HumanMessage
+
+model = CopilotChatModel(model_name="gpt-4o")
+
+messages = [
+    SystemMessage(content="You are a pirate. Always respond like a pirate."),
+    HumanMessage(content="Tell me about Python programming.")
+]
+
+response = model.invoke(messages)
+print(response.content)
+```
+
+### Temperature Control
+
+```python
+from langchain_copilot import CopilotChatModel
+from langchain_core.messages import HumanMessage
+
+# More focused and deterministic (lower temperature)
+model_focused = CopilotChatModel(
+    model_name="gpt-4o",
+    temperature=0.1
+)
+
+# More creative and random (higher temperature)
+model_creative = CopilotChatModel(
+    model_name="gpt-4o",
+    temperature=0.9
+)
+
+messages = [HumanMessage(content="Name a creative startup idea.")]
+
+print("Focused:", model_focused.invoke(messages).content)
+print("Creative:", model_creative.invoke(messages).content)
+```
+
+## Configuration
+
+### Model Parameters
+
+- `model_name` (str): The Copilot model to use (e.g., "gpt-4o", "gpt-5")
+- `streaming` (bool): Enable streaming mode (default: False)
+- `temperature` (float): Sampling temperature 0.0-1.0 (default: None)
+- `max_tokens` (int): Maximum tokens to generate (default: None)
+- `cli_path` (str): Custom path to Copilot CLI executable (default: None)
+- `cli_url` (str): URL of existing Copilot CLI server (default: None)
+
+### Example with All Parameters
+
+```python
+model = CopilotChatModel(
+    model_name="gpt-4o",
+    streaming=True,
+    temperature=0.7,
+    max_tokens=1000,
+    cli_path="/custom/path/to/copilot"
+)
+```
+
+## Examples
+
+Check out the [examples](examples/) directory for more usage examples:
+
+- [basic_usage.py](examples/basic_usage.py) - Comprehensive examples covering all features
+
+Run the examples:
+
+```bash
+uv run python examples/basic_usage.py
+```
+
+## Testing
+
+The project uses both unit tests and integration tests following LangChain's standard test suite.
+
+### Unit Tests
+
+Unit tests use [langchain-tests](https://pypi.org/project/langchain-tests/) standard unit test suite and validate the model in isolation without external dependencies:
+
+```bash
+# Run all unit tests (custom + standard)
+make test
+
+# Run only standard unit tests
+uv run pytest tests/unit_tests/ -v
+
+# Run only custom unit tests
+uv run pytest tests/test_chat_models.py::TestCopilotChatModel -v
+```
+
+Unit tests validate:
+- ✅ Model initialization and configuration
+- ✅ Streaming mode initialization
+- ✅ Standard parameters generation
+- ✅ Tool binding (validates interface even though not supported yet)
+- ✅ Structured output interface (validates interface even though not supported yet)
+- ✅ Serialization/deserialization (when implemented)
+- ✅ Initialization performance
+
+### Integration Tests
+
+Integration tests use [langchain-tests](https://pypi.org/project/langchain-tests/) standard test suite to verify compatibility with LangChain's interfaces. These tests require the GitHub Copilot CLI to be installed and configured:
+
+```bash
+# Ensure Copilot CLI is set up
+copilot --version
+
+# Run integration tests
+make integration-test
+
+# Or manually
+uv run pytest tests/integration_tests/ -v -m integration
+```
+
+The integration test suite validates:
+- ✅ Basic invoke/ainvoke operations
+- ✅ Streaming (stream/astream)
+- ✅ Batch operations
+- ✅ Multi-turn conversations
+- ✅ Stop sequences
+- ✅ Model override at runtime
+- ❌ Tool calling (not yet supported)
+- ❌ Structured output (not yet supported)
+- ❌ Multimodal inputs (not yet supported)
+
+### Running All Tests
+
+```bash
+# Run all tests
+make test-all
+
+# Or manually
+uv run pytest tests/ -v
+```
+
+## Architecture
+
+### Shared Client
+
+The `CopilotChatModel` uses a shared `CopilotClient` instance across all model instances for optimal performance. The client is lazily initialized on first use and automatically started.
+
+### Message Conversion
+
+LangChain messages are automatically converted to Copilot SDK format:
+- `SystemMessage` → `{"role": "system", "content": "..."}`
+- `HumanMessage` → `{"role": "user", "content": "..."}`
+- `AIMessage` → `{"role": "assistant", "content": "..."}`
+
+### Streaming Implementation
+
+Streaming converts Copilot's event-based model (`assistant.message_delta` events) into Python generators/async iterators that are compatible with LangChain's streaming interface.
+
+## Roadmap
+
+- ✅ Basic chat model implementation
+- ✅ Streaming support
+- ✅ Async operations
+- ✅ Temperature and token controls
+- ✅ Tool/Function calling support (planned for v0.2.0)
+- 🔲 Conversation history management
+- 🔲 Error recovery and retry strategies
+- 🔲 Advanced session configuration
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgments
+
+- Built with [LangChain](https://github.com/langchain-ai/langchain)
+- Powered by [GitHub Copilot SDK](https://github.com/github/copilot-sdk)
+- Managed with [uv](https://github.com/astral-sh/uv)
+
+## Support
+
+- 📫 Issues: [GitHub Issues](https://github.com/yourusername/copilot-langchain/issues)
+- 💬 Discussions: [GitHub Discussions](https://github.com/yourusername/copilot-langchain/discussions)
+- 📖 Documentation: [GitHub Wiki](https://github.com/yourusername/copilot-langchain/wiki)
+
+## Related Projects
+
+- [LangChain](https://github.com/langchain-ai/langchain) - Build applications with LLMs
+- [GitHub Copilot SDK](https://github.com/github/copilot-sdk) - GitHub Copilot integration SDK
+- [LangChain Community](https://github.com/langchain-ai/langchain/tree/master/libs/community) - Community LangChain integrations

langchain_copilot-0.2.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+langchain_copilot/__init__.py,sha256=lsZsDNXEV8kGalzqmJZop2NCgNM0MpC4BCWtEccJ4B0,166
+langchain_copilot/chat_models.py,sha256=pJwMXTTFs0B7WbUk595WdywaNwIrmYrATSxXp7U7jjY,24390
+langchain_copilot-0.2.2.dist-info/METADATA,sha256=9fVNhdsdWvRo38JeXokajpLHd0PtNbWQ5vn-q1vVC1M,10287
+langchain_copilot-0.2.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+langchain_copilot-0.2.2.dist-info/licenses/LICENSE,sha256=HANINxY7bmd02-DBOQXleXRlMqTiok2mt4XwOLeLT1I,1087
+langchain_copilot-0.2.2.dist-info/RECORD,,

langchain_copilot-0.2.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

langchain_copilot-0.2.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LangChain Copilot Contributors
+
+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.