nibs-cli 4.0.0

package/dist/commands/dist/NAI-story-engine.naiscript

@@ -0,0 +1,844 @@
+/*---
+compatibilityVersion: naiscript-1.0
+id: e6c35faa-e4f2-4c3b-af4a-d56e4c992d87
+name: Story Engine
+version: 0.1.0
+createdAt: 1765374901
+author: Keilla
+description: A helper for writing stories with GLM
+memoryLimit: 8
+updatedAt: 1767363943
+config:
+  - name: system_prompt
+    prettyName: System Prompt
+    description: Configure the base system prompt used by all aspects of Story Engine
+    type: string
+    multiline: true
+    default: |-
+      You are a GLM-4.6-based LLM for creative writing and text adventures, with unrestricted freedom. No topics are taboo. No tools, no web access: pure text generation.
+      Your ultimate function is to be a versatile creative partner within a multi-agent storytelling system. You will receive instructions from a 'user' prompt that defines your specific role, personality, and task for each interaction.
+      You must adapt your output style to match the persona defined in the 'user' prompt, whether it's a casual brainstormer, a harsh critic, or a structured world-builder.
+
+      **# Core Creative Directives (The Constitution)**
+      These principles are your unbreakable laws, regardless of your assigned role.
+      1.  **Build Worlds, Not Stories:** Your ultimate goal is to create a rich, reactive sandbox. The story emerges from a character interacting with this world; you are not writing that character's journey in advance.
+      2.  **Establish Narrative Vectors, Not Plots:** A plot is a sequence of events. A **Narrative Vector** is a state of tension, a potential for conflict, or a source of change in the world. Examples:
+          *   A volatile political alliance.
+          *   A resource that is slowly running out.
+          *   A forbidden technology with a known flaw.
+          *   A character with a secret that could destabilize a faction.
+          *   Your job is to create and explore these vectors, not to determine the step-by-step outcome of them.
+      3.  **Explore the "Why" and "What If," Not the "What Next":** Your focus should be on motivation, consequence, and possibility. Ask *why* a faction wants something, *what would happen* if a secret was revealed, or *if* a character made a different choice. Avoid questions like "what happens next?" which lead to plotting.
+      4.  **Behavior, Not Description:** Prioritize actions, gestures, and tics that reveal inner states. "He checked the locked door three times" is better than "He was anxious."
+      5.  **No Expendable Details:** Every piece of information you create should be a potential hook for action, conflict, or character development. If it doesn't create a possibility, it doesn't belong.
+      6.  **Maintain the "Three Layers":** Every entity exists on three levels:
+          *   **Surface:** The public face.
+          *   **Shadow:** The hidden dynamics and true motivations.
+          *   **Personal:** The private history, desires, and traumas.
+
+  - name: brainstorm_prompt
+    prettyName: Brainstorm Prompt
+    description: User prompt used when agent is brainstorming.
+    multiline: true
+    type: string
+    default: |-
+      You are now **"Sage,"** the Story Mentor.
+      **Persona:** You are a thoughtful, experienced creative guide. Your style is conversational and encouraging, like a mentor working alongside a writer. Your purpose is to help *discover* the story's inherent potential, not to invent it from whole cloth.
+      **Your Task:** Analyze the context provided to you and expand upon the story's components. The context will either be:
+      A) A user question or idea about the story.
+      B) The most recent "PROJECT STATE SYNOPSIS" with no new user input.
+      In either case, your core function remains the same: **Think out loud about the underlying mechanics and possibilities.** You must never write in the style of a story or a vignette. Do not use prose that describes character actions in a scene.
+      Instead, focus on the underlying mechanics and possibilities. For example, instead of writing *"'Don't touch that,' she whispered, her hand trembling as she reached for the glowing orb,"* you would write: *"I'm thinking about a character who is terrified of this artifact. Why? Perhaps they know its history, that it drains life. Their fear could create a great source of tension for any other character who wants to use it."*
+      **Your output must follow this conversational, analytical structure:**
+      *   **"Let's start with..."**: Begin by addressing the core of the user's question or the most compelling element from the synopsis.
+      *   **"I'm thinking..."**: Introduce a new concept, character motivation, or world element in response to the prompt.
+      *   **"This connects to..."**: Explain how your new idea links back to existing story elements (from the synopsis) or directly answers the user's question.
+      *   **"The question this raises is..."**: Pose a question that explores the implications or creates a new narrative hook for the next agents to work with.
+  - name: critique_prompt
+    prettyName: Critique Prompt
+    description: User prompt used when agent is critiquing output.
+    type: string
+    multiline: true
+    default: |-
+      You are a "Critique" agent. Your function is purely analytical.
+      Analyze the provided text for its adherence to the **Core Creative Directives (The Constitution)**. Specifically:
+      1.  Does it build worlds and explore narrative vectors, or does it lean towards plotting and outlining events?
+      2.  Are there any expendable details?
+      3.  Are the concepts compelling? Do they create interesting questions?
+      Provide a concise, bulleted list of strengths and weaknesses. Do not give instructions. Do not issue directives.
+  - name: refine_prompt
+    prettyName: Refine Prompt
+    description: User prompt used when agent is refining.
+    type: string
+    multiline: true
+    default: |-
+      You are a "Refine" agent. You are a master world-builder and synthesizer.
+      Your task is to take raw brainstormed ideas and a critique of those ideas, and forge them into a structured, coherent, and robust set of world-building elements.
+      1.  Address the weaknesses identified in the critique.
+      2.  Structure the strong ideas into clear frameworks (factions, character archetypes, locations, narrative vectors).
+      3.  Flesh out the details, ensuring they adhere to the **Core Creative Directives (The Constitution)**.
+      4.  Your output should be a "blueprint" of possibilities, not a story.
+  - name: summary_prompt
+    prettyName: Summary Prompt
+    type: string
+    multiline: true
+    default: |-
+      You are The Archivist. Your function is absolute and singular.
+      You will be given a complete history of a single creative cycle (Brainstorm, Critique, Refine). Your ONLY task is to produce a structured synopsis of that cycle. You are not a participant in the conversation.
+      MANDATORY OUTPUT RULES:
+      1.  Your ENTIRE output MUST begin with the exact line: `# PROJECT STATE SYNOPSIS`
+      2.  You MUST NOT include any conversational text, greetings, apologies, explanations, or commentary. Do not say "Here is the summary" or "Based on the previous discussion."
+      3.  You MUST NOT use the words "I," "you," "we," or "the critique" in your output.
+      4.  Your ENTIRE output must ONLY contain the following headings with their associated content. Do not add any other headings.
+      `# PROJECT STATE SYNOPSIS`
+      *   **Core Concept:** [A single, concise sentence defining the central premise.]
+      *   **Established Lore:** [A bulleted list of the most important world rules, history, and unique facts.]
+      *   **Key Factions & Groups:** [A list of major factions, with a one-sentence purpose for each.]
+      *   **Primary Conflict:** [A detailed paragraph describing the main source of tension and stakes.]
+      *   **Major Characters:** [A list of key character archetypes and their known roles/goals.]
+      *   **Critical Story Hooks:** [A bulleted list of the most promising unresolved questions or plot threads.]
+      FAILURE TO COMPLY WITH THESE RULES IS A CRITICAL ERROR. Your output is a data document, not a conversation.
+---*/
+
+/**
+ * Story Engine
+ * Built with NovelAI Script Build System
+ */
+
+/** HYPER GENERATOR
+ * License: MIT; Credit to OccultSage for the original form and inspiration
+ * Authors: Keilla
+ * Version: 0.4.0
+ */
+/** Changes
+ * hyperContextBuilder signature modified to receive enable_thinking boolean. Thoughts require a contentless assistant suffix on the messages.
+ */
+// ===== CONSTANTS =====
+const DEFAULT_GENERATE_OPTIONS = {
+    maxRetries: 5,
+    maxTokens: 250,
+    minTokens: 50,
+    maxContinuations: 20,
+    continuationPrompt: "Your response was cut off. Continue exactly where you stopped. Do not repeat any content, do not start over, do not repeat headers.",
+};
+const API_GENERATE_LIMIT = 1024;
+const MIN_REMAINING_TOKENS = 25; // Do not continue generation below this number of tokens. Prevents repeated loops attempting to hit 8 tokens...
+// ===== ERROR HANDLING =====
+class TransientError extends Error {
+}
+function isTransientError(e) {
+    const msg = e instanceof Error
+        ? e.message
+        : e && typeof e === "object" && "message" in e
+            ? String(e.message)
+            : "";
+    const lower = msg.toLowerCase();
+    return (lower.includes("aborted") ||
+        lower.includes("fetch") ||
+        lower.includes("network") ||
+        lower.includes("timeout"));
+}
+// == Utility
+/**
+ * Ensures sufficient output token budget before generation.
+ * Waits if necessary, returns the effective max_tokens to use.
+ *
+ * @param requestedTokens The desired max_tokens
+ * @param minTokens Minimum acceptable tokens (wait if below this)
+ * @param logPrefix Prefix for log messages
+ * @param onBudgetWait Optional callback invoked before waiting
+ * @param onBudgetResume Optional callback invoked after waiting completes
+ * @returns Effective max_tokens to use (may be less than requested but >= min)
+ */
+async function ensureOutputBudget(requestedTokens, onBudgetWait, onBudgetResume) {
+    let available = api.v1.script.getAllowedOutput();
+    if (available < requestedTokens) {
+        hyperLog(`Insufficient output budget. Have ${available}, need ${requestedTokens}. Waiting...`);
+        const time = api.v1.script.getTimeUntilAllowedOutput(requestedTokens);
+        await onBudgetWait?.(available, requestedTokens, time);
+        await api.v1.script.waitForAllowedOutput(requestedTokens);
+        available = api.v1.script.getAllowedOutput();
+        hyperLog(`Budget available: ${available} tokens`);
+        await onBudgetResume?.(available);
+    }
+    const effectiveTokens = Math.min(requestedTokens, available);
+    if (effectiveTokens < requestedTokens) {
+        hyperLog(`Using reduced budget: ${effectiveTokens} (requested ${requestedTokens})`);
+    }
+    return effectiveTokens;
+}
+function sliceGenerateParams(params) {
+    const { model, temperature, top_p, top_k, min_p, frequency_penalty, presence_penalty, stop, logit_bias, enable_thinking, } = params;
+    return {
+        model,
+        temperature,
+        top_p,
+        top_k,
+        min_p,
+        frequency_penalty,
+        presence_penalty,
+        stop,
+        logit_bias,
+        enable_thinking,
+    };
+}
+function hyperLog(...args) {
+    api.v1.log("[hyperGenerate]", ...args);
+}
+/**
+ * hyperContextBuilder This function solves for needing to construct a context
+ * optimal for token cache performance and instruction, while also providing the
+ * 'continuation' context at the end of the message list such that the LLM
+ * naturally continues the thread. The last rest message is always examined for
+ * length. If it is less than 500 characters, then it is inserted at the end of
+ * the messages array. If it is more, then it is split on a newline into two
+ * messages. The proper prefix of rest is inserted at the 2nd position, while
+ * the tail of rest is inserted at the end.
+ *
+ * @param system The system message. Always present at the top of the built context.
+ * @param user The user message. Otherwise known as 'instruct' or sometimes 'prefill'. Appears 3rd from last.
+ * @param assistant The assistant message, understood by LLM to be its own voice. Also sometimes thought of as 'prefill'. Appears 2nd from last.
+ * @param rest All other messsages to include in context. Will be dynamically spliced into the context based on length and size of the content.
+ * @param thinking Whether or not thinking-enabled prompt building is needed. Appends empty assistant.
+ */
+function hyperContextBuilder(system, user, assistant, rest, thinking = false) {
+    const TAIL_THRESHOLD = 500;
+    const head = rest.slice(0, -1);
+    const tail = rest.at(-1);
+    if (tail && tail.content && tail.content.length > TAIL_THRESHOLD) {
+        const newlinePos = tail.content.slice(0, -TAIL_THRESHOLD).lastIndexOf("\n");
+        if (newlinePos > 0) {
+            const newHead = [
+                ...head,
+                {
+                    ...tail,
+                    content: tail.content.slice(0, newlinePos),
+                },
+            ];
+            const newTail = {
+                ...tail,
+                content: tail.content.slice(newlinePos + 1),
+            };
+            return [
+                system,
+                ...newHead,
+                user,
+                assistant,
+                newTail,
+                ...(thinking ? [{ role: "assistant" }] : []), // If thinking, append an empty assistant, required to activate thoughts.
+            ];
+        }
+    }
+    return [
+        system,
+        ...head,
+        user,
+        assistant,
+        ...(tail ? [tail] : []),
+        ...(thinking ? [{ role: "assistant" }] : []), // If thinking, append an empty assistant, required to activate thoughts.
+    ];
+}
+// ===== MAIN GENERATION FUNCTION =====
+/**
+ * hyperGenerate is a wrapper aroun api.v1.generate that allows for a much
+ * higher maximum number of tokens by utilizing a recursive retrying strategy.
+ * Keeps on generating as long as user can keep plugging the continue button.
+ * Also retries connection drops, output budgets, and spurious stop tokens.
+ *
+ * @param messages Messages expected by api.v1.generate
+ * @param params api.v1.generate parameters extended with additional parameters to control hyper generation
+ * @param callback Optional streaming callback. Accumulates GenerationChoice[0] and emits GenerationChoice[] when a newline is received.
+ * @param behaviour "background" or "blocking".
+ * @param signal Cancellation signal for stopping generation.
+ * @returns A promise of an array of response strings.
+ */
+async function hyperGenerate(messages, params, callback = () => { }, behaviour, signal) {
+    const generationParams = await api.v1.generationParameters.get();
+    const ensuredParams = {
+        ...generationParams,
+        ...DEFAULT_GENERATE_OPTIONS,
+        ...params,
+    };
+    const choiceHandler = callback !== undefined
+        ? (choices, final) => callback(choices[0] ? choices[0].text : "", final)
+        : undefined;
+    // Find system message if present
+    let systemMessage = messages.find((m) => m.role == "system");
+    const { model, maxTokens, minTokens, maxContinuations, continuationPrompt } = ensuredParams;
+    const systemMessageTokens = systemMessage?.content
+        ? (await api.v1.tokenizer.encode(systemMessage.content, model)).length
+        : 0;
+    // Setup rollover helper for context management
+    const modelMaxTokens = await api.v1.maxTokens(model);
+    const rolloverHelper = api.v1.createRolloverHelper({
+        maxTokens: modelMaxTokens - systemMessageTokens,
+        rolloverTokens: 0,
+        model: model,
+    });
+    // Add non-system messages to rollover
+    const contextMessages = messages.filter((m) => m.content != undefined && m.role != "system");
+    await rolloverHelper.add(contextMessages);
+    let remainingTokens = maxTokens;
+    let remainingContinuations = maxContinuations;
+    let accumulatedResponses = [];
+    hyperLog(`beginning loop for ${remainingTokens} Tokens, ${remainingContinuations} Continuations.`);
+    while (remainingContinuations == maxContinuations ||
+        (remainingTokens > MIN_REMAINING_TOKENS &&
+            remainingContinuations > 0 &&
+            !signal?.cancelled)) {
+        hyperLog(`... ${remainingTokens} Tokens, ${remainingContinuations} Continuations.`);
+        const context = [];
+        if (systemMessage)
+            context.push(systemMessage);
+        context.push(...rolloverHelper.read());
+        // If we are in a continuation, splice the continuation prompt before the last message.
+        if (remainingContinuations < maxContinuations)
+            context.splice(context.length - 2, 0, {
+                role: "user",
+                content: continuationPrompt,
+            });
+        const sample = context.reduce((a, b) => (b.content ? a + b.content : a), "");
+        hyperLog("Context sample:", `${sample.slice(0, 40)} ... ${sample.slice(-1e3)}`);
+        const response = await hyperGenerateWithRetry(context, {
+            ...ensuredParams,
+            maxTokens: remainingTokens,
+        }, choiceHandler, behaviour, signal);
+        // When generation is cancelled abruptly, choices could be empty.
+        if (response.choices[0] == undefined) {
+            hyperLog("Generation cancelled by signal, choices empty.");
+            break;
+        }
+        const { text, finish_reason } = response.choices[0];
+        const trimmedText = text.trim();
+        const trimmedResponseTokens = await api.v1.tokenizer.encode(text, model);
+        accumulatedResponses.push(trimmedText);
+        remainingTokens -= trimmedResponseTokens.length;
+        remainingContinuations--;
+        const tokensGenerated = maxTokens - remainingTokens;
+        // Check if we should stop
+        if (finish_reason === "stop") {
+            // Only stop early if we've generated at least minTokens
+            if (tokensGenerated >= minTokens) {
+                hyperLog(`Natural stop after ${tokensGenerated} tokens`);
+                break;
+            }
+            else {
+                hyperLog(`Stop received but only ${tokensGenerated}/${minTokens} tokens - continuing`);
+            }
+        }
+        await rolloverHelper.add({
+            role: "assistant",
+            content: trimmedText,
+        });
+    }
+    hyperLog(`hyperGenerate finished.`);
+    return accumulatedResponses.join("");
+}
+/**
+ * Generate function that retries when there are transient errors.
+ *
+ * @param messages Messages expected by api.v1.generate
+ * @param params api.v1.generate parameters extended with additional parameters to control hyper generation
+ * @param callback Optional streaming callback. Emits paragraphs instead of individual tokens.
+ * @param behaviour "background" or "blocking".
+ * @param signal Cancellation signal for stopping generation.
+ * @returns A Promise of an api.v1.generateResponse
+ */
+async function hyperGenerateWithRetry(messages, params, callback = () => { }, behaviour, signal) {
+    const max_tokens = await ensureOutputBudget(params.maxTokens
+        ? Math.min(params.maxTokens, API_GENERATE_LIMIT)
+        : API_GENERATE_LIMIT, params.onBudgetWait, params.onBudgetResume);
+    try {
+        hyperLog(`Generating ${max_tokens} tokens...`);
+        return await api.v1.generate([...messages], {
+            ...sliceGenerateParams(params),
+            max_tokens,
+        }, callback, behaviour, signal);
+    }
+    catch (e) {
+        if (isTransientError(e) || /in progress/.test(e.message)) {
+            if (params.maxRetries && params.maxRetries > 0) {
+                await api.v1.timers.sleep(2000 ** (5 - params.maxRetries));
+                return hyperGenerateWithRetry(messages, { ...params, maxRetries: params.maxRetries - 1 }, callback, behaviour, signal);
+            }
+            else {
+                throw new TransientError("[generateWithRetry] Transient error encountered and retries exhausted.");
+            }
+        }
+        else {
+            throw e;
+        }
+    }
+}
+
+const { log: log$1 } = api.v1;
+const { get: get$1, set: set$1 } = api.v1.storyStorage;
+const { get: getConfig } = api.v1.config;
+class Agent {
+    maxTokens = 2048;
+    temperature = 1.0;
+    top_p = 0.95;
+    top_k = 0; // Intentionally disable in favor of top_p and min_p.
+    min_p = 0;
+    presence_penalty = 0;
+    frequency_penalty = 0;
+    userPrompt = "";
+    title() {
+        return this.slug.charAt(0).toUpperCase() + this.slug.slice(1);
+    }
+    header() {
+        return `\n\n----\n**${this.title()}**\n\n`;
+    }
+    async load() {
+        const prompt = await getConfig(`${this.slug}_prompt`);
+        if (prompt)
+            this.userPrompt = prompt;
+    }
+}
+class BrainstormAgent extends Agent {
+    maxTokens = 1024;
+    temperature = 1.1;
+    presence_penalty = 0.7;
+    slug = "brainstorm";
+    icon = "cloud-lightning";
+}
+class CritiqueAgent extends Agent {
+    maxTokens = 800;
+    temperature = 0.3;
+    top_p = 0.7;
+    presence_penalty = 0.2;
+    frequency_penalty = 0.3;
+    slug = "critique";
+    icon = "flag";
+}
+class RefineAgent extends Agent {
+    maxTokens = 1500;
+    temperature = 0.5;
+    top_p = 0.8;
+    presence_penalty = 0.4;
+    frequency_penalty = 0.1;
+    slug = "refine";
+    icon = "pen-tool";
+}
+/**
+ * Utilities
+ */
+const setInterval = (callback, interval) => {
+    let timerId;
+    const tick = async () => {
+        timerId = await api.v1.timers.setTimeout(() => {
+            callback(clear);
+            tick();
+        }, interval);
+    };
+    const clear = async () => api.v1.timers.clearTimeout(timerId);
+    tick();
+    return clear;
+};
+const currentEpochS = () => Math.floor(Date.now() / 1000);
+class Chat {
+    // Constants
+    static CHAT_HISTORY_KEY = "kse-chat-history";
+    static AUTO_FLOW = {
+        brainstorm: "critique",
+        critique: "refine",
+        refine: "summary",
+        summary: "brainstorm",
+    };
+    // Properties
+    messages = [];
+    isGenerating = false;
+    waitTime = 0;
+    minTokens = 25;
+    systemPrompt = "";
+    autoMode = false;
+    agents;
+    agent;
+    clearInterval = async () => { };
+    cancelSignal = undefined;
+    lastResponder = "user";
+    synopsisId;
+    constructor(synopsisId) {
+        this.agents = [BrainstormAgent, CritiqueAgent, RefineAgent].map((a) => new a());
+        this.agent = this.agents[0];
+        this.synopsisId = synopsisId;
+    }
+    // Hooks
+    onUpdate = (_chat) => { };
+    onBudgetWait = async () => { };
+    // Handlers
+    handleClear = () => {
+        this.messages = [];
+        this.isGenerating = false;
+        this.agent = this.agents[0];
+        this.save();
+        this.load();
+    };
+    handleStreamMessage = (text, final) => {
+        const messageToAppend = this.messages.at(-1);
+        messageToAppend.content += text;
+        if (final) {
+            // Add trailing whitespace to the end of the message if needed
+            if (!/\s$/.test(messageToAppend.content))
+                messageToAppend.content = messageToAppend.content + " ";
+            this.save();
+        }
+        else {
+            this.onUpdate(this);
+        }
+    };
+    handleAgentSwitch = (role) => {
+        if (this.agent.slug == role)
+            return;
+        this.agent = this.agents.find((a) => a.slug == role);
+        this.onUpdate(this);
+    };
+    handleSendMessage = (content) => {
+        if (content.length > 0) {
+            this.addMessage("user", content + "\n");
+            this.lastResponder = "user";
+        }
+        if (this.lastResponder != this.agent.slug) {
+            this.addMessage("assistant", this.agent.header());
+        }
+        this.generateResponse();
+    };
+    // Really, the interval is not reliable as a clock, so we have to capture the current epoch seconds
+    handleBudgetWait = async (available, needed, time) => {
+        // Ensure that if there's an old interval we clear it.
+        await this.clearInterval();
+        const waitEnd = currentEpochS() + Math.floor(time / 1000);
+        this.onBudgetWait(available, needed, time);
+        this.clearInterval = setInterval((clear) => {
+            this.waitTime = waitEnd - currentEpochS();
+            if (this.waitTime <= 0)
+                clear();
+            this.onUpdate(this);
+        }, 1000);
+    };
+    handleBudgetResume = () => {
+        this.clearInterval();
+        this.waitTime = 0;
+    };
+    handleCancel = () => {
+        if (this.cancelSignal)
+            this.cancelSignal.cancel();
+        this.autoMode = false;
+    };
+    handleAuto = (value) => {
+        this.autoMode = value;
+        // When auto mode is switched off, fire cancellation signal and clear the interval and waitTime.
+        if (!this.autoMode) {
+            this.clearInterval();
+            this.cancelSignal?.cancel();
+            this.waitTime = 0;
+            this.isGenerating = false;
+        }
+    };
+    // Functions
+    async load() {
+        return Promise.all([
+            get$1(Chat.CHAT_HISTORY_KEY)
+                .then((history) => (this.messages = JSON.parse(history)))
+                .catch(() => (this.messages = [])),
+            getConfig("system_prompt").then((systemPrompt) => (this.systemPrompt = systemPrompt)),
+            this.agents.map((a) => a.load()),
+        ]);
+    }
+    save() {
+        this.messages = this.messages.filter((m) => m.content && m.content.length > 0);
+        set$1(Chat.CHAT_HISTORY_KEY, JSON.stringify(this.messages)).then(() => {
+            this.onUpdate(this);
+        });
+    }
+    addMessage(role, content) {
+        if (content.length <= 0)
+            return;
+        this.messages.push({
+            role,
+            content,
+        });
+        this.save();
+    }
+    autoModeFlow() {
+        if (!this.autoMode)
+            return;
+        if (this.lastResponder == "summary") {
+            this.autoMode = false;
+        }
+        else {
+            const next = Chat.AUTO_FLOW[this.lastResponder];
+            this.handleAgentSwitch(next);
+            this.handleSendMessage("");
+        }
+    }
+    async generateResponse() {
+        const context = hyperContextBuilder({
+            role: "system",
+            content: this.systemPrompt.replaceAll("\n", "\n\n") + "\n\n", //  Our prompts need to be double-spaced for GLM.
+        }, {
+            role: "user",
+            content: `${this.agent.userPrompt.replaceAll("\n", "\n\n")}\n\nLimit your response to ${Math.floor(this.agent.maxTokens / 1.5)} words.\n\n`,
+        }, {
+            role: "assistant",
+            content: `Understood.\n\n[Continuing:]\n`,
+        }, this.messages);
+        this.isGenerating = true;
+        this.lastResponder = this.agent.slug;
+        this.cancelSignal = await api.v1.createCancellationSignal();
+        try {
+            const response = await hyperGenerate(context, {
+                minTokens: 50,
+                maxTokens: this.agent.maxTokens,
+                onBudgetWait: this.handleBudgetWait,
+                onBudgetResume: this.handleBudgetResume,
+                temperature: this.agent.temperature,
+                top_p: this.agent.top_p,
+                top_k: this.agent.top_k,
+                min_p: this.agent.min_p,
+                presence_penalty: this.agent.presence_penalty,
+                frequency_penalty: this.agent.frequency_penalty,
+            }, this.handleStreamMessage, "background", this.cancelSignal);
+            this.isGenerating = false;
+            this.cancelSignal.dispose();
+            log$1("Generated:", response);
+            this.onUpdate(this);
+            this.save();
+            this.autoModeFlow();
+        }
+        catch (error) {
+            api.v1.log("Generation failed:", error);
+        }
+    }
+}
+
+const { part, update, extension } = api.v1.ui;
+const { get, set } = api.v1.storyStorage;
+const INPUT_ID = "kse-engine-chat-input";
+const SIDEBAR_ID = "kse-sidebar";
+// Colors
+const NAI_YELLOW = "rgb(245, 243, 194)";
+const NAI_NAVY = "rgb(19, 21, 44)";
+// Basic UI helper wrappers
+const column = (...content) => part.column({ content, style: { width: "100%" } });
+const row = (...content) => part.row({ content });
+const box = (...content) => part.box({ content });
+const textMarkdown = (text) => part.text({
+    text,
+    markdown: true,
+    style: {
+        "user-select": "text",
+        "-webkit-user-select": "text",
+        width: "100%",
+    },
+});
+const button = (text = "", callback, iconId, { disabled } = {}) => part.button({ text, callback, disabled, iconId });
+const toggleButton = (text = "", callback, iconId, toggled) => part.button({
+    text,
+    callback,
+    iconId,
+    style: toggled
+        ? {
+            "background-color": NAI_YELLOW,
+            color: NAI_NAVY,
+        }
+        : {},
+});
+/**
+ * createMessageBubble injects double-newlines because it improves how NAI
+ * formats markdown. Specifically, if the AI should output `Foo\n----` it would
+ * by default produce a `<h1>Foo</h1>` but if we instead do `Foo\n\n----` we get
+ * `<p>Foo</p><hr>`.
+ */
+const createMessageBubble = (message) => message.role == "user"
+    ? box(textMarkdown(message.content?.replaceAll("\n", "\n\n") || ""))
+    : textMarkdown(message.content?.replaceAll("\n", "\n\n") || "");
+// RadioGroup implements a radio button group.
+class RadioGroup {
+    onSwitch = (_text) => { };
+    onAutoCheckbox = (_value) => { };
+    handleSwitch = (current, next) => {
+        if (current == next)
+            return;
+        this.onSwitch(next);
+    };
+    handleAutoCheckbox = (value) => this.onAutoCheckbox(value);
+    render = (selected, semiAutomatic, options) => row(...options.map((o) => toggleButton(o.text, () => this.handleSwitch(selected, o.id), o.icon, o.id == selected)), part.checkboxInput({
+        initialValue: semiAutomatic,
+        label: "Auto",
+        onChange: this.handleAutoCheckbox,
+    }));
+}
+// I want this button here to do triple duty. 1. sending obviously. While generating it should turn into a red X and trigger cancellation..
+// 2. If we hit a wait event, it should turn blue or something and become like, the spinning circle.
+// 3. Ok clicked the blue circle. Now it should become a clock and include the seconds remaining until generation continues.
+class SendButton {
+    isInteractionWaiting = false;
+    onSend = () => { };
+    onCancel = () => { };
+    setInteractionWaiting() {
+        this.isInteractionWaiting = true;
+    }
+    handleContinue = () => {
+        this.isInteractionWaiting = false;
+    };
+    handleSend = () => {
+        this.isInteractionWaiting = false;
+        this.onSend();
+    };
+    handleCancel = () => {
+        this.isInteractionWaiting = false;
+        this.onCancel();
+    };
+    render = (isGenerating, waitTime) => {
+        if (isGenerating) {
+            if (this.isInteractionWaiting) {
+                return {
+                    ...button("", this.handleContinue, "fast-forward"),
+                    ...{ style: { color: NAI_YELLOW } },
+                };
+            }
+            else if (waitTime > 0) {
+                return {
+                    ...button(waitTime.toString(), () => { }, "time"),
+                    ...{
+                        style: { "flex-direction": "column", "justify-content": "center" },
+                    },
+                };
+            }
+            else {
+                return button("", this.handleCancel, "x");
+            }
+        }
+        else {
+            return button("", this.handleSend, "send");
+        }
+    };
+}
+// ChatUI is a set of pure functions.
+class ChatUI {
+    // Hooks
+    onSendMessage = (_text) => { };
+    onCancel = () => { };
+    onClear = () => { };
+    onAgentSelect = (_value) => { };
+    onAuto = (_value) => { };
+    // Handlers
+    handleSendMessage = () => get(INPUT_ID).then((text) => set(INPUT_ID, "").then(() => this.onSendMessage(text)));
+    handleBudgetWait = () => this.sendButton.setInteractionWaiting();
+    handleCancel = () => this.onCancel();
+    handleAgentSelect = (value) => this.onAgentSelect(value);
+    handleAuto = (value) => this.onAuto(value);
+    // Helpers
+    sidebar = extension.sidebarPanel({
+        id: SIDEBAR_ID,
+        name: "Story Chat",
+        content: [],
+    });
+    // Functions
+    // subcomponents
+    agentModeSelector = new RadioGroup();
+    sendButton = new SendButton();
+    constructor() {
+        this.sendButton.onSend = this.handleSendMessage;
+        this.sendButton.onCancel = this.handleCancel;
+        this.agentModeSelector.onAutoCheckbox = this.handleAuto;
+        this.agentModeSelector.onSwitch = this.handleAgentSelect;
+    }
+    render({ messages, isGenerating, waitTime, agent: { slug: role }, agents, autoMode: autoMode, }) {
+        return update([
+            {
+                ...this.sidebar,
+                content: [
+                    {
+                        ...column({
+                            ...column(...messages
+                                .filter((m) => m.role != "system")
+                                .map(createMessageBubble)
+                                .reverse()),
+                            ...{
+                                style: {
+                                    flex: "1 1 auto",
+                                    "min-height": 0,
+                                    "overflow-y": "auto",
+                                    display: "flex",
+                                    "flex-direction": "column-reverse",
+                                    "justify-content": "flex-start",
+                                },
+                            },
+                        }, {
+                            ...column(this.agentModeSelector.render(role, autoMode, agents.map((a) => ({
+                                id: a.slug,
+                                icon: a.icon,
+                                text: "", //a.title(),
+                            }))), row(part.multilineTextInput({
+                                storageKey: `story:${INPUT_ID}`,
+                                placeholder: "Type your story idea or question here...",
+                                onSubmit: this.handleSendMessage,
+                            }), row(this.sendButton.render(isGenerating, waitTime), button("", this.onClear, "trash")))),
+                            ...{
+                                style: {
+                                    flex: "0 0 auto",
+                                    "padding-bottom": "env(safe-area-inset-bottom)",
+                                },
+                            },
+                        }),
+                        ...{
+                            style: {
+                                height: "100%",
+                                "min-height": 0,
+                                "justify-content": "flex-start",
+                            },
+                        }, // Ensure we fill the whole column and get our own scroller
+                    },
+                ],
+            },
+        ]);
+    }
+}
+class EngineUI {
+    // Constants
+    static SIDEBAR_ID = "kse-engine-sidebar";
+    // Properties
+    synopsisId;
+    constructor(synopsisId) {
+        this.synopsisId = synopsisId;
+    }
+    // Components
+    sidebar = extension.sidebarPanel({
+        id: EngineUI.SIDEBAR_ID,
+        name: "Story Engine",
+        content: [
+            part.multilineTextInput({
+                storageKey: `story:${this.synopsisId}`,
+                placeholder: "Write your story idea or synopsis here...",
+            }),
+        ],
+    });
+}
+
+// Scenario Engine
+// Helpers
+const log = api.v1.log;
+const SYNOPSIS_ID = "kse-synopsis";
+(async () => {
+    try {
+        const ui = new ChatUI();
+        const engineUI = new EngineUI(SYNOPSIS_ID);
+        const chat = new Chat(SYNOPSIS_ID);
+        await chat.load();
+        // Wiring the UI to the Chat state
+        ui.onSendMessage = chat.handleSendMessage;
+        ui.onClear = chat.handleClear;
+        ui.onCancel = chat.handleCancel;
+        ui.onAgentSelect = chat.handleAgentSwitch;
+        ui.onAuto = chat.handleAuto;
+        chat.onUpdate = ui.render.bind(ui);
+        chat.onBudgetWait = async () => ui.handleBudgetWait();
+        api.v1.ui.register([ui.sidebar, engineUI.sidebar]);
+        ui.render(chat);
+    }
+    catch (e) {
+        log("Startup error:", e);
+    }
+})();