@swizzy_ai/kit 1.0.0

package/dist/index.js

@@ -0,0 +1,1451 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var zod = require('zod');
+var fs = require('fs');
+var path = require('path');
+var http = require('http');
+var WebSocket = require('ws');
+var openai = require('@ai-sdk/openai');
+var anthropic = require('@ai-sdk/anthropic');
+var google = require('@ai-sdk/google');
+var xai = require('@ai-sdk/xai');
+var ai = require('ai');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var http__namespace = /*#__PURE__*/_interopNamespaceDefault(http);
+var WebSocket__namespace = /*#__PURE__*/_interopNamespaceDefault(WebSocket);
+
+class Step {
+    constructor(config) {
+        this.id = config.id;
+        this.instruction = config.instruction;
+        this.schema = config.schema;
+        this.update = config.update;
+        this.contextFunction = config.contextFunction;
+        this.contextType = config.contextType || 'xml'; // Default to xml
+        this.beforeRun = config.beforeRun;
+        this.afterRun = config.afterRun;
+        this.model = config.model;
+    }
+    validate(data) {
+        const result = this.schema.safeParse(data);
+        if (!result.success) {
+            throw new Error(`Step "${this.id}" validation failed: ${result.error.message}`);
+        }
+        return result.data;
+    }
+    getContext(workflowContext) {
+        return this.contextFunction ? this.contextFunction(workflowContext) : workflowContext;
+    }
+}
+
+class TextStep extends Step {
+    constructor(config) {
+        // Create a dummy schema for string
+        const dummySchema = zod.z.string();
+        super({
+            ...config,
+            schema: dummySchema,
+        });
+    }
+    validate(data) {
+        // For text steps, just return the data as string
+        return typeof data === 'string' ? data : String(data);
+    }
+}
+
+class ComputeStep extends Step {
+    constructor(config) {
+        // Use a permissive schema that accepts any data
+        const permissiveSchema = zod.z.any();
+        super({
+            ...config,
+            schema: permissiveSchema,
+            model: '', // No model needed for compute steps
+        });
+        this.isComputeStep = true;
+    }
+    validate(data) {
+        // For compute steps, accept any data without validation
+        return data;
+    }
+}
+
+exports.Models = void 0;
+(function (Models) {
+    Models["GPT4"] = "gpt-4";
+    Models["GPT35_TURBO"] = "gpt-3.5-turbo";
+    Models["CLAUDE3_SONNET"] = "claude-3-sonnet-20240229";
+    Models["CLAUDE3_HAIKU"] = "claude-3-haiku-20240307";
+    Models["GEMINI_PRO"] = "gemini-pro";
+    Models["GEMINI_PRO_VISION"] = "gemini-pro-vision";
+    Models["GROK_BETA"] = "grok-beta";
+    Models["SWIZZY_DEFAULT"] = "swizzy-default";
+})(exports.Models || (exports.Models = {}));
+class Model {
+    constructor(modelEnum) {
+        this.model = modelEnum;
+        this.provider = this.getProviderFromModel(modelEnum);
+    }
+    getProviderFromModel(model) {
+        switch (model) {
+            case exports.Models.GPT4:
+            case exports.Models.GPT35_TURBO:
+                return 'openai';
+            case exports.Models.CLAUDE3_SONNET:
+            case exports.Models.CLAUDE3_HAIKU:
+                return 'anthropic';
+            case exports.Models.GEMINI_PRO:
+            case exports.Models.GEMINI_PRO_VISION:
+                return 'google';
+            case exports.Models.GROK_BETA:
+                return 'grok';
+            case exports.Models.SWIZZY_DEFAULT:
+                return 'swizzy';
+            default:
+                console.error("Unknown error defaulting to SWIZZY");
+                return 'swizzy';
+        }
+    }
+}
+
+class BaseProvider {
+}
+class SwizzyProvider extends BaseProvider {
+    constructor(config) {
+        super();
+        const baseURL = config.baseURL || process.env.SWIZZY_BASE_URL || 'https://swizzy-kit.hello-ad4.workers.dev';
+        const apiKey = config.apiKey || process.env.SWIZZY_API_KEY;
+        if (!apiKey) {
+            throw new Error('SWIZZY_API_KEY is required. Set it via environment variable SWIZZY_API_KEY or pass apiKey directly.');
+        }
+        this.config = { baseURL, apiKey };
+    }
+    async complete(options) {
+        const endpoint = options.stream ? '/completions/stream' : '/completions';
+        const response = await fetch(`${this.config.baseURL}${endpoint}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.config.apiKey,
+            },
+            body: JSON.stringify({
+                prompt: options.prompt,
+                max_tokens: options.maxTokens || 1000,
+                temperature: options.temperature || 0.7,
+            }),
+        });
+        if (!response.ok) {
+            let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+            try {
+                const errorData = await response.json();
+                errorMessage = errorData.error || errorData.message || errorMessage;
+            }
+            catch (e) {
+                const text = await response.text().catch(() => '');
+                if (text)
+                    errorMessage = text;
+            }
+            throw new Error(`LLM API error: ${errorMessage}`);
+        }
+        if (options.stream) {
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new Error('No response body for streaming');
+            let fullText = '';
+            const decoder = new TextDecoder();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = decoder.decode(value);
+                fullText += chunk;
+            }
+            return { text: fullText };
+        }
+        else {
+            const data = await response.json();
+            let transformedUsage;
+            const usageData = data.fullResult?.usage || data.usage;
+            if (usageData) {
+                transformedUsage = {
+                    promptTokens: usageData.prompt_tokens || 0,
+                    completionTokens: usageData.completion_tokens || 0,
+                    totalTokens: usageData.total_tokens || 0
+                };
+            }
+            if (options.onUsage && transformedUsage) {
+                options.onUsage(transformedUsage, this.getProviderName());
+            }
+            return {
+                text: data.completion,
+                usage: transformedUsage,
+            };
+        }
+    }
+    supportsModel(model) {
+        return model === exports.Models.SWIZZY_DEFAULT;
+    }
+    getProviderName() {
+        return 'swizzy';
+    }
+}
+class MultiProvider extends BaseProvider {
+    constructor() {
+        super();
+        this.openaiKey = process.env.OPENAI_API_KEY;
+        this.anthropicKey = process.env.ANTHROPIC_API_KEY;
+        this.googleKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+        this.xaiKey = process.env.XAI_API_KEY;
+    }
+    async complete(options) {
+        const model = options.model || exports.Models.GPT4;
+        let provider;
+        switch (model) {
+            case exports.Models.GPT4:
+            case exports.Models.GPT35_TURBO:
+                if (!this.openaiKey)
+                    throw new Error('OpenAI API key not available');
+                provider = openai.openai(model);
+                break;
+            case exports.Models.CLAUDE3_SONNET:
+            case exports.Models.CLAUDE3_HAIKU:
+                if (!this.anthropicKey)
+                    throw new Error('Anthropic API key not available');
+                provider = anthropic.anthropic(model);
+                break;
+            case exports.Models.GEMINI_PRO:
+            case exports.Models.GEMINI_PRO_VISION:
+                if (!this.googleKey)
+                    throw new Error('Google API key not available');
+                provider = google.google(model);
+                break;
+            case exports.Models.GROK_BETA:
+                if (!this.xaiKey)
+                    throw new Error('xAI API key not available');
+                provider = xai.xai(model);
+                break;
+            default:
+                throw new Error(`Unsupported model: ${model}`);
+        }
+        const result = await ai.generateText({
+            model: provider,
+            prompt: options.prompt,
+            maxTokens: options.maxTokens,
+            temperature: options.temperature,
+        });
+        const usage = {
+            promptTokens: result.usage.promptTokens,
+            completionTokens: result.usage.completionTokens,
+            totalTokens: result.usage.totalTokens,
+        };
+        if (options.onUsage) {
+            options.onUsage(usage, this.getProviderName());
+        }
+        return {
+            text: result.text,
+            usage,
+        };
+    }
+    supportsModel(model) {
+        const m = model;
+        switch (m) {
+            case exports.Models.GPT4:
+            case exports.Models.GPT35_TURBO:
+                return !!this.openaiKey;
+            case exports.Models.CLAUDE3_SONNET:
+            case exports.Models.CLAUDE3_HAIKU:
+                return !!this.anthropicKey;
+            case exports.Models.GEMINI_PRO:
+            case exports.Models.GEMINI_PRO_VISION:
+                return !!this.googleKey;
+            case exports.Models.GROK_BETA:
+                return !!this.xaiKey;
+            default:
+                return false;
+        }
+    }
+    getProviderName() {
+        return 'multi';
+    }
+}
+
+class ProviderRegistry {
+    constructor() {
+        this.providers = new Map();
+        this.registerDefaultProviders();
+    }
+    registerDefaultProviders() {
+        const hasAnyMultiKey = !!(process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.XAI_API_KEY);
+        if (hasAnyMultiKey) {
+            this.providers.set('multi', new MultiProvider());
+        }
+        if (process.env.SWIZZY_API_KEY) {
+            this.providers.set('swizzy', new SwizzyProvider({ apiKey: process.env.SWIZZY_API_KEY }));
+        }
+    }
+    registerProvider(name, provider) {
+        this.providers.set(name, provider);
+    }
+    getProviderForModel(model) {
+        for (const provider of this.providers.values()) {
+            if (provider.supportsModel(model)) {
+                return provider;
+            }
+        }
+        throw new Error(`No provider registered for model: ${model}`);
+    }
+    getAllProviders() {
+        return Array.from(this.providers.values());
+    }
+    hasProviderForModel(model) {
+        try {
+            this.getProviderForModel(model);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+class LLMClient {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async complete(options) {
+        const model = options.model;
+        if (!model) {
+            throw new Error('Model must be specified in CompletionOptions');
+        }
+        const provider = this.registry.getProviderForModel(model);
+        return provider.complete(options);
+    }
+}
+
+class BungeeBuilder {
+    constructor(currentStepId) {
+        /**
+         * Add a single step execution.
+         */
+        this.add = (stepId) => {
+            this._plan.destinations.push({ type: 'step', targetId: stepId });
+            return this;
+        };
+        /**
+         * Add multiple executions based on count with config function.
+         */
+        this.batch = (stepId, count, configFn) => {
+            for (let i = 0; i < count; i++) {
+                this._plan.destinations.push({ type: 'step', targetId: stepId });
+            }
+            this._plan.configFn = configFn;
+            return this;
+        };
+        /**
+         * Configure execution settings.
+         */
+        this.config = (options) => {
+            if (options.concurrency !== undefined) {
+                this._plan.concurrency = options.concurrency;
+            }
+            return this;
+        };
+        /**
+         * Trigger the Jump.
+         */
+        this.jump = () => {
+            return { type: 'BUNGEE_JUMP', plan: this._plan };
+        };
+        this._plan = {
+            id: `bungee_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            anchorId: currentStepId,
+            destinations: [],
+            concurrency: 5
+        };
+    }
+}
+
+class Wizard {
+    constructor(config) {
+        this.steps = [];
+        this.workflowContext = {};
+        // Bungee state tracking
+        this.bungeeWorkers = new Map();
+        this.pendingReentry = new Set();
+        // Performance optimizations
+        this.stepIndexMap = new Map();
+        this.schemaDescriptions = new Map();
+        this.maxCacheSize = 100;
+        this.connectedClients = new Set();
+        this.maxWebSocketConnections = 10;
+        this.wsIntervals = new WeakMap();
+        // WebSocket messages sent immediately for real-time UI updates
+        // Token tracking
+        this.totalTokens = 0;
+        this.stepTokens = 0;
+        this.currentStepIndex = 0;
+        this.isPaused = false;
+        this.isRunning = false;
+        this.isStepMode = false;
+        this.id = config.id;
+        const registry = new ProviderRegistry();
+        this.llmClient = new LLMClient(registry);
+        this.systemPrompt = config.systemPrompt;
+        // Set up token tracking
+        if (config.onUsage) {
+            const originalOnUsage = config.onUsage;
+            config.onUsage = (usage, provider) => {
+                this.totalTokens += usage.totalTokens;
+                this.stepTokens = usage.totalTokens; // Last step tokens
+                this.sendToClients({
+                    type: 'token_update',
+                    totalTokens: this.totalTokens,
+                    stepTokens: this.stepTokens
+                });
+                originalOnUsage(usage, provider);
+            };
+        }
+        // Create logs directory if it doesn't exist
+        const logsDir = path__namespace.join(process.cwd(), '.wizard');
+        if (!fs__namespace.existsSync(logsDir)) {
+            fs__namespace.mkdirSync(logsDir, { recursive: true });
+        }
+        this.logFilePath = path__namespace.join(logsDir, `${this.id}.log`);
+    }
+    log(messageOrFn) {
+        if (!this.logFilePath)
+            return; // Early exit if logging disabled
+        const message = typeof messageOrFn === 'function' ? messageOrFn() : messageOrFn;
+        const content = `${new Date().toISOString()}: ${message}\n`;
+        this.appendToFile(content);
+    }
+    appendToFile(content) {
+        if (!this.logFilePath)
+            return;
+        try {
+            fs__namespace.appendFileSync(this.logFilePath, content, 'utf8');
+        }
+        catch (error) {
+            console.log('Wizard log:', content.trim());
+        }
+    }
+    addStep(config) {
+        const step = new Step(config);
+        const index = this.steps.length;
+        this.steps.push(step);
+        this.stepIndexMap.set(step.id, index);
+        return this;
+    }
+    addParallelSteps(callback) {
+        const configs = [];
+        const addStep = (config) => configs.push(config);
+        callback(addStep);
+        const parallelSteps = configs.map(c => new Step(c));
+        const index = this.steps.length;
+        this.steps.push(parallelSteps);
+        // Add all parallel steps to index with same position
+        parallelSteps.forEach(step => this.stepIndexMap.set(step.id, index));
+        return this;
+    }
+    addTextStep(config) {
+        const step = new TextStep(config);
+        const index = this.steps.length;
+        this.steps.push(step);
+        this.stepIndexMap.set(step.id, index);
+        return this;
+    }
+    addComputeStep(config) {
+        const step = new ComputeStep(config);
+        const index = this.steps.length;
+        this.steps.push(step);
+        this.stepIndexMap.set(step.id, index);
+        return this;
+    }
+    goto(stepId) { return `GOTO ${stepId}`; }
+    next() { return 'NEXT'; }
+    stop() { return 'STOP'; }
+    retry() { return 'RETRY'; }
+    wait() { return 'WAIT'; }
+    clearStepError(stepId) {
+        delete this.workflowContext[`${stepId}_error`];
+        delete this.workflowContext[`${stepId}_retryCount`];
+    }
+    isStringSignal(signal) {
+        return typeof signal === 'string';
+    }
+    isBungeeJumpSignal(signal) {
+        return typeof signal === 'object' && signal !== null && signal.type === 'BUNGEE_JUMP';
+    }
+    async executeBungeePlan(plan) {
+        console.log(`🪂 Executing Bungee plan ${plan.id} with ${plan.destinations.length} destinations`);
+        // Track active workers for this plan
+        const activeWorkers = new Set();
+        for (let i = 0; i < plan.destinations.length; i++) {
+            // Launch worker
+            const workerPromise = this.launchBungeeWorker(plan, i);
+            activeWorkers.add(workerPromise);
+            // Respect concurrency limit
+            if (activeWorkers.size >= plan.concurrency) {
+                await Promise.race(activeWorkers);
+                // Clean up completed workers
+                for (const promise of activeWorkers) {
+                    if (promise !== workerPromise) {
+                        activeWorkers.delete(promise);
+                    }
+                }
+            }
+        }
+        // Wait for all workers to complete
+        await Promise.all(activeWorkers);
+        console.log(`✅ Bungee plan ${plan.id} completed, returning to anchor ${plan.anchorId}`);
+    }
+    async launchBungeeWorker(plan, index) {
+        const destination = plan.destinations[index];
+        const telescope = plan.configFn ? plan.configFn(index) : {};
+        const workerId = `${plan.id}_${destination.targetId}_${index}_${Date.now()}`;
+        const telescopeContext = this.createTelescopeContext(this.workflowContext, telescope);
+        const promise = this.executeWorkerStep(destination.targetId, telescopeContext);
+        // Track this worker
+        if (!this.bungeeWorkers.has(plan.id)) {
+            this.bungeeWorkers.set(plan.id, new Map());
+        }
+        this.bungeeWorkers.get(plan.id).set(workerId, {
+            planId: plan.id,
+            workerId,
+            promise,
+            telescope
+        });
+        try {
+            await promise;
+        }
+        catch (error) {
+            console.error(`Bungee worker ${workerId} failed:`, error);
+            this.workflowContext[`${workerId}_error`] = error.message;
+        }
+        finally {
+            // Clean up
+            const planWorkers = this.bungeeWorkers.get(plan.id);
+            if (planWorkers) {
+                planWorkers.delete(workerId);
+                if (planWorkers.size === 0) {
+                    this.bungeeWorkers.delete(plan.id);
+                    // Trigger reentry to anchor
+                    this.pendingReentry.add(plan.anchorId);
+                }
+            }
+        }
+    }
+    createWizardActions(anchorStepId = '') {
+        return {
+            updateContext: (updates) => this.updateContext(updates),
+            llmClient: this.llmClient,
+            goto: (stepId) => this.goto(stepId),
+            next: () => this.next(),
+            stop: () => this.stop(),
+            retry: () => this.retry(),
+            wait: () => this.wait(),
+            bungee: {
+                init: () => new BungeeBuilder(anchorStepId)
+            }
+        };
+    }
+    createWorkerActions(telescope) {
+        return {
+            updateContext: (updates) => {
+                this.mergeWorkerResults(updates, telescope);
+            },
+            llmClient: this.llmClient,
+            goto: () => 'STOP',
+            next: () => 'STOP',
+            stop: () => 'STOP',
+            retry: () => 'STOP',
+            wait: () => 'STOP',
+            bungee: {
+                init: () => {
+                    throw new Error('Bungee not allowed in worker context');
+                }
+            }
+        };
+    }
+    createTelescopeContext(baseContext, telescope) {
+        return {
+            ...baseContext,
+            ...telescope,
+            _telescope: telescope,
+            _anchorId: null
+        };
+    }
+    async executeWorkerStep(stepId, telescopeContext) {
+        const step = this.findStep(stepId);
+        if (!step)
+            return;
+        const stepContext = step.getContext(telescopeContext);
+        const stepData = await this.generateStepData(step, stepContext);
+        const actions = this.createWorkerActions(telescopeContext._telescope);
+        return await step.update(stepData, telescopeContext, actions);
+    }
+    mergeWorkerResults(updates, telescope) {
+        Object.entries(updates).forEach(([key, value]) => {
+            this.workflowContext[key] = value;
+        });
+    }
+    async retriggerAnchor(anchorId) {
+        const anchorStep = this.findStep(anchorId);
+        if (anchorStep) {
+            await this.executeStep(anchorStep);
+        }
+    }
+    async processReentries() {
+        const anchorsToRetrigger = Array.from(this.pendingReentry);
+        this.pendingReentry.clear();
+        for (const anchorId of anchorsToRetrigger) {
+            await this.retriggerAnchor(anchorId);
+        }
+    }
+    findStep(stepId) {
+        for (const item of this.steps) {
+            if (Array.isArray(item)) {
+                const found = item.find(s => s.id === stepId);
+                if (found)
+                    return found;
+            }
+            else {
+                if (item.id === stepId)
+                    return item;
+            }
+        }
+        return null;
+    }
+    findStepIndex(stepId) {
+        return this.stepIndexMap.get(stepId) ?? -1;
+    }
+    async executeStep(step) {
+        console.log(`Starting step ${step.id}`);
+        this.log(`Starting step ${step.id}`);
+        const stepContext = step.getContext(this.workflowContext);
+        let processedInstruction = step.instruction;
+        if (step.contextType === 'template' || step.contextType === 'both') {
+            processedInstruction = this.applyTemplate(step.instruction, stepContext);
+        }
+        this.sendToClients({
+            type: 'step_update',
+            stepId: step.id,
+            status: 'current',
+            instruction: processedInstruction,
+            context: stepContext,
+            fields: this.extractSchemaFields(step.schema)
+        });
+        this.sendToClients({
+            type: 'context_update',
+            context: this.workflowContext
+        });
+        try {
+            if (step.beforeRun) {
+                await step.beforeRun();
+            }
+            this.log(() => `Context for step ${step.id}: ${JSON.stringify(stepContext)}`);
+            // Skip LLM data generation for compute steps
+            const stepData = step.isComputeStep ? null : await this.generateStepData(step, stepContext);
+            if (this.isPaused) {
+                console.log('⏸️ Paused before LLM call, waiting for user input...');
+                await this.waitForResume();
+                console.log('▶️ Resumed, checking for user override...');
+                if (this.userOverrideData) {
+                    console.log('📝 Using user override data');
+                    try {
+                        const validatedData = step.validate(this.userOverrideData);
+                        this.sendToClients({
+                            type: 'step_update',
+                            stepId: step.id,
+                            status: 'completed',
+                            data: validatedData
+                        });
+                        this.userOverrideData = undefined;
+                        return await this.processStepResult(step, validatedData);
+                    }
+                    catch (validationError) {
+                        console.error('User override validation failed:', validationError.message);
+                        this.userOverrideData = undefined;
+                    }
+                }
+            }
+            if (stepData && stepData.__validationFailed) {
+                console.log(`🔄 Validation failed for step ${step.id}, retrying...`, stepData);
+                return 'RETRY';
+            }
+            const actions = this.createWizardActions(step.id);
+            const signal = await step.update(stepData, this.workflowContext, actions);
+            this.sendToClients({
+                type: 'step_update',
+                stepId: step.id,
+                status: 'completed',
+                data: stepData
+            });
+            if (this.workflowContext[`${step.id}_error`]) {
+                this.clearStepError(step.id);
+            }
+            if (step.afterRun) {
+                await step.afterRun(stepData);
+            }
+            return signal;
+        }
+        catch (error) {
+            console.log('Processing error', error);
+            this.updateContext({
+                [`${step.id}_error`]: error.message,
+                [`${step.id}_retryCount`]: (this.workflowContext[`${step.id}_retryCount`] || 0) + 1
+            });
+            return 'RETRY';
+        }
+    }
+    async processStepResult(step, stepData) {
+        const actions = this.createWizardActions(step.id);
+        const signal = await step.update(stepData, this.workflowContext, actions);
+        if (this.workflowContext[`${step.id}_error`]) {
+            this.clearStepError(step.id);
+        }
+        if (step.afterRun) {
+            await step.afterRun(stepData);
+        }
+        return signal;
+    }
+    setContext(context) {
+        this.workflowContext = { ...this.workflowContext, ...context };
+        return this;
+    }
+    getContext() {
+        return this.workflowContext;
+    }
+    updateContext(updates) {
+        this.workflowContext = { ...this.workflowContext, ...updates };
+        return this;
+    }
+    async run() {
+        const startTime = Date.now();
+        if (this.visualizationServer) {
+            console.log('🎯 Waiting for UI to start wizard execution...');
+            this.sendToClients({ type: 'status_update', status: { waitingForStart: true, isStepMode: false } });
+            await this.waitForRunCommand();
+            console.log('🚀 Starting wizard execution from UI command');
+            // Send all steps info
+            const stepsInfo = this.steps.map(item => {
+                if (Array.isArray(item)) {
+                    return item.map(step => ({
+                        id: step.id,
+                        instruction: step.instruction,
+                        fields: this.extractSchemaFields(step.schema),
+                        status: 'pending'
+                    }));
+                }
+                else {
+                    return {
+                        id: item.id,
+                        instruction: item.instruction,
+                        fields: this.extractSchemaFields(item.schema),
+                        status: 'pending'
+                    };
+                }
+            }).flat();
+            this.sendToClients({ type: 'wizard_start', steps: stepsInfo });
+        }
+        this.log('Wizard session started');
+        this.currentStepIndex = 0;
+        this.isRunning = true;
+        while (this.currentStepIndex < this.steps.length && this.isRunning) {
+            const item = this.steps[this.currentStepIndex];
+            if (!item)
+                break;
+            if (Array.isArray(item)) {
+                const parallelSteps = item;
+                console.log(`Starting parallel steps: ${parallelSteps.map(s => s.id).join(', ')}`);
+                this.log(`Starting parallel steps: ${parallelSteps.map(s => s.id).join(', ')}`);
+                const promises = parallelSteps.map(step => this.executeStep(step));
+                const signals = await Promise.all(promises);
+                let nextSignal = 'NEXT';
+                for (const signal of signals) {
+                    if (signal === 'STOP') {
+                        return;
+                    }
+                    if (this.isStringSignal(signal) && signal.startsWith('GOTO ')) {
+                        nextSignal = signal;
+                        break;
+                    }
+                    if (signal === 'RETRY') {
+                        nextSignal = 'RETRY';
+                    }
+                }
+                if (nextSignal === 'NEXT') {
+                    this.currentStepIndex++;
+                }
+                else if (nextSignal === 'RETRY') ;
+                else if (this.isStringSignal(nextSignal) && nextSignal.startsWith('GOTO ')) {
+                    const targetStepId = nextSignal.substring(5);
+                    const targetIndex = this.findStepIndex(targetStepId);
+                    if (targetIndex !== -1) {
+                        this.currentStepIndex = targetIndex;
+                    }
+                    else {
+                        throw new Error(`Unknown step ID for GOTO: ${targetStepId}`);
+                    }
+                }
+            }
+            else {
+                const signal = await this.executeStep(item);
+                switch (signal) {
+                    case 'NEXT':
+                        this.currentStepIndex++;
+                        break;
+                    case 'STOP':
+                        return;
+                    case 'RETRY':
+                        break;
+                    case 'WAIT':
+                        await new Promise(resolve => setTimeout(resolve, 10 * 1000));
+                        this.currentStepIndex++;
+                        break;
+                    default:
+                        if (this.isBungeeJumpSignal(signal)) {
+                            await this.executeBungeePlan(signal.plan);
+                        }
+                        else if (this.isStringSignal(signal) && signal.startsWith('GOTO ')) {
+                            const targetStepId = signal.substring(5);
+                            const targetIndex = this.findStepIndex(targetStepId);
+                            if (targetIndex !== -1) {
+                                this.currentStepIndex = targetIndex;
+                            }
+                            else {
+                                throw new Error(`Unknown step ID for GOTO: ${targetStepId}`);
+                            }
+                        }
+                }
+            }
+            if (this.isStepMode) {
+                this.isPaused = true;
+                await this.waitForResume();
+            }
+            await this.processReentries();
+        }
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        this.isRunning = false;
+        this.sendToClients({ type: 'status_update', status: { completed: true } });
+        console.log(`✅ Wizard completed in ${duration}ms`);
+    }
+    async waitForRunCommand() {
+        return new Promise(resolve => {
+            this.runResolver = resolve;
+        });
+    }
+    async generateStepData(step, stepContext) {
+        const systemContext = this.systemPrompt ? `${this.systemPrompt}\n\n` : '';
+        const errorContext = this.workflowContext[`${step.id}_error`] ?
+            `\n\nPREVIOUS ERROR (attempt ${this.workflowContext[`${step.id}_retryCount`] || 1}):\n${this.workflowContext[`${step.id}_error`]}\nPlease fix this.` : '';
+        let processedInstruction = step.instruction;
+        if (step.contextType === 'template' || step.contextType === 'both') {
+            processedInstruction = this.applyTemplate(step.instruction, stepContext);
+        }
+        this.log(() => `Processed instruction for step ${step.id}: ${processedInstruction}`);
+        let contextSection = '';
+        if (step.contextType === 'xml' || step.contextType === 'both' || !step.contextType) {
+            contextSection = `\n\nSTEP CONTEXT:\n${this.objectToXml(stepContext)}`;
+        }
+        this.log(() => `Context section for step ${step.id}: ${contextSection}`);
+        if (step instanceof TextStep) {
+            const prompt = `${systemContext}You are executing a wizard step. Generate text for this step.
+
+STEP: ${step.id}
+INSTRUCTION: ${processedInstruction}${errorContext}${contextSection}
+
+Generate the text response now.`;
+            this.log(() => `Full prompt for step ${step.id}: ${prompt}`);
+            const llmResult = await this.llmClient.complete({
+                prompt,
+                model: step.model,
+                maxTokens: 1000,
+                temperature: 0.3,
+            });
+            this.log(() => `LLM response for step ${step.id}: ${llmResult.text}`);
+            console.log(`LLM response for step ${step.id}:`, llmResult.text);
+            return llmResult.text;
+        }
+        const schemaDescription = this.describeSchema(step.schema, step.id);
+        const prompt = `${systemContext}You are executing a wizard step. Generate data for this step.
+
+STEP: ${step.id}
+INSTRUCTION: ${processedInstruction}${errorContext}${contextSection}
+
+SCHEMA REQUIREMENTS:
+${schemaDescription}
+
+REQUIRED OUTPUT FORMAT:
+Return a plain XML response with a root <response> tag.
+CRITICAL: Every field MUST include tag-category="wizard" attribute. This is MANDATORY.
+Every field MUST also include a type attribute (e.g., type="string", type="number", type="boolean", type="array").
+
+IMPORTANT PARSING RULES:
+- Fields with tag-category="wizard" do NOT need closing tags
+- Content ends when the next tag with tag-category="wizard" begins, OR when </response> is reached
+- This means you can include ANY content (including code with <>, XML snippets, etc.) without worrying about breaking the parser
+- Only fields marked with tag-category="wizard" will be parsed
+
+Example:
+<response>
+  <name tag-category="wizard" type="string">John Smith
+  <age tag-category="wizard" type="number">25
+  <code tag-category="wizard" type="string">
+    function example() {
+      const x = <div>Hello</div>;
+      return x;
+    }
+  <tags tag-category="wizard" type="array">["a", "b", "c"]
+</response>
+
+Notice: No closing tags needed for wizard fields! Content naturally ends at the next wizard field or </response>.
+
+Generate the XML response now.`;
+        this.log(() => `Full prompt for step ${step.id}: ${prompt}`);
+        const llmResult = await this.llmClient.complete({
+            prompt,
+            model: step.model,
+            maxTokens: 1000,
+            temperature: 0.3,
+        });
+        this.log(() => `LLM response for step ${step.id}: ${llmResult.text}`);
+        console.log(`LLM response for step ${step.id}:`, llmResult.text);
+        const jsonData = this.parseXmlToJson(llmResult.text);
+        this.log(() => `Parsed JSON data for step ${step.id}: ${JSON.stringify(jsonData)}`);
+        try {
+            return step.validate(jsonData);
+        }
+        catch (validationError) {
+            this.log(() => `Validation failed for step ${step.id}: ${validationError.message}`);
+            try {
+                const repairedData = await this.repairSchemaData(jsonData, step.schema, validationError.message, step.id);
+                this.log(() => `Repaired data for step ${step.id}: ${JSON.stringify(repairedData)}`);
+                return step.validate(repairedData);
+            }
+            catch (repairError) {
+                this.log(() => `Repair failed for step ${step.id}: ${repairError.message}`);
+                return { __validationFailed: true, error: validationError.message };
+            }
+        }
+    }
+    async repairSchemaData(invalidData, schema, validationError, stepId) {
+        const step = this.findStep(stepId);
+        if (!step)
+            throw new Error(`Step ${stepId} not found`);
+        const schemaDescription = this.describeSchema(schema, stepId);
+        const prompt = `You are repairing invalid data for a wizard step. The data failed validation and needs to be fixed to match the schema.
+
+INVALID DATA: ${JSON.stringify(invalidData, null, 2)}
+VALIDATION ERROR: ${validationError}
+
+SCHEMA REQUIREMENTS:
+${schemaDescription}
+
+REQUIRED OUTPUT FORMAT:
+Return a plain XML response with a root <response> tag.
+CRITICAL: Every field MUST include tag-category="wizard" attribute. This is MANDATORY.
+Every field MUST also include a type attribute (e.g., type="string", type="number", type="boolean", type="array").
+
+IMPORTANT: Fields with tag-category="wizard" do NOT need closing tags. Content ends at the next wizard field or </response>.
+
+Example:
+<response>
+  <name tag-category="wizard" type="string">John
+  <age tag-category="wizard" type="number">25
+  <tags tag-category="wizard" type="array">["a", "b"]
+</response>
+
+Fix the data to match the schema and generate the XML response now.`;
+        const llmResult = await this.llmClient.complete({
+            prompt,
+            model: step.model,
+            maxTokens: 10000,
+            temperature: 0.3,
+        });
+        const repairedJsonData = this.parseXmlToJson(llmResult.text);
+        return repairedJsonData;
+    }
+    describeSchema(schema, stepId) {
+        if (stepId && this.schemaDescriptions.has(stepId)) {
+            return this.schemaDescriptions.get(stepId);
+        }
+        let description;
+        if (schema instanceof zod.z.ZodObject) {
+            const shape = schema._def.shape();
+            const fields = Object.entries(shape).map(([key, fieldSchema]) => {
+                const type = this.getSchemaType(fieldSchema);
+                const xmlExample = this.getXmlExample(key, type);
+                return `${key}: ${type} - ${xmlExample}`;
+            });
+            description = `Object with fields:\n${fields.join('\n')}`;
+        }
+        else {
+            description = 'Unknown schema type';
+        }
+        if (stepId) {
+            // Implement simple cache eviction if needed
+            if (this.schemaDescriptions.size >= this.maxCacheSize) {
+                const firstKey = this.schemaDescriptions.keys().next().value;
+                this.schemaDescriptions.delete(firstKey || '');
+            }
+            this.schemaDescriptions.set(stepId, description);
+        }
+        return description;
+    }
+    getXmlExample(key, type) {
+        switch (type) {
+            case 'string': return `<${key} tag-category="wizard" type="string">example`;
+            case 'number': return `<${key} tag-category="wizard" type="number">123`;
+            case 'boolean': return `<${key} tag-category="wizard" type="boolean">true`;
+            case 'array': return `<${key} tag-category="wizard" type="array">["item1", "item2"]`;
+            default:
+                if (type.startsWith('enum:')) {
+                    const values = type.split(': ')[1].split(', ');
+                    return `<${key} tag-category="wizard" type="string">${values[0]}`;
+                }
+                return `<${key} tag-category="wizard" type="object"><subfield type="string">value</subfield>`;
+        }
+    }
+    getSchemaType(schema) {
+        if (schema instanceof zod.z.ZodOptional)
+            return this.getSchemaType(schema._def.innerType);
+        if (schema instanceof zod.z.ZodString)
+            return 'string';
+        if (schema instanceof zod.z.ZodNumber)
+            return 'number';
+        if (schema instanceof zod.z.ZodBoolean)
+            return 'boolean';
+        if (schema instanceof zod.z.ZodArray)
+            return 'array';
+        if (schema instanceof zod.z.ZodEnum)
+            return `enum: ${schema._def.values.join(', ')}`;
+        return 'object';
+    }
+    extractSchemaFields(schema) {
+        if (!(schema instanceof zod.z.ZodObject))
+            return [];
+        const shape = schema._def.shape();
+        const fields = [];
+        for (const [key, fieldSchema] of Object.entries(shape)) {
+            const type = this.getSchemaType(fieldSchema);
+            const field = { key, type };
+            if (type.startsWith('enum:')) {
+                field.type = 'enum';
+                field.enumValues = type.substring(5).split(', ');
+            }
+            fields.push(field);
+        }
+        return fields;
+    }
+    parseXmlToJson(xml) {
+        const responseMatch = xml.match(/<response\s*>([\s\S]*?)(?:<\/response\s*>|$)/i);
+        if (!responseMatch) {
+            throw new Error('Invalid XML response: missing <response> tag');
+        }
+        return this.parseXmlElementWithTagCategory(responseMatch[1]);
+    }
+    parseXmlElementWithTagCategory(xmlContent) {
+        const result = {};
+        const matches = [];
+        let match;
+        const pattern = new RegExp(Wizard.WIZARD_TAG_PATTERN);
+        while ((match = pattern.exec(xmlContent)) !== null) {
+            matches.push({
+                tagName: match[1],
+                attributes: match[2],
+                index: match.index,
+                fullMatch: match[0]
+            });
+        }
+        this.log(() => `Found ${matches.length} wizard-tagged fields`);
+        for (let i = 0; i < matches.length; i++) {
+            const current = matches[i];
+            const next = matches[i + 1];
+            const typeMatch = current.attributes.match(/type=["']([^"']+)["']/);
+            const typeHint = typeMatch ? typeMatch[1].toLowerCase() : null;
+            const contentStart = current.index + current.fullMatch.length;
+            let contentEnd;
+            if (next) {
+                contentEnd = next.index;
+            }
+            else {
+                const responseCloseIndex = xmlContent.indexOf('</response', contentStart);
+                contentEnd = responseCloseIndex !== -1 ? responseCloseIndex : xmlContent.length;
+            }
+            let rawContent = xmlContent.slice(contentStart, contentEnd);
+            // Optimize: avoid double trimEnd
+            const trimmed = rawContent.trimEnd();
+            const closingTag = `</${current.tagName}>`;
+            if (trimmed.endsWith(closingTag)) {
+                rawContent = trimmed.slice(0, -closingTag.length);
+            }
+            else {
+                rawContent = trimmed;
+            }
+            this.log(() => `Parsing field "${current.tagName}" with type="${typeHint}"`);
+            this.log(() => `Raw content (first 200 chars): ${rawContent.substring(0, 200)}`);
+            let value;
+            if (typeHint === 'string') {
+                value = rawContent;
+            }
+            else if (typeHint === 'number') {
+                value = this.parseNumber(rawContent.trim());
+            }
+            else if (typeHint === 'boolean') {
+                value = this.parseBoolean(rawContent.trim());
+            }
+            else if (typeHint === 'array') {
+                value = this.parseArray(rawContent.trim());
+            }
+            else if (typeHint === 'object') {
+                value = this.parseXmlElementWithTagCategory(rawContent);
+            }
+            else if (typeHint === 'null') {
+                value = null;
+            }
+            else {
+                value = this.inferAndParseValue(rawContent.trim());
+            }
+            if (result[current.tagName] !== undefined) {
+                if (!Array.isArray(result[current.tagName])) {
+                    result[current.tagName] = [result[current.tagName]];
+                }
+                result[current.tagName].push(value);
+            }
+            else {
+                result[current.tagName] = value;
+            }
+            this.log(() => `Parsed "${current.tagName}" = ${JSON.stringify(value).substring(0, 200)}`);
+        }
+        return result;
+    }
+    parseNumber(value) {
+        const num = Number(value);
+        if (isNaN(num)) {
+            throw new Error(`Invalid number value: "${value}"`);
+        }
+        return num;
+    }
+    parseBoolean(value) {
+        const normalized = value.toLowerCase();
+        if (normalized === 'true')
+            return true;
+        if (normalized === 'false')
+            return false;
+        throw new Error(`Invalid boolean value: "${value}" (expected "true" or "false")`);
+    }
+    parseArray(value) {
+        try {
+            const parsed = JSON.parse(value);
+            if (!Array.isArray(parsed)) {
+                throw new Error('Parsed value is not an array');
+            }
+            return parsed;
+        }
+        catch (error) {
+            throw new Error(`Invalid array JSON: "${value}"`);
+        }
+    }
+    inferAndParseValue(content) {
+        const trimmed = content.trim();
+        if (trimmed === '')
+            return '';
+        if (trimmed === 'null')
+            return null;
+        if (trimmed === 'true')
+            return true;
+        if (trimmed === 'false')
+            return false;
+        if (!isNaN(Number(trimmed)) && trimmed !== '') {
+            return Number(trimmed);
+        }
+        if (/<\w+[^>]*tag-category=["']wizard["']/.test(trimmed)) {
+            return this.parseXmlElementWithTagCategory(trimmed);
+        }
+        if ((trimmed.startsWith('[') && trimmed.endsWith(']')) ||
+            (trimmed.startsWith('{') && trimmed.endsWith('}'))) {
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch {
+                return trimmed;
+            }
+        }
+        return trimmed;
+    }
+    objectToXml(obj, rootName = 'context') {
+        const buildXml = (data, tagName) => {
+            let type = typeof data;
+            if (data === null)
+                type = 'null';
+            else if (Array.isArray(data))
+                type = 'array';
+            const attr = ` type="${type}"`;
+            if (data === null || data === undefined)
+                return `<${tagName}${attr}></${tagName}>`;
+            if (type === 'string')
+                return `<${tagName}${attr}>${this.escapeXml(data)}</${tagName}>`;
+            if (type === 'number' || type === 'boolean')
+                return `<${tagName}${attr}>${data}</${tagName}>`;
+            if (type === 'array')
+                return `<${tagName}${attr}>${JSON.stringify(data)}</${tagName}>`;
+            if (type === 'object') {
+                const children = Object.entries(data).map(([k, v]) => buildXml(v, k)).join('');
+                return `<${tagName}${attr}>${children}</${tagName}>`;
+            }
+            return `<${tagName}${attr}>${String(data)}</${tagName}>`;
+        };
+        return buildXml(obj, rootName);
+    }
+    escapeXml(unsafe) {
+        return unsafe
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    applyTemplate(instruction, context) {
+        return instruction.replace(Wizard.TEMPLATE_REGEX, (match, path) => {
+            const keys = path.split('.');
+            let value = context;
+            for (const key of keys) {
+                if (value && typeof value === 'object' && key in value) {
+                    value = value[key];
+                }
+                else {
+                    return match;
+                }
+            }
+            return typeof value === 'string' ? value : JSON.stringify(value);
+        });
+    }
+    async visualize(port = 3000) {
+        return new Promise((resolve, reject) => {
+            const server = http__namespace.createServer((req, res) => {
+                if (req.url === '/') {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(this.getVisualizationHtml());
+                }
+                else {
+                    res.writeHead(404);
+                    res.end('Not found');
+                }
+            });
+            this.wss = new WebSocket__namespace.Server({ server });
+            this.setupWebSocketHandlers();
+            server.listen(port, 'localhost', () => {
+                this.visualizationPort = port;
+                this.visualizationServer = server;
+                const url = `http://localhost:${port}`;
+                console.log(`🎯 Wizard visualization available at: ${url}`);
+                resolve({ server, url });
+            });
+            server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    this.visualize(port + 1).then(resolve).catch(reject);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    setupWebSocketHandlers() {
+        if (!this.wss)
+            return;
+        this.wss.on('connection', (ws) => {
+            if (this.connectedClients.size >= this.maxWebSocketConnections) {
+                console.log('🔗 WebSocket connection rejected: max connections reached');
+                ws.close(1008, 'Max connections reached');
+                return;
+            }
+            console.log('🔗 WebSocket client connected');
+            this.connectedClients.add(ws);
+            const pingInterval = setInterval(() => {
+                if (ws.readyState === WebSocket__namespace.OPEN) {
+                    ws.ping();
+                }
+                else {
+                    clearInterval(pingInterval);
+                }
+            }, 30000);
+            this.wsIntervals.set(ws, pingInterval);
+            ws.on('message', (message) => {
+                try {
+                    const data = JSON.parse(message.toString());
+                    this.handleWebSocketMessage(data, ws);
+                }
+                catch (error) {
+                    console.error('Invalid WebSocket message:', error);
+                }
+            });
+            ws.on('close', () => {
+                console.log('🔌 WebSocket client disconnected');
+                this.connectedClients.delete(ws);
+                const interval = this.wsIntervals.get(ws);
+                if (interval) {
+                    clearInterval(interval);
+                    this.wsIntervals.delete(ws);
+                }
+            });
+            ws.on('error', () => {
+                this.connectedClients.delete(ws);
+                const interval = this.wsIntervals.get(ws);
+                if (interval) {
+                    clearInterval(interval);
+                    this.wsIntervals.delete(ws);
+                }
+            });
+            this.sendToClients({ type: 'status_update', status: { waitingForStart: true, isRunning: false, isPaused: false } });
+        });
+    }
+    handleWebSocketMessage(data, ws) {
+        switch (data.type) {
+            case 'control':
+                switch (data.action) {
+                    case 'start':
+                        console.log('🚀 Starting wizard execution from UI');
+                        this.isRunning = true;
+                        this.sendToClients({ type: 'status_update', status: { isRunning: true, isPaused: false, isStepMode: false } });
+                        if (this.runResolver) {
+                            this.runResolver();
+                            this.runResolver = undefined;
+                        }
+                        break;
+                    case 'pause':
+                        this.isPaused = true;
+                        console.log('⏸️ Wizard execution paused');
+                        this.sendToClients({ type: 'status_update', status: { isPaused: true, isStepMode: this.isStepMode } });
+                        break;
+                    case 'resume':
+                        this.isPaused = false;
+                        this.isStepMode = false;
+                        console.log('▶️ Wizard execution resumed');
+                        if (this.pauseResolver) {
+                            this.pauseResolver();
+                            this.pauseResolver = undefined;
+                        }
+                        this.sendToClients({ type: 'status_update', status: { isPaused: false, isStepMode: false } });
+                        break;
+                    case 'step_forward':
+                        if (this.isPaused) {
+                            this.isStepMode = true;
+                            console.log('⏭️ Stepping forward');
+                            if (this.pauseResolver) {
+                                this.pauseResolver();
+                                this.pauseResolver = undefined;
+                            }
+                            this.sendToClients({ type: 'status_update', status: { isPaused: true, isStepMode: true } });
+                        }
+                        break;
+                    case 'stop':
+                        console.log('🛑 Stopping wizard execution');
+                        this.isRunning = false;
+                        this.isPaused = false;
+                        this.isStepMode = false;
+                        this.sendToClients({ type: 'status_update', status: { isRunning: false, isPaused: false, isStepMode: false } });
+                        break;
+                    case 'replay':
+                        console.log('🔄 Replaying wizard - resetting state');
+                        this.isRunning = false;
+                        this.isPaused = false;
+                        this.workflowContext = {};
+                        this.sendToClients({ type: 'status_update', status: { isRunning: false, isPaused: false, waitingForStart: true } });
+                        break;
+                }
+                break;
+            case 'run':
+                console.log('🚀 Starting wizard execution from UI (run command)');
+                this.isRunning = true;
+                this.sendToClients({ type: 'status_update', status: { isRunning: true, isPaused: false } });
+                if (this.runResolver) {
+                    this.runResolver();
+                    this.runResolver = undefined;
+                }
+                break;
+            case 'form_submit':
+                this.userOverrideData = data.data;
+                console.log('📝 User override data received:', data.data);
+                if (this.pauseResolver) {
+                    this.pauseResolver();
+                    this.pauseResolver = undefined;
+                }
+                break;
+            case 'update_step_data':
+                this.updateContext(data.data);
+                console.log('📝 Step data updated:', data.data);
+                break;
+            case 'goto':
+                const index = this.findStepIndex(data.stepId);
+                if (index !== -1) {
+                    this.currentStepIndex = index;
+                    this.isRunning = true;
+                    this.isPaused = false;
+                    this.isStepMode = false;
+                    console.log(`🔄 Going to step ${data.stepId}`);
+                    this.sendToClients({ type: 'status_update', status: { isRunning: true, isPaused: false, isStepMode: false } });
+                }
+                break;
+        }
+    }
+    sendToClients(message) {
+        const messageStr = JSON.stringify(message);
+        this.connectedClients.forEach(client => {
+            if (client.readyState === WebSocket__namespace.OPEN) {
+                client.send(messageStr);
+            }
+        });
+    }
+    async waitForResume() {
+        return new Promise(resolve => {
+            this.pauseResolver = resolve;
+        });
+    }
+    getVisualizationHtml() {
+        const fs = require('fs');
+        const path = require('path');
+        // Read the HTML file (now self-contained with inline CSS and JS)
+        const htmlPath = path.join(__dirname, 'ui/wizard-visualizer.html');
+        return fs.readFileSync(htmlPath, 'utf-8');
+    }
+}
+Wizard.TEMPLATE_REGEX = /\{\{(\w+(?:\.\w+)*)\}\}/g;
+Wizard.WIZARD_TAG_PATTERN = /<(\w+)\s+([^>]*tag-category=["']wizard["'][^>]*)>/gi;
+
+exports.BaseProvider = BaseProvider;
+exports.BungeeBuilder = BungeeBuilder;
+exports.ComputeStep = ComputeStep;
+exports.LLMClient = LLMClient;
+exports.Model = Model;
+exports.MultiProvider = MultiProvider;
+exports.ProviderRegistry = ProviderRegistry;
+exports.Step = Step;
+exports.SwizzyProvider = SwizzyProvider;
+exports.TextStep = TextStep;
+exports.Wizard = Wizard;
+exports.default = Wizard;
+//# sourceMappingURL=index.js.map