playable-lessons 0.2.2 → 0.6.2

package/out/shared/generate.js

@@ -8,10 +8,24 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractInk = extractInk;
+exports.extractJson = extractJson;
 exports.generateInk = generateInk;
+exports.collectSceneImagePrompts = collectSceneImagePrompts;
+exports.generateSceneImages = generateSceneImages;
+exports.generateFlashcards = generateFlashcards;
+exports.quizLetter = quizLetter;
+exports.generateQuiz = generateQuiz;
+exports.generateSummary = generateSummary;
+exports.generateAiTask = generateAiTask;
+exports.generateCaseStudy = generateCaseStudy;
+exports.generatePlan = generatePlan;
+exports.applyPlan = applyPlan;
+exports.refineText = refineText;
 const aiClient_js_1 = require("./aiClient.js");
 const prompts_js_1 = require("./prompts.js");
 const storyExport_js_1 = require("./storyExport.js");
+const inkParser_js_1 = require("./inkParser.js");
+const imageClient_js_1 = require("./imageClient.js");
 /** Pull Ink source out of an AI response — prefer a ```ink block, then any fence. */
 function extractInk(raw) {
     const inkBlock = raw.match(/```ink\s*([\s\S]*?)```/);
@@ -27,6 +41,37 @@ function extractInkCorrection(raw) {
     const m = raw.match(/```ink\s*([\s\S]*?)```/);
     return m ? m[1].trim() : null;
 }
+/**
+ * Pull a JSON object out of an AI response — prefer a ```json fence, then any
+ * fence, then the outermost {...} span. Throws if nothing parses.
+ */
+function extractJson(raw) {
+    const fence = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const candidate = (fence ? fence[1] : raw).trim();
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        // Fall through and try slicing the outermost object span.
+    }
+    const first = candidate.indexOf('{');
+    const last = candidate.lastIndexOf('}');
+    if (first !== -1 && last > first) {
+        return JSON.parse(candidate.slice(first, last + 1));
+    }
+    throw new Error('Could not parse JSON from the AI response');
+}
+/**
+ * Shared core of the single-call JSON generators (flashcards, quiz, summary):
+ * resolve the transport from `opts` (defaulting to callAI with `config`), invoke
+ * it, and parse the response as JSON. Returns the parsed data and the raw
+ * response — the raw is kept on each result for the `json` export + debugging.
+ */
+async function callForJson(messages, config, opts) {
+    const call = opts.call ?? ((m) => (0, aiClient_js_1.callAI)(m, config));
+    const raw = await call(messages);
+    return { data: extractJson(raw), raw };
+}
 async function generateInk(params, config, opts = {}) {
     const log = opts.log ?? (() => { });
     const call = opts.call ?? ((messages) => (0, aiClient_js_1.callAI)(messages, config));
@@ -36,14 +81,15 @@ async function generateInk(params, config, opts = {}) {
     const protagonist = params.protagonistType || 'the reader';
     const tone = params.tone || 'professional';
     const answers = params.answers || '(no specific preferences provided — use sensible defaults)';
-    const inkSystem = prompts_js_1.PROMPTS.system + '\n\n' + prompts_js_1.PROMPTS.inkSyntaxRef;
+    const sp = (0, prompts_js_1.storyPrompts)(params.branchingStyle);
+    const inkSystem = sp.system + '\n\n' + sp.inkSyntaxRef;
     // ─── Stage 1: Outline ───
     log('[1/4] Generating story outline…');
     const outlineRaw = await call([
-        { role: 'system', content: prompts_js_1.PROMPTS.system },
+        { role: 'system', content: sp.system },
         {
             role: 'user',
-            content: prompts_js_1.PROMPTS.outline
+            content: sp.outline
                 .replace('{{inputMode}}', mode)
                 .replace('{{inputText}}', params.inputText)
                 .replace('{{storyLength}}', length)
@@ -54,16 +100,14 @@ async function generateInk(params, config, opts = {}) {
     ]);
     // ─── Stage 2: Ink generation ───
     log('[2/4] Generating Ink source…');
+    const inkPrompt = sp.inkGeneration
+        .replace('{{outline}}', outlineRaw)
+        .replace('{{inputMode}}', mode)
+        .replace('{{inputText}}', params.inputText)
+        .replace('{{storyLength}}', length) + (params.sceneImages ? '\n' + prompts_js_1.PROMPTS.sceneImageInstruction : '');
     const inkRaw = await call([
         { role: 'system', content: inkSystem },
-        {
-            role: 'user',
-            content: prompts_js_1.PROMPTS.inkGeneration
-                .replace('{{outline}}', outlineRaw)
-                .replace('{{inputMode}}', mode)
-                .replace('{{inputText}}', params.inputText)
-                .replace('{{storyLength}}', length)
-        }
+        { role: 'user', content: inkPrompt }
     ]);
     let inkSource = extractInk(inkRaw);
     // ─── Stage 3: Review pass ───
@@ -110,3 +154,438 @@ async function generateInk(params, config, opts = {}) {
         }
     }
 }
+/** Extract every knot's scene-image prompt from Ink source. */
+function collectSceneImagePrompts(inkSource) {
+    const parsed = (0, inkParser_js_1.parseInkSource)(inkSource);
+    const requests = [];
+    for (const knot of parsed.knots) {
+        if (knot.imagePrompt)
+            requests.push({ knotId: knot.id, prompt: knot.imagePrompt });
+    }
+    return requests;
+}
+/**
+ * Resolve a story's `# IMAGE_PROMPT:` tags to generated images. Returns a map
+ * of the raw prompt (as written in the tag) → data URL, which the preview,
+ * project store, and HTML export use to render scenes. Identical prompts are
+ * generated once; a failed image is logged and skipped rather than failing the
+ * whole run (the story still plays, that scene just shows a placeholder).
+ */
+async function generateSceneImages(inkSource, config, opts = {}) {
+    const log = opts.log ?? (() => { });
+    const style = opts.style ?? 'cartoon';
+    const gen = opts.generate ?? ((styledPrompt) => (0, imageClient_js_1.generateImage)(styledPrompt, config));
+    const requests = collectSceneImagePrompts(inkSource);
+    let unique = [...new Map(requests.map((r) => [r.prompt, r])).values()];
+    if (opts.maxImages && opts.maxImages > 0 && unique.length > opts.maxImages) {
+        log(`Capping scene images at ${opts.maxImages} of ${unique.length} unique prompts.`);
+        unique = unique.slice(0, opts.maxImages);
+    }
+    const images = {};
+    let done = 0;
+    for (const req of unique) {
+        done++;
+        log(`Generating scene image ${done}/${unique.length} (${req.knotId})…`);
+        try {
+            images[req.prompt] = await gen((0, imageClient_js_1.buildSceneImagePrompt)(req.prompt, style));
+        }
+        catch (err) {
+            log(`Scene image failed for ${req.knotId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return images;
+}
+/**
+ * Coerce a parsed AI payload into a valid FlashcardResult. Drops any card that
+ * lacks a usable front/back (models occasionally emit malformed entries) and
+ * drops empty hint/tag strings so exporters can treat them as absent.
+ */
+function normalizeFlashcards(data, fallbackTitle) {
+    const obj = (data ?? {});
+    const deckTitle = typeof obj.deckTitle === 'string' && obj.deckTitle.trim() ? obj.deckTitle.trim() : fallbackTitle;
+    const rawCards = Array.isArray(obj.cards) ? obj.cards : [];
+    const cards = [];
+    for (const entry of rawCards) {
+        const c = entry;
+        const front = typeof c?.front === 'string' ? c.front.trim() : '';
+        const back = typeof c?.back === 'string' ? c.back.trim() : '';
+        if (!front || !back)
+            continue;
+        const hint = typeof c.hint === 'string' ? c.hint.trim() : '';
+        const tag = typeof c.tag === 'string' ? c.tag.trim() : '';
+        cards.push({ front, back, ...(hint ? { hint } : {}), ...(tag ? { tag } : {}) });
+    }
+    return { deckTitle, cards, raw: '' };
+}
+/**
+ * Generate a set of study flashcards from source material. A single AI call
+ * that must return strict JSON — no compile/review loop (unlike generateInk).
+ */
+async function generateFlashcards(params, config, opts = {}) {
+    const log = opts.log ?? (() => { });
+    const cardCount = params.cardCount && params.cardCount > 0 ? params.cardCount : 12;
+    const tone = params.tone || 'professional';
+    log('[1/1] Generating flashcards…');
+    const { data, raw } = await callForJson([
+        { role: 'system', content: prompts_js_1.PROMPTS.flashcardsSystem },
+        {
+            role: 'user',
+            content: prompts_js_1.PROMPTS.flashcards
+                .replace('{{inputMode}}', params.inputMode)
+                .replace('{{inputText}}', params.inputText)
+                .replace('{{cardCount}}', String(cardCount))
+                .replace('{{tone}}', tone)
+        }
+    ], config, opts);
+    const result = normalizeFlashcards(data, 'Flashcards');
+    result.raw = raw;
+    if (result.cards.length === 0) {
+        throw new Error('The model returned no usable flashcards');
+    }
+    log(`Generated ${result.cards.length} flashcard(s).`);
+    return result;
+}
+const QUIZ_LETTERS = 'ABCDEFGHIJ';
+/**
+ * Coerce a parsed AI payload into a valid QuizResult. Drops any question whose
+ * stem is empty, that has fewer than 2 usable options, or whose correctIndex is
+ * out of range. Empty explanations are dropped.
+ */
+function normalizeQuiz(data, fallbackTitle) {
+    const obj = (data ?? {});
+    const quizTitle = typeof obj.quizTitle === 'string' && obj.quizTitle.trim() ? obj.quizTitle.trim() : fallbackTitle;
+    const rawQs = Array.isArray(obj.questions) ? obj.questions : [];
+    const questions = [];
+    for (const entry of rawQs) {
+        const q = entry;
+        const stem = typeof q?.stem === 'string' ? q.stem.trim() : '';
+        if (!stem)
+            continue;
+        const options = Array.isArray(q.options)
+            ? q.options
+                .map((o) => (typeof o === 'string' ? o.trim() : ''))
+                .filter((s) => s.length > 0)
+            : [];
+        if (options.length < 2)
+            continue;
+        const idx = Number(q.correctIndex);
+        const correctIndex = Number.isInteger(idx) && idx >= 0 && idx < options.length ? idx : -1;
+        if (correctIndex < 0)
+            continue;
+        const explanation = typeof q.explanation === 'string' ? q.explanation.trim() : '';
+        questions.push({ stem, options, correctIndex, ...(explanation ? { explanation } : {}) });
+    }
+    return { quizTitle, questions, raw: '' };
+}
+/** 1-based letter (A, B, …) for an option index, used by exporters. */
+function quizLetter(index) {
+    return QUIZ_LETTERS[index] ?? String(index + 1);
+}
+/**
+ * Generate a multiple-choice quiz from source material. A single AI call that
+ * must return strict JSON — no compile/review loop (unlike generateInk).
+ */
+async function generateQuiz(params, config, opts = {}) {
+    const log = opts.log ?? (() => { });
+    const questionCount = params.questionCount && params.questionCount > 0 ? params.questionCount : 10;
+    const tone = params.tone || 'professional';
+    log('[1/1] Generating quiz…');
+    const { data, raw } = await callForJson([
+        { role: 'system', content: prompts_js_1.PROMPTS.quizSystem },
+        {
+            role: 'user',
+            content: prompts_js_1.PROMPTS.quiz
+                .replace('{{inputMode}}', params.inputMode)
+                .replace('{{inputText}}', params.inputText)
+                .replace('{{questionCount}}', String(questionCount))
+                .replace('{{tone}}', tone)
+        }
+    ], config, opts);
+    const result = normalizeQuiz(data, 'Quiz');
+    result.raw = raw;
+    if (result.questions.length === 0) {
+        throw new Error('The model returned no usable quiz questions');
+    }
+    log(`Generated ${result.questions.length} quiz question(s).`);
+    return result;
+}
+/**
+ * Coerce a parsed AI payload into a valid SummaryResult. Drops empty key points
+ * and glossary entries missing a term or definition.
+ */
+function normalizeSummary(data, fallbackTitle) {
+    const obj = (data ?? {});
+    const title = typeof obj.title === 'string' && obj.title.trim() ? obj.title.trim() : fallbackTitle;
+    const overview = typeof obj.overview === 'string' ? obj.overview.trim() : '';
+    const keyPoints = Array.isArray(obj.keyPoints)
+        ? obj.keyPoints
+            .map((p) => (typeof p === 'string' ? p.trim() : ''))
+            .filter((p) => p.length > 0)
+        : [];
+    const glossary = [];
+    const rawEntries = Array.isArray(obj.glossary) ? obj.glossary : [];
+    for (const entry of rawEntries) {
+        const g = entry;
+        const term = typeof g?.term === 'string' ? g.term.trim() : '';
+        const definition = typeof g?.definition === 'string' ? g.definition.trim() : '';
+        if (term && definition)
+            glossary.push({ term, definition });
+    }
+    return { title, overview, keyPoints, glossary, raw: '' };
+}
+/**
+ * Generate a study summary from source material. A single AI call that must
+ * return strict JSON — no compile/review loop (unlike generateInk).
+ */
+async function generateSummary(params, config, opts = {}) {
+    const log = opts.log ?? (() => { });
+    const keyPointCount = params.keyPointCount && params.keyPointCount > 0 ? params.keyPointCount : 8;
+    const tone = params.tone || 'professional';
+    log('[1/1] Generating study summary…');
+    const { data, raw } = await callForJson([
+        { role: 'system', content: prompts_js_1.PROMPTS.summarySystem },
+        {
+            role: 'user',
+            content: prompts_js_1.PROMPTS.summary
+                .replace('{{inputMode}}', params.inputMode)
+                .replace('{{inputText}}', params.inputText)
+                .replace('{{keyPointCount}}', String(keyPointCount))
+                .replace('{{tone}}', tone)
+        }
+    ], config, opts);
+    const result = normalizeSummary(data, 'Summary');
+    result.raw = raw;
+    if (!result.overview && result.keyPoints.length === 0) {
+        throw new Error('The model returned no usable summary content');
+    }
+    log(`Generated ${result.keyPoints.length} key point(s), ${result.glossary.length} glossary term(s).`);
+    return result;
+}
+/**
+ * Coerce a parsed AI payload into a valid AiTaskResult. Drops tasks missing a
+ * scenario/brief/deliverable/whyItWorks, and drops specifics/rubric items that
+ * lack both fields. Keeps only tasks that retain at least one load-bearing
+ * specific and one rubric criterion.
+ */
+function normalizeAiTask(data, fallbackTitle) {
+    const obj = (data ?? {});
+    const title = typeof obj.title === 'string' && obj.title.trim() ? obj.title.trim() : fallbackTitle;
+    const rawTasks = Array.isArray(obj.tasks) ? obj.tasks : [];
+    const tasks = [];
+    for (const entry of rawTasks) {
+        const t = entry;
+        const scenario = typeof t?.scenario === 'string' ? t.scenario.trim() : '';
+        const brief = typeof t?.brief === 'string' ? t.brief.trim() : '';
+        const deliverable = typeof t?.deliverable === 'string' ? t.deliverable.trim() : '';
+        const whyItWorks = typeof t?.whyItWorks === 'string' ? t.whyItWorks.trim() : '';
+        if (!scenario || !brief || !deliverable || !whyItWorks)
+            continue;
+        const specifics = [];
+        for (const s of Array.isArray(t.loadBearingSpecifics) ? t.loadBearingSpecifics : []) {
+            const sp = s;
+            const detail = typeof sp?.detail === 'string' ? sp.detail.trim() : '';
+            const why = typeof sp?.whyGenericAnswersMissIt === 'string' ? sp.whyGenericAnswersMissIt.trim() : '';
+            if (detail && why)
+                specifics.push({ detail, whyGenericAnswersMissIt: why });
+        }
+        const rubric = [];
+        for (const r of Array.isArray(t.rubric) ? t.rubric : []) {
+            const rr = r;
+            const criterion = typeof rr?.criterion === 'string' ? rr.criterion.trim() : '';
+            const description = typeof rr?.description === 'string' ? rr.description.trim() : '';
+            if (criterion && description)
+                rubric.push({ criterion, description });
+        }
+        if (specifics.length === 0 || rubric.length === 0)
+            continue;
+        tasks.push({ scenario, brief, deliverable, loadBearingSpecifics: specifics, rubric, whyItWorks });
+    }
+    return { title, tasks, raw: '' };
+}
+/**
+ * Generate AI-collaboration tasks from source material. A single AI call that
+ * must return strict JSON — no compile/review loop (unlike generateInk).
+ */
+async function generateAiTask(params, config, opts = {}) {
+    const log = opts.log ?? (() => { });
+    const taskCount = params.taskCount && params.taskCount > 0 ? params.taskCount : 3;
+    const tone = params.tone || 'professional';
+    log('[1/1] Generating AI-collaboration tasks…');
+    const { data, raw } = await callForJson([
+        { role: 'system', content: prompts_js_1.PROMPTS.aiTaskSystem },
+        {
+            role: 'user',
+            content: prompts_js_1.PROMPTS.aiTask
+                .replace('{{inputMode}}', params.inputMode)
+                .replace('{{inputText}}', params.inputText)
+                .replace('{{taskCount}}', String(taskCount))
+                .replace('{{tone}}', tone)
+        }
+    ], config, opts);
+    const result = normalizeAiTask(data, 'AI-Collaboration Tasks');
+    result.raw = raw;
+    if (result.tasks.length === 0) {
+        throw new Error('The model returned no usable AI-collaboration tasks');
+    }
+    log(`Generated ${result.tasks.length} AI-collaboration task(s).`);
+    return result;
+}
+/** Coerce a parsed payload into a valid CaseStudyResult (trims, drops empties). */
+function normalizeCaseStudy(data, fallbackTitle) {
+    const obj = (data ?? {});
+    const strArr = (v) => Array.isArray(v)
+        ? v
+            .map((x) => (typeof x === 'string' ? x.trim() : ''))
+            .filter((s) => s.length > 0)
+        : [];
+    const title = typeof obj.title === 'string' && obj.title.trim() ? obj.title.trim() : fallbackTitle;
+    const narrative = typeof obj.narrative === 'string' ? obj.narrative.trim() : '';
+    const caseStudy = {
+        title,
+        protagonist: typeof obj.protagonist === 'string' ? obj.protagonist.trim() : '',
+        situation: typeof obj.situation === 'string' ? obj.situation.trim() : '',
+        keyFacts: strArr(obj.keyFacts),
+        conflict: typeof obj.conflict === 'string' ? obj.conflict.trim() : '',
+        decisionPoints: strArr(obj.decisionPoints),
+        discussionQuestions: strArr(obj.discussionQuestions),
+        ...(narrative ? { narrative } : {})
+    };
+    return { title, caseStudy, raw: '' };
+}
+/**
+ * Generate a teaching case study from source material. A single AI call that
+ * must return strict JSON — no compile/review loop (unlike generateInk).
+ */
+async function generateCaseStudy(params, config, opts = {}) {
+    const log = opts.log ?? (() => { });
+    const depth = params.depth === 'idea' || params.depth === 'outline' ? params.depth : 'complete';
+    const tone = params.tone || 'professional';
+    log(`[1/1] Generating case study (${depth})…`);
+    const { data, raw } = await callForJson([
+        { role: 'system', content: prompts_js_1.PROMPTS.caseStudySystem },
+        {
+            role: 'user',
+            content: prompts_js_1.PROMPTS.caseStudy
+                .replace('{{inputMode}}', params.inputMode)
+                .replace('{{inputText}}', params.inputText)
+                .replace('{{depth}}', depth)
+                .replace('{{tone}}', tone)
+        }
+    ], config, opts);
+    const result = normalizeCaseStudy(data, 'Case Study');
+    result.raw = raw;
+    const cs = result.caseStudy;
+    if (!cs.situation && !cs.conflict && cs.keyFacts.length === 0) {
+        throw new Error('The model returned no usable case study content');
+    }
+    log('Generated case study.');
+    return result;
+}
+const PLAN_TARGETS = ['story', 'flashcards', 'quiz', 'summary', 'ai-task', 'case-study'];
+/** Coerce a parsed payload into a valid PlanResult (validates targets, drops junk). */
+function normalizePlan(data, fallbackTitle) {
+    const obj = (data ?? {});
+    const title = typeof obj.title === 'string' && obj.title.trim() ? obj.title.trim() : fallbackTitle;
+    const summary = typeof obj.summary === 'string' ? obj.summary.trim() : '';
+    const recommendations = [];
+    for (const r of Array.isArray(obj.recommendations) ? obj.recommendations : []) {
+        const rr = r;
+        const target = typeof rr?.target === 'string' ? rr.target.trim() : '';
+        if (!PLAN_TARGETS.includes(target))
+            continue;
+        const rationale = typeof rr.rationale === 'string' ? rr.rationale.trim() : '';
+        if (!rationale)
+            continue;
+        const rec = { target: target, rationale };
+        const depth = typeof rr.depth === 'string' ? rr.depth.trim() : '';
+        if (depth === 'idea' || depth === 'outline' || depth === 'complete')
+            rec.depth = depth;
+        const count = Number(rr.count);
+        if (Number.isInteger(count) && count > 0)
+            rec.count = count;
+        recommendations.push(rec);
+    }
+    return { title, summary, recommendations, raw: '' };
+}
+/**
+ * Recommend a set of outputs for the source material. A single AI call that
+ * must return strict JSON — no compile/review loop (unlike generateInk).
+ */
+async function generatePlan(params, config, opts = {}) {
+    const log = opts.log ?? (() => { });
+    const tone = params.tone || 'professional';
+    log('[1/1] Planning recommendations…');
+    const { data, raw } = await callForJson([
+        { role: 'system', content: prompts_js_1.PROMPTS.planSystem },
+        {
+            role: 'user',
+            content: prompts_js_1.PROMPTS.plan
+                .replace('{{inputMode}}', params.inputMode)
+                .replace('{{inputText}}', params.inputText)
+                .replace('{{tone}}', tone)
+        }
+    ], config, opts);
+    const result = normalizePlan(data, 'Plan');
+    result.raw = raw;
+    if (result.recommendations.length === 0) {
+        throw new Error('The model returned no usable recommendations');
+    }
+    log(`Planned ${result.recommendations.length} output(s).`);
+    return result;
+}
+/**
+ * Generate every recommended output, returning the assembled artifacts. Used by
+ * the CLI (`plan --apply`) and the GUI ("generate all → project"). Reuses the
+ * per-target generators via the shared transport in `opts`.
+ */
+async function applyPlan(plan, params, config, opts = {}) {
+    const log = opts.log ?? (() => { });
+    const { inputMode, inputText, tone, branchingStyle, sceneImages } = params;
+    const artifacts = {};
+    const recs = plan.recommendations;
+    recs.forEach((rec, i) => {
+        log(`[${i + 1}/${recs.length}] Generating ${rec.target}…`);
+    });
+    for (const rec of recs) {
+        switch (rec.target) {
+            case 'story':
+                artifacts.story = await generateInk({ inputMode, inputText, storyLength: 'medium', tone, branchingStyle, sceneImages }, config, opts);
+                break;
+            case 'flashcards':
+                artifacts.flashcards = await generateFlashcards({ inputMode, inputText, cardCount: rec.count, tone }, config, opts);
+                break;
+            case 'quiz':
+                artifacts.quiz = await generateQuiz({ inputMode, inputText, questionCount: rec.count, tone }, config, opts);
+                break;
+            case 'summary':
+                artifacts.summary = await generateSummary({ inputMode, inputText, keyPointCount: rec.count, tone }, config, opts);
+                break;
+            case 'ai-task':
+                artifacts.aiTask = await generateAiTask({ inputMode, inputText, taskCount: rec.count, tone }, config, opts);
+                break;
+            case 'case-study':
+                artifacts.caseStudy = await generateCaseStudy({ inputMode, inputText, depth: rec.depth, tone }, config, opts);
+                break;
+        }
+    }
+    return artifacts;
+}
+// ─── AI refinement (per-item) ────────────────────────────────────────────────
+/**
+ * Refine a single piece of text via the LLM. Returns the improved text (not
+ * JSON — just cleaned-up prose). Used by the inline "✨ Improve" buttons.
+ */
+async function refineText(text, instruction, config, opts = {}) {
+    const call = opts.call ?? ((messages) => (0, aiClient_js_1.callAI)(messages, config));
+    const result = await call([
+        {
+            role: 'system',
+            content: 'You improve educational content. Return ONLY the improved text — no preamble, no explanation, no markdown.'
+        },
+        {
+            role: 'user',
+            content: `${instruction}\n\nCurrent text:\n"""\n${text}\n"""\n\nReturn only the improved version.`
+        }
+    ]);
+    return result.trim();
+}