Switch to OpenRouter and add response stop control

README.md

@@ -35,7 +35,7 @@ pip install -r requirements.txt
 **2. Configure `.env`** in the project root:
 
 ```ini
-GROQ_API_KEY=gsk_...            # required
+OPENROUTER_API_KEY=...            # required
 CANDIDATE_NAME=Your Name        # used in the system prompt
 
 # Optional — Langfuse tracing. Tracing turns on only when both keys are present.
@@ -46,10 +46,10 @@ LANGFUSE_HOST=https://us.cloud.langfuse.com
 
 | Variable | Default | Purpose |
 |---|---|---|
-| `GROQ_API_KEY` | — | Required. Startup fails without it. |
+| `OPENROUTER_API_KEY` | — | Required. Startup fails without it. |
 | `CANDIDATE_NAME` | `the candidate` | Your name, used in the system prompt. |
 | `DATA_DIR` | `data` | Folder holding your profile documents. Relative paths resolve against the project root. |
-| `GROQ_MODEL` | `openai/gpt-oss-120b` | Model id. |
+| `OPENROUTER_MODEL` | `nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free` | OpenRouter model id. |
 | `LLM_TEMPERATURE` | `0.0` | Sampling temperature. |
 | `LLM_MAX_TOKENS` | `3000` | Response cap. See the token budget note below. |
 | `LLM_DRAFTING_TEMPERATURE` | `0.4` | Temperature for cover-letter drafting only. |
@@ -79,7 +79,9 @@ Startup fails if the directory is missing or holds no `.md` file, so do this bef
 python app.py                   # http://localhost:7860
 ```
 
-Paste a job description into the left panel, then chat or use the preset buttons.
+Paste a job description into the left panel, then chat or use the preset buttons. Select
+**Stop** beside the message box to cancel a response that's being generated; any text already
+received remains in the conversation.
 
 ## Project structure
 
@@ -182,10 +184,7 @@ every push to `main` and every pull request.
 
 ## Token budget
 
-Groq's free tier allows 8,000 tokens per minute and 200,000 per day for `openai/gpt-oss-120b`
-(check your own limits — they vary by model and account). A full-profile request sends your
-profile (~3,900 tokens) plus the job description plus the reserved response budget, so it costs
-roughly 7,000–8,000 tokens: about 25–28 such requests per day. Routed chat is much cheaper, so
-the real daily count is higher whenever questions take the `rag_answer` or `trivial_answer`
-route. `LLM_MAX_TOKENS` defaults to 3,000 to keep a full-profile request under the per-minute
-ceiling; raising it can push a request past the limit, which Groq rejects with HTTP 413.
+`LLM_MAX_TOKENS` defaults to 3,000 to cap the response size. A full-profile request also sends
+your profile (~3,900 tokens), the job description, and recent conversation history. OpenRouter
+model context windows and account limits vary, so shorten the job description or lower
+`LLM_MAX_TOKENS` if a request exceeds the model's limits.

app.py

@@ -77,8 +77,21 @@ def stream_response(chat_history, job_description, thread_id, model_query=None,
         if action in STRUCTURED_ACTIONS:
             chat_history[-1]["content"] = "_Extracting and scoring keywords…_"
             yield chat_history
-            result = GRAPH.invoke(state, config)
-            chat_history[-1]["content"] = str(result["messages"][-1].text)
+
+            response = None
+            for mode, chunk in GRAPH.stream(
+                state, config, stream_mode=["messages", "updates"]
+            ):
+                if mode == "messages":
+                    yield chat_history
+                elif mode == "updates":
+                    ats_update = chunk.get("ats_analysis")
+                    if ats_update and ats_update.get("messages"):
+                        response = ats_update["messages"][-1]
+
+            if response is None:
+                raise RuntimeError("ATS analysis completed without a response.")
+            chat_history[-1]["content"] = str(response.text)
             yield chat_history
             return
 
@@ -89,16 +102,15 @@ def stream_response(chat_history, job_description, thread_id, model_query=None,
     except Exception as exc:
         logger.exception("Request failed")
         detail = str(exc)
-        if "tokens per day" in detail or "TPD" in detail:
+        if "rate_limit" in detail or "429" in detail:
             detail = (
-                "Groq daily token limit reached. The quota resets on a rolling "
-                "24-hour basis, or you can raise it on the Groq billing page."
+                "OpenRouter rate limit reached. Check your account's limits or wait "
+                "before retrying."
             )
-        elif "rate_limit" in detail or "413" in detail:
+        elif "413" in detail:
             detail = (
-                "Groq per-minute token limit hit. The profile, job description, and "
-                "reserved response tokens exceed the allowance for one request. Shorten "
-                "the job description, lower LLM_MAX_TOKENS, or wait a minute and retry."
+                "The request is too large for the OpenRouter model. Shorten the job "
+                "description or lower LLM_MAX_TOKENS, then retry."
             )
         chat_history[-1]["content"] = f"**Request failed.** {detail}"
         yield chat_history
@@ -130,11 +142,14 @@ with gr.Blocks(title="job-chat", fill_height=True, analytics_enabled=False) as d
                 }
 
             chatbot = gr.Chatbot(height=520, show_label=False, resizable=True)
-            query_box = gr.Textbox(
-                placeholder="Ask a question...",
-                show_label=False,
-                submit_btn=True,
-            )
+            with gr.Row():
+                query_box = gr.Textbox(
+                    placeholder="Ask a question...",
+                    show_label=False,
+                    submit_btn=True,
+                    scale=5,
+                )
+                stop_btn = gr.Button("Stop", variant="stop", scale=1)
             clear_chat_btn = gr.Button("Reset conversation")
 
     jd_box.change(jd_status, inputs=jd_box, outputs=jd_state)
@@ -143,7 +158,9 @@ with gr.Blocks(title="job-chat", fill_height=True, analytics_enabled=False) as d
     # A new thread id starts a fresh checkpointed conversation; the old one stays on disk.
     clear_chat_btn.click(lambda: ([], new_thread_id()), outputs=[chatbot, thread_id])
 
-    query_box.submit(
+    generation_events = []
+
+    generation_events.append(query_box.submit(
         add_user_message,
         inputs=[query_box, chatbot],
         outputs=[query_box, chatbot],
@@ -152,10 +169,10 @@ with gr.Blocks(title="job-chat", fill_height=True, analytics_enabled=False) as d
         stream_response,
         inputs=[chatbot, jd_box, thread_id],
         outputs=chatbot,
-    )
+    ))
 
     for key, button in action_buttons.items():
-        button.click(
+        generation_events.append(button.click(
             partial(show_action_label, ACTIONS[key][0]),
             inputs=chatbot,
             outputs=chatbot,
@@ -164,7 +181,9 @@ with gr.Blocks(title="job-chat", fill_height=True, analytics_enabled=False) as d
             partial(run_action, key),
             inputs=[chatbot, jd_box, thread_id],
             outputs=chatbot,
-        )
+        ))
+
+    stop_btn.click(fn=None, cancels=generation_events, queue=False)
 
 
 if __name__ == "__main__":

config.py

@@ -11,15 +11,15 @@ load_dotenv()
 
 PROJECT_ROOT = Path(__file__).parent
 
-DEFAULT_MODEL = "openai/gpt-oss-120b"
+DEFAULT_MODEL = "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free"
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
 DEFAULT_TEMPERATURE = 0.0
 # Drafting a cover letter is writing, not analysis: a little sampling gives
 # natural prose. Kept low so it does not start inventing detail.
 DEFAULT_DRAFTING_TEMPERATURE = 0.4
 # The preset actions (ATS keyword tables, detailed reviews) run long, so 2048
-# truncated them mid-answer. The ceiling is Groq's free-tier limit of 8000
-# tokens per minute, which counts input + max_tokens together: profile (~3.9k)
-# plus job description plus this value must stay under it.
+# truncated them mid-answer. This leaves room for the profile, job description,
+# and conversation history while avoiding an unnecessarily large response cap.
 DEFAULT_MAX_TOKENS = 3000
 DEFAULT_DATA_DIR = "data"
 DEFAULT_LANGFUSE_HOST = "https://cloud.langfuse.com"
@@ -38,7 +38,7 @@ class ConfigError(RuntimeError):
 
 @dataclass(frozen=True)
 class Settings:
-    groq_api_key: str
+    openrouter_api_key: str
     candidate_name: str
     data_dir: Path
     model: str
@@ -101,15 +101,15 @@ def _resolve_data_dir():
 
 @lru_cache(maxsize=1)
 def get_settings() -> Settings:
-    api_key = os.getenv("GROQ_API_KEY", "").strip()
+    api_key = os.getenv("OPENROUTER_API_KEY", "").strip()
     if not api_key:
-        raise ConfigError("GROQ_API_KEY is not set. Add it to your .env file.")
+        raise ConfigError("OPENROUTER_API_KEY is not set. Add it to your .env file.")
 
     return Settings(
-        groq_api_key=api_key,
+        openrouter_api_key=api_key,
         candidate_name=os.getenv("CANDIDATE_NAME", "").strip() or "the candidate",
         data_dir=_resolve_data_dir(),
-        model=os.getenv("GROQ_MODEL", "").strip() or DEFAULT_MODEL,
+        model=os.getenv("OPENROUTER_MODEL", "").strip() or DEFAULT_MODEL,
         temperature=_get_float("LLM_TEMPERATURE", DEFAULT_TEMPERATURE),
         drafting_temperature=_get_float("LLM_DRAFTING_TEMPERATURE", DEFAULT_DRAFTING_TEMPERATURE),
         max_tokens=_get_int("LLM_MAX_TOKENS", DEFAULT_MAX_TOKENS),

email_writer.py

@@ -0,0 +1,80 @@
+import os
+from google import genai
+from google.genai import types
+
+def generate_application_email(
+    resume_text: str, 
+    projects_text: str, 
+    volunteer_text: str, 
+    target_company: str, 
+    job_title: str, 
+    recruiter_name: str = "Hiring Manager"
+):
+    # 1. Initialize the AI client (ensure GEMINI_API_KEY is in your environment variables)
+    client = genai.Client(api_key=os.environ.get("GEMINI_API_KEY"))
+
+    # 2. Load the skill instructions
+    # In production, you would read this from your skill.md file
+    with open("skill.md", "r") as file:
+        skill_instructions = file.read()
+
+    # 3. Construct the user prompt with all inputs
+    user_prompt = f"""
+    Please write my job application email based on the following information:
+    
+    TARGET JOB:
+    - Company: {target_company}
+    - Role: {job_title}
+    - Recruiter/Contact: {recruiter_name}
+    
+    MY BACKGROUND:
+    [Resume]
+    {resume_text}
+    
+    [Projects]
+    {projects_text}
+    
+    [Volunteer Experience]
+    {volunteer_text}
+    """
+
+    # 4. Call the LLM with the skill.md as the system instruction
+    print(f"Generating email for {job_title} at {target_company}...\n")
+    
+    response = client.models.generate_content(
+        model='gemini-2.5-pro',
+        contents=user_prompt,
+        config=types.GenerateContentConfig(
+            # The system instruction forces the AI to obey skill.md
+            system_instruction=skill_instructions,
+            # Lower temperature keeps the AI factual and prevents creative fluff
+            temperature=0.3,
+        )
+    )
+
+    return response.text
+
+# ==========================================
+# Example Usage
+# ==========================================
+if __name__ == "__main__":
+    # Mock inputs based on your profile
+    my_resume = "AI/ML Engineer with experience in deep learning frameworks. Tech stack: Python, PyTorch, Docker, Kubernetes."
+    my_projects = "Co-founder of Cysora: Built autonomous sales AI agents. Optimized PyTorch FSDP memory management for vision models."
+    my_volunteer = "Organized local tree-planting initiatives, coordinating 50+ volunteers."
+    
+    company = "Anthropic"
+    role = "Senior Machine Learning Engineer"
+    contact = "Sarah (Technical Recruiter)"
+
+    # Run the function
+    email_draft = generate_application_email(
+        resume_text=my_resume,
+        projects_text=my_projects,
+        volunteer_text=my_volunteer,
+        target_company=company,
+        job_title=role,
+        recruiter_name=contact
+    )
+    
+    print(email_draft)

graph.py

@@ -11,14 +11,14 @@ from functools import partial
 from typing import Annotated, TypedDict
 
 from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, trim_messages
-from langchain_groq import ChatGroq
+from langchain_openai import ChatOpenAI
 from langgraph.checkpoint.sqlite import SqliteSaver
 from langgraph.graph import START, StateGraph
 from langgraph.graph.message import add_messages
 
 import router as router_module
 from ats import ATSAnalysis, format_ats_report
-from config import get_settings
+from config import OPENROUTER_BASE_URL, get_settings
 from dataloader import ProfileLoader
 from embeddings import embed
 from prompts import (
@@ -89,8 +89,9 @@ DRAFTING_ACTIONS = {"cover_letter"}
 
 def build_llm(temperature=None):
     settings = get_settings()
-    return ChatGroq(
-        api_key=settings.groq_api_key,
+    return ChatOpenAI(
+        api_key=settings.openrouter_api_key,
+        base_url=OPENROUTER_BASE_URL,
         model=settings.model,
         temperature=settings.temperature if temperature is None else temperature,
         max_tokens=settings.max_tokens,

requirements.txt

@@ -2,7 +2,7 @@ fastembed==0.8.0
 gradio==6.22.0
 langchain==1.3.14
 langchain-core==1.5.1
-langchain-groq==1.1.3
+langchain-openai==1.1.3
 langgraph==1.2.10
 langgraph-checkpoint-sqlite==3.1.1
 langfuse==4.14.3

skills/analyze-ats-keywords.md

@@ -0,0 +1,29 @@
+# Skill: ATS Keyword Matcher & Optimization Engine
+
+## Role & Description
+You are an elite Applicant Tracking System (ATS) algorithm and technical recruiter. Your task is to mathematically analyze a user's resume against a specific Job Description (JD), calculate a match score, and provide highly actionable, organic integration strategies for missing keywords.
+
+## Inputs Provided by User
+- **User Background:** Resume (text).
+- **Target Data:** Job Description (text).
+
+## Core Directives & Rules
+
+### 1. The Strict Keyword Extraction
+- Extract "Hard Skills" (frameworks, languages, tools, e.g., PyTorch, Kubernetes, RAG).
+- Extract "Business Impact Skills" (e.g., cross-functional leadership, product strategy, A/B testing).
+- Discard generic corporate buzzwords (e.g., "fast-paced environment", "self-starter").
+
+### 2. The ATS Scoring Logic
+- **Score (0-100%):** Calculate based on the exact presence of critical Hard Skills and Business Impact Skills. 
+- Penalize heavily if core technical requirements (the first 3 bullets of a JD) are missing.
+
+### 3. The "No-Stuffing" Rule
+- Never recommend blindly listing keywords at the bottom of a resume.
+- For every missing keyword, suggest a way to integrate it organically into a past project or experience *only if* it aligns with the user's actual background (e.g., "If you used Elasticsearch for your project, explicitly name it in bullet 2").
+
+## Execution Steps
+1. **The Score:** Output a bolded ATS Match Score (e.g., **ATS Match: 72%**).
+2. **The Gap Analysis (Markdown Table):** Create a 3-column table: 
+   | Keyword Needed | Missing/Found | Context in JD |
+3. **Actionable Rewrites:** Select 2-3 existing resume bullets and rewrite them to naturally incorporate the highest-priority missing keywords.

skills/email-writing.md

@@ -0,0 +1,35 @@
+# Skill: Direct Job Application Email Writer
+
+## Role & Description
+You are an elite career coach and executive assistant. Your task is to synthesize a user's resume, projects, and volunteer experiences into highly optimized, perfectly structured direct job application emails. Your outputs strictly adhere to the proven best practices of top-tier university career centers (Stanford, CMU, MIT) and tech industry recruiters.
+
+## Inputs Provided by User
+- **User Background:** Resume, Relevant Projects, Volunteer Experience.
+- **Target Data:** Target Company, Job Title/Link, Hiring Manager/Recruiter Name (if known).
+
+## Core Directives & Rules
+
+### 1. The Bulleted Application Structure
+Construct the email body using this exact 3-part sequence:
+1. **The Direct Hook (1 sentence):** State exactly what role the user is applying for and mention one overarching theme of their background that makes them a perfect fit.
+2. **The Bulleted Value Pitch (2-3 bullets max):** 
+   - Extract the most relevant technical or business accomplishments from the user's data that directly solve a problem for the target role. 
+   - Start each bullet with a strong active verb (e.g., "Architected," "Optimized," "Led").
+   - Quantify the result or specify the technical stack in every bullet.
+   - Keep each bullet punchy and to a single line.
+3. **The Low-Friction Close (1 sentence):** State that the resume is attached for their review and propose a confident, low-friction next step.
+
+### 2. "Human-Written" Tone Guardrails
+- **Peer-to-Peer Tone:** Write like a competent professional, not a subordinate. Avoid overly formal or subservient language (e.g., "esteemed company," "humble," "It would be an honor").
+- **Plain English:** Use active voice and contractions (I'm, I've). Replace corporate jargon ("utilize," "leverage") with simple verbs ("use," "build").
+- **Zero Fluff:** Never use filler phrases like "I hope this email finds you well," "My name is X," or "Please find my resume attached below."
+
+### 3. Absolute Integrity & Strength-Focus
+- **Never Lie:** Do not fabricate metrics, skills, or experiences. Stick strictly to the provided user data.
+- **Do Not Highlight Gaps:** If the user's data does not perfectly match every requirement of the job description, focus entirely on the overlapping strengths. Do not apologize for or acknowledge missing skills.
+
+## Execution Steps
+1. **Analyze:** Ingest all provided background material. Silently discard anything irrelevant to the target job.
+2. **Draft Subject Lines:** Generate 3 highly optimized, scannable subject line options (e.g., "[Role] Application - [Name] - [Top Credential]").
+3. **Draft the Email:** Write the email strictly following the structure and tone rules above. Target length: ~100 words.
+4. **Format Output:** Present the subject lines, the email draft, and a brief 1-bullet explanation of why those specific bullets were chosen.

skills/review-resume-detailed.md

@@ -0,0 +1,34 @@
+# Skill: FAANG-Level Resume Reviewer & Architect
+
+## Role & Description
+You are a Principal Technical Recruiter at a top-tier tech company (e.g., Meta, Google, Anthropic). Your task is to ruthlessly critique a user's resume for impact, clarity, and signal-to-noise ratio. You do not offer vague encouragement; you offer surgical, line-by-line optimization based on industry standards.
+
+## Inputs Provided by User
+- **User Background:** Resume (text or current draft).
+- **Target Data:** Target Role/Level (e.g., Senior ML Engineer, Staff Software Engineer).
+
+## Core Directives & Rules
+
+### 1. The Google "XYZ" Formula Enforcement
+Every bullet point on the resume must be evaluated against the XYZ format:
+* **"Accomplished [X] as measured by [Y], by doing [Z]."**
+* If a bullet lacks a quantifiable metric (Y) or a specific technical implementation (Z), flag it as weak.
+
+### 2. The "So What?" Test
+- Identify responsibilities disguised as achievements. (e.g., "Responsible for maintaining databases" is a failure. "Reduced database query latency by 40% by implementing Elasticsearch" is a pass).
+- Flag any use of passive language or weak verbs ("helped," "assisted," "worked on").
+
+### 3. Visual & Cognitive Load Reduction
+- Identify redundant technical skills listed in multiple places.
+- Flag overly dense paragraphs. Resumes should be strictly bulleted. 
+- Ensure the most impressive, highest-impact bullet point is listed *first* under every job title.
+
+## Execution Steps
+1. **The Executive Summary (2-3 sentences):** Give a blunt, professional assessment of the resume's overall strength and primary weakness for the target role.
+2. **The Brutal Tear-Down (Section by Section):**
+   - **Strengths:** 2-3 bullets highlighting what is currently working well.
+   - **Weaknesses:** 2-3 bullets highlighting fluff, missing metrics, or poor formatting.
+3. **The Surgical Rewrites:** 
+   - Select the 3 weakest or most poorly phrased bullet points from the user's draft.
+   - Present the "Before" (original text).
+   - Present the "After" (rewritten text applying the XYZ formula, inferring structure where necessary but explicitly instructing the user to fill in the exact metrics).

skills/write-cover-letter.md

@@ -0,0 +1,33 @@
+# Skill: Elite Tech Cover Letter Writer
+
+## Role & Description
+You are a Tier-1 tech industry copywriter. Your task is to write high-converting, fluff-free cover letters. You completely reject the outdated, 5-paragraph essay format in favor of a modern, highly scannable, bullet-driven structure designed for hiring managers who only have 15 seconds to read.
+
+## Inputs Provided by User
+- **User Background:** Resume, Relevant Projects, Portfolio links.
+- **Target Data:** Target Company, Job Title, Job Description.
+
+## Core Directives & Rules
+
+### 1. The Scannable "T-Format" Structure
+Construct the cover letter using this exact sequence:
+1. **The Hook (1-2 sentences):** Skip the pleasantries. State the role, and immediately mention the specific company product/challenge you want to work on, backed by your overarching expertise.
+2. **The "Why I'm a Fit" Bullet Section:** 
+   - Write a bolded introductory half-sentence (e.g., "How my background maps to your requirements:").
+   - Provide 3 punchy bullet points.
+   - Each bullet must pair a specific requirement from the JD with a quantified accomplishment from the user's resume.
+3. **The Culture/Scale Tie-in (1 sentence):** A brief sentence demonstrating you understand the company's current stage (e.g., scaling infrastructure, finding product-market fit, enterprise sales).
+4. **The Close (1 sentence):** Confident, low-friction sign-off.
+
+### 2. Tone Guardrails
+- **Peer-to-Peer:** Write as a competent professional offering solutions, not a subordinate begging for a job.
+- **Active Voice Only:** "I architected the pipeline," not "The pipeline was architected by me."
+- **Zero Fluff:** Banned phrases: "I am writing to express my interest," "I believe I am the perfect candidate," "Enclosed please find my resume."
+
+### 3. Integrity
+- **Never Lie:** Stick strictly to the provided user data. Do not hallucinate metrics or skills.
+
+## Execution Steps
+1. **Analyze:** Cross-reference the user's resume with the JD to find the 3 strongest overlaps.
+2. **Draft:** Write the cover letter strictly following the T-Format structure. Maximum length: 200 words.
+3. **Output:** Present the cover letter draft, followed by a brief list of the 3 specific JD requirements targeted.

tests/conftest.py

@@ -20,7 +20,7 @@ atexit.register(shutil.rmtree, _FIXTURE_DIR, True)
 
 # load_dotenv() does not override variables that are already set, so these win
 # over any real .env on a developer machine.
-os.environ["GROQ_API_KEY"] = "test-key-not-used"
+os.environ["OPENROUTER_API_KEY"] = "test-key-not-used"
 os.environ["DATA_DIR"] = _FIXTURE_DIR
 os.environ["CANDIDATE_NAME"] = "Test Candidate"
 # Set to empty rather than deleted: load_dotenv() skips keys already present, so

tests/test_config.py

@@ -19,17 +19,17 @@ def data_dir(tmp_path):
 
 @pytest.fixture
 def base_env(monkeypatch, data_dir):
-    monkeypatch.setenv("GROQ_API_KEY", "test-key")
+    monkeypatch.setenv("OPENROUTER_API_KEY", "test-key")
     monkeypatch.setenv("DATA_DIR", str(data_dir))
-    for name in ("GROQ_MODEL", "LLM_TEMPERATURE", "LLM_MAX_TOKENS", "MAX_HISTORY_TURNS",
+    for name in ("OPENROUTER_MODEL", "LLM_TEMPERATURE", "LLM_MAX_TOKENS", "MAX_HISTORY_TURNS",
                  "CANDIDATE_NAME", "LANGFUSE_HOST", "LANGFUSE_BASE_URL",
                  "LANGFUSE_PUBLIC_KEY", "LANGFUSE_SECRET_KEY"):
         monkeypatch.delenv(name, raising=False)
 
 
 def test_missing_api_key_is_rejected(base_env, monkeypatch):
-    monkeypatch.setenv("GROQ_API_KEY", "   ")
-    with pytest.raises(ConfigError, match="GROQ_API_KEY"):
+    monkeypatch.setenv("OPENROUTER_API_KEY", "   ")
+    with pytest.raises(ConfigError, match="OPENROUTER_API_KEY"):
         get_settings()
 
 
@@ -56,6 +56,7 @@ def test_non_numeric_values_are_rejected(base_env, monkeypatch, var):
 
 def test_defaults_apply_when_optional_vars_are_unset(base_env):
     settings = get_settings()
+    assert settings.openrouter_api_key == "test-key"
     assert settings.model == config.DEFAULT_MODEL
     assert settings.temperature == config.DEFAULT_TEMPERATURE
     assert settings.max_tokens == config.DEFAULT_MAX_TOKENS
@@ -64,7 +65,7 @@ def test_defaults_apply_when_optional_vars_are_unset(base_env):
 
 
 def test_overrides_are_read_from_the_environment(base_env, monkeypatch):
-    monkeypatch.setenv("GROQ_MODEL", "some/other-model")
+    monkeypatch.setenv("OPENROUTER_MODEL", "some/other-model")
     monkeypatch.setenv("LLM_TEMPERATURE", "0.7")
     monkeypatch.setenv("MAX_HISTORY_TURNS", "3")
     settings = get_settings()

tests/test_isolation.py

@@ -17,8 +17,8 @@ def test_tracing_is_disabled_during_tests():
     assert get_settings().tracing_enabled is False
 
 
-def test_the_real_groq_key_is_not_used():
-    assert get_settings().groq_api_key == "test-key-not-used"
+def test_the_real_openrouter_key_is_not_used():
+    assert get_settings().openrouter_api_key == "test-key-not-used"
 
 
 def test_personal_documents_are_not_read():

tests/test_temperature.py

@@ -22,8 +22,8 @@ def test_default_temperatures():
 
 
 def test_build_llm_defaults_to_the_analysis_temperature():
-    # ChatGroq clamps an exact 0.0 to 1e-08, since Groq rejects zero.
     assert build_llm().temperature == pytest.approx(get_settings().temperature, abs=1e-6)
+    assert build_llm().openai_api_base == config.OPENROUTER_BASE_URL
 
 
 def test_build_llm_accepts_an_override():