@goscribe/server 1.5.0 → 1.7.0

package/dist/src/services/billing/usage.service.js

@@ -0,0 +1,149 @@
+import { prisma } from '../../lib/prisma.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+const FALLBACK_PLAN_LIMITS = {
+    id: 'fallback-free',
+    planId: 'fallback-free',
+    maxStorageBytes: BigInt(1024 * 1024 * 1024), // 1GB
+    maxWorksheets: 3,
+    maxFlashcards: 20,
+    maxPodcasts: 0,
+    maxStudyGuides: 1,
+};
+const CACHE_TTL_MS = 30000;
+const usageCache = new Map();
+const limitsCache = new Map();
+const accountSummaryCache = new Map();
+function readCache(map, userId) {
+    const entry = map.get(userId);
+    if (!entry || entry.expiresAt <= Date.now()) {
+        map.delete(userId);
+        return null;
+    }
+    return entry.value;
+}
+function writeCache(map, userId, value) {
+    map.set(userId, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+/** Bust cached usage/limit reads after creates, deletes, or billing changes. */
+export function invalidateUserBillingCache(userId) {
+    usageCache.delete(userId);
+    limitsCache.delete(userId);
+    accountSummaryCache.delete(userId);
+}
+function workspaceAccessFilter(userId) {
+    return workspaceAccessWhere(userId);
+}
+/**
+ * Counts all resources consumed by a user across the platform.
+ */
+export async function getUserUsage(userId) {
+    const cached = readCache(usageCache, userId);
+    if (cached)
+        return cached;
+    const [flashcards, worksheets, studyGuides, podcasts, storageResult] = await Promise.all([
+        prisma.artifact.count({ where: { createdById: userId, type: 'FLASHCARD_SET' } }),
+        prisma.artifact.count({ where: { createdById: userId, type: 'WORKSHEET' } }),
+        prisma.artifact.count({ where: { createdById: userId, type: 'STUDY_GUIDE' } }),
+        prisma.artifact.count({ where: { createdById: userId, type: 'PODCAST_EPISODE' } }),
+        prisma.fileAsset.aggregate({
+            _sum: { size: true },
+            where: { userId },
+        }),
+    ]);
+    const usage = {
+        flashcards,
+        worksheets,
+        studyGuides,
+        podcasts,
+        storageBytes: Number(storageResult._sum.size || 0),
+    };
+    writeCache(usageCache, userId, usage);
+    return usage;
+}
+/**
+ * Retrieves the specific plan limits for a user based on their active subscription
+ * PLUS any extra credits purchased.
+ */
+export async function getUserPlanLimits(userId) {
+    const cached = readCache(limitsCache, userId);
+    if (cached)
+        return cached;
+    const [activeSub, freePlan, userCredits] = await Promise.all([
+        prisma.subscription.findFirst({
+            where: { userId, status: 'active' },
+            include: { plan: { include: { limit: true } } },
+            orderBy: { createdAt: 'desc' },
+        }),
+        prisma.plan.findFirst({
+            where: {
+                active: true,
+                price: 0,
+                limit: { isNot: null },
+            },
+            include: { limit: true },
+            orderBy: { createdAt: 'asc' },
+        }),
+        prisma.userCredit.groupBy({
+            by: ['resourceType'],
+            where: { userId },
+            _sum: { amount: true },
+        }),
+    ]);
+    const baseLimit = activeSub?.plan?.limit ?? freePlan?.limit;
+    const base = baseLimit ?? FALLBACK_PLAN_LIMITS;
+    const getCreditSum = (type) => userCredits.find((c) => c.resourceType === type)?._sum.amount || 0;
+    const limits = {
+        id: base.id,
+        planId: base.planId,
+        maxStorageBytes: BigInt(Number(base.maxStorageBytes) + getCreditSum('STORAGE') * 1024 * 1024),
+        maxWorksheets: base.maxWorksheets + getCreditSum('WORKSHEET'),
+        maxFlashcards: base.maxFlashcards + getCreditSum('FLASHCARD_SET'),
+        maxPodcasts: base.maxPodcasts + getCreditSum('PODCAST_EPISODE'),
+        maxStudyGuides: base.maxStudyGuides + getCreditSum('STUDY_GUIDE'),
+        createdAt: baseLimit?.createdAt || new Date(),
+        updatedAt: baseLimit?.updatedAt || new Date(),
+        isFallbackPlan: !baseLimit,
+    };
+    writeCache(limitsCache, userId, limits);
+    return limits;
+}
+/**
+ * Sidebar/dashboard summary: stats + usage + limits in one parallel DB round-trip batch.
+ */
+export async function getAccountSummary(userId) {
+    const cached = readCache(accountSummaryCache, userId);
+    if (cached)
+        return cached;
+    const workspaceWhere = workspaceAccessFilter(userId);
+    const [workspaceMeta, folderCount, usage, limits, storageUsed] = await Promise.all([
+        prisma.workspace.aggregate({
+            where: workspaceWhere,
+            _count: { _all: true },
+            _max: { updatedAt: true },
+        }),
+        prisma.folder.count({ where: { ownerId: userId } }),
+        getUserUsage(userId),
+        getUserPlanLimits(userId),
+        prisma.fileAsset.aggregate({
+            where: {
+                userId,
+                workspace: workspaceWhere,
+            },
+            _sum: { size: true },
+        }),
+    ]);
+    const summary = {
+        stats: {
+            workspaces: workspaceMeta._count._all,
+            folders: folderCount,
+            lastUpdated: workspaceMeta._max.updatedAt,
+            spaceUsed: Number(storageUsed._sum.size ?? 0),
+            spaceTotal: Number(limits.maxStorageBytes),
+        },
+        usage,
+        limits,
+        hasActivePlan: !limits.isFallbackPlan,
+    };
+    writeCache(accountSummaryCache, userId, summary);
+    return summary;
+}

package/dist/src/services/content/copilot.service.d.ts

@@ -0,0 +1,113 @@
+import type { PrismaClient } from '@prisma/client';
+import { z } from 'zod';
+import { BaseService } from '../base.service.js';
+export declare const copilotArtifactType: z.ZodEnum<{
+    flashcards: "flashcards";
+    worksheet: "worksheet";
+    "study-guide": "study-guide";
+}>;
+export declare const copilotContextSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    artifactId: z.ZodString;
+    artifactType: z.ZodEnum<{
+        flashcards: "flashcards";
+        worksheet: "worksheet";
+        "study-guide": "study-guide";
+    }>;
+    documentContent: z.ZodString;
+    documentPlainText: z.ZodOptional<z.ZodString>;
+    selectedText: z.ZodOptional<z.ZodString>;
+    viewportText: z.ZodOptional<z.ZodString>;
+    cursorPosition: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        flashcardId: z.ZodOptional<z.ZodString>;
+        questionId: z.ZodOptional<z.ZodString>;
+        documentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CopilotContextInput = z.infer<typeof copilotContextSchema>;
+export declare class CopilotService extends BaseService {
+    constructor(db: PrismaClient);
+    private assertWorkspaceAccess;
+    private assertConversationAccess;
+    private loadHistory;
+    private persistConversationExchange;
+    listConversations(userId: string, workspaceId: string): Promise<{
+        id: string;
+        title: string;
+        updatedAt: Date;
+        preview: string;
+    }[]>;
+    getConversation(userId: string, workspaceId: string, conversationId: string): Promise<{
+        id: string;
+        title: string;
+        messages: {
+            id: string;
+            role: string;
+            content: string;
+            createdAt: Date;
+        }[];
+    }>;
+    createConversation(userId: string, input: {
+        workspaceId: string;
+        title?: string;
+    }): Promise<{
+        id: string;
+        title: string;
+        updatedAt: Date;
+    }>;
+    deleteConversation(userId: string, workspaceId: string, conversationId: string): Promise<{
+        success: boolean;
+    }>;
+    ask(userId: string, input: {
+        context: CopilotContextInput;
+        message: string;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+        highlights: {
+            text: string;
+            label?: string;
+        }[];
+    }>;
+    explainSelection(userId: string, input: {
+        context: CopilotContextInput;
+        message?: string;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+    }>;
+    suggestHighlights(userId: string, input: {
+        context: CopilotContextInput;
+        message?: string;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+        highlights: {
+            text: string;
+            label?: string;
+        }[];
+    }>;
+    generateFlashcards(userId: string, input: {
+        context: CopilotContextInput;
+        message?: string;
+        numCards: number;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+        artifactId: string;
+        flashcards: {
+            id: string;
+            createdAt: Date;
+            tags: string[];
+            artifactId: string;
+            order: number;
+            front: string;
+            back: string;
+            acceptedAnswers: string[];
+        }[];
+    }>;
+}

package/dist/src/services/content/copilot.service.js

@@ -0,0 +1,439 @@
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+import { BaseService } from '../base.service.js';
+import { ai } from '../../lib/ai/index.js';
+import { workspaceKbService } from '../workspace/workspace-kb.service.js';
+import { sanitizeString } from '../../lib/validation.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+import PusherService from '../../lib/pusher.js';
+import { FlashcardService } from './flashcard.service.js';
+export const copilotArtifactType = z.enum([
+    'study-guide',
+    'worksheet',
+    'flashcards',
+]);
+export const copilotContextSchema = z.object({
+    workspaceId: z.string().min(1),
+    artifactId: z.string().min(1),
+    artifactType: copilotArtifactType,
+    documentContent: z.string().min(1),
+    documentPlainText: z.string().optional(),
+    selectedText: z.string().optional(),
+    viewportText: z.string().optional(),
+    cursorPosition: z
+        .object({
+        start: z.number().int().min(0),
+        end: z.number().int().min(0),
+    })
+        .optional(),
+    metadata: z
+        .object({
+        flashcardId: z.string().optional(),
+        questionId: z.string().optional(),
+        documentId: z.string().optional(),
+    })
+        .optional(),
+});
+const highlightInstructionSchema = z.object({
+    text: z.string().min(1),
+    label: z.string().optional(),
+});
+const flashcardSchema = z.object({
+    front: z.string().min(1),
+    back: z.string().min(1),
+});
+const RATE_LIMIT_WINDOW_MS = 60000;
+const RATE_LIMIT_MAX_REQUESTS = 20;
+const requestBuckets = new Map();
+function enforceRateLimit(userId, workspaceId) {
+    const now = Date.now();
+    const key = `${userId}:${workspaceId}`;
+    const existing = requestBuckets.get(key) ?? [];
+    const recent = existing.filter((timestamp) => now - timestamp < RATE_LIMIT_WINDOW_MS);
+    if (recent.length >= RATE_LIMIT_MAX_REQUESTS) {
+        throw new TRPCError({
+            code: 'TOO_MANY_REQUESTS',
+            message: 'Too many copilot requests. Please wait a moment.',
+        });
+    }
+    recent.push(now);
+    requestBuckets.set(key, recent);
+}
+function contextWindow(context) {
+    return sanitizeString(context.documentContent, 5000000);
+}
+function extractJson(content) {
+    return ai.parse.extractJson(content);
+}
+function getAnswerFromParsedJSON(parsed) {
+    if (!parsed)
+        return null;
+    const potentialKeys = [
+        'answer',
+        'summary',
+        'explanation',
+        'content',
+        'explanationText',
+        'response',
+        'result',
+    ];
+    for (const key of potentialKeys) {
+        if (typeof parsed[key] === 'string' && parsed[key].length > 0) {
+            return parsed[key];
+        }
+    }
+    return null;
+}
+function normalizeHighlightInstructions(raw, anchorDocument) {
+    const parsed = z.array(highlightInstructionSchema).safeParse(raw);
+    if (!parsed.success)
+        return [];
+    const seen = new Set();
+    const results = [];
+    for (const item of parsed.data) {
+        const text = sanitizeString(item.text, 800).trim();
+        if (text.length < 2)
+            continue;
+        if (!anchorDocument.includes(text))
+            continue;
+        const key = text.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        results.push({
+            text,
+            label: item.label ? sanitizeString(item.label, 120) : undefined,
+        });
+    }
+    return results;
+}
+async function callCopilotModel(params) {
+    const documentSnippet = contextWindow(params.context);
+    const selectedText = params.context.selectedText
+        ? sanitizeString(params.context.selectedText, 2000)
+        : '';
+    const viewportText = params.context.viewportText
+        ? sanitizeString(params.context.viewportText, 4000)
+        : '';
+    const message = sanitizeString(params.message, 4000);
+    const ragContext = await workspaceKbService.retrieveContext(params.context.workspaceId, message, 6);
+    const systemPrompt = [
+        'You are an AI study assistant for the Scribe learning platform.',
+        'Be concise, correct, and safe. Do not claim edits were applied unless asked and confirmed by the user.',
+        'Return valid JSON only.',
+        '',
+        'OUTPUT FORMAT:',
+        '{',
+        '  "answer": "markdown response for the user",',
+        '  "highlights": [{ "text": "exact quote from PLAIN_DOCUMENT", "label": "optional" }],',
+        '  "flashcards": [{ "front": "question", "back": "answer" }]',
+        '}',
+        'Include only relevant keys for the task.',
+        'For highlights: each "text" must be copied verbatim from PLAIN_DOCUMENT. Prefer unique phrases of about 3–40 words, not isolated common words. Do not use numeric start/end offsets.',
+        '',
+        `MODE: ${params.mode}`,
+        `ARTIFACT_TYPE: ${params.context.artifactType}`,
+    ].join('\n');
+    const plainSnippet = params.context.documentPlainText
+        ? sanitizeString(params.context.documentPlainText, 12000)
+        : '';
+    const contextPrompt = [
+        'DOCUMENT:',
+        documentSnippet,
+        '',
+        'PLAIN_DOCUMENT:',
+        plainSnippet || documentSnippet.slice(0, 12000),
+        '',
+        'WORKSPACE_KNOWLEDGE:',
+        ragContext || 'None',
+        '',
+        'SELECTION:',
+        selectedText || 'None',
+        '',
+        'VIEWPORT_TEXT:',
+        viewportText || 'None',
+    ].join('\n');
+    const messages = [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: contextPrompt },
+    ];
+    if (params.history && params.history.length > 0) {
+        params.history.forEach((msg) => {
+            messages.push({
+                role: msg.role === 'user' ? 'user' : 'assistant',
+                content: msg.content,
+            });
+        });
+    }
+    messages.push({ role: 'user', content: message });
+    const response = await ai.llm.complete(messages);
+    const content = response.choices?.[0]?.message?.content ?? '';
+    const parsed = extractJson(content);
+    return { rawContent: content, parsed };
+}
+export class CopilotService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async assertWorkspaceAccess(userId, workspaceId) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: workspaceId, ...workspaceAccessWhere(userId) },
+            select: { id: true },
+        });
+        if (!workspace) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'You do not have access to this workspace',
+            });
+        }
+    }
+    async assertConversationAccess(userId, workspaceId, conversationId) {
+        const conversation = await this.db.copilotConversation.findFirst({
+            where: { id: conversationId, workspaceId, userId },
+            select: { id: true },
+        });
+        if (!conversation) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Conversation not found' });
+        }
+    }
+    async loadHistory(conversationId) {
+        if (!conversationId)
+            return [];
+        const messages = await this.db.copilotMessage.findMany({
+            where: { conversationId },
+            orderBy: { createdAt: 'asc' },
+            take: 50,
+        });
+        return messages.map((m) => ({
+            role: m.role.toLowerCase(),
+            content: m.content,
+        }));
+    }
+    async persistConversationExchange(params) {
+        if (!params.conversationId)
+            return;
+        await this.assertConversationAccess(params.userId, params.workspaceId, params.conversationId);
+        const generatedTitle = sanitizeString(params.userMessage.replace(/\s+/g, ' ').trim(), 80);
+        const conversation = await this.db.copilotConversation.findUnique({
+            where: { id: params.conversationId },
+            select: { title: true },
+        });
+        const shouldUpdateTitle = !!conversation &&
+            conversation.title.trim().toLowerCase() === 'new chat' &&
+            generatedTitle.length > 0;
+        await this.db.copilotMessage.createMany({
+            data: [
+                {
+                    conversationId: params.conversationId,
+                    role: 'USER',
+                    content: sanitizeString(params.userMessage, 8000),
+                },
+                {
+                    conversationId: params.conversationId,
+                    role: 'ASSISTANT',
+                    content: sanitizeString(params.assistantMessage, 20000),
+                },
+            ],
+        });
+        await this.db.copilotConversation.update({
+            where: { id: params.conversationId },
+            data: {
+                updatedAt: new Date(),
+                ...(shouldUpdateTitle ? { title: generatedTitle } : {}),
+            },
+        });
+    }
+    async listConversations(userId, workspaceId) {
+        await this.assertWorkspaceAccess(userId, workspaceId);
+        const conversations = await this.db.copilotConversation.findMany({
+            where: { workspaceId, userId },
+            include: {
+                messages: { orderBy: { createdAt: 'desc' }, take: 1 },
+            },
+            orderBy: { updatedAt: 'desc' },
+        });
+        return conversations.map((conversation) => ({
+            id: conversation.id,
+            title: conversation.title,
+            updatedAt: conversation.updatedAt,
+            preview: conversation.messages[0]?.content ?? '',
+        }));
+    }
+    async getConversation(userId, workspaceId, conversationId) {
+        await this.assertWorkspaceAccess(userId, workspaceId);
+        await this.assertConversationAccess(userId, workspaceId, conversationId);
+        const conversation = await this.db.copilotConversation.findUnique({
+            where: { id: conversationId },
+            include: { messages: { orderBy: { createdAt: 'asc' } } },
+        });
+        if (!conversation) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Conversation not found' });
+        }
+        return {
+            id: conversation.id,
+            title: conversation.title,
+            messages: conversation.messages.map((message) => ({
+                id: message.id,
+                role: message.role === 'USER' ? 'user' : 'assistant',
+                content: message.content,
+                createdAt: message.createdAt,
+            })),
+        };
+    }
+    async createConversation(userId, input) {
+        await this.assertWorkspaceAccess(userId, input.workspaceId);
+        const conversation = await this.db.copilotConversation.create({
+            data: {
+                workspaceId: input.workspaceId,
+                userId,
+                title: sanitizeString(input.title || 'New Chat', 120),
+            },
+        });
+        return {
+            id: conversation.id,
+            title: conversation.title,
+            updatedAt: conversation.updatedAt,
+        };
+    }
+    async deleteConversation(userId, workspaceId, conversationId) {
+        await this.assertWorkspaceAccess(userId, workspaceId);
+        await this.assertConversationAccess(userId, workspaceId, conversationId);
+        await this.db.copilotConversation.delete({ where: { id: conversationId } });
+        return { success: true };
+    }
+    async ask(userId, input) {
+        enforceRateLimit(userId, input.context.workspaceId);
+        await this.assertWorkspaceAccess(userId, input.context.workspaceId);
+        const history = await this.loadHistory(input.conversationId);
+        const model = await callCopilotModel({
+            mode: 'ask',
+            context: input.context,
+            message: input.message,
+            history,
+        });
+        const answer = getAnswerFromParsedJSON(model.parsed) ||
+            model.rawContent ||
+            'I could not generate a response.';
+        const safeHighlights = normalizeHighlightInstructions(model.parsed?.highlights, input.context.documentPlainText ?? input.context.documentContent);
+        await this.persistConversationExchange({
+            userId,
+            workspaceId: input.context.workspaceId,
+            conversationId: input.conversationId,
+            userMessage: input.message,
+            assistantMessage: answer,
+        });
+        return { answer, highlights: safeHighlights };
+    }
+    async explainSelection(userId, input) {
+        enforceRateLimit(userId, input.context.workspaceId);
+        await this.assertWorkspaceAccess(userId, input.context.workspaceId);
+        const question = input.message && input.message.trim().length > 0
+            ? input.message
+            : 'Explain the selected text in simple study-friendly terms and include one practical example.';
+        const history = await this.loadHistory(input.conversationId);
+        const model = await callCopilotModel({
+            mode: 'explainSelection',
+            context: input.context,
+            message: question,
+            history,
+        });
+        const answer = getAnswerFromParsedJSON(model.parsed) ||
+            model.rawContent ||
+            'I could not explain this selection.';
+        await this.persistConversationExchange({
+            userId,
+            workspaceId: input.context.workspaceId,
+            conversationId: input.conversationId,
+            userMessage: question,
+            assistantMessage: answer,
+        });
+        return { answer };
+    }
+    async suggestHighlights(userId, input) {
+        enforceRateLimit(userId, input.context.workspaceId);
+        await this.assertWorkspaceAccess(userId, input.context.workspaceId);
+        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:thinking', {
+            status: 'started',
+        });
+        const instruction = input.message && input.message.trim().length > 0
+            ? input.message
+            : 'Suggest key highlights. Return exact phrases copied from PLAIN_DOCUMENT (about 3–40 words each).';
+        const history = await this.loadHistory(input.conversationId);
+        const model = await callCopilotModel({
+            mode: 'suggestHighlights',
+            context: input.context,
+            message: instruction,
+            history,
+        });
+        const safeHighlights = normalizeHighlightInstructions(model.parsed?.highlights, input.context.documentPlainText ?? input.context.documentContent);
+        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:highlight_suggestions', { highlights: safeHighlights });
+        const answer = getAnswerFromParsedJSON(model.parsed) || 'Here are suggested highlights.';
+        await this.persistConversationExchange({
+            userId,
+            workspaceId: input.context.workspaceId,
+            conversationId: input.conversationId,
+            userMessage: instruction,
+            assistantMessage: answer,
+        });
+        return { answer, highlights: safeHighlights };
+    }
+    async generateFlashcards(userId, input) {
+        enforceRateLimit(userId, input.context.workspaceId);
+        await this.assertWorkspaceAccess(userId, input.context.workspaceId);
+        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:thinking', {
+            status: 'started',
+        });
+        const instruction = input.message && input.message.trim().length > 0
+            ? input.message
+            : `Generate ${input.numCards} concise study flashcards from this context.`;
+        const history = await this.loadHistory(input.conversationId);
+        const model = await callCopilotModel({
+            mode: 'generateFlashcards',
+            context: input.context,
+            message: instruction,
+            history,
+        });
+        const parsedFlashcards = z.array(flashcardSchema).safeParse(model.parsed?.flashcards);
+        const cards = (parsedFlashcards.success ? parsedFlashcards.data : []).slice(0, input.numCards);
+        if (cards.length === 0) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'Copilot did not return valid flashcards.',
+            });
+        }
+        const flashcardService = new FlashcardService(this.db);
+        const primarySet = await flashcardService.ensurePrimarySet(userId, input.context.workspaceId);
+        const orderOffset = primarySet.flashcards.reduce((max, card) => Math.max(max, card.order), -1);
+        await this.db.flashcard.createMany({
+            data: cards.map((card, index) => ({
+                artifactId: primarySet.id,
+                front: sanitizeString(card.front, 200),
+                back: sanitizeString(card.back, 500),
+                order: orderOffset + 1 + index,
+                tags: ['copilot-generated'],
+            })),
+        });
+        const artifact = await this.db.artifact.findUniqueOrThrow({
+            where: { id: primarySet.id },
+            include: { flashcards: true },
+        });
+        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:response', {
+            status: 'completed',
+            flashcardSetId: artifact.id,
+        });
+        const answer = getAnswerFromParsedJSON(model.parsed) ||
+            `Generated ${artifact.flashcards.length} flashcards.`;
+        await this.persistConversationExchange({
+            userId,
+            workspaceId: input.context.workspaceId,
+            conversationId: input.conversationId,
+            userMessage: instruction,
+            assistantMessage: answer,
+        });
+        return {
+            answer,
+            artifactId: artifact.id,
+            flashcards: artifact.flashcards,
+        };
+    }
+}