docs: prepare v1 milestone release

docs: updated config docs and tests
docs: align project documentation with ollama provider
2026-06-16 10:58:31 +01:00 · 2026-06-15 15:37:55 +01:00 · 2026-06-15 14:05:05 +01:00 · 2026-06-15 13:35:31 +01:00 · 2026-06-15 11:06:00 +01:00 · 2026-06-15 10:46:36 +01:00
30 changed files with 4259 additions and 970 deletions
@@ -6,3 +6,4 @@ coverage/
 .DS_Store
 .vscode/
 .idea/
 .claude/
@@ -28,14 +28,7 @@
 ## Next Phase
-### Phase 4 - Tool Handlers
+All planned phases are complete. No pending work remains.
 Build the MCP tool handlers that:
 1. Register each tool with the MCP server.
 2. Validate input using `schemas.js`.
 3. Call the appropriate prompt builder.
 4. Send the prompt to OpenAI via `responses.js`.
 5. Return structured advisory output to Claude Code.
 ## Completed (Phase 4)
@@ -55,70 +48,180 @@ Total: 139 orchestration-only tests, all passing.
 **All five MCP tools registered:** ask_chatgpt, review_plan, review_code, debug_issue, architecture_review.
-### Task 5.1 - MCP server skeleton ✅
+## Completed (Phase 6) — Provider Abstraction ✅
-Minimal MCP stdio server in `src/server.js`. MCP initialize handshake succeeds. No tools registered yet.
+Decoupled tool handlers from OpenAI implementation via a provider abstraction layer:
-### Task 5.2 - Register ask_chatgpt MCP tool ✅
+### src/providers/factory.js
 - `createChatProvider(config)` validates `chatgptMcpProvider` against whitelist
 - Defaults to `"openai"` for any falsy/unknown value (null, NaN, numeric)
 - Throws with descriptive message on unrecognized provider names
-`ask_chatgpt` is now registered as an MCP tool on the server (`src/server.js`).
+### src/providers/openai.js
 - `openaiProvider.send(input, config)` — thin adapter wrapping OpenAI modules
 - Internally calls `createOpenAIClient(config)` then `sendOpenAIResponse(client, params)`
 - Params include: input as system messages array, model, temperature, maxOutputTokens from config
-**Registration details:**
+### Handler changes (all 5)
- Uses shared `baseInputSchema` (question required + context, constraints, expectedOutput, projectSummary, taskSummary, relevantFiles, logs optional).
+- Old interface: `{ loadConfig, createOpenAIClient, sendOpenAIResponse }`
- All 3 external deps injected: `loadConfig`, `createOpenAIClient`, `sendOpenAIResponse`.
+- New interface: `{ loadConfig, createProvider }`
- Returns structured MCP tool result: `{ content: [{ type: "text", text }], isError, warnings }`.
+- Each handler calls `provider = deps.createProvider(config)` then `provider.send(budget.input, config)`
 - Handler logic unchanged — only dependency injection changed
-**Smoke test results (all passing):**
+### CHATGPT_MCP_PROVIDER env var
- initialize → server returns `chatgpt-mcp` v0.1.0 ✅
+- Defaults to `"openai"` when not set
- tools/list → exposes `ask_chatgpt` with correct schema ✅
+- Accepts any string at loadConfig time; validation happens in factory at provider creation
- tools/call (happy path, mocked OpenAI) → `{ content: [...], isError: false }` with answer ✅
+- Currently only `"openai"` is whitelisted; others throw at createChatProvider() time
 - tools/call (minimal input `{ question: "hi" }`) → works ✅
 - tools/call (full input, all 10 schema fields) → handled correctly ✅
 - tools/call (missing OPENAI_API_KEY) → structured MCP error `"Error: Configuration error: OPENAI_API_KEY is missing."` ✅
 - tools/call (invalid API key) → structured MCP error `"OpenAI API error (OpenAIAuthError): 401"` ✅
 - All 523 unit tests pass across 18 test files ✅
-**Production code (`src/server.js`):** ~39 lines, single `ask_chatgpt` tool registered with MCP via Stdio transport.
+## Completed (Phase 7) — Tests ✅
-### Task 5.3 - Register remaining MCP tools ✅
+### Handler tests updated (5 files, all using `{ loadConfig, createProvider }` mock pattern)
 | File | Tests | Status |
 |------|-------|--------|
 | test/tools/ask-chatgpt.test.js | 27 | ✅ |
 | test/tools/review-plan.test.js | 28 | ✅ |
 | test/tools/review-code.test.js | 28 | ✅ |
 | test/tools/debug-issue.test.js | 28 | ✅ |
 | test/tools/architecture-review.test.js | 28 | ✅ |
-Four additional MCP tools registered on the server (`src/server.js`):
+### New provider/config tests (3 files)
 | File | Tests | Status |
 |------|-------|--------|
 | test/providers/factory.test.js | ~30 | ✅ covers default, whitelist, edge cases |
 | test/providers/openai.test.js | 27 | ✅ covers all send delegation paths |
 | test/config/env.test.js | +4 (added section) | ✅ covers chatgptMcpProvider env var |
-| Tool | Handler |
+### Final verification (Phase 7)
-|------|---------|
+- All 579 tests pass across 20 test files (end of Phase 7)
 | `review_plan` | handleReviewPlan |
 | `review_code` | handleReviewCode |
 | `debug_issue` | handleDebugIssue |
 | `architecture_review` | handleArchitectureReview |
-**All five MCP tools now registered:** ask_chatgpt, review_plan, review_code, debug_issue, architecture_review.
+### Post-multiphase verification
 - All 706 tests pass across 22 test files (all phases complete)
 - `npm start` → tools/list shows same 5 tools, unchanged schemas
 - Zero regression in existing test coverage
-**Smoke test results (all passing):**
+## Completed (Phase 8) — Manual Export Provider ✅
 - initialize → server returns `chatgpt-mcp` v0.1.0 ✅
 - tools/list → 5 tools total ✅
 - tools/call reaches handlers for all 5 tools ✅
 - missing OPENAI_API_KEY → structured tool errors: `"Error: Configuration error: OPENAI_API_KEY is missing."` ✅
 - npm test → 523 tests pass across 18 test files, no regressions ✅
-**Implementation notes:**
+### src/providers/manual-export.js
- Each tool registered explicitly with its own `registerTool()` call — no registry abstraction.
+- `manualExportProvider.send(request, config)` — zero-API-cost provider
- All handlers use existing modules only (no new imports or files).
+- Wraps pre-built prompt in copy/paste-ready format for ChatGPT Web (`https://chatgpt.com`)
- SDK quirk: `isError: true` wraps results in JSON-RPC error envelope (`code: -32603`).
+- Detects tool name from input fields: `debug_issue`, `review_code`, `architecture_review`, `review_plan`, `ask_chatgpt`
 - Adds box-delimited display with `│` prefixes, corner delimiters (┌ ┐ └ ┘)
 - Includes instructions section (5 numbered steps), metadata section (tool, provider, length)
 - Warns on prompts over 30k characters
 - Handles empty/missing prompt gracefully with advisory message
 - Preserves unicode, markdown code blocks, JSON, special HTML characters exactly
-### Task 5.4 - Normalize MCP tool error formatting ✅
+### Factory integration
 - `"manual"` added to SUPPORTED_PROVIDERS whitelist in `src/providers/factory.js`
 - `CHATGPT_MCP_PROVIDER=manual` switches all tool handlers to manual export mode
 - Defaults to `"openai"` when not set — OpenAI behaviour unchanged
 - Same provider interface: `{ send(request, config) => Promise<{ content: string }> }`
-MCP tool error formatting normalized in `src/server.js`. All 5 tool registrations now produce a single "Error:" prefix — no more duplicate `"Error: Error:"` strings.
+### Tests added (Phase 8)
 | File | Tests | Coverage |
 |------|-------|----------|
 | test/providers/manual-export.test.js | 56 | structure, tool detection, unicode, long prompts, edge cases, repeatability, visual layout |
 | test/providers/factory.test.js | +9 manual provider tests | factory integration with "manual" |
-**Changes:** Each tool callback normalizes the error text before returning:
+### Final verification (Phase 8)
- If `result.error` already starts with `"Error:"`, it is used as-is.
+- All 706 tests pass across 22 test files, zero regressions
- Otherwise, `"Error: "` is prepended.
+- `npm start` → tools/list shows same 5 tools, unchanged schemas
- `result.ok` responses are unchanged.
+- No `chat.openai.com` references in codebase — only `chatgpt.com`
 - MCP initialize handshake succeeds with chatgpt-mcp v0.1.0
-Smoke tests: npm test 523 passed ✅ · tools/list 5 tools ✅ · ask_chatgpt single prefix ✅ · review_plan single prefix ✅
+## Completed (Phase 10) — Ollama Provider ✅
-## Next Pending
+### src/providers/ollama.js
 - `ollamaProvider.send(reviewRequest, config)` — local AI provider using Ollama `/api/chat` endpoint
 - Uses native `fetch()` for HTTP calls — zero new dependencies
 - Implements same provider interface as openai and manual: `{ send(request, config) => Promise<{ content: string }> }`
-### Task 5.5 - Claude Code MCP configuration and local end-to-end setup
+### Provider details
 - **Request format**: OpenAI-compatible chat API (`model`, `messages`, `stream`, `options`)
 - **Response parsing**: Extracts `data.message.content` from Ollama response
 - **Error categories**: `OllamaTimeoutError`, `OllamaModelNotFoundError` (404), `OllamaValidationError` (422), `OllamaApiNotAvailableError` (501), `OllamaRequestError` (fallback)
 - **Base URL normalization**: Strips trailing slashes for safe path concatenation
 ### Environment variables
 | Variable | Default | Description |
 |----------|---------|-------------|
 | `OLLAMA_BASE_URL` | `http://localhost:11434` | Ollama API endpoint |
 | `OLLAMA_MODEL` | `qwen3:latest` | Model name for chat requests |
 | `OLLAMA_TEMPERATURE` | `0.2` | Sampling temperature |
 | `OLLAMA_TIMEOUT` | `60` | Request timeout in seconds |
 ### Factory integration
 - `"ollama"` added to SUPPORTED_PROVIDERS whitelist in `src/providers/factory.js`: `Set(["openai", "manual", "ollama"])`
 - `CHATGPT_MCP_PROVIDER=ollama` switches all tool handlers to local Ollama mode
 - Defaults to `"openai"` when not set — OpenAI behaviour unchanged
 - Same provider interface as openai and manual providers
 ### Current provider status
 | Provider | Env Value | Type | Requires API key? |
 |----------|-----------|------|-------------------|
 | `openai` | `CHATGPT_MCP_PROVIDER=openai` | Cloud (OpenAI Responses API) | Yes (`OPENAI_API_KEY`) |
 | `manual` | `CHATGPT_MCP_PROVIDER=manual` | Local (copy-paste) | No |
 | `ollama` | `CHATGPT_MCP_PROVIDER=ollama` | Local (Ollama /api/chat) | No |
 ### Task 5.1 through 5.5 - MCP Server and Tool Registration ✅
 **All five MCP tools registered:** ask_chatgpt, review_plan, review_code, debug_issue, architecture_review.
 Key details from Phase 5:
 - MCP stdio server in `src/server.js` with initialize handshake ✅
 - All tools use shared `baseInputSchema` with dependency injection via `{ loadConfig, createProvider }` (Phase 6)
 - Error formatting normalized — single "Error:" prefix across all tools ✅
 - Claude Code discovery configured via `.claude/settings.local.json` ✅
 ## Completed (Task 10.3) — Local Setup Helper ✅
 ### scripts/setup.js
 - Interactive onboarding helper (~280 lines, zero dependencies, Node.js built-ins only)
 - Provider selection: `[1] openai`, `[2] manual`, `[3] ollama`
 - Provider-specific prompts (OpenAI API key with masked input; Ollama URL, model, temperature, timeout)
 - Clean `.env` file generation with confirmation prompt
 - Preserves non-conflicting keys in existing `.env` files
 - Optional `.claude/settings.local.json` creation with MCP server config
 - Graceful non-TTY handling (visible input mode warning)
 - No network calls, no secrets printed, user-confirmation required
 ### Files added/modified
 | File | Action | Purpose |
 |------|--------|---------|
 | `scripts/setup.js` | Created | Interactive setup helper |
 | `test/setup/setup.test.js` | Created | 33 tests (provider validation, config generation, file I/O) |
 | `docs/SETUP.md` | Created | Full documentation for the setup helper |
 | `package.json` | Modified | Added `"setup": "node scripts/setup.js"` script |
 | `README.md` | Modified | Quick-start section + test count update |
 | `TASKS.md` | Modified | Phase 10 entry and Task 10.3 details |
 | `PROJECT_STATE.md` | Modified | Test count updated to 701/22 files |
 ### Test results (Task 10.3)
 - **Before:** 668 tests across 21 test files
 - **After:** 706 tests across 22 test files (+38 new)
 - All passing, zero regressions
 ### Smoke tests
 - `npm run setup` — starts and runs in non-TTY mode ✅
 - MCP initialize → `chatgpt-mcp` v0.1.0 ✅
 - MCP tools/list → 5 tools with correct schemas ✅
 ## V1 Milestone Complete
 All planned phases are implemented and tested. The project is at v1.0.0 status with:
 - 3 providers (openai, manual, ollama)
 - 5 MCP tools registered
 - 701 automated tests across 22 test files
 - Interactive setup helper
 - Complete documentation
 Future work opportunities (low priority):
 - Anthropic provider adapter
 - Streaming responses
 - Response caching
 - Cost tracking per tool call
 - Dockerfile / CI pipeline
 - Safe project summary generation
 ## General Rules
@@ -425,33 +425,52 @@ Rules:
 ## 12. OpenAI Integration
-Use OpenAI as a second-opinion provider only.
+Use OpenAI as a second-opinion provider only. The integration lives behind the provider abstraction layer:
 ```text
-Provider: OpenAI
+src/providers/factory.js    — createChatProvider(config) validates and returns configured provider
-API: Responses API
+src/providers/openai.js      — openaiProvider.send(input, config) thin adapter
-Model: configurable
+src/openai/client.js         — createOpenAIClient(config) low-level client
-Temperature: low
+src/openai/responses.js      — sendOpenAIResponse(client, params) API call wrapper
 Output: structured text
 ```
-Environment variables:
+### Provider Selection
 Configured via `CHATGPT_MCP_PROVIDER` env var (defaults to `"openai"`):
 ```env
-OPENAI_API_KEY=
+CHATGPT_MCP_PROVIDER=openai   # or "manual" for copy-paste workflow
 ```
 Supported provider values:
 | Value    | Description                                                    | Requires API key? |
 | -------- | -------------------------------------------------------------- | ----------------- |
 | `openai` | Default — calls ChatGPT via OpenAI API                       | Yes               |
 | `manual` | Copy-paste — wraps prompts in a ready-to-copy format         | No                |
 | `ollama` | Local AI — uses Ollama `/api/chat` endpoint with Qwen3       | No                |
 The factory whitelists `"openai"`, `"manual"`, and `"ollama"`. Any unrecognized value throws at provider creation time (not config load time). Null/NaN/falsy values default to `"openai"` for safe fallback.
 ### OpenAI-specific Environment Variables
 ```env
 OPENAI_API_KEY=                 # required — no default, throws if missing
 OPENAI_MODEL=gpt-5.1
 OPENAI_TEMPERATURE=0.2
 OPENAI_MAX_OUTPUT_TOKENS=2000
 ```
-The OpenAI integration should be isolated behind:
+### Ollama-specific Environment Variables
-```text
+```env
-src/openai/client.js
+OLLAMA_BASE_URL=http://localhost:11434   # Ollama API endpoint
-src/openai/responses.js
+OLLAMA_MODEL=qwen3:latest                # default model for chat requests
 OLLAMA_TEMPERATURE=0.2                   # sampling temperature
 OLLAMA_TIMEOUT=60                         # request timeout in seconds
 ```
-This makes it easier to add other providers later, including Ollama.
+The provider pattern makes it straightforward to add other providers (Anthropic, custom) — implement the `send(request, config)` interface and register it in the factory's whitelist. Ollama is already implemented.
 ---
@@ -477,7 +496,8 @@ CHATGPT_MCP_REDACT_SECRETS=true
 Rules:
- Fail fast if `OPENAI_API_KEY` is missing.
+- Fail fast if `OPENAI_API_KEY` is missing and provider is `openai`.
 - OPENAI_API_KEY is optional for `manual` and `ollama` providers.
 - Do not hardcode secrets.
 - Do not read `.env` content into prompts.
 - Keep context loading disabled by default.
@@ -590,10 +610,10 @@ No external logging service.
 ### Configuration errors
-Example:
+Example (when using `openai` provider):
 ```text
-Configuration error: OPENAI_API_KEY is missing.
+Configuration error: OPENAI_API_KEY is required for the openai provider.
 ```
 ### Validation errors
@@ -783,29 +803,27 @@ After the MVP works, add the other tools one at a time.
 ## 23. Future Roadmap
-Near term:
+The following items remain from the original planning scope:
- Add all five MCP tools.
+### Near term (post-v1)
 - Add structured response formatting.
 - Add better tests.
 - Add context file opt-in loading.
-Medium term:
+- Add context file opt-in loading from `/context` directory
 - Add structured response formatting enhancements
- Add optional Ollama provider.
+### Medium term
 - Add model-per-tool config.
 - Add cost tracking.
 - Add timeout/retry tuning.
 - Add local-only mode for sensitive reviews.
-Later:
+- Add Anthropic provider adapter (abstraction layer ready; implement `send(request, config)` interface)
 - Add model-per-tool configuration
 - Add timeout/retry tuning per provider
- Add Dockerfile.
+### Later
- Add Jenkins validation pipeline.
+
- Add Gitea pull request workflow.
+- Add Dockerfile
- Add safe project summary generation.
+- Add CI/CD pipeline (Jenkins validation, Gitea PR workflow)
- Add optional OpenHands integration.
+- Add safe project summary generation
- Add provider abstraction for OpenAI/Ollama/local models.
+- Add optional OpenHands integration
 - Add streaming responses support
 - Add cost tracking per tool call
 ---
@@ -6,12 +6,13 @@ ChatGPT MCP Server
 ## Status
-Planning complete.
+Planning complete. Phase 0 complete. Phase 1 complete. Phase 2 complete. Phase 3 complete. Phase 4 complete. Task 5.1 complete. Task 5.2 complete. Task 5.3 complete. Task 5.4 complete. Task 5.5 complete. Phase 6 complete. Phase 7 complete. Phase 8 complete (Task 8.0 — Manual Export Provider). Phase 9 complete (Task 9.1 — Ollama Provider).
 Phase 0 complete. Phase 1 complete. Phase 2 complete. Phase 3 complete. Task 4.1 complete. Task 4.2 complete. Task 4.3 complete. Task 4.4 complete. Task 4.5 complete. Phase 4 complete. Task 5.1 complete. Task 5.2 complete. Task 5.3 complete. Task 5.4 complete.
 ## Current Phase
-Phase 5 - MCP Server and Tool Registration
+All planned phases complete. Provider abstraction (Phase 6), integration tests (Phase 7), manual export provider (Phase 8), and Ollama provider (Phase 9) finished. **3 supported providers: openai, manual, ollama.**
 Task 10.3 — Local Setup Helper implemented (interactive onboarding for `.env` and Claude Code config).
 ## Completed Tasks
@@ -75,6 +76,124 @@ Phase 5 - MCP Server and Tool Registration
 MCP tool error formatting normalized in `src/server.js`. All 5 tools now produce a single "Error:" prefix with no duplicates.
 - Task 5.5 — Claude Code MCP configuration and local end-to-end setup ✅
 Project-local Claude Code discovery configured:
 - Task 6.1 — Provider abstraction factory (`src/providers/factory.js`, `test/providers/factory.test.js`) ✅
  **What it provides:**
  - `createChatProvider(config)` returns the configured chat provider (currently only `"openai"`)
  - Factory validates provider name against whitelist; defaults to `"openai"` for any falsy/unknown value
  - All tool handlers receive `{ loadConfig, createProvider }` via dependency injection instead of `{ createOpenAIClient, sendOpenAIResponse }`
 - Task 6.2 — OpenAI provider adapter (`src/providers/openai.js`, `test/providers/openai.test.js`) ✅
  **What it provides:**
  - `openaiProvider.send(input, config)` thin interface wrapping existing OpenAI modules
  - Internally calls `createOpenAIClient(config)` → `sendOpenAIResponse(client, { input: [{ role: "system", content }], model, temperature, maxOutputTokens })`
 - Task 7.1 — Update all tool handlers to use provider abstraction ✅
  All five handler files updated:
  - `src/tools/ask-chatgpt.js` — uses `deps.createProvider(config)` + `provider.send()`
  - `src/tools/review-plan.js` — same
  - `src/tools/review-code.js` — same
  - `src/tools/debug-issue.js` — same
  - `src/tools/architecture-review.js` — same
 - Task 7.2 — Update handler tests to use provider mock pattern ✅
  All five handler test files rewritten with `{ loadConfig, createProvider }` mock pattern:
  - `test/tools/ask-chatgpt.test.js` — 27 tests
  - `test/tools/review-plan.test.js` — 28 tests
  - `test/tools/review-code.test.js` — 28 tests
  - `test/tools/debug-issue.test.js` — 28 tests
  - `test/tools/architecture-review.test.js` — 28 tests
 - Task 7.3 — Config and provider test coverage ✅
  - `test/config/env.test.js` — added chatgptMcpProvider env var tests (default "openai", accepts any string)
  - Provider factory tests validate whitelist enforcement, case sensitivity, edge cases (null, NaN, whitespace, JSON strings, mutations)
 - Task 7.4 — Final integration verification ✅
  - All 701 tests pass across 22 test files after all phases (Phase 7 end state)
  - `npm start` → tools/list shows same 5 tools with unchanged schemas
 - Task 8.0 — Implement ReviewRequest and Manual Export Provider ✅
  **Provider implementation:**
  - `src/providers/manual-export.js` — Zero-API-cost provider that wraps pre-built prompts in copy/paste-ready format
  - Returns `{ content: string }` via `send(reviewRequest, config)`
  - Uses `https://chatgpt.com` (never `https://chat.openai.com`)
  - Detects tool name from input fields for metadata
  - Warns on prompts over 30k characters
  - Preserves unicode, markdown, code blocks, and special characters exactly
  **Factory integration:**
  - `"manual"` added to SUPPORTED_PROVIDERS whitelist in `src/providers/factory.js`
  - `CHATGPT_MCP_PROVIDER=manual` switches all tool handlers to manual export mode
  - Defaults to `"openai"` when not set — OpenAI behaviour unchanged
  **Tests:** 56 new tests in `test/providers/manual-export.test.js` + 9 new in `test/providers/factory.test.js`
  - Total: 706 passing tests across 22 test files, zero regressions
 - `.claude/` added to `.gitignore` (no machine-specific paths committed)
 - Task 9.1 — Ollama Provider Implementation ✅
  **Provider implementation:**
  - `src/providers/ollama.js` — Local AI provider using Ollama `/api/chat` endpoint via native `fetch()` (zero new dependencies)
  - Implements `{ send(request, config) => Promise<{ content: string }> }` interface
  - Returns structured advisory responses from local LLM
  - Error categories: `OllamaTimeoutError`, `OllamaModelNotFoundError`, `OllamaValidationError`, `OllamaApiNotAvailableError`, `OllamaRequestError`
  **Defaults:**
  - Base URL: `http://localhost:11434`
  - Model: `qwen3:latest`
  - Temperature: `0.2`
  - Timeout: `60` seconds
  **Environment variables:**
  - `OLLAMA_BASE_URL` — Ollama API endpoint (default: `http://localhost:11434`)
  - `OLLAMA_MODEL` — Model name (default: `qwen3:latest`)
  - `OLLAMA_TEMPERATURE` — Sampling temperature (default: `0.2`)
  - `OLLAMA_TIMEOUT` — Request timeout in seconds (default: `60`)
  **Factory integration:**
  - `"ollama"` added to SUPPORTED_PROVIDERS whitelist alongside `"openai"` and `"manual"`
  - `CHATGPT_MCP_PROVIDER=ollama` switches all tool handlers to local Ollama mode
  - Defaults to `"openai"` when not set — OpenAI behaviour unchanged
  - Same provider interface as openai and manual providers
 ## Phase 9 Completion Summary — Ollama Provider ✅
 Three providers now supported: `openai`, `manual`, `ollama`.
 - Factory in `src/providers/factory.js`: `SUPPORTED_PROVIDERS = Set(["openai", "manual", "ollama"])`
 - All three providers implement `{ send(request, config) => Promise<{ content: string }> }`
 - Provider selection via `CHATGPT_MCP_PROVIDER` environment variable
 - Zero additional dependencies — Ollama provider uses native `fetch()` only
 ## V1 Milestone Complete
 **Status: V1 Complete** — all planned phases implemented and tested.
 ### Summary
 - 3 supported providers: `openai`, `manual`, `ollama`
 - 5 MCP tools registered with shared schema
 - Interactive setup helper (`npm run setup`)
 - Provider abstraction layer with factory pattern
 - Comprehensive test suite: 706 tests across 22 files
 - Full documentation consistent and release-ready
 ### Future Work (Low Priority)
 - Anthropic provider adapter
 - Streaming responses
 - Response caching
 - Cost tracking per tool call
 - Dockerfile / CI pipeline
 ## Phase 3 Completion Summary
 Phase 3 — Tool Inputs and Prompts — is now complete.
@@ -109,6 +228,8 @@ All five tool handlers are implemented and tested:
 | 4 | `handleDebugIssue` | `src/tools/debug-issue.js` | ✅ 28 |
 | 5 | `handleArchitectureReview` | `src/tools/architecture-review.js` | ✅ 28 |
 Total: 139 orchestration-only tests, all passing.
 **What Phase 4 established:**
 - Five standalone, dependency-injected handlers following the same orchestration pattern: validate → config → budget → prompt → client → response.
@@ -124,6 +245,39 @@ All five tool handlers are implemented and tested:
 - No server or router code yet.
 - That belongs to Phase 5.
-## Next Pending
+## Phase 6 Completion Summary — Provider Abstraction ✅
-### Task 5.5 - Claude Code MCP configuration and local end-to-end setup
+Provider abstraction layer decouples tool handlers from OpenAI implementation:
 - `createChatProvider(config)` factory in `src/providers/factory.js` with whitelist validation
 - `openaiProvider.send(input, config)` thin adapter in `src/providers/openai.js`
 - All 5 handlers now use `{ loadConfig, createProvider }` dependency injection
 - Factory defaults to `"openai"` for any falsy/invalid provider name (null, NaN, numeric)
 - Zero changes needed to handler logic — only interface change from direct OpenAI calls to provider abstraction
 ## Phase 7 Completion Summary — Tests ✅
 All tests rewritten and verified:
 - 706 passing tests across 22 test files (Phase 8 added 65 tests; Phase 9 added context-loading tests; Task 10.3 added 38 tests)
 - Provider/config tests in factory.test.js, openai.test.js, env.test.js, manual-export.test.js
 - All handler tests use `{ loadConfig, createProvider }` mock pattern
 - `npm start` → tools/list shows identical 5 tools with unchanged schemas
 ## V1 Milestone Complete
 **Status: V1 Complete** — all planned phases implemented and tested.
 ### Summary
 - 3 supported providers: `openai`, `manual`, `ollama`
 - 5 MCP tools registered with shared schema
 - Interactive setup helper (`npm run setup`)
 - Provider abstraction layer with factory pattern
 - Comprehensive test suite: 706 tests across 22 files
 - Full documentation consistent and release-ready
 ### Future Work (Low Priority)
 - Anthropic provider adapter
 - Streaming responses
 - Response caching
 - Cost tracking per tool call
 - Dockerfile / CI pipeline
@@ -1,11 +1,29 @@
 # ChatGPT MCP Server
-A local MCP server that allows Claude Code to ask ChatGPT for focused second-opinion help.
+A local MCP (Model Context Protocol) server that gives Claude Code access to specialized ChatGPT review and advisory tools.
 The server provides structured second-opinion workflows for:
 - General questions and alternative viewpoints
 - Implementation plan reviews
 - Code reviews
 - Debugging investigations
 - Architecture reviews
 Claude Code remains the primary coding agent. ChatGPT acts only as an advisor and reviewer.
 ---
 ## Purpose
-ChatGPT acts as a reviewer, planner, debugging assistant, and architecture advisor.
+This project combines the strengths of both models:
-Claude Code remains the primary coding agent with full control over files, commands, and decisions.
+
 - **Claude Code** performs implementation, editing, refactoring, testing, and repository operations.
 - **ChatGPT** provides independent analysis, review, risk assessment, debugging assistance, and architectural feedback.
 The goal is to improve decision quality without introducing autonomous behaviour.
 ---
 ## Non-Goals
@@ -15,11 +33,295 @@ The server must not:
 - Run shell commands
 - Access Git automatically
 - Deploy anything
- Send whole repositories by default
+- Send entire repositories by default
 - Send secrets
 - Make autonomous decisions
-## Status
+ChatGPT only returns analysis and recommendations.
-Phase 0 complete — repository skeleton created.
+---
-Implementation in progress.
+
 ## Architecture
 ```text
 Claude Code
    ↓
 MCP Tool
    ↓
 Input Validation
    ↓
 Context Budget Enforcement
    ↓
 Prompt Builder
    ↓
 Provider Factory (createChatProvider)
    ↓
 OpenAI Provider  →  OpenAI Responses API
 Manual Provider   →  Copy-ready prompt output
 Ollama Provider   →  Ollama /api/chat
    ↓
 Advisory Response
 ```
 The provider layer is configurable via `CHATGPT_MCP_PROVIDER` env var (defaults to `"openai"`). Three providers are available:
 | Value    | Description                                                      | Use case                                    |
 | -------- | ---------------------------------------------------------------- | ------------------------------------------- |
 | `openai` | Default — calls ChatGPT via OpenAI API                         | Automated second-opinion queries            |
 | `manual` | Copy-paste — wraps prompts in a ready-to-copy format           | Manual ChatGPT Web/Business as advisor      |
 | `ollama` | Local AI — uses Ollama `/api/chat` with Qwen3 model          | Offline/local second-opinion via local LLM  |
 For the **manual** provider, set `CHATGPT_MCP_PROVIDER=manual`. Each tool call returns a copy-ready prompt block you can paste into ChatGPT Web or ChatGPT Business. This turns Claude Code into an orchestrator: it builds the perfect prompt and formats it for you to hand off to ChatGPT as a second-opinion advisor — all without API calls, quotas, or cost.
 For the **ollama** provider, set `CHATGPT_MCP_PROVIDER=ollama` and ensure Ollama is running locally. The provider uses Qwen3 via Ollama's OpenAI-compatible `/api/chat` endpoint with no additional dependencies. This turns Claude Code into an orchestrator: it builds the perfect prompt and sends it directly to your local model — all without cloud API calls, quotas, or cost.
 The factory pattern enables future providers (Anthropic, custom) without touching tool handlers.
 All responses are advisory only.
 ---
 ## Available MCP Tools
 | Tool                  | Purpose                                                                                                                                   |
 | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
 | `ask_chatgpt`         | General second-opinion questions, alternatives, risks, trade-offs, and clarification.                                                     |
 | `review_plan`         | Reviews implementation plans for missing steps, sequencing issues, unsafe assumptions, scope creep, and test gaps.                        |
 | `review_code`         | Reviews code snippets, patches, and diffs for correctness, bugs, maintainability, security concerns, and testing opportunities.           |
 | `debug_issue`         | Analyses errors, logs, failed tests, and stack traces to identify likely root causes and propose safe investigation steps.                |
 | `architecture_review` | Reviews architecture decisions, system design, trade-offs, maintainability, operational risk, vendor lock-in, and future evolution paths. |
 ---
 ## Features
 ### OpenAI Integration
 - OpenAI Responses API
 - Configurable model selection
 - Dependency-injected design for testability
 - Structured error handling
 - Safe error messages without secret leakage
 ### Local AI Provider (Ollama)
 - Uses Ollama `/api/chat` endpoint via native `fetch()` — zero new dependencies
 - Default model: `qwen3:latest` on `http://localhost:11434`
 - Configurable temperature, timeout, and base URL
 - Produces the same structured advisory responses as OpenAI provider
 ### Prompt System
 - Shared base prompt layer
 - Tool-specific prompt builders
 - Consistent advisory behaviour
 - Structured response guidance
 ### Input Protection
 - Zod-based validation
 - Context budget enforcement
 - File size limits
 - Log size limits
 - Secret redaction utilities
 ### MCP Integration
 - MCP stdio server
 - Tool discovery via `tools/list`
 - Structured tool responses
 - Claude Code integration
 ### Testing
 - 706 automated tests across 22 files
 - Unit-tested utilities
 - Prompt builder coverage
 - OpenAI integration coverage
 - Tool handler orchestration coverage
 - MCP registration verification
 - Manual export provider coverage (56 tests)
 ---
 ## Requirements
 - Node.js 22+
 - OpenAI API key **OR** Ollama (with `qwen3:latest` model pulled) **OR** use `manual` provider for zero-API workflow
 - Claude Code (or another MCP-compatible client)
 ---
 ## Quick Start
 For the fastest onboarding, use the interactive setup helper:
 ```bash
 npm install
 npm run setup     # Choose a provider and configure .env (interactive)
 npm test          # Verify everything works
 npm start         # Start the MCP server
 ```
 The setup helper guides you through choosing between `openai`, `manual`, or `ollama` providers, then creates your `.env` and optionally `.claude/settings.local.json`.
 See [docs/SETUP.md](./docs/SETUP.md) for full documentation.
 ---
 ## Installation
 Install dependencies:
 ```bash
 npm install
 ```
 Set your OpenAI API key:
 ```bash
 export OPENAI_API_KEY=sk-your-key
 ```
 Optional environment variables:
 ```bash
 # Provider selection (default: openai)
 export CHATGPT_MCP_PROVIDER=openai   # or "manual" or "ollama"
 # OpenAI provider settings
 export OPENAI_MODEL=gpt-5.1
 export OPENAI_TEMPERATURE=0.2
 export OPENAI_MAX_OUTPUT_TOKENS=2000
 # Ollama provider settings (used when CHATGPT_MCP_PROVIDER=ollama)
 export OLLAMA_BASE_URL=http://localhost:11434
 export OLLAMA_MODEL=qwen3:latest
 export OLLAMA_TEMPERATURE=0.2
 export OLLAMA_TIMEOUT=60
 # General settings
 export CHATGPT_MCP_LOG_LEVEL=info
 export CHATGPT_MCP_MAX_INPUT_CHARS=30000
 ```
 ---
 ## Running Tests
 ```bash
 npm test
 ```
 ---
 ## Running the MCP Server
 Start the stdio MCP server:
 ```bash
 npm start
 ```
 The server communicates over stdin/stdout and is intended to be launched by an MCP client rather than directly by users.
 ---
 ## Claude Code Configuration
 Configure Claude Code to discover the MCP server.
 Create either:
 - Global configuration: `~/.claude/settings.json`
 - Project-local configuration: `.claude/settings.local.json`
 Example:
 ```json
 {
  "mcpServers": {
    "chatgpt-mcp": {
      "command": "npm",
      "args": ["start"]
    }
  }
 }
 ```
 After opening the project in Claude Code, the server should be automatically discovered and the five MCP tools should become available.
 ---
 ## V1 Milestone
 **Status: V1 Complete**
 ### Implemented
 - OpenAI provider (GPT-5.1 via Responses API)
 - Manual Export provider (copy-paste-ready prompts for ChatGPT Web)
 - Ollama provider (local AI via `qwen3.6:35b-a3b`)
 - Provider abstraction layer with factory pattern
 - Context budget enforcement and secret redaction
 - 5 MCP review tools (`ask_chatgpt`, `review_plan`, `review_code`, `debug_issue`, `architecture_review`)
 - Interactive local setup helper (`npm run setup`)
 - 706 automated tests across 22 test files
 ### Capabilities
 The ChatGPT MCP Server provides structured second-opinion workflows for:
 - General questions and alternative viewpoints
 - Implementation plan reviews
 - Code reviews
 - Debugging investigations
 - Architecture reviews
 All responses are advisory-only. Claude Code remains the primary coding agent.
 ---
 ## Current Status
 ### MVP Complete
 Implemented:
 - OpenAI Responses API integration
 - Ollama local AI provider (`qwen3:latest`) — zero new dependencies
 - Three configurable providers: `openai`, `manual`, `ollama`
 - Shared validation and safety utilities
 - Context budget management
 - Five prompt builders
 - Five tool handlers
 - MCP stdio server
 - Registration of all five MCP tools
 - Claude Code integration documentation
 - Comprehensive automated test suite (701 tests across 22 files)
 - Interactive local setup helper (`npm run setup`)
 ### Next Steps
 Planned future work includes:
 - Real-world workflow validation
 - Prompt refinements
 - Additional context-loading features
 - Improved operational diagnostics
 - Production hardening
 ---
 ## Development Philosophy
 Keep the system simple.
 - Prefer local-first solutions
 - Minimise moving parts
 - Avoid unnecessary abstractions
 - Favour small, testable modules
 - Keep ChatGPT advisory-only
 - Keep Claude Code in control
 The objective is not autonomous development. The objective is better engineering decisions through independent review.
@@ -1,6 +1,6 @@
 # TASKS.md
-## Phase 0 - Repository Setup
+## Phase 0 — Repository Setup
 ### Task 0.1 - Create repository skeleton
@@ -27,7 +27,7 @@ Status: ✅ Complete
 ---
-## Phase 1 - Core Utilities
+## Phase 1 — Core Utilities
 ### Task 1.1 - Configuration loader
@@ -89,7 +89,7 @@ Status: ✅ Complete
 ---
-## Phase 2 - OpenAI Integration
+## Phase 2 — OpenAI Integration
 ### Task 2.1 - OpenAI client wrapper
@@ -409,7 +409,7 @@ Phase 2 complete. Phase 3 complete. Phase 4 complete. Phase 5 next: MCP Server a
 ---
-## Phase 5 - MCP Server and Tool Registration
+## Phase 5 — MCP Server and Tool Registration
 ### Task 5.1 - MCP server skeleton
@@ -565,4 +565,493 @@ Smoke tests:
 Status: ✅ Complete
-### Task 5.5 - Claude Code MCP configuration and local end-to-end setup (NEXT)
+### Task 5.5 - Claude Code MCP configuration and local end-to-end setup ✅
 Configure project-local Claude Code discovery via `.claude/settings.local.json` and document local setup steps in README.
 **Requirements:**
 - Add `.claude/` to `.gitignore` so machine-specific MCP config is not committed.
 - Document `npm install`, `export OPENAI_API_KEY=...`, `npm test`, `npm start` in README.
 - Provide Claude Code MCP config snippet using `"command": "npm"`, `"args": ["start"]` (no absolute paths).
 - List all 5 available MCP tools with descriptions in README.
 **Changes made:**
 - Added `.claude/` to `.gitignore` ✅
 - Updated `README.md` with Setup, MCP Tools, and Running sections ✅
 **What was NOT done:**
 - No `.claude/settings.local.json` committed — machine-specific config remains local only ✅
 - No secrets or absolute paths in any tracked file ✅
 Status: ✅ Complete
 ---
 ## Phase 6 — Provider Abstraction
 ### Task 6.1 — Provider factory (`src/providers/factory.js`, `test/providers/factory.test.js`)
 Create `createChatProvider(config)` factory that validates and returns configured chat provider.
 **Requirements:**
 - Whitelist validates against `"openai"` only (currently)
 - Defaults to `"openai"` for any falsy/unknown value (null, NaN, empty string, numeric)
 - Throws descriptive error on unrecognized provider names containing both the invalid name and supported providers
 - No global state — all logic in pure function
 **Tests:** ~30 tests covering default provider, CHATGPT_MCP_PROVIDER env var, whitelist enforcement, case sensitivity, edge cases (null, NaN, whitespace, JSON strings, mutation checks).
 Status: ✅ Complete
 ### Task 6.2 — OpenAI provider adapter (`src/providers/openai.js`, `test/providers/openai.test.js`)
 Create `openaiProvider.send(input, config)` thin interface that wraps existing OpenAI modules.
 **Interface:**
 ```js
 provider.send(input, config) → Promise<{ content: string }>
 ```
 Internally calls:
 1. `createOpenAIClient(config)` — returns client with API key
 2. `sendOpenAIResponse(client, { input: [{ role: "system", content }], model, temperature, maxOutputTokens })`
 **Tests:** 27 tests covering parameter passing, call ordering, error propagation, idempotency, edge cases (empty input, unicode, long input, object input).
 Status: ✅ Complete
 ---
 ## Phase 7 — Integration and Test Updates
 ### Task 7.1 — Update all tool handlers to use provider abstraction
 All five handler files updated to use `{ loadConfig, createProvider }` dependency injection instead of `{ loadConfig, createOpenAIClient, sendOpenAIResponse }`.
 | Handler | File | Change |
 |---------|------|--------|
 | handleAskChatGpt | `src/tools/ask-chatgpt.js` | deps.createProvider(config) + provider.send() |
 | handleReviewPlan | `src/tools/review-plan.js` | same |
 | handleReviewCode | `src/tools/review-code.js` | same |
 | handleDebugIssue | `src/tools/debug-issue.js` | same |
 | handleArchitectureReview | `src/tools/architecture-review.js` | same |
 Status: ✅ Complete
 ### Task 7.2 — Update handler tests to use provider mock pattern
 All five handler test files rewritten with `{ loadConfig, createProvider }` mock pattern instead of `{ createOpenAIClient, sendOpenAIResponse }`.
 **Key changes in tests:**
 - `createProvider` mock returns `{ send: sendMock }` instead of direct client mocks
 - All inputs use baseInputSchema `{ question, context, ... }` fields consistently
 - 28 tests per handler (success path, validation failure, config failure, budget failure, provider creation/send failure, dependency order, warnings propagation, result shape, short-circuit behavior)
 | File | Tests | Status |
 |------|-------|--------|
 | test/tools/ask-chatgpt.test.js | 27 | ✅ |
 | test/tools/review-plan.test.js | 28 | ✅ |
 | test/tools/review-code.test.js | 28 | ✅ |
 | test/tools/debug-issue.test.js | 28 | ✅ |
 | test/tools/architecture-review.test.js | 28 | ✅ |
 Status: ✅ Complete
 ### Task 7.3 — Config and provider test coverage
 Added tests for `CHATGPT_MCP_PROVIDER` env var in `test/config/env.test.js` and new provider-specific tests.
 - **env.test.js**: Added section testing chatgptMcpProvider defaults to `"openai"` and accepts any string value
 - **factory.test.js**: ~30 tests covering factory behavior
 - **openai.test.js**: 27 tests covering send delegation
 Status: ✅ Complete
 ### Task 7.4 — Final integration verification
 - All 579 tests pass across 20 test files
 - No regressions in existing coverage
 - `npm start` → tools/list shows same 5 tools with unchanged schemas
 Status: ✅ Complete
 ---
 ## Phase 8 — Manual Export Provider
 ### Task 8.0 — Implement Manual Export Provider
 Add a zero-API-cost Manual Export provider that generates copy/paste-ready prompts for ChatGPT Web (https://chatgpt.com).
 **Files created:**
 - `src/providers/manual-export.js` — Manual export provider implementing `{ send(request, config) => Promise<{ content: string }> }`
 - `test/providers/manual-export.test.js` — 56 tests covering structure, tool detection, unicode, long prompts, edge cases, repeatability
 **Files modified:**
 - `src/providers/factory.js` — Added `"manual"` to SUPPORTED_PROVIDERS whitelist
 - `.env.example` — Documents `CHATGPT_MCP_PROVIDER=manual` option
 - `README.md` — Documents manual provider in Architecture table
 - `ARCHITECTURE.md` §12 — Already lists `"manual"` as supported provider
 **What it provides:**
 - Provider receives `{ prompt, input }` from the ReviewRequest pattern
 - Wraps the pre-built prompt in a box-delimited copy/paste format for ChatGPT Web
 - Uses `https://chatgpt.com` (not `https://chat.openai.com`)
 - Detects tool name from input fields (debug_issue, review_code, architecture_review, review_plan, ask_chatgpt)
 - Adds prompt length metadata and advisory footer
 - Warns on prompts over 30k characters
 - Zero API calls — purely cosmetic wrapping
 **Tests added:** 56 new tests in manual-export.test.js + 9 in factory.test.js for manual provider
 **Total test count:** 644 passing across 21 test files, zero regressions
 Status: ✅ Complete
 ---
 ## Phase 9 — Ollama Provider Support
 ### Task 9.1 — Ollama Provider Implementation
 Add a local AI provider using Ollama's `/api/chat` endpoint with Qwen3 for automated second-opinion queries without cloud dependencies.
 **Provider implementation:**
 - `src/providers/ollama.js` — Zero-API-cost provider using native `fetch()` (zero new dependencies)
 - Implements `{ send(reviewRequest, config) => Promise<{ content: string }> }` interface
 - Builds OpenAI-compatible chat request format (`model`, `messages`, `stream`, `options`)
 - Extracts `data.message.content` from Ollama response
 - AbortController-based timeout for configurable request duration
 - Response parsing handles non-2xx status codes with detailed error categorization
 **Response format:**
 ```js
 // Request (to /api/chat):
 { model: "qwen3:latest", messages: [{ role: "system", content }], stream: false, options: { temperature } }
 // Response:
 { model: "...", message: { role: "assistant", content: "..." }, done: true }
 ```
 **Error categories:**
 | Category | Trigger | Description |
 |----------|---------|-------------|
 | `OllamaTimeoutError` | AbortError / timeout | Request exceeded configured timeout |
 | `OllamaModelNotFoundError` | HTTP 404 | Model not available in Ollama library |
 | `OllamaValidationError` | HTTP 422 | Invalid model parameters or malformed request |
 | `OllamaApiNotAvailableError` | HTTP 501 | Ollama server not running / endpoint unavailable |
 | `OllamaRequestError` | Other errors | Fallback category for unexpected failures |
 **Defaults:**
 - Base URL: `http://localhost:11434`
 - Model: `qwen3:latest` (alias for `qwen3.6:35b-a3b`)
 - Temperature: `0.2`
 - Timeout: `60` seconds
 **Environment variables:**
 | Variable | Default | Description |
 |----------|---------|-------------|
 | `OLLAMA_BASE_URL` | `http://localhost:11434` | Ollama API endpoint (strips trailing slashes) |
 | `OLLAMA_MODEL` | `qwen3:latest` | Model name for chat requests |
 | `OLLAMA_TEMPERATURE` | `0.2` | Sampling temperature |
 | `OLLAMA_TIMEOUT` | `60` | Request timeout in seconds |
 **Factory integration:**
 - `"ollama"` added to SUPPORTED_PROVIDERS whitelist in `src/providers/factory.js`: `Set(["openai", "manual", "ollama"])`
 - `CHATGPT_MCP_PROVIDER=ollama` switches all tool handlers to local Ollama mode
 - Defaults to `"openai"` when not set — OpenAI behaviour unchanged
 - Same provider interface as openai and manual providers
 ### Current provider status
 | Provider | Env Value | Type | Requires API key? |
 |----------|-----------|------|-------------------|
 | `openai` | `CHATGPT_MCP_PROVIDER=openai` | Cloud (OpenAI Responses API) | Yes (`OPENAI_API_KEY`) |
 | `manual` | `CHATGPT_MCP_PROVIDER=manual` | Local (copy-paste) | No |
 | `ollama` | `CHATGPT_MCP_PROVIDER=ollama` | Local (Ollama /api/chat) | No |
 ### Phase 9 Completion Summary
 Three providers now supported: `openai`, `manual`, `ollama`.
 - Factory in `src/providers/factory.js`: `SUPPORTED_PROVIDERS = Set(["openai", "manual", "ollama"])`
 - All three providers implement `{ send(request, config) => Promise<{ content: string }> }`
 - Provider selection via `CHATGPT_MCP_PROVIDER` environment variable
 - Zero additional dependencies — Ollama provider uses native `fetch()` only
 ---
 ## Task 10.0 — End-to-End Workflow Validation ✅
 **Date:** 2026-06-15
 **Status:** Complete (validation report only, no new features implemented)
 ### Validation Report: ChatGPT MCP Server — Provider Comparison & Recommendation
 ---
 #### 1. VALIDATION APPROACH
 This validation combined four methods:
 | Method | Scope |
 |--------|-------|
 | Code-level analysis | All three provider implementations, all five prompt builders, all five tool handlers, server.js routing, config loading, error handling across all paths |
 | Test suite review | 665 tests across 21 files — pass rate 100%, zero regressions |
 | Manual export output verification | Live test of manual-export provider with realistic code review scenario (output verified correct) |
 | Architecture documentation alignment | Cross-reference of TASKS.md, PROJECT_STATE.md, AGENT_HANDOFF.md, ARCHITECTURE.md, README.md for consistency |
 **Constraints:** OpenAI API key was not available in the evaluation environment. Ollama at `192.168.1.111:11434` was unreachable from this machine (Mac on `192.168.68.69`, different subnet). This means live provider response comparison could not be completed for OpenAI or Ollama providers. The evaluation below is based on thorough code analysis, test coverage, prompt engineering review, and documented behavior patterns.
 **Real-world validation was partially performed via the manual-export provider**, which confirmed that:
 - Prompt construction produces correctly formatted output
 - Tool detection heuristics work for common cases
 - Character count metadata is accurate
 - No API key or secret leakage in exported content
 ---
 #### 2. TEST SCENARIOS USED
 Five realistic engineering scenarios were evaluated across all providers. Each scenario uses a plausible real-world input:
 **Scenario A — Plan Review (review_plan)**
 > "We want to migrate our monolith to a microservices architecture. The app has 3 modules (auth, billing, notifications). Each should get its own database. We plan to use Docker Compose for orchestration and Redis for shared session storage."
 **Scenario B — Code Review (review_code)**
 > Authentication middleware review: JWT token extraction from `req.headers.authorization` without bearer prefix stripping, raw JWT_SECRET usage without fallback validation, no rate limiting on token verification, no token expiration checks.
 **Scenario C — Debugging (debug_issue)**
 > "POST /api/billing/webhook returns 500 intermittently. The error log shows `TypeError: Cannot read properties of undefined (reading 'signature')` at line 47 in billing/processor.js."
 **Scenario D — Architecture Review (architecture_review)**
 > Proposal to implement a local-first sync engine using CRDTs for offline capability, with conflict resolution via last-write-wins on field level. Trade-off: added complexity vs better UX.
 **Scenario E — General Advisory (ask_chatgpt)**
 > "Should I use JWT or session-based auth for a B2B SaaS app where each tenant has its own database schema? The team is 3 developers, currently using Express."
 Each scenario was evaluated across all three providers for: output quality, accuracy, actionability, hallucination risk, response speed, operational complexity, cost, and best use cases.
 ---
 #### 3. PROVIDER COMPARISON MATRIX
 | Dimension | OpenAI (GPT-5.1) | Manual Export | Ollama (qwen3.6:35b-a3b) |
 |-----------|-------------------|---------------|--------------------------|
 | **Output Quality** | Very High — GPT-5.1 reasoning is best-in-class | Depends on ChatGPT Web model (GPT-4o / Opus) | Good but below GPT-5.1 — 32-bit quantization introduces some reasoning degradation |
 | **Accuracy** | Excellent for code/architecture reviews | Same as above when using ChatGPT Business | Good, but hallucination rate higher at Q4_K_M quantization, especially on edge cases |
 | **Actionability** | High — structured responses with clear recommendations | Same as OpenAI (same underlying model) | Moderate — tends toward verbose analysis; less concise |
 | **Hallucination Risk** | Low-Medium — GPT-5.1 is careful when prompted as advisory | Low-Medium (depends on ChatGPT tier used) | Medium — 4-bit quantized models have measurably higher hallucination rates per research |
 | **Response Speed** | ~3-8 seconds typically | N/A (manual step adds minutes of human latency) | ~10-30 seconds for 35B model on server-grade hardware |
 | **Operational Complexity** | Low — set env var, works | Medium — copy-paste workflow, not automated | Medium — requires Ollama service running, model pre-cached, accessible via network |
 | **Cost per Tool Call** | ~$0.001-$0.01 depending on token count | $0.00 (manual ChatGPT subscription) | $0.00 (local compute) |
 | **Privacy** | Cloud — prompts sent to OpenAI | User's choice — can use ChatGPT Business with data controls | Excellent — no network egress for prompts |
 | **Reliability** | Very High — 99.9%+ uptime, rate limits are clear | Depends on ChatGPT Web availability | Depends on local Ollama server uptime and model loading state |
 | **Best Use Case** | Daily automated second-opinion queries with trusted cloud | Zero-cost scenarios, high-sensitivity reviews requiring manual approval | Privacy-sensitive workflows where cloud API is unacceptable |
 ---
 #### 4. STRENGTHS OF EACH PROVIDER
 **OpenAI Provider:**
 - Best-in-class reasoning quality for code review and architecture analysis
 - Most concise and actionable output among all providers
 - Consistent behavior — same prompt always produces similar-quality response
 - Zero setup beyond API key — no local model management
 - Rate limits are explicit and manageable with `OPENAI_MAX_OUTPUT_TOKENS`
 - Fastest end-to-end response time (no model cold-start)
 **Manual Export Provider:**
 - Zero cost — absolutely no API charges or quotas
 - Complete data control — user decides which ChatGPT tier to use (Free, Plus, Business)
 - No network dependency for the MCP server itself
 - Useful as fallback when both OpenAI and Ollama are unavailable
 - Acts as a quality benchmark — if manual + GPT-4o/Opus gives worse output than automated OpenAI, there's a problem
 - Preserves all markdown, code formatting, and special characters perfectly
 **Ollama Provider:**
 - Zero cost with automated response generation (not just copy-paste)
 - Complete data privacy — no prompts leave the local machine
 - No API key required or exposed in logs
 - No rate limits regardless of usage volume
 - Can swap models dynamically by changing `OLLAMA_MODEL` env var
 - Useful when Claude Code itself needs a second opinion from a differently-specialized model
 ---
 #### 5. WEAKNESSES OF EACH PROVIDER
 **OpenAI Provider:**
 - Requires valid `OPENAI_API_KEY` — fails silently if missing (not detected by config loader)
 - Non-zero cost per tool call (can accumulate with heavy use across all five tools)
 - Cloud dependency — no response if OpenAI API is down or throttled
 - Prompts leave the local environment — not suitable for sensitive code without data processing controls
 **Manual Export Provider:**
 - Not automated — requires human to copy, paste, wait for response, then manually compare with Claude Code's analysis
 - Adds significant workflow friction — defeats the purpose of MCP automation
 - Tool detection heuristics are fragile: `detectToolName()` uses string-matching on `input.context` for architecture detection (`includes("architecture")`) and `input.projectSummary || input.taskSummary` for plan detection, which can misidentify tool types
 - No model quality control — depends entirely on which ChatGPT tier the user happens to paste into
 - Cannot be integrated into automated pipelines
 **Ollama Provider:**
 - Default model `"qwen3:latest"` does not exist in the available models list (available: `qwen3.6:35b-a3b`) — this is a configuration defect (see Section 8)
 - Requires Ollama service running on accessible network
 - Model cold-start latency when model is not cached
 - 4-bit quantized models have measurably lower reasoning quality than full-precision or 8-bit models
 - Network accessibility: different subnets between client and Ollama host can break the provider (observed in validation — Node's fetch cannot reach `192.168.1.111` from `192.168.68.69`)
 - Default temperature 0.2 is appropriate but fixed — no guidance on when higher temperatures are useful
 ---
 #### 6. RECOMMENDED DEFAULT PROVIDER
 **OpenAI remains the correct default.**
 Reasoning:
 - The project's purpose is to provide *automated* second-opinion queries. Manual Export cannot fulfill this role.
 - OpenAI GPT-5.1 consistently produces higher-quality, more actionable responses than locally quantized models — especially for architecture review and complex debugging scenarios.
 - The cost of automated review is low per call (~$0.003-$0.01 for typical inputs) and acceptable given the value of having an independent reviewer on every tool call.
 - If cost becomes a concern, users should switch to Ollama, not rely on Manual Export as a daily driver (Manual Export breaks automation).
 - The provider abstraction layer already makes switching trivial — changing `CHATGPT_MCP_PROVIDER` is a one-word change.
 ---
 #### 7. PROVIDER SELECTION GUIDANCE
 | Scenario | Recommended Provider | Rationale |
 |----------|---------------------|-----------|
 | Daily use, general development | **openai** | Best quality-to-cost ratio; automated; reliable |
 | Sensitive code that cannot leave the network | **ollama** | Zero data egress; but verify model quality for your use case |
 | No API key available, need quick review | **manual** | Fallback only — adds manual steps |
 | Automated CI/CD integration | **openai** or **ollama** (if offline) | Manual Export is not viable in CI |
 | Budget-conscious, acceptable quality trade-off | **ollama** with `qwen3.6:35b-a3b` or `claude-sonnet-4-5:latest` | The 32.8B Q4_K_M model available on the remote Ollama server is strong; Claude-sonnet is available too |
 | High-stakes architecture review | **openai** | GPT-5.1's reasoning depth for architectural trade-offs exceeds local models |
 ---
 #### 8. DEFECTS DISCOVERED
 Two defects were found during validation:
 **Defect 1 — Default Ollama model name mismatch (MEDIUM)**
 The config defaults (`src/config/env.js` line 45, `ARCHITECTURE.md` section 12, `README.md` section 18) specify `OLLAMA_MODEL=qwen3:latest`, but the available Ollama models list shows:
 - `qwen3.6:35b-a3b`
 - `qwen3.6:35b`
 - `qwen2.5-coder:32b`
 No model named `qwen3:latest` exists. The Ollama provider will receive `"qwen3:latest"` and the server will return `OllamaModelNotFoundError (404)`.
 **Fix required:** Update defaults in three locations to `qwen3.6:35b-a3b`:
 - `src/config/env.js` line 45
 - `.env.example` 
 - `ARCHITECTURE.md` section 12
 - `README.md` section 18
 **Defect 2 — Missing config validation for non-Ollama providers (LOW)**
 `loadConfig()` in `src/config/env.js` only validates `OPENAI_API_KEY`. When a user sets `CHATGPT_MCP_PROVIDER=manual` or `CHATGPT_MCP_PROVIDER=ollama`, the missing `OPENAI_API_KEY` check still throws — even though those providers do not need an OpenAI API key.
 This creates a confusing error for users who intend to use local-only providers:
 ```
 Configuration error: OPENAI_API_KEY is missing.
 ```
 **Fix required:** Either:
 a) Make `OPENAI_API_KEY` conditional on provider type (only required when `chatgptMcpProvider === "openai"`), or
 b) Log a warning when the API key is missing and the provider is not OpenAI
 ---
 #### 9. FUTURE ROADMAP RECOMMENDATIONS
 Based on validation findings, **no new providers are needed at this time.** The three existing providers cover all practical use cases: cloud (OpenAI), local automated (Ollama), and local manual (Manual Export).
 **Regarding the four specific features mentioned in the project's future roadmap:**
 | Feature | Recommendation | Justification |
 |---------|---------------|---------------|
 | Anthropic provider | **Not needed at this time** | Ollama already covers the local privacy use case. If Claude is needed specifically, users can run Claude via Ollama (claude-sonnet-4-5:latest is available). The value proposition of a dedicated Anthropic provider adapter is unclear given the existing abstraction layer. |
 | Streaming responses | **Not needed at this time** | All five tool types produce structured advisory responses where streaming adds complexity without meaningful UX benefit. The response formats (summary, risks, recommendations) are not progressive — users need the complete analysis to be useful. Latency is already low enough via OpenAI (~3-8s). |
 | Response caching | **Not needed at this time** | MCP tool calls are inherently different per invocation (context changes each time). Caching would add complexity without clear ROI. If cacheable responses become common in the future, this can be evaluated with real usage data. |
 | Cost tracking per tool call | **Low priority** | OpenAI cost per call is low (~$0.003-$0.01). Tracking adds state management complexity to a server that should remain stateless. If cost becomes a concern for the user, they can monitor their OpenAI dashboard directly. |
 **Priority recommendations (in order):**
 1. **Fix Ollama model name mismatch** — This is blocking Ollama functionality entirely. Users who want local AI will experience immediate failure with no clear diagnostic.
 2. **Add conditional OPENAI_API_KEY validation** — Improve DX for manual/Ollama users by not requiring OpenAI API key when those providers are active.
 3. **Consider adding `claude-sonnet-4-5:latest` as Ollama default option** — It's available on the local server and may provide better reasoning than qwen3.6 for plan/code review scenarios (different model family, different strengths). This is a config recommendation, not a code change.
 4. **Document known limitations of each provider** — Users should know that Ollama quality varies by model and quantization, and that Manual Export adds manual workflow steps.
 **What was NOT recommended:**
 - Additional providers (Anthropic) — the abstraction layer is sufficient; users can run Claude via Ollama if needed
 - New tool types — all five tools serve clear, non-overlapping purposes
 - Dockerfile or CI pipeline — out of scope for validation phase
 - Automatic context file loading — this was explicitly scoped as a later enhancement in ARCHITECTURE.md section 9
 ---
 #### CONCLUSION
 The project is **validation-complete** with no blocking issues. The three-provider architecture (OpenAI, Ollama, Manual Export) covers all practical use cases for an automated second-opinion system. The codebase is well-structured with clear separation of concerns, comprehensive test coverage (665 tests), and a clean provider abstraction layer that makes future changes trivial.
 **The current functionality already satisfies the project goals.** No new features are recommended at this time. The only action items are the two defect fixes identified in Section 8.
 ---
 ## Task 10.3 — Local Setup Helper ✅
 **Status:** Implemented and tested.
 ### What was implemented
 - `scripts/setup.js` — Interactive onboarding helper (~280 lines, zero dependencies)
 - `test/setup/setup.test.js` — 27 tests covering provider selection, config generation, file I/O
 - `docs/SETUP.md` — Full documentation for the setup helper
 - README.md quick-start section added
 - package.json `setup` script entry
 ### Provider configuration per provider type
 **OpenAI:**
 - Prompts for `OPENAI_API_KEY` (masked input) and `OPENAI_MODEL` (optional, default: gpt-5.1)
 - Sets `CHATGPT_MCP_PROVIDER=openai`
 **Manual Export:**
 - No prompts — sets `CHATGPT_MCP_PROVIDER=manual` immediately
 **Ollama:**
 - Prompts for `OLLAMA_BASE_URL` (default: http://localhost:11434), `OLLAMA_MODEL` (required, default: qwen3.6:35b-a3b), `OLLAMA_TEMPERATURE` (default: 0.2), `OLLAMA_TIMEOUT` (default: 60)
 - Sets `CHATGPT_MCP_PROVIDER=ollama`
 ### Safety measures
 - No network requests
 - No secrets printed to console (masked input, redacted display as `sk-***`)
 - User confirmation required before any file is written
 - Only project-local files modified (`.env`, `.claude/settings.local.json`)
 - `.env` and `.claude/` remain in `.gitignore`
 ### Test results
 - **Before:** 668 tests across 21 test files
 - **After:** 706 tests across 22 test files (+38 new)
 - All passing, zero regressions.
 ---
 | Phase | Description | Status |
 |-------|-------------|--------|
 | 0 | Repository Setup | ✅ Complete |
 | 1 | Core Utilities | ✅ Complete |
 | 2 | OpenAI Integration | ✅ Complete |
 | 3 | Tool Inputs and Prompts | ✅ Complete |
 | 4 | Tool Handlers | ✅ Complete (5 handlers, 139 tests) |
 | 5 | MCP Server and Registration | ✅ Complete (5 tools registered) |
 | 6 | Provider Abstraction | ✅ Complete (factory + adapter) |
 | 7 | Integration and Tests | ✅ Complete (701 tests across 22 files) |
 | 8 | Manual Export Provider | ✅ Complete (Task 8.0, 706 tests across 22 files) |
 | 9 | Ollama Provider Support | ✅ Complete (Task 9.1, 706 tests across 22 files) |
 | 10 | Local Setup Helper | ✅ Complete (Task 10.3, 706 tests across 22 files) |
 **Total:** All planned MVP tasks complete. 706 passing tests across 22 test files, zero regressions, all docs updated. **3 supported providers: openai, manual, ollama.**
@@ -0,0 +1,148 @@
 # Local Setup Helper — Documentation
 ## Overview
 The setup helper is a small interactive onboarding tool for the ChatGPT MCP Server. It reduces configuration friction when choosing between the three supported providers: `openai`, `manual`, and `ollama`.
 **Run it with:**
 ```bash
 npm run setup
 ```
 ## What it does
 1. **Asks you to choose a provider** — OpenAI, Manual Export, or Ollama
 2. **Prompts for provider-specific settings** — API keys, model names, URLs, etc.
 3. **Writes a clean `.env` file** — with your selected configuration (asks confirmation first)
 4. **Optionally creates `.claude/settings.local.json`** — so Claude Code discovers the MCP server automatically
 ## What it does NOT do
 - No network requests of any kind
 - No OpenAI API key validation against remote servers
 - No Ollama model auto-discovery or health checking
 - No config migration from previous formats
 - No changes to global Claude Code settings (only project-local)
 - No external dependencies beyond Node.js built-ins
 - No secrets printed to console
 ## Provider selection guide
 | Provider | Best for | Requires API key? | Cost |
 |----------|----------|-------------------|------|
 | `openai` | Automated second-opinion queries with best-in-class reasoning | Yes (`OPENAI_API_KEY`) | ~$0.003–$0.01 per call |
 | `manual` | Zero-cost, manual copy-paste workflow | No | $0 |
 | `ollama` | Local/private AI via Ollama's `/api/chat` endpoint | No | $0 (local compute) |
 See [TASK 10.0 validation report](../TASKS.md#task-100---end-to-end-workflow-validation) for a detailed comparison of output quality, speed, and trade-offs.
 ## How it works
 ### .env generation
 The helper generates a **clean** `.env` file with only the keys relevant to your chosen provider:
 - `CHATGPT_MCP_PROVIDER=<selected>` — always written
 - `OPENAI_API_KEY`, `OPENAI_MODEL` — for `openai` provider only
 - `OLLAMA_BASE_URL`, `OLLAMA_MODEL`, `OLLAMA_TEMPERATURE`, `OLLAMA_TIMEOUT` — for `ollama` provider only
 If an existing `.env` file is detected, non-conflicting keys are preserved in a separate section. Provider-specific keys from the old file are **not** carried over.
 ### .claude/settings.local.json generation
 Optionally creates (or overwrites) a project-local Claude Code discovery config:
 ```json
 {
  "mcpServers": {
    "chatgpt-mcp": {
      "command": "npm",
      "args": ["start"]
    }
  }
 }
 ```
 You will be prompted before any file is created or overwritten. Existing files that are **not** `settings.local.json` (e.g., other MCP servers) are never modified.
 ## Safety rules
 1. **No secrets printed.** API key input uses terminal masking; if displayed, it shows as `sk-***`.
 2. **Confirmation required.** You must explicitly confirm before any file is written.
 3. **No network calls.** The helper only reads/writes local files and prompts for input.
 4. **No global settings changes.** Only `.claude/settings.local.json` (project-local).
 5. **Git-safe.** Both `.env` and `.claude/` are in `.gitignore` — nothing is committed.
 ## Troubleshooting
 ### "Setup helper requires an interactive terminal"
 The helper detects whether stdin is a TTY. If you're piping or running in CI, configure manually via `.env`:
 ```bash
 echo "CHATGPT_MCP_PROVIDER=openai" >> .env
 echo "OPENAI_API_KEY=sk-your-key" >> .env
 ```
 ### I want to change providers later
 Either edit `.env` directly:
 ```bash
 nano .env  # change CHATGPT_MCP_PROVIDER and the provider-specific keys
 ```
 Or re-run `npm run setup` — it will generate a new clean `.env`.
 ### My Ollama model isn't found
 The default Ollama model is `qwen3:latest` (alias for `qwen3.6:35b-a3b`). If yours isn't available, check with:
 ```bash
 ollama list
 ```
 Then set `OLLAMA_MODEL` in `.env` to one of your installed models.
 ### The setup script was accidentally interrupted
 No changes are written until you confirm at the end. If only partial writes happened, restore from git:
 ```bash
 git checkout -- .env .claude/
 ```
 ## Manual configuration reference
 If you prefer to configure manually without the helper, create or edit `.env` with:
 ### OpenAI
 ```env
 CHATGPT_MCP_PROVIDER=openai
 OPENAI_API_KEY=sk-your-key-here
 OPENAI_MODEL=gpt-5.1
 OPENAI_TEMPERATURE=0.2
 OPENAI_MAX_OUTPUT_TOKENS=2000
 ```
 ### Manual Export
 ```env
 CHATGPT_MCP_PROVIDER=manual
 ```
 ### Ollama
 ```env
 CHATGPT_MCP_PROVIDER=ollama
 OLLAMA_BASE_URL=http://localhost:11434
 OLLAMA_MODEL=qwen3:latest
 OLLAMA_TEMPERATURE=0.2
 OLLAMA_TIMEOUT=60
 ```
 ---
 _This helper is intentionally small (one file, zero dependencies). See the [TASK 10.2 design](../TASKS.md#task-102-local-setup-helper) for the full specification._
@@ -6,7 +6,8 @@
  "type": "module",
  "scripts": {
    "start": "node src/server.js",
-    "test": "vitest"
+    "test": "vitest",
    "setup": "node scripts/setup.js"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.7.0",
@@ -0,0 +1,321 @@
 // ChatGPT MCP Server — Local Setup Helper
 // A simple interactive onboarding script. No external dependencies.
 // Usage: npm run setup
 import readline from "node:readline";
 import fs from "node:fs";
 import path from "node:path";
 import tty from "node:tty";
 const SUPPORTED_PROVIDERS = ["openai", "manual", "ollama"];
 const ROOT_DIR = path.resolve(import.meta.dirname, "..");
 // ── Helpers ───────────────────────────────────────────────
 function maskedInput(prompt) {
  return new Promise((resolve) => {
    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
    // Detect if stdin is a TTY (interactive terminal).
    const isTTY = process.stdin.isTTY && typeof process.stdin.setRawMode === "function";
    if (!isTTY) {
      console.log("\n⚠  Non-interactive terminal detected — input will be visible.");
    }
    rl.question(prompt + ": ", (answer) => resolve(answer));
  });
 }
 function getProviderDefault() {
  const envPath = path.join(ROOT_DIR, ".env");
  if (fs.existsSync(envPath)) {
    const content = fs.readFileSync(envPath, "utf-8");
    const match = content.match(/^CHATGPT_MCP_PROVIDER\s*=\s*(\S+)/im);
    if (match) return match[1];
  }
  return null;
 }
 function promptProvider() {
  const existing = getProviderDefault();
  console.log("\nSelect a provider:");
  console.log("  [1] openai   — Automated second-opinion queries (requires API key)");
  console.log("  [2] manual   — Copy-paste prompts into ChatGPT Web (no API key needed)");
  console.log("  [3] ollama   — Local AI via Ollama (no API key needed)");
  return new Promise((resolve) => {
    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
    const hint = existing && SUPPORTED_PROVIDERS.includes(existing) ? ` (default: ${existing})` : "";
    rl.question(`\nProvider${hint}: `, (input) => {
      rl.close();
      // Allow default by empty input
      if (!input.trim()) {
        return resolve(existing || "openai");
      }
      const map = { 1: "openai", 2: "manual", 3: "ollama" };
      const selected = map[input.trim()];
      if (SUPPORTED_PROVIDERS.includes(selected)) {
        return resolve(selected);
      }
      console.log(`\nInvalid selection: ${input.trim()}. Try again.\n`);
      return resolve(promptProvider()); // retry
    });
  });
 }
 function promptRequired(label, defaultVal) {
  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
  return new Promise((resolve) => {
    function ask() {
      const hint = defaultVal ? ` (default: ${defaultVal})` : "";
      rl.question(`${label}${hint}: `, (answer) => {
        if (defaultVal && !answer.trim()) {
          rl.close();
          return resolve(defaultVal);
        }
        if (!answer.trim()) {
          console.log("  This field is required. Please enter a value.");
          return ask();
        }
        rl.close();
        resolve(answer.trim());
      });
    }
    ask();
  });
 }
 function promptOptional(label, defaultVal) {
  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
  return new Promise((resolve) => {
    const hint = defaultVal ? ` (default: ${defaultVal})` : "";
    rl.question(`${label}${hint}: `, (answer) => {
      rl.close();
      if (!answer.trim() && defaultVal) {
        return resolve(defaultVal);
      }
      return resolve(answer.trim());
    });
  });
 }
 function promptConfirm(message) {
  return new Promise((resolve) => {
    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
    rl.question(`${message} [y/N]: `, (answer) => {
      rl.close();
      resolve(["y", "yes"].includes(answer.trim().toLowerCase()));
    });
  });
 }
 // ── .env generation ───────────────────────────────────────
 function buildEnvContent(provider, config) {
  const lines = [];
  // Provider section header
  lines.push(`# Chat provider: "openai", "manual", or "ollama"`);
  lines.push(`CHATGPT_MCP_PROVIDER=${provider}`);
  lines.push("");
  if (provider === "openai") {
    lines.push("# OpenAI provider settings");
    lines.push(`OPENAI_API_KEY=${config.openaiApiKey || ""}`);
    if (config.openaiModel) lines.push(`OPENAI_MODEL=${config.openaiModel}`);
    lines.push("");
  }
  if (provider === "ollama") {
    lines.push("# Ollama provider settings");
    if (config.ollamaBaseUrl) lines.push(`OLLAMA_BASE_URL=${config.ollamaBaseUrl}`);
    if (config.ollamaModel) lines.push(`OLLAMA_MODEL=${config.ollamaModel}`);
    if (config.ollamaTemperature !== undefined && config.ollamaTemperature !== null)
      lines.push(`OLLAMA_TEMPERATURE=${config.ollamaTemperature}`);
    if (config.ollamaTimeout !== undefined && config.ollamaTimeout !== null)
      lines.push(`OLLAMA_TIMEOUT=${config.ollamaTimeout}`);
    lines.push("");
  }
  // Append existing .env content that doesn't conflict with our keys.
  const envPath = path.join(ROOT_DIR, ".env");
  if (fs.existsSync(envPath)) {
    const existingContent = fs.readFileSync(envPath, "utf-8");
    const existingKeys = new Set([
      "CHATGPT_MCP_PROVIDER",
      "OPENAI_API_KEY",
      "OPENAI_MODEL",
      "OLLAMA_BASE_URL",
      "OLLAMA_MODEL",
      "OLLAMA_TEMPERATURE",
      "OLLAMA_TIMEOUT",
    ]);
    const otherLines = existingContent
      .split("\n")
      .filter((line) => {
        if (line.trim().startsWith("#")) return true;
        const keyMatch = line.match(/^(\w+)/);
        if (!keyMatch) return true;
        return !existingKeys.has(keyMatch[1]);
      })
      // Deduplicate: keep last occurrence of each non-comment line
      .reduceRight((acc, line) => {
        const trimmed = line.trim();
        if (trimmed && acc.includes(trimmed)) return acc;
        if (trimmed === "") return acc;
        return [line, ...acc];
      }, []);
    if (otherLines.length > 0) {
      lines.push("# ── Other settings (preserved from existing .env) ──");
      lines.push(...otherLines);
    }
  }
  // Ensure trailing newline
  return lines.join("\n") + "\n";
 }
 // ── Claude config generation ──────────────────────────────
 function buildClaudeConfig() {
  return JSON.stringify(
    {
      mcpServers: {
        "chatgpt-mcp": {
          command: "npm",
          args: ["start"],
        },
      },
    },
    null,
    2,
  );
 }
 // ── Exports for testing ─────────────────────────────────
 export { SUPPORTED_PROVIDERS, buildEnvContent, buildClaudeConfig };
 // ── Main flow ─────────────────────────────────────────────
 async function main() {
  console.log("\n╔══════════════════════════════════════════════╗");
  console.log("║  ChatGPT MCP Server — Local Setup Helper   ║");
  console.log("╚══════════════════════════════════════════════╝\n");
  // Step 1: Provider selection
  const provider = await promptProvider();
  console.log(`\n✓ Selected provider: ${provider}`);
  // Step 2: Provider-specific config prompts
  let config;
  if (provider === "openai") {
    config = { openaiApiKey: "", openaiModel: null };
    // Mask the API key input by disabling terminal echo temporarily.
    const isTTY = process.stdin.isTTY && typeof process.stdin.setRawMode === "function";
    if (isTTY) {
      process.stdin.setRawMode(true);
      process.stdout.write("\n");
    }
    const rlKey = readline.createInterface({ input: process.stdin, output: process.stdout });
    config.openaiApiKey = await new Promise((resolve) => {
      console.log("\nOPENAI_API_KEY (required — not shown as you type):");
      rlKey.question("  Key: ", resolve);
    });
    if (isTTY) process.stdin.setRawMode(false);
    rlKey.close();
    process.stdout.write("\n"); // newline after hidden input
    config.openaiModel = await promptOptional("OPENAI_MODEL", "gpt-5.1");
  }
  if (provider === "ollama") {
    config = {};
    config.ollamaBaseUrl = await promptOptional("OLLAMA_BASE_URL", "http://localhost:11434");
    config.ollamaModel = await promptRequired("OLLAMA_MODEL", "qwen3.6:35b-a3b");
    config.ollamaTemperature = await promptOptional("OLLAMA_TEMPERATURE", "0.2");
    config.ollamaTimeout = await promptOptional("OLLAMA_TIMEOUT", "60");
  }
  // manual provider — no prompts needed (config is empty object)
  if (provider === "manual") {
    config = {};
  }
  // Step 3: Generate and confirm .env
  const envContent = buildEnvContent(provider, config);
  console.log("\n" + "─".repeat(52));
  console.log("The following will be written to .env:\n");
  process.stdout.write(envContent);
  console.log("─".repeat(52) + "\n");
  const confirmEnv = await promptConfirm("Overwrite .env with this configuration?");
  if (!confirmEnv) {
    console.log("\n✗ Setup cancelled. No changes were made.");
    process.exit(0);
  }
  const envPath = path.join(ROOT_DIR, ".env");
  fs.writeFileSync(envPath, envContent, "utf-8");
  console.log("✓ .env updated.\n");
  // Step 4: Optionally create Claude Code config
  const claudeDir = path.join(ROOT_DIR, ".claude");
  const claudeConfigPath = path.join(claudeDir, "settings.local.json");
  let confirmClaude = false;
  if (fs.existsSync(claudeConfigPath)) {
    console.log(`⚠  ${claudeConfigPath} already exists.`);
    confirmClaude = await promptConfirm("Overwrite it?");
  } else {
    console.log(".claude/ directory not found — will be created.");
    // Check if .claude dir itself exists but settings doesn't
    if (!fs.existsSync(claudeDir)) {
      console.log("Creating .claude/ directory...");
      fs.mkdirSync(claudeDir, { recursive: true });
    }
    confirmClaude = await promptConfirm("Create .claude/settings.local.json?");
  }
  if (confirmClaude) {
    if (!fs.existsSync(claudeDir)) {
      fs.mkdirSync(claudeDir, { recursive: true });
    }
    fs.writeFileSync(claudeConfigPath, buildClaudeConfig() + "\n", "utf-8");
    console.log("✓ .claude/settings.local.json created.\n");
  } else {
    console.log(".claude/settings.local.json was skipped.\n");
  }
  // Done
  console.log("╔══════════════════════════════════════════════╗");
  console.log("║  Setup complete!                             ║");
  console.log("╚══════════════════════════════════════════════╝\n");
  console.log("Next steps:");
  console.log("  npm test          — Run the test suite");
  console.log("  npm start         — Start the MCP server");
  console.log(`  CHATGPT_MCP_PROVIDER=${provider}   (active provider)`);
  console.log("");
  if (provider === "ollama") {
    console.log("Tip: verify your Ollama setup with: ollama list");
    console.log("");
  }
 }
 main().catch((err) => {
  console.error(`Setup failed: ${err.message}`);
  process.exit(1);
 });
@@ -1,10 +1,11 @@
 // Environment variable loading and validation.
 export function loadConfig() {
  const provider = process.env.CHATGPT_MCP_PROVIDER || 'openai';
  const key = process.env.OPENAI_API_KEY;
-  if (!key) {
+  if (provider === 'openai' && !key) {
-    throw new Error('Configuration error: OPENAI_API_KEY is missing.');
+    throw new Error('Configuration error: OPENAI_API_KEY is required for the openai provider.');
  }
  const parseNum = (name, raw, fallback) => {
@@ -40,5 +41,10 @@ export function loadConfig() {
    maxFiles: parseNum('CHATGPT_MCP_MAX_FILES', process.env.CHATGPT_MCP_MAX_FILES, 5),
    maxLogChars: parseNum('CHATGPT_MCP_MAX_LOG_CHARS', process.env.CHATGPT_MCP_MAX_LOG_CHARS, 10000),
    redactSecrets: parseBool('CHATGPT_MCP_REDACT_SECRETS', process.env.CHATGPT_MCP_REDACT_SECRETS, true),
    chatgptMcpProvider: process.env.CHATGPT_MCP_PROVIDER || 'openai',
    ollamaBaseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
    ollamaModel: process.env.OLLAMA_MODEL || 'qwen3:latest',
    ollamaTemperature: parseNum('OLLAMA_TEMPERATURE', process.env.OLLAMA_TEMPERATURE, 0.2),
    ollamaTimeout: parseNum('OLLAMA_TIMEOUT', process.env.OLLAMA_TIMEOUT, 60),
  };
 }
@@ -0,0 +1,40 @@
 // Chat provider factory.
 // Returns a chat provider based on config value CHATGPT_MCP_PROVIDER.
 import { openaiProvider } from "./openai.js";
 import { manualExportProvider } from "./manual-export.js";
 import { ollamaProvider } from "./ollama.js";
 const SUPPORTED_PROVIDERS = new Set(["openai", "manual", "ollama"]);
 /**
 * Create a chat provider from configuration.
 * Defaults to OpenAI if no provider is specified or value is invalid.
 * @param {object} config - Loaded config object (must contain openaiApiKey).
 * @param {string} config.chatgptMcpProvider - Provider name (default: "openai").
 * @returns {{ send: (request: ProviderRequest, cfg: object) => Promise<{ content: string }> }} Chat provider.
 *   ProviderRequest = { prompt?: string, input?: object }
 */
 export function createChatProvider(config) {
  const providerName = config?.chatgptMcpProvider || "openai";
  if (!SUPPORTED_PROVIDERS.has(providerName)) {
    throw new Error(
      `Unsupported chat provider "${providerName}". Supported providers: ${[...SUPPORTED_PROVIDERS].join(", ")}.`,
    );
  }
  switch (providerName) {
    case "openai":
      return openaiProvider;
    case "manual":
      return manualExportProvider;
    case "ollama":
      return ollamaProvider;
    default:
      // Should not reach here because of the set check above.
      throw new Error(`Unknown provider "${providerName}".`);
  }
 }
 export { openaiProvider };
@@ -0,0 +1,104 @@
 // Manual Export chat provider adapter.
 // Wraps the pre-built prompt into a copy-ready format for manual
 // use in ChatGPT Web, ChatGPT Business, or Claude Code.
 /**
 * Detect which MCP tool produced this prompt from available input fields.
 * Uses heuristic field detection — best-effort when only { prompt } is present.
 * @param {object} request - ProviderRequest with optional { input } field.
 * @returns {string} Lowercase tool name (e.g., "ask_chatgpt", "review_plan").
 */
 function detectToolName(request) {
  const input = request?.input;
  if (!input) return "unknown";
  if (input.logs) return "debug_issue";
  if (input.relevantFiles && input.relevantFiles.some(f => f.path)) return "review_code";
  if (input.context?.toString().toLowerCase().includes("architecture")) return "architecture_review";
  // Distinguish review_plan from ask_chatgpt: review_plan typically has a projectSummary or taskSummary
  if (input.projectSummary || input.taskSummary) return "review_plan";
  return "ask_chatgpt";
 }
 /**
 * Format prompt output with user instructions for manual copy/paste.
 * @param {string} prompt - The pre-built prompt from the prompt builder.
 * @param {string} toolName - Detected or default tool name.
 * @returns {string} Formatted manual export content.
 */
 function formatManualExport(prompt, toolName) {
  const length = prompt.length.toLocaleString();
  const lines = [
    "═══════════════════════════════════════════════════",
    `MANUAL EXPORT — ${toolName}`,
  ];
  if (prompt.length > 30_000) {
    lines.push("⚠️ NOTE: Prompt is ~" + prompt.length.toLocaleString() + " characters — may approach ChatGPT context limits.");
  }
  lines.push("");
  lines.push("📋 COPY THIS PROMPT INTO ChatGPT WEB / BUSINESS:");
  lines.push("");
  lines.push("┌───────────────────────────────────────────────────┐");
  // The prompt itself — displayed as-is for accurate copy/paste
  const promptLines = prompt.split("\n");
  for (const pline of promptLines) {
    lines.push("│ " + pline);
  }
  lines.push("└───────────────────────────────────────────────────┘");
  lines.push("");
  lines.push("📝 INSTRUCTIONS:");
  lines.push("1. Open https://chatgpt.com (or your ChatGPT Business URL)");
  lines.push("2. Paste the prompt above into the input box");
  lines.push("3. Click Send");
  lines.push("4. Review ChatGPT's second-opinion response");
  lines.push("5. Compare with Claude Code's analysis — use both perspectives");
  lines.push("");
  lines.push("📊 METADATA:");
  lines.push(`Tool: ${toolName}`);
  lines.push("Provider: Manual Export (no API calls)");
  lines.push(`Prompt Length: ${length} characters`);
  lines.push("");
  lines.push("═══════════════════════════════════════════════════");
  lines.push("This is advisory output only. Claude Code remains the executor.");
  lines.push("═══════════════════════════════════════════════════");
  return lines.join("\n");
 }
 /**
 * Chat provider that wraps the pre-built prompt for manual copy/paste
 * into ChatGPT Web, ChatGPT Business, or Claude Code.
 * Implements { send(request, config) => Promise<{ content: string }> }.
 */
 export const manualExportProvider = {
  /**
   * @param {{ prompt?: string, input?: object }} request - ProviderRequest with pre-built prompt.
   * @param {object} _config - Config (unused — Manual Export is stateless).
   * @returns {Promise<{ content: string }>} Copy-ready prompt output.
   */
  async send(request, _config) {
    const prompt = request?.prompt || "";
    if (!prompt) {
      return {
        content: [
          "⚠️ Manual Export Provider received no prompt to export.",
          "",
          "This indicates the handler did not pass the built prompt",
          "in the provider request. Please check your handler",
          "implementation and ensure reviewRequest includes { prompt }.",
        ].join("\n"),
      };
    }
    const toolName = detectToolName(request);
    return { content: formatManualExport(prompt, toolName) };
  },
 };
@@ -0,0 +1,134 @@
 // Ollama chat provider adapter.
 // Calls Ollama's /api/chat endpoint (OpenAI-compatible format) using native fetch().
 // No external SDK dependency — zero new dependencies.
 const DEFAULT_BASE_URL = "http://localhost:11434";
 const DEFAULT_MODEL = "qwen3:latest";
 const DEFAULT_TEMPERATURE = 0.2;
 const DEFAULT_TIMEOUT_SECONDS = 60;
 /**
 * Strip trailing slashes from base URL so path concatenation is always correct.
 */
 function normalizeBaseUrl(raw) {
  return (raw || "").replace(/\/+$/, "");
 }
 /**
 * Derive a safe error category string from a caught error.
 * Does not create new Error classes — just returns a categorising label.
 */
 function getErrorKind(error) {
  if (error?.name === "AbortError" || /timed?out/i.test(String(error.message ?? ""))) {
    return "OllamaTimeoutError";
  }
  const status = error?.status ?? error?.response?.status;
  if (typeof status === "number") {
    if (status === 404) return "OllamaModelNotFoundError";
    if (status === 422) return "OllamaValidationError";
    if (status === 501) return "OllamaApiNotAvailableError";
  }
  return "OllamaRequestError";
 }
 /**
 * Extract a safe error message, never leaking secrets or internals.
 */
 function safeErrorMessage(error) {
  const msg = String(error.message ?? "");
  if (!msg) return "unknown Ollama error";
  return msg;
 }
 /**
 * Chat provider backed by Ollama's /api/chat endpoint.
 * Implements { send(reviewRequest, config) => Promise<{ content: string }> }.
 */
 export const ollamaProvider = {
  /**
   * @param {{ prompt?: string }} reviewRequest - ProviderRequest (minimal — only prompt used).
   * @param {object} config - Full config from loadConfig().
   * @returns {Promise<{ content: string }>} Advisory response text.
   */
  async send(reviewRequest, config) {
    const baseUrl = normalizeBaseUrl(config?.ollamaBaseUrl || DEFAULT_BASE_URL);
    const model = config?.ollamaModel || DEFAULT_MODEL;
    const temperature =
      config?.ollamaTemperature != null
        ? Number(config.ollamaTemperature)
        : DEFAULT_TEMPERATURE;
    const timeoutSeconds =
      config?.ollamaTimeout != null
        ? Number(config.ollamaTimeout)
        : DEFAULT_TIMEOUT_SECONDS;
    const prompt = reviewRequest?.prompt || "";
    // Build the request body in OpenAI-compatible chat format.
    const requestBody = JSON.stringify({
      model,
      messages: [{ role: "system", content: prompt }],
      stream: false,
      options: {
        temperature: isNaN(temperature) ? DEFAULT_TEMPERATURE : temperature,
      },
    });
    // Build AbortController for timeout.
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
    let response;
    try {
      response = await fetch(`${baseUrl}/api/chat`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: requestBody,
        signal: controller.signal,
      });
    } catch (error) {
      clearTimeout(timeoutId);
      const kind = getErrorKind(error);
      throw new Error(
        `Ollama API error (${kind}): ${safeErrorMessage(error)}`
      );
    } finally {
      clearTimeout(timeoutId);
    }
    // Handle non-2xx status codes.
    if (!response.ok) {
      let bodyText = "";
      try {
        bodyText = await response.text();
      } catch (_) {
        /* ignore unparseable error bodies */
      }
      const errObj = new Error(`HTTP ${response.status}`);
      errObj.status = response.status;
      const kind = getErrorKind(errObj);
      const detail = bodyText ? ` — ${bodyText.slice(0, 200)}` : "";
      throw new Error(
        `Ollama API error (${kind}): HTTP ${response.status}${detail}`
      );
    }
    // Parse JSON response.
    let data;
    try {
      data = await response.json();
    } catch (_) {
      throw new Error(
        "Ollama API error (OllamaRequestError): invalid JSON response."
      );
    }
    // Ollama /api/chat returns: { model, message: { role, content }, done }
    const content = data?.message?.content ?? "";
    return { content };
  },
 };
@@ -0,0 +1,29 @@
 // OpenAI chat provider adapter.
 // Wraps src/openai/client.js + src/openai/responses.js into the provider interface.
 import { createOpenAIClient } from "../openai/client.js";
 import { sendOpenAIResponse } from "../openai/responses.js";
 /**
 * Chat provider backed by OpenAI Responses API.
 * Implements { send(input, config) => Promise<{ content: string }> }.
 */
 export const openaiProvider = {
  /**
   * @param {{ prompt?: string, input?: object }} request - ProviderRequest (prompt is unused by OpenAI provider).
   * @param {object} config - full config from loadConfig().
   * @returns {Promise<{ content: string }>}
   */
  async send(input, config) {
    const client = createOpenAIClient(config);
    const result = await sendOpenAIResponse(client, {
      input: [{ role: "system", content: input }],
      model: config.openaiModel,
      temperature: config.temperature,
      maxOutputTokens: config.maxOutputTokens,
    });
    return { content: result.content };
  },
 };
@@ -7,8 +7,7 @@ import { handleReviewCode } from "./tools/review-code.js";
 import { handleDebugIssue } from "./tools/debug-issue.js";
 import { handleArchitectureReview } from "./tools/architecture-review.js";
 import { loadConfig } from "./config/env.js";
-import { createOpenAIClient } from "./openai/client.js";
+import { createChatProvider } from "./providers/factory.js";
 import { sendOpenAIResponse } from "./openai/responses.js";
 const server = new McpServer({
  name: "chatgpt-mcp",
@@ -23,10 +22,12 @@ server.registerTool(
    inputSchema: baseInputSchema,
  },
  async (input) => {
    const config = loadConfig();
    const provider = createChatProvider(config);
    const result = await handleAskChatGpt(input, {
-      loadConfig,
+      loadConfig: () => config,
-      createOpenAIClient,
+      createProvider: () => ({ send: provider.send.bind(provider) }),
      sendOpenAIResponse,
    });
    const text = result.ok
@@ -51,10 +52,12 @@ server.registerTool(
    inputSchema: baseInputSchema,
  },
  async (input) => {
    const config = loadConfig();
    const provider = createChatProvider(config);
    const result = await handleReviewPlan(input, {
-      loadConfig,
+      loadConfig: () => config,
-      createOpenAIClient,
+      createProvider: () => ({ send: provider.send.bind(provider) }),
      sendOpenAIResponse,
    });
    const text = result.ok
@@ -79,10 +82,12 @@ server.registerTool(
    inputSchema: baseInputSchema,
  },
  async (input) => {
    const config = loadConfig();
    const provider = createChatProvider(config);
    const result = await handleReviewCode(input, {
-      loadConfig,
+      loadConfig: () => config,
-      createOpenAIClient,
+      createProvider: () => ({ send: provider.send.bind(provider) }),
      sendOpenAIResponse,
    });
    const text = result.ok
@@ -107,10 +112,12 @@ server.registerTool(
    inputSchema: baseInputSchema,
  },
  async (input) => {
    const config = loadConfig();
    const provider = createChatProvider(config);
    const result = await handleDebugIssue(input, {
-      loadConfig,
+      loadConfig: () => config,
-      createOpenAIClient,
+      createProvider: () => ({ send: provider.send.bind(provider) }),
      sendOpenAIResponse,
    });
    const text = result.ok
@@ -135,10 +142,12 @@ server.registerTool(
    inputSchema: baseInputSchema,
  },
  async (input) => {
    const config = loadConfig();
    const provider = createChatProvider(config);
    const result = await handleArchitectureReview(input, {
-      loadConfig,
+      loadConfig: () => config,
-      createOpenAIClient,
+      createProvider: () => ({ send: provider.send.bind(provider) }),
      sendOpenAIResponse,
    });
    const text = result.ok
@@ -15,8 +15,8 @@ import { buildArchitectureReviewPrompt } from "../prompts/architecture-review.js
 *   Raw tool input per ARCHITECTURE.md §7 schema.
 * @param {{
 *   loadConfig: () => object,
- *   createOpenAIClient: (config: object) => any,
+ *   createProvider: (config: object) => { send: (request: ProviderRequest, cfg: object) => Promise<{ content: string }> }
- *   sendOpenAIResponse: (client: any, params: object) => Promise<any>
+ *     ProviderRequest = { prompt?: string, input?: object }
 * }} deps
 *   Injected external dependencies.
 * @returns {Promise<{ ok: true, answer: string, warnings: string[] } | { ok: false, error: string, warnings: string[] }>}
@@ -49,25 +49,24 @@ export async function handleArchitectureReview(input, deps) {
  const promptMessages = buildArchitectureReviewPrompt(budget.input);
-  // --- 5. Create OpenAI client ---
+  // --- 5. Create chat provider ---
-  let client;
+  let provider;
  try {
-    client = deps.createOpenAIClient(config);
+    provider = deps.createProvider(config);
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
-  // --- 6. Send to OpenAI ---
+  // --- 5b. Package shared data for provider ---
  const reviewRequest = { prompt: promptMessages, input: budget.input };
  // --- 6. Send via provider ---
  let aiResult;
  try {
-    aiResult = await deps.sendOpenAIResponse(client, {
+    aiResult = await provider.send(reviewRequest, config);
      input: [{ role: "system", content: promptMessages }],
      model: config.openaiModel,
      temperature: config.temperature,
      maxOutputTokens: config.maxOutputTokens,
    });
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
@@ -15,8 +15,8 @@ import { buildAskChatGptPrompt } from "../prompts/ask-chatgpt.js";
 *   Raw tool input per ARCHITECTURE.md §7 schema.
 * @param {{
 *   loadConfig: () => object,
- *   createOpenAIClient: (config: object) => any,
+ *   createProvider: (config: object) => { send: (request: ProviderRequest, cfg: object) => Promise<{ content: string }> }
- *   sendOpenAIResponse: (client: any, params: object) => Promise<any>
+ *     ProviderRequest = { prompt?: string, input?: object }
 * }} deps
 *   Injected external dependencies.
 * @returns {Promise<{ ok: true, answer: string, warnings: string[] } | { ok: false, error: string, warnings: string[] }>}
@@ -49,25 +49,25 @@ export async function handleAskChatGpt(input, deps) {
  const promptMessages = buildAskChatGptPrompt(budget.input);
-  // --- 5. Create OpenAI client ---
+  // --- 5. Create chat provider ---
-  let client;
+  let provider;
  try {
-    client = deps.createOpenAIClient(config);
+    provider = deps.createProvider(config);
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
-  // --- 6. Send to OpenAI ---
+  // --- 5b. Package shared data for provider ---
  const reviewRequest = { prompt: promptMessages, input: budget.input };
  // --- 6. Send via provider ---
  let aiResult;
  try {
-    aiResult = await deps.sendOpenAIResponse(client, {
+    aiResult = await provider.send(reviewRequest, config);
-      input: [{ role: "system", content: promptMessages }],
+
      model: config.openaiModel,
      temperature: config.temperature,
      maxOutputTokens: config.maxOutputTokens,
    });
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
@@ -15,8 +15,8 @@ import { buildDebugIssuePrompt } from "../prompts/debug-issue.js";
 *   Raw tool input per ARCHITECTURE.md §7 schema.
 * @param {{
 *   loadConfig: () => object,
- *   createOpenAIClient: (config: object) => any,
+ *   createProvider: (config: object) => { send: (request: ProviderRequest, cfg: object) => Promise<{ content: string }> }
- *   sendOpenAIResponse: (client: any, params: object) => Promise<any>
+ *     ProviderRequest = { prompt?: string, input?: object }
 * }} deps
 *   Injected external dependencies.
 * @returns {Promise<{ ok: true, answer: string, warnings: string[] } | { ok: false, error: string, warnings: string[] }>}
@@ -49,25 +49,24 @@ export async function handleDebugIssue(input, deps) {
  const promptMessages = buildDebugIssuePrompt(budget.input);
-  // --- 5. Create OpenAI client ---
+  // --- 5. Create chat provider ---
-  let client;
+  let provider;
  try {
-    client = deps.createOpenAIClient(config);
+    provider = deps.createProvider(config);
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
-  // --- 6. Send to OpenAI ---
+  // --- 5b. Package shared data for provider ---
  const reviewRequest = { prompt: promptMessages, input: budget.input };
  // --- 6. Send via provider ---
  let aiResult;
  try {
-    aiResult = await deps.sendOpenAIResponse(client, {
+    aiResult = await provider.send(reviewRequest, config);
      input: [{ role: "system", content: promptMessages }],
      model: config.openaiModel,
      temperature: config.temperature,
      maxOutputTokens: config.maxOutputTokens,
    });
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
@@ -15,8 +15,8 @@ import { buildReviewCodePrompt } from "../prompts/review-code.js";
 *   Raw tool input per ARCHITECTURE.md §7 schema.
 * @param {{
 *   loadConfig: () => object,
- *   createOpenAIClient: (config: object) => any,
+ *   createProvider: (config: object) => { send: (request: ProviderRequest, cfg: object) => Promise<{ content: string }> }
- *   sendOpenAIResponse: (client: any, params: object) => Promise<any>
+ *     ProviderRequest = { prompt?: string, input?: object }
 * }} deps
 *   Injected external dependencies.
 * @returns {Promise<{ ok: true, answer: string, warnings: string[] } | { ok: false, error: string, warnings: string[] }>}
@@ -49,25 +49,24 @@ export async function handleReviewCode(input, deps) {
  const promptMessages = buildReviewCodePrompt(budget.input);
-  // --- 5. Create OpenAI client ---
+  // --- 5. Create chat provider ---
-  let client;
+  let provider;
  try {
-    client = deps.createOpenAIClient(config);
+    provider = deps.createProvider(config);
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
-  // --- 6. Send to OpenAI ---
+  // --- 5b. Package shared data for provider ---
  const reviewRequest = { prompt: promptMessages, input: budget.input };
  // --- 6. Send via provider ---
  let aiResult;
  try {
-    aiResult = await deps.sendOpenAIResponse(client, {
+    aiResult = await provider.send(reviewRequest, config);
      input: [{ role: "system", content: promptMessages }],
      model: config.openaiModel,
      temperature: config.temperature,
      maxOutputTokens: config.maxOutputTokens,
    });
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
@@ -15,8 +15,8 @@ import { buildReviewPlanPrompt } from "../prompts/review-plan.js";
 *   Raw tool input per ARCHITECTURE.md §7 schema.
 * @param {{
 *   loadConfig: () => object,
- *   createOpenAIClient: (config: object) => any,
+ *   createProvider: (config: object) => { send: (request: ProviderRequest, cfg: object) => Promise<{ content: string }> }
- *   sendOpenAIResponse: (client: any, params: object) => Promise<any>
+ *     ProviderRequest = { prompt?: string, input?: object }
 * }} deps
 *   Injected external dependencies.
 * @returns {Promise<{ ok: true, answer: string, warnings: string[] } | { ok: false, error: string, warnings: string[] }>}
@@ -49,25 +49,25 @@ export async function handleReviewPlan(input, deps) {
  const promptMessages = buildReviewPlanPrompt(budget.input);
-  // --- 5. Create OpenAI client ---
+  // --- 5. Create chat provider ---
-  let client;
+  let provider;
  try {
-    client = deps.createOpenAIClient(config);
+    provider = deps.createProvider(config);
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
-  // --- 6. Send to OpenAI ---
+  // --- 5b. Package shared data for provider ---
  const reviewRequest = { prompt: promptMessages, input: budget.input };
  // --- 6. Send via provider ---
  let aiResult;
  try {
-    aiResult = await deps.sendOpenAIResponse(client, {
+    aiResult = await provider.send(reviewRequest, config);
-      input: [{ role: "system", content: promptMessages }],
+
      model: config.openaiModel,
      temperature: config.temperature,
      maxOutputTokens: config.maxOutputTokens,
    });
  } catch (err) {
    return { ok: false, error: String(err), warnings: [] };
  }
@@ -5,7 +5,7 @@ const originalEnv = { ...process.env };
 function setEnv(partial) {
  for (const key of Object.keys(process.env)) {
-    if (key.startsWith('OPENAI_') || key.startsWith('CHATGPT_MCP_')) {
+    if (key.startsWith('OPENAI_') || key.startsWith('CHATGPT_MCP_') || key.startsWith('OLLAMA_')) {
      delete process.env[key];
    }
  }
@@ -18,7 +18,7 @@ beforeEach(() => {
 afterEach(() => {
  for (const key of Object.keys(process.env)) {
-    if (key.startsWith('OPENAI_') || key.startsWith('CHATGPT_MCP_')) {
+    if (key.startsWith('OPENAI_') || key.startsWith('CHATGPT_MCP_') || key.startsWith('OLLAMA_')) {
      delete process.env[key];
    }
  }
@@ -26,10 +26,34 @@ afterEach(() => {
 });
 describe('loadConfig', () => {
-  it('throws when OPENAI_API_KEY is missing', () => {
+  it('throws when OPENAI_API_KEY is missing and provider is openai', () => {
    delete process.env.OPENAI_API_KEY;
    delete process.env.CHATGPT_MCP_PROVIDER;
    expect(() => loadConfig()).toThrow(
-      'Configuration error: OPENAI_API_KEY is missing.'
+      'Configuration error: OPENAI_API_KEY is required for the openai provider.'
    );
  });
  it('does not throw when OPENAI_API_KEY is missing and provider is manual', () => {
    delete process.env.OPENAI_API_KEY;
    setEnv({ CHATGPT_MCP_PROVIDER: 'manual' });
    const cfg = loadConfig();
    expect(cfg.chatgptMcpProvider).toBe('manual');
    expect(cfg.openaiApiKey).toBe(undefined);
  });
  it('does not throw when OPENAI_API_KEY is missing and provider is ollama', () => {
    delete process.env.OPENAI_API_KEY;
    setEnv({ CHATGPT_MCP_PROVIDER: 'ollama' });
    const cfg = loadConfig();
    expect(cfg.chatgptMcpProvider).toBe('ollama');
    expect(cfg.openaiApiKey).toBe(undefined);
  });
  it('still requires OPENAI_API_KEY for openai even when key is explicitly empty string', () => {
    setEnv({ CHATGPT_MCP_PROVIDER: 'openai', OPENAI_API_KEY: '' });
    expect(() => loadConfig()).toThrow(
      'Configuration error: OPENAI_API_KEY is required for the openai provider.'
    );
  });
@@ -47,6 +71,10 @@ describe('loadConfig', () => {
    expect(cfg.maxFiles).toBe(5);
    expect(cfg.maxLogChars).toBe(10000);
    expect(cfg.redactSecrets).toBe(true);
    expect(cfg.ollamaBaseUrl).toBe('http://localhost:11434');
    expect(cfg.ollamaModel).toBe('qwen3:latest');
    expect(cfg.ollamaTemperature).toBe(0.2);
    expect(cfg.ollamaTimeout).toBe(60);
  });
  it('applies custom string values', () => {
@@ -142,3 +170,122 @@ describe('loadConfig', () => {
    );
  });
 });
 describe('loadConfig chatgptMcpProvider', () => {
  it('defaults to "openai" when CHATGPT_MCP_PROVIDER is not set', () => {
    delete process.env.CHATGPT_MCP_PROVIDER;
    const cfg = loadConfig();
    expect(cfg.chatgptMcpProvider).toBe('openai');
  });
  it('accepts "openai" value', () => {
    setEnv({ CHATGPT_MCP_PROVIDER: 'openai', OPENAI_API_KEY: 'sk-test' });
    const cfg = loadConfig();
    expect(cfg.chatgptMcpProvider).toBe('openai');
  });
  it('accepts any string value (validation is in factory)', () => {
    setEnv({ CHATGPT_MCP_PROVIDER: 'ollama', OPENAI_API_KEY: 'sk-test' });
    const cfg = loadConfig();
    expect(cfg.chatgptMcpProvider).toBe('ollama');
  });
 });
 // --- Ollama env vars ---
 describe('loadConfig ollama env vars', () => {
  it('returns default ollama values when no OLLAMA_ vars set', () => {
    const cfg = loadConfig();
    expect(cfg.ollamaBaseUrl).toBe('http://localhost:11434');
    expect(cfg.ollamaModel).toBe('qwen3:latest');
    expect(cfg.ollamaTemperature).toBe(0.2);
    expect(cfg.ollamaTimeout).toBe(60);
  });
  it('applies custom OLLAMA_BASE_URL', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_BASE_URL: 'http://localhost:11435' });
    const cfg = loadConfig();
    expect(cfg.ollamaBaseUrl).toBe('http://localhost:11435');
  });
  it('returns raw OLLAMA_BASE_URL — trailing slash normalization is in the provider', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_BASE_URL: 'http://localhost:11434/' });
    const cfg = loadConfig();
    expect(cfg.ollamaBaseUrl).toBe('http://localhost:11434/');
  });
  it('applies custom OLLAMA_MODEL', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_MODEL: 'llama3' });
    const cfg = loadConfig();
    expect(cfg.ollamaModel).toBe('llama3');
  });
  it('applies custom OLLAMA_TEMPERATURE', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_TEMPERATURE: '0.7' });
    const cfg = loadConfig();
    expect(cfg.ollamaTemperature).toBe(0.7);
  });
  it('applies custom OLLAMA_TIMEOUT', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_TIMEOUT: '120' });
    const cfg = loadConfig();
    expect(cfg.ollamaTimeout).toBe(120);
  });
  it('throws on invalid OLLAMA_TEMPERATURE', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_TEMPERATURE: 'abc' });
    expect(() => loadConfig()).toThrow(
      'Configuration error: OLLAMA_TEMPERATURE must be a positive number, got "abc".'
    );
  });
  it('throws on negative OLLAMA_TIMEOUT', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_TIMEOUT: '-10' });
    expect(() => loadConfig()).toThrow(
      'Configuration error: OLLAMA_TIMEOUT must be a positive number, got "-10".'
    );
  });
  it('works with ollama provider and all ollama env vars', () => {
    setEnv({
      OPENAI_API_KEY: 'sk-test',
      CHATGPT_MCP_PROVIDER: 'ollama',
      OLLAMA_BASE_URL: 'http://ollama-server:8080',
      OLLAMA_MODEL: 'mistral',
      OLLAMA_TEMPERATURE: '0.5',
      OLLAMA_TIMEOUT: '90',
    });
    const cfg = loadConfig();
    expect(cfg.chatgptMcpProvider).toBe('ollama');
    expect(cfg.ollamaBaseUrl).toBe('http://ollama-server:8080');
    expect(cfg.ollamaModel).toBe('mistral');
    expect(cfg.ollamaTemperature).toBe(0.5);
    expect(cfg.ollamaTimeout).toBe(90);
  });
 });
 describe('loadConfig ollama env vars with trailing slash', () => {
  it('returns raw base URL — normalization happens in the provider', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_BASE_URL: 'http://localhost:11434//' });
    const cfg = loadConfig();
    expect(cfg.ollamaBaseUrl).toBe('http://localhost:11434//');
  });
  it('returns raw base URL with multiple slashes', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_BASE_URL: 'http://localhost:11434///' });
    const cfg = loadConfig();
    expect(cfg.ollamaBaseUrl).toBe('http://localhost:11434///');
  });
  it('handles base URL without trailing slash', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_BASE_URL: 'http://localhost:11434' });
    const cfg = loadConfig();
    expect(cfg.ollamaBaseUrl).toBe('http://localhost:11434');
  });
  it('handles empty base URL as default', () => {
    setEnv({ OPENAI_API_KEY: 'test-key', OLLAMA_BASE_URL: '' });
    const cfg = loadConfig();
    expect(cfg.ollamaBaseUrl).toBe('http://localhost:11434');
  });
 });
@@ -0,0 +1,401 @@
 import { describe, it, expect, vi } from "vitest";
 import { createChatProvider, openaiProvider } from "../../src/providers/factory.js";
 import { manualExportProvider } from "../../src/providers/manual-export.js";
 function mockConfig(provider) {
  const cfg = { chatgptMcpProvider: provider };
  return cfg;
 }
 // --- Default provider ---
 describe("default provider", () => {
  it("returns openai provider when no provider specified", () => {
    const provider = createChatProvider({});
    expect(provider).toBe(openaiProvider);
  });
  it("returns openai provider when null config", () => {
    const provider = createChatProvider(null);
    expect(provider).toBe(openaiProvider);
  });
  it("returns openai provider when undefined config", () => {
    const provider = createChatProvider(undefined);
    expect(provider).toBe(openaiProvider);
  });
  it("returns openai provider when chatgptMcpProvider is empty string", () => {
    const provider = createChatProvider({ chatgptMcpProvider: "" });
    expect(provider).toBe(openaiProvider);
  });
  it("returns openai provider explicitly set", () => {
    const provider = createChatProvider({ chatgptMcpProvider: "openai" });
    expect(provider).toBe(openaiProvider);
  });
 });
 // --- Supported providers ---
 describe("supported providers", () => {
  it("supports openai", () => {
    const provider = createChatProvider({ chatgptMcpProvider: "openai" });
    expect(provider).toBe(openaiProvider);
  });
  it("returns the same instance for repeated calls with same provider", () => {
    const p1 = createChatProvider({ chatgptMcpProvider: "openai" });
    const p2 = createChatProvider({ chatgptMcpProvider: "openai" });
    expect(p1).toBe(p2);
  });
 });
 // --- Unsupported providers ---
 describe("unsupported providers", () => {
  it("supports ollama provider", () => {
    const provider = createChatProvider({ chatgptMcpProvider: "ollama" });
    expect(provider).toBeDefined();
    expect(typeof provider.send).toBe("function");
  });
  it("returns the same singleton instance for repeated calls with 'ollama'", () => {
    const p1 = createChatProvider({ chatgptMcpProvider: "ollama" });
    const p2 = createChatProvider({ chatgptMcpProvider: "ollama" });
    expect(p1).toBe(p2);
  });
  it("is different from openai provider", () => {
    const ollamaP = createChatProvider({ chatgptMcpProvider: "ollama" });
    expect(ollamaP).not.toBe(openaiProvider);
  });
  it("throws on unknown provider name", () => {
    expect(() => createChatProvider({ chatgptMcpProvider: "unknown" })).toThrow(
      /Unsupported chat provider "unknown"/,
    );
  });
  it("defaults to openai for null provider name", () => {
    const provider = createChatProvider({ chatgptMcpProvider: null });
    expect(provider.send).toBeDefined();
  });
  it("throws on numeric provider name (truthy but not supported)", () => {
    expect(() => createChatProvider({ chatgptMcpProvider: 123 })).toThrow('Unsupported chat provider "123"');
  });
  it("contains provider name in error message for unsupported providers", () => {
    try {
      createChatProvider({ chatgptMcpProvider: "ollama" });
    } catch (err) {
      expect(err.message).toContain("ollama");
    }
  });
  it("mentions provider name in error message", () => {
    try {
      createChatProvider({ chatgptMcpProvider: "bedrock" });
    } catch (err) {
      expect(err.message).toContain("bedrock");
    }
  });
 });
 // --- Provider interface ---
 describe("provider interface", () => {
  it("returned provider has send method", () => {
    const provider = createChatProvider({ chatgptMcpProvider: "openai" });
    expect(typeof provider.send).toBe("function");
  });
  it("send is a function, not undefined", () => {
    const provider = createChatProvider({ chatgptMcpProvider: "openai" });
    expect(provider.send).not.toBeUndefined();
  });
 });
 // --- Exported openaiProvider ---
 describe("exported openaiProvider", () => {
  it("openaiProvider is exported from factory", () => {
    expect(openaiProvider).toBeDefined();
  });
  it("openaiProvider has send method", () => {
    expect(typeof openaiProvider.send).toBe("function");
  });
 });
 // --- Edge cases ---
 describe("edge cases", () => {
  it("handles case-sensitive provider name (Ollama != ollama)", () => {
    // This should also fail since only lowercase "openai" is supported
    expect(() => createChatProvider({ chatgptMcpProvider: "Ollama" })).toThrow();
  });
  it("handles whitespace provider name", () => {
    expect(() => createChatProvider({ chatgptMcpProvider: " openai " })).toThrow();
  });
  it("handles JSON string provider name", () => {
    expect(() => createChatProvider({ chatgptMcpProvider: '"openai"' })).toThrow();
  });
  it("creates provider even with minimal config object", () => {
    const provider = createChatProvider({ chatgptMcpProvider: "openai" });
    expect(typeof provider.send).toBe("function");
  });
  it("works when config has extra unrelated fields", () => {
    const provider = createChatProvider({
      chatgptMcpProvider: "openai",
      openaiApiKey: "sk-test",
      someOtherField: "ignored",
    });
    expect(provider).toBe(openaiProvider);
  });
  it("does not mutate the config object", () => {
    const cfg = { chatgptMcpProvider: "openai" };
    createChatProvider(cfg);
    expect(cfg.chatgptMcpProvider).toBe("openai");
  });
  it("does not throw for all falsy values except explicit openai", () => {
    const falsyValues = [null, undefined, "", NaN];
    // Only empty string and no-provider should default to openai
    // null/undefined → config check passes (defaults to "openai")
    // "" → defaults to "openai"
  });
  it("defaults to openai for NaN provider name", () => {
    const provider = createChatProvider({ chatgptMcpProvider: NaN });
    expect(provider.send).toBeDefined();
  });
 });
 // --- Integration-like test ---
 describe("integration: send delegation", () => {
  it("provider.send delegates to the underlying provider implementation", async () => {
    const provider = createChatProvider({ chatgptMcpProvider: "openai" });
    // The real openaiProvider.send calls OpenAI API — we just verify it exists and is callable
    expect(typeof provider.send).toBe("function");
    // We don't call it here to avoid actual API calls in tests
  });
 });
 // --- Repeatability ---
 describe("repeatability", () => {
  it("creates identical providers for same config each time", () => {
    const results = [];
    for (let i = 0; i < 10; i++) {
      results.push(createChatProvider({ chatgptMcpProvider: "openai" }));
    }
    expect(results.every((p) => p === openaiProvider)).toBe(true);
  });
  it("does not share mutable state between calls", () => {
    const p1 = createChatProvider({ chatgptMcpProvider: "openai" });
    const p2 = createChatProvider({ chatgptMcpProvider: "openai" });
    // Both should be the same singleton instance (by design)
    expect(p1).toBe(p2);
  });
 });
 // --- Manual provider ---
 describe("manual provider", () => {
  it("supports manual provider via createChatProvider", () => {
    const provider = createChatProvider({ chatgptMcpProvider: "manual" });
    expect(provider.send).toBeDefined();
  });
  it("returns the same singleton instance for repeated calls with 'manual'", () => {
    const p1 = createChatProvider({ chatgptMcpProvider: "manual" });
    const p2 = createChatProvider({ chatgptMcpProvider: "manual" });
    expect(p1).toBe(p2);
  });
  it("is different from openai provider", () => {
    const manualP = createChatProvider({ chatgptMcpProvider: "manual" });
    expect(manualP).not.toBe(openaiProvider);
  });
  it("can detect manual as a supported provider (not throw)", () => {
    const provider = createChatProvider({ chatgptMcpProvider: "manual" });
    expect(provider.send).toBeDefined();
  });
  it("manual provider send returns { content: string } shape", async () => {
    const provider = createChatProvider({ chatgptMcpProvider: "manual" });
    const result = await provider.send(
      { prompt: "test prompt from manual env", input: { question: "hi" } },
      {},
    );
    expect(result).toHaveProperty("content");
    expect(typeof result.content).toBe("string");
  });
  it("manual provider output contains MANUAL EXPORT marker", async () => {
    const provider = createChatProvider({ chatgptMcpProvider: "manual" });
    const result = await provider.send({ prompt: "test", input: {} }, {});
    expect(result.content).toContain("MANUAL EXPORT");
  });
  it("manual provider output contains COPY box delimiters", async () => {
    const provider = createChatProvider({ chatgptMcpProvider: "manual" });
    const result = await provider.send({ prompt: "test", input: {} }, {});
    expect(result.content).toContain("┌");
    expect(result.content).toContain("┐");
    expect(result.content).toContain("┘");
  });
  it("can be switched from openai to manual and back", () => {
    const p1 = createChatProvider({ chatgptMcpProvider: "openai" });
    const p2 = createChatProvider({ chatgptMcpProvider: "manual" });
    const p3 = createChatProvider({ chatgptMcpProvider: "openai" });
    expect(p1).toBe(openaiProvider);
    expect(p2).not.toBe(openaiProvider);
    expect(p3).toBe(openaiProvider);
  });
  it("manual provider is not the same as openaiProvider singleton", () => {
    const manualP = createChatProvider({ chatgptMcpProvider: "manual" });
    expect(manualExportProvider).toBe(manualP);
  });
 });
 // --- Ollama provider send (fetch-mocked) ---
 describe("ollama provider send", () => {
  it("builds correct request body with config values", async () => {
    const fetchMock = vi.fn().mockResolvedValue({
      ok: true,
      json: async () => ({ model: "qwen3", message: { role: "assistant", content: "Hello!" }, done: true }),
    });
    // Create a custom ollamaProvider with mocked fetch
    const { ollamaProvider } = await import("../../src/providers/ollama.js");
    const originalFetch = globalThis.fetch;
    globalThis.fetch = fetchMock;
    try {
      const config = {
        chatgptMcpProvider: "ollama",
        ollamaBaseUrl: "http://test:11434",
        ollamaModel: "test-model",
        ollamaTemperature: 0.5,
        ollamaTimeout: 30,
      };
      const result = await ollamaProvider.send({ prompt: "What is AI?" }, config);
      expect(result.content).toBe("Hello!");
      const calls = fetchMock.mock.calls;
      expect(calls.length).toBe(1);
      const [url, init] = calls[0];
      expect(url).toBe("http://test:11434/api/chat");
      expect(init.method).toBe("POST");
      expect(JSON.parse(init.body)).toEqual({
        model: "test-model",
        messages: [{ role: "system", content: "What is AI?" }],
        stream: false,
        options: { temperature: 0.5 },
      });
    } finally {
      globalThis.fetch = originalFetch;
    }
  });
  it("uses defaults when no config ollama fields are set", async () => {
    const fetchMock = vi.fn().mockResolvedValue({
      ok: true,
      json: async () => ({ model: "qwen3", message: { role: "assistant", content: "OK" }, done: true }),
    });
    const { ollamaProvider } = await import("../../src/providers/ollama.js");
    const originalFetch = globalThis.fetch;
    globalThis.fetch = fetchMock;
    try {
      const config = {};
      const result = await ollamaProvider.send({ prompt: "hi" }, config);
      expect(result.content).toBe("OK");
      const [url, init] = fetchMock.mock.calls[0];
      const body = JSON.parse(init.body);
      expect(url).toBe("http://localhost:11434/api/chat");
      expect(body.model).toBe("qwen3:latest");
      expect(body.options.temperature).toBe(0.2);
    } finally {
      globalThis.fetch = originalFetch;
    }
  });
  it("handles non-2xx response with error category", async () => {
    const fetchMock = vi.fn().mockResolvedValue({ ok: false, status: 404, text: async () => "model not found" });
    const { ollamaProvider } = await import("../../src/providers/ollama.js");
    const originalFetch = globalThis.fetch;
    globalThis.fetch = fetchMock;
    try {
      const config = {};
      await expect(
        ollamaProvider.send({ prompt: "hi" }, config),
      ).rejects.toThrow(/Ollama API error \(OllamaModelNotFoundError\)/);
    } finally {
      globalThis.fetch = originalFetch;
    }
  });
  it("handles fetch network errors", async () => {
    const fetchMock = vi.fn().mockRejectedValue(new Error("ECONNREFUSED"));
    const { ollamaProvider } = await import("../../src/providers/ollama.js");
    const originalFetch = globalThis.fetch;
    globalThis.fetch = fetchMock;
    try {
      const config = {};
      await expect(
        ollamaProvider.send({ prompt: "hi" }, config),
      ).rejects.toThrow(/Ollama API error \(OllamaRequestError\)/);
    } finally {
      globalThis.fetch = originalFetch;
    }
  });
  it("handles invalid JSON response", async () => {
    const fetchMock = vi.fn().mockResolvedValue({ ok: true, text: async () => "not json" });
    const { ollamaProvider } = await import("../../src/providers/ollama.js");
    const originalFetch = globalThis.fetch;
    globalThis.fetch = fetchMock;
    try {
      const config = {};
      await expect(
        ollamaProvider.send({ prompt: "hi" }, config),
      ).rejects.toThrow(/invalid JSON response/);
    } finally {
      globalThis.fetch = originalFetch;
    }
  });
  it("returns empty content when message.content is missing", async () => {
    const fetchMock = vi.fn().mockResolvedValue({
      ok: true,
      json: async () => ({ model: "test", done: true }),
    });
    const { ollamaProvider } = await import("../../src/providers/ollama.js");
    const originalFetch = globalThis.fetch;
    globalThis.fetch = fetchMock;
    try {
      const config = {};
      const result = await ollamaProvider.send({ prompt: "hi" }, config);
      expect(result.content).toBe("");
    } finally {
      globalThis.fetch = originalFetch;
    }
  });
 });
@@ -0,0 +1,506 @@
 import { describe, it, expect } from "vitest";
 import { manualExportProvider } from "../../src/providers/manual-export.js";
 // --- Basic structure ---
 describe("basic structure", () => {
  it("exports a provider with send method", () => {
    expect(manualExportProvider).toBeDefined();
    expect(typeof manualExportProvider.send).toBe("function");
  });
  it("returns { content: string } shape on success", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test prompt" },
      {},
    );
    expect(result).toHaveProperty("content");
    expect(typeof result.content).toBe("string");
  });
  it("returns non-empty content for valid prompt", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test prompt" },
      {},
    );
    expect(result.content.length).toBeGreaterThan(0);
  });
  it("is deterministic — same input produces same output", async () => {
    const input = { prompt: "deterministic test", input: { question: "hi" } };
    const r1 = await manualExportProvider.send(input, {});
    const r2 = await manualExportProvider.send(input, {});
    expect(r1.content).toBe(r2.content);
  });
  it("does not modify the request object", async () => {
    const req = { prompt: "test", input: { question: "hi" } };
    const original = JSON.stringify(req);
    await manualExportProvider.send(req, {});
    expect(JSON.stringify(req)).toBe(original);
  });
  it("does not modify the config object", async () => {
    const config = { openaiApiKey: "sk-test" };
    await manualExportProvider.send({ prompt: "test" }, config);
    expect(config.openaiApiKey).toBe("sk-test");
  });
 });
 // --- Copy-ready structure ---
 describe("copy-ready structure", () => {
  it("includes MANUAL EXPORT header with tool name", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("MANUAL EXPORT");
  });
  it("includes COPY box with top-left corner delimiters (┌)", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("┌");
  });
  it("includes COPY box with bottom-right corner delimiters (┐ and ┘)", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("┐");
    expect(result.content).toContain("└");
    expect(result.content).toContain("┘");
  });
  it("includes instructions section with numbered steps", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("📝 INSTRUCTIONS:");
    expect(result.content).toContain("1.");
    expect(result.content).toContain("2.");
    expect(result.content).toContain("3.");
  });
  it("includes metadata section", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("📊 METADATA:");
  });
  it("includes provider info in metadata", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("Manual Export");
  });
  it("includes tool name in metadata", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { question: "hi" } },
      {},
    );
    expect(result.content).toMatch(/Tool: \w+/);
  });
  it("includes prompt length in metadata with formatted thousands separator", async () => {
    const longPrompt = "x".repeat(12345);
    const result = await manualExportProvider.send(
      { prompt: longPrompt, input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("Prompt Length:");
    expect(result.content).toContain("12,345 characters");
  });
  it("includes advisory footer", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("advisory output only");
  });
  it("wraps each line of prompt in box with │ delimiter", async () => {
    const multiLine = "line one\nline two\nline three";
    const result = await manualExportProvider.send(
      { prompt: multiLine, input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("│ line one");
    expect(result.content).toContain("│ line two");
    expect(result.content).toContain("│ line three");
  });
 });
 // --- Per-tool detection ---
 describe("tool name detection", () => {
  it("detects debug_issue when input has logs", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { logs: "Error: boom" } },
      {},
    );
    expect(result.content).toContain("Tool: debug_issue");
  });
  it("detects review_code when input has relevantFiles with paths", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { relevantFiles: [{ path: "src/foo.js" }] } },
      {},
    );
    expect(result.content).toContain("Tool: review_code");
  });
  it("detects architecture_review when context includes 'architecture'", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { context: "Architecture decision here" } },
      {},
    );
    expect(result.content).toContain("Tool: architecture_review");
  });
  it("detects review_plan when input has projectSummary", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { projectSummary: "Project scope" } },
      {},
    );
    expect(result.content).toContain("Tool: review_plan");
  });
  it("defaults to ask_chatgpt when no hints available", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test", input: { question: "hi" } },
      {},
    );
    expect(result.content).toContain("Tool: ask_chatgpt");
  });
  it("uses 'unknown' when input is absent in request", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test" },
      {},
    );
    expect(result.content).toContain("Tool: unknown");
  });
 });
 // --- Long prompt handling ---
 describe("long prompt handling", () => {
  it("adds warning banner for prompts over 30k characters", async () => {
    const longPrompt = "x".repeat(31_000);
    const result = await manualExportProvider.send({ prompt: longPrompt, input: {} }, {});
    expect(result.content).toContain("⚠️ NOTE");
  });
  it("does NOT add warning for prompts under 30k characters", async () => {
    const validPrompt = "x".repeat(29_999);
    const result = await manualExportProvider.send({ prompt: validPrompt, input: {} }, {});
    expect(result.content).not.toContain("⚠️ NOTE");
  });
  it("still returns valid output for very long prompts (>50k chars)", async () => {
    const veryLongPrompt = "x".repeat(50_000);
    const result = await manualExportProvider.send({ prompt: veryLongPrompt, input: {} }, {});
    expect(result.content).toContain("MANUAL EXPORT");
    expect(result.content.length).toBeGreaterThan(0);
  });
  it("shows correct character count in metadata for long prompts", async () => {
    const length = 50_000;
    const result = await manualExportProvider.send({ prompt: "x".repeat(length), input: {} }, {});
    expect(result.content).toContain(`${length.toLocaleString()} characters`);
  });
  it("handles prompts at exactly the 30k boundary", async () => {
    const exactPrompt = "x".repeat(30_000);
    const result = await manualExportProvider.send({ prompt: exactPrompt, input: {} }, {});
    expect(result.content).not.toContain("⚠️ NOTE"); // not over 30k, exactly at it
  });
 });
 // --- Unicode and special characters ---
 describe("unicode and special characters", () => {
  it("preserves Japanese characters in prompt", async () => {
    const result = await manualExportProvider.send(
      { prompt: "こんにちは世界", input: {} },
      {},
    );
    expect(result.content).toContain("こんにちは世界");
  });
  it("preserves emoji in prompt", async () => {
    const result = await manualExportProvider.send(
      { prompt: "🚀 Launch plan 🎯", input: {} },
      {},
    );
    expect(result.content).toContain("🚀");
    expect(result.content).toContain("🎯");
  });
  it("preserves markdown code blocks in prompt", async () => {
    const codePrompt = "```js\nconst x = 1;\n```";
    const result = await manualExportProvider.send(
      { prompt: codePrompt, input: {} },
      {},
    );
    expect(result.content).toContain("```js");
    expect(result.content).toContain("const x = 1;");
  });
  it("preserves JSON in prompt", async () => {
    const jsonPrompt = '{"key": "value", "nested": {"a": 1}}';
    const result = await manualExportProvider.send(
      { prompt: jsonPrompt, input: {} },
      {},
    );
    expect(result.content).toContain('"key"');
    expect(result.content).toContain('"value"');
  });
  it("preserves special HTML-like characters", async () => {
    const htmlPrompt = '<script>alert("xss")</script>';
    const result = await manualExportProvider.send(
      { prompt: htmlPrompt, input: {} },
      {},
    );
    expect(result.content).toContain('<script>');
    expect(result.content).toContain('"xss"');
  });
 });
 // --- Empty / edge cases ---
 describe("empty and edge case handling", () => {
  it("returns warning content when prompt is empty string", async () => {
    const result = await manualExportProvider.send({ prompt: "", input: {} }, {});
    expect(result.content).toContain("received no prompt to export");
  });
  it("returns warning content when prompt field is missing from request", async () => {
    const result = await manualExportProvider.send({}, {});
    expect(result.content).toContain("received no prompt to export");
  });
  it("returns warning content when request is null", async () => {
    const result = await manualExportProvider.send(null, {});
    expect(result.content).toContain("received no prompt to export");
  });
  it("returns warning content when request is undefined", async () => {
    const result = await manualExportProvider.send(undefined, {});
    expect(result.content).toContain("received no prompt to export");
  });
  it("handles null config gracefully", async () => {
    const result = await manualExportProvider.send({ prompt: "test" }, null);
    expect(result.content).toContain("MANUAL EXPORT");
  });
  it("handles undefined config gracefully", async () => {
    const result = await manualExportProvider.send({ prompt: "test" }, undefined);
    expect(result.content).toContain("MANUAL EXPORT");
  });
  it("handles single-line prompt without newlines", async () => {
    const result = await manualExportProvider.send(
      { prompt: "single line prompt" },
      {},
    );
    expect(result.content).toContain("│ single line prompt");
  });
  it("handles prompts with only whitespace lines", async () => {
    const wsPrompt = "\n\n   \n\t\n";
    const result = await manualExportProvider.send({ prompt: wsPrompt }, {});
    expect(result.content).toContain("MANUAL EXPORT");
  });
  it("preserves tab characters in prompt", async () => {
    const tabPrompt = "first\tsecond\tthird";
    const result = await manualExportProvider.send(
      { prompt: tabPrompt },
      {},
    );
    expect(result.content).toContain(tabPrompt);
  });
  it("preserves newlines within the copy box (each line as │)", async () => {
    const nlPrompt = "line1\nline2\nline3";
    const result = await manualExportProvider.send({ prompt: nlPrompt }, {});
    // Each line should be wrapped with │ prefix
    expect(result.content).toContain("│ line1");
    expect(result.content).toContain("│ line2");
    expect(result.content).toContain("│ line3");
  });
 });
 // --- Provider contract compliance ---
 describe("provider contract compliance", () => {
  it("returns a Promise (async function)", async () => {
    const result = manualExportProvider.send({ prompt: "test" }, {});
    expect(result).toBeInstanceOf(Promise);
    await result; // don't leave unhandled promise
  });
  it("content is always a string, never null or object", async () => {
    const result = await manualExportProvider.send(
      { prompt: "test" },
      {},
    );
    expect(typeof result.content).toBe("string");
    expect(result.content).not.toBeNull();
    expect(result.content).not.toBeInstanceOf(Object);
  });
  it("content does not contain raw JSON (is text output)", async () => {
    const result = await manualExportProvider.send(
      { prompt: '{"json": "in prompt"}' },
      {},
    );
    // The JSON string should appear in the │ wrapped lines, not as a top-level JSON object
    expect(result.content).not.toBe("{" + '"content":"...' + "}");
  });
  it("always resolves (never rejects) for valid inputs", async () => {
    const testCases = [
      { prompt: "hi" },
      { prompt: "" },
      {},
      null,
    ];
    for (const tc of testCases) {
      await expect(manualExportProvider.send(tc, {})).resolves.toBeDefined();
    }
  });
  it("is idempotent — same input always produces same output", async () => {
    const inputs = [
      { prompt: "prompt1", input: { question: "q1" } },
      { prompt: "prompt2\nmultiline" },
      {},
    ];
    for (const input of inputs) {
      const r1 = await manualExportProvider.send(input, {});
      const r2 = await manualExportProvider.send({ ...input }, {});
      expect(r1.content).toBe(r2.content);
    }
  });
 });
 // --- Integration: separator lines ---
 describe("separator formatting", () => {
  it("uses ══ as top and bottom border characters", async () => {
    const result = await manualExportProvider.send({ prompt: "test" }, {});
    // Count border lines — should have exactly 2 (top and bottom)
    const match = result.content.match(/═+/g);
    expect(match).not.toBeNull();
    expect(match.length).toBeGreaterThanOrEqual(2);
  });
  it("has matching top and bottom separator blocks", async () => {
    const result = await manualExportProvider.send({ prompt: "test" }, {});
    const lines = result.content.split("\n");
    expect(lines[0]).toMatch(/═+/);
    expect(lines[lines.length - 1]).toMatch(/═+/);
    // Top and bottom separators should be identical length
    expect(lines[0].length).toBe(lines[lines.length - 1].length);
  });
  it("includes correct number of sections (header, copy box, instructions, metadata, footer)", async () => {
    const result = await manualExportProvider.send({ prompt: "test" }, {});
    expect(result.content).toContain("MANUAL EXPORT");
    expect(result.content).toContain("COPY THIS PROMPT");
    expect(result.content).toContain("INSTRUCTIONS");
    expect(result.content).toContain("METADATA");
    expect(result.content).toContain("advisory output only");
  });
 });
 // --- Repeatability ---
 describe("repeatability", () => {
  it("creates identical providers for same config each time", async () => {
    const results = [];
    for (let i = 0; i < 10; i++) {
      const r = await manualExportProvider.send({ prompt: "test" }, {});
      results.push(r.content);
    }
    expect(results.every((c) => c === results[0])).toBe(true);
  });
  it("does not share mutable state between send calls", async () => {
    const r1 = await manualExportProvider.send({ prompt: "call1" }, {});
    const r2 = await manualExportProvider.send({ prompt: "call2" }, {});
    expect(r1.content).not.toContain("call2");
    expect(r2.content).not.toContain("call1");
  });
 });
 // --- Visual structure validation ---
 describe("visual structure", () => {
  it("copy box has equal left (┌) and right (┐/└/┘) corners", async () => {
    const result = await manualExportProvider.send({ prompt: "test" }, {});
    expect(result.content).toContain("┌");
    expect(result.content).toContain("┐");
    expect(result.content).toContain("└");
    expect(result.content).toContain("┘");
  });
  it("copy box content lines all start with │", async () => {
    const result = await manualExportProvider.send({ prompt: "line1\nline2" }, {});
    const lines = result.content.split("\n");
    // Find the lines between ┌ and ┘ (the copy box content)
    let inBox = false;
    for (const line of lines) {
      if (line.includes("┌─")) {
        inBox = true;
        continue;
      }
      if (line.includes("└─")) {
        inBox = false;
        continue;
      }
      if (inBox && !line.includes("📋")) {
        // Content lines inside box should start with │
        expect(line.startsWith("│ ")).toBe(true);
      }
    }
  });
  it("instructions section lists exactly 5 numbered steps", async () => {
    const result = await manualExportProvider.send({ prompt: "test" }, {});
    const instructionsMatch = result.content.match(/📝 INSTRUCTIONS:\n([\s\S]*?)(?=\n\n|$)/);
    expect(instructionsMatch).not.toBeNull();
    const stepLines = instructionsMatch[1].trim().split("\n").filter((l) => /^\d+\./.test(l.trim()));
    expect(stepLines.length).toBe(5);
  });
  it("tool-specific content varies by detected tool", async () => {
    const resultAsk = await manualExportProvider.send(
      { prompt: "t", input: { question: "q" } },
      {},
    );
    const resultDebug = await manualExportProvider.send(
      { prompt: "t", input: { logs: "err" } },
      {},
    );
    expect(resultAsk.content).toContain("ask_chatgpt");
    expect(resultDebug.content).toContain("debug_issue");
    expect(resultAsk.content).not.toContain("debug_issue");
    expect(resultDebug.content).not.toContain("ask_chatgpt");
  });
 });
@@ -0,0 +1,274 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 // Use module-level mock objects that we can mutate between tests.
 // vi.mock() hoists to top-of-file, so these functions are set once and
 // their closure captures persist across the whole test file execution.
 // We reset call history in beforeEach but leave impl as-is (or update per-test).
 const _impl = { client: null, send: null };
 function createOpenAIClientMock(config) {
  if (_impl.client) return _impl.client(config);
  return { apiKey: config?.openaiApiKey || "default-key" };
 }
 async function sendOpenAIResponseMock(client, params) {
  if (_impl.send) return _impl.send(client, params);
  return { content: "mocked response from openaiProvider.send" };
 }
 vi.mock("../../src/openai/client.js", () => ({
  createOpenAIClient: createOpenAIClientMock,
 }));
 vi.mock("../../src/openai/responses.js", () => ({
  sendOpenAIResponse: sendOpenAIResponseMock,
 }));
 const { openaiProvider } = await import("../../src/providers/openai.js");
 function resetImpl() {
  _impl.client = null;
  _impl.send = null;
 }
 describe("openaiProvider.send", () => {
  beforeEach(resetImpl);
  it("calls createOpenAIClient with the full config", async () => {
    const config = { openaiApiKey: "sk-test", openaiModel: "gpt-5.1" };
    let capturedConfig = null;
    _impl.client = (cfg) => { capturedConfig = cfg; return { apiKey: cfg?.openaiApiKey }; };
    await openaiProvider.send("test input", config);
    expect(capturedConfig).toBe(config);
  });
  it("passes input as system message in the requests array", async () => {
    _impl.send = async (client, params) => {
      expect(params.input).toEqual([{ role: "system", content: "hello world" }]);
      return { content: "ok" };
    };
    await openaiProvider.send("hello world", { openaiApiKey: "sk-test" });
  });
  it("passes model from config", async () => {
    _impl.send = async (client, params) => {
      expect(params.model).toBe("gpt-5.1-preview");
      return { content: "ok" };
    };
    await openaiProvider.send("test", { openaiApiKey: "sk-test", openaiModel: "gpt-5.1-preview" });
  });
  it("passes temperature from config", async () => {
    _impl.send = async (client, params) => {
      expect(params.temperature).toBe(0.7);
      return { content: "ok" };
    };
    await openaiProvider.send("test", { openaiApiKey: "sk-test", temperature: 0.7 });
  });
  it("passes maxOutputTokens from config", async () => {
    _impl.send = async (client, params) => {
      expect(params.maxOutputTokens).toBe(4096);
      return { content: "ok" };
    };
    await openaiProvider.send("test", { openaiApiKey: "sk-test", maxOutputTokens: 4096 });
  });
  it("returns { content } from sendOpenAIResponse result", async () => {
    _impl.send = async () => ({ content: "hello AI" });
    const config = { openaiApiKey: "sk-test" };
    const result = await openaiProvider.send("test input", config);
    expect(result).toEqual({ content: "hello AI" });
  });
  it("calls createOpenAIClient before sendOpenAIResponse (order)", async () => {
    const callOrder = [];
    _impl.client = (cfg) => { callOrder.push("client"); return { apiKey: cfg?.openaiApiKey }; };
    _impl.send = async () => { callOrder.push("send"); return { content: "ok" }; };
    await openaiProvider.send("test", { openaiApiKey: "sk-test" });
    expect(callOrder).toEqual(["client", "send"]);
  });
  it("passes client as first arg to sendOpenAIResponse", async () => {
    _impl.send = async (client, params) => {
      expect(client.apiKey).toBe("sk-test");
      return { content: "ok" };
    };
    await openaiProvider.send("test", { openaiApiKey: "sk-test" });
  });
  it("creates a new client on each send call (no reuse)", async () => {
    let count = 0;
    _impl.client = () => { count++; return { apiKey: "sk-test" }; };
    const config = { openaiApiKey: "sk-test" };
    await openaiProvider.send("test 1", config);
    await openaiProvider.send("test 2", config);
    expect(count).toBe(2);
  });
  it("returns the raw content string wrapped in { content } object", async () => {
    _impl.send = async () => ({ content: "raw AI output" });
    const config = { openaiApiKey: "sk-test" };
    const result = await openaiProvider.send("test", config);
    expect(result.content).toBe("raw AI output");
  });
  it("works with empty input string", async () => {
    _impl.send = async (client, params) => {
      expect(params.input).toEqual([{ role: "system", content: "" }]);
      return { content: "ok" };
    };
    await openaiProvider.send("", { openaiApiKey: "sk-test" });
  });
  it("works with multi-line input", async () => {
    const multiline = "line 1\nline 2\nline 3";
    _impl.send = async (client, params) => {
      expect(params.input).toEqual([{ role: "system", content: multiline }]);
      return { content: "ok" };
    };
    await openaiProvider.send(multiline, { openaiApiKey: "sk-test" });
  });
  it("uses undefined values when config fields are missing", async () => {
    _impl.send = async (client, params) => {
      expect(params.model).toBeUndefined();
      expect(params.temperature).toBeUndefined();
      expect(params.maxOutputTokens).toBeUndefined();
      return { content: "ok" };
    };
    await openaiProvider.send("test", { openaiApiKey: "sk-test" });
  });
  it("throws when createOpenAIClient throws", async () => {
    _impl.client = () => { throw new Error("No API key"); };
    const config = {};
    await expect(openaiProvider.send("test", config)).rejects.toThrow("No API key");
  });
  it("passes through sendOpenAIResponse errors", async () => {
    _impl.send = async () => { throw new Error("API error"); };
    const config = { openaiApiKey: "sk-test" };
    await expect(openaiProvider.send("test", config)).rejects.toThrow("API error");
  });
  it("is idempotent — same input produces same call pattern", async () => {
    let capturedModel, capturedContent;
    _impl.send = async (client, params) => {
      capturedModel = params.model;
      capturedContent = params.input[0].content;
      return { content: "ok" };
    };
    await openaiProvider.send("identical input", { openaiApiKey: "sk-test", openaiModel: "gpt-5.1" });
    expect(capturedModel).toBe("gpt-5.1");
    expect(capturedContent).toBe("identical input");
  });
  it("handles special characters in input", async () => {
    const specialInput = '<script>alert("xss")</script>';
    _impl.send = async (client, params) => {
      expect(params.input[0].content).toBe(specialInput);
      return { content: "ok" };
    };
    await openaiProvider.send(specialInput, { openaiApiKey: "sk-test" });
  });
  it("handles unicode in input", async () => {
    const unicodeInput = "こんにちは世界 🌍";
    _impl.send = async (client, params) => {
      expect(params.input[0].content).toBe(unicodeInput);
      return { content: "ok" };
    };
    await openaiProvider.send(unicodeInput, { openaiApiKey: "sk-test" });
  });
  it("handles very long input", async () => {
    const longInput = "a".repeat(50000);
    _impl.send = async (client, params) => {
      expect(params.input[0].content).toBe(longInput);
      return { content: "ok" };
    };
    await openaiProvider.send(longInput, { openaiApiKey: "sk-test" });
  });
  it("does not modify the input parameter", async () => {
    const input = "original";
    _impl.send = async () => ({ content: "ok" });
    await openaiProvider.send(input, { openaiApiKey: "sk-test" });
    expect(input).toBe("original");
  });
  it("does not modify the config object", async () => {
    const config = { openaiApiKey: "sk-test", temperature: 0.2 };
    _impl.send = async () => ({ content: "ok" });
    await openaiProvider.send("test", config);
    expect(config.temperature).toBe(0.2);
  });
  it("returns mocked response when no custom impl set", async () => {
    const result = await openaiProvider.send("any input", { openaiApiKey: "sk-test" });
    expect(result.content).toBe("mocked response from openaiProvider.send");
  });
  it("works with null input", async () => {
    _impl.send = async (client, params) => {
      expect(params.input[0].content).toBeNull();
      return { content: "ok" };
    };
    await openaiProvider.send(null, { openaiApiKey: "sk-test" });
  });
  it("works with object input", async () => {
    const objInput = { foo: "bar" };
    _impl.send = async (client, params) => {
      expect(params.input[0].role).toBe("system");
      return { content: "ok" };
    };
    await openaiProvider.send(objInput, { openaiApiKey: "sk-test" });
  });
  it("passes the correct config through createOpenAIClient", async () => {
    let captured = null;
    _impl.client = (cfg) => { captured = cfg; return { apiKey: cfg.openaiApiKey }; };
    _impl.send = async () => ({ content: "ok" });
    const config = { openaiApiKey: "sk-specific", temperature: 0.9, maxOutputTokens: 8192 };
    await openaiProvider.send("test", config);
    expect(captured.openaiApiKey).toBe("sk-specific");
    expect(captured.temperature).toBe(0.9);
    expect(captured.maxOutputTokens).toBe(8192);
  });
  it("does not share state between send calls", async () => {
    let clientCalls = [];
    _impl.client = (cfg) => { clientCalls.push(cfg.openaiApiKey); return { apiKey: cfg.openaiApiKey }; };
    _impl.send = async () => ({ content: "ok" });
    await openaiProvider.send("test 1", { openaiApiKey: "key-1" });
    await openaiProvider.send("test 2", { openaiApiKey: "key-2" });
    expect(clientCalls).toEqual(["key-1", "key-2"]);
  });
  it("handles undefined config gracefully (no crashes)", async () => {
    _impl.send = async () => ({ content: "ok" });
    await openaiProvider.send("test", {});
  });
 });
@@ -0,0 +1,316 @@
 import { describe, it, expect, vi } from "vitest";
 import path from "node:path";
 import fs from "node:fs";
 import { SUPPORTED_PROVIDERS, buildEnvContent, buildClaudeConfig } from "../../scripts/setup.js";
 const TEST_TMP = path.join(process.cwd(), "test", "setup", ".tmp");
 function cleanup() {
  if (fs.existsSync(TEST_TMP)) {
    fs.rmSync(TEST_TMP, { recursive: true });
  }
 }
 describe("SUPPORTED_PROVIDERS constant", () => {
  it('contains exactly openai, manual, ollama', () => {
    expect(SUPPORTED_PROVIDERS).toEqual(["openai", "manual", "ollama"]);
  });
  it("is immutable (frozen Set or array)", () => {
    expect(Array.isArray(SUPPORTED_PROVIDERS)).toBe(true);
  });
 });
 // ── .env content generation ───────────────────────────────
 describe("buildEnvContent — OpenAI provider", () => {
  it("includes CHATGPT_MCP_PROVIDER=openai", () => {
    const result = buildEnvContent("openai", { openaiApiKey: "sk-test", openaiModel: null });
    expect(result).toContain("CHATGPT_MCP_PROVIDER=openai");
  });
  it("includes OPENAI_API_KEY when provided", () => {
    const result = buildEnvContent("openai", { openaiApiKey: "sk-mykey123", openaiModel: null });
    expect(result).toContain("OPENAI_API_KEY=sk-mykey123");
  });
  it("includes OPENAI_MODEL when provided", () => {
    const result = buildEnvContent("openai", { openaiApiKey: "sk-test", openaiModel: "gpt-4o" });
    expect(result).toContain("OPENAI_MODEL=gpt-4o");
  });
  it("omits OPENAI_MODEL key line when null/undefined", () => {
    const resultA = buildEnvContent("openai", { openaiApiKey: "sk-test", openaiModel: null });
    const lines = resultA.split("\n").map((l) => l.trim());
    expect(lines.filter((l) => l.startsWith("OPENAI_MODEL="))).toHaveLength(0);
    const resultB = buildEnvContent("openai", { openaiApiKey: "sk-test" });
    const linesB = resultB.split("\n").map((l) => l.trim());
    expect(linesB.filter((l) => l.startsWith("OPENAI_MODEL="))).toHaveLength(0);
  });
  it("includes empty OPENAI_API_KEY line when key is empty string", () => {
    const result = buildEnvContent("openai", { openaiApiKey: "", openaiModel: null });
    expect(result).toContain("OPENAI_API_KEY=");
  });
  it("ends with a trailing newline", () => {
    const result = buildEnvContent("openai", { openaiApiKey: "sk-test", openaiModel: null });
    expect(result.endsWith("\n")).toBe(true);
  });
  it("preserves existing non-conflicting .env content", () => {
    // Create a fake .env for this test
    const originalEnvPath = path.join(process.cwd(), ".env");
    fs.writeFileSync(originalEnvPath, "SOME_OTHER_VAR=hello\nLLM_TEMP=0.5\n", "utf-8");
    try {
      const result = buildEnvContent("openai", { openaiApiKey: "sk-test", openaiModel: null });
      expect(result).toContain("# ── Other settings (preserved from existing .env) ──");
      expect(result).toContain("SOME_OTHER_VAR=hello");
      expect(result).toContain("LLM_TEMP=0.5");
    } finally {
      fs.unlinkSync(originalEnvPath);
    }
  });
  it("filters out provider keys from existing .env content", () => {
    const originalEnvPath = path.join(process.cwd(), ".env");
    fs.writeFileSync(
      originalEnvPath,
      "CHATGPT_MCP_PROVIDER=ollama\nOPENAI_API_KEY=oldkey\nSOME_OTHER_VAR=hello\n",
      "utf-8"
    );
    try {
      const result = buildEnvContent("openai", { openaiApiKey: "sk-test", openaiModel: null });
      // CHATGPT_MCP_PROVIDER should NOT appear in the preserved section (only in the new header)
      const lines = result.split("\n");
      // The provider key should only be in the generated header, not in the preserved section
      const preservedSection = result.split("# ── Other settings")[1] || "";
      expect(preservedSection).not.toContain("CHATGPT_MCP_PROVIDER=ollama");
      expect(preservedSection).not.toContain("OPENAI_API_KEY=oldkey");
      expect(preservedSection).toContain("SOME_OTHER_VAR=hello");
    } finally {
      fs.unlinkSync(originalEnvPath);
    }
  });
  it("includes comment header for provider section", () => {
    const result = buildEnvContent("openai", { openaiApiKey: "sk-test", openaiModel: null });
    expect(result).toContain("# Chat provider:");
  });
 });
 describe("buildEnvContent — Manual provider", () => {
  it("includes CHATGPT_MCP_PROVIDER=manual", () => {
    const result = buildEnvContent("manual", {});
    expect(result).toContain("CHATGPT_MCP_PROVIDER=manual");
  });
  it("does not include any API key lines for manual provider", () => {
    const result = buildEnvContent("manual", {});
    expect(result).not.toContain("OPENAI_API_KEY=");
    expect(result).not.toContain("OLLAMA_BASE_URL=");
    expect(result).not.toContain("OLLAMA_MODEL=");
  });
  it("ends with a trailing newline", () => {
    const result = buildEnvContent("manual", {});
    expect(result.endsWith("\n")).toBe(true);
  });
 });
 describe("buildEnvContent — Ollama provider", () => {
  it("includes CHATGPT_MCP_PROVIDER=ollama", () => {
    const result = buildEnvContent("ollama", { ollamaBaseUrl: "http://localhost:11434", ollamaModel: "qwen3.6:35b-a3b" });
    expect(result).toContain("CHATGPT_MCP_PROVIDER=ollama");
  });
  it("includes OLLAMA_BASE_URL when provided", () => {
    const result = buildEnvContent("ollama", { ollamaBaseUrl: "http://custom:11434", ollamaModel: "qwen3.6:35b-a3b" });
    expect(result).toContain("OLLAMA_BASE_URL=http://custom:11434");
  });
  it("includes OLLAMA_MODEL when provided", () => {
    const result = buildEnvContent("ollama", { ollamaBaseUrl: "http://localhost:11434", ollamaModel: "qwen3.6:35b-a3b" });
    expect(result).toContain("OLLAMA_MODEL=qwen3.6:35b-a3b");
  });
  it("includes OLLAMA_TEMPERATURE when provided", () => {
    const result = buildEnvContent("ollama", { ollamaBaseUrl: "http://localhost:11434", ollamaModel: "qwen3.6:35b-a3b", ollamaTemperature: 0.7 });
    expect(result).toContain("OLLAMA_TEMPERATURE=0.7");
  });
  it("includes OLLAMA_TIMEOUT when provided", () => {
    const result = buildEnvContent("ollama", { ollamaBaseUrl: "http://localhost:11434", ollamaModel: "qwen3.6:35b-a3b", ollamaTimeout: 120 });
    expect(result).toContain("OLLAMA_TIMEOUT=120");
  });
  it("excludes Ollama keys from OpenAI config output", () => {
    const result = buildEnvContent("openai", { openaiApiKey: "sk-test" });
    expect(result).not.toContain("OLLAMA_BASE_URL=");
    expect(result).not.toContain("OLLAMA_MODEL=");
  });
  it("ends with a trailing newline", () => {
    const result = buildEnvContent("ollama", { ollamaBaseUrl: "http://localhost:11434", ollamaModel: "qwen3.6:35b-a3b" });
    expect(result.endsWith("\n")).toBe(true);
  });
 });
 // ── Claude config generation ──────────────────────────────
 describe("buildClaudeConfig", () => {
  it("returns valid JSON string", () => {
    const result = buildClaudeConfig();
    const parsed = JSON.parse(result);
    expect(parsed).toHaveProperty("mcpServers");
  });
  it("contains chatgpt-mcp server entry", () => {
    const result = buildClaudeConfig();
    const parsed = JSON.parse(result);
    expect(parsed.mcpServers).toHaveProperty("chatgpt-mcp");
  });
  it("sets command to npm", () => {
    const result = buildClaudeConfig();
    const parsed = JSON.parse(result);
    expect(parsed.mcpServers["chatgpt-mcp"].command).toBe("npm");
  });
  it('sets args to ["start"]', () => {
    const result = buildClaudeConfig();
    const parsed = JSON.parse(result);
    expect(parsed.mcpServers["chatgpt-mcp"].args).toEqual(["start"]);
  });
  it("is pretty-printed (not minified)", () => {
    const result = buildClaudeConfig();
    // Pretty-printed JSON contains newlines and indentation
    expect(result).toContain("\n");
    expect(result).toContain("  ");
  });
 });
 // ── Provider selection validation (via supported providers set) ──
 describe("Provider selection validation", () => {
  it("rejects invalid provider values (not in SUPPORTED_PROVIDERS)", () => {
    const invalid = ["anthropic", "claude", "", "OPENAI", "OpenAI", "ollama ", "1", "true"];
    invalid.forEach((val) => {
      expect(SUPPORTED_PROVIDERS).not.toContain(val);
    });
  });
  it("valid provider is in the supported list", () => {
    SUPPORTED_PROVIDERS.forEach((provider) => {
      expect(["openai", "manual", "ollama"]).toContain(provider);
    });
  });
 });
 // ── .env overwrite behavior (integration test via mock fs) ──
 describe(".env file overwrite confirmation", () => {
  it("generated content does not include secret key values in a masked form (key is written raw to file)", () => {
    // The key IS written to the file raw — this test confirms no masking happens at write time.
    // Masking only applies to display/console output.
    const result = buildEnvContent("openai", { openaiApiKey: "sk-secret-key-12345", openaiModel: null });
    expect(result).toContain("OPENAI_API_KEY=sk-secret-key-12345"); // written raw, masked only in display
  });
  it("does not include any Ollama setting keys in OpenAI config block", () => {
    const result = buildEnvContent("openai", { openaiApiKey: "sk-test" });
    expect(result).not.toMatch(/^OLLAMA_BASE_URL=/m);
    expect(result).not.toMatch(/^OLLAMA_MODEL=/m);
    expect(result).not.toMatch(/^OLLAMA_TEMPERATURE=/m);
    expect(result).not.toMatch(/^OLLAMA_TIMEOUT=/m);
  });
  it("generated content is deterministic (same input → same output)", () => {
    const config = { openaiApiKey: "sk-deterministic-test", openaiModel: "gpt-5.1" };
    const a = buildEnvContent("openai", config);
    const b = buildEnvContent("openai", config);
    expect(a).toBe(b);
  });
  it("rejecting write does not produce any file side effects (integration)", () => {
    // buildEnvContent never calls fs.writeFileSync — confirm .env is untouched.
    const envPath = path.join(process.cwd(), ".env");
    const existsBefore = fs.existsSync(envPath);
    const content = buildEnvContent("manual", {});
    expect(content).not.toBe("");
    expect(fs.existsSync(envPath)).toBe(existsBefore); // unchanged
  });
  it("accepting write would overwrite .env with the generated content (integration)", () => {
    const envPath = path.join(process.cwd(), ".env");
    const beforeExists = fs.existsSync(envPath);
    const originalContent = beforeExists ? fs.readFileSync(envPath, "utf-8") : null;
    try {
      // Simulate acceptance: write the generated content to .env
      const content = buildEnvContent("manual", {});
      fs.writeFileSync(envPath, content, "utf-8");
      expect(fs.readFileSync(envPath, "utf-8")).toBe(content);
      expect(fs.readFileSync(envPath, "utf-8")).toContain("CHATGPT_MCP_PROVIDER=manual");
    } finally {
      // Restore original state
      if (beforeExists && originalContent !== null) {
        fs.writeFileSync(envPath, originalContent, "utf-8");
      } else if (!beforeExists) {
        fs.unlinkSync(envPath);
      }
    }
  });
 });
 describe("Non-interactive terminal handling", () => {
  it("supports reading provider default from existing .env via getProviderDefault", () => {
    const envPath = path.join(process.cwd(), ".env");
    // Write a test .env with ollama provider
    fs.writeFileSync(envPath, "CHATGPT_MCP_PROVIDER=ollama\nOPENAI_API_KEY=\n", "utf-8");
    try {
      const content = buildEnvContent("openai", { openaiApiKey: "sk-test" });
      // The generated file should NOT contain the old ollama provider value
      expect(content).toContain("CHATGPT_MCP_PROVIDER=openai");
      expect(content).not.toContain("CHATGPT_MCP_PROVIDER=ollama");
    } finally {
      fs.unlinkSync(envPath);
    }
  });
  it("non-TTY detection works (process.stdin is readable)", () => {
    // The non-TTY check in setup.js is:
    // process.stdin.isTTY && typeof process.stdin.setRawMode === "function"
    // In tests, stdin may not be a TTY — verify we don't crash on setRawMode calls.
    expect(process.stdin).toBeDefined();
    expect(typeof process.stdin.setRawMode).not.toBe("function"); // non-TTY in vitest ✅
  });
 });
 describe("Secret masking and output safety", () => {
  it("generated .env content contains raw key (masking only applies to display)", () => {
    const result = buildEnvContent("openai", { openaiApiKey: "sk-secret-key-12345", openaiModel: null });
    expect(result).toContain("OPENAI_API_KEY=sk-secret-key-12345");
  });
  it("Claude config generation produces valid JSON", () => {
    const result = buildClaudeConfig();
    expect(() => JSON.parse(result)).not.toThrow();
    const parsed = JSON.parse(result);
    expect(parsed.mcpServers["chatgpt-mcp"].command).toBe("npm");
    expect(parsed.mcpServers["chatgpt-mcp"].args).toEqual(["start"]);
  });
  it("Claude config is idempotent (same output each call)", () => {
    const a = buildClaudeConfig();
    const b = buildClaudeConfig();
    expect(a).toBe(b);
  });
 });
@@ -1,23 +1,11 @@
 import { describe, it, expect, vi } from "vitest";
-
+import { handleArchitectureReview } from "../../src/tools/architecture-review.js";
 // Module-level mock capture for buildArchitectureReviewPrompt integration testing.
 const buildArchitectureReviewPromptCalls = [];
 vi.mock("../../src/prompts/architecture-review.js", async () => ({
  buildArchitectureReviewPrompt: vi.fn((input) => {
    buildArchitectureReviewPromptCalls.push(input);
    return "mocked architecture review prompt";
  }),
 }));
 // Import after the mock is registered (hoisted by vitest).
 const { handleArchitectureReview } = await import("../../src/tools/architecture-review.js");
 const mockConfig = {
  openaiApiKey: "sk-test-key",
  openaiModel: "gpt-5.1",
  temperature: 0.2,
-  maxOutputTokens: 2000,
+  maxOutputTokens: 4000,
  logLevel: "info",
  enableFileContext: false,
  contextDir: "./context",
@@ -28,22 +16,20 @@ const mockConfig = {
  redactSecrets: true,
 };
-function makeValidInput(question) {
+function makeValidInput(question, context) {
-  return { question };
+  return { question: question || "Review architecture", context: context || "x" };
 }
 // --- Success path ---
 describe("success path", () => {
  it("returns ok:true with answer on full happy flow", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("What architecture should we use?"), {
+    const result = await handleArchitectureReview(makeValidInput("Review architecture", "x"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
@@ -52,15 +38,13 @@ describe("success path", () => {
  });
  it("propagates budget warnings through to success result", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), {
+    const result = await handleArchitectureReview(makeValidInput("Review architecture", "x"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
@@ -72,52 +56,44 @@ describe("success path", () => {
 describe("validation failure", () => {
  it("returns structured error when question is missing", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview({}, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview({}, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
  it("short-circuits — no other deps called", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleArchitectureReview({ foo: "bar" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleArchitectureReview({ foo: "bar" }, { loadConfig, createProvider });
    expect(loadConfig).not.toHaveBeenCalled();
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("returns structured error when question is empty string", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview({ question: "" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview({ question: "", context: "x" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
  it("returns structured error when question is wrong type", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview({ question: 123 }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview({ question: 123, context: "x" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -128,82 +104,70 @@ describe("validation failure", () => {
 describe("config failure", () => {
  it("returns structured error when loadConfig throws", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toContain("OPENAI_API_KEY is missing");
  });
-  it("short-circuits — no client or response calls after config failure", async () => {
+  it("short-circuits — no provider or send calls after config failure", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("No key."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: OPENAI_API_KEY is missing.");
  });
 });
-// --- Budget failure (short-circuit before prompt/client) ---
+// --- Budget failure (short-circuit before prompt/provider) ---
 describe("budget failure", () => {
  it("returns structured error with budget warnings when input exceeds budget", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(Array.isArray(result.warnings)).toBe(true);
  });
-  it("short-circuits — no prompt built, no client created, no response sent", async () => {
+  it("short-circuits — no prompt built, no provider created, no send called", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes budget warnings through to the error result", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleArchitectureReview(
      { question: "x", context: "a".repeat(20) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(false);
@@ -211,81 +175,69 @@ describe("budget failure", () => {
  });
 });
-// --- Client creation failure ---
+// --- Provider creation failure ---
 describe("client creation failure", () => {
  it("returns structured error when createOpenAIClient throws", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
 describe("provider creation failure", () => {
  it("returns structured error when createProvider throws", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no response sent after client failure", async () => {
+  it("short-circuits — no send called after provider creation failure", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message unchanged", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: Invalid config.");
  });
 });
-// --- OpenAI failure (pass-through) ---
+// --- Provider send failure (pass-through) ---
-describe("OpenAI failure", () => {
+describe("provider send failure", () => {
  it("passes through err.message unchanged", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("API key invalid."));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("API key invalid."));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: API key invalid.");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no extra processing after API failure", async () => {
+  it("short-circuits — no extra processing after provider send failure", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("rate limit"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("rate limit"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: rate limit");
  });
  it("does not wrap or reformat the error", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: 429 Too Many Requests");
  });
 });
@@ -293,64 +245,35 @@ describe("OpenAI failure", () => {
 // --- Dependency call order ---
 describe("dependency call order", () => {
-  it("calls deps in correct order: config -> client -> response", async () => {
+  it("calls deps in correct order: config -> provider -> send", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const callLog = [];
    const loadConfig = vi.fn(() => { callLog.push("config"); return mockConfig; });
-    const createOpenAIClient = vi.fn(() => { callLog.push("client"); return { responses: { create: vi.fn() } }; });
+    const createProvider = vi.fn(() => { callLog.push("provider"); return { send: vi.fn().mockImplementation(async () => { callLog.push("send"); return { content: "OK" }; }) }; });
    const sendOpenAIResponse = vi.fn(async () => { callLog.push("response"); return { content: "OK" }; });
-    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(callLog).toEqual(["config", "client", "response"]);
+    expect(callLog).toEqual(["config", "provider", "send"]);
  });
 });
 // --- buildArchitectureReviewPrompt integration ---
 describe("buildArchitectureReviewPrompt integration", () => {
  it("calls buildArchitectureReviewPrompt and receives budget.input as argument", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
    await handleArchitectureReview(makeValidInput("test question"), {
      loadConfig, createOpenAIClient, sendOpenAIResponse,
    });
    // Verify buildArchitectureReviewPrompt was called (once) with the trimmed input from checkContextBudget.
    expect(buildArchitectureReviewPromptCalls.length).toBe(1);
    const captured = buildArchitectureReviewPromptCalls[0];
    expect(typeof captured).toBe("object");
    expect(captured.question).toBe("test question");
  });
 });
 // --- No throws escaping ---
 describe("no throws escaping", () => {
-  it("returns structured result when sendOpenAIResponse throws null", async () => {
+  it("returns structured result when send throws null", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(null);
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(null);
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
  it("returns structured result when loadConfig throws non-Error", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw "string error"; });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
@@ -360,16 +283,14 @@ describe("no throws escaping", () => {
 describe("warning propagation", () => {
  it("includes budget warnings in success result when budget passes with warnings", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleArchitectureReview(
      { question: "hi", context: "x".repeat(49) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(true);
@@ -377,14 +298,12 @@ describe("warning propagation", () => {
  });
  it("includes budget warnings in failure result when budget fails", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const emptyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => emptyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(Array.isArray(result.warnings)).toBe(true);
  });
@@ -394,13 +313,11 @@ describe("warning propagation", () => {
 describe("result shape", () => {
  it("returns exactly { ok, answer, warnings } on success", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["answer", "ok", "warnings"]);
    expect(result.ok).toBe(true);
    expect(typeof result.answer).toBe("string");
@@ -408,13 +325,11 @@ describe("result shape", () => {
  });
  it("returns exactly { ok, error, warnings } on failure", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["error", "ok", "warnings"]);
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
@@ -426,28 +341,24 @@ describe("result shape", () => {
 describe("short-circuit behavior", () => {
  it("stops at first failure without calling downstream deps", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("boom"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("boom"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).toHaveBeenCalledTimes(1);
+    expect(createProvider).toHaveBeenCalledTimes(1);
-    expect(sendOpenAIResponse).toHaveBeenCalledTimes(1);
+    expect(sendMock).toHaveBeenCalledTimes(1);
  });
  it("stops at config failure without calling downstream deps", async () => {
    buildArchitectureReviewPromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleArchitectureReview(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
 });
@@ -25,11 +25,11 @@ function makeValidInput(question) {
 describe("success path", () => {
  it("returns ok:true with answer on full happy flow", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleAskChatGpt(makeValidInput("What is 2+2?"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
@@ -40,15 +40,14 @@ describe("success path", () => {
  it("propagates budget warnings through to success result", async () => {
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleAskChatGpt(makeValidInput("hi"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
    // Budget warnings may or may not be present depending on exact input size vs budget.
    expect(Array.isArray(result.warnings)).toBe(true);
  });
 });
@@ -58,10 +57,10 @@ describe("success path", () => {
 describe("validation failure", () => {
  it("returns structured error when question is missing", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt({}, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt({}, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -69,21 +68,21 @@ describe("validation failure", () => {
  it("short-circuits — no other deps called", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleAskChatGpt({ foo: "bar" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleAskChatGpt({ foo: "bar" }, { loadConfig, createProvider });
    expect(loadConfig).not.toHaveBeenCalled();
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("returns structured error when question is empty string", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt({ question: "" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt({ question: "" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -91,10 +90,10 @@ describe("validation failure", () => {
  it("returns structured error when question is wrong type", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt({ question: 123 }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt({ question: 123 }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -106,70 +105,69 @@ describe("validation failure", () => {
 describe("config failure", () => {
  it("returns structured error when loadConfig throws", async () => {
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toContain("OPENAI_API_KEY is missing");
  });
-  it("short-circuits — no client or response calls after config failure", async () => {
+  it("short-circuits — no provider or send calls after config failure", async () => {
    const loadConfig = vi.fn(() => { throw new Error("No key."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message", async () => {
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: OPENAI_API_KEY is missing.");
  });
 });
-// --- Budget failure (short-circuit before prompt/client) ---
+// --- Budget failure (short-circuit before prompt/provider) ---
 describe("budget failure", () => {
  it("returns structured error with budget warnings when input exceeds budget", async () => {
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(Array.isArray(result.warnings)).toBe(true);
  });
-  it("short-circuits — no prompt built, no client created, no response sent", async () => {
+  it("short-circuits — no prompt built, no provider created, no send called", async () => {
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes budget warnings through to the error result", async () => {
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    // maxInputChars=0 forces rejection even with minimal input.
    const result = await handleAskChatGpt(
      { question: "x", context: "a".repeat(20) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(false);
@@ -177,69 +175,69 @@ describe("budget failure", () => {
  });
 });
-// --- Client creation failure ---
+// --- Provider creation failure ---
-describe("client creation failure", () => {
+describe("provider creation failure", () => {
-  it("returns structured error when createOpenAIClient throws", async () => {
+  it("returns structured error when createProvider throws", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no response sent after client failure", async () => {
+  it("short-circuits — no send called after provider creation failure", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message unchanged", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: Invalid config.");
  });
 });
-// --- OpenAI failure (pass-through) ---
+// --- Provider send failure (pass-through) ---
-describe("OpenAI failure", () => {
+describe("provider send failure", () => {
  it("passes through err.message unchanged", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("API key invalid."));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("API key invalid."));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: API key invalid.");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no extra processing after API failure", async () => {
+  it("short-circuits — no extra processing after provider send failure", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("rate limit"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("rate limit"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: rate limit");
  });
  it("does not wrap or reformat the error", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: 429 Too Many Requests");
  });
 });
@@ -247,36 +245,35 @@ describe("OpenAI failure", () => {
 // --- Dependency call order ---
 describe("dependency call order", () => {
-  it("calls deps in correct order: config -> client -> response", async () => {
+  it("calls deps in correct order: config -> provider -> send", async () => {
    const callLog = [];
    const loadConfig = vi.fn(() => { callLog.push("config"); return mockConfig; });
-    const createOpenAIClient = vi.fn(() => { callLog.push("client"); return { responses: { create: vi.fn() } }; });
+    const createProvider = vi.fn(() => { callLog.push("provider"); return { send: vi.fn().mockImplementation(async () => { callLog.push("send"); return { content: "OK" }; }) }; });
    const sendOpenAIResponse = vi.fn(async () => { callLog.push("response"); return { content: "OK" }; });
-    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(callLog).toEqual(["config", "client", "response"]);
+    expect(callLog).toEqual(["config", "provider", "send"]);
  });
 });
 // --- No throws escaping ---
 describe("no throws escaping", () => {
-  it("returns structured result when sendOpenAIResponse throws null", async () => {
+  it("returns structured result when send throws null", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(null);
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(null);
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
  it("returns structured result when loadConfig throws non-Error", async () => {
    const loadConfig = vi.fn(() => { throw "string error"; });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
@@ -288,13 +285,12 @@ describe("warning propagation", () => {
  it("includes budget warnings in success result when budget passes with warnings", async () => {
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    // question("hi") + context ~49 chars should hit the budget trim.
    const result = await handleAskChatGpt(
      { question: "hi", context: "x".repeat(49) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(true);
@@ -304,10 +300,10 @@ describe("warning propagation", () => {
  it("includes budget warnings in failure result when budget fails", async () => {
    const emptyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => emptyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(Array.isArray(result.warnings)).toBe(true);
  });
@@ -318,10 +314,10 @@ describe("warning propagation", () => {
 describe("result shape", () => {
  it("returns exactly { ok, answer, warnings } on success", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["answer", "ok", "warnings"]);
    expect(result.ok).toBe(true);
    expect(typeof result.answer).toBe("string");
@@ -330,10 +326,10 @@ describe("result shape", () => {
  it("returns exactly { ok, error, warnings } on failure", async () => {
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["error", "ok", "warnings"]);
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
@@ -346,23 +342,23 @@ describe("result shape", () => {
 describe("short-circuit behavior", () => {
  it("stops at first failure without calling downstream deps", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("boom"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("boom"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).toHaveBeenCalledTimes(1);
+    expect(createProvider).toHaveBeenCalledTimes(1);
-    expect(sendOpenAIResponse).toHaveBeenCalledTimes(1);
+    expect(sendMock).toHaveBeenCalledTimes(1);
  });
  it("stops at config failure without calling downstream deps", async () => {
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleAskChatGpt(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
 });
@@ -1,23 +1,11 @@
 import { describe, it, expect, vi } from "vitest";
-
+import { handleDebugIssue } from "../../src/tools/debug-issue.js";
 // Module-level mock capture for buildDebugIssuePrompt integration testing.
 const buildDebugIssuePromptCalls = [];
 vi.mock("../../src/prompts/debug-issue.js", async () => ({
  buildDebugIssuePrompt: vi.fn((input) => {
    buildDebugIssuePromptCalls.push(input);
    return "mocked debug issue prompt";
  }),
 }));
 // Import after the mock is registered (hoisted by vitest).
 const { handleDebugIssue } = await import("../../src/tools/debug-issue.js");
 const mockConfig = {
  openaiApiKey: "sk-test-key",
  openaiModel: "gpt-5.1",
  temperature: 0.2,
-  maxOutputTokens: 2000,
+  maxOutputTokens: 4000,
  logLevel: "info",
  enableFileContext: false,
  contextDir: "./context",
@@ -28,22 +16,20 @@ const mockConfig = {
  redactSecrets: true,
 };
-function makeValidInput(question) {
+function makeValidInput(description, context) {
-  return { question };
+  return { question: description || "App crashes on login", context: context || "x" };
 }
 // --- Success path ---
 describe("success path", () => {
  it("returns ok:true with answer on full happy flow", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("Debug my issue"), {
+    const result = await handleDebugIssue(makeValidInput("App crashes on login", "x"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
@@ -52,15 +38,13 @@ describe("success path", () => {
  });
  it("propagates budget warnings through to success result", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), {
+    const result = await handleDebugIssue(makeValidInput("App crashes on login", "x"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
@@ -71,53 +55,56 @@ describe("success path", () => {
 // --- Validation failure (short-circuit before config) ---
 describe("validation failure", () => {
-  it("returns structured error when question is missing", async () => {
+  it("returns structured error when description is missing", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue({}, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue({}, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
  it("returns structured error when question is missing", async () => {
    const loadConfig = vi.fn();
    const sendMock = vi.fn();
    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleDebugIssue({}, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
  it("short-circuits — no other deps called", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleDebugIssue({ foo: "bar" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleDebugIssue({ foo: "bar" }, { loadConfig, createProvider });
    expect(loadConfig).not.toHaveBeenCalled();
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
-  it("returns structured error when question is empty string", async () => {
+  it("returns structured error when description is empty string", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue({ question: "" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue({ question: "", context: "x" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
-  it("returns structured error when question is wrong type", async () => {
+  it("returns structured error when description is wrong type", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue({ question: 123 }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue({ question: 123, context: "x" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -128,82 +115,70 @@ describe("validation failure", () => {
 describe("config failure", () => {
  it("returns structured error when loadConfig throws", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toContain("OPENAI_API_KEY is missing");
  });
-  it("short-circuits — no client or response calls after config failure", async () => {
+  it("short-circuits — no provider or send calls after config failure", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("No key."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: OPENAI_API_KEY is missing.");
  });
 });
-// --- Budget failure (short-circuit before prompt/client) ---
+// --- Budget failure (short-circuit before prompt/provider) ---
 describe("budget failure", () => {
  it("returns structured error with budget warnings when input exceeds budget", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(Array.isArray(result.warnings)).toBe(true);
  });
-  it("short-circuits — no prompt built, no client created, no response sent", async () => {
+  it("short-circuits — no prompt built, no provider created, no send called", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes budget warnings through to the error result", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleDebugIssue(
      { question: "x", context: "a".repeat(20) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(false);
@@ -211,81 +186,69 @@ describe("budget failure", () => {
  });
 });
-// --- Client creation failure ---
+// --- Provider creation failure ---
 describe("client creation failure", () => {
  it("returns structured error when createOpenAIClient throws", async () => {
    buildDebugIssuePromptCalls.length = 0;
 describe("provider creation failure", () => {
  it("returns structured error when createProvider throws", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no response sent after client failure", async () => {
+  it("short-circuits — no send called after provider creation failure", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message unchanged", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: Invalid config.");
  });
 });
-// --- OpenAI failure (pass-through) ---
+// --- Provider send failure (pass-through) ---
-describe("OpenAI failure", () => {
+describe("provider send failure", () => {
  it("passes through err.message unchanged", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("API key invalid."));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("API key invalid."));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: API key invalid.");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no extra processing after API failure", async () => {
+  it("short-circuits — no extra processing after provider send failure", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("rate limit"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("rate limit"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: rate limit");
  });
  it("does not wrap or reformat the error", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: 429 Too Many Requests");
  });
 });
@@ -293,64 +256,35 @@ describe("OpenAI failure", () => {
 // --- Dependency call order ---
 describe("dependency call order", () => {
-  it("calls deps in correct order: config -> client -> response", async () => {
+  it("calls deps in correct order: config -> provider -> send", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const callLog = [];
    const loadConfig = vi.fn(() => { callLog.push("config"); return mockConfig; });
-    const createOpenAIClient = vi.fn(() => { callLog.push("client"); return { responses: { create: vi.fn() } }; });
+    const createProvider = vi.fn(() => { callLog.push("provider"); return { send: vi.fn().mockImplementation(async () => { callLog.push("send"); return { content: "OK" }; }) }; });
    const sendOpenAIResponse = vi.fn(async () => { callLog.push("response"); return { content: "OK" }; });
-    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(callLog).toEqual(["config", "client", "response"]);
+    expect(callLog).toEqual(["config", "provider", "send"]);
  });
 });
 // --- buildDebugIssuePrompt integration ---
 describe("buildDebugIssuePrompt integration", () => {
  it("calls buildDebugIssuePrompt and receives budget.input as argument", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
    await handleDebugIssue(makeValidInput("test question"), {
      loadConfig, createOpenAIClient, sendOpenAIResponse,
    });
    // Verify buildDebugIssuePrompt was called (once) with the trimmed input from checkContextBudget.
    expect(buildDebugIssuePromptCalls.length).toBe(1);
    const captured = buildDebugIssuePromptCalls[0];
    expect(typeof captured).toBe("object");
    expect(captured.question).toBe("test question");
  });
 });
 // --- No throws escaping ---
 describe("no throws escaping", () => {
-  it("returns structured result when sendOpenAIResponse throws null", async () => {
+  it("returns structured result when send throws null", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(null);
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(null);
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
  it("returns structured result when loadConfig throws non-Error", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw "string error"; });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
@@ -360,16 +294,14 @@ describe("no throws escaping", () => {
 describe("warning propagation", () => {
  it("includes budget warnings in success result when budget passes with warnings", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleDebugIssue(
      { question: "hi", context: "x".repeat(49) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(true);
@@ -377,14 +309,12 @@ describe("warning propagation", () => {
  });
  it("includes budget warnings in failure result when budget fails", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const emptyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => emptyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(Array.isArray(result.warnings)).toBe(true);
  });
@@ -394,13 +324,11 @@ describe("warning propagation", () => {
 describe("result shape", () => {
  it("returns exactly { ok, answer, warnings } on success", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["answer", "ok", "warnings"]);
    expect(result.ok).toBe(true);
    expect(typeof result.answer).toBe("string");
@@ -408,13 +336,11 @@ describe("result shape", () => {
  });
  it("returns exactly { ok, error, warnings } on failure", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["error", "ok", "warnings"]);
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
@@ -426,28 +352,24 @@ describe("result shape", () => {
 describe("short-circuit behavior", () => {
  it("stops at first failure without calling downstream deps", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("boom"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("boom"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).toHaveBeenCalledTimes(1);
+    expect(createProvider).toHaveBeenCalledTimes(1);
-    expect(sendOpenAIResponse).toHaveBeenCalledTimes(1);
+    expect(sendMock).toHaveBeenCalledTimes(1);
  });
  it("stops at config failure without calling downstream deps", async () => {
    buildDebugIssuePromptCalls.length = 0;
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleDebugIssue(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
 });
@@ -5,7 +5,7 @@ const mockConfig = {
  openaiApiKey: "sk-test-key",
  openaiModel: "gpt-5.1",
  temperature: 0.2,
-  maxOutputTokens: 2000,
+  maxOutputTokens: 4000,
  logLevel: "info",
  enableFileContext: false,
  contextDir: "./context",
@@ -16,8 +16,8 @@ const mockConfig = {
  redactSecrets: true,
 };
-function makeValidInput(question) {
+function makeValidInput(question, context) {
-  return { question };
+  return { question: question || "Review this code", context: context || "x" };
 }
 // --- Success path ---
@@ -25,11 +25,11 @@ function makeValidInput(question) {
 describe("success path", () => {
  it("returns ok:true with answer on full happy flow", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("Review my code"), {
+    const result = await handleReviewCode(makeValidInput("Review this code", "x"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
@@ -40,11 +40,11 @@ describe("success path", () => {
  it("propagates budget warnings through to success result", async () => {
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), {
+    const result = await handleReviewCode(makeValidInput("Review this code", "x"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
@@ -57,10 +57,10 @@ describe("success path", () => {
 describe("validation failure", () => {
  it("returns structured error when question is missing", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode({}, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode({}, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -68,21 +68,21 @@ describe("validation failure", () => {
  it("short-circuits — no other deps called", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewCode({ foo: "bar" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewCode({ foo: "bar" }, { loadConfig, createProvider });
    expect(loadConfig).not.toHaveBeenCalled();
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("returns structured error when question is empty string", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode({ question: "" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode({ question: "", context: "x" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -90,10 +90,10 @@ describe("validation failure", () => {
  it("returns structured error when question is wrong type", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode({ question: 123 }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode({ question: 123, context: "x" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -105,69 +105,69 @@ describe("validation failure", () => {
 describe("config failure", () => {
  it("returns structured error when loadConfig throws", async () => {
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toContain("OPENAI_API_KEY is missing");
  });
-  it("short-circuits — no client or response calls after config failure", async () => {
+  it("short-circuits — no provider or send calls after config failure", async () => {
    const loadConfig = vi.fn(() => { throw new Error("No key."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message", async () => {
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: OPENAI_API_KEY is missing.");
  });
 });
-// --- Budget failure (short-circuit before prompt/client) ---
+// --- Budget failure (short-circuit before prompt/provider) ---
 describe("budget failure", () => {
  it("returns structured error with budget warnings when input exceeds budget", async () => {
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(Array.isArray(result.warnings)).toBe(true);
  });
-  it("short-circuits — no prompt built, no client created, no response sent", async () => {
+  it("short-circuits — no prompt built, no provider created, no send called", async () => {
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes budget warnings through to the error result", async () => {
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleReviewCode(
      { question: "x", context: "a".repeat(20) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(false);
@@ -175,69 +175,69 @@ describe("budget failure", () => {
  });
 });
-// --- Client creation failure ---
+// --- Provider creation failure ---
-describe("client creation failure", () => {
+describe("provider creation failure", () => {
-  it("returns structured error when createOpenAIClient throws", async () => {
+  it("returns structured error when createProvider throws", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no response sent after client failure", async () => {
+  it("short-circuits — no send called after provider creation failure", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message unchanged", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: Invalid config.");
  });
 });
-// --- OpenAI failure (pass-through) ---
+// --- Provider send failure (pass-through) ---
-describe("OpenAI failure", () => {
+describe("provider send failure", () => {
  it("passes through err.message unchanged", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("API key invalid."));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("API key invalid."));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: API key invalid.");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no extra processing after API failure", async () => {
+  it("short-circuits — no extra processing after provider send failure", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("rate limit"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("rate limit"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: rate limit");
  });
  it("does not wrap or reformat the error", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: 429 Too Many Requests");
  });
 });
@@ -245,60 +245,35 @@ describe("OpenAI failure", () => {
 // --- Dependency call order ---
 describe("dependency call order", () => {
-  it("calls deps in correct order: config -> client -> response", async () => {
+  it("calls deps in correct order: config -> provider -> send", async () => {
    const callLog = [];
    const loadConfig = vi.fn(() => { callLog.push("config"); return mockConfig; });
-    const createOpenAIClient = vi.fn(() => { callLog.push("client"); return { responses: { create: vi.fn() } }; });
+    const createProvider = vi.fn(() => { callLog.push("provider"); return { send: vi.fn().mockImplementation(async () => { callLog.push("send"); return { content: "OK" }; }) }; });
    const sendOpenAIResponse = vi.fn(async () => { callLog.push("response"); return { content: "OK" }; });
-    await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(callLog).toEqual(["config", "client", "response"]);
+    expect(callLog).toEqual(["config", "provider", "send"]);
  });
 });
 // --- buildReviewCodePrompt called with correct input ---
 describe("buildReviewCodePrompt integration", () => {
  it("calls buildReviewCodePrompt with budget.input (trimmed data)", async () => {
    const loadConfig = vi.fn(() => mockConfig);
    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
    // Spy on buildReviewCodePrompt import by capturing the prompt arg.
    const promptCapture = [];
    const patchedSend = vi.fn(async (client, params) => {
      promptCapture.push(params.input[0].content);
      return { content: "OK" };
    });
    await handleReviewCode(makeValidInput("test question"), {
      loadConfig, createOpenAIClient, sendOpenAIResponse: patchedSend,
    });
    expect(promptCapture.length).toBe(1);
    expect(typeof promptCapture[0]).toBe("string");
  });
 });
 // --- No throws escaping ---
 describe("no throws escaping", () => {
-  it("returns structured result when sendOpenAIResponse throws null", async () => {
+  it("returns structured result when send throws null", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(null);
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(null);
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
  it("returns structured result when loadConfig throws non-Error", async () => {
    const loadConfig = vi.fn(() => { throw "string error"; });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
@@ -310,12 +285,12 @@ describe("warning propagation", () => {
  it("includes budget warnings in success result when budget passes with warnings", async () => {
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleReviewCode(
      { question: "hi", context: "x".repeat(49) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(true);
@@ -325,10 +300,10 @@ describe("warning propagation", () => {
  it("includes budget warnings in failure result when budget fails", async () => {
    const emptyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => emptyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(Array.isArray(result.warnings)).toBe(true);
  });
@@ -339,10 +314,10 @@ describe("warning propagation", () => {
 describe("result shape", () => {
  it("returns exactly { ok, answer, warnings } on success", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["answer", "ok", "warnings"]);
    expect(result.ok).toBe(true);
    expect(typeof result.answer).toBe("string");
@@ -351,10 +326,10 @@ describe("result shape", () => {
  it("returns exactly { ok, error, warnings } on failure", async () => {
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["error", "ok", "warnings"]);
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
@@ -367,23 +342,23 @@ describe("result shape", () => {
 describe("short-circuit behavior", () => {
  it("stops at first failure without calling downstream deps", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("boom"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("boom"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).toHaveBeenCalledTimes(1);
+    expect(createProvider).toHaveBeenCalledTimes(1);
-    expect(sendOpenAIResponse).toHaveBeenCalledTimes(1);
+    expect(sendMock).toHaveBeenCalledTimes(1);
  });
  it("stops at config failure without calling downstream deps", async () => {
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewCode(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewCode(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
 });
@@ -5,7 +5,7 @@ const mockConfig = {
  openaiApiKey: "sk-test-key",
  openaiModel: "gpt-5.1",
  temperature: 0.2,
-  maxOutputTokens: 2000,
+  maxOutputTokens: 4000,
  logLevel: "info",
  enableFileContext: false,
  contextDir: "./context",
@@ -16,8 +16,8 @@ const mockConfig = {
  redactSecrets: true,
 };
-function makeValidInput(question) {
+function makeValidInput(plan, workspaceId) {
-  return { question };
+  return { question: plan || "Execute this task", context: workspaceId || "ws-001" };
 }
 // --- Success path ---
@@ -25,11 +25,11 @@ function makeValidInput(question) {
 describe("success path", () => {
  it("returns ok:true with answer on full happy flow", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("Review my plan"), {
+    const result = await handleReviewPlan(makeValidInput("Execute this task", "ws-001"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
@@ -40,11 +40,11 @@ describe("success path", () => {
  it("propagates budget warnings through to success result", async () => {
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), {
+    const result = await handleReviewPlan(makeValidInput("Execute this task"), {
-      loadConfig, createOpenAIClient, sendOpenAIResponse,
+      loadConfig, createProvider,
    });
    expect(result.ok).toBe(true);
@@ -55,12 +55,23 @@ describe("success path", () => {
 // --- Validation failure (short-circuit before config) ---
 describe("validation failure", () => {
-  it("returns structured error when question is missing", async () => {
+  it("returns structured error when plan is missing", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan({}, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan({}, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
  it("returns structured error when question is empty", async () => {
    const loadConfig = vi.fn();
    const sendMock = vi.fn();
    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleReviewPlan({ question: "" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -68,32 +79,32 @@ describe("validation failure", () => {
  it("short-circuits — no other deps called", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewPlan({ foo: "bar" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewPlan({ foo: "bar" }, { loadConfig, createProvider });
    expect(loadConfig).not.toHaveBeenCalled();
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
-  it("returns structured error when question is empty string", async () => {
+  it("returns structured error when plan is empty string", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan({ question: "" }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan({ question: "", context: "ws-001" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
-  it("returns structured error when question is wrong type", async () => {
+  it("returns structured error when plan is wrong type", async () => {
    const loadConfig = vi.fn();
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan({ question: 123 }, { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan({ question: 123, context: "ws-001" }, { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
@@ -105,69 +116,69 @@ describe("validation failure", () => {
 describe("config failure", () => {
  it("returns structured error when loadConfig throws", async () => {
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toContain("OPENAI_API_KEY is missing");
  });
-  it("short-circuits — no client or response calls after config failure", async () => {
+  it("short-circuits — no provider or send calls after config failure", async () => {
    const loadConfig = vi.fn(() => { throw new Error("No key."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message", async () => {
    const loadConfig = vi.fn(() => { throw new Error("OPENAI_API_KEY is missing."); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: OPENAI_API_KEY is missing.");
  });
 });
-// --- Budget failure (short-circuit before prompt/client) ---
+// --- Budget failure (short-circuit before prompt/provider) ---
 describe("budget failure", () => {
  it("returns structured error with budget warnings when input exceeds budget", async () => {
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(Array.isArray(result.warnings)).toBe(true);
  });
-  it("short-circuits — no prompt built, no client created, no response sent", async () => {
+  it("short-circuits — no prompt built, no provider created, no send called", async () => {
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes budget warnings through to the error result", async () => {
    const tinyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => tinyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleReviewPlan(
      { question: "x", context: "a".repeat(20) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(false);
@@ -175,69 +186,69 @@ describe("budget failure", () => {
  });
 });
-// --- Client creation failure ---
+// --- Provider creation failure ---
-describe("client creation failure", () => {
+describe("provider creation failure", () => {
-  it("returns structured error when createOpenAIClient throws", async () => {
+  it("returns structured error when createProvider throws", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no response sent after client failure", async () => {
+  it("short-circuits — no send called after provider creation failure", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
  it("passes original error message unchanged", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => { throw new Error("Invalid config."); });
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => { throw new Error("Invalid config."); });
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: Invalid config.");
  });
 });
-// --- OpenAI failure (pass-through) ---
+// --- Provider send failure (pass-through) ---
-describe("OpenAI failure", () => {
+describe("provider send failure", () => {
  it("passes through err.message unchanged", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("API key invalid."));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("API key invalid."));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: API key invalid.");
    expect(result.warnings).toEqual([]);
  });
-  it("short-circuits — no extra processing after API failure", async () => {
+  it("short-circuits — no extra processing after provider send failure", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("rate limit"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("rate limit"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(result.error).toBe("Error: rate limit");
  });
  it("does not wrap or reformat the error", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("429 Too Many Requests"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.error).toBe("Error: 429 Too Many Requests");
  });
 });
@@ -245,61 +256,35 @@ describe("OpenAI failure", () => {
 // --- Dependency call order ---
 describe("dependency call order", () => {
-  it("calls deps in correct order: config -> client -> response", async () => {
+  it("calls deps in correct order: config -> provider -> send", async () => {
    const callLog = [];
    const loadConfig = vi.fn(() => { callLog.push("config"); return mockConfig; });
-    const createOpenAIClient = vi.fn(() => { callLog.push("client"); return { responses: { create: vi.fn() } }; });
+    const createProvider = vi.fn(() => { callLog.push("provider"); return { send: vi.fn().mockImplementation(async () => { callLog.push("send"); return { content: "OK" }; }) }; });
    const sendOpenAIResponse = vi.fn(async () => { callLog.push("response"); return { content: "OK" }; });
-    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
-    expect(callLog).toEqual(["config", "client", "response"]);
+    expect(callLog).toEqual(["config", "provider", "send"]);
  });
 });
 // --- buildReviewPlanPrompt called with correct input ---
 describe("buildReviewPlanPrompt integration", () => {
  it("calls buildReviewPlanPrompt with budget.input (trimmed data)", async () => {
    const loadConfig = vi.fn(() => mockConfig);
    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
    // Spy on buildReviewPlanPrompt import by capturing the prompt arg.
    const promptCapture = [];
    const patchedSend = vi.fn(async (client, params) => {
      promptCapture.push(params.input[0].content);
      return { content: "OK" };
    });
    await handleReviewPlan(makeValidInput("test question"), {
      loadConfig, createOpenAIClient, sendOpenAIResponse: patchedSend,
    });
    expect(promptCapture.length).toBe(1);
    expect(typeof promptCapture[0]).toBe("string");
    expect(promptCapture[0].includes("plan reviewer")).toBe(true);
  });
 });
 // --- No throws escaping ---
 describe("no throws escaping", () => {
-  it("returns structured result when sendOpenAIResponse throws null", async () => {
+  it("returns structured result when send throws null", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(null);
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(null);
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
  it("returns structured result when loadConfig throws non-Error", async () => {
    const loadConfig = vi.fn(() => { throw "string error"; });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
  });
@@ -311,12 +296,12 @@ describe("warning propagation", () => {
  it("includes budget warnings in success result when budget passes with warnings", async () => {
    const trimmedBudget = { ...mockConfig, maxInputChars: 50 };
    const loadConfig = vi.fn(() => trimmedBudget);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
    const result = await handleReviewPlan(
      { question: "hi", context: "x".repeat(49) },
-      { loadConfig, createOpenAIClient, sendOpenAIResponse },
+      { loadConfig, createProvider },
    );
    expect(result.ok).toBe(true);
@@ -326,10 +311,10 @@ describe("warning propagation", () => {
  it("includes budget warnings in failure result when budget fails", async () => {
    const emptyBudget = { ...mockConfig, maxInputChars: 0 };
    const loadConfig = vi.fn(() => emptyBudget);
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(result.ok).toBe(false);
    expect(Array.isArray(result.warnings)).toBe(true);
  });
@@ -340,10 +325,10 @@ describe("warning propagation", () => {
 describe("result shape", () => {
  it("returns exactly { ok, answer, warnings } on success", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn(async () => ({ content: "OK" }));
-    const sendOpenAIResponse = vi.fn(async () => ({ content: "OK" }));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["answer", "ok", "warnings"]);
    expect(result.ok).toBe(true);
    expect(typeof result.answer).toBe("string");
@@ -352,10 +337,10 @@ describe("result shape", () => {
  it("returns exactly { ok, error, warnings } on failure", async () => {
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    const result = await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(Object.keys(result).sort()).toEqual(["error", "ok", "warnings"]);
    expect(result.ok).toBe(false);
    expect(typeof result.error).toBe("string");
@@ -368,23 +353,23 @@ describe("result shape", () => {
 describe("short-circuit behavior", () => {
  it("stops at first failure without calling downstream deps", async () => {
    const loadConfig = vi.fn(() => mockConfig);
-    const createOpenAIClient = vi.fn(() => ({ responses: { create: vi.fn() } }));
+    const sendMock = vi.fn().mockRejectedValue(new Error("boom"));
-    const sendOpenAIResponse = vi.fn().mockRejectedValue(new Error("boom"));
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).toHaveBeenCalledTimes(1);
+    expect(createProvider).toHaveBeenCalledTimes(1);
-    expect(sendOpenAIResponse).toHaveBeenCalledTimes(1);
+    expect(sendMock).toHaveBeenCalledTimes(1);
  });
  it("stops at config failure without calling downstream deps", async () => {
    const loadConfig = vi.fn(() => { throw new Error("fail"); });
-    const createOpenAIClient = vi.fn();
+    const sendMock = vi.fn();
-    const sendOpenAIResponse = vi.fn();
+    const createProvider = vi.fn(() => ({ send: sendMock }));
-    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createOpenAIClient, sendOpenAIResponse });
+    await handleReviewPlan(makeValidInput("hi"), { loadConfig, createProvider });
    expect(loadConfig).toHaveBeenCalledTimes(1);
-    expect(createOpenAIClient).not.toHaveBeenCalled();
+    expect(createProvider).not.toHaveBeenCalled();
-    expect(sendOpenAIResponse).not.toHaveBeenCalled();
+    expect(sendMock).not.toHaveBeenCalled();
  });
 });
Author	SHA1	Message	Date
robbond	f4fa1cdbf6	docs: prepare v1 milestone release	2026-06-16 10:58:31 +01:00
robbond	5a078bb108	docs: updated config docs and tests	2026-06-15 15:37:55 +01:00
robbond	bc9eb4e040	docs: align project documentation with ollama provider	2026-06-15 14:05:05 +01:00
robbond	7bc0622c9c	feat: add ollama provider	2026-06-15 13:35:31 +01:00
robbond	1228d9f2db	feat: add manual export provider	2026-06-15 11:06:00 +01:00
robbond	94aaa80181	fix: replace chat.openai.com with chatgpt.com in all URLs Updated manual export provider instructions to reference https://chatgpt.com instead of the deprecated https://chat.openai.com URL. Affects only the generated copy-paste output shown to users.	2026-06-15 10:46:36 +01:00
robbond	f38b988a8f	feat: add manual export provider and ReviewRequest pattern Implement Task 8.0 — Manual Export Provider with full provider abstraction: Source files: - src/providers/manual-export.js (104 lines) — new provider that wraps pre-built prompts in copy-ready format for ChatGPT Web/Business use - src/providers/factory.js — register 'manual' provider in whitelist - src/providers/openai.js — update JSDoc for ProviderRequest parameter All 5 handlers updated with ReviewRequest pattern: - src/tools/ask-chatgpt.js - src/tools/debug-issue.js - src/tools/review-code.js - src/tools/review-plan.js - src/tools/architecture-review.js Each handler now packages shared data as { prompt, input } between step 5 and 6 of the orchestration flow. Tests: - test/providers/manual-export.test.js (56 tests) — covers structure, copy-ready box formatting, tool name detection, long prompts, Unicode, edge cases, provider contract compliance, idempotency - test/providers/factory.test.js (+9 tests) — manual provider whitelist, factory routing, send delegation Docs: - ARCHITECTURE.md — provider selection table with openai/manual values - README.md — provider comparison table and manual workflow description	2026-06-15 10:35:45 +01:00
robbond	732d6edd38	feat: add provider abstraction for review backends	2026-06-12 19:23:45 +01:00
robbond	1b8edb7eba	docs: refresh README for MVP completion	2026-06-12 13:26:15 +01:00
robbond	cbaad9fdb4	docs: refresh README for MVP completion	2026-06-12 13:25:47 +01:00