@goscribe/server 1.3.3 → 1.5.0

package/dist/controllers/workspace.controller.js

@@ -0,0 +1,9 @@
+import { prisma } from '../lib/prisma.js';
+import { workspace } from '../routers/workspace.js';
+import { RouterModuleRepository } from '../repositories/router-module.repository.js';
+import { RouterModuleService } from '../services/router-module.service.js';
+import { RouterModuleController } from './router-module.controller.js';
+const workspaceRepository = new RouterModuleRepository(prisma, workspace);
+const workspaceService = new RouterModuleService(prisma, workspaceRepository);
+export const workspaceController = new RouterModuleController(workspaceService);
+export const workspaceRouter = workspaceController.getModule();

package/dist/lib/activity_human_description.test.js

@@ -1,16 +1,17 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { getActivityHumanDescription, getTrpcPathsMatchingDescriptionSearch, } from "./activity_human_description.js";
-test("description search resolves paths by label substring", () => {
-    const paths = getTrpcPathsMatchingDescriptionSearch("study streak");
-    assert.ok(paths.includes("workspace.getStudyAnalytics"));
-});
-test("known path returns curated label", () => {
-    assert.equal(getActivityHumanDescription("workspace.getStudyAnalytics"), "Loaded study streak and analytics");
-    assert.equal(getActivityHumanDescription("payment.getUsageOverview"), "Viewed plan usage and limits");
-});
-test("unknown path gets formatted fallback", () => {
-    const d = getActivityHumanDescription("someRouter.unknownProcedureName");
-    assert.ok(d.includes("Some Router"));
-    assert.ok(d.includes("Unknown"));
+import { describe, it, expect } from 'vitest';
+import { getActivityHumanDescription, getTrpcPathsMatchingDescriptionSearch, } from './activity_human_description.js';
+describe('activity_human_description', () => {
+    it('description search resolves paths by label substring', () => {
+        const paths = getTrpcPathsMatchingDescriptionSearch('study streak');
+        expect(paths).toContain('workspace.getStudyAnalytics');
+    });
+    it('known path returns curated label', () => {
+        expect(getActivityHumanDescription('workspace.getStudyAnalytics')).toBe('Loaded study streak and analytics');
+        expect(getActivityHumanDescription('payment.getUsageOverview')).toBe('Viewed plan usage and limits');
+    });
+    it('unknown path gets formatted fallback', () => {
+        const d = getActivityHumanDescription('someRouter.unknownProcedureName');
+        expect(d).toContain('Some Router');
+        expect(d).toContain('Unknown');
+    });
 });

package/dist/lib/activity_log_service.test.js

@@ -1,27 +1,32 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { ActivityLogCategory, ActivityLogStatus } from "@prisma/client";
-import { buildActivityLogWhere, inferCategoryFromTrpcPath, redactSensitive, } from "./activity_log_service.js";
-test("redactSensitive redacts sensitive keys", () => {
-    const out = redactSensitive({
-        email: "a@b.com",
-        password: "secret",
-        nested: { authToken: "t", safe: 1 },
+import { describe, it, expect } from 'vitest';
+import { ActivityLogCategory, ActivityLogStatus } from '@prisma/client';
+import { buildActivityLogWhere, inferCategoryFromTrpcPath, redactSensitive, } from './activity_log_service.js';
+describe('redactSensitive', () => {
+    it('redacts sensitive keys', () => {
+        const out = redactSensitive({
+            email: 'a@b.com',
+            password: 'secret',
+            nested: { authToken: 't', safe: 1 },
+        });
+        expect(out.password).toBe('[REDACTED]');
+        const nested = out.nested;
+        expect(nested.authToken).toBe('[REDACTED]');
+        expect(nested.safe).toBe(1);
     });
-    assert.equal(out.password, "[REDACTED]");
-    const nested = out.nested;
-    assert.equal(nested.authToken, "[REDACTED]");
-    assert.equal(nested.safe, 1);
 });
-test("inferCategoryFromTrpcPath maps routers", () => {
-    assert.equal(inferCategoryFromTrpcPath("auth.login"), ActivityLogCategory.AUTH);
-    assert.equal(inferCategoryFromTrpcPath("payment.checkout"), ActivityLogCategory.BILLING);
-    assert.equal(inferCategoryFromTrpcPath("admin.listUsers"), ActivityLogCategory.ADMIN);
-    assert.equal(inferCategoryFromTrpcPath("workspace.list"), ActivityLogCategory.WORKSPACE);
-    assert.equal(inferCategoryFromTrpcPath("flashcards.list"), ActivityLogCategory.CONTENT);
+describe('inferCategoryFromTrpcPath', () => {
+    it('maps routers to categories', () => {
+        expect(inferCategoryFromTrpcPath('auth.login')).toBe(ActivityLogCategory.AUTH);
+        expect(inferCategoryFromTrpcPath('payment.checkout')).toBe(ActivityLogCategory.BILLING);
+        expect(inferCategoryFromTrpcPath('admin.listUsers')).toBe(ActivityLogCategory.ADMIN);
+        expect(inferCategoryFromTrpcPath('workspace.list')).toBe(ActivityLogCategory.WORKSPACE);
+        expect(inferCategoryFromTrpcPath('flashcards.list')).toBe(ActivityLogCategory.CONTENT);
+    });
 });
-test("buildActivityLogWhere forces actor for user scope", () => {
-    const w = buildActivityLogWhere({ status: ActivityLogStatus.SUCCESS }, { forceActorUserId: "user-1" });
-    assert.equal(w.actorUserId, "user-1");
-    assert.equal(w.status, ActivityLogStatus.SUCCESS);
+describe('buildActivityLogWhere', () => {
+    it('forces actor for user scope', () => {
+        const w = buildActivityLogWhere({ status: ActivityLogStatus.SUCCESS }, { forceActorUserId: 'user-1' });
+        expect(w.actorUserId).toBe('user-1');
+        expect(w.status).toBe(ActivityLogStatus.SUCCESS);
+    });
 });

package/dist/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/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/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/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/lib/ai/index.d.ts

@@ -0,0 +1,47 @@
+import { aiConfig } from './config.js';
+import { complete, completeText } 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;
+    };
+    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, DEFAULT_EMBEDDING_DIM, DEFAULT_EMBEDDING_MODEL, embedQuery, embedTexts, extractJson, inferenceBackend, isAiMockMode, mockDelay, parseJsonField, toVectorLiteral, };

package/dist/lib/ai/index.js

@@ -0,0 +1,28 @@
+import { aiConfig } from './config.js';
+import { complete, completeText, } 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,
+    },
+    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, DEFAULT_EMBEDDING_DIM, DEFAULT_EMBEDDING_MODEL, embedQuery, embedTexts, extractJson, inferenceBackend, isAiMockMode, mockDelay, parseJsonField, toVectorLiteral, };

package/dist/lib/ai/inference-backend/client.d.ts

@@ -0,0 +1,28 @@
+import type { MarkScheme, UserMarkScheme } from '../../../types/index.js';
+import type { AISession, PodcastSpeaker, ProcessFileResult, StudyGuideSegment, WorksheetGenerationOptions, BackendGenerationOptions } from './types.js';
+export declare class InferenceBackendClient {
+    private sessions;
+    private get uploadUrl();
+    private postCommand;
+    private buildForm;
+    private withRag;
+    initSession(workspaceId: string, user: string): Promise<AISession>;
+    processFile(sessionId: string, _user: string, fileUrl: string, fileType: 'image' | 'pdf', maxPages?: number): Promise<ProcessFileResult>;
+    generateStudyGuide(sessionId: string, user: string, opts?: BackendGenerationOptions): Promise<string>;
+    generateFlashcardQuestions(sessionId: string, user: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard', prompt?: string, opts?: BackendGenerationOptions): Promise<string>;
+    generateWorksheetQuestions(sessionId: string, user: string, numQuestions: number, difficulty: 'EASY' | 'MEDIUM' | 'HARD', options?: WorksheetGenerationOptions): Promise<string>;
+    checkWorksheetQuestions(sessionId: string, user: string, question: string, answer: string, markScheme: MarkScheme): Promise<UserMarkScheme>;
+    generatePodcastStructure(sessionId: string, user: string, title: string, description: string, prompt: string, speakers: PodcastSpeaker[]): Promise<any>;
+    generatePodcastAudioFromText(sessionId: string, user: string, podcastId: string, segmentIndex: number, text: string, speakers: PodcastSpeaker[], voiceId?: string): Promise<any>;
+    generatePodcastImage(sessionId: string, user: string, summary: string): Promise<string>;
+    segmentStudyGuide(sessionId: string, user: string, studyGuide: string): Promise<StudyGuideSegment[]>;
+    validateSegmentSummary(sessionId: string, user: string, segmentContent: string, studentResponse: string, studyGuide: string): Promise<{
+        valid: boolean;
+        feedback: string;
+    }>;
+    getSession(sessionId: string): AISession | undefined;
+    getSessionsByUserAndWorkspace(_userId: string, workspaceId: string): AISession[];
+    deleteSession(sessionId: string): boolean;
+    checkHealth(): Promise<boolean>;
+}
+export declare const inferenceBackend: InferenceBackendClient;

package/dist/lib/ai/inference-backend/client.js

@@ -0,0 +1,301 @@
+import { TRPCError } from '@trpc/server';
+import { getInferenceBackendUploadUrl, aiConfig, tryGetInferenceBackendUploadUrl } from '../config.js';
+import { isAiMockMode, mockDelay } from '../mock.js';
+import { parseJsonField } from '../json-parse.js';
+import { withRetry } from '../../retry.js';
+import { logger } from '../../logger.js';
+import { mockFlashcards, mockPodcastAudio, mockPodcastStructure, mockProcessFile, mockSegmentSummaryValidation, mockStudyGuide, mockStudyGuideSegmentation, mockWorksheet, } from './mocks.js';
+export class InferenceBackendClient {
+    constructor() {
+        this.sessions = new Map();
+    }
+    get uploadUrl() {
+        return getInferenceBackendUploadUrl();
+    }
+    async postCommand(formData, options) {
+        const { label, timeoutMs = 300000, retries = 3 } = options;
+        return withRetry(async () => {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(this.uploadUrl, {
+                    method: 'POST',
+                    body: formData,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => '');
+                    throw new Error(`AI backend error (${response.status}): ${errorText || response.statusText}`);
+                }
+                return (await response.json());
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                throw error;
+            }
+        }, { maxRetries: retries, timeoutMs, label });
+    }
+    buildForm(command, fields = {}) {
+        const formData = new FormData();
+        formData.append('command', command);
+        for (const [key, value] of Object.entries(fields)) {
+            formData.append(key, value);
+        }
+        return formData;
+    }
+    withRag(fields, opts) {
+        if (opts?.ragContext?.trim()) {
+            return { ...fields, rag_context: opts.ragContext.trim() };
+        }
+        return fields;
+    }
+    async initSession(workspaceId, user) {
+        await mockDelay();
+        const sessionId = workspaceId;
+        if (isAiMockMode()) {
+            logger.info(`[ai] mock initSession workspace=${workspaceId}`);
+            const session = {
+                id: sessionId,
+                workspaceId,
+                status: 'initialized',
+                files: [],
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            this.sessions.set(sessionId, session);
+            return session;
+        }
+        const result = await this.postCommand(this.buildForm('init_session', { session: sessionId, user }), { label: 'initSession' });
+        if (!result.message) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'AI backend returned no session message',
+            });
+        }
+        const session = {
+            id: sessionId,
+            workspaceId,
+            status: 'initialized',
+            files: [],
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        this.sessions.set(sessionId, session);
+        return session;
+    }
+    async processFile(sessionId, _user, fileUrl, fileType, maxPages) {
+        await mockDelay();
+        if (isAiMockMode()) {
+            logger.info(`[ai] mock processFile session=${sessionId} type=${fileType}`);
+            return mockProcessFile(fileType);
+        }
+        const fields = { fileUrl, fileType };
+        if (maxPages)
+            fields.maxPages = maxPages.toString();
+        try {
+            const result = await this.postCommand(this.buildForm('process_file', fields), { label: 'processFile' });
+            if (result.status === 'error') {
+                throw new Error(result.error || 'File processing failed');
+            }
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`[ai] processFile failed: ${message}`);
+            return {
+                status: 'error',
+                textContent: null,
+                imageDescriptions: [],
+                comprehensiveDescription: null,
+                pageCount: 0,
+                error: message,
+            };
+        }
+    }
+    async generateStudyGuide(sessionId, user, opts) {
+        await mockDelay();
+        if (isAiMockMode()) {
+            logger.info(`[ai] mock generateStudyGuide session=${sessionId}`);
+            return mockStudyGuide();
+        }
+        const result = await this.postCommand(this.buildForm('generate_study_guide', this.withRag({ session: sessionId, user }, opts)), { label: 'generateStudyGuide' });
+        if (!result.markdown) {
+            throw new Error('AI backend returned empty study guide');
+        }
+        return result.markdown;
+    }
+    async generateFlashcardQuestions(sessionId, user, numQuestions, difficulty, prompt, opts) {
+        await mockDelay();
+        if (isAiMockMode()) {
+            logger.info(`[ai] mock generateFlashcardQuestions session=${sessionId}`);
+            return JSON.stringify(mockFlashcards(numQuestions, difficulty));
+        }
+        const fields = {
+            session: sessionId,
+            user,
+            num_questions: numQuestions.toString(),
+            difficulty,
+        };
+        if (prompt)
+            fields.prompt = prompt;
+        const result = await this.postCommand(this.buildForm('generate_flashcard_questions', this.withRag(fields, opts)), { label: 'generateFlashcardQuestions' });
+        const parsed = JSON.parse(result.flashcards);
+        if (Array.isArray(parsed))
+            return JSON.stringify(parsed);
+        return JSON.stringify(parsed.flashcards ?? []);
+    }
+    async generateWorksheetQuestions(sessionId, user, numQuestions, difficulty, options) {
+        await mockDelay();
+        if (isAiMockMode()) {
+            logger.info(`[ai] mock generateWorksheetQuestions session=${sessionId}`);
+            return JSON.stringify(mockWorksheet(numQuestions, difficulty, options));
+        }
+        const fields = {
+            session: sessionId,
+            user,
+            num_questions: numQuestions.toString(),
+            difficulty,
+            mode: options?.mode ?? 'practice',
+        };
+        if (options?.mcqRatio !== undefined) {
+            fields.mcq_ratio = String(options.mcqRatio);
+        }
+        if (options?.questionTypes?.length) {
+            fields.question_types = JSON.stringify(options.questionTypes);
+        }
+        if (options?.prompt) {
+            fields.worksheet_prompt = options.prompt;
+        }
+        const result = await this.postCommand(this.buildForm('generate_worksheet_questions', this.withRag(fields, { ragContext: options?.ragContext })), { label: 'generateWorksheetQuestions' });
+        return result.worksheet;
+    }
+    async checkWorksheetQuestions(sessionId, user, question, answer, markScheme) {
+        const result = await this.postCommand(this.buildForm('mark_worksheet_questions', {
+            session: sessionId,
+            user,
+            question,
+            answer,
+            mark_scheme: JSON.stringify(markScheme),
+        }), { label: 'checkWorksheetQuestions', retries: 2 });
+        return parseJsonField(result.marking, 'marking');
+    }
+    async generatePodcastStructure(sessionId, user, title, description, prompt, speakers) {
+        await mockDelay();
+        if (isAiMockMode()) {
+            logger.info(`[ai] mock generatePodcastStructure session=${sessionId}`);
+            return mockPodcastStructure(title, speakers);
+        }
+        try {
+            return await this.postCommand(this.buildForm('generate_podcast_structure', {
+                user,
+                session: sessionId,
+                title,
+                description,
+                prompt,
+                speakers: JSON.stringify(speakers),
+            }), { label: 'generatePodcastStructure' });
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to generate podcast structure: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    async generatePodcastAudioFromText(sessionId, user, podcastId, segmentIndex, text, speakers, voiceId) {
+        await mockDelay();
+        if (isAiMockMode()) {
+            logger.info(`[ai] mock generatePodcastAudio session=${sessionId}`);
+            return mockPodcastAudio(user, sessionId, podcastId, segmentIndex, text);
+        }
+        const fields = {
+            user,
+            session: sessionId,
+            podcast_id: podcastId,
+            segment_index: segmentIndex.toString(),
+            text,
+            speakers: JSON.stringify(speakers),
+        };
+        if (voiceId)
+            fields.voice_id = voiceId;
+        try {
+            return await this.postCommand(this.buildForm('generate_podcast_audio_from_text', fields), { label: 'generatePodcastAudioFromText' });
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to generate podcast audio: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    async generatePodcastImage(sessionId, user, summary) {
+        const result = await this.postCommand(this.buildForm('generate_podcast_image', {
+            session: sessionId,
+            user,
+            summary,
+        }), { label: 'generatePodcastImage' });
+        return result.image_key;
+    }
+    async segmentStudyGuide(sessionId, user, studyGuide) {
+        if (isAiMockMode()) {
+            return mockStudyGuideSegmentation();
+        }
+        const result = await this.postCommand(this.buildForm('generate_study_guide_segmentation', {
+            session: sessionId,
+            user,
+            study_guide: studyGuide,
+        }), { label: 'segmentStudyGuide' });
+        return result.segmentation;
+    }
+    async validateSegmentSummary(sessionId, user, segmentContent, studentResponse, studyGuide) {
+        if (isAiMockMode()) {
+            return mockSegmentSummaryValidation();
+        }
+        const result = await this.postCommand(this.buildForm('validate_segment_summary', {
+            session: sessionId,
+            user,
+            segment_content: segmentContent,
+            student_response: studentResponse,
+            study_guide: studyGuide,
+        }), { label: 'validateSegmentSummary' });
+        return result.feedback;
+    }
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    getSessionsByUserAndWorkspace(_userId, workspaceId) {
+        return Array.from(this.sessions.values()).filter((session) => session.workspaceId === workspaceId);
+    }
+    deleteSession(sessionId) {
+        return this.sessions.delete(sessionId);
+    }
+    async checkHealth() {
+        await mockDelay();
+        if (isAiMockMode()) {
+            logger.info('[ai] mock health check');
+            return true;
+        }
+        const uploadUrl = tryGetInferenceBackendUploadUrl();
+        if (!uploadUrl)
+            return false;
+        try {
+            const response = await fetch(uploadUrl, {
+                method: 'POST',
+                body: new FormData(),
+            });
+            return response.ok;
+        }
+        catch (error) {
+            logger.error('[ai] health check failed', error);
+            return false;
+        }
+    }
+}
+export const inferenceBackend = new InferenceBackendClient();
+if (aiConfig.inferenceBackend.url) {
+    logger.info(`[ai] inference backend: ${aiConfig.inferenceBackend.url}`);
+}
+if (isAiMockMode()) {
+    logger.info('[ai] mock mode enabled (DONT_TEST_INFERENCE=true)');
+}

package/dist/lib/ai/inference-backend/mocks.d.ts

@@ -0,0 +1,12 @@
+import type { ProcessFileResult, PodcastSpeaker, StudyGuideSegment, WorksheetGenerationOptions } from './types.js';
+export declare function mockStudyGuide(): string;
+export declare function mockFlashcards(numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): unknown[];
+export declare function mockWorksheet(numQuestions: number, difficulty: 'EASY' | 'MEDIUM' | 'HARD', options?: WorksheetGenerationOptions): object;
+export declare function mockProcessFile(fileType: 'image' | 'pdf'): ProcessFileResult;
+export declare function mockPodcastStructure(title: string, speakers: PodcastSpeaker[]): object;
+export declare function mockPodcastAudio(user: string, sessionId: string, podcastId: string, segmentIndex: number, text: string): object;
+export declare function mockStudyGuideSegmentation(): StudyGuideSegment[];
+export declare function mockSegmentSummaryValidation(): {
+    valid: boolean;
+    feedback: string;
+};