btca-server 1.0.962 → 2.0.0

package/src/context/transaction.ts

@@ -1,33 +1,26 @@
-import { Result } from 'better-result';
+import { metricsError, metricsErrorInfo, metricsInfo } from '../metrics/index.ts';
+import { requireContext } from './index.ts';
 
-import { Metrics } from '../metrics/index.ts';
-import { Context } from './index.ts';
+export const runTransaction = async <T>(name: string, fn: () => Promise<T>): Promise<T> => {
+	const store = requireContext();
+	const depth = store.txDepth;
+	store.txDepth = depth + 1;
 
-export namespace Transaction {
-	export const run = async <T>(name: string, fn: () => Promise<T>): Promise<T> => {
-		const store = Context.require();
-		const depth = store.txDepth;
-		store.txDepth = depth + 1;
-
-		const start = performance.now();
-		Metrics.info('tx.start', { name, depth });
-		const result = await Result.tryPromise(fn);
-		store.txDepth = depth;
-
-		return result.match({
-			ok: (value) => {
-				Metrics.info('tx.commit', { name, depth, ms: Math.round(performance.now() - start) });
-				return value;
-			},
-			err: (cause) => {
-				Metrics.error('tx.rollback', {
-					name,
-					depth,
-					ms: Math.round(performance.now() - start),
-					error: Metrics.errorInfo(cause)
-				});
-				throw cause;
-			}
+	const start = performance.now();
+	metricsInfo('tx.start', { name, depth });
+	try {
+		const value = await fn();
+		metricsInfo('tx.commit', { name, depth, ms: Math.round(performance.now() - start) });
+		return value;
+	} catch (cause) {
+		metricsError('tx.rollback', {
+			name,
+			depth,
+			ms: Math.round(performance.now() - start),
+			error: metricsErrorInfo(cause)
 		});
-	};
-}
+		throw cause;
+	} finally {
+		store.txDepth = depth;
+	}
+};

package/src/effect/errors.ts

@@ -0,0 +1,45 @@
+import { Data } from 'effect';
+import { getErrorHint, getErrorMessage, getErrorTag } from '../errors.ts';
+
+export class ServerError extends Data.TaggedError('ServerError')<{
+	readonly message: string;
+	readonly hint?: string;
+	readonly cause?: unknown;
+}> {}
+
+export interface HttpErrorPayload {
+	readonly error: string;
+	readonly tag: string;
+	readonly hint?: string;
+	readonly status: number;
+}
+
+const getHttpStatusFromErrorTag = (tag: string) => {
+	if (
+		tag === 'RequestError' ||
+		tag === 'CollectionError' ||
+		tag === 'ResourceError' ||
+		tag === 'ConfigError' ||
+		tag === 'InvalidProviderError' ||
+		tag === 'InvalidModelError' ||
+		tag === 'ProviderNotAuthenticatedError' ||
+		tag === 'ProviderAuthTypeError' ||
+		tag === 'ProviderNotFoundError' ||
+		tag === 'ProviderNotConnectedError' ||
+		tag === 'ProviderOptionsError'
+	) {
+		return 400;
+	}
+	if (tag === 'RouteNotFound') return 404;
+	return 500;
+};
+
+export const toHttpErrorPayload = (error: unknown): HttpErrorPayload => {
+	const tag = getErrorTag(error);
+	return {
+		error: getErrorMessage(error),
+		tag,
+		hint: getErrorHint(error),
+		status: getHttpStatusFromErrorTag(tag)
+	};
+};

package/src/effect/layers.ts

@@ -0,0 +1,26 @@
+import { Layer, ServiceMap, pipe } from 'effect';
+import type { AgentService as AgentServiceShape } from '../agent/service.ts';
+import type { CollectionsService as CollectionsServiceShape } from '../collections/service.ts';
+import type { ConfigService as ConfigServiceShape } from '../config/index.ts';
+import { AgentService, CollectionsService, ConfigService } from './services.ts';
+
+export type ServerLayerDependencies = {
+	config: ConfigServiceShape;
+	collections: CollectionsServiceShape;
+	agent: AgentServiceShape;
+};
+
+export const makeServerLayer = (dependencies: ServerLayerDependencies) =>
+	Layer.mergeAll(
+		Layer.succeed(ConfigService, dependencies.config),
+		Layer.succeed(CollectionsService, dependencies.collections),
+		Layer.succeed(AgentService, dependencies.agent)
+	);
+
+export const makeServerServiceMap = (dependencies: ServerLayerDependencies) =>
+	pipe(
+		ServiceMap.empty(),
+		ServiceMap.add(ConfigService, dependencies.config),
+		ServiceMap.add(CollectionsService, dependencies.collections),
+		ServiceMap.add(AgentService, dependencies.agent)
+	);

package/src/effect/runtime.ts

@@ -0,0 +1,19 @@
+import { Effect, Exit, ManagedRuntime } from 'effect';
+import { makeServerLayer, makeServerServiceMap, type ServerLayerDependencies } from './layers.ts';
+
+export interface ServerRuntime {
+	runPromise: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
+	runPromiseExit: <A, E>(effect: Effect.Effect<A, E>) => Promise<Exit.Exit<A, E>>;
+	services: () => Promise<ReturnType<typeof makeServerServiceMap>>;
+	dispose: () => Promise<void>;
+}
+
+export const createServerRuntime = (dependencies: ServerLayerDependencies): ServerRuntime => {
+	const runtime = ManagedRuntime.make(makeServerLayer(dependencies));
+	return {
+		runPromise: (effect) => runtime.runPromise(effect),
+		runPromiseExit: (effect) => runtime.runPromiseExit(effect),
+		services: () => runtime.services(),
+		dispose: () => runtime.dispose()
+	};
+};

package/src/effect/services.ts

@@ -0,0 +1,154 @@
+import { Effect, ServiceMap } from 'effect';
+import type { AgentService as AgentServiceShape } from '../agent/service.ts';
+import type { CollectionsService as CollectionsServiceShape } from '../collections/service.ts';
+import { getCollectionKey } from '../collections/types.ts';
+import type { ConfigService as ConfigServiceShape } from '../config/index.ts';
+import type { ResourceDefinition } from '../resources/schema.ts';
+
+export class ConfigService extends ServiceMap.Service<ConfigService, ConfigServiceShape>()(
+	'btca-server/effect/ConfigService'
+) {}
+
+export class CollectionsService extends ServiceMap.Service<
+	CollectionsService,
+	CollectionsServiceShape
+>()('btca-server/effect/CollectionsService') {}
+
+export class AgentService extends ServiceMap.Service<AgentService, AgentServiceShape>()(
+	'btca-server/effect/AgentService'
+) {}
+
+const configService = Effect.service(ConfigService);
+const collectionsService = Effect.service(CollectionsService);
+const agentService = Effect.service(AgentService);
+
+export type ConfigSnapshot = {
+	provider: string;
+	model: string;
+	providerTimeoutMs: number | null;
+	maxSteps: number;
+	resourcesDirectory: string;
+	resourceCount: number;
+};
+
+export type ResourcesSnapshot = {
+	resources: Array<{
+		name: string;
+		type: 'git' | 'local' | 'npm';
+		url?: string;
+		branch?: string;
+		path?: string;
+		package?: string;
+		version?: string | null;
+		searchPath?: string | null;
+		searchPaths?: string[] | null;
+		specialNotes?: string | null;
+	}>;
+};
+
+export const getConfigSnapshot: Effect.Effect<ConfigSnapshot, never, ConfigService> = Effect.map(
+	configService,
+	(config) => ({
+		provider: config.provider,
+		model: config.model,
+		providerTimeoutMs: config.providerTimeoutMs ?? null,
+		maxSteps: config.maxSteps,
+		resourcesDirectory: config.resourcesDirectory,
+		resourceCount: config.resources.length
+	})
+);
+
+export const getResourcesSnapshot: Effect.Effect<ResourcesSnapshot, never, ConfigService> =
+	Effect.map(configService, (config) => ({
+		resources: config.resources.map((resource) => {
+			if (resource.type === 'git') {
+				return {
+					name: resource.name,
+					type: resource.type,
+					url: resource.url,
+					branch: resource.branch,
+					searchPath: resource.searchPath ?? null,
+					searchPaths: resource.searchPaths ?? null,
+					specialNotes: resource.specialNotes ?? null
+				};
+			}
+			if (resource.type === 'local') {
+				return {
+					name: resource.name,
+					type: resource.type,
+					path: resource.path,
+					specialNotes: resource.specialNotes ?? null
+				};
+			}
+			return {
+				name: resource.name,
+				type: resource.type,
+				package: resource.package,
+				version: resource.version ?? null,
+				specialNotes: resource.specialNotes ?? null
+			};
+		})
+	}));
+
+export const getDefaultResourceNames: Effect.Effect<string[], never, ConfigService> = Effect.map(
+	configService,
+	(config) => config.resources.map((resource) => resource.name)
+);
+
+export const reloadConfig: Effect.Effect<void, unknown, ConfigService> = Effect.flatMap(
+	configService,
+	(config) => config.reloadEffect()
+);
+
+export const listProviders: Effect.Effect<
+	Awaited<ReturnType<AgentServiceShape['listProviders']>>,
+	unknown,
+	AgentService
+> = Effect.flatMap(agentService, (agent) => agent.listProvidersEffect());
+
+export const loadCollection = (args: {
+	resourceNames: readonly string[];
+	quiet?: boolean;
+}): Effect.Effect<
+	Awaited<ReturnType<CollectionsServiceShape['load']>>,
+	unknown,
+	CollectionsService
+> => Effect.flatMap(collectionsService, (collections) => collections.loadEffect(args));
+
+export const askQuestion = (args: {
+	collection: Awaited<ReturnType<CollectionsServiceShape['load']>>;
+	question: string;
+}): Effect.Effect<Awaited<ReturnType<AgentServiceShape['ask']>>, unknown, AgentService> =>
+	Effect.flatMap(agentService, (agent) => agent.askEffect(args));
+
+export const askQuestionStream = (args: {
+	collection: Awaited<ReturnType<CollectionsServiceShape['load']>>;
+	question: string;
+}): Effect.Effect<Awaited<ReturnType<AgentServiceShape['askStream']>>, unknown, AgentService> =>
+	Effect.flatMap(agentService, (agent) => agent.askStreamEffect(args));
+
+export const updateModelConfig = (args: {
+	provider: string;
+	model: string;
+	providerOptions?: Parameters<ConfigServiceShape['updateModel']>[2];
+}): Effect.Effect<Awaited<ReturnType<ConfigServiceShape['updateModel']>>, unknown, ConfigService> =>
+	Effect.flatMap(configService, (config) =>
+		config.updateModelEffect(args.provider, args.model, args.providerOptions)
+	);
+
+export const addConfigResource = (
+	resource: ResourceDefinition
+): Effect.Effect<ResourceDefinition, unknown, ConfigService> =>
+	Effect.flatMap(configService, (config) => config.addResourceEffect(resource));
+
+export const removeConfigResource = (name: string): Effect.Effect<void, unknown, ConfigService> =>
+	Effect.flatMap(configService, (config) => config.removeResourceEffect(name));
+
+export const clearConfigResources: Effect.Effect<
+	Awaited<ReturnType<ConfigServiceShape['clearResources']>>,
+	unknown,
+	ConfigService
+> = Effect.flatMap(configService, (config) => config.clearResourcesEffect());
+
+export const loadedResourceCollectionKey = (resourceNames: readonly string[]) =>
+	getCollectionKey(resourceNames);