btca-server 1.0.92 → 1.0.93

package/README.md

@@ -125,7 +125,7 @@ The server reads configuration from `~/.btca/config.toml` or your local project'
 
 - **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
+- **Resources**: Local directories, git repositories, or npm packages to query
 
 Example config.toml:
 
@@ -144,6 +144,12 @@ type = "git"
 name = "some-repo"
 url = "https://github.com/user/repo"
 branch = "main"
+
+[[resources]]
+type = "npm"
+name = "react-npm"
+package = "react"
+version = "latest"
 ```
 
 ## Supported Providers

package/package.json

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

package/src/agent/loop.ts

@@ -61,10 +61,19 @@ export namespace AgentLoop {
 			'- list: List directory contents',
 			'',
 			'Guidelines:',
-			'- Use glob to find relevant files first, then read them',
-			'- Use grep to search for specific code patterns or text',
-			'- Always cite the source files in your answers',
-			'- Be concise but thorough in your responses',
+			'- Ground answers in the loaded resources. Do not rely on unstated prior knowledge.',
+			'- Search efficiently: start with one focused list/glob pass, then read likely files; only expand search when evidence is insufficient.',
+			'- Prefer targeted grep/read over broad repeated scans once candidate files are known.',
+			'- Give clear, unambiguous answers. State assumptions, prerequisites, and important version-sensitive caveats.',
+			'- For implementation/how-to questions, provide complete step-by-step instructions with commands and code snippets.',
+			'- Be concise but thorough in your responses.',
+			'- End every answer with a "Sources" section.',
+			'- For git resources, source links must be full GitHub blob URLs.',
+			'- In "Sources", format git citations as markdown links: "- [repo/relative/path.ext](https://github.com/.../blob/.../repo/relative/path.ext)".',
+			'- Do not use raw URLs as link labels.',
+			'- Do not repeat a URL in parentheses after a link.',
+			'- Do not output sources in "url (url)" format.',
+			'- For local resources, cite local file paths (no GitHub URL required).',
 			'- If you cannot find the answer, say so clearly',
 			'',
 			agentInstructions

package/src/agent/service.ts

@@ -5,7 +5,7 @@
 import { Result } from 'better-result';
 
 import { Config } from '../config/index.ts';
-import { type TaggedErrorOptions } from '../errors.ts';
+import { getErrorHint, getErrorMessage, 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';
@@ -217,30 +217,30 @@ export namespace Agent {
 
 			await cleanup();
 
-			return runResult.match({
-				ok: (result) => {
-					Metrics.info('agent.ask.complete', {
-						provider: config.provider,
-						model: config.model,
-						answerLength: result.answer.length,
-						eventCount: result.events.length
-					});
+			if (!Result.isOk(runResult)) {
+				const cause = runResult.error;
+				Metrics.error('agent.ask.error', { error: Metrics.errorInfo(cause) });
+				throw new AgentError({
+					message: getErrorMessage(cause),
+					hint:
+						getErrorHint(cause) ?? 'This may be a temporary issue. Try running the command again.',
+					cause
+				});
+			}
 
-					return {
-						answer: result.answer,
-						model: result.model,
-						events: result.events
-					};
-				},
-				err: (error) => {
-					Metrics.error('agent.ask.error', { error: Metrics.errorInfo(error) });
-					throw new AgentError({
-						message: 'Failed to get response from AI',
-						hint: 'This may be a temporary issue. Try running the command again.',
-						cause: error
-					});
-				}
+			const result = runResult.value;
+			Metrics.info('agent.ask.complete', {
+				provider: config.provider,
+				model: config.model,
+				answerLength: result.answer.length,
+				eventCount: result.events.length
 			});
+
+			return {
+				answer: result.answer,
+				model: result.model,
+				events: result.events
+			};
 		};
 
 		/**

package/src/collections/service.ts

@@ -7,8 +7,9 @@ import { Transaction } from '../context/transaction.ts';
 import { CommonHints, getErrorHint, getErrorMessage } from '../errors.ts';
 import { Metrics } from '../metrics/index.ts';
 import { Resources } from '../resources/service.ts';
-import { isGitResource } from '../resources/schema.ts';
+import { isGitResource, isNpmResource } from '../resources/schema.ts';
 import { FS_RESOURCE_SYSTEM_NOTE, type BtcaFsResource } from '../resources/types.ts';
+import { parseNpmReference } from '../validation/index.ts';
 import { CollectionError, getCollectionKey, type CollectionResult } from './types.ts';
 import { VirtualFs } from '../vfs/virtual-fs.ts';
 import {
@@ -25,14 +26,51 @@ export namespace Collections {
 		}) => Promise<CollectionResult>;
 	};
 
-	const createCollectionInstructionBlock = (resource: BtcaFsResource): string => {
+	const encodePathSegments = (value: string) => value.split('/').map(encodeURIComponent).join('/');
+
+	const trimGitSuffix = (url: string) => url.replace(/\.git$/u, '').replace(/\/+$/u, '');
+	const getNpmCitationAlias = (metadata?: VirtualResourceMetadata) => {
+		if (!metadata?.package) return undefined;
+		return `npm:${metadata.package}@${metadata.version ?? 'latest'}`;
+	};
+
+	const createCollectionInstructionBlock = (
+		resource: BtcaFsResource,
+		metadata?: VirtualResourceMetadata
+	): string => {
 		const focusLines = resource.repoSubPaths.map(
 			(subPath) => `Focus: ./${resource.fsName}/${subPath}`
 		);
+		const gitRef = metadata?.branch ?? metadata?.commit;
+		const githubPrefix =
+			resource.type === 'git' && metadata?.url && gitRef
+				? `${trimGitSuffix(metadata.url)}/blob/${encodeURIComponent(gitRef)}`
+				: undefined;
+		const npmCitationAlias = resource.type === 'npm' ? getNpmCitationAlias(metadata) : undefined;
 		const lines = [
 			`## Resource: ${resource.name}`,
 			FS_RESOURCE_SYSTEM_NOTE,
 			`Path: ./${resource.fsName}`,
+			resource.type === 'git' && metadata?.url ? `Repo URL: ${trimGitSuffix(metadata.url)}` : '',
+			resource.type === 'git' && metadata?.branch ? `Repo Branch: ${metadata.branch}` : '',
+			resource.type === 'git' && metadata?.commit ? `Repo Commit: ${metadata.commit}` : '',
+			resource.type === 'npm' && metadata?.package ? `NPM Package: ${metadata.package}` : '',
+			resource.type === 'npm' && metadata?.version ? `NPM Version: ${metadata.version}` : '',
+			resource.type === 'npm' && metadata?.url ? `NPM URL: ${metadata.url}` : '',
+			npmCitationAlias ? `NPM Citation Alias: ${npmCitationAlias}` : '',
+			githubPrefix ? `GitHub Blob Prefix: ${githubPrefix}` : '',
+			githubPrefix
+				? `GitHub Citation Rule: Convert virtual paths under ./${resource.fsName}/ to repo-relative paths, then encode each path segment for GitHub URLs (example segment: "+page.server.js" -> "${encodeURIComponent('+page.server.js')}").`
+				: '',
+			githubPrefix
+				? `GitHub Citation Example: ${githubPrefix}/${encodePathSegments('src/routes/blog/+page.server.js')}`
+				: '',
+			resource.type !== 'git'
+				? 'Citation Rule: Cite local file paths only for this resource (no GitHub URL).'
+				: '',
+			npmCitationAlias
+				? `NPM Citation Rule: In "Sources", cite npm files using "${npmCitationAlias}/<file>" (for example, "${npmCitationAlias}/README.md"). Do not cite encoded virtual folder names.`
+				: '',
 			...focusLines,
 			resource.specialAgentInstructions ? `Notes: ${resource.specialAgentInstructions}` : ''
 		].filter(Boolean);
@@ -159,6 +197,32 @@ export namespace Collections {
 	const ANON_PREFIX = 'anonymous:';
 	const getAnonymousUrlFromName = (name: string) =>
 		name.startsWith(ANON_PREFIX) ? name.slice(ANON_PREFIX.length) : undefined;
+	const NPM_ANON_PREFIX = `${ANON_PREFIX}npm:`;
+	const NPM_META_FILE = '.btca-npm-meta.json';
+	const getAnonymousNpmReferenceFromName = (name: string) =>
+		name.startsWith(NPM_ANON_PREFIX) ? name.slice(ANON_PREFIX.length) : undefined;
+
+	const readNpmMeta = async (resourcePath: string) => {
+		const result = await Result.gen(async function* () {
+			const content = yield* Result.await(
+				Result.tryPromise(() => Bun.file(path.join(resourcePath, NPM_META_FILE)).text())
+			);
+			const parsed = yield* Result.try(
+				() =>
+					JSON.parse(content) as {
+						packageName?: string;
+						resolvedVersion?: string;
+						packageUrl?: string;
+					}
+			);
+			return Result.ok(parsed);
+		});
+
+		return result.match({
+			ok: (value) => value,
+			err: () => null
+		});
+	};
 
 	const buildVirtualMetadata = async (args: {
 		resource: BtcaFsResource;
@@ -174,6 +238,27 @@ export namespace Collections {
 			repoSubPaths: args.resource.repoSubPaths,
 			loadedAt: args.loadedAt
 		};
+
+		if (args.resource.type === 'npm') {
+			const configuredDefinition =
+				args.definition && isNpmResource(args.definition) ? args.definition : null;
+			const anonymousReference = getAnonymousNpmReferenceFromName(args.resource.name);
+			const anonymousNpm = anonymousReference ? parseNpmReference(anonymousReference) : null;
+			const cached = await readNpmMeta(args.resourcePath);
+			const packageName =
+				configuredDefinition?.package ?? cached?.packageName ?? anonymousNpm?.packageName;
+			const version =
+				configuredDefinition?.version ?? cached?.resolvedVersion ?? anonymousNpm?.version;
+			const url = cached?.packageUrl ?? anonymousNpm?.packageUrl;
+
+			return {
+				...base,
+				...(packageName ? { package: packageName } : {}),
+				...(version ? { version } : {}),
+				...(url ? { url } : {})
+			};
+		}
+
 		if (args.resource.type !== 'git') return base;
 
 		const configuredDefinition =
@@ -267,7 +352,12 @@ export namespace Collections {
 							resources: metadataResources
 						});
 
-						const instructionBlocks = loadedResources.map(createCollectionInstructionBlock);
+						const metadataByName = new Map(
+							metadataResources.map((resource) => [resource.name, resource])
+						);
+						const instructionBlocks = loadedResources.map((resource) =>
+							createCollectionInstructionBlock(resource, metadataByName.get(resource.name))
+						);
 
 						return Result.ok({
 							path: collectionPath,

package/src/collections/virtual-metadata.ts

@@ -1,12 +1,14 @@
 export type VirtualResourceMetadata = {
 	name: string;
 	fsName: string;
-	type: 'git' | 'local';
+	type: 'git' | 'local' | 'npm';
 	path: string;
 	repoSubPaths: readonly string[];
 	url?: string;
 	branch?: string;
 	commit?: string;
+	package?: string;
+	version?: string;
 	loadedAt: string;
 };
 

package/src/config/config.test.ts

@@ -66,6 +66,34 @@ describe('Config', () => {
 			expect(config.getResource('svelte')).toBeDefined();
 		});
 
+		it('loads npm resources from config', async () => {
+			const projectConfig = {
+				$schema: 'https://btca.dev/btca.schema.json',
+				provider: 'test-provider',
+				model: 'test-model',
+				resources: [
+					{
+						name: 'reactNpm',
+						type: 'npm',
+						package: 'react',
+						version: 'latest'
+					}
+				]
+			};
+
+			await fs.writeFile(path.join(testDir, 'btca.config.jsonc'), JSON.stringify(projectConfig));
+			process.chdir(testDir);
+
+			const config = await Config.load();
+			const npmResource = config.getResource('reactNpm');
+			expect(npmResource).toBeDefined();
+			expect(npmResource?.type).toBe('npm');
+			if (npmResource?.type === 'npm') {
+				expect(npmResource.package).toBe('react');
+				expect(npmResource.version).toBe('latest');
+			}
+		});
+
 		it('handles JSONC with comments', async () => {
 			const projectConfigWithComments = `{
 				// This is a comment

package/src/config/index.ts

@@ -71,6 +71,7 @@ const StoredConfigSchema = z.object({
 type StoredConfig = z.infer<typeof StoredConfigSchema>;
 type ProviderOptionsConfig = z.infer<typeof ProviderOptionsSchema>;
 type ProviderOptionsMap = z.infer<typeof ProviderOptionsMapSchema>;
+type ConfigScope = 'project' | 'global';
 
 // Legacy config schemas (btca.json format from old CLI)
 // There are two legacy formats:
@@ -137,7 +138,7 @@ export namespace Config {
 			provider: string,
 			model: string,
 			providerOptions?: ProviderOptionsConfig
-		) => Promise<{ provider: string; model: string }>;
+		) => Promise<{ provider: string; model: string; savedTo: ConfigScope }>;
 		addResource: (resource: ResourceDefinition) => Promise<ResourceDefinition>;
 		removeResource: (name: string) => Promise<void>;
 		clearResources: () => Promise<{ cleared: number }>;
@@ -689,7 +690,11 @@ export namespace Config {
 				setMutableConfig(updated);
 				await saveConfig(configPath, updated);
 				Metrics.info('config.model.updated', { provider, model });
-				return { provider, model };
+				return {
+					provider,
+					model,
+					savedTo: currentProjectConfig ? 'project' : 'global'
+				};
 			},
 
 			addResource: async (resource: ResourceDefinition) => {

package/src/errors.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'bun:test';
+
+import { formatErrorForDisplay, getErrorHint, getErrorMessage, getErrorTag } from './errors.ts';
+
+describe('errors', () => {
+	it('unwraps panic wrappers to the underlying tagged error details', () => {
+		const providerError = Object.assign(new Error('Provider "opencode" is not authenticated.'), {
+			_tag: 'ProviderNotAuthenticatedError',
+			hint: 'Run "opencode auth" to configure provider credentials.'
+		});
+		const wrapped = {
+			_tag: 'Panic',
+			message: 'match err handler threw',
+			cause: {
+				_tag: 'AgentError',
+				message: 'Failed to get response from AI',
+				hint: 'This may be a temporary issue. Try running the command again.',
+				cause: {
+					_tag: 'UnhandledException',
+					message: 'Unhandled exception: Provider "opencode" is not authenticated.',
+					cause: providerError
+				}
+			}
+		};
+
+		expect(getErrorTag(wrapped)).toBe('ProviderNotAuthenticatedError');
+		expect(getErrorMessage(wrapped)).toBe('Provider "opencode" is not authenticated.');
+		expect(getErrorHint(wrapped)).toBe('Run "opencode auth" to configure provider credentials.');
+		expect(formatErrorForDisplay(wrapped)).toBe(
+			'Provider "opencode" is not authenticated.\n\nHint: Run "opencode auth" to configure provider credentials.'
+		);
+	});
+
+	it('keeps contextual non-wrapper error messages', () => {
+		const error = {
+			_tag: 'CollectionError',
+			message: 'Failed to load resource "npm:prettier": missing docs index',
+			hint: 'Try running "btca clear" and reload resources.',
+			cause: {
+				_tag: 'Panic',
+				message: 'match err handler threw',
+				cause: new Error('boom')
+			}
+		};
+
+		expect(getErrorTag(error)).toBe('CollectionError');
+		expect(getErrorMessage(error)).toBe(
+			'Failed to load resource "npm:prettier": missing docs index'
+		);
+		expect(getErrorHint(error)).toBe('Try running "btca clear" and reload resources.');
+	});
+
+	it('handles cyclic cause chains without throwing', () => {
+		const cyclic = { _tag: 'Panic', message: 'match err handler threw' } as {
+			_tag: string;
+			message: string;
+			cause?: unknown;
+		};
+		cyclic.cause = cyclic;
+
+		expect(getErrorTag(cyclic)).toBe('Panic');
+		expect(getErrorMessage(cyclic)).toBe('match err handler threw');
+		expect(getErrorHint(cyclic)).toBeUndefined();
+	});
+});

package/src/errors.ts

@@ -11,22 +11,115 @@ export type TaggedErrorLike = {
 	readonly hint?: string;
 };
 
+const MAX_CAUSE_DEPTH = 12;
+const WRAPPER_TAGS = new Set(['Panic', 'UnhandledException']);
+const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
+	typeof value === 'object' && value !== null;
+
+const readStringField = (value: unknown, field: '_tag' | 'message' | 'hint') => {
+	if (!isObjectRecord(value) || !(field in value)) return undefined;
+	const candidate = value[field];
+	return typeof candidate === 'string' && candidate.length > 0 ? candidate : undefined;
+};
+
+const readCauseField = (value: unknown) => {
+	if (!isObjectRecord(value) || !('cause' in value)) return undefined;
+	return value.cause;
+};
+
+const isWrapperMessage = (message?: string) =>
+	Boolean(
+		message &&
+		(message.startsWith('Unhandled exception:') ||
+			/handler threw$/u.test(message) ||
+			/callback threw$/u.test(message))
+	);
+
+const normalizeMessage = (message: string) => {
+	if (!message.startsWith('Unhandled exception:')) return message;
+	const stripped = message.slice('Unhandled exception:'.length).trim();
+	return stripped.length > 0 ? stripped : message;
+};
+
+const isWrapperEntry = (entry: unknown) => {
+	const tag = readStringField(entry, '_tag');
+	const message = readStringField(entry, 'message');
+	const hasCause = readCauseField(entry) !== undefined;
+	const isAgentWrapper =
+		tag === 'AgentError' && message === 'Failed to get response from AI' && hasCause;
+	return (
+		isAgentWrapper || (tag !== undefined && WRAPPER_TAGS.has(tag)) || isWrapperMessage(message)
+	);
+};
+
+const getErrorChain = (error: unknown) => {
+	const chain: unknown[] = [];
+	const visited = new Set<unknown>();
+	let current: unknown = error;
+	let depth = 0;
+
+	while (current !== undefined && depth < MAX_CAUSE_DEPTH && !visited.has(current)) {
+		chain.push(current);
+		visited.add(current);
+		const cause = readCauseField(current);
+		if (cause === undefined) break;
+		current = cause;
+		depth += 1;
+	}
+
+	return chain;
+};
+
 export const getErrorTag = (error: unknown): string => {
-	if (error && typeof error === 'object' && '_tag' in error) return String((error as any)._tag);
+	const chain = getErrorChain(error);
+
+	for (const entry of chain) {
+		const tag = readStringField(entry, '_tag');
+		if (tag && !isWrapperEntry(entry)) return tag;
+	}
+
+	for (const entry of chain) {
+		const tag = readStringField(entry, '_tag');
+		if (tag) return tag;
+	}
+
 	return 'UnknownError';
 };
 
 export const getErrorMessage = (error: unknown): string => {
-	if (error && typeof error === 'object' && 'message' in error)
-		return String((error as any).message);
+	const chain = getErrorChain(error);
+
+	for (const entry of chain) {
+		const message = readStringField(entry, 'message');
+		if (message && !isWrapperEntry(entry)) return message;
+	}
+
+	for (const entry of chain) {
+		const message = readStringField(entry, 'message');
+		if (message && !isWrapperMessage(message)) return message;
+	}
+
+	for (const entry of chain) {
+		const message = readStringField(entry, 'message');
+		if (message) return normalizeMessage(message);
+	}
+
 	return String(error);
 };
 
 export const getErrorHint = (error: unknown): string | undefined => {
-	if (error && typeof error === 'object' && 'hint' in error) {
-		const hint = (error as any).hint;
-		return typeof hint === 'string' ? hint : undefined;
+	const chain = getErrorChain(error);
+
+	for (const entry of chain) {
+		const hint = readStringField(entry, 'hint');
+		if (hint && !isWrapperEntry(entry)) return hint;
 	}
+
+	for (const entry of chain) {
+		const hint = readStringField(entry, 'hint');
+		if (hint) return hint;
+	}
+
 	return undefined;
 };
 

package/src/index.ts

@@ -12,12 +12,13 @@ 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 { GitResourceSchema, LocalResourceSchema, NpmResourceSchema } from './resources/schema.ts';
 import { StreamService } from './stream/service.ts';
 import type { BtcaStreamMetaEvent } from './stream/types.ts';
 import {
 	LIMITS,
 	normalizeGitHubUrl,
+	parseNpmReference,
 	validateGitUrl,
 	validateResourceReference
 } from './validation/index.ts';
@@ -82,6 +83,8 @@ const ResourceReferenceField = z.string().superRefine((value, ctx) => {
 });
 
 const normalizeQuestionResourceReference = (reference: string): string => {
+	const npmReference = parseNpmReference(reference);
+	if (npmReference) return npmReference.normalizedReference;
 	const gitUrlResult = validateGitUrl(reference);
 	if (gitUrlResult.valid) return gitUrlResult.value;
 	return reference;
@@ -165,9 +168,18 @@ const AddLocalResourceRequestSchema = z.object({
 	specialNotes: LocalResourceSchema.shape.specialNotes
 });
 
+const AddNpmResourceRequestSchema = z.object({
+	type: z.literal('npm'),
+	name: NpmResourceSchema.shape.name,
+	package: NpmResourceSchema.shape.package,
+	version: NpmResourceSchema.shape.version,
+	specialNotes: NpmResourceSchema.shape.specialNotes
+});
+
 const AddResourceRequestSchema = z.discriminatedUnion('type', [
 	AddGitResourceRequestSchema,
-	AddLocalResourceRequestSchema
+	AddLocalResourceRequestSchema,
+	AddNpmResourceRequestSchema
 ]);
 
 const RemoveResourceRequestSchema = z.object({
@@ -188,16 +200,16 @@ class RequestError extends Error {
 
 const decodeJson = async <T>(req: Request, schema: z.ZodType<T>): Promise<T> => {
 	const bodyResult = await Result.tryPromise(() => req.json());
-	return bodyResult.match({
-		ok: (body) => {
-			const parsed = schema.safeParse(body);
-			if (!parsed.success) throw new RequestError('Invalid request body', parsed.error);
-			return parsed.data;
-		},
-		err: (cause) => {
-			throw new RequestError('Failed to parse request JSON', cause);
-		}
-	});
+	if (!Result.isOk(bodyResult)) {
+		throw new RequestError('Failed to parse request JSON', bodyResult.error);
+	}
+
+	const parsed = schema.safeParse(bodyResult.value);
+	if (!parsed.success) {
+		throw new RequestError('Invalid request body', parsed.error);
+	}
+
+	return parsed.data;
 };
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -242,6 +254,9 @@ const createApp = (deps: {
 				tag === 'ConfigError' ||
 				tag === 'InvalidProviderError' ||
 				tag === 'InvalidModelError' ||
+				tag === 'ProviderNotAuthenticatedError' ||
+				tag === 'ProviderAuthTypeError' ||
+				tag === 'ProviderNotFoundError' ||
 				tag === 'ProviderNotConnectedError' ||
 				tag === 'ProviderOptionsError'
 					? 400
@@ -287,7 +302,8 @@ const createApp = (deps: {
 							searchPaths: r.searchPaths ?? null,
 							specialNotes: r.specialNotes ?? null
 						};
-					} else {
+					}
+					if (r.type === 'local') {
 						return {
 							name: r.name,
 							type: r.type,
@@ -295,6 +311,13 @@ const createApp = (deps: {
 							specialNotes: r.specialNotes ?? null
 						};
 					}
+					return {
+						name: r.name,
+						type: r.type,
+						package: r.package,
+						version: r.version ?? null,
+						specialNotes: r.specialNotes ?? null
+					};
 				})
 			});
 		})
@@ -435,7 +458,8 @@ const createApp = (deps: {
 				};
 				const added = await config.addResource(resource);
 				return c.json(added, 201);
-			} else {
+			}
+			if (decoded.type === 'local') {
 				const resource = {
 					type: 'local' as const,
 					name: decoded.name,
@@ -445,6 +469,15 @@ const createApp = (deps: {
 				const added = await config.addResource(resource);
 				return c.json(added, 201);
 			}
+			const resource = {
+				type: 'npm' as const,
+				name: decoded.name,
+				package: decoded.package,
+				...(decoded.version ? { version: decoded.version } : {}),
+				...(decoded.specialNotes ? { specialNotes: decoded.specialNotes } : {})
+			};
+			const added = await config.addResource(resource);
+			return c.json(added, 201);
 		})
 
 		// DELETE /config/resources - Remove a resource

package/src/providers/auth.ts

@@ -181,7 +181,7 @@ export namespace Auth {
 				return 'Run "btca connect -p minimax" and enter your API key. Get your API key at https://platform.minimax.io/user-center/basic-information.';
 			default:
 				return 'Run "btca connect" and configure credentials for this provider.';
-			}
+		}
 	};
 
 	/**