llms-py 3.0.14__py3-none-any.whl → 3.0.16__py3-none-any.whl

llms/extensions/skills/ui/index.mjs

@@ -0,0 +1,362 @@
+import { ref, inject, computed } from "vue"
+import { leftPart } from "@servicestack/client"
+
+let ext
+
+const SkillSelector = {
+    template: `
+        <div class="px-4 py-4 bg-gray-50 dark:bg-gray-800 border-b border-gray-200 dark:border-gray-700 max-h-[80vh] overflow-y-auto">
+            
+            <!-- Global Controls -->
+            <div class="flex items-center justify-between mb-4">
+                <span class="text-xs font-bold uppercase text-gray-500 tracking-wider">Include Skills</span>
+                <div class="flex items-center gap-2">
+                    <button @click="$ctx.setPrefs({ onlySkills: null })"
+                        class="px-3 py-1 rounded-md text-xs font-medium border transition-colors select-none"
+                        :class="$prefs.onlySkills == null
+                            ? 'bg-green-100 dark:bg-green-900/40 text-green-800 dark:text-green-300 border-green-300 dark:border-green-800' 
+                            : 'cursor-pointer bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-400 border-gray-200 dark:border-gray-700 hover:border-gray-300 dark:hover:border-gray-600'">
+                        All Skills
+                    </button>
+                    <button @click="$ctx.setPrefs({ onlySkills:[] })"
+                        class="px-3 py-1 rounded-md text-xs font-medium border transition-colors select-none"
+                        :class="$prefs.onlySkills?.length === 0
+                            ? 'bg-fuchsia-100 dark:bg-fuchsia-900/40 text-fuchsia-800 dark:text-fuchsia-300 border-fuchsia-200 dark:border-fuchsia-800' 
+                            : 'cursor-pointer bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-400 border-gray-200 dark:border-gray-700 hover:border-gray-300 dark:hover:border-gray-600'">
+                        No Skills
+                    </button>
+                </div>
+            </div>
+
+            <!-- Groups -->
+            <div class="space-y-3">
+                <div v-for="group in skillGroups" :key="group.name" 
+                     class="bg-white dark:bg-gray-900 rounded-lg border border-gray-200 dark:border-gray-700 overflow-hidden">
+                     
+                     <!-- Group Header -->
+                     <div class="flex items-center justify-between px-3 py-2 bg-gray-50/50 dark:bg-gray-800/50 cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
+                          @click="toggleCollapse(group.name)">
+                        
+                        <div class="flex items-center gap-2 min-w-0">
+                             <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" class="w-4 h-4 text-gray-400 transition-transform duration-200" :class="{ '-rotate-90': isCollapsed(group.name) }">
+                                <path fill-rule="evenodd" d="M5.23 7.21a.75.75 0 011.06.02L10 11.168l3.71-3.938a.75.75 0 111.08 1.04l-4.25 4.5a.75.75 0 01-1.08 0l-4.25-4.5a.75.75 0 01.02-1.06z" clip-rule="evenodd" />
+                             </svg>
+                             <span class="font-semibold text-sm text-gray-700 dark:text-gray-200 truncate">
+                                {{ group.name || 'Other Skills' }}
+                             </span>
+                             <span class="text-xs text-gray-400 font-mono">
+                                {{ getActiveCount(group) }}/{{ group.skills.length }}
+                             </span>
+                        </div>
+
+                        <div class="flex items-center gap-2" @click.stop>
+                             <button @click="setGroupSkills(group, true)" type="button"
+                                title="Include All in Group"
+                                class="px-2 py-0.5 rounded text-xs font-medium border transition-colors select-none"
+                                :class="getActiveCount(group) === group.skills.length
+                                    ? 'bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300 border-green-300 dark:border-green-800 hover:bg-green-100 dark:hover:bg-green-900/40'
+                                    : 'bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-400 border-gray-200 dark:border-gray-700 hover:border-gray-300 dark:hover:border-gray-600'">
+                                all
+                             </button>
+                             <button @click="setGroupSkills(group, false)" type="button"
+                                title="Include None in Group"
+                                class="px-2 py-0.5 rounded text-xs font-medium border transition-colors select-none"
+                                :class="getActiveCount(group) === 0
+                                    ? 'bg-fuchsia-50 dark:bg-fuchsia-900/20 text-fuchsia-700 dark:text-fuchsia-300 border-fuchsia-200 dark:border-fuchsia-800 hover:bg-fuchsia-100 dark:hover:bg-fuchsia-900/40'
+                                    : 'bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-400 border-gray-200 dark:border-gray-700 hover:border-gray-300 dark:hover:border-gray-600'">
+                                none
+                             </button>
+                        </div>
+                     </div>
+                     
+                     <!-- Group Body -->
+                     <div v-show="!isCollapsed(group.name)" class="p-3 bg-white dark:bg-gray-900 border-t border-gray-100 dark:border-gray-800">
+                         <div class="flex flex-wrap gap-2">
+                            <button v-for="skill in group.skills" :key="skill.name" type="button"
+                                @click="toggleSkill(skill.name)"
+                                :title="skill.description"
+                                class="px-2.5 py-1 rounded-full text-xs font-medium border transition-colors select-none text-left truncate max-w-[200px]"
+                                :class="isSkillActive(skill.name)
+                                    ? 'bg-blue-100 dark:bg-blue-900/40 text-blue-800 dark:text-blue-300 border-blue-200 dark:border-blue-800' 
+                                    : 'bg-gray-50 dark:bg-gray-800 text-gray-600 dark:text-gray-400 border-gray-200 dark:border-gray-700 hover:border-gray-300 dark:hover:border-gray-600'">
+                                {{ skill.name }}
+                            </button>
+                         </div>
+                     </div>
+                </div>
+            </div>
+        </div>
+    `,
+    setup() {
+        const ctx = inject('ctx')
+        const collapsedState = ref({})
+
+        const availableSkills = computed(() => Object.values(ctx.state.skills || {}))
+
+        const skillGroups = computed(() => {
+            const skills = availableSkills.value
+            const groupsMap = {}
+            const otherSkills = []
+
+            skills.forEach(skill => {
+                if (skill.group) {
+                    if (!groupsMap[skill.group]) groupsMap[skill.group] = []
+                    groupsMap[skill.group].push(skill)
+                } else {
+                    otherSkills.push(skill)
+                }
+            })
+
+            const definedGroups = Object.entries(groupsMap).map(([name, skills]) => ({
+                name,
+                skills
+            }))
+
+            // Sort groups by name if needed, but for now rely on insertion order or backend order
+            definedGroups.sort((a, b) => a.name.localeCompare(b.name))
+
+            if (otherSkills.length > 0) {
+                definedGroups.push({ name: '', skills: otherSkills })
+            }
+
+            return definedGroups
+        })
+
+        function isSkillActive(name) {
+            const only = ctx.prefs.onlySkills
+            if (only == null) return true
+            if (Array.isArray(only)) {
+                return only.includes(name)
+            }
+            return false
+        }
+
+        function toggleSkill(name) {
+            let onlySkills = ctx.prefs.onlySkills
+
+            if (onlySkills == null) {
+                // If currently 'All', clicking a skill means we enter custom mode with all OTHER skills selected (deselecting clicked)
+                // Wait, logic in ToolSelector:
+                // if (onlyTools == null) { onlyTools = availableTools.value.map(t => t.function.name).filter(t => t !== name) }
+                // This means deselecting one tool switches to "custom" with all but that one.
+
+                onlySkills = availableSkills.value.map(s => s.name).filter(s => s !== name)
+            } else {
+                if (onlySkills.includes(name)) {
+                    onlySkills = onlySkills.filter(s => s !== name)
+                } else {
+                    onlySkills = [...onlySkills, name]
+                }
+            }
+
+            ctx.setPrefs({ onlySkills })
+        }
+
+        function toggleCollapse(groupName) {
+            const key = groupName || '_other_'
+            collapsedState.value[key] = !collapsedState.value[key]
+        }
+
+        function isCollapsed(groupName) {
+            const key = groupName || '_other_'
+            return !!collapsedState.value[key]
+        }
+
+        function setGroupSkills(group, enable) {
+            const groupSkillNames = group.skills.map(s => s.name)
+            let onlySkills = ctx.prefs.onlySkills
+
+            if (enable) {
+                if (onlySkills == null) return
+                const newSet = new Set(onlySkills)
+                groupSkillNames.forEach(n => newSet.add(n))
+                onlySkills = Array.from(newSet)
+                if (onlySkills.length === availableSkills.value.length) {
+                    onlySkills = null
+                }
+            } else {
+                if (onlySkills == null) {
+                    onlySkills = availableSkills.value
+                        .map(s => s.name)
+                        .filter(n => !groupSkillNames.includes(n))
+                } else {
+                    onlySkills = onlySkills.filter(n => !groupSkillNames.includes(n))
+                }
+            }
+
+            ctx.setPrefs({ onlySkills })
+        }
+
+        function getActiveCount(group) {
+            const onlySkills = ctx.prefs.onlySkills
+            if (onlySkills == null) return group.skills.length
+            return group.skills.filter(s => onlySkills.includes(s.name)).length
+        }
+
+        return {
+            availableSkills,
+            skillGroups,
+            isSkillActive,
+            toggleSkill,
+            toggleCollapse,
+            isCollapsed,
+            setGroupSkills,
+            getActiveCount
+        }
+    }
+}
+
+function codeFragment(s) {
+    return "`" + s + "`"
+}
+function codeBlock(s) {
+    return "```\n" + s + "\n```\n"
+}
+
+const SkillInstructions = `
+You have access to specialized skills that extend your capabilities with domain-specific knowledge, workflows, and tools. 
+Skills are modular packages containing instructions, scripts, references, and assets for particular tasks.
+
+## Using Skills
+
+Use the skill tool to read a skill's main instructions and guidance, e.g:
+${codeBlock("skill({ name: \"skill-name\" })")}
+
+To read a specific file within a skill (scripts, references, assets):
+${codeBlock("skill({ name: \"skill-name\", file: \"relative/path/to/file\" })")}
+
+Examples:
+- ${codeFragment("skill({ name: \"create-plan\" })")} - Read the create-plan skill's SKILL.md instructions
+- ${codeFragment("skill({ name: \"web-artifacts-builder\", file: \"scripts/init-artifact.sh\" })")} - Read a specific script
+
+## When to Use Skills
+
+You should read the appropriate skill BEFORE starting work on relevant tasks. Skills contain best practices, scripts, and reference materials that significantly improve output quality.
+
+**Skill Selection Guidelines:**
+- Match the task to available skill descriptions
+- Multiple skills may be relevant - read all that apply
+- Read the skill first, then follow its instructions
+
+## Available Skills
+$$AVAILABLE_SKILLS$$
+
+## Important Notes
+
+- Always read the skill BEFORE starting implementation
+- Skills may contain scripts that can be executed directly without loading into context
+- Multiple skills can and should be combined when tasks span multiple domains
+- If a skill references additional files (references/, scripts/, assets/), read those as needed during execution
+`
+
+export default {
+    order: 15 - 100,
+
+    install(ctx) {
+        ext = ctx.scope("skills")
+
+        ctx.components({ SkillSelector })
+
+        const svg = (attrs, title) => `<svg ${attrs} xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">${title ? "<title>" + title + "</title>" : ''}<path fill="currentColor" d="M20 17a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2H9.46c.35.61.54 1.3.54 2h10v11h-9v2m4-10v2H9v13H7v-6H5v6H3v-8H1.5V9a2 2 0 0 1 2-2zM8 4a2 2 0 0 1-2 2a2 2 0 0 1-2-2a2 2 0 0 1 2-2a2 2 0 0 1 2 2"/></svg>`
+
+        ctx.setTopIcons({
+            skills: {
+                component: {
+                    template: svg([
+                        `@click="$ctx.toggleTop('SkillSelector')"`,
+                        `:class="$prefs.onlySkills == null ? 'text-green-600 dark:text-green-300' : $prefs.onlySkills.length ? 'text-blue-600! dark:text-blue-300!' : ''"`
+                    ].join(' ')),
+                },
+                isActive({ top }) {
+                    return top === 'SkillSelector'
+                },
+                get title() {
+                    return ctx.prefs.onlySkills == null
+                        ? `All Skills Included`
+                        : ctx.prefs.onlySkills.length
+                            ? `${ctx.prefs.onlySkills.length} ${ctx.utils.pluralize('Skill', ctx.prefs.onlySkills.length)} Included`
+                            : 'No Skills Included'
+                }
+            }
+        })
+
+        ctx.chatRequestFilters.push(({ request, thread, context }) => {
+
+            const prefs = ctx.prefs
+            if (prefs.onlySkills != null) {
+                if (Array.isArray(prefs.onlySkills)) {
+                    request.metadata.skills = prefs.onlySkills.length > 0
+                        ? prefs.onlySkills.join(',')
+                        : 'none'
+                }
+            } else {
+                request.metadata.skills = 'all'
+            }
+
+            console.log('skills.chatRequestFilters', prefs.onlySkills, Object.keys(ctx.state.skills || {}))
+            const skills = ctx.state.skills
+            if (!skills) return
+
+            const includeSkills = []
+            for (const skill of Object.values(skills)) {
+                if (prefs.onlySkills == null || prefs.onlySkills.includes(skill.name)) {
+                    includeSkills.push(skill)
+                }
+            }
+            if (!includeSkills.length) return
+
+            const sb = []
+            sb.push("<available_skills>")
+            for (const skill of includeSkills) {
+                sb.push(" <skill>")
+                sb.push("  <name>" + ctx.utils.encodeHtml(skill.name) + "</name>")
+                sb.push("  <description>" + ctx.utils.encodeHtml(skill.description) + "</description>")
+                sb.push("  <location>" + ctx.utils.encodeHtml(skill.location) + "</location>")
+                sb.push(" </skill>")
+            }
+            sb.push("</available_skills>")
+
+            const skillsPrompt = SkillInstructions.replace('$$AVAILABLE_SKILLS$$', sb.join('\n')).trim()
+            context.requiredSystemPrompts.push(skillsPrompt)
+        })
+
+        ctx.setThreadFooters({
+            skills: {
+                component: {
+                    template: `
+                        <div class="mt-2 w-full flex justify-center">
+                            <button type="button" @click="$ctx.chat.sendUserMessage('proceed')"
+                                class="px-3 py-1 rounded-md text-xs font-medium border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 text-gray-700 dark:text-gray-300 hover:bg-gray-50 dark:hover:bg-gray-700 transition-colors select-none">
+                                proceed
+                            </button>
+                        </div>
+                    `
+                },
+                show({ thread }) {
+                    if (thread.messages.length < 2) return false
+                    const msgRoles = thread.messages.map(m => m.role)
+                    if (msgRoles[msgRoles.length - 1] != "assistant") return false
+                    const hasSkillToolCall = thread.messages.some(m =>
+                        m.tool_calls?.some(tc => tc.type == "function" && tc.function.name == "skill"))
+                    const systemPrompt = thread.messages.find(m => m.role == "system")?.content.toLowerCase() || ''
+                    const line1 = leftPart(systemPrompt.trim(), "\n")
+                    const hasPlanSystemPrompt = line1.includes("plan") || systemPrompt.includes("# plan")
+                    return hasSkillToolCall || hasPlanSystemPrompt
+                }
+            }
+        })
+
+        ctx.setState({
+            skills: {}
+        })
+    },
+
+    async load(ctx) {
+        const api = await ext.getJson('/')
+        if (api.response) {
+            ctx.setState({ skills: api.response })
+        } else {
+            ctx.setError(api.error)
+        }
+    }
+}

llms/extensions/skills/ui/skills/create-plan/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: create-plan
+description: Create a concise plan. Use when a user explicitly asks for a plan related to a coding task.
+metadata:
+  short-description: Create a plan
+---
+
+# Create Plan
+
+## Goal
+
+Turn a user prompt into a **single, actionable plan** delivered in the final assistant message.
+
+## Minimal workflow
+
+Throughout the entire workflow, operate in read-only mode. Do not write or update files.
+
+1. **Scan context quickly**
+   - Read `README.md` and any obvious docs (`docs/`, `CONTRIBUTING.md`, `ARCHITECTURE.md`).
+   - Skim relevant files (the ones most likely touched).
+   - Identify constraints (language, frameworks, CI/test commands, deployment shape).
+
+2. **Ask follow-ups only if blocking**
+   - Ask **at most 1–2 questions**.
+   - Only ask if you cannot responsibly plan without the answer; prefer multiple-choice.
+   - If unsure but not blocked, make a reasonable assumption and proceed.
+
+3. **Create a plan using the template below**
+   - Start with **1 short paragraph** describing the intent and approach.
+   - Clearly call out what is **in scope** and what is **not in scope** in short.
+   - Then provide a **small checklist** of action items (default 6–10 items).
+      - Each checklist item should be a concrete action and, when helpful, mention files/commands.
+      - **Make items atomic and ordered**: discovery → changes → tests → rollout.
+      - **Verb-first**: “Add…”, “Refactor…”, “Verify…”, “Ship…”.
+   - Include at least one item for **tests/validation** and one for **edge cases/risk** when applicable.
+   - If there are unknowns, include a tiny **Open questions** section (max 3).
+
+4. **Do not preface the plan with meta explanations; output only the plan as per template**
+
+## Plan template (follow exactly)
+
+```markdown
+# Plan
+
+<1–3 sentences: what we’re doing, why, and the high-level approach.>
+
+## Scope
+- In:
+- Out:
+
+## Action items
+[ ] <Step 1>
+[ ] <Step 2>
+[ ] <Step 3>
+[ ] <Step 4>
+[ ] <Step 5>
+[ ] <Step 6>
+
+## Open questions
+- <Question 1>
+- <Question 2>
+- <Question 3>
+```
+
+## Checklist item guidance
+Good checklist items:
+- Point to likely files/modules: src/..., app/..., services/...
+- Name concrete validation: “Run npm test”, “Add unit tests for X”
+- Include safe rollout when relevant: feature flag, migration plan, rollback note
+
+Avoid:
+- Vague steps (“handle backend”, “do auth”)
+- Too many micro-steps
+- Writing code snippets (keep the plan implementation-agnostic)

llms/extensions/skills/validator.py

@@ -0,0 +1,177 @@
+"""Skill validation logic."""
+
+import unicodedata
+from pathlib import Path
+from typing import Optional
+
+from .errors import ParseError
+from .parser import find_skill_md, parse_frontmatter
+
+MAX_SKILL_NAME_LENGTH = 64
+MAX_DESCRIPTION_LENGTH = 1024
+MAX_COMPATIBILITY_LENGTH = 500
+
+# Allowed frontmatter fields per Agent Skills Spec
+ALLOWED_FIELDS = {
+    "name",
+    "description",
+    "license",
+    "allowed-tools",
+    "metadata",
+    "compatibility",
+}
+
+
+def _validate_name(name: str, skill_dir: Path) -> list[str]:
+    """Validate skill name format and directory match.
+
+    Skill names support i18n characters (Unicode letters) plus hyphens.
+    Names must be lowercase and cannot start/end with hyphens.
+    """
+    errors = []
+
+    if not name or not isinstance(name, str) or not name.strip():
+        errors.append("Field 'name' must be a non-empty string")
+        return errors
+
+    name = unicodedata.normalize("NFKC", name.strip())
+
+    if len(name) > MAX_SKILL_NAME_LENGTH:
+        errors.append(
+            f"Skill name '{name}' exceeds {MAX_SKILL_NAME_LENGTH} character limit "
+            f"({len(name)} chars)"
+        )
+
+    if name != name.lower():
+        errors.append(f"Skill name '{name}' must be lowercase")
+
+    if name.startswith("-") or name.endswith("-"):
+        errors.append("Skill name cannot start or end with a hyphen")
+
+    if "--" in name:
+        errors.append("Skill name cannot contain consecutive hyphens")
+
+    if not all(c.isalnum() or c == "-" for c in name):
+        errors.append(
+            f"Skill name '{name}' contains invalid characters. "
+            "Only letters, digits, and hyphens are allowed."
+        )
+
+    if skill_dir:
+        dir_name = unicodedata.normalize("NFKC", skill_dir.name)
+        if dir_name != name:
+            errors.append(
+                f"Directory name '{skill_dir.name}' must match skill name '{name}'"
+            )
+
+    return errors
+
+
+def _validate_description(description: str) -> list[str]:
+    """Validate description format."""
+    errors = []
+
+    if not description or not isinstance(description, str) or not description.strip():
+        errors.append("Field 'description' must be a non-empty string")
+        return errors
+
+    if len(description) > MAX_DESCRIPTION_LENGTH:
+        errors.append(
+            f"Description exceeds {MAX_DESCRIPTION_LENGTH} character limit "
+            f"({len(description)} chars)"
+        )
+
+    return errors
+
+
+def _validate_compatibility(compatibility: str) -> list[str]:
+    """Validate compatibility format."""
+    errors = []
+
+    if not isinstance(compatibility, str):
+        errors.append("Field 'compatibility' must be a string")
+        return errors
+
+    if len(compatibility) > MAX_COMPATIBILITY_LENGTH:
+        errors.append(
+            f"Compatibility exceeds {MAX_COMPATIBILITY_LENGTH} character limit "
+            f"({len(compatibility)} chars)"
+        )
+
+    return errors
+
+
+def _validate_metadata_fields(metadata: dict) -> list[str]:
+    """Validate that only allowed fields are present."""
+    errors = []
+
+    extra_fields = set(metadata.keys()) - ALLOWED_FIELDS
+    if extra_fields:
+        errors.append(
+            f"Unexpected fields in frontmatter: {', '.join(sorted(extra_fields))}. "
+            f"Only {sorted(ALLOWED_FIELDS)} are allowed."
+        )
+
+    return errors
+
+
+def validate_metadata(metadata: dict, skill_dir: Optional[Path] = None) -> list[str]:
+    """Validate parsed skill metadata.
+
+    This is the core validation function that works on already-parsed metadata,
+    avoiding duplicate file I/O when called from the parser.
+
+    Args:
+        metadata: Parsed YAML frontmatter dictionary
+        skill_dir: Optional path to skill directory (for name-directory match check)
+
+    Returns:
+        List of validation error messages. Empty list means valid.
+    """
+    errors = []
+    errors.extend(_validate_metadata_fields(metadata))
+
+    if "name" not in metadata:
+        errors.append("Missing required field in frontmatter: name")
+    else:
+        errors.extend(_validate_name(metadata["name"], skill_dir))
+
+    if "description" not in metadata:
+        errors.append("Missing required field in frontmatter: description")
+    else:
+        errors.extend(_validate_description(metadata["description"]))
+
+    if "compatibility" in metadata:
+        errors.extend(_validate_compatibility(metadata["compatibility"]))
+
+    return errors
+
+
+def validate(skill_dir: Path) -> list[str]:
+    """Validate a skill directory.
+
+    Args:
+        skill_dir: Path to the skill directory
+
+    Returns:
+        List of validation error messages. Empty list means valid.
+    """
+    skill_dir = Path(skill_dir)
+
+    if not skill_dir.exists():
+        return [f"Path does not exist: {skill_dir}"]
+
+    if not skill_dir.is_dir():
+        return [f"Not a directory: {skill_dir}"]
+
+    skill_md = find_skill_md(skill_dir)
+    if skill_md is None:
+        return ["Missing required file: SKILL.md"]
+
+    try:
+        content = skill_md.read_text()
+        metadata, _ = parse_frontmatter(content)
+    except ParseError as e:
+        return [str(e)]
+
+    return validate_metadata(metadata, skill_dir)

llms/extensions/system_prompts/ui/index.mjs

@@ -163,7 +163,7 @@ const SystemPromptEditor = {
                 </div>
             </div>
             <div v-if="hasMessages" class="w-full rounded-md border border-gray-300 dark:border-gray-600 bg-white dark:bg-gray-900 text-gray-900 dark:text-gray-100 px-3 py-2 text-sm">
-                {{$threads.currentThread.value?.systemPrompt || 'No System Prompt was used' }}
+                <TextViewer prefsName="systemPrompt" :text="$threads.getCurrentThreadSystemPrompt() || 'No System Prompt was used'" />
             </div>
             <div v-else>
                 <textarea
@@ -251,21 +251,17 @@ export default {
             }
         })
 
-        ctx.chatRequestFilters.push(({ request, thread }) => {
+        ctx.chatRequestFilters.push(({ request, thread, context }) => {
 
-            const hasSystemPrompt = request.messages.find(x => x.role === 'system')
+            const hasSystemPrompt = !!context.systemPrompt
+            console.log('system_prompts chatRequestFilters', hasSystemPrompt)
             if (hasSystemPrompt) {
                 console.log('Already has system prompt', hasSystemPrompt.content)
                 return
             }
 
-            // Only add the selected system prompt for new requests
-            if (ext.prefs.systemPrompt && request.messages.length <= 1) {
-                // add message to start
-                request.messages.unshift({
-                    role: 'system',
-                    content: ext.prefs.systemPrompt
-                })
+            if (ext.prefs.systemPrompt) {
+                context.systemPrompt = ext.prefs.systemPrompt
             }
         })