btca-server 1.0.89 → 1.0.91

package/README.md

@@ -102,13 +102,14 @@ Clear all locally cloned resources.
 POST /question
 ```
 
-Ask a question (non-streaming response).
+Ask a question (non-streaming response). The `resources` field accepts configured resource names or HTTPS Git URLs.
 
 ```
 POST /question/stream
 ```
 
-Ask a question with streaming SSE response.
+Ask a question with streaming SSE response. The `resources` field accepts configured resource names or HTTPS Git URLs.
+The final `done` SSE event may include optional usage/metrics (tokens, timing, throughput, and best-effort pricing).
 
 ### Model Configuration
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "btca-server",
-	"version": "1.0.89",
+	"version": "1.0.91",
 	"description": "BTCA server for answering questions about your codebase using OpenCode AI",
 	"author": "Ben Davis",
 	"license": "MIT",
@@ -61,6 +61,7 @@
 		"hono": "^4.7.11",
 		"just-bash": "^2.7.0",
 		"opencode-ai": "^1.1.36",
+		"vercel-minimax-ai-provider": "^0.0.2",
 		"zod": "^3.25.76"
 	}
 }

package/src/agent/loop.ts

@@ -18,7 +18,12 @@ export namespace AgentLoop {
 		| {
 				type: 'finish';
 				finishReason: string;
-				usage?: { inputTokens?: number; outputTokens?: number };
+				usage?: {
+					inputTokens?: number;
+					outputTokens?: number;
+					reasoningTokens?: number;
+					totalTokens?: number;
+				};
 		  }
 		| { type: 'error'; error: Error };
 
@@ -213,7 +218,11 @@ export namespace AgentLoop {
 						finishReason: part.finishReason ?? 'unknown',
 						usage: {
 							inputTokens: part.totalUsage?.inputTokens,
-							outputTokens: part.totalUsage?.outputTokens
+							outputTokens: part.totalUsage?.outputTokens,
+							reasoningTokens:
+								part.totalUsage?.outputTokenDetails?.reasoningTokens ??
+								part.totalUsage?.reasoningTokens,
+							totalTokens: part.totalUsage?.totalTokens
 						}
 					});
 					break;
@@ -322,7 +331,11 @@ export namespace AgentLoop {
 						finishReason: part.finishReason ?? 'unknown',
 						usage: {
 							inputTokens: part.totalUsage?.inputTokens,
-							outputTokens: part.totalUsage?.outputTokens
+							outputTokens: part.totalUsage?.outputTokens,
+							reasoningTokens:
+								part.totalUsage?.outputTokenDetails?.reasoningTokens ??
+								part.totalUsage?.reasoningTokens,
+							totalTokens: part.totalUsage?.totalTokens
 						}
 					};
 					break;

package/src/agent/service.ts

@@ -119,10 +119,16 @@ export namespace Agent {
 				questionLength: question.length
 			});
 
-			const cleanup = () => {
-				if (!collection.vfsId) return;
-				VirtualFs.dispose(collection.vfsId);
-				clearVirtualCollectionMetadata(collection.vfsId);
+			const cleanup = async () => {
+				if (collection.vfsId) {
+					VirtualFs.dispose(collection.vfsId);
+					clearVirtualCollectionMetadata(collection.vfsId);
+				}
+				try {
+					await collection.cleanup?.();
+				} catch {
+					// cleanup should never fail user-visible operations
+				}
 			};
 
 			// Validate provider is authenticated
@@ -130,7 +136,7 @@ export namespace Agent {
 			const requiresAuth = config.provider !== 'opencode' && config.provider !== 'openai-compat';
 			if (!isAuthed && requiresAuth) {
 				const authenticated = await Auth.getAuthenticatedProviders();
-				cleanup();
+				await cleanup();
 				throw new ProviderNotConnectedError({
 					providerId: config.provider,
 					connectedProviders: authenticated
@@ -153,7 +159,7 @@ export namespace Agent {
 						yield event;
 					}
 				} finally {
-					cleanup();
+					await cleanup();
 				}
 			})();
 
@@ -173,10 +179,16 @@ export namespace Agent {
 				questionLength: question.length
 			});
 
-			const cleanup = () => {
-				if (!collection.vfsId) return;
-				VirtualFs.dispose(collection.vfsId);
-				clearVirtualCollectionMetadata(collection.vfsId);
+			const cleanup = async () => {
+				if (collection.vfsId) {
+					VirtualFs.dispose(collection.vfsId);
+					clearVirtualCollectionMetadata(collection.vfsId);
+				}
+				try {
+					await collection.cleanup?.();
+				} catch {
+					// cleanup should never fail user-visible operations
+				}
 			};
 
 			// Validate provider is authenticated
@@ -184,7 +196,7 @@ export namespace Agent {
 			const requiresAuth = config.provider !== 'opencode' && config.provider !== 'openai-compat';
 			if (!isAuthed && requiresAuth) {
 				const authenticated = await Auth.getAuthenticatedProviders();
-				cleanup();
+				await cleanup();
 				throw new ProviderNotConnectedError({
 					providerId: config.provider,
 					connectedProviders: authenticated
@@ -203,7 +215,7 @@ export namespace Agent {
 				})
 			);
 
-			cleanup();
+			await cleanup();
 
 			return runResult.match({
 				ok: (result) => {

package/src/collections/service.ts

@@ -135,13 +135,37 @@ export namespace Collections {
 		});
 	};
 
+	const getGitHeadBranch = async (resourcePath: string) => {
+		const result = await Result.tryPromise(async () => {
+			const proc = Bun.spawn(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], {
+				cwd: resourcePath,
+				stdout: 'pipe',
+				stderr: 'pipe'
+			});
+			const stdout = await new Response(proc.stdout).text();
+			const exitCode = await proc.exited;
+			if (exitCode !== 0) return undefined;
+			const trimmed = stdout.trim();
+			if (!trimmed || trimmed === 'HEAD') return undefined;
+			return trimmed;
+		});
+
+		return result.match({
+			ok: (value) => value,
+			err: () => undefined
+		});
+	};
+
+	const ANON_PREFIX = 'anonymous:';
+	const getAnonymousUrlFromName = (name: string) =>
+		name.startsWith(ANON_PREFIX) ? name.slice(ANON_PREFIX.length) : undefined;
+
 	const buildVirtualMetadata = async (args: {
 		resource: BtcaFsResource;
 		resourcePath: string;
 		loadedAt: string;
 		definition?: ReturnType<Config.Service['getResource']>;
 	}) => {
-		if (!args.definition) return null;
 		const base = {
 			name: args.resource.name,
 			fsName: args.resource.fsName,
@@ -150,13 +174,19 @@ export namespace Collections {
 			repoSubPaths: args.resource.repoSubPaths,
 			loadedAt: args.loadedAt
 		};
-		if (!isGitResource(args.definition)) return base;
+		if (args.resource.type !== 'git') return base;
+
+		const configuredDefinition =
+			args.definition && isGitResource(args.definition) ? args.definition : null;
+		const url = configuredDefinition?.url ?? getAnonymousUrlFromName(args.resource.name);
+		const branch = configuredDefinition?.branch ?? (await getGitHeadBranch(args.resourcePath));
 		const commit = await getGitHeadHash(args.resourcePath);
+
 		return {
 			...base,
-			url: args.definition.url,
-			branch: args.definition.branch,
-			commit
+			...(url ? { url } : {}),
+			...(branch ? { branch } : {}),
+			...(commit ? { commit } : {})
 		};
 	};
 
@@ -184,11 +214,18 @@ export namespace Collections {
 						VirtualFs.dispose(vfsId);
 						clearVirtualCollectionMetadata(vfsId);
 					};
+					const cleanupResources = (resources: BtcaFsResource[]) =>
+						Promise.all(
+							resources.map(async (resource) => {
+								if (!resource.cleanup) return;
+								await ignoreErrors(() => resource.cleanup!());
+							})
+						);
 
+					const loadedResources: BtcaFsResource[] = [];
 					const result = await Result.gen(async function* () {
 						yield* Result.await(initVirtualRoot(collectionPath, vfsId));
 
-						const loadedResources: BtcaFsResource[] = [];
 						for (const name of sortedNames) {
 							const resource = yield* Result.await(loadResource(args.resources, name, quiet));
 							loadedResources.push(resource);
@@ -235,17 +272,19 @@ export namespace Collections {
 						return Result.ok({
 							path: collectionPath,
 							agentInstructions: instructionBlocks.join('\n\n'),
-							vfsId
+							vfsId,
+							cleanup: async () => {
+								await cleanupResources(loadedResources);
+							}
 						});
 					});
 
-					return result.match({
-						ok: (value) => value,
-						err: (error) => {
-							cleanupVirtual();
-							throw error;
-						}
-					});
+					if (!Result.isOk(result)) {
+						cleanupVirtual();
+						await cleanupResources(loadedResources);
+						throw result.error;
+					}
+					return result.value;
 				})
 		};
 	};

package/src/collections/types.ts

@@ -5,6 +5,7 @@ export type CollectionResult = {
 	path: string;
 	agentInstructions: string;
 	vfsId?: string;
+	cleanup?: () => Promise<void>;
 };
 
 export class CollectionError extends Error {

package/src/config/config.test.ts

@@ -443,15 +443,17 @@ describe('Config', () => {
 			const config = await Config.load();
 
 			// Update the model
-			await config.updateModel('new-provider', 'new-model');
+			const nextProvider = 'openrouter';
+			const nextModel = 'openai/gpt-4o-mini';
+			await config.updateModel(nextProvider, nextModel);
 
-			expect(config.provider).toBe('new-provider');
-			expect(config.model).toBe('new-model');
+			expect(config.provider).toBe(nextProvider);
+			expect(config.model).toBe(nextModel);
 
 			// CRITICAL: Verify project config was updated
 			const savedProjectConfig = JSON.parse(await fs.readFile(projectConfigPath, 'utf-8'));
-			expect(savedProjectConfig.provider).toBe('new-provider');
-			expect(savedProjectConfig.model).toBe('new-model');
+			expect(savedProjectConfig.provider).toBe(nextProvider);
+			expect(savedProjectConfig.model).toBe(nextModel);
 			// Global resources should NOT have leaked into project config
 			expect(savedProjectConfig.resources.length).toBe(0);
 

package/src/config/index.ts

@@ -464,12 +464,8 @@ export namespace Config {
 			return Result.ok(migrated);
 		});
 
-		const saved = result.match({
-			ok: (value) => value,
-			err: (error) => {
-				throw error;
-			}
-		});
+		if (!Result.isOk(result)) throw result.error;
+		const saved = result.value;
 
 		Metrics.info('config.legacy.migrated', {
 			newPath: newConfigPath,
@@ -498,12 +494,8 @@ export namespace Config {
 			return Result.ok(stored);
 		});
 
-		return result.match({
-			ok: (value) => value,
-			err: (error) => {
-				throw error;
-			}
-		});
+		if (!Result.isOk(result)) throw result.error;
+		return result.value;
 	};
 
 	const createDefaultConfig = async (configPath: string): Promise<StoredConfig> => {
@@ -540,12 +532,8 @@ export namespace Config {
 			return Result.ok(defaultStored);
 		});
 
-		return result.match({
-			ok: (value) => value,
-			err: (error) => {
-				throw error;
-			}
-		});
+		if (!Result.isOk(result)) throw result.error;
+		return result.value;
 	};
 
 	const saveConfig = async (configPath: string, stored: StoredConfig): Promise<void> => {
@@ -555,12 +543,7 @@ export namespace Config {
 			`Failed to save config to: "${configPath}"`,
 			'Check that you have write permissions and the disk is not full.'
 		);
-		result.match({
-			ok: () => undefined,
-			err: (error) => {
-				throw error;
-			}
-		});
+		if (!Result.isOk(result)) throw result.error;
 	};
 
 	/**

package/src/config/remote.ts

@@ -308,12 +308,8 @@ export namespace RemoteConfigService {
 			return Result.ok(undefined);
 		});
 
-		result.match({
-			ok: () => Metrics.info('remote.auth.saved', { path: authPath }),
-			err: (error) => {
-				throw error;
-			}
-		});
+		if (!Result.isOk(result)) throw result.error;
+		Metrics.info('remote.auth.saved', { path: authPath });
 	}
 
 	/**
@@ -394,16 +390,11 @@ export namespace RemoteConfigService {
 				})
 		});
 
-		result.match({
-			ok: () =>
-				Metrics.info('remote.config.saved', {
-					path: configPath,
-					project: config.project,
-					resourceCount: config.resources.length
-				}),
-			err: (error) => {
-				throw error;
-			}
+		if (!Result.isOk(result)) throw result.error;
+		Metrics.info('remote.config.saved', {
+			path: configPath,
+			project: config.project,
+			resourceCount: config.resources.length
 		});
 	}
 

package/src/errors.ts

@@ -61,7 +61,7 @@ export const CommonHints = {
 	CHECK_NETWORK: 'Check your internet connection and try again.',
 	CHECK_URL: 'Verify the URL is correct and the repository exists.',
 	CHECK_BRANCH:
-		'Verify the branch name exists in the repository. Common branches are "main", "master", or "dev".',
+		'Verify the branch name exists in the repository. Common branches are "main", "master", "trunk", or "dev".',
 	CHECK_CONFIG: 'Check your btca config file for errors.',
 	CHECK_PERMISSIONS:
 		'Ensure you have access to the repository. Private repos require authentication.',

package/src/index.ts

@@ -10,11 +10,17 @@ import { Config } from './config/index.ts';
 import { Context } from './context/index.ts';
 import { getErrorMessage, getErrorTag, getErrorHint } from './errors.ts';
 import { Metrics } from './metrics/index.ts';
+import { ModelsDevPricing } from './pricing/models-dev.ts';
 import { Resources } from './resources/service.ts';
 import { GitResourceSchema, LocalResourceSchema } from './resources/schema.ts';
 import { StreamService } from './stream/service.ts';
 import type { BtcaStreamMetaEvent } from './stream/types.ts';
-import { LIMITS, normalizeGitHubUrl } from './validation/index.ts';
+import {
+	LIMITS,
+	normalizeGitHubUrl,
+	validateGitUrl,
+	validateResourceReference
+} from './validation/index.ts';
 import { clearAllVirtualCollectionMetadata } from './collections/virtual-metadata.ts';
 import { VirtualFs } from './vfs/virtual-fs.ts';
 
@@ -37,6 +43,8 @@ import { VirtualFs } from './vfs/virtual-fs.ts';
 const DEFAULT_PORT = 8080;
 const PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : DEFAULT_PORT;
 
+const modelsDevPricing = ModelsDevPricing.create();
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Request Schemas
 // ─────────────────────────────────────────────────────────────────────────────
@@ -63,6 +71,22 @@ const ResourceNameField = z
 	.refine((name) => !name.includes('//'), 'Resource name must not contain "//"')
 	.refine((name) => !name.endsWith('/'), 'Resource name must not end with "/"');
 
+const ResourceReferenceField = z.string().superRefine((value, ctx) => {
+	const result = validateResourceReference(value);
+	if (!result.valid) {
+		ctx.addIssue({
+			code: 'custom',
+			message: result.error
+		});
+	}
+});
+
+const normalizeQuestionResourceReference = (reference: string): string => {
+	const gitUrlResult = validateGitUrl(reference);
+	if (gitUrlResult.valid) return gitUrlResult.value;
+	return reference;
+};
+
 const QuestionRequestSchema = z.object({
 	question: z
 		.string()
@@ -72,7 +96,7 @@ const QuestionRequestSchema = z.object({
 			`Question too long (max ${LIMITS.QUESTION_MAX.toLocaleString()} chars). This includes conversation history - try starting a new thread or clearing the chat.`
 		),
 	resources: z
-		.array(ResourceNameField)
+		.array(ResourceReferenceField)
 		.max(
 			LIMITS.MAX_RESOURCES_PER_REQUEST,
 			`Too many resources (max ${LIMITS.MAX_RESOURCES_PER_REQUEST})`
@@ -295,7 +319,7 @@ const createApp = (deps: {
 			const decoded = await decodeJson(c.req.raw, QuestionRequestSchema);
 			const resourceNames =
 				decoded.resources && decoded.resources.length > 0
-					? decoded.resources
+					? Array.from(new Set(decoded.resources.map(normalizeQuestionResourceReference)))
 					: config.resources.map((r) => r.name);
 
 			const collectionKey = getCollectionKey(resourceNames);
@@ -327,10 +351,11 @@ const createApp = (deps: {
 
 		// POST /question/stream
 		.post('/question/stream', async (c: HonoContext) => {
+			const requestStartMs = performance.now();
 			const decoded = await decodeJson(c.req.raw, QuestionRequestSchema);
 			const resourceNames =
 				decoded.resources && decoded.resources.length > 0
-					? decoded.resources
+					? Array.from(new Set(decoded.resources.map(normalizeQuestionResourceReference)))
 					: config.resources.map((r) => r.name);
 
 			const collectionKey = getCollectionKey(resourceNames);
@@ -361,10 +386,13 @@ const createApp = (deps: {
 			} satisfies BtcaStreamMetaEvent;
 
 			Metrics.info('question.stream.start', { collectionKey });
+			modelsDevPricing.prefetch();
 			const stream = StreamService.createSseStream({
 				meta,
 				eventStream,
-				question: decoded.question
+				question: decoded.question,
+				requestStartMs,
+				pricing: modelsDevPricing
 			});
 
 			return new Response(stream, {

package/src/metrics/index.ts

@@ -46,20 +46,12 @@ export namespace Metrics {
 	): Promise<T> => {
 		const start = performance.now();
 		const result = await Result.tryPromise(fn);
-		return result.match({
-			ok: (value) => {
-				info('span.ok', { name, ms: Math.round(performance.now() - start), ...fields });
-				return value;
-			},
-			err: (cause) => {
-				error('span.err', {
-					name,
-					ms: Math.round(performance.now() - start),
-					...fields,
-					error: errorInfo(cause)
-				});
-				throw cause;
-			}
-		});
+		const ms = Math.round(performance.now() - start);
+		if (!Result.isOk(result)) {
+			error('span.err', { name, ms, ...fields, error: errorInfo(result.error) });
+			throw result.error;
+		}
+		info('span.ok', { name, ms, ...fields });
+		return result.value;
 	};
 }