@goscribe/server 1.5.0 → 1.7.0

package/dist/services/content/media-analysis.service.js

@@ -7,6 +7,7 @@ import { ai } from '../../lib/ai/index.js';
 import { workspaceKbService } from '../workspace/workspace-kb.service.js';
 import { getUserUsage, getUserPlanLimits } from '../billing/usage.service.js';
 import { notifyArtifactFailed, notifyArtifactReady } from '../notifications/notification.service.js';
+import { FlashcardService } from './flashcard.service.js';
 const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'];
 const PROGRESS_FILENAME_MAX_CHARS = 20;
 function truncateProgressFilename(value, maxChars = PROGRESS_FILENAME_MAX_CHARS) {
@@ -312,16 +313,27 @@ export class MediaAnalysisService extends BaseService {
                         }));
                         const flashcardRag = await workspaceKbService.retrieveContext(input.workspaceId, 'flashcard key concepts facts definitions questions', 8);
                         const content = await ai.backend.generateFlashcardQuestions(input.workspaceId, userId, 10, 'medium', undefined, { ragContext: flashcardRag });
-                        const artifact = await this.db.artifact.create({
-                            data: {
-                                workspaceId: input.workspaceId,
-                                type: ArtifactType.FLASHCARD_SET,
-                                title: files.length === 1
-                                    ? `Flashcards - ${primaryFile.name}`
-                                    : `Flashcards - ${files.length} files`,
-                                createdById: userId,
-                            },
+                        const flashcardService = new FlashcardService(this.db);
+                        const primarySet = await flashcardService.ensurePrimarySet(userId, input.workspaceId);
+                        const orderOffset = primarySet.flashcards.reduce((max, card) => Math.max(max, card.order), -1);
+                        const flashcardTitle = files.length === 1
+                            ? `Flashcards - ${primaryFile.name}`
+                            : `Flashcards - ${files.length} files`;
+                        await this.db.artifact.update({
+                            where: { id: primarySet.id },
+                            data: { title: flashcardTitle },
                         });
+                        const appendCard = async (front, back, index) => {
+                            await this.db.flashcard.create({
+                                data: {
+                                    artifactId: primarySet.id,
+                                    front,
+                                    back,
+                                    order: orderOffset + 1 + index,
+                                    tags: ['ai-generated', 'medium'],
+                                },
+                            });
+                        };
                         try {
                             const parsed = typeof content === 'string' ? JSON.parse(content) : content;
                             const flashcardData = Array.isArray(parsed) ? parsed : (parsed.flashcards || []);
@@ -329,15 +341,7 @@ export class MediaAnalysisService extends BaseService {
                                 const card = flashcardData[i];
                                 const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
                                 const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
-                                await this.db.flashcard.create({
-                                    data: {
-                                        artifactId: artifact.id,
-                                        front: front,
-                                        back: back,
-                                        order: i,
-                                        tags: ['ai-generated', 'medium'],
-                                    },
-                                });
+                                await appendCard(front, back, i);
                             }
                         }
                         catch (parseError) {
@@ -347,18 +351,14 @@ export class MediaAnalysisService extends BaseService {
                                 const line = lines[i];
                                 if (line.includes(' - ')) {
                                     const [front, back] = line.split(' - ');
-                                    await this.db.flashcard.create({
-                                        data: {
-                                            artifactId: artifact.id,
-                                            front: front.trim(),
-                                            back: back.trim(),
-                                            order: i,
-                                            tags: ['ai-generated', 'medium'],
-                                        },
-                                    });
+                                    await appendCard(front.trim(), back.trim(), i);
                                 }
                             }
                         }
+                        const artifact = await this.db.artifact.findUniqueOrThrow({
+                            where: { id: primarySet.id },
+                            include: { flashcards: true },
+                        });
                         results.artifacts.flashcards = artifact;
                         await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
                         await notifyArtifactReady(this.db, {

package/dist/services/content/worksheet-generation.service.test.js

@@ -4,8 +4,8 @@ import { mergeWorksheetGenerationConfig, normalizeWorksheetProblemForDb } from '
 test('mergeWorksheetGenerationConfig: override beats preset and legacy', () => {
     const r = mergeWorksheetGenerationConfig({ mode: 'practice', numQuestions: 5, difficulty: 'easy' }, { mode: 'quiz', numQuestions: 10, difficulty: 'medium' }, { numQuestions: 3, difficulty: 'hard' });
     assert.equal(r.mode, 'quiz');
-    assert.equal(r.numQuestions, 10);
-    assert.equal(r.difficulty, 'medium');
+    assert.equal(r.numQuestions, 3);
+    assert.equal(r.difficulty, 'hard');
 });
 test('normalizeWorksheetProblemForDb coerces MCQ answer to option index', () => {
     const row = normalizeWorksheetProblemForDb({

package/dist/services/workspace/workspace.service.d.ts

@@ -33,35 +33,26 @@ export declare class WorkspaceService extends BaseService {
         folders: {
             name: string;
             id: string;
-            createdAt: Date;
             updatedAt: Date;
-            ownerId: string;
             parentId: string | null;
             color: string;
             markerColor: string | null;
         }[];
-        workspaces: ({
-            uploads: {
-                name: string;
-                id: string;
-                createdAt: Date;
-                mimeType: string;
-            }[];
-        } & {
+        workspaces: {
             id: string;
-            createdAt: Date;
             updatedAt: Date;
             title: string;
-            description: string | null;
-            ownerId: string;
             color: string;
             markerColor: string | null;
             icon: string;
             folderId: string | null;
-            fileBeingAnalyzed: boolean;
-            analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
-            needsAnalysis: boolean;
-        })[];
+            uploads: {
+                name: string;
+                id: string;
+                createdAt: Date;
+                mimeType: string;
+            }[];
+        }[];
     }>;
     create(userId: string, input: {
         name: string;
@@ -122,70 +113,35 @@ export declare class WorkspaceService extends BaseService {
         markerColor: string | null;
     }>;
     get(userId: string, id: string): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
         folder: {
             name: string;
             id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            ownerId: string;
-            parentId: string | null;
             color: string;
-            markerColor: string | null;
         } | null;
-        artifacts: {
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            workspaceId: string;
-            type: import("@prisma/client").$Enums.ArtifactType;
-            title: string;
-            isArchived: boolean;
-            difficulty: import("@prisma/client").$Enums.Difficulty | null;
-            estimatedTime: string | null;
-            createdById: string | null;
-            description: string | null;
-            generating: boolean;
-            generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
-            worksheetConfig: import("@prisma/client/runtime/library").JsonValue | null;
-            imageObjectKey: string | null;
-        }[];
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        icon: string;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: import("@prisma/client/runtime/library").JsonValue;
+        needsAnalysis: boolean;
         uploads: {
-            meta: import("@prisma/client/runtime/library").JsonValue | null;
             name: string;
             id: string;
             createdAt: Date;
-            workspaceId: string | null;
-            userId: string | null;
             mimeType: string;
             size: number;
-            bucket: string | null;
             objectKey: string | null;
-            url: string | null;
-            checksum: string | null;
-            aiTranscription: import("@prisma/client/runtime/library").JsonValue | null;
         }[];
-    } & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        title: string;
-        description: string | null;
-        ownerId: string;
-        color: string;
-        markerColor: string | null;
-        icon: string;
-        folderId: string | null;
-        fileBeingAnalyzed: boolean;
-        analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
-        needsAnalysis: boolean;
-    }>;
-    getStats(userId: string): Promise<{
-        workspaces: number;
-        folders: number;
-        lastUpdated: Date | undefined;
-        spaceUsed: number;
-        spaceTotal: number;
     }>;
+    getAccountSummary(userId: string): Promise<import("../billing/usage.service.js").AccountSummary>;
+    getStats(userId: string): Promise<import("../billing/usage.service.js").AccountStats>;
     update(userId: string, input: {
         id: string;
         name?: string;

package/dist/services/workspace/workspace.service.js

@@ -1,10 +1,10 @@
 import { TRPCError } from '@trpc/server';
 import { BaseService } from '../base.service.js';
-import { ArtifactType } from '../../lib/constants.js';
 import { supabaseClient } from '../../lib/storage.js';
 import PusherService from '../../lib/pusher.js';
 import { ai } from '../../lib/ai/index.js';
 import { workspaceKbService } from './workspace-kb.service.js';
+import { getAccountSummary, invalidateUserBillingCache, } from '../billing/usage.service.js';
 import { getUserStorageLimit } from '../billing/subscription.service.js';
 import { notifyWorkspaceDeleted } from '../notifications/notification.service.js';
 export class WorkspaceService extends BaseService {
@@ -22,24 +22,41 @@ export class WorkspaceService extends BaseService {
         return { workspaces, folders };
     }
     async getTree(userId) {
-        const allFolders = await this.db.folder.findMany({
-            where: { ownerId: userId },
-            orderBy: { updatedAt: 'desc' },
-        });
-        const allWorkspaces = await this.db.workspace.findMany({
-            where: { ownerId: userId },
-            include: {
-                uploads: {
-                    select: {
-                        id: true,
-                        name: true,
-                        mimeType: true,
-                        createdAt: true,
+        const [allFolders, allWorkspaces] = await Promise.all([
+            this.db.folder.findMany({
+                where: { ownerId: userId },
+                select: {
+                    id: true,
+                    name: true,
+                    parentId: true,
+                    color: true,
+                    markerColor: true,
+                    updatedAt: true,
+                },
+                orderBy: { updatedAt: 'desc' },
+            }),
+            this.db.workspace.findMany({
+                where: { ownerId: userId },
+                select: {
+                    id: true,
+                    title: true,
+                    folderId: true,
+                    icon: true,
+                    color: true,
+                    markerColor: true,
+                    updatedAt: true,
+                    uploads: {
+                        select: {
+                            id: true,
+                            name: true,
+                            mimeType: true,
+                            createdAt: true,
+                        },
                     },
                 },
-            },
-            orderBy: { updatedAt: 'desc' },
-        });
+                orderBy: { updatedAt: 'desc' },
+            }),
+        ]);
         return { folders: allFolders, workspaces: allWorkspaces };
     }
     async create(userId, input) {
@@ -50,27 +67,16 @@ export class WorkspaceService extends BaseService {
                 ownerId: userId,
                 folderId: input.parentId ?? null,
                 ...(input.markerColor !== undefined ? { markerColor: input.markerColor } : {}),
-                artifacts: {
-                    create: {
-                        type: ArtifactType.FLASHCARD_SET,
-                        title: 'New Flashcard Set',
-                    },
-                    createMany: {
-                        data: [
-                            { type: ArtifactType.WORKSHEET, title: 'Worksheet 1' },
-                            { type: ArtifactType.WORKSHEET, title: 'Worksheet 2' },
-                        ],
-                    },
-                },
             },
         });
-        await ai.backend.initSession(ws.id, userId).catch((err) => {
+        void ai.backend.initSession(ws.id, userId).catch((err) => {
             this.logger.error('Failed to init AI session on workspace creation:', err);
         });
-        await workspaceKbService.ensureWorkspaceKb(ws.id, userId, input.name).catch((err) => {
+        void workspaceKbService.ensureWorkspaceKb(ws.id, userId, input.name).catch((err) => {
             this.logger.error('Failed to create workspace knowledge base:', err);
         });
-        await PusherService.emitLibraryUpdate(userId);
+        invalidateUserBillingCache(userId);
+        void PusherService.emitLibraryUpdate(userId);
         return ws;
     }
     async createFolder(userId, input) {
@@ -101,43 +107,44 @@ export class WorkspaceService extends BaseService {
     async get(userId, id) {
         const ws = await this.db.workspace.findFirst({
             where: { id, ownerId: userId },
-            include: {
-                artifacts: true,
-                folder: true,
-                uploads: true,
+            select: {
+                id: true,
+                title: true,
+                description: true,
+                icon: true,
+                color: true,
+                markerColor: true,
+                ownerId: true,
+                folderId: true,
+                fileBeingAnalyzed: true,
+                analysisProgress: true,
+                needsAnalysis: true,
+                createdAt: true,
+                updatedAt: true,
+                folder: { select: { id: true, name: true, color: true } },
+                uploads: {
+                    select: {
+                        id: true,
+                        name: true,
+                        mimeType: true,
+                        size: true,
+                        createdAt: true,
+                        objectKey: true,
+                    },
+                    orderBy: { createdAt: 'desc' },
+                },
             },
         });
         if (!ws)
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ws;
     }
+    async getAccountSummary(userId) {
+        return getAccountSummary(userId);
+    }
     async getStats(userId) {
-        const workspaces = await this.db.workspace.findMany({
-            where: {
-                OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
-            },
-        });
-        const folders = await this.db.folder.findMany({
-            where: { OR: [{ ownerId: userId }] },
-        });
-        const lastUpdated = await this.db.workspace.findFirst({
-            where: {
-                OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
-            },
-            orderBy: { updatedAt: 'desc' },
-        });
-        const spaceLeft = await this.db.fileAsset.aggregate({
-            where: { workspaceId: { in: workspaces.map((ws) => ws.id) }, userId },
-            _sum: { size: true },
-        });
-        const storageLimit = await getUserStorageLimit(userId);
-        return {
-            workspaces: workspaces.length,
-            folders: folders.length,
-            lastUpdated: lastUpdated?.updatedAt,
-            spaceUsed: spaceLeft._sum?.size ?? 0,
-            spaceTotal: storageLimit,
-        };
+        const summary = await getAccountSummary(userId);
+        return summary.stats;
     }
     async update(userId, input) {
         const existed = await this.db.workspace.findFirst({

package/dist/src/context.d.ts

@@ -0,0 +1,27 @@
+import type { CreateExpressContextOptions } from "@trpc/server/adapters/express";
+import { prisma } from "./lib/prisma.js";
+import cookie from "cookie";
+export type SessionUser = {
+    id: string;
+    emailVerified: boolean;
+    isSystemAdmin: boolean;
+};
+export declare function createContext({ req, res }: CreateExpressContextOptions): Promise<{
+    db: import("../generated/prisma/client.js").PrismaClient;
+    session: null;
+    req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    res: import("express").Response<any, Record<string, any>>;
+    cookies: cookie.Cookies;
+} | {
+    db: import("../generated/prisma/client.js").PrismaClient;
+    session: {
+        user: SessionUser;
+    };
+    req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    res: import("express").Response<any, Record<string, any>>;
+    cookies: cookie.Cookies;
+}>;
+/** Use `typeof prisma` for `db` so TS keeps generated model delegates (not a bare PrismaClient). */
+export type Context = Omit<Awaited<ReturnType<typeof createContext>>, "db"> & {
+    db: typeof prisma;
+};

package/dist/src/context.js

@@ -0,0 +1,33 @@
+import { prisma } from "./lib/prisma.js";
+import { verifyCustomAuthCookie } from "./lib/auth.js";
+import cookie from "cookie";
+export async function createContext({ req, res }) {
+    const cookies = cookie.parse(req.headers.cookie ?? "");
+    const custom = verifyCustomAuthCookie(cookies["auth_token"]);
+    if (custom) {
+        const user = await prisma.user.findUnique({
+            where: { id: custom.userId },
+            select: {
+                id: true,
+                emailVerified: true,
+                role: { select: { name: true } },
+            },
+        });
+        if (!user) {
+            return { db: prisma, session: null, req, res, cookies };
+        }
+        const sessionUser = {
+            id: user.id,
+            emailVerified: !!user.emailVerified,
+            isSystemAdmin: user.role?.name === "System Admin",
+        };
+        return {
+            db: prisma,
+            session: { user: sessionUser },
+            req,
+            res,
+            cookies,
+        };
+    }
+    return { db: prisma, session: null, req, res, cookies };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export type { AppRouter } from "./routers/_app.js";
+export type { RouterInputs } from "./routers/_app.js";
+export type { RouterOutputs } from "./routers/_app.js";

package/dist/src/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/lib/ai/config.d.ts

@@ -0,0 +1,20 @@
+export declare const aiConfig: {
+    readonly llm: {
+        readonly apiKey: string | undefined;
+        readonly baseUrl: string | undefined;
+        readonly model: string;
+    };
+    readonly embeddings: {
+        readonly apiKey: string | undefined;
+        readonly baseUrl: undefined;
+        readonly model: string;
+        readonly dim: number;
+    };
+    readonly inferenceBackend: {
+        readonly url: string | undefined;
+        readonly mockEnabled: boolean;
+        readonly mockDelayMs: 0 | 10000;
+    };
+};
+export declare function getInferenceBackendUploadUrl(): string;
+export declare function tryGetInferenceBackendUploadUrl(): string | null;

package/dist/src/lib/ai/config.js

@@ -0,0 +1,31 @@
+export const aiConfig = {
+    llm: {
+        apiKey: process.env.INFERENCE_API_KEY,
+        baseUrl: process.env.INFERENCE_BASE_URL,
+        model: process.env.INFERENCE_MODEL ?? 'command-a-03-2025',
+    },
+    embeddings: {
+        apiKey: process.env.OPENAI_API_KEY,
+        baseUrl: undefined,
+        model: process.env.EMBEDDING_MODEL ?? 'text-embedding-3-small',
+        dim: Number(process.env.EMBEDDING_DIM ?? 1536),
+    },
+    inferenceBackend: {
+        url: process.env.INFERENCE_API_URL,
+        mockEnabled: process.env.DONT_TEST_INFERENCE === 'true',
+        mockDelayMs: process.env.DONT_TEST_INFERENCE === 'true' ? 10000 : 0,
+    },
+};
+export function getInferenceBackendUploadUrl() {
+    const base = aiConfig.inferenceBackend.url;
+    if (!base) {
+        throw new Error('INFERENCE_API_URL is not configured');
+    }
+    return `${base.replace(/\/$/, '')}/upload`;
+}
+export function tryGetInferenceBackendUploadUrl() {
+    const base = aiConfig.inferenceBackend.url;
+    if (!base)
+        return null;
+    return `${base.replace(/\/$/, '')}/upload`;
+}

package/dist/src/lib/ai/embedding-client.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_EMBEDDING_MODEL: string;
+export declare const DEFAULT_EMBEDDING_DIM: number;
+export interface EmbedOptions {
+    model?: string;
+}
+export declare function embedTexts(texts: string[], opts?: EmbedOptions): Promise<number[][]>;
+export declare function embedQuery(text: string, opts?: EmbedOptions): Promise<number[]>;
+export declare function toVectorLiteral(vec: number[]): string;

package/dist/src/lib/ai/embedding-client.js

@@ -0,0 +1,30 @@
+import OpenAI from 'openai';
+import { aiConfig } from './config.js';
+const client = new OpenAI({
+    apiKey: aiConfig.embeddings.apiKey,
+    baseURL: aiConfig.embeddings.baseUrl,
+});
+export const DEFAULT_EMBEDDING_MODEL = aiConfig.embeddings.model;
+export const DEFAULT_EMBEDDING_DIM = aiConfig.embeddings.dim;
+export async function embedTexts(texts, opts = {}) {
+    const model = opts.model ?? DEFAULT_EMBEDDING_MODEL;
+    if (texts.length === 0)
+        return [];
+    const BATCH = 96;
+    const out = new Array(texts.length);
+    for (let i = 0; i < texts.length; i += BATCH) {
+        const batch = texts.slice(i, i + BATCH);
+        const res = await client.embeddings.create({ model, input: batch });
+        res.data.forEach((row, j) => {
+            out[i + j] = row.embedding;
+        });
+    }
+    return out;
+}
+export async function embedQuery(text, opts = {}) {
+    const [vec] = await embedTexts([text], opts);
+    return vec;
+}
+export function toVectorLiteral(vec) {
+    return `[${vec.map((n) => (Number.isFinite(n) ? n : 0)).join(',')}]`;
+}

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

@@ -0,0 +1,48 @@
+import { aiConfig } from './config.js';
+import { complete, completeText, streamComplete } from './llm-client.js';
+import { DEFAULT_EMBEDDING_DIM, DEFAULT_EMBEDDING_MODEL, embedQuery, embedTexts, toVectorLiteral } from './embedding-client.js';
+import { extractJson, parseJsonField } from './json-parse.js';
+import { isAiMockMode, mockDelay } from './mock.js';
+import { inferenceBackend } from './inference-backend/client.js';
+export declare const ai: {
+    config: {
+        readonly llm: {
+            readonly apiKey: string | undefined;
+            readonly baseUrl: string | undefined;
+            readonly model: string;
+        };
+        readonly embeddings: {
+            readonly apiKey: string | undefined;
+            readonly baseUrl: undefined;
+            readonly model: string;
+            readonly dim: number;
+        };
+        readonly inferenceBackend: {
+            readonly url: string | undefined;
+            readonly mockEnabled: boolean;
+            readonly mockDelayMs: 0 | 10000;
+        };
+    };
+    isMockMode: typeof isAiMockMode;
+    mockDelay: typeof mockDelay;
+    llm: {
+        complete: typeof complete;
+        completeText: typeof completeText;
+        streamComplete: typeof streamComplete;
+    };
+    embed: {
+        texts: typeof embedTexts;
+        query: typeof embedQuery;
+        toVectorLiteral: typeof toVectorLiteral;
+        DEFAULT_MODEL: string;
+        DEFAULT_DIM: number;
+    };
+    backend: import("./inference-backend/client.js").InferenceBackendClient;
+    parse: {
+        extractJson: typeof extractJson;
+        parseJsonField: typeof parseJsonField;
+    };
+};
+export type { ChatMessage, ChatRole, CompleteOptions } from './types.js';
+export type { AISession, ProcessFileResult, PodcastSpeaker, StudyGuideSegment, WorksheetGenerationOptions, } from './inference-backend/types.js';
+export { aiConfig, complete, completeText, streamComplete, DEFAULT_EMBEDDING_DIM, DEFAULT_EMBEDDING_MODEL, embedQuery, embedTexts, extractJson, inferenceBackend, isAiMockMode, mockDelay, parseJsonField, toVectorLiteral, };

package/dist/src/lib/ai/index.js

@@ -0,0 +1,29 @@
+import { aiConfig } from './config.js';
+import { complete, completeText, streamComplete, } from './llm-client.js';
+import { DEFAULT_EMBEDDING_DIM, DEFAULT_EMBEDDING_MODEL, embedQuery, embedTexts, toVectorLiteral, } from './embedding-client.js';
+import { extractJson, parseJsonField } from './json-parse.js';
+import { isAiMockMode, mockDelay } from './mock.js';
+import { inferenceBackend } from './inference-backend/client.js';
+export const ai = {
+    config: aiConfig,
+    isMockMode: isAiMockMode,
+    mockDelay,
+    llm: {
+        complete,
+        completeText,
+        streamComplete,
+    },
+    embed: {
+        texts: embedTexts,
+        query: embedQuery,
+        toVectorLiteral,
+        DEFAULT_MODEL: DEFAULT_EMBEDDING_MODEL,
+        DEFAULT_DIM: DEFAULT_EMBEDDING_DIM,
+    },
+    backend: inferenceBackend,
+    parse: {
+        extractJson,
+        parseJsonField,
+    },
+};
+export { aiConfig, complete, completeText, streamComplete, DEFAULT_EMBEDDING_DIM, DEFAULT_EMBEDDING_MODEL, embedQuery, embedTexts, extractJson, inferenceBackend, isAiMockMode, mockDelay, parseJsonField, toVectorLiteral, };