@m6d/cortex-server 1.8.0 → 2.0.1

package/dist/contracts/runtime.d.ts

@@ -0,0 +1,310 @@
+import { z } from "zod";
+/** Runtime contract §1.1: the `:id` path param, validated on both sides of the wire. */
+export declare const AGENT_SLUG_PATTERN: RegExp;
+/** Runtime contract §5: tool names become `tools.<name>()` sandbox bindings. */
+export declare const TOOL_NAME_PATTERN: RegExp;
+export declare const PROMPT_VARIABLES: readonly ["userName", "channel", "locale", "utcTime", "timezone"];
+/**
+ * One entry per prompt variable, driving editor autocomplete, validation, and
+ * runtime substitution alike. Adding a variable = extending the tuple above
+ * plus one entry here (the compiler enforces the pair); the consumer embedding
+ * the agent supplies the value in its session/request context under the same
+ * key. Descriptions are plain English on purpose: variables are code-like
+ * identifiers shown in an LTR suggestion list, not localized UI copy.
+ */
+export declare const PROMPT_VARIABLE_DEFINITIONS: {
+    userName: {
+        description: string;
+        example: string;
+    };
+    channel: {
+        description: string;
+        example: string;
+    };
+    locale: {
+        description: string;
+        example: string;
+    };
+    utcTime: {
+        description: string;
+        example: string;
+    };
+    timezone: {
+        description: string;
+        example: string;
+    };
+};
+export declare const RUNTIME_ERROR_KINDS: readonly ["timeout", "upstream_4xx", "upstream_5xx", "schema_mismatch", "rate_limited", "not_found", "unauthorized", "invalid_request", "egress_blocked", "internal"];
+/** The ways an execute output may disagree with the tool's declared schema. */
+export declare const JSON_SCHEMA_ISSUE_KINDS: readonly ["missing", "unexpected", "type_mismatch"];
+export declare const agentSlugSchema: z.ZodString;
+export declare const localeSchema: z.ZodEnum<{
+    ar: "ar";
+    en: "en";
+}>;
+export declare const catalogVersionSchema: z.ZodString;
+export declare const sharedShapeSchema: z.ZodObject<{
+    ref: z.ZodString;
+    shape: z.ZodString;
+}, z.core.$strip>;
+export declare const knowledgeChunkSchema: z.ZodObject<{
+    chunkId: z.ZodUUID;
+    text: z.ZodString;
+    score: z.ZodNumber;
+    citation: z.ZodObject<{
+        documentId: z.ZodUUID;
+        documentTitle: z.ZodString;
+        page: z.ZodNullable<z.ZodNumber>;
+        section: z.ZodNullable<z.ZodString>;
+        uri: z.ZodNullable<z.ZodURL>;
+        service: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const toolSignatureSchema: z.ZodObject<{
+    toolId: z.ZodUUID;
+    name: z.ZodString;
+    version: z.ZodNumber;
+    readOnly: z.ZodBoolean;
+    tags: z.ZodArray<z.ZodString>;
+    signature: z.ZodString;
+    score: z.ZodNullable<z.ZodNumber>;
+    pinned: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const serviceCardSchema: z.ZodObject<{
+    serviceId: z.ZodUUID;
+    key: z.ZodString;
+    name: z.ZodString;
+    card: z.ZodString;
+    score: z.ZodNumber;
+}, z.core.$strip>;
+export declare const runtimeAgentConfigSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    systemPrompt: z.ZodString;
+    promptVariables: z.ZodArray<z.ZodEnum<{
+        userName: "userName";
+        channel: "channel";
+        locale: "locale";
+        utcTime: "utcTime";
+        timezone: "timezone";
+    }>>;
+    catalogBlurb: z.ZodString;
+    defaultLocale: z.ZodEnum<{
+        ar: "ar";
+        en: "en";
+    }>;
+    metaTools: z.ZodObject<{
+        searchKnowledge: z.ZodBoolean;
+        searchTools: z.ZodBoolean;
+        searchServices: z.ZodBoolean;
+    }, z.core.$strip>;
+    limits: z.ZodObject<{
+        resolveTokenBudget: z.ZodNumber;
+        executeTimeoutMs: z.ZodNumber;
+        maxResponseBytes: z.ZodNumber;
+    }, z.core.$strip>;
+    catalogVersion: z.ZodString;
+    publishedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const resolveRequestSchema: z.ZodObject<{
+    query: z.ZodString;
+    locale: z.ZodOptional<z.ZodEnum<{
+        ar: "ar";
+        en: "en";
+    }>>;
+    hints: z.ZodOptional<z.ZodObject<{
+        threadId: z.ZodOptional<z.ZodString>;
+        recentToolNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        turnIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    tokenBudget: z.ZodOptional<z.ZodNumber>;
+    limits: z.ZodOptional<z.ZodObject<{
+        knowledge: z.ZodDefault<z.ZodNumber>;
+        tools: z.ZodDefault<z.ZodNumber>;
+        services: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const resolveResponseSchema: z.ZodObject<{
+    resolveId: z.ZodUUID;
+    catalogVersion: z.ZodString;
+    locale: z.ZodEnum<{
+        ar: "ar";
+        en: "en";
+    }>;
+    knowledge: z.ZodArray<z.ZodObject<{
+        chunkId: z.ZodUUID;
+        text: z.ZodString;
+        score: z.ZodNumber;
+        citation: z.ZodObject<{
+            documentId: z.ZodUUID;
+            documentTitle: z.ZodString;
+            page: z.ZodNullable<z.ZodNumber>;
+            section: z.ZodNullable<z.ZodString>;
+            uri: z.ZodNullable<z.ZodURL>;
+            service: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    tools: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodUUID;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        readOnly: z.ZodBoolean;
+        tags: z.ZodArray<z.ZodString>;
+        signature: z.ZodString;
+        score: z.ZodNullable<z.ZodNumber>;
+        pinned: z.ZodBoolean;
+    }, z.core.$strip>>;
+    services: z.ZodArray<z.ZodObject<{
+        serviceId: z.ZodUUID;
+        key: z.ZodString;
+        name: z.ZodString;
+        card: z.ZodString;
+        score: z.ZodNumber;
+    }, z.core.$strip>>;
+    sharedShapes: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        shape: z.ZodString;
+    }, z.core.$strip>>;
+    budget: z.ZodObject<{
+        requested: z.ZodNumber;
+        used: z.ZodNumber;
+        truncated: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const searchRequestSchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodEnum<{
+        ar: "ar";
+        en: "en";
+    }>>;
+    threadId: z.ZodOptional<z.ZodString>;
+    service: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const searchToolsResponseSchema: z.ZodObject<{
+    catalogVersion: z.ZodString;
+    tools: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodUUID;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        readOnly: z.ZodBoolean;
+        tags: z.ZodArray<z.ZodString>;
+        signature: z.ZodString;
+        score: z.ZodNullable<z.ZodNumber>;
+        pinned: z.ZodBoolean;
+    }, z.core.$strip>>;
+    sharedShapes: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        shape: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const searchServicesResponseSchema: z.ZodObject<{
+    catalogVersion: z.ZodString;
+    services: z.ZodArray<z.ZodObject<{
+        serviceId: z.ZodUUID;
+        key: z.ZodString;
+        name: z.ZodString;
+        card: z.ZodString;
+        score: z.ZodNumber;
+    }, z.core.$strip>>;
+    tools: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodUUID;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        readOnly: z.ZodBoolean;
+        tags: z.ZodArray<z.ZodString>;
+        signature: z.ZodString;
+        score: z.ZodNullable<z.ZodNumber>;
+        pinned: z.ZodBoolean;
+    }, z.core.$strip>>;
+    sharedShapes: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        shape: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const searchKnowledgeResponseSchema: z.ZodObject<{
+    catalogVersion: z.ZodString;
+    knowledge: z.ZodArray<z.ZodObject<{
+        chunkId: z.ZodUUID;
+        text: z.ZodString;
+        score: z.ZodNumber;
+        citation: z.ZodObject<{
+            documentId: z.ZodUUID;
+            documentTitle: z.ZodString;
+            page: z.ZodNullable<z.ZodNumber>;
+            section: z.ZodNullable<z.ZodString>;
+            uri: z.ZodNullable<z.ZodURL>;
+            service: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const executeRequestSchema: z.ZodObject<{
+    input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    context: z.ZodOptional<z.ZodObject<{
+        threadId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        locale: z.ZodOptional<z.ZodEnum<{
+            ar: "ar";
+            en: "en";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const executeResponseSchema: z.ZodObject<{
+    toolId: z.ZodUUID;
+    name: z.ZodString;
+    version: z.ZodNumber;
+    output: z.ZodUnknown;
+    meta: z.ZodObject<{
+        upstreamStatus: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        replayed: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+        truncatedPaths: z.ZodArray<z.ZodString>;
+        drift: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                missing: "missing";
+                unexpected: "unexpected";
+                type_mismatch: "type_mismatch";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const runtimeErrorKindSchema: z.ZodEnum<{
+    timeout: "timeout";
+    upstream_4xx: "upstream_4xx";
+    upstream_5xx: "upstream_5xx";
+    schema_mismatch: "schema_mismatch";
+    rate_limited: "rate_limited";
+    not_found: "not_found";
+    unauthorized: "unauthorized";
+    invalid_request: "invalid_request";
+    egress_blocked: "egress_blocked";
+    internal: "internal";
+}>;
+export type RuntimeErrorKind = z.infer<typeof runtimeErrorKindSchema>;
+export declare const runtimeErrorSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        kind: z.ZodEnum<{
+            timeout: "timeout";
+            upstream_4xx: "upstream_4xx";
+            upstream_5xx: "upstream_5xx";
+            schema_mismatch: "schema_mismatch";
+            rate_limited: "rate_limited";
+            not_found: "not_found";
+            unauthorized: "unauthorized";
+            invalid_request: "invalid_request";
+            egress_blocked: "egress_blocked";
+            internal: "internal";
+        }>;
+        detail: z.ZodString;
+        retryable: z.ZodBoolean;
+        retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
+        upstreamStatus: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RuntimeAgentConfig = z.infer<typeof runtimeAgentConfigSchema>;
+export type ResolveRequest = z.input<typeof resolveRequestSchema>;
+export type ResolveResponse = z.infer<typeof resolveResponseSchema>;
+export type SearchRequest = z.input<typeof searchRequestSchema>;
+export type ExecuteRequest = z.input<typeof executeRequestSchema>;
+export {};

package/dist/contracts/wire.d.ts

@@ -0,0 +1,120 @@
+/**
+ * The wire contract — every shape that crosses the HTTP/WebSocket boundary
+ * between `@m6d/cortex-server` and the client SDKs (`@m6d/cortex-angular`,
+ * `@m6d/cortex-react`).
+ *
+ * Nothing here has a runtime dependency, and nothing here may grow one: this
+ * file is compiled into an Angular library, a React library and a Bun server
+ * alike.
+ */
+export declare const ATTACHMENT_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/webp", "application/pdf"];
+export declare const ATTACHMENT_MAX_BYTES: number;
+export declare const MAX_ATTACHMENTS_PER_MESSAGE = 5;
+export declare const ATTACHMENT_STATUSES: readonly ["pending", "described", "failed", "skipped"];
+export declare function checkAttachmentPolicy(contentType: string, sizeBytes: number): "type" | "size" | "ok";
+export type AttachmentStatus = (typeof ATTACHMENT_STATUSES)[number];
+export type AttachmentSummary = {
+    id: string;
+    filename: string;
+    contentType: string;
+    sizeBytes: number;
+    status: AttachmentStatus;
+    description?: string;
+};
+export type ThreadSummary = {
+    id: string;
+    title?: string;
+    createdAt: string;
+    updatedAt: string;
+    isRunning: boolean;
+};
+/**
+ * Response of `POST /chat/:chatId/abort`. `aborted: false` means there was no
+ * live run to abort — the turn had already committed — so the caller must not
+ * present the turn as aborted and should read the settled state back instead.
+ */
+export type AbortRunResult = {
+    aborted: boolean;
+};
+export type TokenUsage = {
+    input: {
+        noCache: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    output: {
+        reasoning: number;
+        text: number;
+        total: number;
+    };
+    total: number;
+};
+export type MessageMetadata = {
+    modelId?: string;
+    providerMetadata?: unknown;
+    isAborted?: boolean;
+    tokenUsage?: TokenUsage;
+    attachments?: AttachmentSummary[];
+};
+/**
+ * A stored message as it is persisted and served. TanStack AI's `UIMessage`
+ * has no metadata field, so cortex owns the envelope: the SDK's parts plus the
+ * server-derived metadata the UI renders on settled messages.
+ *
+ * `TPart` stays generic so this file keeps its zero dependencies — both
+ * sides substitute the SDK's `MessagePart`.
+ */
+export type CortexMessage<TPart = unknown> = {
+    id: string;
+    role: "system" | "user" | "assistant";
+    parts: TPart[];
+    metadata?: MessageMetadata;
+};
+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 ToolProgressEvent = {
+    type: "thread:tool-progress";
+    payload: {
+        threadId: string;
+        toolCallId: string;
+        toolName: string;
+        status: "started" | "finished";
+    };
+};
+export type WsEvent = ThreadCreatedEvent | ThreadDeletedEvent | ThreadTitleUpdatedEvent | ThreadRunStartedEvent | ThreadRunFinishedEvent | ThreadMessagesUpdatedEvent | ToolProgressEvent;

package/dist/src/lib/adapters/database/index.d.ts

@@ -0,0 +1,61 @@
+import type { Attachment, ChatMessage, NewAttachment, StoredMessage, Thread, TokenUsage } from "../../types";
+import type { ThreadContextMeta } from "../../ai/context/types";
+/**
+ * The persistence contract, implemented once per dialect under `mssql/` and
+ * `postgres/`.
+ *
+ * Those two trees are near-identical on purpose. Drizzle types its query
+ * builders per dialect, so a shared body is not expressible — `.top`/`.limit`,
+ * `.output`/`.returning` and the row-lock hint differ down in the query, not at
+ * a seam that could be factored out. What is *not* SQL lives in
+ * `message-content.ts` instead, so the rules the two must agree on are stated
+ * once.
+ *
+ * Drift is guarded rather than prevented: `db/schema.parity.test.ts` asserts the
+ * two schemas still infer the same rows, and the adapter tests beside this file
+ * run against both implementations. The `code-duplication` suppressions in
+ * `postgres/` record the same decision for fallow.
+ */
+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: ChatMessage[], options?: {
+            replaceAttachments?: boolean;
+        }): Promise<void>;
+    };
+    llmRequests: {
+        insert(requests: {
+            messageId: string;
+            stepNumber: number;
+            prompt: string;
+            output: string | null;
+            tokenUsage: TokenUsage | null;
+        }[]): Promise<void>;
+        listByMessageId(messageId: string): Promise<{
+            id: string;
+            prompt: string;
+            output: string | null;
+            tokenUsage: TokenUsage | null;
+        }[]>;
+    };
+    attachments: {
+        createPending(row: NewAttachment, limit: number): Promise<Attachment | undefined>;
+        getById(id: string, userId: string): Promise<Attachment | undefined>;
+        listByThread(threadId: string, userId: string): Promise<Attachment[]>;
+        claimForMessage(threadId: string, userId: string, messageId: string): Promise<Attachment[]>;
+        setDescription(id: string, userId: string, status: Attachment["status"], description?: string): Promise<void>;
+        remove(id: string, userId: string): Promise<Attachment | undefined>;
+    };
+};

package/dist/src/lib/adapters/database/message-content.d.ts

@@ -0,0 +1,30 @@
+import type { ChatMessage } from "../../types";
+/**
+ * The parts of `messages.upsert` that are decisions rather than SQL. Each
+ * dialect writes its own queries, but they must agree on what gets written —
+ * so the rules live here and neither repository restates them.
+ */
+/** Denormalized alongside the JSON content so the column is searchable. */
+export declare function textOf(message: ChatMessage): string | undefined;
+/**
+ * Attachments are the server's to assign: a caller may name them but never
+ * establish them. Only a turn that has just claimed them may carry them in.
+ */
+export declare function withOwnedAttachments(messages: ChatMessage[], replaceAttachments?: boolean): (ChatMessage | {
+    metadata: {
+        modelId?: string;
+        providerMetadata?: unknown;
+        isAborted?: boolean;
+        tokenUsage?: import("../../types").TokenUsage;
+    };
+    id: string;
+    role: "system" | "user" | "assistant";
+    parts: import("@tanstack/ai").MessagePart[];
+})[];
+/**
+ * The envelope is the server's — usage, model id and the attachments it claimed
+ * are facts no caller carries in full, so an update only contributes the fields
+ * it actually set. Attachments were already stripped from anything that must
+ * not replace them.
+ */
+export declare function mergeStoredContent(existing: ChatMessage, incoming: ChatMessage): ChatMessage;

package/dist/src/lib/adapters/database/mssql/attachments.d.ts

@@ -0,0 +1,100 @@
+import type { MssqlDb } from "./client";
+export declare function createAttachmentsRepository(db: MssqlDb): {
+    createPending(row: {
+        userId: string;
+        threadId: string;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        id?: string | undefined;
+        createdAt?: Date | undefined;
+        updatedAt?: Date | undefined;
+        messageId?: string | null | undefined;
+        description?: string | null | undefined;
+    }, limit: number): Promise<{
+        id: string;
+        userId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        threadId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    } | undefined>;
+    getById(id: string, userId: string): Promise<{
+        id: string;
+        userId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        threadId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    } | {
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        threadId: string;
+        userId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    } | undefined>;
+    listByThread(threadId: string, userId: string): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        threadId: string;
+        userId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    }[]>;
+    claimForMessage(threadId: string, userId: string, messageId: string): Promise<{
+        id: string;
+        userId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        threadId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    }[]>;
+    setDescription(id: string, userId: string, status: "pending" | "described" | "failed" | "skipped", description: string | undefined): Promise<void>;
+    remove(id: string, userId: string): Promise<{
+        id: string;
+        userId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        threadId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    } | undefined>;
+};

package/dist/src/lib/adapters/database/mssql/client.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Global snake_case mapping means schema columns are never spelled out twice —
+ * the TypeScript name is the source of truth and Drizzle derives the column.
+ */
+export declare function createMssqlDb(connectionString: string): import("drizzle-orm/node-mssql").NodeMsSqlDatabase<Record<string, never>> & {
+    $client: import("drizzle-orm/node-mssql/pool").AutoPool;
+};
+export type MssqlDb = ReturnType<typeof createMssqlDb>;