copilot: support Copilot authentication and service

Co-authored-by: GitHub Copilot (claude-opus-4.6)
Fixes: #2

Author: mathstuf

README.md

@@ -75,7 +75,7 @@ Run the cloud setup script:
 
 Or configure manually:
 - Press `,` in the app → configure API key
-- Supports OpenAI, Anthropic, OpenRouter
+- Supports OpenAI, Anthropic, OpenRouter, Copilot
 - Keys stored in `~/.config/meeting-notes/config.yaml`
 
 **Option B: Local AI (Free, private, but slower)**
@@ -187,7 +187,7 @@ python run.py --dev
 ### Settings
 
 Press `,` to configure:
-- AI provider (OpenAI, Anthropic, OpenRouter, Ollama, none)
+- AI provider (OpenAI, Anthropic, OpenRouter, Copilot, Ollama, none)
 - API keys
 - Whisper model (tiny/base/small/medium/large)
 - Recording mode (mic/system/combined)

meeting_notes/ai_summarizer.py

@@ -459,3 +459,139 @@ def summarize(self, transcript: str, user_notes: str = "") -> MeetingSummary:
                     logger.error(f"All {max_retries} attempts failed for OpenRouter API call")
                     logger.error(error_msg, exc_info=True)
                     raise
+
+
+class CopilotSummarizer(BaseSummarizer):
+    """Summarizer using GitHub Copilot API (included with Copilot subscription)."""
+
+    MODELS = {
+        "mini": {
+            "id": "gpt-4o-mini",
+            "name": "GPT-4o Mini (Copilot)",
+        },
+        "standard": {
+            "id": "gpt-4o",
+            "name": "GPT-4o (Copilot)",
+        },
+    }
+
+    def __init__(self, api_key: Optional[str] = None, model: str = "mini"):
+        """
+        Initialize Copilot summarizer.
+
+        Args:
+            api_key: GitHub OAuth access token (from device flow authentication).
+            model: Model tier - "mini" (gpt-4o-mini) or "standard" (gpt-4o).
+        """
+        if not api_key:
+            raise ValueError(
+                "GitHub Copilot token required. "
+                "Authenticate via Settings > GitHub Copilot > Authenticate with GitHub."
+            )
+
+        if model not in self.MODELS:
+            raise ValueError(
+                f"Invalid model: {model}. Choose from: {list(self.MODELS.keys())}"
+            )
+
+        self.model_config = self.MODELS[model]
+        self.model = self.model_config["id"]
+
+        try:
+            from .copilot_auth import COPILOT_API_BASE
+
+            self._oauth_token = api_key
+            self.copilot_api_base = COPILOT_API_BASE
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize Copilot auth: {e}")
+
+        try:
+            from openai import OpenAI
+
+            self._openai_class = OpenAI
+        except ImportError:
+            raise ImportError("openai package not installed. Run: pip install openai")
+
+        # Create initial client (token used directly as Bearer)
+        self._client = None
+        self._current_token = None
+
+    def _get_client(self):
+        """Get an OpenAI client using the OAuth token directly as Bearer."""
+        from meeting_notes import __version__
+
+        token = self._oauth_token
+
+        # Re-create client if token changed
+        if token != self._current_token:
+            self._client = self._openai_class(
+                api_key=token,
+                base_url=self.copilot_api_base,
+                default_headers={
+                    "Openai-Intent": "conversation-edits",
+                    "User-Agent": f"meeting-notes/{__version__}",
+                },
+            )
+            self._current_token = token
+
+        return self._client
+
+    def summarize(self, transcript: str, user_notes: str = "") -> MeetingSummary:
+        """Generate summary using GitHub Copilot with retry logic."""
+        logger.info(f"Generating AI summary with {self.model_config['name']}...")
+        logger.info(f"Transcript: {len(transcript.split())} words")
+        print(f"Generating AI summary with {self.model_config['name']}...")
+        print(f"Transcript: {len(transcript.split())} words")
+
+        max_retries = 2
+        retry_delay = 2  # seconds
+
+        for attempt in range(max_retries):
+            try:
+                client = self._get_client()
+
+                response = client.chat.completions.create(
+                    model=self.model,
+                    messages=[
+                        {
+                            "role": "user",
+                            "content": self._build_prompt(
+                                transcript, user_notes=user_notes
+                            ),
+                        }
+                    ],
+                    temperature=0.3,
+                )
+
+                # Log token usage if available (no cost tracking - included in subscription)
+                if response.usage:
+                    total_tokens = (
+                        response.usage.prompt_tokens + response.usage.completion_tokens
+                    )
+                    logger.info(
+                        f"Summary generated ({total_tokens} tokens, included in Copilot subscription)"
+                    )
+                    print(
+                        f"Summary generated ({total_tokens} tokens, included in Copilot subscription)"
+                    )
+                else:
+                    logger.info("Summary generated (Copilot)")
+                    print("Summary generated (Copilot)")
+
+                return self._parse_response(response.choices[0].message.content)
+
+            except Exception as e:
+                error_msg = f"Attempt {attempt + 1}/{max_retries} failed: {type(e).__name__}: {e}"
+
+                if attempt < max_retries - 1:
+                    # If it's a token error, force a refresh before retrying
+                    self._current_token = None
+                    logger.warning(error_msg + f" - Retrying in {retry_delay}s...")
+                    print(f"Warning: {error_msg} - Retrying in {retry_delay}s...")
+                    time.sleep(retry_delay)
+                else:
+                    logger.error(
+                        f"All {max_retries} attempts failed for Copilot API call"
+                    )
+                    logger.error(error_msg, exc_info=True)
+                    raise

meeting_notes/app.py

@@ -676,6 +676,8 @@ def __init__(self, dev_mode: bool = False):
             api_key = self.config.anthropic_api_key or os.getenv("ANTHROPIC_API_KEY")
         elif self.config.ai_provider == "openrouter":
             api_key = self.config.openrouter_api_key or os.getenv("OPENROUTER_API_KEY")
+        elif self.config.ai_provider == "copilot":
+            api_key = self.config.github_copilot_token or os.getenv("GITHUB_COPILOT_TOKEN")
 
         self.note_maker = NoteMaker(
             output_dir=self.config.notes_dir,
@@ -1517,6 +1519,8 @@ def handle_settings_closed(self, new_config: Optional[AppConfig]) -> None:
                 api_key = self.config.anthropic_api_key or os.getenv("ANTHROPIC_API_KEY")
             elif self.config.ai_provider == "openrouter":
                 api_key = self.config.openrouter_api_key or os.getenv("OPENROUTER_API_KEY")
+            elif self.config.ai_provider == "copilot":
+                api_key = self.config.github_copilot_token or os.getenv("GITHUB_COPILOT_TOKEN")
 
             self.note_maker = NoteMaker(
                 output_dir=self.config.notes_dir,

meeting_notes/config.py

@@ -15,13 +15,15 @@
 class AppConfig:
     """Application configuration."""
     # AI Summarization
-    ai_provider: str = "anthropic"  # "openai", "anthropic", "openrouter", "local", or "none"
+    ai_provider: str = "anthropic"  # "openai", "anthropic", "openrouter", "copilot", "local", or "none"
     ai_model: str = "haiku"  # Model tier (varies by provider)
 
     # API Keys (or set environment variables)
     openai_api_key: str = ""  # OPENAI_API_KEY
     anthropic_api_key: str = ""  # ANTHROPIC_API_KEY
     openrouter_api_key: str = ""  # OPENROUTER_API_KEY
+    github_copilot_token: str = ""  # OAuth token from GitHub Device Flow
+    github_copilot_client_id: str = ""  # GITHUB_COPILOT_CLIENT_ID
 
     # Legacy (kept for backwards compatibility)
     ollama_model: str = "llama3.2:3b"
@@ -54,6 +56,8 @@ def to_safe_dict(self) -> Dict[str, Any]:
             data['anthropic_api_key'] = self._redact_key(data['anthropic_api_key'])
         if data.get('openrouter_api_key'):
             data['openrouter_api_key'] = self._redact_key(data['openrouter_api_key'])
+        if data.get('github_copilot_token'):
+            data['github_copilot_token'] = self._redact_key(data['github_copilot_token'])
         return data
 
     @classmethod
@@ -138,7 +142,7 @@ def validate_config(config: AppConfig) -> tuple[bool, Optional[str]]:
         (is_valid, error_message)
     """
     # Validate AI provider
-    valid_providers = ["openai", "anthropic", "openrouter", "local", "none"]
+    valid_providers = ["openai", "anthropic", "openrouter", "copilot", "local", "none"]
     if config.ai_provider not in valid_providers:
         return False, f"Invalid ai_provider: {config.ai_provider}. Must be one of {valid_providers}"
 
@@ -177,6 +181,19 @@ def validate_config(config: AppConfig) -> tuple[bool, Optional[str]]:
         valid_models = ["cheap", "balanced", "premium"]
         if config.ai_model not in valid_models:
             return False, f"Invalid ai_model for OpenRouter: {config.ai_model}. Must be one of {valid_models}"
+    elif config.ai_provider == "copilot":
+        token = config.github_copilot_token or os.getenv("GITHUB_COPILOT_TOKEN")
+        if not token:
+            return False, (
+                "ai_provider is 'copilot' but not authenticated.\n"
+                "Set GITHUB_COPILOT_TOKEN environment variable or authenticate in Settings"
+            )
+        valid_models = ["mini", "standard"]
+        if config.ai_model not in valid_models:
+            return (
+                False,
+                f"Invalid ai_model for Copilot: {config.ai_model}. Must be one of {valid_models}",
+            )
 
     # Validate whisper model
     valid_whisper = ["tiny", "base", "small", "medium", "large"]