agent-framework-github-copilot 1.0.0b260127__tar.gz

agent_framework_github_copilot-1.0.0b260127/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

agent_framework_github_copilot-1.0.0b260127/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: agent-framework-github-copilot
+Version: 1.0.0b260127
+Summary: GitHub Copilot integration for Microsoft Agent Framework.
+Author-email: Microsoft <af-support@microsoft.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+License-File: LICENSE
+Requires-Dist: agent-framework-core
+Requires-Dist: github-copilot-sdk>=0.1.0
+Project-URL: homepage, https://aka.ms/agent-framework
+Project-URL: issues, https://github.com/microsoft/agent-framework/issues
+Project-URL: release_notes, https://github.com/microsoft/agent-framework/releases?q=tag%3Apython-1&expanded=true
+Project-URL: source, https://github.com/microsoft/agent-framework/tree/main/python
+
+# Get Started with Microsoft Agent Framework GitHub Copilot
+
+Please install this package via pip:
+
+```bash
+pip install agent-framework-github-copilot --pre
+```
+
+## GitHub Copilot Agent
+
+The GitHub Copilot agent enables integration with GitHub Copilot, allowing you to interact with Copilot's agentic capabilities through the Agent Framework.
+

agent_framework_github_copilot-1.0.0b260127/README.md

@@ -0,0 +1,11 @@
+# Get Started with Microsoft Agent Framework GitHub Copilot
+
+Please install this package via pip:
+
+```bash
+pip install agent-framework-github-copilot --pre
+```
+
+## GitHub Copilot Agent
+
+The GitHub Copilot agent enables integration with GitHub Copilot, allowing you to interact with Copilot's agentic capabilities through the Agent Framework.

agent_framework_github_copilot-1.0.0b260127/agent_framework_github_copilot/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import importlib.metadata
+
+from ._agent import GithubCopilotAgent, GithubCopilotOptions
+from ._settings import GithubCopilotSettings
+
+try:
+    __version__ = importlib.metadata.version(__name__)
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = [
+    "GithubCopilotAgent",
+    "GithubCopilotOptions",
+    "GithubCopilotSettings",
+    "__version__",
+]

agent_framework_github_copilot-1.0.0b260127/agent_framework_github_copilot/_agent.py

@@ -0,0 +1,528 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+import contextlib
+import logging
+import sys
+from collections.abc import AsyncIterable, Callable, MutableMapping, Sequence
+from typing import Any, ClassVar, Generic, TypedDict
+
+from agent_framework import (
+    AgentMiddlewareTypes,
+    AgentResponse,
+    AgentResponseUpdate,
+    AgentThread,
+    BaseAgent,
+    ChatMessage,
+    Content,
+    ContextProvider,
+    Role,
+    normalize_messages,
+)
+from agent_framework._tools import AIFunction, ToolProtocol
+from agent_framework._types import normalize_tools
+from agent_framework.exceptions import ServiceException, ServiceInitializationError
+from copilot import CopilotClient, CopilotSession
+from copilot.generated.session_events import SessionEvent, SessionEventType
+from copilot.types import (
+    CopilotClientOptions,
+    MCPServerConfig,
+    PermissionRequest,
+    PermissionRequestResult,
+    ResumeSessionConfig,
+    SessionConfig,
+    ToolInvocation,
+    ToolResult,
+)
+from copilot.types import Tool as CopilotTool
+from pydantic import ValidationError
+
+from ._settings import GithubCopilotSettings
+
+if sys.version_info >= (3, 13):
+    from typing import TypeVar
+else:
+    from typing_extensions import TypeVar
+
+
+DEFAULT_TIMEOUT_SECONDS: float = 60.0
+"""Default timeout in seconds for Copilot requests."""
+
+PermissionHandlerType = Callable[[PermissionRequest, dict[str, str]], PermissionRequestResult]
+"""Type for permission request handlers."""
+
+logger = logging.getLogger("agent_framework.github_copilot")
+
+
+class GithubCopilotOptions(TypedDict, total=False):
+    """GitHub Copilot-specific options."""
+
+    instructions: str
+    """System message to append to the session."""
+
+    cli_path: str
+    """Path to the Copilot CLI executable. Defaults to GITHUB_COPILOT_CLI_PATH environment variable
+    or 'copilot' in PATH."""
+
+    model: str
+    """Model to use (e.g., "gpt-5", "claude-sonnet-4"). Defaults to GITHUB_COPILOT_MODEL environment variable."""
+
+    timeout: float
+    """Request timeout in seconds. Defaults to GITHUB_COPILOT_TIMEOUT environment variable or 60 seconds."""
+
+    log_level: str
+    """CLI log level. Defaults to GITHUB_COPILOT_LOG_LEVEL environment variable."""
+
+    on_permission_request: PermissionHandlerType
+    """Permission request handler.
+    Called when Copilot requests permission to perform an action (shell, read, write, etc.).
+    Takes a PermissionRequest and context dict, returns PermissionRequestResult.
+    If not provided, all permission requests will be denied by default.
+    """
+
+    mcp_servers: dict[str, MCPServerConfig]
+    """MCP (Model Context Protocol) server configurations.
+    A dictionary mapping server names to their configurations.
+    Supports both local (stdio) and remote (HTTP/SSE) servers.
+    """
+
+
+TOptions = TypeVar(
+    "TOptions",
+    bound=TypedDict,  # type: ignore[valid-type]
+    default="GithubCopilotOptions",
+    covariant=True,
+)
+
+
+class GithubCopilotAgent(BaseAgent, Generic[TOptions]):
+    """A GitHub Copilot Agent.
+
+    This agent wraps the GitHub Copilot SDK to provide Copilot agentic capabilities
+    within the Agent Framework. It supports both streaming and non-streaming responses,
+    custom tools, and session management.
+
+    The agent can be used as an async context manager to ensure proper cleanup:
+
+    Examples:
+        Basic usage:
+
+        .. code-block:: python
+
+            async with GithubCopilotAgent() as agent:
+                response = await agent.run("Hello, world!")
+                print(response)
+
+        With explicitly typed options:
+
+        .. code-block:: python
+
+            from agent_framework_github_copilot import GithubCopilotAgent, GithubCopilotOptions
+
+            agent: GithubCopilotAgent[GithubCopilotOptions] = GithubCopilotAgent(
+                default_options={"model": "claude-sonnet-4", "timeout": 120}
+            )
+
+        With tools:
+
+        .. code-block:: python
+
+            def get_weather(city: str) -> str:
+                return f"Weather in {city} is sunny"
+
+
+            async with GithubCopilotAgent(tools=[get_weather]) as agent:
+                response = await agent.run("What's the weather in Seattle?")
+    """
+
+    AGENT_PROVIDER_NAME: ClassVar[str] = "github.copilot"
+
+    def __init__(
+        self,
+        *,
+        client: CopilotClient | None = None,
+        id: str | None = None,
+        name: str | None = None,
+        description: str | None = None,
+        context_provider: ContextProvider | None = None,
+        middleware: Sequence[AgentMiddlewareTypes] | None = None,
+        tools: ToolProtocol
+        | Callable[..., Any]
+        | MutableMapping[str, Any]
+        | Sequence[ToolProtocol | Callable[..., Any] | MutableMapping[str, Any]]
+        | None = None,
+        default_options: TOptions | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initialize the GitHub Copilot Agent.
+
+        Keyword Args:
+            client: Optional pre-configured CopilotClient instance. If not provided,
+                a new client will be created using the other parameters.
+            id: ID of the GithubCopilotAgent.
+            name: Name of the GithubCopilotAgent.
+            description: Description of the GithubCopilotAgent.
+            context_provider: Context Provider, to be used by the agent.
+            middleware: Agent middleware used by the agent.
+            tools: Tools to use for the agent. Can be functions, ToolProtocol instances,
+                or tool definition dicts. These are converted to Copilot SDK tools internally.
+            default_options: Default options for the agent. Can include cli_path, model,
+                timeout, log_level, etc.
+            env_file_path: Optional path to .env file for loading configuration.
+            env_file_encoding: Encoding of the .env file, defaults to 'utf-8'.
+
+        Raises:
+            ServiceInitializationError: If required configuration is missing or invalid.
+        """
+        super().__init__(
+            id=id,
+            name=name,
+            description=description,
+            context_provider=context_provider,
+            middleware=list(middleware) if middleware else None,
+        )
+
+        self._client = client
+        self._owns_client = client is None
+
+        # Parse options
+        opts: dict[str, Any] = dict(default_options) if default_options else {}
+        instructions = opts.pop("instructions", None)
+        cli_path = opts.pop("cli_path", None)
+        model = opts.pop("model", None)
+        timeout = opts.pop("timeout", None)
+        log_level = opts.pop("log_level", None)
+        on_permission_request: PermissionHandlerType | None = opts.pop("on_permission_request", None)
+        mcp_servers: dict[str, MCPServerConfig] | None = opts.pop("mcp_servers", None)
+
+        try:
+            self._settings = GithubCopilotSettings(
+                cli_path=cli_path,
+                model=model,
+                timeout=timeout,
+                log_level=log_level,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as ex:
+            raise ServiceInitializationError("Failed to create GitHub Copilot settings.", ex) from ex
+
+        self._instructions = instructions
+        self._tools = normalize_tools(tools)
+        self._permission_handler = on_permission_request
+        self._mcp_servers = mcp_servers
+        self._default_options = opts
+        self._started = False
+
+    async def __aenter__(self) -> "GithubCopilotAgent[TOptions]":
+        """Start the agent when entering async context."""
+        await self.start()
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Stop the agent when exiting async context."""
+        await self.stop()
+
+    async def start(self) -> None:
+        """Start the Copilot client.
+
+        This method initializes the Copilot client and establishes a connection
+        to the Copilot CLI server. It is called automatically when using the
+        agent as an async context manager.
+
+        Raises:
+            ServiceException: If the client fails to start.
+        """
+        if self._started:
+            return
+
+        if self._client is None:
+            client_options: CopilotClientOptions = {}
+            if self._settings.cli_path:
+                client_options["cli_path"] = self._settings.cli_path
+            if self._settings.log_level:
+                client_options["log_level"] = self._settings.log_level  # type: ignore[typeddict-item]
+
+            self._client = CopilotClient(client_options if client_options else None)
+
+        try:
+            await self._client.start()
+            self._started = True
+        except Exception as ex:
+            raise ServiceException(f"Failed to start GitHub Copilot client: {ex}") from ex
+
+    async def stop(self) -> None:
+        """Stop the Copilot client and clean up resources.
+
+        Stops the Copilot client if owned by this agent. The client handles
+        session cleanup internally. Called automatically when using the agent
+        as an async context manager.
+        """
+        if self._client and self._owns_client:
+            with contextlib.suppress(Exception):
+                await self._client.stop()
+
+        self._started = False
+
+    async def run(
+        self,
+        messages: str | ChatMessage | Sequence[str | ChatMessage] | None = None,
+        *,
+        thread: AgentThread | None = None,
+        options: TOptions | None = None,
+        **kwargs: Any,
+    ) -> AgentResponse:
+        """Get a response from the agent.
+
+        This method returns the final result of the agent's execution
+        as a single AgentResponse object. The caller is blocked until
+        the final result is available.
+
+        Args:
+            messages: The message(s) to send to the agent.
+
+        Keyword Args:
+            thread: The conversation thread associated with the message(s).
+            options: Runtime options (model, timeout, etc.).
+            kwargs: Additional keyword arguments.
+
+        Returns:
+            An agent response item.
+
+        Raises:
+            ServiceException: If the request fails.
+        """
+        if not self._started:
+            await self.start()
+
+        if not thread:
+            thread = self.get_new_thread()
+
+        opts: dict[str, Any] = dict(options) if options else {}
+        timeout = opts.pop("timeout", None) or self._settings.timeout or DEFAULT_TIMEOUT_SECONDS
+
+        session = await self._get_or_create_session(thread, streaming=False)
+        input_messages = normalize_messages(messages)
+        prompt = "\n".join([message.text for message in input_messages])
+
+        try:
+            response_event = await session.send_and_wait({"prompt": prompt}, timeout=timeout)
+        except Exception as ex:
+            raise ServiceException(f"GitHub Copilot request failed: {ex}") from ex
+
+        response_messages: list[ChatMessage] = []
+        response_id: str | None = None
+
+        # send_and_wait returns only the final ASSISTANT_MESSAGE event;
+        # other events (deltas, tool calls) are handled internally by the SDK.
+        if response_event and response_event.type == SessionEventType.ASSISTANT_MESSAGE:
+            message_id = response_event.data.message_id
+
+            if response_event.data.content:
+                response_messages.append(
+                    ChatMessage(
+                        role=Role.ASSISTANT,
+                        contents=[Content.from_text(response_event.data.content)],
+                        message_id=message_id,
+                        raw_representation=response_event,
+                    )
+                )
+            response_id = message_id
+
+        return AgentResponse(messages=response_messages, response_id=response_id)
+
+    async def run_stream(
+        self,
+        messages: str | ChatMessage | Sequence[str | ChatMessage] | None = None,
+        *,
+        thread: AgentThread | None = None,
+        options: TOptions | None = None,
+        **kwargs: Any,
+    ) -> AsyncIterable[AgentResponseUpdate]:
+        """Run the agent as a stream.
+
+        This method will return the intermediate steps and final results of the
+        agent's execution as a stream of AgentResponseUpdate objects to the caller.
+
+        Args:
+            messages: The message(s) to send to the agent.
+
+        Keyword Args:
+            thread: The conversation thread associated with the message(s).
+            options: Runtime options (model, timeout, etc.).
+            kwargs: Additional keyword arguments.
+
+        Yields:
+            An agent response update for each delta.
+
+        Raises:
+            ServiceException: If the request fails.
+        """
+        if not self._started:
+            await self.start()
+
+        if not thread:
+            thread = self.get_new_thread()
+
+        session = await self._get_or_create_session(thread, streaming=True)
+        input_messages = normalize_messages(messages)
+        prompt = "\n".join([message.text for message in input_messages])
+
+        queue: asyncio.Queue[AgentResponseUpdate | Exception | None] = asyncio.Queue()
+
+        def event_handler(event: SessionEvent) -> None:
+            if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
+                if event.data.delta_content:
+                    update = AgentResponseUpdate(
+                        role=Role.ASSISTANT,
+                        contents=[Content.from_text(event.data.delta_content)],
+                        response_id=event.data.message_id,
+                        message_id=event.data.message_id,
+                        raw_representation=event,
+                    )
+                    queue.put_nowait(update)
+            elif event.type == SessionEventType.SESSION_IDLE:
+                queue.put_nowait(None)
+            elif event.type == SessionEventType.SESSION_ERROR:
+                error_msg = event.data.message or "Unknown error"
+                queue.put_nowait(ServiceException(f"GitHub Copilot session error: {error_msg}"))
+
+        unsubscribe = session.on(event_handler)
+
+        try:
+            await session.send({"prompt": prompt})
+
+            while (item := await queue.get()) is not None:
+                if isinstance(item, Exception):
+                    raise item
+                yield item
+        finally:
+            unsubscribe()
+
+    def _prepare_tools(
+        self,
+        tools: list[ToolProtocol | MutableMapping[str, Any]],
+    ) -> list[CopilotTool]:
+        """Convert Agent Framework tools to Copilot SDK tools.
+
+        Args:
+            tools: List of Agent Framework tools.
+
+        Returns:
+            List of Copilot SDK tools.
+        """
+        copilot_tools: list[CopilotTool] = []
+
+        for tool in tools:
+            if isinstance(tool, ToolProtocol):
+                match tool:
+                    case AIFunction():
+                        copilot_tools.append(self._ai_function_to_copilot_tool(tool))  # type: ignore
+                    case _:
+                        logger.debug(f"Unsupported tool type: {type(tool)}")
+            elif isinstance(tool, CopilotTool):
+                copilot_tools.append(tool)
+
+        return copilot_tools
+
+    def _ai_function_to_copilot_tool(self, ai_func: AIFunction[Any, Any]) -> CopilotTool:
+        """Convert an AIFunction to a Copilot SDK tool."""
+
+        async def handler(invocation: ToolInvocation) -> ToolResult:
+            args = invocation.get("arguments", {})
+            try:
+                if ai_func.input_model:
+                    args_instance = ai_func.input_model(**args)
+                    result = await ai_func.invoke(arguments=args_instance)
+                else:
+                    result = await ai_func.invoke(arguments=args)
+                return ToolResult(
+                    textResultForLlm=str(result),
+                    resultType="success",
+                )
+            except Exception as e:
+                return ToolResult(
+                    textResultForLlm=f"Error: {e}",
+                    resultType="failure",
+                    error=str(e),
+                )
+
+        return CopilotTool(
+            name=ai_func.name,
+            description=ai_func.description,
+            handler=handler,
+            parameters=ai_func.parameters(),
+        )
+
+    async def _get_or_create_session(
+        self,
+        thread: AgentThread,
+        streaming: bool = False,
+    ) -> CopilotSession:
+        """Get an existing session or create a new one for the thread.
+
+        Args:
+            thread: The conversation thread.
+            streaming: Whether to enable streaming for the session.
+
+        Returns:
+            A CopilotSession instance.
+
+        Raises:
+            ServiceException: If the session cannot be created.
+        """
+        if not self._client:
+            raise ServiceException("GitHub Copilot client not initialized. Call start() first.")
+
+        try:
+            if thread.service_thread_id:
+                return await self._resume_session(thread.service_thread_id, streaming)
+
+            session = await self._create_session(streaming)
+            thread.service_thread_id = session.session_id
+            return session
+        except Exception as ex:
+            raise ServiceException(f"Failed to create GitHub Copilot session: {ex}") from ex
+
+    async def _create_session(self, streaming: bool) -> CopilotSession:
+        """Create a new Copilot session."""
+        if not self._client:
+            raise ServiceException("GitHub Copilot client not initialized. Call start() first.")
+
+        config: SessionConfig = {"streaming": streaming}
+
+        if self._settings.model:
+            config["model"] = self._settings.model  # type: ignore[typeddict-item]
+
+        if self._instructions:
+            config["system_message"] = {"mode": "append", "content": self._instructions}
+
+        if self._tools:
+            config["tools"] = self._prepare_tools(self._tools)
+
+        if self._permission_handler:
+            config["on_permission_request"] = self._permission_handler
+
+        if self._mcp_servers:
+            config["mcp_servers"] = self._mcp_servers
+
+        return await self._client.create_session(config)
+
+    async def _resume_session(self, session_id: str, streaming: bool) -> CopilotSession:
+        """Resume an existing Copilot session by ID."""
+        if not self._client:
+            raise ServiceException("GitHub Copilot client not initialized. Call start() first.")
+
+        config: ResumeSessionConfig = {"streaming": streaming}
+
+        if self._tools:
+            config["tools"] = self._prepare_tools(self._tools)
+
+        if self._permission_handler:
+            config["on_permission_request"] = self._permission_handler
+
+        if self._mcp_servers:
+            config["mcp_servers"] = self._mcp_servers
+
+        return await self._client.resume_session(session_id, config)

agent_framework_github_copilot-1.0.0b260127/agent_framework_github_copilot/_settings.py

@@ -0,0 +1,49 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import ClassVar
+
+from agent_framework._pydantic import AFBaseSettings
+
+
+class GithubCopilotSettings(AFBaseSettings):
+    """GitHub Copilot model settings.
+
+    The settings are first loaded from environment variables with the prefix 'GITHUB_COPILOT_'.
+    If the environment variables are not found, the settings can be loaded from a .env file
+    with the encoding 'utf-8'. If the settings are not found in the .env file, the settings
+    are ignored; however, validation will fail alerting that the settings are missing.
+
+    Keyword Args:
+        cli_path: Path to the Copilot CLI executable.
+            Can be set via environment variable GITHUB_COPILOT_CLI_PATH.
+        model: Model to use (e.g., "gpt-5", "claude-sonnet-4").
+            Can be set via environment variable GITHUB_COPILOT_MODEL.
+        timeout: Request timeout in seconds.
+            Can be set via environment variable GITHUB_COPILOT_TIMEOUT.
+        log_level: CLI log level.
+            Can be set via environment variable GITHUB_COPILOT_LOG_LEVEL.
+        env_file_path: If provided, the .env settings are read from this file path location.
+        env_file_encoding: The encoding of the .env file, defaults to 'utf-8'.
+
+    Examples:
+        .. code-block:: python
+
+            from agent_framework_github_copilot import GithubCopilotSettings
+
+            # Using environment variables
+            # Set GITHUB_COPILOT_MODEL=gpt-5
+            settings = GithubCopilotSettings()
+
+            # Or passing parameters directly
+            settings = GithubCopilotSettings(model="claude-sonnet-4", timeout=120)
+
+            # Or loading from a .env file
+            settings = GithubCopilotSettings(env_file_path="path/to/.env")
+    """
+
+    env_prefix: ClassVar[str] = "GITHUB_COPILOT_"
+
+    cli_path: str | None = None
+    model: str | None = None
+    timeout: float | None = None
+    log_level: str | None = None

agent_framework_github_copilot-1.0.0b260127/pyproject.toml

@@ -0,0 +1,89 @@
+[project]
+name = "agent-framework-github-copilot"
+description = "GitHub Copilot integration for Microsoft Agent Framework."
+authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
+readme = "README.md"
+requires-python = ">=3.10"
+version = "1.0.0b260127"
+license-files = ["LICENSE"]
+urls.homepage = "https://aka.ms/agent-framework"
+urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
+urls.release_notes = "https://github.com/microsoft/agent-framework/releases?q=tag%3Apython-1&expanded=true"
+urls.issues = "https://github.com/microsoft/agent-framework/issues"
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Typing :: Typed",
+]
+dependencies = [
+    "agent-framework-core",
+    "github-copilot-sdk>=0.1.0",
+]
+
+[tool.uv]
+prerelease = "if-necessary-or-explicit"
+environments = [
+    "sys_platform == 'darwin'",
+    "sys_platform == 'linux'",
+    "sys_platform == 'win32'"
+]
+
+[tool.uv-dynamic-versioning]
+fallback-version = "0.0.0"
+[tool.pytest.ini_options]
+testpaths = 'tests'
+addopts = "-ra -q -r fEX"
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+filterwarnings = [
+    "ignore:Support for class-based `config` is deprecated:DeprecationWarning:pydantic.*"
+]
+timeout = 120
+
+[tool.ruff]
+extend = "../../pyproject.toml"
+
+[tool.coverage.run]
+omit = [
+    "**/__init__.py"
+]
+
+[tool.pyright]
+extends = "../../pyproject.toml"
+
+
+[tool.mypy]
+plugins = ['pydantic.mypy']
+strict = true
+python_version = "3.10"
+ignore_missing_imports = true
+disallow_untyped_defs = true
+no_implicit_optional = true
+check_untyped_defs = true
+warn_return_any = true
+show_error_codes = true
+warn_unused_ignores = false
+disallow_incomplete_defs = true
+disallow_untyped_decorators = true
+
+[tool.bandit]
+targets = ["agent_framework_github_copilot"]
+exclude_dirs = ["tests"]
+
+[tool.poe]
+executor.type = "uv"
+include = "../../shared_tasks.toml"
+[tool.poe.tasks]
+mypy = "mypy --config-file $POE_ROOT/pyproject.toml agent_framework_github_copilot"
+test = "pytest --cov=agent_framework_github_copilot --cov-report=term-missing:skip-covered tests"
+
+[build-system]
+requires = ["flit-core >= 3.11,<4.0"]
+build-backend = "flit_core.buildapi"