synthos 0.8.0 → 0.9.0

package/src/files.ts

@@ -72,3 +72,60 @@ export async function copyFolderRecursive(srcFolder: string, destFolder: string)
 export async function deleteFolder(dirPath: string): Promise<void> {
     await fs.rm(dirPath, { recursive: true });
 }
+
+// --- Multi-folder helpers ---
+
+/**
+ * Search folders in order, return the full path to the first existing match
+ * for the given filename.
+ */
+export async function findFileInFolders(folders: string[], filename: string): Promise<string | undefined> {
+    for (const folder of folders) {
+        const candidate = path.join(folder, filename);
+        if (await checkIfExists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+
+/**
+ * Merge file listings from multiple folders. First folder takes priority on
+ * name collisions (earlier occurrence wins).
+ */
+export async function listFilesFromFolders(folders: string[]): Promise<string[]> {
+    const seen = new Set<string>();
+    const result: string[] = [];
+    for (const folder of folders) {
+        if (!await checkIfExists(folder)) continue;
+        const files = await listFiles(folder);
+        for (const f of files) {
+            if (!seen.has(f)) {
+                seen.add(f);
+                result.push(f);
+            }
+        }
+    }
+    return result;
+}
+
+/**
+ * Copy files from multiple source folders into a single destination.
+ * First folder takes priority on duplicate filenames (copy is skipped
+ * if the file already exists in dest from an earlier folder).
+ */
+export async function copyFilesFromFolders(folders: string[], destFolder: string): Promise<void> {
+    await ensureFolderExists(destFolder);
+    const copied = new Set<string>();
+    for (const folder of folders) {
+        if (!await checkIfExists(folder)) continue;
+        const files = await fs.readdir(folder);
+        for (const file of files) {
+            if (copied.has(file)) continue;
+            copied.add(file);
+            const srcPath = path.join(folder, file);
+            const destPath = path.join(destFolder, file);
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}

package/src/index.ts

@@ -3,4 +3,5 @@ export * from './files';
 export * from './init';
 export * from './pages';
 export * from './scripts';
-export * from './settings';
+export * from './settings';
+export * from './customizer';

package/src/init.ts

@@ -1,29 +1,67 @@
 import * as fs from 'fs/promises';
 import path from "path";
-import { checkIfExists, copyFile, copyFiles, deleteFile, ensureFolderExists, listFiles, saveFile } from "./files";
-import { PAGE_VERSION } from "./pages";
+import { checkIfExists, copyFile, copyFolderRecursive, deleteFile, ensureFolderExists, findFileInFolders, listFiles, listFolders, saveFile } from "./files";
+import { PAGE_VERSION, getRequiredPages } from "./pages";
 import { DefaultSettings } from "./settings";
-import { getOutdatedThemes, parseThemeFilename } from "./themes";
+import { Customizer } from './customizer';
 
 export interface SynthOSConfig {
+    localFolder: string;
     pagesFolder: string;
-    requiredPagesFolder: string;
-    defaultPagesFolder: string;
-    defaultScriptsFolder: string;
-    defaultThemesFolder: string;
-    pageScriptsFolder: string;
+    requiredPagesFolders: string[];
+    defaultPagesFolders: string[];
+    defaultScriptsFolders: string[];
+    defaultThemesFolders: string[];
+    staticFilesFolders: string[];
+    serviceConnectorsFolders: string[];
+    requiredPages: string[];
     debug: boolean;
     debugPageUpdates: boolean;
 }
 
-export function createConfig(pagesFolder = '.synthos', options?: { debug?: boolean; debugPageUpdates?: boolean }): SynthOSConfig {
+/**
+ * Resolve a folder array from a Customizer getter: replace the `'default'`
+ * sentinel with the built-in SynthOS path.
+ */
+function resolveFolders(folders: string[], builtInPath: string): string[] {
+    return folders.map(f => f === 'default' ? builtInPath : f);
+}
+
+export async function createConfig(
+    pagesFolder = '.synthos',
+    options?: { debug?: boolean; debugPageUpdates?: boolean },
+    customizer?: Customizer
+): Promise<SynthOSConfig> {
+    const requiredPagesFolders = resolveFolders(
+        customizer?.requiredPagesFolders ?? ['default'],
+        path.join(__dirname, '../required-pages')
+    );
+    const requiredPages = await getRequiredPages(requiredPagesFolders);
     return {
+        localFolder: pagesFolder,
         pagesFolder: path.join(process.cwd(), pagesFolder),
-        requiredPagesFolder: path.join(__dirname, '../required-pages'),
-        defaultPagesFolder: path.join(__dirname, '../default-pages'),
-        defaultScriptsFolder: path.join(__dirname, '../default-scripts'),
-        defaultThemesFolder: path.join(__dirname, '../default-themes'),
-        pageScriptsFolder: path.join(__dirname, '../page-scripts'),
+        requiredPagesFolders,
+        defaultPagesFolders: resolveFolders(
+            customizer?.defaultPagesFolders ?? ['default'],
+            path.join(__dirname, '../default-pages')
+        ),
+        defaultScriptsFolders: resolveFolders(
+            customizer?.defaultScriptsFolders ?? ['default'],
+            path.join(__dirname, '../default-scripts')
+        ),
+        defaultThemesFolders: resolveFolders(
+            customizer?.defaultThemesFolders ?? ['default'],
+            path.join(__dirname, '../default-themes')
+        ),
+        staticFilesFolders: resolveFolders(
+            customizer?.staticFilesFolders ?? ['default'],
+            path.join(__dirname, '../static-files')
+        ),
+        serviceConnectorsFolders: resolveFolders(
+            customizer?.serviceConnectorsFolders ?? ['default'],
+            path.join(__dirname, '../service-connectors')
+        ),
+        requiredPages,
         debug: options?.debug ?? false,
         debugPageUpdates: options?.debugPageUpdates ?? false
     };
@@ -36,7 +74,7 @@ export async function init(config: SynthOSConfig, includeDefaultPages: boolean =
         return false;
     }
 
-    console.log(`Initializing .synthos folder...`);
+    console.log(`Initializing ${config.localFolder} folder...`);
 
     // Create pages folder
     await ensureFolderExists(config.pagesFolder);
@@ -47,37 +85,29 @@ export async function init(config: SynthOSConfig, includeDefaultPages: boolean =
     await saveFile(path.join(config.pagesFolder, 'settings.json.example'), JSON.stringify(DefaultSettings, null, 4));
 
     // Setup default scripts
-    console.log(`Copying default scripts to .synthos folder...`);
+    console.log(`Copying default scripts to ${config.localFolder} folder...`);
     const scriptsFolder = path.join(config.pagesFolder, 'scripts');
     await ensureFolderExists(scriptsFolder);
-    switch (process.platform) {
-        case 'win32':
-            await copyFile(path.join(config.defaultScriptsFolder, 'windows-terminal.json'), scriptsFolder);
-            break;
-        case 'darwin':
-            await copyFile(path.join(config.defaultScriptsFolder, 'mac-terminal.json'), scriptsFolder);
-            break;
-        case 'android':
-            await copyFile(path.join(config.defaultScriptsFolder, 'android-terminal.json'), scriptsFolder);
-            break;
-        case 'linux':
-        default:
-            await copyFile(path.join(config.defaultScriptsFolder, 'linux-terminal.json'), scriptsFolder);
-            break;
-    }  
-
-    await saveFile(path.join(scriptsFolder, 'example.sh'), '#!/bin/bash\n\n# This is an example script\n\n# You can run this script using the following command:\n# sh .synthos/scripts/example.sh\n\n# This script will print "Hello, World!" to the console\n\necho "Hello, World!"\n');
-
-    // Setup default themes
-    console.log(`Copying default themes to .synthos folder...`);
-    const themesFolder = path.join(config.pagesFolder, 'themes');
-    await ensureFolderExists(themesFolder);
-    await copyFiles(config.defaultThemesFolder, themesFolder);
+    const scriptFilename = ({
+        win32: 'windows-terminal.json',
+        darwin: 'mac-terminal.json',
+        android: 'android-terminal.json',
+    } as Record<string, string>)[process.platform] ?? 'linux-terminal.json';
+    const scriptSrc = await findFileInFolders(config.defaultScriptsFolders, scriptFilename);
+    if (scriptSrc) {
+        await copyFile(scriptSrc, scriptsFolder);
+    }
+
+    await saveFile(path.join(scriptsFolder, 'example.sh'), `#!/bin/bash\n\n# This is an example script\n\n# You can run this script using the following command:\n# sh ${config.localFolder}/scripts/example.sh\n\n# This script will print "Hello, World!" to the console\n\necho "Hello, World!"\n`);
+
+    // Create empty themes folder — default themes are served directly from
+    // defaultThemesFolders; users can add custom themes here.
+    await ensureFolderExists(path.join(config.pagesFolder, 'themes'));
 
     // Copy pages
     if (includeDefaultPages) {
-        console.log(`Copying default pages to .synthos folder...`);
-        await copyDefaultPages(config.defaultPagesFolder, config.pagesFolder);
+        console.log(`Copying default pages to ${config.localFolder} folder...`);
+        await copyDefaultPages(config.defaultPagesFolders, config.pagesFolder);
     }
 
     return true;
@@ -87,57 +117,23 @@ async function repairMissingFolders(config: SynthOSConfig): Promise<void> {
     // Rebuild scripts folder from defaults if missing
     const scriptsFolder = path.join(config.pagesFolder, 'scripts');
     if (!await checkIfExists(scriptsFolder)) {
-        console.log(`Restoring default scripts to .synthos folder...`);
+        console.log(`Restoring default scripts to ${config.localFolder} folder...`);
         await ensureFolderExists(scriptsFolder);
-        switch (process.platform) {
-            case 'win32':
-                await copyFile(path.join(config.defaultScriptsFolder, 'windows-terminal.json'), scriptsFolder);
-                break;
-            case 'darwin':
-                await copyFile(path.join(config.defaultScriptsFolder, 'mac-terminal.json'), scriptsFolder);
-                break;
-            case 'android':
-                await copyFile(path.join(config.defaultScriptsFolder, 'android-terminal.json'), scriptsFolder);
-                break;
-            case 'linux':
-            default:
-                await copyFile(path.join(config.defaultScriptsFolder, 'linux-terminal.json'), scriptsFolder);
-                break;
+        const scriptFilename = ({
+            win32: 'windows-terminal.json',
+            darwin: 'mac-terminal.json',
+            android: 'android-terminal.json',
+        } as Record<string, string>)[process.platform] ?? 'linux-terminal.json';
+        const scriptSrc = await findFileInFolders(config.defaultScriptsFolders, scriptFilename);
+        if (scriptSrc) {
+            await copyFile(scriptSrc, scriptsFolder);
         }
-        await saveFile(path.join(scriptsFolder, 'example.sh'), '#!/bin/bash\n\n# This is an example script\n\n# You can run this script using the following command:\n# sh .synthos/scripts/example.sh\n\n# This script will print "Hello, World!" to the console\n\necho "Hello, World!"\n');
+        await saveFile(path.join(scriptsFolder, 'example.sh'), `#!/bin/bash\n\n# This is an example script\n\n# You can run this script using the following command:\n# sh ${config.localFolder}/scripts/example.sh\n\n# This script will print "Hello, World!" to the console\n\necho "Hello, World!"\n`);
     }
 
-    // Rebuild themes folder from defaults if missing
-    const themesFolder = path.join(config.pagesFolder, 'themes');
-    if (!await checkIfExists(themesFolder)) {
-        console.log(`Restoring default themes to .synthos folder...`);
-        await ensureFolderExists(themesFolder);
-        await copyFiles(config.defaultThemesFolder, themesFolder);
-    } else {
-        // Upgrade outdated themes — copy newer versioned CSS from defaults
-        const outdated = await getOutdatedThemes(config);
-        if (outdated.length > 0) {
-            console.log(`Upgrading ${outdated.length} theme(s): ${outdated.join(', ')}...`);
-            const defaultFiles = await listFiles(config.defaultThemesFolder);
-            for (const themeName of outdated) {
-                // Remove old versioned CSS files for this theme
-                const localFiles = await listFiles(themesFolder);
-                for (const f of localFiles) {
-                    const parsed = parseThemeFilename(f);
-                    if (parsed && parsed.name === themeName) {
-                        await deleteFile(path.join(themesFolder, f));
-                    }
-                }
-                // Copy the new versioned CSS from defaults
-                for (const f of defaultFiles) {
-                    const parsed = parseThemeFilename(f);
-                    if (parsed && parsed.name === themeName) {
-                        await copyFile(path.join(config.defaultThemesFolder, f), themesFolder);
-                    }
-                }
-            }
-        }
-    }
+    // Ensure themes folder exists — default themes are served directly from
+    // defaultThemesFolders; this folder is for user-added custom themes only.
+    await ensureFolderExists(path.join(config.pagesFolder, 'themes'));
 
     // Ensure pages/ subfolder exists
     const pagesSubdir = path.join(config.pagesFolder, 'pages');
@@ -145,15 +141,15 @@ async function repairMissingFolders(config: SynthOSConfig): Promise<void> {
         // No pages folder and no flat files — rebuild from defaults
         const htmlFiles = (await listFiles(config.pagesFolder)).filter(f => f.endsWith('.html'));
         if (htmlFiles.length === 0) {
-            console.log(`Restoring default pages to .synthos/pages/ folder...`);
-            await copyDefaultPages(config.defaultPagesFolder, config.pagesFolder);
+            console.log(`Restoring default pages to ${config.localFolder}/pages/ folder...`);
+            await copyDefaultPages(config.defaultPagesFolders, config.pagesFolder);
         } else {
             await ensureFolderExists(pagesSubdir);
         }
     }
 
     // Migrate any stray flat .html files from root into pages/<name>/
-    await migrateFlatPages(config.pagesFolder);
+    await migrateFlatPages(config.pagesFolder, config.localFolder);
 }
 
 function toTitleCase(name: string): string {
@@ -164,12 +160,12 @@ function toTitleCase(name: string): string {
         .replace(/\b\w/g, c => c.toUpperCase());
 }
 
-async function migrateFlatPages(pagesFolder: string): Promise<void> {
+async function migrateFlatPages(pagesFolder: string, localFolder: string): Promise<void> {
     const pagesSubdir = path.join(pagesFolder, 'pages');
     const htmlFiles = (await listFiles(pagesFolder)).filter(f => f.endsWith('.html'));
     if (htmlFiles.length === 0) return;
 
-    console.log(`Migrating ${htmlFiles.length} page(s) to .synthos/pages/ folder...`);
+    console.log(`Migrating ${htmlFiles.length} page(s) to ${localFolder}/pages/ folder...`);
     await ensureFolderExists(pagesSubdir);
     const now = new Date().toISOString();
 
@@ -200,40 +196,58 @@ async function migrateFlatPages(pagesFolder: string): Promise<void> {
     }
 }
 
-async function copyDefaultPages(srcFolder: string, destFolder: string): Promise<void> {
+async function copyDefaultPages(srcFolders: string[], destFolder: string): Promise<void> {
     const pagesDir = path.join(destFolder, 'pages');
     await ensureFolderExists(pagesDir);
-    const files = await fs.readdir(srcFolder);
     const now = new Date().toISOString();
-    for (const file of files) {
-        if (!file.endsWith('.html')) continue;
-        const pageName = file.replace(/\.html$/, '');
-        const pageFolder = path.join(pagesDir, pageName);
-        await ensureFolderExists(pageFolder);
-        await fs.copyFile(path.join(srcFolder, file), path.join(pageFolder, 'page.html'));
-
-        // Read companion .json metadata from source folder, fall back to defaults
-        let metadata: Record<string, unknown> = {};
-        const jsonPath = path.join(srcFolder, `${pageName}.json`);
-        if (await checkIfExists(jsonPath)) {
-            try {
-                const raw = await fs.readFile(jsonPath, 'utf-8');
-                metadata = JSON.parse(raw);
-            } catch {
-                // use defaults
+    const seen = new Set<string>();
+
+    for (const srcFolder of srcFolders) {
+        if (!await checkIfExists(srcFolder)) continue;
+        const dirs = await listFolders(srcFolder);
+        for (const dir of dirs) {
+            const srcPageDir = path.join(srcFolder, dir);
+            if (!await checkIfExists(path.join(srcPageDir, 'page.html'))) continue;
+            if (seen.has(dir)) continue; // first folder wins
+            seen.add(dir);
+
+            const pageFolder = path.join(pagesDir, dir);
+            await ensureFolderExists(pageFolder);
+            await fs.copyFile(path.join(srcPageDir, 'page.html'), path.join(pageFolder, 'page.html'));
+
+            // Read companion page.json metadata from source folder, fall back to defaults
+            let metadata: Record<string, unknown> = {};
+            const jsonPath = path.join(srcPageDir, 'page.json');
+            if (await checkIfExists(jsonPath)) {
+                try {
+                    const raw = await fs.readFile(jsonPath, 'utf-8');
+                    metadata = JSON.parse(raw);
+                } catch {
+                    // use defaults
+                }
+            }
+            const fullMetadata = {
+                title: typeof metadata.title === 'string' ? metadata.title : '',
+                categories: Array.isArray(metadata.categories) ? metadata.categories : [],
+                pinned: typeof metadata.pinned === 'boolean' ? metadata.pinned : false,
+                showInAll: typeof metadata.showInAll === 'boolean' ? metadata.showInAll : true,
+                createdDate: now,
+                lastModified: now,
+                pageVersion: typeof metadata.pageVersion === 'number' ? metadata.pageVersion
+                    : typeof metadata.uxVersion === 'number' ? metadata.uxVersion : PAGE_VERSION,
+                mode: metadata.mode === 'locked' ? 'locked' : 'unlocked',
+            };
+            await saveFile(path.join(pageFolder, 'page.json'), JSON.stringify(fullMetadata, null, 4));
+
+            // Copy data subfolders (anything that isn't page.html/page.json)
+            const subEntries = await fs.readdir(srcPageDir, { withFileTypes: true });
+            for (const entry of subEntries) {
+                if (!entry.isDirectory()) continue;
+                await copyFolderRecursive(
+                    path.join(srcPageDir, entry.name),
+                    path.join(pageFolder, entry.name)
+                );
             }
         }
-        const fullMetadata = {
-            title: typeof metadata.title === 'string' ? metadata.title : '',
-            categories: Array.isArray(metadata.categories) ? metadata.categories : [],
-            pinned: typeof metadata.pinned === 'boolean' ? metadata.pinned : false,
-            showInAll: typeof metadata.showInAll === 'boolean' ? metadata.showInAll : true,
-            createdDate: now,
-            lastModified: now,
-            pageVersion: typeof metadata.pageVersion === 'number' ? metadata.pageVersion
-                : typeof metadata.uxVersion === 'number' ? metadata.uxVersion : PAGE_VERSION,
-            mode: metadata.mode === 'locked' ? 'locked' : 'unlocked',
-        };
-        await saveFile(path.join(pageFolder, 'page.json'), JSON.stringify(fullMetadata, null, 4));
     }
 }

package/src/migrations.ts

@@ -10,6 +10,7 @@ import { deduplicateInlineScripts } from './service/transformPage';
  */
 const migrations: Record<number, (html: string, completePrompt: completePrompt) => Promise<string>> = {
     1: migrateV1toV2,
+    2: migrateV2toV3,
 };
 
 /**
@@ -36,7 +37,6 @@ const SHARED_CSS_SELECTORS = [
     '.chat-panel', '.chat-header', '.chat-messages',
     '.chat-message', '.chat-message p', '.chat-message p strong', '.chat-message p code',
     '.chat-message strong', '.chat-message pre', '.chat-message code', '.chat-message a',
-    '.link-group', '.link-group a', '.link-group a:hover',
     'form',
     '.chat-input', '.chat-input:focus', '.chat-input::placeholder', '.chat-input:disabled',
     '.chat-submit', '.chat-submit:hover', '.chat-submit:active', '.chat-submit:disabled',
@@ -80,14 +80,8 @@ const DEFAULT_CHAT_PANEL = `
         <div class="chat-messages" id="chatMessages">
             <div class="chat-message"><p>Welcome! How can I help you?</p></div>
         </div>
-        <div class="link-group">
-            <a href="#" id="saveLink">Save</a>
-            <a href="/pages" id="pagesLink">Pages</a>
-            <a href="#" id="resetLink">Reset</a>
-        </div>
         <form action="/" method="POST" id="chatForm">
-            <input type="text" class="chat-input" id="chatInput" name="message" placeholder="Type a message...">
-            <button type="submit" class="chat-submit">Send</button>
+            <textarea class="chat-input" id="chatInput" name="message" rows="2" placeholder="Type a message..."></textarea>
         </form>
     </div>`;
 
@@ -125,6 +119,33 @@ async function migrateV1toV2(html: string, completePrompt: completePrompt): Prom
     return migrated;
 }
 
+/**
+ * v2 -> v3: Cheerio-based migration (no LLM).
+ * - Removes .link-group div
+ * - Converts chat <input> to <textarea>
+ * - Removes .chat-submit button (v3 creates it dynamically)
+ */
+async function migrateV2toV3(html: string, _completePrompt: completePrompt): Promise<string> {
+    const $ = cheerio.load(html, { decodeEntities: false });
+
+    // 1. Remove .link-group div and its children
+    $('.link-group').remove();
+
+    // 2. Replace <input type="text" id="chatInput" ...> with <textarea>
+    const chatInput = $('input#chatInput, input.chat-input');
+    if (chatInput.length > 0) {
+        chatInput.replaceWith(
+            '<textarea class="chat-input" id="chatInput" name="message" rows="2" placeholder="Type a message..."></textarea>'
+        );
+    }
+
+    // 3. Remove .chat-submit button inside #chatForm (or anywhere)
+    $('button.chat-submit').remove();
+
+    // Run through postProcessV2 to ensure structural integrity
+    return postProcessV2($.html());
+}
+
 /**
  * Cheerio-based post-processing to verify the LLM output meets v2 requirements.
  * Uses the original HTML as a fallback source for critical elements.
@@ -146,8 +167,7 @@ export function postProcessV2(html: string, originalHtml?: string): string {
                 // Append default form
                 $('.chat-panel').append(`
         <form action="/" method="POST" id="chatForm">
-            <input type="text" class="chat-input" id="chatInput" name="message" placeholder="Type a message...">
-            <button type="submit" class="chat-submit">Send</button>
+            <textarea class="chat-input" id="chatInput" name="message" rows="2" placeholder="Type a message..."></textarea>
         </form>`);
             }
         } else {

package/src/models/anthropic.ts

@@ -1,5 +1,5 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { AgentCompletion, completePrompt, PromptCompletionArgs, RequestError } from './types';
+import { AgentCompletion, completePrompt, PromptCompletionArgs, RequestError, isMultimodalContent } from './types';
 
 export interface AnthropicArgs {
     apiKey: string;
@@ -14,25 +14,44 @@ export interface AnthropicArgs {
  * Pure function — no SDK dependency.
  */
 export function buildAnthropicRequest(args: PromptCompletionArgs, defaultTemp: number): {
-    messages: { role: string; content: string }[];
-    system: string | undefined;
+    messages: { role: string; content: string | Anthropic.ContentBlockParam[] }[];
+    system: string | Anthropic.TextBlockParam[] | undefined;
     temperature: number;
+    outputConfig?: Anthropic.OutputConfig;
 } {
     const reqTemp = args.temperature ?? defaultTemp;
 
-    const messages: { role: string; content: string }[] = [];
+    const messages: { role: string; content: string | Anthropic.ContentBlockParam[] }[] = [];
     if (args.history) {
         for (const msg of args.history) {
             messages.push({ role: msg.role, content: msg.content });
         }
     }
 
-    const useJsonPrefill = args.jsonMode || args.jsonSchema;
+    // Build user content — multimodal when ContentBlock[] is provided
+    const promptContent = args.prompt.content;
+    let userContent: string | Anthropic.ContentBlockParam[];
+    if (isMultimodalContent(promptContent)) {
+        userContent = promptContent.map(block => {
+            if (block.type === 'text') {
+                return { type: 'text' as const, text: block.text };
+            }
+            return {
+                type: 'image' as const,
+                source: { type: 'base64' as const, media_type: block.mediaType as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp', data: block.data },
+            };
+        });
+    } else {
+        userContent = promptContent;
+    }
+
+    // Structured output via output_config is incompatible with prefilling
+    const useJsonPrefill = !args.outputSchema && (args.jsonMode || args.jsonSchema);
     if (useJsonPrefill) {
-        messages.push({ role: 'user', content: args.prompt.content });
+        messages.push({ role: 'user', content: userContent });
         messages.push({ role: 'assistant', content: '{' });
     } else {
-        messages.push({ role: 'user', content: args.prompt.content });
+        messages.push({ role: 'user', content: userContent });
     }
 
     let system = args.system?.content;
@@ -41,7 +60,17 @@ export function buildAnthropicRequest(args: PromptCompletionArgs, defaultTemp: n
         system = system ? system + schemaInstruction : schemaInstruction;
     }
 
-    return { messages, system, temperature: reqTemp };
+    // Wrap system content with cache_control for prompt caching
+    const finalSystem: string | Anthropic.TextBlockParam[] | undefined = (system && args.cacheSystem)
+        ? [{ type: 'text' as const, text: system, cache_control: { type: 'ephemeral' as const } }]
+        : system;
+
+    // Structured output config for constrained decoding
+    const outputConfig: Anthropic.OutputConfig | undefined = args.outputSchema
+        ? { format: { type: 'json_schema', schema: args.outputSchema } }
+        : undefined;
+
+    return { messages, system: finalSystem, temperature: reqTemp, outputConfig };
 }
 
 export function anthropic(args: AnthropicArgs): completePrompt {
@@ -50,9 +79,9 @@ export function anthropic(args: AnthropicArgs): completePrompt {
     const client = new Anthropic({ apiKey, baseURL, maxRetries });
 
     return async (completionArgs: PromptCompletionArgs): Promise<AgentCompletion<string>> => {
-        const { messages, system: systemContent, temperature: reqTemp } = buildAnthropicRequest(completionArgs, temperature);
+        const { messages, system: systemContent, temperature: reqTemp, outputConfig } = buildAnthropicRequest(completionArgs, temperature);
 
-        const useJsonPrefill = completionArgs.jsonMode || completionArgs.jsonSchema;
+        const useJsonPrefill = !completionArgs.outputSchema && (completionArgs.jsonMode || completionArgs.jsonSchema);
 
         try {
             const stream = await client.messages.create({
@@ -62,6 +91,7 @@ export function anthropic(args: AnthropicArgs): completePrompt {
                 system: systemContent,
                 messages: messages as Anthropic.MessageParam[],
                 stream: true,
+                ...(outputConfig && { output_config: outputConfig }),
             });
 
             let text = '';

package/src/models/fireworksai.ts

@@ -1,5 +1,5 @@
 import OpenAI from 'openai';
-import { AgentCompletion, completePrompt, PromptCompletionArgs, RequestError } from './types';
+import { AgentCompletion, completePrompt, PromptCompletionArgs, RequestError, isMultimodalContent } from './types';
 
 export interface FireworksAIArgs {
     apiKey: string;
@@ -83,7 +83,14 @@ export function buildFireworksRequest(args: PromptCompletionArgs, defaultTemp: n
         }
     }
 
-    let userContent = args.prompt.content;
+    // Strip images — FireworksAI has no vision support; keep text only
+    const promptContent = args.prompt.content;
+    let userContent: string;
+    if (isMultimodalContent(promptContent)) {
+        userContent = promptContent.filter(b => b.type === 'text').map(b => (b as { text: string }).text).join('\n');
+    } else {
+        userContent = promptContent;
+    }
     if (useJson) {
         userContent += '\n\nRespond with valid JSON only. No markdown fences.';
     }

package/src/models/index.ts

@@ -1,4 +1,4 @@
-export { ProviderName, ProviderConfig, ModelEntry, Provider, SystemMessage, UserMessage, Message, AgentCompletion, completePrompt, PromptCompletionArgs, AgentArgs, RequestError } from './types';
+export { ProviderName, ProviderConfig, ModelEntry, Provider, SystemMessage, UserMessage, Message, AgentCompletion, completePrompt, PromptCompletionArgs, AgentArgs, RequestError, TextBlock, ImageBlock, ContentBlock, MessageContent, isMultimodalContent } from './types';
 export { AnthropicProvider, OpenAIProvider, PROVIDERS, getProvider, detectProvider } from './providers';
 export { anthropic, AnthropicArgs, buildAnthropicRequest } from './anthropic';
 export { openai, OpenaiArgs, buildOpenAIRequest } from './openai';