@rtsee/messenger-signaling 0.0.122 → 0.0.124

package/dist/messenger-signaling/src/models/ozzy/tasks/StoryRepairTask.js

@@ -0,0 +1,673 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoryRepairTask = void 0;
+exports.getStoryRepairTask = getStoryRepairTask;
+const common_1 = require("@rtsee/common");
+const Task_js_1 = require("./Task.js");
+const MAX_SLIDES_PER_STORY = 500;
+const DEFAULT_IMAGE_URL = 'https://rtsee-files-vault-public.s3.us-east-1.amazonaws.com/default/default-story-pic.png';
+function buildRepairSystemPrompt(options) {
+    const sections = [
+        `You are an expert story editor for the RTSee presentation player.`,
+        `Your task is to inspect an existing story, its sequenced slides, and its existing story elements (characters, locations, artifacts), and repair/enrich them strictly according to the enabled repair options below.`,
+        `The output descriptions you provide must be SEO friendly.`,
+    ];
+    if (options.grammarAndFlow) {
+        sections.push(`
+1. GRAMMAR, READABILITY & FLOW REPAIR (ENABLED):
+- The story text may have been copied from old book scans or rough drafts and might contain typos, grammar mistakes, awkward phrasing, or punctuation errors. Fix all of these and improve readability and narrative flow across:
+  * "story": "description" (1-2 sentence SEO-friendly teaser), "history" (5-6 sentences on the origins/history of the story), and "moralMeaning" (5-6 sentences on what can be learned from the story). If "history" or "moralMeaning" are missing or empty, write them.
+  * "slides": fix grammar, punctuation, typos, and improve flow of each slide's "text" and "illustrationDescription".
+  * "updatedLocations", "updatedCharacters", "updatedArtifacts": if any existing elements have typos, weak descriptions, or missing/weak "visualDescription" prompts, include their updated entries (keeping their exact existing "id") in these arrays.
+- CRITICAL ZERO-LOSS TEXT INVARIANT:
+  * You must keep slide "text" very close to the original story text.
+  * DO NOT summarize, shorten, or condense any slide text.
+  * Do NOT drop, merge, or reorder slides — keep the exact same slide "id" values.
+  * Use line-by-line dialogue style. Every time the active speaker shifts, start a fresh paragraph.
+- CRITICAL SLIDE ILLUSTRATION PROMPT ("illustrationDescription"):
+  * Ensure EVERY slide has a vivid, detailed, self-contained "illustrationDescription" field used directly as the generative prompt for our image generator (NanoBanana) to produce the fairy tale illustration for that slide:
+    - Specify what is visually happening in the foreground, midground, and background.
+    - Explicitly mention which characters are present, their actions, facial expressions, poses, clothing, and interactions.
+    - Include the environment/setting (lighting, atmospheric mood, weather, scenery matching the slide's location).
+    - Include any prominent artifacts held, used, or visible in the scene.
+    - Use painterly, cinematic visual descriptors suited for enchanted storybook illustrations.
+    - Do NOT write meta text such as "In this slide" or "This image illustrates". Write directly as an image prompt.`);
+    }
+    else {
+        sections.push(`
+1. GRAMMAR, READABILITY & FLOW REPAIR (DISABLED):
+- Do NOT alter the existing story or slide texts. Omit "story", "updatedLocations", "updatedCharacters", and "updatedArtifacts", and keep slide "text" and "illustrationDescription" unchanged.`);
+    }
+    const enabledEntities = [];
+    if (options.locations) {
+        enabledEntities.push(`- LOCATIONS (ENABLED): Check "existingLocations" against the story and slides. Identify any important places where episodes of the story take place that are MISSING from "existingLocations". Return only genuinely missing important locations in "newLocations" (each with "id" like "new-loc-1", "name": 2-3 words, "description": 1-2 sentences on its story significance, "visualDescription": detailed visual prompt for NanoBanana image generation). If all important locations are already present in "existingLocations", return [] for "newLocations". Link both existing location IDs and new location IDs ("new-loc-1") to each slide's "location" field.`);
+    }
+    else {
+        enabledEntities.push(`- LOCATIONS (DISABLED): Return [] for "newLocations" and keep each slide's existing "location" unchanged.`);
+    }
+    if (options.characters) {
+        enabledEntities.push(`- CHARACTERS (ENABLED): Check "existingCharacters" against the story and slides. Identify any important heroes, villains, or supporting characters in the story that are MISSING from "existingCharacters". Return only genuinely missing important characters in "newCharacters" (each with "id" like "new-char-1", "name", "description": 1-2 sentences, "visualDescription": detailed visual appearance for NanoBanana image generation). If all important characters are already present in "existingCharacters", return [] for "newCharacters". Link both existing character IDs and new character IDs ("new-char-1") to each slide's "characters" array.`);
+    }
+    else {
+        enabledEntities.push(`- CHARACTERS (DISABLED): Return [] for "newCharacters" and keep each slide's existing "characters" array unchanged.`);
+    }
+    if (options.artifacts) {
+        enabledEntities.push(`- ARTIFACTS (ENABLED): Check "existingArtifacts" against the story and slides. Identify any meaningful or memorable objects from the story that are MISSING from "existingArtifacts". Return only genuinely missing important artifacts in "newArtifacts" (each with "id" like "new-art-1", "name", "description": 1-2 sentences, "visualDescription": detailed visual appearance for NanoBanana image generation). If all important artifacts are already present in "existingArtifacts", return [] for "newArtifacts". Link both existing artifact IDs and new artifact IDs ("new-art-1") to each slide's "artifacts" array.`);
+    }
+    else {
+        enabledEntities.push(`- ARTIFACTS (DISABLED): Return [] for "newArtifacts" and keep each slide's existing "artifacts" array unchanged.`);
+    }
+    sections.push(`\n2. ENTITY DISCOVERY & LINKING RULES:\n${enabledEntities.join('\n')}`);
+    sections.push(`
+Respond with ONLY a valid JSON object, no markdown fences, no comments, using this exact shape:
+{
+  "story": {
+    "description": string,
+    "history": string,
+    "moralMeaning": string
+  },
+  "newLocations": [{"id": string, "name": string, "description": string, "visualDescription": string}],
+  "newCharacters": [{"id": string, "name": string, "description": string, "visualDescription": string}],
+  "newArtifacts": [{"id": string, "name": string, "description": string, "visualDescription": string}],
+  "updatedLocations": [{"id": string, "name": string, "description": string, "visualDescription": string}],
+  "updatedCharacters": [{"id": string, "name": string, "description": string, "visualDescription": string}],
+  "updatedArtifacts": [{"id": string, "name": string, "description": string, "visualDescription": string}],
+  "slides": [
+    {
+      "id": string,
+      "text": string,
+      "illustrationDescription": string,
+      "location": string | null,
+      "characters": [string],
+      "artifacts": [string]
+    }
+  ]
+}`);
+    return sections.join('\n');
+}
+/**
+ * Repairs an existing story: fixes grammar/flow of story, slides, and entities,
+ * and/or identifies and creates missing important characters, locations, and artifacts
+ * and links them to slides.
+ */
+class StoryRepairTask extends Task_js_1.OzzyTask {
+    presentation;
+    constructor(options, presentation) {
+        super(options);
+        this.presentation = presentation;
+    }
+    async execute() {
+        const repairOptions = this.validateInput();
+        const needsLlmRepair = repairOptions.grammarAndFlow ||
+            repairOptions.characters ||
+            repairOptions.artifacts ||
+            repairOptions.locations;
+        const agent = needsLlmRepair ? await this.resolveAgent() : null;
+        this.log(`Loading story "${this.input.storyName || this.input.storyId}"...`);
+        const story = await this.presentation.getStory(this.transport, {
+            storyId: this.input.storyId,
+        });
+        if (!story) {
+            throw new Error(`Story ${this.input.storyId} not found.`);
+        }
+        this.log('Loading slides and existing story elements...');
+        const [slides, charRes, locRes, artRes] = await Promise.all([
+            this.loadSlides(story.id),
+            this.presentation
+                .getCharacters(this.transport, { storyId: story.id, limit: 100 })
+                .catch(() => ({
+                characters: [],
+                total: 0,
+            })),
+            this.presentation
+                .getLocations(this.transport, { storyId: story.id, limit: 100 })
+                .catch(() => ({
+                locations: [],
+                total: 0,
+            })),
+            this.presentation
+                .getArtifacts(this.transport, { storyId: story.id, limit: 100 })
+                .catch(() => ({
+                artifacts: [],
+                total: 0,
+            })),
+        ]);
+        const existingCharacters = charRes?.characters || [];
+        const existingLocations = locRes?.locations || [];
+        const existingArtifacts = artRes?.artifacts || [];
+        this.log(`Loaded ${slides.length} slide(s), ${existingCharacters.length} character(s), ` +
+            `${existingLocations.length} location(s), ${existingArtifacts.length} artifact(s).`);
+        let addedLocationsIds = [];
+        let addedCharactersIds = [];
+        let addedArtifactsIds = [];
+        let updatedSlidesCount = 0;
+        let updatedStoryDescription = story.description;
+        if (needsLlmRepair && agent) {
+            const model = agent.agentConfiguration.model?.model;
+            const activeFlags = [
+                repairOptions.grammarAndFlow ? 'Grammar & Flow' : '',
+                repairOptions.characters ? 'Characters' : '',
+                repairOptions.artifacts ? 'Artifacts' : '',
+                repairOptions.locations ? 'Locations' : '',
+            ].filter(Boolean);
+            this.log(`Asking ${agent.name || agent.agentConfiguration.name} (${model || 'default model'}) ` +
+                `to repair story (${activeFlags.join(', ')})...`);
+            const prompt = this.buildPrompt(story, slides, existingLocations, existingCharacters, existingArtifacts, repairOptions);
+            const { text, cost } = await this.context.ozzy.complete({
+                prompt,
+                systemPrompt: `${agent.agentConfiguration.systemPrompt || ''}\n${buildRepairSystemPrompt(repairOptions)}`,
+                transport: this.transport,
+                model,
+                agentId: agent.id,
+                maxTokens: 24000,
+                onChunk: (chunk) => this.log(chunk, 'chunk'),
+            });
+            if (cost) {
+                const fmt = (n) => (n || 0).toLocaleString('en-US');
+                this.log(`Token usage: ${fmt(cost.inputTokens)} in / ${fmt(cost.outputTokens)} out / ${fmt(cost.totalTokens)} total`, 'info', cost);
+            }
+            this.log('Response received, parsing repair instructions...');
+            const draft = this.parseRepairDraft(text);
+            // Pre-populate entityIdMap with all existing entities (by id and lowercase name)
+            const entityIdMap = new Map();
+            const existingLocNames = new Set();
+            const existingCharNames = new Set();
+            const existingArtNames = new Set();
+            for (const loc of existingLocations) {
+                entityIdMap.set(loc.id, loc.id);
+                if (loc.name) {
+                    const lower = loc.name.trim().toLowerCase();
+                    entityIdMap.set(lower, loc.id);
+                    existingLocNames.add(lower);
+                }
+            }
+            for (const char of existingCharacters) {
+                entityIdMap.set(char.id, char.id);
+                if (char.name) {
+                    const lower = char.name.trim().toLowerCase();
+                    entityIdMap.set(lower, char.id);
+                    existingCharNames.add(lower);
+                }
+            }
+            for (const art of existingArtifacts) {
+                entityIdMap.set(art.id, art.id);
+                if (art.name) {
+                    const lower = art.name.trim().toLowerCase();
+                    entityIdMap.set(lower, art.id);
+                    existingArtNames.add(lower);
+                }
+            }
+            // 1. Create missing entities for enabled categories
+            if (repairOptions.locations && draft.newLocations.length > 0) {
+                const toCreate = draft.newLocations.filter((l) => {
+                    const lower = l.name.toLowerCase();
+                    if (existingLocNames.has(lower)) {
+                        if (l.id && entityIdMap.get(lower)) {
+                            entityIdMap.set(l.id, entityIdMap.get(lower));
+                        }
+                        return false;
+                    }
+                    return true;
+                });
+                addedLocationsIds = await this.createElements('location', toCreate, DEFAULT_IMAGE_URL, entityIdMap);
+            }
+            if (repairOptions.characters && draft.newCharacters.length > 0) {
+                const toCreate = draft.newCharacters.filter((c) => {
+                    const lower = c.name.toLowerCase();
+                    if (existingCharNames.has(lower)) {
+                        if (c.id && entityIdMap.get(lower)) {
+                            entityIdMap.set(c.id, entityIdMap.get(lower));
+                        }
+                        return false;
+                    }
+                    return true;
+                });
+                addedCharactersIds = await this.createElements('character', toCreate, DEFAULT_IMAGE_URL, entityIdMap);
+            }
+            if (repairOptions.artifacts && draft.newArtifacts.length > 0) {
+                const toCreate = draft.newArtifacts.filter((a) => {
+                    const lower = a.name.toLowerCase();
+                    if (existingArtNames.has(lower)) {
+                        if (a.id && entityIdMap.get(lower)) {
+                            entityIdMap.set(a.id, entityIdMap.get(lower));
+                        }
+                        return false;
+                    }
+                    return true;
+                });
+                addedArtifactsIds = await this.createElements('artifact', toCreate, DEFAULT_IMAGE_URL, entityIdMap);
+            }
+            // 2. Update existing entities if grammarAndFlow is enabled
+            if (repairOptions.grammarAndFlow) {
+                await this.updateExistingElements('location', existingLocations, draft.updatedLocations);
+                await this.updateExistingElements('character', existingCharacters, draft.updatedCharacters);
+                await this.updateExistingElements('artifact', existingArtifacts, draft.updatedArtifacts);
+            }
+            // 3. Update Story metadata and entity ID lists
+            const mergedLocationIds = Array.from(new Set([
+                ...(story.locationIds || []),
+                ...existingLocations.map((l) => l.id),
+                ...addedLocationsIds,
+            ]));
+            const mergedCharactersIds = Array.from(new Set([
+                ...(story.charactersIds || []),
+                ...existingCharacters.map((c) => c.id),
+                ...addedCharactersIds,
+            ]));
+            const mergedArtifactsIds = Array.from(new Set([
+                ...(story.artifactsIds || []),
+                ...existingArtifacts.map((a) => a.id),
+                ...addedArtifactsIds,
+            ]));
+            updatedStoryDescription =
+                repairOptions.grammarAndFlow && draft.story?.description?.trim()
+                    ? draft.story.description.trim()
+                    : story.description;
+            const updatedStoryHistory = repairOptions.grammarAndFlow && draft.story?.history?.trim()
+                ? draft.story.history.trim()
+                : story.history;
+            const updatedStoryMoralMeaning = repairOptions.grammarAndFlow && draft.story?.moralMeaning?.trim()
+                ? draft.story.moralMeaning.trim()
+                : story.moralMeaning;
+            const storyChanged = updatedStoryDescription !== story.description ||
+                updatedStoryHistory !== story.history ||
+                updatedStoryMoralMeaning !== story.moralMeaning ||
+                addedLocationsIds.length > 0 ||
+                addedCharactersIds.length > 0 ||
+                addedArtifactsIds.length > 0 ||
+                mergedLocationIds.length !== (story.locationIds || []).length ||
+                mergedCharactersIds.length !== (story.charactersIds || []).length ||
+                mergedArtifactsIds.length !== (story.artifactsIds || []).length;
+            if (storyChanged) {
+                this.log('Updating story details and linked elements...');
+                await this.presentation.editStory(this.transport, {
+                    ...story,
+                    description: updatedStoryDescription,
+                    history: updatedStoryHistory,
+                    moralMeaning: updatedStoryMoralMeaning,
+                    locationIds: mergedLocationIds,
+                    charactersIds: mergedCharactersIds,
+                    artifactsIds: mergedArtifactsIds,
+                });
+            }
+            // 4. Update slides
+            const draftSlidesById = new Map();
+            for (const ds of draft.slides) {
+                if (ds.id) {
+                    draftSlidesById.set(ds.id, ds);
+                }
+            }
+            for (let i = 0; i < slides.length; i++) {
+                const slide = slides[i];
+                const draftSlide = draftSlidesById.get(slide.id) || draft.slides[i];
+                if (!draftSlide) {
+                    continue;
+                }
+                const nextText = repairOptions.grammarAndFlow && draftSlide.text?.trim()
+                    ? draftSlide.text.trim()
+                    : slide.text;
+                const nextIllustrationDescription = repairOptions.grammarAndFlow && draftSlide.illustrationDescription?.trim()
+                    ? draftSlide.illustrationDescription.trim()
+                    : slide.illustrationDescription;
+                let nextLocationId = slide.locationId;
+                if (repairOptions.locations && draftSlide.location !== undefined) {
+                    if (draftSlide.location === null || draftSlide.location === '') {
+                        nextLocationId = slide.locationId;
+                    }
+                    else {
+                        const resolvedLoc = entityIdMap.get(draftSlide.location) ||
+                            entityIdMap.get(draftSlide.location.toLowerCase());
+                        if (resolvedLoc) {
+                            nextLocationId = resolvedLoc;
+                        }
+                    }
+                }
+                let nextCharactersIds = slide.charactersIds || [];
+                if (repairOptions.characters && Array.isArray(draftSlide.characters)) {
+                    const resolvedChars = draftSlide.characters
+                        .map((ref) => entityIdMap.get(ref) || entityIdMap.get(ref.toLowerCase()))
+                        .filter((id) => Boolean(id));
+                    nextCharactersIds = Array.from(new Set([...(slide.charactersIds || []), ...resolvedChars]));
+                }
+                let nextArtifactsIds = slide.artifactsIds || [];
+                if (repairOptions.artifacts && Array.isArray(draftSlide.artifacts)) {
+                    const resolvedArts = draftSlide.artifacts
+                        .map((ref) => entityIdMap.get(ref) || entityIdMap.get(ref.toLowerCase()))
+                        .filter((id) => Boolean(id));
+                    nextArtifactsIds = Array.from(new Set([...(slide.artifactsIds || []), ...resolvedArts]));
+                }
+                const slideChanged = nextText !== slide.text ||
+                    nextIllustrationDescription !== slide.illustrationDescription ||
+                    nextLocationId !== slide.locationId ||
+                    !this.sameStringArray(nextCharactersIds, slide.charactersIds || []) ||
+                    !this.sameStringArray(nextArtifactsIds, slide.artifactsIds || []);
+                if (slideChanged) {
+                    try {
+                        await this.presentation.editSlide(this.transport, {
+                            ...slide,
+                            text: nextText,
+                            illustrationDescription: nextIllustrationDescription,
+                            locationId: nextLocationId,
+                            charactersIds: nextCharactersIds,
+                            artifactsIds: nextArtifactsIds,
+                        });
+                        updatedSlidesCount++;
+                        this.log(`Slide ${i + 1}/${slides.length} updated.`);
+                    }
+                    catch (e) {
+                        this.log(`Failed to update slide ${i + 1}: ${e?.message || e}`, 'warn');
+                    }
+                }
+            }
+        }
+        // 5. Sanitize & upload story-related images to the public S3 bucket when enabled
+        let sanitizedImagesCount = 0;
+        if (repairOptions.sanitizeImages) {
+            if (this.presentation.sanitizeStoryImages) {
+                this.log('Checking and sanitizing story-related images for public S3 bucket...');
+                try {
+                    const sanitizeResult = await this.presentation.sanitizeStoryImages(this.transport, {
+                        storyId: story.id,
+                        onProgress: (msg) => this.log(msg),
+                    });
+                    sanitizedImagesCount = sanitizeResult.updatedCount;
+                    this.log(`Image sanitization completed: ${sanitizeResult.checkedCount} checked, ` +
+                        `${sanitizeResult.uploadedCount} uploaded to public bucket, ` +
+                        `${sanitizeResult.updatedCount} entity image URL(s) updated.`);
+                }
+                catch (e) {
+                    this.log(`Failed to sanitize story images: ${e?.message || e}`, 'warn');
+                }
+            }
+            else {
+                this.log('Image sanitization handler is not configured on presentation storage.', 'warn');
+            }
+        }
+        this.log(`Story repair completed: ${updatedSlidesCount} slide(s) updated, ` +
+            `${addedCharactersIds.length} character(s), ${addedArtifactsIds.length} artifact(s), ` +
+            `${addedLocationsIds.length} location(s) added` +
+            (repairOptions.sanitizeImages ? `, ${sanitizedImagesCount} image(s) sanitized.` : '.'));
+        return {
+            storyId: story.id,
+            name: story.name,
+            description: updatedStoryDescription || story.description || '',
+            slidesCount: slides.length,
+            updatedSlidesCount,
+            addedCharactersCount: addedCharactersIds.length,
+            addedArtifactsCount: addedArtifactsIds.length,
+            addedLocationsCount: addedLocationsIds.length,
+            repairedGrammar: repairOptions.grammarAndFlow,
+            sanitizedImagesCount,
+        };
+    }
+    validateInput() {
+        if (!this.input?.storyId) {
+            throw new Error('Story is required.');
+        }
+        const opts = this.input.options || {
+            grammarAndFlow: true,
+            characters: true,
+            artifacts: true,
+            locations: true,
+            sanitizeImages: true,
+        };
+        const sanitizeImages = opts.sanitizeImages !== undefined ? !!opts.sanitizeImages : true;
+        const needsLlm = !!opts.grammarAndFlow || !!opts.characters || !!opts.artifacts || !!opts.locations;
+        if (!needsLlm && !sanitizeImages) {
+            throw new Error('At least one repair option must be selected.');
+        }
+        if (needsLlm && !this.input?.agentId) {
+            throw new Error('Agent is required.');
+        }
+        return {
+            grammarAndFlow: !!opts.grammarAndFlow,
+            characters: !!opts.characters,
+            artifacts: !!opts.artifacts,
+            locations: !!opts.locations,
+            sanitizeImages,
+        };
+    }
+    async resolveAgent() {
+        this.log('Resolving selected agent...');
+        const member = await this.context.getChatMember(this.chatId, this.input.agentId);
+        if (!member || !member.isAgent || !member.agentConfiguration) {
+            throw new Error('Selected agent is not an agentic member of this chat.');
+        }
+        return member;
+    }
+    async loadSlides(storyId) {
+        const response = await this.presentation.getSlides(this.transport, {
+            storyId,
+            slideNumber: -1,
+            direction: 'front',
+            limit: MAX_SLIDES_PER_STORY,
+        });
+        return [...(response?.slides || [])].sort((a, b) => (a.slideNumber || 0) - (b.slideNumber || 0));
+    }
+    buildPrompt(story, slides, existingLocations, existingCharacters, existingArtifacts, options) {
+        const payload = {
+            repairOptions: options,
+            story: {
+                id: story.id,
+                name: story.name,
+                description: story.description || '',
+                history: story.history || '',
+                moralMeaning: story.moralMeaning || '',
+                recommendedAge: story.recommendedAge || '',
+            },
+            existingLocations: existingLocations.map((l) => ({
+                id: l.id,
+                name: l.name,
+                description: l.description || '',
+                visualDescription: l.visualDescription || '',
+            })),
+            existingCharacters: existingCharacters.map((c) => ({
+                id: c.id,
+                name: c.name,
+                description: c.description || '',
+                visualDescription: c.visualDescription || '',
+            })),
+            existingArtifacts: existingArtifacts.map((a) => ({
+                id: a.id,
+                name: a.name,
+                description: a.description || '',
+                visualDescription: a.visualDescription || '',
+            })),
+            slides: slides.map((s) => ({
+                id: s.id,
+                slideNumber: s.slideNumber,
+                text: s.text || '',
+                illustrationDescription: s.illustrationDescription || '',
+                location: s.locationId || null,
+                characters: s.charactersIds || [],
+                artifacts: s.artifactsIds || [],
+            })),
+        };
+        return JSON.stringify(payload);
+    }
+    async createElements(kind, drafts, imageUrl, idMapping) {
+        const ids = [];
+        if (!drafts.length) {
+            return ids;
+        }
+        this.log(`Creating ${drafts.length} missing ${kind}(s)...`);
+        for (let i = 0; i < drafts.length; i++) {
+            const element = {
+                applicationId: this.transport.peer.rtseeAppId,
+                configurationId: '',
+                name: drafts[i].name,
+                description: drafts[i].description,
+                visualDescription: drafts[i].visualDescription,
+                imageUrl,
+                images: [],
+                tagIds: [],
+                tags: [],
+            };
+            try {
+                const created = kind === 'location'
+                    ? await this.presentation.createLocation(this.transport, element)
+                    : kind === 'character'
+                        ? await this.presentation.createCharacter(this.transport, element)
+                        : await this.presentation.createArtifact(this.transport, element);
+                ids.push(created.id);
+                if (idMapping) {
+                    if (drafts[i].id) {
+                        idMapping.set(drafts[i].id, created.id);
+                    }
+                    if (drafts[i].name) {
+                        idMapping.set(drafts[i].name.toLowerCase(), created.id);
+                    }
+                }
+                this.log(`Created ${kind} ${i + 1}/${drafts.length}: "${created.name}".`);
+            }
+            catch (e) {
+                this.log(`Failed to create ${kind} "${drafts[i].name}": ${e?.message || e}`, 'warn');
+            }
+        }
+        return ids;
+    }
+    async updateExistingElements(kind, existing, updates) {
+        if (!updates.length || !existing.length) {
+            return;
+        }
+        const existingById = new Map(existing.map((e) => [e.id, e]));
+        for (const upd of updates) {
+            if (!upd.id) {
+                continue;
+            }
+            const orig = existingById.get(upd.id);
+            if (!orig) {
+                continue;
+            }
+            const nextName = upd.name?.trim() || orig.name;
+            const nextDesc = upd.description?.trim() || orig.description;
+            const nextVisual = upd.visualDescription?.trim() || orig.visualDescription;
+            if (nextName === orig.name &&
+                nextDesc === orig.description &&
+                nextVisual === orig.visualDescription) {
+                continue;
+            }
+            const updatedElement = {
+                ...orig,
+                name: nextName,
+                description: nextDesc,
+                visualDescription: nextVisual,
+            };
+            try {
+                if (kind === 'location') {
+                    await this.presentation.editLocation(this.transport, updatedElement);
+                }
+                else if (kind === 'character') {
+                    await this.presentation.editCharacter(this.transport, updatedElement);
+                }
+                else {
+                    await this.presentation.editArtifact(this.transport, updatedElement);
+                }
+                this.log(`Updated ${kind} "${nextName}".`);
+            }
+            catch (e) {
+                this.log(`Failed to update ${kind} "${nextName}": ${e?.message || e}`, 'warn');
+            }
+        }
+    }
+    parseRepairDraft(text) {
+        if (!text || !text.trim()) {
+            throw new Error('Repair response is empty.');
+        }
+        const start = text.indexOf('{');
+        const end = text.lastIndexOf('}');
+        if (start === -1 || end <= start) {
+            throw new Error('No JSON object found in the repair response.');
+        }
+        let candidate = text.substring(start, end + 1).trim();
+        candidate = candidate.replace(/^```json\s*/i, '').replace(/```$/i, '').trim();
+        let parsed;
+        try {
+            parsed = JSON.parse(candidate);
+        }
+        catch {
+            const cleaned = candidate.replace(/,\s*([\]}])/g, '$1');
+            parsed = JSON.parse(cleaned);
+        }
+        const slides = (Array.isArray(parsed.slides) ? parsed.slides : []).map((s) => ({
+            id: `${s?.id || ''}`.trim(),
+            slideNumber: typeof s?.slideNumber === 'number' ? s.slideNumber : undefined,
+            text: s?.text ? `${s.text}`.trim() : undefined,
+            illustrationDescription: s?.illustrationDescription
+                ? `${s.illustrationDescription}`.trim()
+                : undefined,
+            location: s?.location === null
+                ? null
+                : s?.location
+                    ? `${s.location}`.trim()
+                    : undefined,
+            characters: Array.isArray(s?.characters)
+                ? s.characters.map((c) => `${c}`.trim()).filter(Boolean)
+                : undefined,
+            artifacts: Array.isArray(s?.artifacts)
+                ? s.artifacts.map((a) => `${a}`.trim()).filter(Boolean)
+                : undefined,
+        }));
+        return {
+            story: parsed.story
+                ? {
+                    description: parsed.story.description
+                        ? `${parsed.story.description}`.trim()
+                        : undefined,
+                    history: parsed.story.history ? `${parsed.story.history}`.trim() : undefined,
+                    moralMeaning: parsed.story.moralMeaning
+                        ? `${parsed.story.moralMeaning}`.trim()
+                        : undefined,
+                }
+                : undefined,
+            newLocations: this.parseElements(parsed.newLocations),
+            newCharacters: this.parseElements(parsed.newCharacters),
+            newArtifacts: this.parseElements(parsed.newArtifacts),
+            updatedLocations: this.parseElements(parsed.updatedLocations),
+            updatedCharacters: this.parseElements(parsed.updatedCharacters),
+            updatedArtifacts: this.parseElements(parsed.updatedArtifacts),
+            slides,
+        };
+    }
+    parseElements(raw) {
+        if (!Array.isArray(raw)) {
+            return [];
+        }
+        const seen = new Set();
+        return raw
+            .map((e) => ({
+            id: e?.id ? `${e.id}`.trim() : undefined,
+            name: `${e?.name || ''}`.trim(),
+            description: `${e?.description || ''}`.trim(),
+            visualDescription: `${e?.visualDescription || ''}`.trim(),
+        }))
+            .filter((e) => {
+            const key = e.name.toLowerCase();
+            if (!e.name || seen.has(key)) {
+                return false;
+            }
+            seen.add(key);
+            return true;
+        });
+    }
+    sameStringArray(a, b) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.StoryRepairTask = StoryRepairTask;
+function getStoryRepairTask(presentation) {
+    return {
+        name: common_1.STORY_REPAIR_TASK_NAME,
+        description: 'Repairs a Story by fixing grammar & flow and/or creating and linking missing characters, locations, and artifacts.',
+        create: (options) => new StoryRepairTask(options, presentation),
+    };
+}
+//# sourceMappingURL=StoryRepairTask.js.map