btca-server 1.0.82 → 1.0.84

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "btca-server",
-	"version": "1.0.82",
+	"version": "1.0.84",
 	"description": "BTCA server for answering questions about your codebase using OpenCode AI",
 	"author": "Ben Davis",
 	"license": "MIT",

package/src/agent/loop.ts

@@ -5,6 +5,7 @@
 import { streamText, tool, stepCountIs, type ModelMessage } from 'ai';
 
 import { Model } from '../providers/index.ts';
+import type { ProviderOptions } from '../providers/registry.ts';
 import { ReadTool, GrepTool, GlobTool, ListTool } from '../tools/index.ts';
 
 export namespace AgentLoop {
@@ -30,6 +31,7 @@ export namespace AgentLoop {
 		agentInstructions: string;
 		question: string;
 		maxSteps?: number;
+		providerOptions?: Partial<ProviderOptions>;
 	};
 
 	// Result type
@@ -135,10 +137,15 @@ export namespace AgentLoop {
 		const systemPrompt = buildSystemPrompt(agentInstructions);
 		const sessionId = crypto.randomUUID();
 
+		const mergedProviderOptions =
+			providerId === 'openai'
+				? { ...options.providerOptions, instructions: systemPrompt, sessionId }
+				: options.providerOptions;
+
 		// Get the model
 		const model = await Model.getModel(providerId, modelId, {
-			providerOptions:
-				providerId === 'openai' ? { instructions: systemPrompt, sessionId } : undefined
+			providerOptions: mergedProviderOptions,
+			allowMissingAuth: providerId === 'openai-compat'
 		});
 
 		// Get initial context
@@ -244,10 +251,15 @@ export namespace AgentLoop {
 		const systemPrompt = buildSystemPrompt(agentInstructions);
 		const sessionId = crypto.randomUUID();
 
+		const mergedProviderOptions =
+			providerId === 'openai'
+				? { ...options.providerOptions, instructions: systemPrompt, sessionId }
+				: options.providerOptions;
+
 		// Get the model
 		const model = await Model.getModel(providerId, modelId, {
-			providerOptions:
-				providerId === 'openai' ? { instructions: systemPrompt, sessionId } : undefined
+			providerOptions: mergedProviderOptions,
+			allowMissingAuth: providerId === 'openai-compat'
 		});
 
 		// Get initial context

package/src/agent/service.ts

@@ -127,7 +127,8 @@ export namespace Agent {
 
 			// Validate provider is authenticated
 			const isAuthed = await Auth.isAuthenticated(config.provider);
-			if (!isAuthed && config.provider !== 'opencode') {
+			const requiresAuth = config.provider !== 'opencode' && config.provider !== 'openai-compat';
+			if (!isAuthed && requiresAuth) {
 				const authenticated = await Auth.getAuthenticatedProviders();
 				cleanup();
 				throw new ProviderNotConnectedError({
@@ -145,7 +146,8 @@ export namespace Agent {
 						collectionPath: collection.path,
 						vfsId: collection.vfsId,
 						agentInstructions: collection.agentInstructions,
-						question
+						question,
+						providerOptions: config.getProviderOptions(config.provider)
 					});
 					for await (const event of stream) {
 						yield event;
@@ -179,7 +181,8 @@ export namespace Agent {
 
 			// Validate provider is authenticated
 			const isAuthed = await Auth.isAuthenticated(config.provider);
-			if (!isAuthed && config.provider !== 'opencode') {
+			const requiresAuth = config.provider !== 'opencode' && config.provider !== 'openai-compat';
+			if (!isAuthed && requiresAuth) {
 				const authenticated = await Auth.getAuthenticatedProviders();
 				cleanup();
 				throw new ProviderNotConnectedError({
@@ -195,7 +198,8 @@ export namespace Agent {
 					collectionPath: collection.path,
 					vfsId: collection.vfsId,
 					agentInstructions: collection.agentInstructions,
-					question
+					question,
+					providerOptions: config.getProviderOptions(config.provider)
 				})
 			);
 

package/src/config/index.ts

@@ -50,6 +50,13 @@ export const DEFAULT_RESOURCES: ResourceDefinition[] = [
 	}
 ];
 
+const ProviderOptionsSchema = z.object({
+	baseURL: z.string().optional(),
+	name: z.string().optional()
+});
+
+const ProviderOptionsMapSchema = z.record(z.string(), ProviderOptionsSchema);
+
 const StoredConfigSchema = z.object({
 	$schema: z.string().optional(),
 	dataDirectory: z.string().optional(),
@@ -57,10 +64,13 @@ const StoredConfigSchema = z.object({
 	resources: z.array(ResourceDefinitionSchema),
 	// Provider and model are optional - defaults are applied when loading
 	model: z.string().optional(),
-	provider: z.string().optional()
+	provider: z.string().optional(),
+	providerOptions: ProviderOptionsMapSchema.optional()
 });
 
 type StoredConfig = z.infer<typeof StoredConfigSchema>;
+type ProviderOptionsConfig = z.infer<typeof ProviderOptionsSchema>;
+type ProviderOptionsMap = z.infer<typeof ProviderOptionsMapSchema>;
 
 // Legacy config schemas (btca.json format from old CLI)
 // There are two legacy formats:
@@ -121,8 +131,13 @@ export namespace Config {
 		provider: string;
 		providerTimeoutMs?: number;
 		configPath: string;
+		getProviderOptions: (providerId: string) => ProviderOptionsConfig | undefined;
 		getResource: (name: string) => ResourceDefinition | undefined;
-		updateModel: (provider: string, model: string) => Promise<{ provider: string; model: string }>;
+		updateModel: (
+			provider: string,
+			model: string,
+			providerOptions?: ProviderOptionsConfig
+		) => Promise<{ provider: string; model: string }>;
 		addResource: (resource: ResourceDefinition) => Promise<ResourceDefinition>;
 		removeResource: (name: string) => Promise<void>;
 		clearResources: () => Promise<{ cleared: number }>;
@@ -585,6 +600,28 @@ export namespace Config {
 			return Array.from(resourceMap.values());
 		};
 
+		const mergeProviderOptions = (
+			globalConfigValue: StoredConfig,
+			projectConfigValue: StoredConfig | null
+		): ProviderOptionsMap => {
+			const merged: ProviderOptionsMap = {};
+			const globalOptions = globalConfigValue.providerOptions ?? {};
+			const projectOptions = projectConfigValue?.providerOptions ?? {};
+
+			for (const [providerId, options] of Object.entries(globalOptions)) {
+				merged[providerId] = { ...options };
+			}
+
+			for (const [providerId, options] of Object.entries(projectOptions)) {
+				merged[providerId] = { ...(merged[providerId] ?? {}), ...options };
+			}
+
+			return merged;
+		};
+
+		const getMergedProviderOptions = (): ProviderOptionsMap =>
+			mergeProviderOptions(currentGlobalConfig, currentProjectConfig);
+
 		// Get the config that should be used for model/provider
 		const getActiveConfig = (): StoredConfig => {
 			return currentProjectConfig ?? currentGlobalConfig;
@@ -619,9 +656,14 @@ export namespace Config {
 			get providerTimeoutMs() {
 				return getActiveConfig().providerTimeoutMs;
 			},
+			getProviderOptions: (providerId: string) => getMergedProviderOptions()[providerId],
 			getResource: (name: string) => getMergedResources().find((r) => r.name === name),
 
-			updateModel: async (provider: string, model: string) => {
+			updateModel: async (
+				provider: string,
+				model: string,
+				providerOptions?: ProviderOptionsConfig
+			) => {
 				if (!isProviderSupported(provider)) {
 					const available = getSupportedProviders();
 					throw new ConfigError({
@@ -630,7 +672,37 @@ export namespace Config {
 					});
 				}
 				const mutableConfig = getMutableConfig();
-				const updated = { ...mutableConfig, provider, model };
+				const existingProviderOptions = mutableConfig.providerOptions ?? {};
+				const nextProviderOptions = providerOptions
+					? {
+							...existingProviderOptions,
+							[provider]: {
+								...(existingProviderOptions[provider] ?? {}),
+								...providerOptions
+							}
+						}
+					: existingProviderOptions;
+				const updated = {
+					...mutableConfig,
+					provider,
+					model,
+					...(providerOptions ? { providerOptions: nextProviderOptions } : {})
+				};
+
+				if (provider === 'openai-compat') {
+					const merged = currentProjectConfig
+						? mergeProviderOptions(currentGlobalConfig, updated)
+						: mergeProviderOptions(updated, null);
+					const compat = merged['openai-compat'];
+					const baseURL = compat?.baseURL?.trim();
+					const name = compat?.name?.trim();
+					if (!baseURL || !name) {
+						throw new ConfigError({
+							message: 'openai-compat requires baseURL and name',
+							hint: 'Run "btca connect -p openai-compat" to configure baseURL and name.'
+						});
+					}
+				}
 				setMutableConfig(updated);
 				await saveConfig(configPath, updated);
 				Metrics.info('config.model.updated', { provider, model });

package/src/index.ts

@@ -91,7 +91,13 @@ const UpdateModelRequestSchema = z.object({
 		.string()
 		.min(1, 'Model name cannot be empty')
 		.max(LIMITS.MODEL_NAME_MAX)
-		.regex(SAFE_NAME_REGEX, 'Invalid model name format')
+		.regex(SAFE_NAME_REGEX, 'Invalid model name format'),
+	providerOptions: z
+		.object({
+			baseURL: z.string().optional(),
+			name: z.string().optional()
+		})
+		.optional()
 });
 
 /**
@@ -212,7 +218,8 @@ const createApp = (deps: {
 				tag === 'ConfigError' ||
 				tag === 'InvalidProviderError' ||
 				tag === 'InvalidModelError' ||
-				tag === 'ProviderNotConnectedError'
+				tag === 'ProviderNotConnectedError' ||
+				tag === 'ProviderOptionsError'
 					? 400
 					: 500;
 			return c.json({ error: message, tag, ...(hint && { hint }) }, status);
@@ -372,7 +379,11 @@ const createApp = (deps: {
 		// PUT /config/model - Update model configuration
 		.put('/config/model', async (c: HonoContext) => {
 			const decoded = await decodeJson(c.req.raw, UpdateModelRequestSchema);
-			const result = await config.updateModel(decoded.provider, decoded.model);
+			const result = await config.updateModel(
+				decoded.provider,
+				decoded.model,
+				decoded.providerOptions
+			);
 			return c.json(result);
 		})
 

package/src/providers/auth.ts

@@ -25,6 +25,7 @@ export namespace Auth {
 		'github-copilot': ['oauth'],
 		openrouter: ['api'],
 		openai: ['oauth'],
+		'openai-compat': ['api'],
 		anthropic: ['api'],
 		google: ['api', 'oauth']
 	};
@@ -164,6 +165,8 @@ export namespace Auth {
 				return 'Run "btca connect -p github-copilot" and complete device flow OAuth.';
 			case 'openai':
 				return 'Run "opencode auth --provider openai" and complete OAuth.';
+			case 'openai-compat':
+				return 'Set baseURL + name via "btca connect" and optionally add an API key.';
 			case 'anthropic':
 				return 'Run "opencode auth --provider anthropic" and enter an API key.';
 			case 'google':

package/src/providers/model.ts

@@ -52,11 +52,25 @@ export namespace Model {
 		}
 	}
 
+	export class ProviderOptionsError extends Error {
+		readonly _tag = 'ProviderOptionsError';
+		readonly providerId: string;
+		readonly hint: string;
+
+		constructor(args: { providerId: string; message: string; hint: string }) {
+			super(args.message);
+			this.providerId = args.providerId;
+			this.hint = args.hint;
+		}
+	}
+
 	export type ModelOptions = {
 		/** Additional provider options */
 		providerOptions?: Partial<ProviderOptions>;
 		/** Skip authentication check (useful for providers with wellknown auth) */
 		skipAuth?: boolean;
+		/** Allow missing auth for providers that can be used without credentials */
+		allowMissingAuth?: boolean;
 	};
 
 	/**
@@ -92,13 +106,17 @@ export namespace Model {
 		if (!options.skipAuth) {
 			const status = await Auth.getAuthStatus(normalizedProviderId);
 			if (status.status === 'missing') {
-				throw new ProviderNotAuthenticatedError(providerId);
+				if (!options.allowMissingAuth) {
+					throw new ProviderNotAuthenticatedError(providerId);
+				}
 			}
 			if (status.status === 'invalid') {
 				throw new ProviderAuthTypeError({ providerId, authType: status.authType });
 			}
-			apiKey = status.apiKey;
-			accountId = status.accountId;
+			if (status.status === 'ok') {
+				apiKey = status.apiKey;
+				accountId = status.accountId;
+			}
 		}
 
 		// Build provider options
@@ -111,6 +129,20 @@ export namespace Model {
 			providerOptions.apiKey = apiKey;
 		}
 
+		if (normalizedProviderId === 'openai-compat') {
+			const baseURL = providerOptions.baseURL?.trim();
+			const name = providerOptions.name?.trim();
+			if (!baseURL || !name) {
+				throw new ProviderOptionsError({
+					providerId: normalizedProviderId,
+					message: 'openai-compat requires baseURL and name',
+					hint: 'Run "btca connect -p openai-compat" to configure baseURL and name.'
+				});
+			}
+			providerOptions.baseURL = baseURL;
+			providerOptions.name = name;
+		}
+
 		// Create the provider and get the model
 		const provider = factory(providerOptions);
 		const model = provider(modelId);

package/src/providers/openai-compat.ts

@@ -0,0 +1,24 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+
+export const createOpenAICompat = (
+	options: {
+		apiKey?: string;
+		baseURL?: string;
+		name?: string;
+	} = {}
+) => {
+	const baseURL = options.baseURL?.trim();
+	const name = options.name?.trim();
+
+	if (!baseURL || !name) {
+		throw new Error('openai-compat requires baseURL and name');
+	}
+
+	const provider = createOpenAICompatible({
+		apiKey: options.apiKey,
+		baseURL,
+		name
+	});
+
+	return (modelId: string) => provider.chatModel(modelId);
+};

package/src/providers/registry.ts

@@ -8,6 +8,7 @@ import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createCopilotProvider } from './copilot.ts';
 import { createOpenCodeZen } from './opencode.ts';
 import { createOpenAICodex } from './openai.ts';
+import { createOpenAICompat } from './openai-compat.ts';
 import { createOpenRouter } from './openrouter.ts';
 
 // Type for provider factory options
@@ -37,6 +38,8 @@ export const PROVIDER_REGISTRY: Record<string, ProviderFactory> = {
 
 	// OpenAI
 	openai: createOpenAICodex as ProviderFactory,
+	// OpenAI-compatible
+	'openai-compat': createOpenAICompat as ProviderFactory,
 	// GitHub Copilot
 	'github-copilot': createCopilotProvider as ProviderFactory,
 	// Google