btca-server 1.0.71 → 1.0.72

package/README.md

@@ -130,7 +130,7 @@ Update the AI provider and model configuration.
 
 The server reads configuration from `~/.btca/config.toml` or your local project's `.btca/config.toml`. You'll need to configure:
 
-- **AI Provider**: OpenCode AI provider (e.g., "anthropic")
+- **AI Provider**: OpenCode AI provider (e.g., "opencode", "anthropic")
 - **Model**: AI model to use (e.g., "claude-3-7-sonnet-20250219")
 - **Resources**: Local directories or git repositories to query
 
@@ -153,10 +153,33 @@ url = "https://github.com/user/repo"
 branch = "main"
 ```
 
+## Supported Providers
+
+BTCA supports the following providers only:
+
+- `opencode` — API key required
+- `openrouter` — API key required
+- `openai` — OAuth only
+- `google` — API key or OAuth
+- `anthropic` — API key required
+
+Authenticate providers via OpenCode:
+
+```bash
+opencode auth --provider <provider>
+```
+
+## Authentication Notes
+
+- OpenCode and OpenRouter can use environment variables or OpenCode auth.
+- OpenAI requires OAuth (API keys are not supported).
+- Anthropic requires an API key.
+- Google supports API key or OAuth.
+
 ## Environment Variables
 
 - `PORT`: Server port (default: 8080)
-- `OPENCODE_API_KEY`: OpenCode AI API key (required)
+- `OPENCODE_API_KEY`: OpenCode API key (required when provider is `opencode`)
 - `OPENROUTER_API_KEY`: OpenRouter API key (required when provider is `openrouter`)
 - `OPENROUTER_BASE_URL`: Override OpenRouter base URL (optional)
 - `OPENROUTER_HTTP_REFERER`: Optional OpenRouter header for rankings
@@ -184,7 +207,7 @@ import type { BtcaStreamEvent, BtcaStreamMetaEvent } from 'btca-server/stream/ty
 ## Requirements
 
 - **Bun**: >= 1.1.0 (this package is designed specifically for Bun runtime)
-- **OpenCode AI API Key**: Required for AI functionality
+- **OpenCode API Key**: Required when using the `opencode` provider
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "btca-server",
-	"version": "1.0.71",
+	"version": "1.0.72",
 	"description": "BTCA server for answering questions about your codebase using OpenCode AI",
 	"author": "Ben Davis",
 	"license": "MIT",
@@ -51,21 +51,10 @@
 		"prettier": "^3.7.4"
 	},
 	"dependencies": {
-		"@ai-sdk/amazon-bedrock": "^4.0.30",
 		"@ai-sdk/anthropic": "^3.0.23",
-		"@ai-sdk/azure": "^3.0.18",
-		"@ai-sdk/cerebras": "^2.0.20",
-		"@ai-sdk/cohere": "^3.0.11",
-		"@ai-sdk/deepinfra": "^2.0.19",
 		"@ai-sdk/google": "^3.0.13",
-		"@ai-sdk/google-vertex": "^4.0.28",
-		"@ai-sdk/groq": "^3.0.15",
-		"@ai-sdk/mistral": "^3.0.12",
 		"@ai-sdk/openai": "^3.0.18",
 		"@ai-sdk/openai-compatible": "^2.0.18",
-		"@ai-sdk/perplexity": "^3.0.11",
-		"@ai-sdk/togetherai": "^2.0.20",
-		"@ai-sdk/xai": "^3.0.34",
 		"@btca/shared": "workspace:*",
 		"@opencode-ai/sdk": "^1.1.28",
 		"ai": "^6.0.49",

package/src/agent/loop.ts

@@ -11,6 +11,7 @@ export namespace AgentLoop {
 	// Event types for streaming
 	export type AgentEvent =
 		| { type: 'text-delta'; text: string }
+		| { type: 'reasoning-delta'; text: string }
 		| { type: 'tool-call'; toolName: string; input: unknown }
 		| { type: 'tool-result'; toolName: string; output: string }
 		| {
@@ -131,8 +132,14 @@ export namespace AgentLoop {
 			maxSteps = 40
 		} = options;
 
+		const systemPrompt = buildSystemPrompt(agentInstructions);
+		const sessionId = crypto.randomUUID();
+
 		// Get the model
-		const model = await Model.getModel(providerId, modelId);
+		const model = await Model.getModel(providerId, modelId, {
+			providerOptions:
+				providerId === 'openai' ? { instructions: systemPrompt, sessionId } : undefined
+		});
 
 		// Get initial context
 		const initialContext = await getInitialContext(collectionPath, vfsId);
@@ -155,9 +162,13 @@ export namespace AgentLoop {
 		// Run streamText with tool execution
 		const result = streamText({
 			model,
-			system: buildSystemPrompt(agentInstructions),
+			system: systemPrompt,
 			messages,
 			tools,
+			providerOptions:
+				providerId === 'openai'
+					? { openai: { instructions: systemPrompt, store: false } }
+					: undefined,
 			stopWhen: stepCountIs(maxSteps)
 		});
 
@@ -169,6 +180,10 @@ export namespace AgentLoop {
 					events.push({ type: 'text-delta', text: part.text });
 					break;
 
+				case 'reasoning-delta':
+					events.push({ type: 'reasoning-delta', text: part.text });
+					break;
+
 				case 'tool-call':
 					events.push({
 						type: 'tool-call',
@@ -226,8 +241,14 @@ export namespace AgentLoop {
 			maxSteps = 40
 		} = options;
 
+		const systemPrompt = buildSystemPrompt(agentInstructions);
+		const sessionId = crypto.randomUUID();
+
 		// Get the model
-		const model = await Model.getModel(providerId, modelId);
+		const model = await Model.getModel(providerId, modelId, {
+			providerOptions:
+				providerId === 'openai' ? { instructions: systemPrompt, sessionId } : undefined
+		});
 
 		// Get initial context
 		const initialContext = await getInitialContext(collectionPath, vfsId);
@@ -246,9 +267,13 @@ export namespace AgentLoop {
 		// Run streamText with tool execution
 		const result = streamText({
 			model,
-			system: buildSystemPrompt(agentInstructions),
+			system: systemPrompt,
 			messages,
 			tools,
+			providerOptions:
+				providerId === 'openai'
+					? { openai: { instructions: systemPrompt, store: false } }
+					: undefined,
 			stopWhen: stepCountIs(maxSteps)
 		});
 
@@ -259,6 +284,10 @@ export namespace AgentLoop {
 					yield { type: 'text-delta', text: part.text };
 					break;
 
+				case 'reasoning-delta':
+					yield { type: 'reasoning-delta', text: part.text };
+					break;
+
 				case 'tool-call':
 					yield {
 						type: 'tool-call',

package/src/agent/service.ts

@@ -11,7 +11,7 @@ import {
 import { Result } from 'better-result';
 
 import { Config } from '../config/index.ts';
-import { CommonHints, type TaggedErrorOptions } from '../errors.ts';
+import { type TaggedErrorOptions } from '../errors.ts';
 import { Metrics } from '../metrics/index.ts';
 import { Auth, getSupportedProviders } from '../providers/index.ts';
 import type { CollectionResult } from '../collections/types.ts';
@@ -79,7 +79,9 @@ export namespace Agent {
 			super(`Invalid provider: "${args.providerId}"`);
 			this.providerId = args.providerId;
 			this.availableProviders = args.availableProviders;
-			this.hint = `Available providers: ${args.availableProviders.join(', ')}. Update your config with a valid provider.`;
+			this.hint = `Available providers: ${args.availableProviders.join(
+				', '
+			)}. Update your config with a valid provider. Open an issue to request this provider: https://github.com/davis7dotsh/better-context/issues.`;
 		}
 	}
 
@@ -113,10 +115,7 @@ export namespace Agent {
 			super(`Provider "${args.providerId}" is not connected`);
 			this.providerId = args.providerId;
 			this.connectedProviders = args.connectedProviders;
-			const baseHint =
-				args.providerId === 'openrouter'
-					? 'Set OPENROUTER_API_KEY to authenticate OpenRouter.'
-					: CommonHints.RUN_AUTH;
+			const baseHint = Auth.getProviderAuthHint(args.providerId);
 			if (args.connectedProviders.length > 0) {
 				this.hint = `${baseHint} Connected providers: ${args.connectedProviders.join(', ')}.`;
 			} else {

package/src/config/index.ts

@@ -6,6 +6,7 @@ import { z } from 'zod';
 
 import { CommonHints, type TaggedErrorOptions } from '../errors.ts';
 import { Metrics } from '../metrics/index.ts';
+import { getSupportedProviders, isProviderSupported } from '../providers/index.ts';
 import { ResourceDefinitionSchema, type ResourceDefinition } from '../resources/schema.ts';
 
 export const GLOBAL_CONFIG_DIR = '~/.config/btca';
@@ -621,6 +622,13 @@ export namespace Config {
 			getResource: (name: string) => getMergedResources().find((r) => r.name === name),
 
 			updateModel: async (provider: string, model: string) => {
+				if (!isProviderSupported(provider)) {
+					const available = getSupportedProviders();
+					throw new ConfigError({
+						message: `Provider "${provider}" is not supported`,
+						hint: `Available providers: ${available.join(', ')}. Open an issue to request this provider: https://github.com/davis7dotsh/better-context/issues.`
+					});
+				}
 				const mutableConfig = getMutableConfig();
 				const updated = { ...mutableConfig, provider, model };
 				setMutableConfig(updated);

package/src/index.ts

@@ -120,10 +120,30 @@ const AddGitResourceRequestSchema = z.object({
 	specialNotes: GitResourceSchema.shape.specialNotes
 });
 
+const isWsl = () =>
+	process.platform === 'linux' &&
+	(Boolean(process.env.WSL_DISTRO_NAME) ||
+		Boolean(process.env.WSL_INTEROP) ||
+		Boolean(process.env.WSLENV));
+
+const normalizeWslPath = (value: string) => {
+	if (!isWsl()) return value;
+	const match = value.match(/^([a-zA-Z]):\\(.*)$/);
+	if (!match) return value;
+	const drive = match[1]!.toLowerCase();
+	const rest = match[2]!.replace(/\\/g, '/');
+	return `/mnt/${drive}/${rest}`;
+};
+
+const LocalPathRequestSchema = z.preprocess(
+	(value) => (typeof value === 'string' ? normalizeWslPath(value) : value),
+	LocalResourceSchema.shape.path
+) as z.ZodType<string>;
+
 const AddLocalResourceRequestSchema = z.object({
 	type: z.literal('local'),
 	name: LocalResourceSchema.shape.name,
-	path: LocalResourceSchema.shape.path,
+	path: LocalPathRequestSchema,
 	specialNotes: LocalResourceSchema.shape.specialNotes
 });
 

package/src/providers/auth.ts

@@ -13,9 +13,30 @@ import { z } from 'zod';
 import { Result } from 'better-result';
 
 export namespace Auth {
-	const getOpenRouterApiKey = () => {
-		const apiKey = process.env.OPENROUTER_API_KEY;
-		return apiKey && apiKey.trim().length > 0 ? apiKey.trim() : undefined;
+	export type AuthType = 'api' | 'oauth' | 'wellknown';
+
+	export type AuthStatus =
+		| { status: 'ok'; authType: AuthType; apiKey?: string; accountId?: string }
+		| { status: 'missing' }
+		| { status: 'invalid'; authType: AuthType };
+
+	const PROVIDER_AUTH_TYPES: Record<string, readonly AuthType[]> = {
+		opencode: ['api'],
+		openrouter: ['api'],
+		openai: ['oauth'],
+		anthropic: ['api'],
+		google: ['api', 'oauth']
+	};
+
+	const readEnv = (key: string) => {
+		const value = process.env[key];
+		return value && value.trim().length > 0 ? value.trim() : undefined;
+	};
+
+	const getEnvApiKey = (providerId: string) => {
+		if (providerId === 'openrouter') return readEnv('OPENROUTER_API_KEY');
+		if (providerId === 'opencode') return readEnv('OPENCODE_API_KEY');
+		return undefined;
 	};
 
 	// Auth schema matching OpenCode's format
@@ -28,7 +49,8 @@ export namespace Auth {
 		type: z.literal('oauth'),
 		access: z.string(),
 		refresh: z.string(),
-		expires: z.number()
+		expires: z.number(),
+		accountId: z.string().optional()
 	});
 
 	const WellKnownAuthSchema = z.object({
@@ -106,13 +128,52 @@ export namespace Auth {
 		return authData[providerId];
 	}
 
+	export async function getAuthStatus(providerId: string): Promise<AuthStatus> {
+		const allowedTypes = PROVIDER_AUTH_TYPES[providerId];
+		if (!allowedTypes) return { status: 'missing' };
+
+		const envKey = getEnvApiKey(providerId);
+		if (envKey) {
+			return allowedTypes.includes('api')
+				? { status: 'ok', authType: 'api', apiKey: envKey }
+				: { status: 'invalid', authType: 'api' };
+		}
+
+		const auth = await getCredentials(providerId);
+		if (!auth) return { status: 'missing' };
+
+		if (!allowedTypes.includes(auth.type)) {
+			return { status: 'invalid', authType: auth.type };
+		}
+
+		const apiKey = auth.type === 'api' ? auth.key : auth.type === 'oauth' ? auth.access : undefined;
+		const accountId = auth.type === 'oauth' ? auth.accountId : undefined;
+		return { status: 'ok', authType: auth.type, apiKey, accountId };
+	}
+
+	export const getProviderAuthHint = (providerId: string) => {
+		switch (providerId) {
+			case 'openai':
+				return 'Run "opencode auth --provider openai" and complete OAuth.';
+			case 'anthropic':
+				return 'Run "opencode auth --provider anthropic" and enter an API key.';
+			case 'google':
+				return 'Run "opencode auth --provider google" and enter an API key or OAuth.';
+			case 'openrouter':
+				return 'Set OPENROUTER_API_KEY or run "opencode auth --provider openrouter".';
+			case 'opencode':
+				return 'Set OPENCODE_API_KEY or run "opencode auth --provider opencode".';
+			default:
+				return 'Run "opencode auth --provider <provider>" to configure credentials.';
+		}
+	};
+
 	/**
 	 * Check if a provider is authenticated
 	 */
 	export async function isAuthenticated(providerId: string): Promise<boolean> {
-		if (providerId === 'openrouter' && getOpenRouterApiKey()) return true;
-		const auth = await getCredentials(providerId);
-		return auth !== undefined;
+		const status = await getAuthStatus(providerId);
+		return status.status === 'ok';
 	}
 
 	/**
@@ -120,24 +181,9 @@ export namespace Auth {
 	 * Returns undefined if not authenticated or no key available
 	 */
 	export async function getApiKey(providerId: string): Promise<string | undefined> {
-		if (providerId === 'openrouter') {
-			const envKey = getOpenRouterApiKey();
-			if (envKey) return envKey;
-		}
-
-		const auth = await getCredentials(providerId);
-		if (!auth) return undefined;
-
-		if (auth.type === 'api') {
-			return auth.key;
-		}
-
-		if (auth.type === 'oauth') {
-			return auth.access;
-		}
-
-		// wellknown auth doesn't have an API key
-		return undefined;
+		const status = await getAuthStatus(providerId);
+		if (status.status !== 'ok') return undefined;
+		return status.apiKey;
 	}
 
 	/**
@@ -147,20 +193,22 @@ export namespace Auth {
 		return readAuthFile();
 	}
 
+	/**
+	 * Update stored credentials for a provider
+	 */
+	export async function setCredentials(providerId: string, info: AuthInfo): Promise<void> {
+		const filepath = getAuthFilePath();
+		const existing = await readAuthFile();
+		const next = { ...existing, [providerId]: info };
+		await Bun.write(filepath, JSON.stringify(next, null, 2), { mode: 0o600 });
+	}
+
 	/**
 	 * Get the list of all authenticated provider IDs
 	 */
 	export async function getAuthenticatedProviders(): Promise<string[]> {
-		const authData = await readAuthFile();
-		const providers = new Set(Object.keys(authData));
-
-		if (getOpenRouterApiKey()) {
-			providers.add('openrouter');
-		}
-		if (authData['openrouter.ai'] || authData['openrouter-ai']) {
-			providers.add('openrouter');
-		}
-
-		return Array.from(providers);
+		const providers = Object.keys(PROVIDER_AUTH_TYPES);
+		const statuses = await Promise.all(providers.map((provider) => getAuthStatus(provider)));
+		return providers.filter((_, index) => statuses[index]?.status === 'ok');
 	}
 }

package/src/providers/index.ts

@@ -6,7 +6,6 @@ export { Auth } from './auth.ts';
 export { Model } from './model.ts';
 export {
 	PROVIDER_REGISTRY,
-	PROVIDER_ALIASES,
 	isProviderSupported,
 	normalizeProviderId,
 	getProviderFactory,

package/src/providers/model.ts

@@ -16,24 +16,39 @@ export namespace Model {
 	export class ProviderNotFoundError extends Error {
 		readonly _tag = 'ProviderNotFoundError';
 		readonly providerId: string;
+		readonly hint: string;
 
 		constructor(providerId: string) {
 			super(`Provider "${providerId}" is not supported`);
 			this.providerId = providerId;
+			this.hint =
+				'Open an issue to request this provider: https://github.com/davis7dotsh/better-context/issues.';
 		}
 	}
 
 	export class ProviderNotAuthenticatedError extends Error {
 		readonly _tag = 'ProviderNotAuthenticatedError';
 		readonly providerId: string;
+		readonly hint: string;
 
 		constructor(providerId: string) {
-			super(
-				providerId === 'openrouter'
-					? `Provider "${providerId}" is not authenticated. Set OPENROUTER_API_KEY to authenticate.`
-					: `Provider "${providerId}" is not authenticated. Run 'opencode auth login' to authenticate.`
-			);
+			super(`Provider "${providerId}" is not authenticated.`);
 			this.providerId = providerId;
+			this.hint = Auth.getProviderAuthHint(providerId);
+		}
+	}
+
+	export class ProviderAuthTypeError extends Error {
+		readonly _tag = 'ProviderAuthTypeError';
+		readonly providerId: string;
+		readonly authType: string;
+		readonly hint: string;
+
+		constructor(args: { providerId: string; authType: string }) {
+			super(`Provider "${args.providerId}" does not support "${args.authType}" auth.`);
+			this.providerId = args.providerId;
+			this.authType = args.authType;
+			this.hint = Auth.getProviderAuthHint(args.providerId);
 		}
 	}
 
@@ -72,22 +87,24 @@ export namespace Model {
 
 		// Get authentication
 		let apiKey: string | undefined;
+		let accountId: string | undefined;
 
 		if (!options.skipAuth) {
-			// Special handling for 'opencode' provider - check env var first
-			if (normalizedProviderId === 'opencode') {
-				apiKey = process.env.OPENCODE_API_KEY || (await Auth.getApiKey(normalizedProviderId));
-			} else {
-				apiKey = await Auth.getApiKey(normalizedProviderId);
-				if (!apiKey) {
-					throw new ProviderNotAuthenticatedError(providerId);
-				}
+			const status = await Auth.getAuthStatus(normalizedProviderId);
+			if (status.status === 'missing') {
+				throw new ProviderNotAuthenticatedError(providerId);
 			}
+			if (status.status === 'invalid') {
+				throw new ProviderAuthTypeError({ providerId, authType: status.authType });
+			}
+			apiKey = status.apiKey;
+			accountId = status.accountId;
 		}
 
 		// Build provider options
 		const providerOptions: ProviderOptions = {
-			...options.providerOptions
+			...options.providerOptions,
+			...(accountId ? { accountId } : {})
 		};
 
 		if (apiKey) {
@@ -111,11 +128,6 @@ export namespace Model {
 			return false;
 		}
 
-		// Special case: opencode gateway is always available
-		if (normalizedProviderId === 'opencode') {
-			return true;
-		}
-
 		return Auth.isAuthenticated(normalizedProviderId);
 	}
 

package/src/providers/openai.ts

@@ -0,0 +1,220 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import * as os from 'node:os';
+import { Auth } from './auth.ts';
+
+const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+const ISSUER = 'https://auth.openai.com';
+const CODEX_API_ENDPOINT = 'https://chatgpt.com/backend-api/codex/responses';
+const USER_AGENT = `btca/${process.env.npm_package_version ?? 'dev'} (${os.platform()} ${os.release()}; ${os.arch()})`;
+
+type TokenResponse = {
+	id_token?: string;
+	access_token: string;
+	refresh_token?: string;
+	expires_in?: number;
+};
+
+type IdTokenClaims = {
+	chatgpt_account_id?: string;
+	organizations?: Array<{ id: string }>;
+	email?: string;
+	'https://api.openai.com/auth'?: {
+		chatgpt_account_id?: string;
+	};
+};
+
+const parseJwtClaims = (token: string): IdTokenClaims | undefined => {
+	const parts = token.split('.');
+	if (parts.length !== 3 || !parts[1]) return undefined;
+	try {
+		return JSON.parse(Buffer.from(parts[1], 'base64url').toString()) as IdTokenClaims;
+	} catch {
+		return undefined;
+	}
+};
+
+const extractAccountIdFromClaims = (claims: IdTokenClaims): string | undefined =>
+	claims.chatgpt_account_id ||
+	claims['https://api.openai.com/auth']?.chatgpt_account_id ||
+	claims.organizations?.[0]?.id;
+
+const extractAccountId = (tokens: TokenResponse): string | undefined => {
+	if (tokens.id_token) {
+		const claims = parseJwtClaims(tokens.id_token);
+		const accountId = claims && extractAccountIdFromClaims(claims);
+		if (accountId) return accountId;
+	}
+	if (tokens.access_token) {
+		const claims = parseJwtClaims(tokens.access_token);
+		return claims ? extractAccountIdFromClaims(claims) : undefined;
+	}
+	return undefined;
+};
+
+const refreshAccessToken = async (refreshToken: string): Promise<TokenResponse> => {
+	const response = await fetch(`${ISSUER}/oauth/token`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+		body: new URLSearchParams({
+			grant_type: 'refresh_token',
+			refresh_token: refreshToken,
+			client_id: CLIENT_ID
+		}).toString()
+	});
+	if (!response.ok) {
+		throw new Error(`Token refresh failed: ${response.status}`);
+	}
+	return response.json() as Promise<TokenResponse>;
+};
+
+const buildHeaders = (initHeaders: unknown, accountId?: string): Headers => {
+	const headers = new Headers();
+
+	if (initHeaders instanceof Headers) {
+		initHeaders.forEach((value, key) => headers.set(key, value));
+	} else if (Array.isArray(initHeaders)) {
+		for (const [key, value] of initHeaders) {
+			if (value !== undefined) headers.set(key, String(value));
+		}
+	} else if (initHeaders && typeof initHeaders === 'object') {
+		for (const [key, value] of Object.entries(initHeaders as Record<string, unknown>)) {
+			if (value !== undefined) headers.set(key, String(value));
+		}
+	}
+
+	if (accountId) {
+		headers.set('ChatGPT-Account-Id', accountId);
+	}
+
+	return headers;
+};
+
+const rewriteUrl = (requestInput: unknown) => {
+	const parsed =
+		requestInput instanceof URL
+			? requestInput
+			: new URL(
+					typeof requestInput === 'string'
+						? requestInput
+						: requestInput instanceof Request
+							? requestInput.url
+							: String(requestInput)
+				);
+
+	return parsed.pathname.includes('/v1/responses') || parsed.pathname.includes('/chat/completions')
+		? new URL(CODEX_API_ENDPOINT)
+		: parsed;
+};
+
+const normalizeBody = (body: unknown): string | undefined => {
+	if (typeof body === 'string') return body;
+	if (body instanceof Uint8Array) return new TextDecoder().decode(body);
+	if (body instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(body));
+	return undefined;
+};
+
+const sanitizeCodexPayload = (parsed: Record<string, unknown>) => {
+	parsed.store = false;
+	if ('previous_response_id' in parsed) {
+		delete parsed.previous_response_id;
+	}
+	const input = parsed.input;
+	if (!Array.isArray(input)) return;
+	parsed.input = input
+		.filter(
+			(item) =>
+				!(item && typeof item === 'object' && 'type' in item && item.type === 'item_reference')
+		)
+		.map((item) => {
+			if (!item || typeof item !== 'object') return item;
+			// Strip item IDs to avoid referencing non-persisted items when store=false.
+			const { id: _unused, ...rest } = item as Record<string, unknown>;
+			return rest;
+		});
+};
+
+const injectCodexDefaults = (
+	init: RequestInit | undefined,
+	instructions?: string
+): RequestInit | undefined => {
+	if (!instructions) return init;
+	const bodyText = normalizeBody(init?.body);
+	if (!bodyText) return init;
+
+	try {
+		const parsed = JSON.parse(bodyText) as Record<string, unknown>;
+		if (parsed.instructions == null) {
+			parsed.instructions = instructions;
+		}
+		sanitizeCodexPayload(parsed);
+		return { ...init, body: JSON.stringify(parsed) };
+	} catch {
+		return init;
+	}
+};
+
+export function createOpenAICodex(
+	options: {
+		apiKey?: string;
+		accountId?: string;
+		baseURL?: string;
+		headers?: Record<string, string>;
+		name?: string;
+		instructions?: string;
+		sessionId?: string;
+	} = {}
+) {
+	const customFetch = (async (requestInput, init) => {
+		const storedAuth = await Auth.getCredentials('openai');
+		let accessToken = options.apiKey;
+		let accountId = options.accountId;
+
+		if (storedAuth?.type === 'oauth') {
+			accessToken = storedAuth.access;
+			accountId = storedAuth.accountId ?? accountId;
+
+			if (!storedAuth.access || storedAuth.expires < Date.now()) {
+				const tokens = await refreshAccessToken(storedAuth.refresh);
+				const refreshedAccountId = extractAccountId(tokens) ?? accountId;
+				accessToken = tokens.access_token;
+				accountId = refreshedAccountId;
+				await Auth.setCredentials('openai', {
+					type: 'oauth',
+					refresh: tokens.refresh_token ?? storedAuth.refresh,
+					access: tokens.access_token,
+					expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+					...(refreshedAccountId ? { accountId: refreshedAccountId } : {})
+				});
+			}
+		}
+
+		const url = rewriteUrl(requestInput);
+		const headerSource =
+			init?.headers ?? (requestInput instanceof Request ? requestInput.headers : undefined);
+		const headers = buildHeaders(headerSource, accountId);
+		const fallbackInstructions =
+			options.instructions ?? 'You are btca, an expert documentation search agent.';
+		const nextInit = injectCodexDefaults(init, fallbackInstructions);
+		headers.set('originator', 'opencode');
+		headers.set('User-Agent', USER_AGENT);
+		if (options.sessionId) {
+			headers.set('session_id', options.sessionId);
+		}
+		if (accessToken) {
+			headers.set('authorization', `Bearer ${accessToken}`);
+		}
+		return fetch(url, { ...nextInit, headers });
+	}) as typeof fetch;
+
+	if (fetch.preconnect) {
+		customFetch.preconnect = fetch.preconnect.bind(fetch);
+	}
+
+	return createOpenAI({
+		apiKey: options.apiKey,
+		baseURL: options.baseURL,
+		headers: options.headers,
+		name: options.name,
+		fetch: customFetch
+	});
+}

package/src/providers/registry.ts

@@ -2,31 +2,22 @@
  * Provider Registry
  * Maps provider IDs to their AI SDK factory functions
  */
-import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { createAnthropic } from '@ai-sdk/anthropic';
-import { createAzure } from '@ai-sdk/azure';
-import { createCerebras } from '@ai-sdk/cerebras';
-import { createCohere } from '@ai-sdk/cohere';
-import { createDeepInfra } from '@ai-sdk/deepinfra';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
-import { createVertex } from '@ai-sdk/google-vertex';
-import { createGroq } from '@ai-sdk/groq';
-import { createMistral } from '@ai-sdk/mistral';
-import { createOpenAI } from '@ai-sdk/openai';
-import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
-import { createPerplexity } from '@ai-sdk/perplexity';
-import { createTogetherAI } from '@ai-sdk/togetherai';
-import { createXai } from '@ai-sdk/xai';
 
 import { createOpenCodeZen } from './opencode.ts';
+import { createOpenAICodex } from './openai.ts';
 import { createOpenRouter } from './openrouter.ts';
 
 // Type for provider factory options
 export type ProviderOptions = {
 	apiKey?: string;
+	accountId?: string;
 	baseURL?: string;
 	headers?: Record<string, string>;
 	name?: string; // Required for openai-compatible
+	instructions?: string;
+	sessionId?: string;
 };
 
 // Type for a provider factory function
@@ -44,58 +35,26 @@ export const PROVIDER_REGISTRY: Record<string, ProviderFactory> = {
 	anthropic: createAnthropic as ProviderFactory,
 
 	// OpenAI
-	openai: createOpenAI as ProviderFactory,
-
+	openai: createOpenAICodex as ProviderFactory,
 	// Google
 	google: createGoogleGenerativeAI as ProviderFactory,
-	'google-vertex': createVertex as ProviderFactory,
-
-	// Amazon
-	'amazon-bedrock': createAmazonBedrock as ProviderFactory,
-
-	// Azure
-	azure: createAzure as ProviderFactory,
-
-	// Other providers
-	groq: createGroq as ProviderFactory,
-	mistral: createMistral as ProviderFactory,
-	xai: createXai as ProviderFactory,
-	cohere: createCohere as ProviderFactory,
-	deepinfra: createDeepInfra as ProviderFactory,
-	cerebras: createCerebras as ProviderFactory,
-	perplexity: createPerplexity as ProviderFactory,
-	togetherai: createTogetherAI as ProviderFactory,
-
-	// OpenAI-compatible providers (for custom endpoints)
-	openrouter: createOpenRouter as ProviderFactory,
-	'openai-compatible': createOpenAICompatible as ProviderFactory
-};
 
-// Provider aliases for common naming variations
-export const PROVIDER_ALIASES: Record<string, string> = {
-	claude: 'anthropic',
-	'gpt-4': 'openai',
-	'gpt-4o': 'openai',
-	gemini: 'google',
-	vertex: 'google-vertex',
-	bedrock: 'amazon-bedrock',
-	grok: 'xai',
-	together: 'togetherai'
+	// OpenRouter (OpenAI-compatible gateway)
+	openrouter: createOpenRouter as ProviderFactory
 };
 
 /**
  * Check if a provider is supported
  */
 export function isProviderSupported(providerId: string): boolean {
-	const normalized = PROVIDER_ALIASES[providerId] || providerId;
-	return normalized in PROVIDER_REGISTRY;
+	return providerId in PROVIDER_REGISTRY;
 }
 
 /**
  * Get the normalized provider ID
  */
 export function normalizeProviderId(providerId: string): string {
-	return PROVIDER_ALIASES[providerId] || providerId;
+	return providerId;
 }
 
 /**

package/src/stream/service.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'bun:test';
+
+import { StreamService } from './service.ts';
+import type { BtcaStreamEvent } from './types.ts';
+
+const readStream = async (stream: ReadableStream<Uint8Array>) => {
+	const decoder = new TextDecoder();
+	let output = '';
+	for await (const chunk of stream) {
+		output += decoder.decode(chunk, { stream: true });
+	}
+	output += decoder.decode();
+	return output;
+};
+
+const parseSseEvents = (payload: string) =>
+	payload
+		.split('\n\n')
+		.map((chunk) => chunk.trim())
+		.filter(Boolean)
+		.map((chunk) => chunk.split('\n').find((line) => line.startsWith('data: ')))
+		.filter((line): line is string => Boolean(line))
+		.map((line) => JSON.parse(line.slice(6)) as BtcaStreamEvent);
+
+describe('StreamService.createSseStream', () => {
+	it('streams reasoning deltas and includes final reasoning in done', async () => {
+		const eventStream = (async function* () {
+			yield { type: 'reasoning-delta', text: 'First ' } as const;
+			yield { type: 'reasoning-delta', text: 'Second' } as const;
+			yield { type: 'text-delta', text: 'Answer' } as const;
+			yield { type: 'finish', finishReason: 'stop' } as const;
+		})();
+
+		const stream = StreamService.createSseStream({
+			meta: {
+				type: 'meta',
+				model: { provider: 'test', model: 'test-model' },
+				resources: ['svelte'],
+				collection: { key: 'test', path: '/tmp' }
+			},
+			eventStream,
+			question: 'What?'
+		});
+
+		const payload = await readStream(stream);
+		const events = parseSseEvents(payload);
+
+		const reasoningDeltaText = events
+			.filter((event) => event.type === 'reasoning.delta')
+			.map((event) => event.delta)
+			.join('');
+		expect(reasoningDeltaText).toBe('First Second');
+
+		const doneEvent = events.find((event) => event.type === 'done');
+		expect(doneEvent?.reasoning).toBe('First Second');
+	});
+});

package/src/stream/service.ts

@@ -10,6 +10,7 @@ import type {
 	BtcaStreamErrorEvent,
 	BtcaStreamEvent,
 	BtcaStreamMetaEvent,
+	BtcaStreamReasoningDeltaEvent,
 	BtcaStreamTextDeltaEvent,
 	BtcaStreamToolUpdatedEvent
 } from './types.ts';
@@ -36,9 +37,12 @@ export namespace StreamService {
 
 		// Track accumulated text and tool state
 		let accumulatedText = '';
+		let emittedText = '';
+		let accumulatedReasoning = '';
 		const toolsByCallId = new Map<string, Omit<BtcaStreamToolUpdatedEvent, 'type'>>();
 		let textEvents = 0;
 		let toolEvents = 0;
+		let reasoningEvents = 0;
 
 		// Extract the core question for stripping echoed user message from final response
 		const coreQuestion = extractCoreQuestion(args.question);
@@ -61,8 +65,24 @@ export namespace StreamService {
 									textEvents += 1;
 									accumulatedText += event.text;
 
-									const msg: BtcaStreamTextDeltaEvent = {
-										type: 'text.delta',
+									const nextText = stripUserQuestionFromStart(accumulatedText, coreQuestion);
+									const delta = nextText.slice(emittedText.length);
+									if (delta) {
+										emittedText = nextText;
+										const msg: BtcaStreamTextDeltaEvent = {
+											type: 'text.delta',
+											delta
+										};
+										emit(controller, msg);
+									}
+									break;
+								}
+
+								case 'reasoning-delta': {
+									reasoningEvents += 1;
+									accumulatedReasoning += event.text;
+									const msg: BtcaStreamReasoningDeltaEvent = {
+										type: 'reasoning.delta',
 										delta: event.text
 									};
 									emit(controller, msg);
@@ -123,21 +143,24 @@ export namespace StreamService {
 									const tools = Array.from(toolsByCallId.values());
 
 									// Strip the echoed user question from the final text
-									let finalText = stripUserQuestionFromStart(accumulatedText, coreQuestion);
+									const finalText = stripUserQuestionFromStart(accumulatedText, coreQuestion);
+									emittedText = finalText;
 
 									Metrics.info('stream.done', {
 										collectionKey: args.meta.collection.key,
 										textLength: finalText.length,
+										reasoningLength: accumulatedReasoning.length,
 										toolCount: tools.length,
 										textEvents,
 										toolEvents,
+										reasoningEvents,
 										finishReason: event.finishReason
 									});
 
 									const done: BtcaStreamDoneEvent = {
 										type: 'done',
 										text: finalText,
-										reasoning: '', // We don't have reasoning in the new format
+										reasoning: accumulatedReasoning,
 										tools
 									};
 									emit(controller, done);

package/src/validation/index.ts

@@ -72,6 +72,19 @@ const okWithValue = <T>(value: T): ValidationResultWithValue<T> => ({ valid: tru
 const fail = (error: string): ValidationResult => ({ valid: false, error });
 const failWithValue = <T>(error: string): ValidationResultWithValue<T> => ({ valid: false, error });
 const parseUrl = (value: string) => Result.try(() => new URL(value));
+const isWsl = () =>
+	process.platform === 'linux' &&
+	(Boolean(process.env.WSL_DISTRO_NAME) ||
+		Boolean(process.env.WSL_INTEROP) ||
+		Boolean(process.env.WSLENV));
+const normalizeWslPath = (value: string) => {
+	if (!isWsl()) return value;
+	const match = value.match(/^([a-zA-Z]):\\(.*)$/);
+	if (!match) return value;
+	const drive = match[1]!.toLowerCase();
+	const rest = match[2]!.replace(/\\/g, '/');
+	return `/mnt/${drive}/${rest}`;
+};
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Validators
@@ -301,17 +314,19 @@ export const validateSearchPaths = (searchPaths: string[] | undefined): Validati
  * - Must be absolute path
  */
 export const validateLocalPath = (path: string): ValidationResult => {
-	if (!path || path.trim().length === 0) {
+	const normalizedPath = normalizeWslPath(path);
+
+	if (!normalizedPath || normalizedPath.trim().length === 0) {
 		return fail('Local path cannot be empty');
 	}
 
 	// Reject null bytes
-	if (path.includes('\0')) {
+	if (normalizedPath.includes('\0')) {
 		return fail('Path must not contain null bytes');
 	}
 
 	// Must be absolute path (starts with / on Unix or drive letter on Windows)
-	if (!path.startsWith('/') && !path.match(/^[a-zA-Z]:\\/)) {
+	if (!normalizedPath.startsWith('/') && !normalizedPath.match(/^[a-zA-Z]:\\/)) {
 		return fail('Local path must be an absolute path');
 	}
 
@@ -502,7 +517,8 @@ export const validateLocalResource = (resource: {
 	const nameResult = validateResourceName(resource.name);
 	if (!nameResult.valid) return failWithValue(nameResult.error);
 
-	const pathResult = validateLocalPath(resource.path);
+	const normalizedPath = normalizeWslPath(resource.path);
+	const pathResult = validateLocalPath(normalizedPath);
 	if (!pathResult.valid) return failWithValue(pathResult.error);
 
 	const notesResult = validateNotes(resource.specialNotes);
@@ -510,7 +526,7 @@ export const validateLocalResource = (resource: {
 
 	return okWithValue({
 		name: resource.name,
-		path: resource.path,
+		path: normalizedPath,
 		...(resource.specialNotes && { specialNotes: resource.specialNotes })
 	});
 };