monomind 1.10.57 → 1.11.0

package/packages/@monomind/cli/dist/src/commands/appliance.js

@@ -1,406 +0,0 @@
-/**
- * CLI Appliance Command
- * Self-contained RVFA appliance management (build, inspect, verify, extract, run, sign, publish, update)
- */
-import { output } from '../output.js';
-import { signCommand, publishCommand, updateAppCommand } from './appliance-advanced.js';
-function fmtSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    if (bytes < 1024 * 1024 * 1024)
-        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
-function errMsg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-const fail = (msg, detail) => {
-    output.printError(msg, detail);
-    return { success: false, exitCode: 1 };
-};
-async function loadModule(path, exportName, label) {
-    try {
-        const mod = await import(path);
-        return mod[exportName];
-    }
-    catch {
-        output.printError(`RVFA ${label} module not found`, 'Install with: npm install @monoes/appliance');
-        return null;
-    }
-}
-async function requireFile(file) {
-    const fs = await import('fs');
-    if (!fs.existsSync(file)) {
-        output.printError(`File not found: ${file}`);
-        return false;
-    }
-    return true;
-}
-function header(title) {
-    output.writeln();
-    output.writeln(output.bold(title));
-    output.writeln(output.dim('─'.repeat(50)));
-    output.writeln();
-}
-async function runSteps(steps, delay = 300) {
-    for (const step of steps) {
-        const spinner = output.createSpinner({ text: step + '...', spinner: 'dots' });
-        spinner.start();
-        await new Promise(r => setTimeout(r, delay));
-        spinner.succeed(step);
-    }
-}
-// BUILD
-const buildCommand = {
-    name: 'build',
-    description: 'Build a self-contained monomind.rvf appliance',
-    options: [
-        { name: 'profile', short: 'p', type: 'string', description: 'Build profile: cloud, hybrid, offline', default: 'cloud' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output file path', default: 'monomind.rvf' },
-        { name: 'arch', type: 'string', description: 'Target architecture', default: 'x86_64' },
-        { name: 'models', short: 'm', type: 'array', description: 'Models to include (offline/hybrid)' },
-        { name: 'api-keys', type: 'string', description: 'Path to .env file for API key vault' },
-        { name: 'verbose', short: 'v', type: 'boolean', description: 'Verbose output' },
-    ],
-    action: async (ctx) => {
-        const profile = ctx.flags.profile || 'cloud';
-        const outputPath = ctx.flags.output || 'monomind.rvf';
-        const arch = ctx.flags.arch || 'x86_64';
-        const models = ctx.flags.models || [];
-        const apiKeysPath = ctx.flags['api-keys'];
-        header('RVFA Appliance Builder');
-        output.printInfo(`Profile:  ${output.highlight(profile)}`);
-        output.printInfo(`Arch:     ${arch}`);
-        output.printInfo(`Output:   ${outputPath}`);
-        if (models.length > 0)
-            output.printInfo(`Models:   ${models.join(', ')}`);
-        output.writeln();
-        const startTime = Date.now();
-        const RvfaBuilder = await loadModule('../appliance/rvfa-builder.js', 'RvfaBuilder', 'builder');
-        if (!RvfaBuilder)
-            return { success: false, exitCode: 1 };
-        const steps = [
-            'Collecting kernel artifacts', 'Bundling runtime environment',
-            'Packaging monomind CLI + MCP tools', 'Compressing sections',
-            'Computing SHA-256 checksums', 'Writing RVFA container',
-        ];
-        if (profile !== 'cloud' && models.length > 0)
-            steps.splice(3, 0, 'Embedding model weights');
-        if (apiKeysPath)
-            steps.splice(steps.length - 1, 0, 'Sealing API key vault');
-        try {
-            const builder = new RvfaBuilder({ profile, outputPath, arch, models, apiKeysPath });
-            await runSteps(steps);
-            const result = await builder.build();
-            const duration = ((Date.now() - startTime) / 1000).toFixed(1);
-            if (result.sections?.length) {
-                output.writeln();
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'Section', width: 16 },
-                        { key: 'size', header: 'Size', width: 12, align: 'right' },
-                    ],
-                    data: result.sections.map(s => ({ id: s.id, size: fmtSize(s.size) })),
-                });
-            }
-            output.writeln();
-            output.printSuccess(`Appliance written to ${output.bold(outputPath)}`);
-            output.printInfo(`Total size: ${output.bold(fmtSize(result.totalSize))}  Duration: ${duration}s`);
-            return { success: true, data: result };
-        }
-        catch (err) {
-            return fail('Build failed', errMsg(err));
-        }
-    },
-};
-// INSPECT
-const inspectCommand = {
-    name: 'inspect',
-    description: 'Show RVFA appliance header and section manifest',
-    options: [
-        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
-        { name: 'json', type: 'boolean', description: 'Output as JSON' },
-    ],
-    action: async (ctx) => {
-        const file = ctx.flags.file;
-        if (!file)
-            return fail('--file is required');
-        const RvfaReader = await loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format');
-        if (!RvfaReader)
-            return { success: false, exitCode: 1 };
-        if (!(await requireFile(file)))
-            return { success: false, exitCode: 1 };
-        try {
-            const reader = new RvfaReader(file);
-            const hdr = await reader.parse();
-            if (ctx.flags.json) {
-                output.printJson(hdr);
-                return { success: true, data: hdr };
-            }
-            header('RVFA Appliance');
-            for (const [label, value] of [
-                ['Name', hdr.name || 'monomind'], ['Version', hdr.version || 'unknown'],
-                ['Architecture', hdr.arch || 'x86_64'], ['Profile', hdr.profile || 'cloud'],
-                ['Created', hdr.created || 'unknown'],
-            ]) {
-                output.writeln(`  ${output.bold(label.padEnd(16))}${value}`);
-            }
-            output.writeln();
-            output.writeln(output.bold('Sections'));
-            output.writeln(output.dim('─'.repeat(60)));
-            if (hdr.sections?.length) {
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'Section', width: 14 },
-                        { key: 'size', header: 'Packed', width: 12, align: 'right' },
-                        { key: 'original', header: 'Original', width: 12, align: 'right' },
-                        { key: 'compression', header: 'Compression', width: 12 },
-                        { key: 'sha256', header: 'SHA-256', width: 18 },
-                    ],
-                    data: hdr.sections.map((s) => ({
-                        id: s.id,
-                        size: fmtSize(s.size),
-                        original: fmtSize(s.originalSize ?? s.size),
-                        compression: s.compression || 'none',
-                        sha256: s.sha256 ? s.sha256.slice(0, 16) + '..' : output.dim('n/a'),
-                    })),
-                });
-            }
-            else {
-                output.writeln(output.dim('  No sections found'));
-            }
-            const fs = await import('fs');
-            const stat = fs.statSync(file);
-            output.writeln();
-            output.printInfo(`Total file size: ${output.bold(fmtSize(stat.size))}`);
-            if (hdr.footerHash) {
-                output.printInfo(`Footer hash:     ${output.dim(hdr.footerHash.slice(0, 32) + '..')}`);
-            }
-            return { success: true, data: hdr };
-        }
-        catch (err) {
-            return fail('Failed to inspect appliance', errMsg(err));
-        }
-    },
-};
-// VERIFY
-const verifyCommand = {
-    name: 'verify',
-    description: 'Verify appliance integrity and run capability tests',
-    options: [
-        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
-        { name: 'quick', short: 'q', type: 'boolean', description: 'Quick check (integrity only, skip capability tests)' },
-    ],
-    action: async (ctx) => {
-        const file = ctx.flags.file;
-        const quick = ctx.flags.quick;
-        if (!file)
-            return fail('--file is required');
-        const RvfaReader = await loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format');
-        if (!RvfaReader)
-            return { success: false, exitCode: 1 };
-        if (!(await requireFile(file)))
-            return { success: false, exitCode: 1 };
-        try {
-            header('RVFA Verification');
-            const reader = new RvfaReader(file);
-            const hdr = await reader.parse();
-            // Section checksums
-            const s1 = output.createSpinner({ text: 'Verifying section checksums...', spinner: 'dots' });
-            s1.start();
-            const checksums = await reader.verifyChecksums();
-            const allValid = checksums.every(r => r.valid);
-            if (allValid) {
-                s1.succeed(`Section checksums: ${output.success('PASS')} (${checksums.length} sections)`);
-            }
-            else {
-                const bad = checksums.filter(r => !r.valid);
-                s1.fail(`Section checksums: ${output.error('FAIL')} (${bad.length} corrupted)`);
-                bad.forEach(f => output.writeln(`  ${output.error('X')} ${f.section}`));
-            }
-            // Footer hash
-            const s2 = output.createSpinner({ text: 'Verifying footer hash...', spinner: 'dots' });
-            s2.start();
-            const footerOk = await reader.verifyFooter();
-            footerOk ? s2.succeed(`Footer hash: ${output.success('PASS')}`)
-                : s2.fail(`Footer hash: ${output.error('FAIL')}`);
-            // Capability tests
-            let capOk = true;
-            if (!quick && hdr.sections?.find((s) => s.id === 'verify')) {
-                const s3 = output.createSpinner({ text: 'Running capability tests...', spinner: 'dots' });
-                s3.start();
-                await new Promise(r => setTimeout(r, 500));
-                s3.succeed(`Capability tests: ${output.success('PASS')}`);
-            }
-            else if (quick) {
-                output.writeln(output.dim('  Skipped capability tests (--quick)'));
-            }
-            output.writeln();
-            const pass = allValid && footerOk && capOk;
-            pass ? output.printSuccess('Appliance verification passed')
-                : output.printError('Appliance verification failed');
-            return { success: pass, exitCode: pass ? 0 : 1 };
-        }
-        catch (err) {
-            return fail('Verification failed', errMsg(err));
-        }
-    },
-};
-// EXTRACT
-const extractCommand = {
-    name: 'extract',
-    description: 'Extract all sections from an RVFA appliance',
-    options: [
-        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
-        { name: 'output', short: 'o', type: 'string', description: 'Output directory', default: './rvfa-extracted' },
-        { name: 'section', short: 's', type: 'string', description: 'Extract specific section only' },
-    ],
-    action: async (ctx) => {
-        const file = ctx.flags.file;
-        const outputDir = ctx.flags.output || './rvfa-extracted';
-        const sectionFilter = ctx.flags.section;
-        if (!file)
-            return fail('--file is required');
-        const RvfaReader = await loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format');
-        if (!RvfaReader)
-            return { success: false, exitCode: 1 };
-        if (!(await requireFile(file)))
-            return { success: false, exitCode: 1 };
-        try {
-            const fs = await import('fs');
-            const path = await import('path');
-            header('RVFA Extraction');
-            const reader = new RvfaReader(file);
-            const hdr = await reader.parse();
-            const dest = path.resolve(outputDir);
-            if (!fs.existsSync(dest))
-                fs.mkdirSync(dest, { recursive: true });
-            output.printInfo(`Destination: ${dest}`);
-            output.writeln();
-            if (sectionFilter) {
-                if (!hdr.sections?.find((s) => s.id === sectionFilter)) {
-                    output.printError(`Section not found: ${sectionFilter}`);
-                    output.printInfo(`Available: ${(hdr.sections || []).map((s) => s.id).join(', ')}`);
-                    return { success: false, exitCode: 1 };
-                }
-                const sp = output.createSpinner({ text: `Extracting ${sectionFilter}...`, spinner: 'dots' });
-                sp.start();
-                const r = await reader.extractSection(sectionFilter, dest);
-                sp.succeed(`${sectionFilter}: ${fmtSize(r.size)}`);
-            }
-            else {
-                const results = await reader.extractAll(dest);
-                for (const r of results) {
-                    output.printSuccess(`${r.id.padEnd(14)} ${fmtSize(r.size).padStart(10)}  -> ${r.path}`);
-                }
-            }
-            output.writeln();
-            output.printSuccess(`Extraction complete: ${dest}`);
-            output.writeln(output.dim('  Directory structure:'));
-            for (const d of ['kernel', 'runtime', 'monomind', 'models', 'data', 'verify']) {
-                const exists = fs.existsSync(path.join(dest, d));
-                output.writeln(`  ${exists ? output.success('+') : output.dim('-')} ${d}/`);
-            }
-            return { success: true };
-        }
-        catch (err) {
-            return fail('Extraction failed', errMsg(err));
-        }
-    },
-};
-// RUN
-const runCommand = {
-    name: 'run',
-    description: 'Boot and run an RVFA appliance',
-    options: [
-        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
-        { name: 'mode', type: 'string', description: 'Run mode: cli, mcp, verify', default: 'cli' },
-        { name: 'isolation', type: 'string', description: 'Isolation: container, native', default: 'native' },
-    ],
-    action: async (ctx) => {
-        const file = ctx.flags.file;
-        const mode = ctx.flags.mode || 'cli';
-        const isolation = ctx.flags.isolation || 'native';
-        if (!file)
-            return fail('--file is required');
-        const RvfaRunner = await loadModule('../appliance/rvfa-runner.js', 'RvfaRunner', 'runner');
-        if (!RvfaRunner)
-            return { success: false, exitCode: 1 };
-        if (!(await requireFile(file)))
-            return { success: false, exitCode: 1 };
-        try {
-            header('RVFA Appliance Boot');
-            output.printInfo(`File:      ${file}`);
-            output.printInfo(`Mode:      ${mode}`);
-            output.printInfo(`Isolation: ${isolation}`);
-            output.writeln();
-            await runSteps([
-                'Loading RVFA container', 'Verifying integrity', 'Extracting kernel',
-                'Initializing runtime', `Starting ${mode} interface`,
-            ], 250);
-            output.writeln();
-            const runner = new RvfaRunner({ file, mode, isolation });
-            const result = await runner.boot();
-            if (mode === 'mcp' && result.port)
-                output.printSuccess(`MCP server listening on port ${result.port}`);
-            else if (mode === 'verify')
-                output.printSuccess('Verification complete');
-            else
-                output.printSuccess('Appliance is running');
-            if (result.pid)
-                output.printInfo(`PID: ${result.pid}`);
-            return { success: true, data: result };
-        }
-        catch (err) {
-            return fail('Boot failed', errMsg(err));
-        }
-    },
-};
-// Main command
-export const applianceCommand = {
-    name: 'appliance',
-    description: 'Self-contained RVFA appliance management (build, inspect, verify, extract, run)',
-    aliases: ['rvfa'],
-    subcommands: [buildCommand, inspectCommand, verifyCommand, extractCommand, runCommand, signCommand, publishCommand, updateAppCommand],
-    examples: [
-        { command: 'monomind appliance build -p cloud', description: 'Build a cloud appliance' },
-        { command: 'monomind appliance inspect -f monomind.rvf', description: 'Inspect appliance contents' },
-        { command: 'monomind appliance verify -f monomind.rvf', description: 'Verify integrity' },
-        { command: 'monomind appliance extract -f monomind.rvf', description: 'Extract sections' },
-        { command: 'monomind appliance run -f monomind.rvf', description: 'Boot and run appliance' },
-        { command: 'monomind appliance sign -f monomind.rvf --generate-keys', description: 'Generate keys and sign' },
-        { command: 'monomind appliance publish -f monomind.rvf', description: 'Publish to IPFS via Pinata' },
-        { command: 'monomind appliance update -f monomind.rvf -s monomind -d ./new-monomind.bin', description: 'Hot-patch a section' },
-    ],
-    action: async () => {
-        output.writeln();
-        output.writeln(output.bold('Monomind Appliance (RVFA)'));
-        output.writeln(output.dim('Self-contained deployment format for the full Monomind platform.'));
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            'build     - Build a self-contained monomind.rvf appliance',
-            'inspect   - Show appliance header and section manifest',
-            'verify    - Verify appliance integrity and run capability tests',
-            'extract   - Extract all sections from an appliance',
-            'run       - Boot and run an RVFA appliance',
-            'sign      - Sign an appliance with Ed25519 for tamper detection',
-            'publish   - Publish an appliance to IPFS via Pinata',
-            'update    - Hot-patch a section in an appliance',
-        ]);
-        output.writeln();
-        output.writeln('Profiles:');
-        output.printList([
-            `${output.bold('cloud')}    - API-only, smallest footprint (~15 MB)`,
-            `${output.bold('hybrid')}   - API + local fallback models (~500 MB)`,
-            `${output.bold('offline')}  - Fully air-gapped with bundled models (~4 GB)`,
-        ]);
-        output.writeln();
-        output.writeln(output.dim('Use "monomind appliance <subcommand> --help" for details.'));
-        return { success: true };
-    },
-};
-export default applianceCommand;
-//# sourceMappingURL=appliance.js.map

package/packages/@monomind/cli/dist/src/commands/ruvector/backup.d.ts

@@ -1,11 +0,0 @@
-/**
- * CLI RuVector Backup Command
- * Backup and restore for RuVector PostgreSQL data
- */
-import type { Command } from '../../types.js';
-/**
- * RuVector backup main command
- */
-export declare const backupCommand: Command;
-export default backupCommand;
-//# sourceMappingURL=backup.d.ts.map

package/packages/@monomind/cli/dist/src/commands/ruvector/benchmark.d.ts

@@ -1,11 +0,0 @@
-/**
- * CLI RuVector Benchmark Command
- * Performance benchmarking for RuVector PostgreSQL Bridge
- */
-import type { Command } from '../../types.js';
-/**
- * RuVector benchmark command
- */
-export declare const benchmarkCommand: Command;
-export default benchmarkCommand;
-//# sourceMappingURL=benchmark.d.ts.map

package/packages/@monomind/cli/dist/src/commands/ruvector/import.d.ts

@@ -1,18 +0,0 @@
-/**
- * CLI RuVector Import Command
- * Import data from sql.js/JSON memory to RuVector PostgreSQL
- *
- * Usage:
- *   npx monomind ruvector import --input memory-export.json
- *   npx monomind ruvector import --from-memory
- *   npx monomind ruvector import --input data.json --batch-size 100
- *
- * https://github.com/nokhodian/monomind
- */
-import type { Command } from '../../types.js';
-/**
- * RuVector Import command - import from sql.js/JSON to PostgreSQL
- */
-export declare const importCommand: Command;
-export default importCommand;
-//# sourceMappingURL=import.d.ts.map

package/packages/@monomind/cli/dist/src/commands/ruvector/init.d.ts

@@ -1,11 +0,0 @@
-/**
- * CLI RuVector Init Command
- * Initialize RuVector PostgreSQL Bridge
- */
-import type { Command } from '../../types.js';
-/**
- * Initialize RuVector in PostgreSQL
- */
-export declare const initCommand: Command;
-export default initCommand;
-//# sourceMappingURL=init.d.ts.map

package/packages/@monomind/cli/dist/src/commands/ruvector/migrate.d.ts

@@ -1,11 +0,0 @@
-/**
- * CLI RuVector Migrate Command
- * Database migration management for RuVector
- */
-import type { Command } from '../../types.js';
-/**
- * RuVector migrate command
- */
-export declare const migrateCommand: Command;
-export default migrateCommand;
-//# sourceMappingURL=migrate.d.ts.map

package/packages/@monomind/cli/dist/src/commands/ruvector/setup.d.ts

@@ -1,18 +0,0 @@
-/**
- * CLI RuVector Setup Command
- * Outputs Docker files and SQL for easy RuVector PostgreSQL setup
- *
- * Usage:
- *   npx monomind ruvector setup              # Output to ./ruvector-postgres/
- *   npx monomind ruvector setup --output /path/to/dir
- *   npx monomind ruvector setup --print      # Print to stdout only
- *
- * https://github.com/nokhodian/monomind
- */
-import type { Command } from '../../types.js';
-/**
- * RuVector Setup command - outputs Docker files and SQL
- */
-export declare const setupCommand: Command;
-export default setupCommand;
-//# sourceMappingURL=setup.d.ts.map

package/packages/@monomind/cli/dist/src/ruvector/agent-wasm.d.ts

@@ -1,182 +0,0 @@
-/**
- * RuVector Agent WASM Integration
- *
- * Wraps @ruvector/rvagent-wasm for sandboxed AI agent execution.
- * Provides WasmAgent lifecycle, gallery templates, RVF container building,
- * and MCP server bridge — all running in WASM without OS access.
- *
- * Published API (v0.1.0): WasmAgent, WasmGallery, WasmMcpServer,
- * WasmRvfBuilder, JsModelProvider, initSync.
- *
- * @module @monomind/cli/ruvector/agent-wasm
- */
-export interface WasmAgentConfig {
-    model?: string;
-    instructions?: string;
-    maxTurns?: number;
-}
-export interface WasmAgentInfo {
-    id: string;
-    state: 'idle' | 'running' | 'error';
-    config: WasmAgentConfig;
-    model: string;
-    turnCount: number;
-    fileCount: number;
-    isStopped: boolean;
-    createdAt: string;
-}
-export interface GalleryTemplate {
-    id: string;
-    name: string;
-    description: string;
-    category: string;
-    tags: string[];
-    version: string;
-    author: string;
-    builtin: boolean;
-}
-export interface GalleryTemplateDetail extends GalleryTemplate {
-    tools: Array<{
-        name: string;
-        description: string;
-        parameters: unknown[];
-        returns: string;
-    }>;
-    prompts: Array<{
-        name: string;
-        system_prompt: string;
-        version: string;
-    }>;
-    skills: Array<{
-        name: string;
-        description: string;
-        trigger: string;
-        content: string;
-    }>;
-    mcp_tools: Array<{
-        name: string;
-        description: string;
-        input_schema: unknown;
-        group: string;
-    }>;
-    capabilities: Array<{
-        name: string;
-        rights: string[];
-        scope: string;
-        delegation_depth: number;
-    }>;
-}
-export interface ToolResult {
-    success: boolean;
-    output: string;
-}
-/**
- * Check if @ruvector/rvagent-wasm is installed and loadable.
- */
-export declare function isAgentWasmAvailable(): Promise<boolean>;
-/**
- * Initialize the WASM module for Node.js. Safe to call multiple times.
- * Uses initSync with file-loaded WASM bytes (browser fetch doesn't work in Node).
- */
-export declare function initAgentWasm(): Promise<void>;
-/**
- * Create a new sandboxed WASM agent.
- */
-export declare function createWasmAgent(config?: WasmAgentConfig): Promise<WasmAgentInfo>;
-/**
- * Send a prompt to a WASM agent. Requires a model provider to be set.
- */
-export declare function promptWasmAgent(agentId: string, input: string): Promise<string>;
-export declare function executeWasmTool(agentId: string, toolCall: Record<string, unknown>): Promise<ToolResult>;
-/**
- * Get agent info.
- */
-export declare function getWasmAgent(agentId: string): WasmAgentInfo | null;
-/**
- * List all active WASM agents.
- */
-export declare function listWasmAgents(): WasmAgentInfo[];
-/**
- * Terminate a WASM agent and free resources.
- */
-export declare function terminateWasmAgent(agentId: string): boolean;
-/**
- * Get agent state (messages, turn count, etc.)
- */
-export declare function getWasmAgentState(agentId: string): unknown;
-/**
- * Get agent tools list.
- */
-export declare function getWasmAgentTools(agentId: string): string[];
-/**
- * Get agent todos.
- */
-export declare function getWasmAgentTodos(agentId: string): unknown[];
-/**
- * Export the full agent state as JSON (for persistence).
- */
-export declare function exportWasmState(agentId: string): string;
-/**
- * Create a WASM-based MCP server for an agent.
- * Returns a handler function for JSON-RPC requests.
- *
- * Note: WasmMcpServer may have stability issues in v0.1.0 for
- * certain agent configurations. Use with a fully configured agent.
- */
-export declare function createWasmMcpServer(agentId: string): Promise<(jsonRpc: string) => Promise<string>>;
-/**
- * List all available gallery templates.
- * Returns objects directly (Gallery.list() returns parsed objects in v0.1.0).
- */
-export declare function listGalleryTemplates(): Promise<GalleryTemplate[]>;
-/**
- * Get gallery template count.
- */
-export declare function getGalleryCount(): Promise<number>;
-/**
- * Get gallery categories with counts.
- */
-export declare function getGalleryCategories(): Promise<Record<string, number>>;
-/**
- * Search gallery templates by query. Returns results with relevance scores.
- */
-export declare function searchGalleryTemplates(query: string): Promise<Array<GalleryTemplate & {
-    relevance: number;
-}>>;
-/**
- * Get a gallery template by id.
- * Wraps in try/catch because WasmGallery.get() panics on unknown IDs in v0.1.0.
- */
-export declare function getGalleryTemplate(id: string): Promise<GalleryTemplateDetail | null>;
-/**
- * Create an agent from a gallery template.
- */
-export declare function createAgentFromTemplate(templateId: string): Promise<WasmAgentInfo>;
-/**
- * Build an RVF container with prompts, tools, and skills.
- * Uses the high-level RVF builder API (addPrompt, addTool, addSkill).
- */
-export declare function buildRvfContainer(opts: {
-    prompts?: Array<{
-        name: string;
-        system_prompt: string;
-        version: string;
-    }>;
-    tools?: Array<{
-        name: string;
-        description: string;
-        parameters: unknown[];
-        returns: string;
-    }>;
-    skills?: Array<{
-        name: string;
-        description: string;
-        trigger: string;
-        content: string;
-    }>;
-}): Promise<Uint8Array>;
-/**
- * Build an RVF container from a gallery template.
- */
-export declare function buildRvfFromTemplate(templateId: string): Promise<Uint8Array>;
-//# sourceMappingURL=agent-wasm.d.ts.map