@m6d/cortex-server 1.7.0 → 2.0.0

package/dist/src/ai/context/index.d.ts

@@ -1,15 +0,0 @@
-export type { ContextConfig, ThreadContextMeta } from "./types.ts";
-export { DEFAULT_CONTEXT_CONFIG } from "./types.ts";
-export { CHARS_PER_TOKEN, estimateTokens, estimateMessageTokens, estimateMessagesTokens, } from "./token-estimator.ts";
-export { compressToolResults } from "./compressor.ts";
-export { summarizeMessages } from "./summarizer.ts";
-export { buildContextMessages, trimMessagesToFit } from "./builder.ts";
-import type { UIMessage } from "ai";
-import type { ResolvedCortexAgentConfig } from "../../config.ts";
-import type { Thread } from "../../types.ts";
-/**
- * Post-response context optimization.
- * Called fire-and-forget from onFinish — summarizes older messages
- * when token usage exceeds the configured threshold.
- */
-export declare function optimizeThreadContext(thread: Thread, messages: UIMessage[], config: ResolvedCortexAgentConfig): Promise<void>;

package/dist/src/ai/context/summarizer.d.ts

@@ -1,5 +0,0 @@
-import type { UIMessage } from "ai";
-import type { ContextConfig } from "./types.ts";
-type SummarizationModelConfig = NonNullable<ContextConfig["summarizationModel"]>;
-export declare function summarizeMessages(messages: UIMessage[], existingSummary: string | null, modelConfig: SummarizationModelConfig): Promise<string>;
-export {};

package/dist/src/ai/helpers.d.ts

@@ -1,5 +0,0 @@
-import type { ResolvedCortexAgentConfig } from "../config.ts";
-export declare function createModel(config: ResolvedCortexAgentConfig["model"]): import("@ai-sdk/provider").LanguageModelV3;
-export declare function createEmbeddingModel(config: ResolvedCortexAgentConfig["embedding"]): import("@ai-sdk/provider").EmbeddingModelV3;
-export declare function streamToBase64(stream: ReadableStream<Uint8Array>): Promise<string>;
-export declare function tokenToUserId(token: string): string;

package/dist/src/ai/index.d.ts

@@ -1,4 +0,0 @@
-import type { ResolvedCortexAgentConfig } from "../config.ts";
-import type { Thread } from "../types.ts";
-export declare function stream(messages: unknown[], thread: Thread, userId: string, token: string, requestContext: Record<string, unknown>, config: ResolvedCortexAgentConfig): Promise<Response>;
-export declare function generateTitle(threadId: string, prompt: string, userId: string, config: ResolvedCortexAgentConfig): Promise<void>;

package/dist/src/ai/interceptors/request-interceptor.d.ts

@@ -1,12 +0,0 @@
-import type { DatabaseAdapter } from "../../adapters/database.ts";
-import type { StorageAdapter } from "../../adapters/storage.ts";
-export type ResolvedFile = {
-    name: string;
-    bytes: string;
-};
-export type RequestInterceptorOptions = {
-    transformFile?: (file: ResolvedFile) => unknown;
-};
-export declare function createRequestInterceptor(db: DatabaseAdapter, storage: StorageAdapter, options?: RequestInterceptorOptions): (body: Record<string, unknown>, context: {
-    token: string;
-}) => Promise<Record<string, unknown>>;

package/dist/src/ai/tools/call-endpoint.tool.d.ts

@@ -1,7 +0,0 @@
-import type { ResolvedCortexAgentConfig } from "../../config.ts";
-export declare function createCallEndpointTool(backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>, token: string): import("ai").Tool<{
-    method: "GET" | "POST" | "PUT" | "DELETE";
-    path: string;
-    body?: string | undefined;
-    queryParams?: string | undefined;
-}, string>;

package/dist/src/ai/tools/capture-files.tool.d.ts

@@ -1,6 +0,0 @@
-export declare const captureFilesTool: import("ai").Tool<{
-    files: {
-        id: string;
-        label: string;
-    }[];
-}, never>;

package/dist/src/ai/tools/execute-code.tool.d.ts

@@ -1,4 +0,0 @@
-import type { ResolvedCortexAgentConfig } from "../../config.ts";
-export declare function createExecuteCodeTool(backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>, token: string): import("ai").Tool<{
-    code: string;
-}, string>;

package/dist/src/ai/tools/query-graph.tool.d.ts

@@ -1,5 +0,0 @@
-import type { Neo4jClient } from "../../graph/neo4j.ts";
-export declare function createQueryGraphTool(neo4j: Neo4jClient): import("ai").Tool<{
-    query: string;
-    parameters?: string | undefined;
-}, string>;

package/dist/src/cli/extract-endpoints.d.ts

@@ -1,6 +0,0 @@
-export type ExtractEndpointsOptions = {
-    swaggerUrl: string;
-    domainsDir: string;
-    write?: boolean;
-};
-export declare function extractEndpoints(options: ExtractEndpointsOptions): Promise<void>;

package/dist/src/config.d.ts

@@ -1,165 +0,0 @@
-import type { ToolSet, UIMessage } from "ai";
-import type { DatabaseAdapter } from "./adapters/database";
-import type { StorageAdapter } from "./adapters/storage";
-import type { DomainDef } from "./graph/types.ts";
-import type { RequestInterceptorOptions } from "./ai/interceptors/request-interceptor.ts";
-import type { ContextConfig } from "./ai/context/types.ts";
-export type KnowledgeConfig = {
-    swagger?: {
-        url: string;
-    };
-    domains?: Record<string, DomainDef>;
-};
-export type PromptContext<TSession extends Record<string, unknown> = Record<string, unknown>, TRequestContext extends Record<string, unknown> = Record<string, unknown>> = {
-    session: TSession | null;
-    requestContext: TRequestContext;
-};
-export type DatabaseConfig = {
-    type: "mssql";
-    connectionString: string;
-};
-export type StorageConfig = {
-    endPoint: string;
-    port: number;
-    useSSL: boolean;
-    accessKey: string;
-    secretKey: string;
-    bucketName?: string;
-};
-export type CortexAgentDefinition<TSession extends Record<string, unknown> = Record<string, unknown>, TRequestContext extends Record<string, unknown> = Record<string, unknown>> = {
-    systemPrompt: string | ((context: PromptContext<TSession, TRequestContext>) => string | Promise<string>);
-    tools?: ToolSet;
-    backendFetch?: {
-        baseUrl: string;
-        apiKey: string;
-        headers?: Record<string, string>;
-        transformRequestBody?: (body: Record<string, unknown>, context: {
-            token: string;
-        }) => Promise<Record<string, unknown>>;
-        interceptor?: RequestInterceptorOptions;
-    };
-    loadSessionData?: (token: string) => Promise<TSession>;
-    resolveRequestContext?: (request: Request) => TRequestContext | Promise<TRequestContext>;
-    onToolCall?: (toolCall: {
-        toolName: string;
-        toolCallId: string;
-        args: Record<string, unknown>;
-    }) => void;
-    onStreamFinish?: (result: {
-        messages: UIMessage[];
-        isAborted: boolean;
-    }) => void;
-    model?: {
-        baseURL: string;
-        apiKey: string;
-        modelName: string;
-        providerName?: string;
-    };
-    embedding?: {
-        baseURL: string;
-        apiKey: string;
-        modelName: string;
-        dimension: number;
-    };
-    neo4j?: {
-        url: string;
-        user: string;
-        password: string;
-    };
-    reranker?: {
-        url: string;
-        apiKey: string;
-    };
-    context?: Partial<ContextConfig>;
-    knowledge?: KnowledgeConfig | null;
-};
-export type ResolvedCortexAgentConfig = {
-    db: DatabaseAdapter;
-    storage: StorageAdapter;
-    model: {
-        baseURL: string;
-        apiKey: string;
-        modelName: string;
-        providerName?: string;
-    };
-    embedding: {
-        baseURL: string;
-        apiKey: string;
-        modelName: string;
-        dimension: number;
-    };
-    neo4j: {
-        url: string;
-        user: string;
-        password: string;
-    };
-    reranker?: {
-        url: string;
-        apiKey: string;
-    };
-    systemPrompt: string | ((context: PromptContext) => string | Promise<string>);
-    tools?: ToolSet;
-    backendFetch?: {
-        baseUrl: string;
-        apiKey: string;
-        headers?: Record<string, string>;
-        transformRequestBody?: (body: Record<string, unknown>, context: {
-            token: string;
-        }) => Promise<Record<string, unknown>>;
-        interceptor?: RequestInterceptorOptions;
-    };
-    loadSessionData?: (token: string) => Promise<Record<string, unknown>>;
-    resolveRequestContext?: (request: Request) => Record<string, unknown> | Promise<Record<string, unknown>>;
-    onToolCall?: (toolCall: {
-        toolName: string;
-        toolCallId: string;
-        args: Record<string, unknown>;
-    }) => void;
-    onStreamFinish?: (result: {
-        messages: UIMessage[];
-        isAborted: boolean;
-    }) => void;
-    context: ContextConfig;
-    knowledge?: KnowledgeConfig;
-};
-export type CortexConfig = {
-    port?: number;
-    database: DatabaseConfig;
-    storage: StorageConfig;
-    auth: {
-        jwksUri: string;
-        issuer: string;
-        tokenExtractor?: (req: Request) => string | null;
-        cookieName?: string;
-    };
-    model: {
-        baseURL: string;
-        apiKey: string;
-        modelName: string;
-        providerName?: string;
-    };
-    embedding: {
-        baseURL: string;
-        apiKey: string;
-        modelName: string;
-        dimension: number;
-    };
-    neo4j: {
-        url: string;
-        user: string;
-        password: string;
-    };
-    reranker?: {
-        url: string;
-        apiKey: string;
-    };
-    context?: Partial<ContextConfig>;
-    knowledge?: KnowledgeConfig;
-    agents: Record<string, CortexAgentDefinition>;
-};
-/**
- * Helper to define an agent with full type inference for `systemPrompt` context.
- * The `context.session` type is inferred from `loadSessionData`'s return type,
- * and `context.requestContext` is inferred from `resolveRequestContext`'s return type.
- */
-export declare function defineAgent<TSession extends Record<string, unknown> = Record<string, unknown>, TRequestContext extends Record<string, unknown> = Record<string, unknown>>(config: CortexAgentDefinition<TSession, TRequestContext>): CortexAgentDefinition;

package/dist/src/db/migrate.d.ts

@@ -1 +0,0 @@
-export declare function runMigrations(connectionString: string): Promise<void>;

package/dist/src/graph/expand-domains.d.ts

@@ -1,2 +0,0 @@
-import type { DomainDef } from "./types.ts";
-export declare function expandDomains(domains: Record<string, DomainDef>): Record<string, DomainDef>;

package/dist/src/graph/generate-cypher.d.ts

@@ -1,22 +0,0 @@
-/**
- * Transforms declarative DomainDef into idempotent MERGE-based Cypher.
- *
- * Returns two phases:
- *   - `nodes`  -- MERGE statements that create/update Domain, Concept, Endpoint,
- *                 Service, and Rule nodes.
- *   - `edges`  -- MATCH+MERGE statements that wire up relationships between nodes.
- *
- * The caller MUST run all `nodes` from every module before running any `edges`,
- * because edges may reference nodes defined in a different module (e.g. a Rule
- * in the leaves module that GOVERNS a Concept created by the servicing module).
- */
-import type { DomainDef } from "./types.ts";
-export type GeneratedCypher = {
-    nodes: string[];
-    edges: string[];
-};
-export declare function generateCypher(data: DomainDef): {
-    nodes: string[];
-    edges: string[];
-};
-export declare function toCypherScript(data: DomainDef): string;

package/dist/src/graph/index.d.ts

@@ -1,11 +0,0 @@
-export type { EndpointScalarType, EndpointProperty, ResponseKind, AutoGenerated, ConceptDef, EndpointDef, EndpointInput, ServiceDef, RuleDef, DomainDef, } from "./types.ts";
-export { defineConcept, defineRule, defineService, defineDomain, defineEndpoint, } from "./helpers.ts";
-export type { GeneratedCypher } from "./generate-cypher.ts";
-export { generateCypher, toCypherScript } from "./generate-cypher.ts";
-export { validateDomain } from "./validate.ts";
-export type { Neo4jConfig, Neo4jClient } from "./neo4j.ts";
-export { createNeo4jClient } from "./neo4j.ts";
-export type { EmbeddingConfig, SeedGraphConfig } from "./seed.ts";
-export { seedGraph } from "./seed.ts";
-export type { RerankerConfig, ResolverConfig, ResolvedEndpoint, ResolvedService, ResolvedContext, } from "./resolver.ts";
-export { resolveFromGraph } from "./resolver.ts";

package/dist/src/graph/seed.d.ts

@@ -1,19 +0,0 @@
-/**
- * Seed orchestrator for the knowledge graph.
- *
- * Validates domains, generates Cypher, executes against Neo4j,
- * and generates concept embeddings. All configuration is passed
- * explicitly — no environment variables or Convex dependencies.
- */
-import type { EmbeddingModel } from "ai";
-import type { Neo4jConfig } from "./neo4j.ts";
-import type { DomainDef } from "./types.ts";
-export type EmbeddingConfig = {
-    model: EmbeddingModel;
-    dimension: number;
-};
-export type SeedGraphConfig = {
-    neo4j: Neo4jConfig;
-    embedding: EmbeddingConfig;
-};
-export declare function seedGraph(config: SeedGraphConfig, domains: Record<string, DomainDef>): Promise<void>;

package/dist/src/graph/validate.d.ts

@@ -1,2 +0,0 @@
-import type { DomainDef } from "./types.ts";
-export declare function validateDomain(data: DomainDef): string[];

package/dist/src/routes/index.d.ts

@@ -1,4 +0,0 @@
-export { createThreadRoutes } from "./threads.ts";
-export { createChatRoutes } from "./chat.ts";
-export { createFileRoutes } from "./files.ts";
-export { createWsRoute } from "./ws.ts";

package/dist/src/types.d.ts

@@ -1,74 +0,0 @@
-import type { ResolvedCortexAgentConfig } from "./config";
-import type { InferSelectModel } from "drizzle-orm";
-import type { messages, threads } from "./db/schema";
-export type Thread = InferSelectModel<typeof threads>;
-export type StoredMessage = InferSelectModel<typeof messages>;
-export type ThreadSummary = {
-    id: string;
-    title?: string;
-    createdAt: Date;
-    updatedAt: Date;
-    isRunning: boolean;
-};
-export type MessageMetadata = {
-    modelId: string;
-    providerMetadata: unknown;
-    isAborted?: boolean;
-    tokenUsage?: {
-        input: {
-            noCache: number;
-            cacheRead: number;
-            cacheWrite: number;
-            total: number;
-        };
-        output: {
-            reasoning: number;
-            text: number;
-            total: number;
-        };
-        total: number;
-    };
-};
-export type CapturedFileInput = {
-    id: string;
-    file: {
-        name: string;
-        bytes: string;
-    };
-};
-export type AppEnv = {
-    Bindings: {};
-    Variables: {
-        user: {
-            id: string;
-            token: string;
-        } | undefined;
-    };
-};
-export type AuthedAppEnv = {
-    Bindings: {};
-    Variables: {
-        user: {
-            id: string;
-            token: string;
-        };
-    };
-};
-export type CortexAppEnv = {
-    Bindings: {};
-    Variables: {
-        user: {
-            id: string;
-            token: string;
-        };
-        agentConfig: ResolvedCortexAgentConfig;
-        agentId: string;
-    };
-};
-export declare function toThreadSummary(thread: Thread, isRunning: boolean): {
-    id: string;
-    title: string | undefined;
-    createdAt: Date;
-    updatedAt: Date;
-    isRunning: boolean;
-};

package/dist/src/ws/events.d.ts

@@ -1,39 +0,0 @@
-import type { ThreadSummary } from "../types.ts";
-export type ThreadCreatedEvent = {
-    type: "thread:created";
-    payload: {
-        thread: ThreadSummary;
-    };
-};
-export type ThreadDeletedEvent = {
-    type: "thread:deleted";
-    payload: {
-        threadId: string;
-    };
-};
-export type ThreadTitleUpdatedEvent = {
-    type: "thread:title-updated";
-    payload: {
-        thread: ThreadSummary;
-    };
-};
-export type ThreadRunStartedEvent = {
-    type: "thread:run-started";
-    payload: {
-        thread: ThreadSummary;
-    };
-};
-export type ThreadRunFinishedEvent = {
-    type: "thread:run-finished";
-    payload: {
-        thread: ThreadSummary;
-    };
-};
-export type ThreadMessagesUpdatedEvent = {
-    type: "thread:messages-updated";
-    payload: {
-        threadId: string;
-        thread: ThreadSummary;
-    };
-};
-export type WsEvent = ThreadCreatedEvent | ThreadDeletedEvent | ThreadTitleUpdatedEvent | ThreadRunStartedEvent | ThreadRunFinishedEvent | ThreadMessagesUpdatedEvent;

package/dist/src/ws/index.d.ts

@@ -1,3 +0,0 @@
-export { addConnection, removeConnection, getConnections } from "./connections.ts";
-export { notify } from "./notify.ts";
-export type { WsEvent, ThreadCreatedEvent, ThreadDeletedEvent, ThreadTitleUpdatedEvent, ThreadRunStartedEvent, ThreadRunFinishedEvent, ThreadMessagesUpdatedEvent, } from "./events.ts";

package/dist/src/ws/notify.d.ts

@@ -1,2 +0,0 @@
-import type { WsEvent } from "./events.ts";
-export declare function notify(userId: string, agentId: string, event: WsEvent): void;

package/src/adapters/database.ts

@@ -1,29 +0,0 @@
-import type { ToolUIPart, UIMessage } from "ai";
-import type { Thread, StoredMessage, CapturedFileInput } from "../types";
-import type { ThreadContextMeta } from "../ai/context/types.ts";
-
-export type DatabaseAdapter = {
-    threads: {
-        list(userId: string, agentId: string): Promise<Thread[]>;
-        getById(userId: string, threadId: string): Promise<Thread | null>;
-        create(userId: string, agentId: string): Promise<Thread>;
-        delete(userId: string, threadId: string): Promise<void>;
-        touch(threadId: string): Promise<Thread>;
-        updateTitle(threadId: string, title: string): Promise<void>;
-        updateSession(threadId: string, session: Record<string, unknown>): Promise<void>;
-        updateContextMeta(threadId: string, meta: ThreadContextMeta): Promise<void>;
-    };
-    messages: {
-        list(userId: string, threadId: string, opts?: { limit?: number }): Promise<StoredMessage[]>;
-        upsert(threadId: string, messages: UIMessage[]): Promise<void>;
-    };
-    capturedFiles: {
-        create(
-            userId: string,
-            messageId: string,
-            toolPart: ToolUIPart,
-            files: CapturedFileInput[],
-        ): Promise<{ id: string; uploadId: string }[]>;
-        getById(id: string, userId: string): Promise<{ name: string } | null>;
-    };
-};

package/src/adapters/mssql.ts

@@ -1,195 +0,0 @@
-import type { ToolUIPart, UIMessage } from "ai";
-import { and, desc, eq, getColumns, inArray, type InferInsertModel } from "drizzle-orm";
-import { drizzle } from "drizzle-orm/node-mssql";
-import { threads, messages, capturedFiles } from "../db/schema";
-import type { DatabaseAdapter } from "./database";
-import type { StorageAdapter } from "./storage";
-import type { Thread, CapturedFileInput, MessageMetadata } from "../types";
-import type { ThreadContextMeta } from "../ai/context/types.ts";
-
-export function createMssqlAdapter(connectionString: string, storage: StorageAdapter) {
-    const db = drizzle(connectionString, { casing: "snake_case" });
-
-    const adapter: DatabaseAdapter = {
-        threads: {
-            async list(userId: string, agentId: string) {
-                return (await db
-                    .select()
-                    .from(threads)
-                    .where(and(eq(threads.userId, userId), eq(threads.agentId, agentId)))
-                    .orderBy(desc(threads.updatedAt), desc(threads.createdAt))) as Thread[];
-            },
-
-            async getById(userId: string, threadId: string) {
-                const result = await db
-                    .select()
-                    .top(1)
-                    .from(threads)
-                    .where(and(eq(threads.id, threadId), eq(threads.userId, userId)))
-                    .execute();
-                return result.length ? (result[0] as Thread) : null;
-            },
-
-            async create(userId: string, agentId: string) {
-                const result = await db
-                    .insert(threads)
-                    .output()
-                    .values({ userId, agentId })
-                    .execute();
-                return result[0] as Thread;
-            },
-
-            async delete(userId: string, threadId: string) {
-                const capturedFilePaths = await db
-                    .select({ id: capturedFiles.id })
-                    .from(capturedFiles)
-                    .innerJoin(messages, eq(messages.id, capturedFiles.messageId))
-                    .innerJoin(threads, eq(threads.id, messages.threadId))
-                    .where(and(eq(threads.id, threadId), eq(threads.userId, userId)))
-                    .execute()
-                    .then((x) => x.map((y) => `captured_files/${y.id}`));
-
-                await storage.delete(capturedFilePaths);
-
-                await db
-                    .delete(threads)
-                    .where(and(eq(threads.id, threadId), eq(threads.userId, userId)))
-                    .execute();
-            },
-
-            async touch(threadId: string) {
-                const result = await db
-                    .update(threads)
-                    .set({ updatedAt: new Date() })
-                    .where(eq(threads.id, threadId))
-                    .output()
-                    .execute();
-
-                return result[0] as Thread;
-            },
-
-            async updateTitle(threadId: string, title: string) {
-                await db.update(threads).set({ title }).where(eq(threads.id, threadId)).execute();
-            },
-
-            async updateSession(threadId: string, session: Record<string, unknown>) {
-                await db.update(threads).set({ session }).where(eq(threads.id, threadId)).execute();
-            },
-
-            async updateContextMeta(threadId: string, meta: ThreadContextMeta) {
-                await db
-                    .update(threads)
-                    .set({ contextMeta: meta })
-                    .where(eq(threads.id, threadId))
-                    .execute();
-            },
-        },
-
-        messages: {
-            async list(userId: string, threadId: string, opts?: { limit?: number }) {
-                return await db
-                    .select(getColumns(messages))
-                    .from(messages)
-                    .innerJoin(threads, eq(threads.id, messages.threadId))
-                    .where(and(eq(threads.userId, userId), eq(threads.id, threadId)))
-                    .orderBy(desc(messages.createdAt))
-                    .offset(0)
-                    .fetch(opts?.limit ?? 100)
-                    .then((x) => x.reverse());
-            },
-
-            async upsert(threadId: string, messagesToUpsert: UIMessage<MessageMetadata>[]) {
-                const ids = messagesToUpsert.map((x) => x.id);
-
-                const existingIds = await db
-                    .select({ id: messages.id })
-                    .from(messages)
-                    .where(inArray(messages.id, ids))
-                    .execute()
-                    .then((x) => x.map((y) => y.id));
-
-                const newMessages = messagesToUpsert.filter((x) => !existingIds.includes(x.id));
-
-                if (newMessages.length) {
-                    await db
-                        .insert(messages)
-                        .values(
-                            newMessages.map(
-                                (x) =>
-                                    ({
-                                        id: x.id,
-                                        role: x.role,
-                                        threadId,
-                                        content: x,
-                                        text: x.parts.find((y) => y.type === "text")?.text,
-                                    }) satisfies InferInsertModel<typeof messages>,
-                            ),
-                        )
-                        .execute();
-                }
-
-                const existingMessages = messagesToUpsert.filter((x) => existingIds.includes(x.id));
-                for (const message of existingMessages) {
-                    await db
-                        .update(messages)
-                        .set({
-                            content: message,
-                            text: message.parts.find((x) => x.type === "text")?.text,
-                        })
-                        .where(eq(messages.id, message.id))
-                        .execute();
-                }
-            },
-        },
-
-        capturedFiles: {
-            async create(
-                userId: string,
-                messageId: string,
-                toolPart: ToolUIPart,
-                files: CapturedFileInput[],
-            ) {
-                const result = await db
-                    .insert(capturedFiles)
-                    .output({ id: capturedFiles.id })
-                    .values(
-                        files.map(
-                            (file) =>
-                                ({
-                                    userId,
-                                    messageId,
-                                    toolPart,
-                                    name: file.file.name,
-                                    agentGeneratedId: file.id,
-                                }) satisfies InferInsertModel<typeof capturedFiles>,
-                        ),
-                    )
-                    .execute()
-                    .then((x) => x.map((y) => y.id));
-
-                await Promise.all(
-                    result.map(
-                        async (id, idx) =>
-                            await storage.put(`captured_files/${id}`, files[idx]!.file.bytes),
-                    ),
-                );
-
-                return result.map((r, i) => ({ id: files[i]!.id, uploadId: r }));
-            },
-
-            async getById(id: string, userId: string) {
-                const file = await db
-                    .select()
-                    .top(1)
-                    .from(capturedFiles)
-                    .where(and(eq(capturedFiles.id, id), eq(capturedFiles.userId, userId)))
-                    .execute()
-                    .then((x) => (x.length ? x[0] : null));
-
-                return file ? { name: file.name } : null;
-            },
-        },
-    };
-
-    return adapter;
-}