@swizzy_ai/kit 1.0.0 → 1.0.2

package/dist/index.js

@@ -3,15 +3,15 @@
 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');
+var http = require('http');
+var WebSocket = require('ws');
+var fs = require('fs');
+var path = require('path');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -30,18 +30,19 @@ function _interopNamespaceDefault(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);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 class Step {
     constructor(config) {
+        this.executionCount = 0;
         this.id = config.id;
         this.instruction = config.instruction;
         this.schema = config.schema;
         this.update = config.update;
-        this.contextFunction = config.contextFunction;
+        this.context = config.context;
         this.contextType = config.contextType || 'xml'; // Default to xml
         this.beforeRun = config.beforeRun;
         this.afterRun = config.afterRun;
@@ -55,7 +56,7 @@ class Step {
         return result.data;
     }
     getContext(workflowContext) {
-        return this.contextFunction ? this.contextFunction(workflowContext) : workflowContext;
+        return this.context ? this.context(workflowContext) : workflowContext;
     }
 }
 
@@ -142,7 +143,7 @@ class SwizzyProvider extends BaseProvider {
         this.config = { baseURL, apiKey };
     }
     async complete(options) {
-        const endpoint = options.stream ? '/completions/stream' : '/completions';
+        const endpoint = '/completions';
         const response = await fetch(`${this.config.baseURL}${endpoint}`, {
             method: 'POST',
             headers: {
@@ -153,6 +154,7 @@ class SwizzyProvider extends BaseProvider {
                 prompt: options.prompt,
                 max_tokens: options.maxTokens || 1000,
                 temperature: options.temperature || 0.7,
+                stream: options.stream || false,
             }),
         });
         if (!response.ok) {
@@ -173,13 +175,43 @@ class SwizzyProvider extends BaseProvider {
             if (!reader)
                 throw new Error('No response body for streaming');
             let fullText = '';
+            let buffer = '';
             const decoder = new TextDecoder();
             while (true) {
                 const { done, value } = await reader.read();
                 if (done)
                     break;
-                const chunk = decoder.decode(value);
-                fullText += chunk;
+                buffer += decoder.decode(value, { stream: true });
+                const events = buffer.split('\n\n');
+                buffer = events.pop() || '';
+                for (const event of events) {
+                    if (event.startsWith('data: ')) {
+                        const data = event.slice(6);
+                        if (data === '[DONE]') {
+                            continue;
+                        }
+                        try {
+                            const parsed = JSON.parse(data);
+                            if (parsed.response !== undefined) {
+                                if (options.onChunk) {
+                                    options.onChunk(parsed.response);
+                                }
+                                fullText += parsed.response;
+                            }
+                            if (parsed.usage && options.onUsage) {
+                                const usage = {
+                                    promptTokens: parsed.usage.prompt_tokens || 0,
+                                    completionTokens: parsed.usage.completion_tokens || 0,
+                                    totalTokens: parsed.usage.total_tokens || 0,
+                                };
+                                options.onUsage(usage, this.getProviderName());
+                            }
+                        }
+                        catch (e) {
+                            console.error('Failed to parse SSE data:', data, e);
+                        }
+                    }
+                }
             }
             return { text: fullText };
         }
@@ -386,297 +418,918 @@ class BungeeBuilder {
     }
 }
 
-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);
-            };
+class SchemaUtils {
+    static describeSchema(schema, stepId) {
+        if (stepId && this.schemaDescriptions.has(stepId)) {
+            return this.schemaDescriptions.get(stepId);
         }
-        // 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 });
+        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')}`;
         }
-        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');
+        else {
+            description = 'Unknown schema type';
         }
-        catch (error) {
-            console.log('Wizard log:', content.trim());
+        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;
     }
-    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';
+    static 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';
     }
-    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);
-                    }
-                }
+    static 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);
         }
-        // Wait for all workers to complete
-        await Promise.all(activeWorkers);
-        console.log(`✅ Bungee plan ${plan.id} completed, returning to anchor ${plan.anchorId}`);
+        return fields;
     }
-    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);
+    static 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>`;
         }
     }
-    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)
+    static 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);
     }
-    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');
-                }
-            }
-        };
+    static escapeXml(unsafe) {
+        return unsafe
+            .replace(/&/g, '&')
+            .replace(/</g, '<')
+            .replace(/>/g, '>')
+            .replace(/"/g, '"')
+            .replace(/'/g, "'");
     }
-    createTelescopeContext(baseContext, telescope) {
-        return {
-            ...baseContext,
+}
+SchemaUtils.schemaDescriptions = new Map();
+SchemaUtils.maxCacheSize = 100;
+
+class VisualizationManager {
+    constructor(wizard) {
+        this.wizard = wizard;
+        this.connectedClients = new Set();
+        this.maxWebSocketConnections = 10;
+        this.wsIntervals = new WeakMap();
+    } // Wizard instance for callbacks
+    getStepsInfo() {
+        return this.wizard.steps.map((item) => {
+            if (Array.isArray(item)) {
+                return item.map((step) => ({
+                    id: step.id,
+                    instruction: step.instruction,
+                    fields: SchemaUtils.extractSchemaFields(step.schema),
+                    status: 'pending'
+                }));
+            }
+            else {
+                return {
+                    id: item.id,
+                    instruction: item.instruction,
+                    fields: SchemaUtils.extractSchemaFields(item.schema),
+                    status: 'pending'
+                };
+            }
+        }).flat();
+    }
+    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 if (req.url === '/api/steps') {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(this.getStepsInfo()));
+                }
+                else if (req.url === '/api/context') {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(this.wizard.getContext()));
+                }
+                else if (req.url === '/api/log') {
+                    this.wizard.logger.getLog().then((log) => {
+                        res.writeHead(200, { 'Content-Type': 'text/plain' });
+                        res.end(log);
+                    }).catch(() => {
+                        res.writeHead(200, { 'Content-Type': 'text/plain' });
+                        res.end('');
+                    });
+                }
+                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.wizard.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.wizard.isPaused = true;
+                        console.log('⏸️ Wizard execution paused');
+                        this.sendToClients({ type: 'status_update', status: { isPaused: true, isStepMode: this.wizard.isStepMode } });
+                        break;
+                    case 'resume':
+                        this.wizard.isPaused = false;
+                        this.wizard.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.wizard.isPaused) {
+                            this.wizard.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.wizard.isRunning = false;
+                        this.wizard.isPaused = false;
+                        this.wizard.isStepMode = false;
+                        this.sendToClients({ type: 'status_update', status: { isRunning: false, isPaused: false, isStepMode: false } });
+                        break;
+                    case 'replay':
+                        console.log('🔄 Replaying wizard - resetting state');
+                        this.wizard.isRunning = false;
+                        this.wizard.isPaused = false;
+                        this.wizard.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.wizard.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.wizard.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.wizard.updateContext(data.data);
+                console.log('📝 Step data updated:', data.data);
+                break;
+            case 'goto':
+                const index = this.wizard.findStepIndex(data.stepId);
+                if (index !== -1) {
+                    const wasRunning = this.wizard.isRunning;
+                    if (!wasRunning) {
+                        this.wizard.startFrom(data.stepId);
+                    }
+                    else {
+                        this.wizard.currentStepIndex = index;
+                    }
+                    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 waitForRunCommand() {
+        return new Promise(resolve => {
+            this.runResolver = resolve;
+        });
+    }
+    async waitForResume() {
+        return new Promise(resolve => {
+            this.pauseResolver = resolve;
+        });
+    }
+    sendStatusUpdate(status) {
+        this.sendToClients({ type: 'status_update', status });
+    }
+    sendWizardStart(steps) {
+        this.sendToClients({ type: 'wizard_start', steps });
+    }
+    sendStepUpdate(update) {
+        this.sendToClients({ type: 'step_update', ...update });
+    }
+    sendContextUpdate(context) {
+        this.sendToClients({ type: 'context_update', context });
+    }
+    sendTokenUpdate(totalTokens, rate) {
+        this.sendToClients({
+            type: 'token_update',
+            totalTokens,
+            rate
+        });
+    }
+    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');
+    }
+}
+
+class BungeeExecutor {
+    constructor(wizard) {
+        this.wizard = wizard;
+        this.bungeeWorkers = new Map();
+        this.pendingReentry = new Set();
+    } // Wizard instance
+    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.wizard.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.wizard.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);
+                }
+            }
+        }
+    }
+    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);
+    async executeWorkerStep(stepId, telescopeContext) {
+        const step = this.wizard.findStep(stepId);
+        if (!step)
+            return;
+        const stepContext = step.getContext(telescopeContext);
+        const stepData = await this.wizard.generateStepData(step, stepContext);
+        const actions = this.wizard.createWorkerActions(telescopeContext._telescope);
+        return await step.update(stepData, telescopeContext, actions);
+    }
+    mergeWorkerResults(updates, telescope) {
+        Object.entries(updates).forEach(([key, value]) => {
+            this.wizard.workflowContext[key] = value;
+        });
+    }
+    async retriggerAnchor(anchorId) {
+        const anchorStep = this.wizard.findStep(anchorId);
+        if (anchorStep) {
+            await this.wizard.executeStep(anchorStep);
+        }
+    }
+    async processReentries() {
+        const anchorsToRetrigger = Array.from(this.pendingReentry);
+        this.pendingReentry.clear();
+        for (const anchorId of anchorsToRetrigger) {
+            await this.retriggerAnchor(anchorId);
+        }
+    }
+}
+
+class Logger {
+    constructor(id) {
+        // 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, `${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());
+        }
+    }
+    async getLog() {
+        if (!this.logFilePath || !fs__namespace.existsSync(this.logFilePath))
+            return '';
+        try {
+            return await fs__namespace.promises.readFile(this.logFilePath, 'utf8');
+        }
+        catch {
+            return '';
+        }
+    }
+}
+
+class UsageTracker {
+    constructor(onUsage, onUpdate) {
+        this.totalTokens = 0;
+        this.stepTokens = 0;
+        this.onUsage = onUsage;
+        this.onUpdate = onUpdate;
+        if (onUsage) {
+            const originalOnUsage = onUsage;
+            this.onUsage = (usage, provider) => {
+                this.totalTokens += usage.totalTokens;
+                this.stepTokens = usage.totalTokens; // Last step tokens
+                originalOnUsage(usage, provider);
+                this.notifyUpdate();
+            };
+        }
+    }
+    setStartTime(time) {
+        this.startTime = time;
+    }
+    notifyUpdate() {
+        if (this.onUpdate && this.startTime) {
+            const elapsed = (Date.now() - this.startTime) / 1000; // seconds
+            const rate = elapsed > 0 ? this.totalTokens / elapsed : 0;
+            this.onUpdate(this.totalTokens, rate);
+        }
+    }
+    getTotalTokens() {
+        return this.totalTokens;
+    }
+    getStepTokens() {
+        return this.stepTokens;
+    }
+    updateUsage(usage, provider) {
+        if (this.onUsage) {
+            this.onUsage(usage, provider);
+        }
+        else {
+            // If no onUsage, still update totals and notify
+            this.totalTokens += usage.totalTokens;
+            this.stepTokens = usage.totalTokens;
+            this.notifyUpdate();
+        }
+    }
+}
+
+class ContextManager {
+    constructor() {
+        this.workflowContext = {};
+    }
+    setContext(context) {
+        this.workflowContext = { ...this.workflowContext, ...context };
+    }
+    getContext() {
+        return this.workflowContext;
+    }
+    updateContext(updates) {
+        this.workflowContext = { ...this.workflowContext, ...updates };
+    }
+    getWorkflowContext() {
+        return this.workflowContext;
+    }
+    setWorkflowContext(context) {
+        this.workflowContext = context;
+    }
+}
+
+// Simple EventEmitter for wizard events
+class EventEmitter {
+    constructor() {
+        this.events = new Map();
+    }
+    on(event, callback) {
+        if (!this.events.has(event)) {
+            this.events.set(event, []);
+        }
+        this.events.get(event).push(callback);
+    }
+    emit(event, data) {
+        const callbacks = this.events.get(event);
+        if (callbacks) {
+            callbacks.forEach(cb => cb(data));
+        }
+    }
+}
+class Wizard {
+    debounce(func, wait) {
+        let timeout;
+        return (...args) => {
+            clearTimeout(timeout);
+            timeout = setTimeout(() => func.apply(this, args), wait);
+        };
+    }
+    // Getters for manager methods
+    get workflowContext() {
+        return this.contextManager.getContext();
+    }
+    set workflowContext(value) {
+        this.contextManager.setWorkflowContext(value);
+    }
+    get log() {
+        return this.isLoggingEnabled ? this.logger.log.bind(this.logger) : () => { };
+    }
+    get sendToClients() {
+        return this.visualizationManager.sendToClients.bind(this.visualizationManager);
+    }
+    get visualizationServer() {
+        return this.visualizationManager.visualizationServer;
+    }
+    constructor(config) {
+        this.steps = [];
+        this.stepIndexMap = new Map();
+        this.currentStepIndex = 0;
+        this.isPaused = false;
+        this.isRunning = false;
+        this.isStepMode = false;
+        this.skipStartWait = false;
+        this.isLoggingEnabled = process.env.NODE_ENV === 'development' || !process.env.NODE_ENV;
+        this.debouncedSendContextUpdate = this.debounce(() => {
+            this.visualizationManager.sendContextUpdate(this.contextManager.getContext());
+        }, 100);
+        this.id = config.id;
+        const registry = new ProviderRegistry();
+        this.llmClient = new LLMClient(registry);
+        this.systemPrompt = config.systemPrompt;
+        // Initialize managers
+        this.logger = new Logger(this.id);
+        this.contextManager = new ContextManager();
+        this.visualizationManager = new VisualizationManager(this);
+        this.usageTracker = new UsageTracker(config.onUsage, (totalTokens, rate) => {
+            this.visualizationManager.sendTokenUpdate(totalTokens, rate);
+        });
+        this.bungeeExecutor = new BungeeExecutor(this);
+        this.events = new EventEmitter();
+    }
+    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;
     }
-    mergeWorkerResults(updates, telescope) {
-        Object.entries(updates).forEach(([key, value]) => {
-            this.workflowContext[key] = value;
-        });
+    addComputeStep(config) {
+        const step = new ComputeStep(config);
+        const index = this.steps.length;
+        this.steps.push(step);
+        this.stepIndexMap.set(step.id, index);
+        return this;
     }
-    async retriggerAnchor(anchorId) {
-        const anchorStep = this.findStep(anchorId);
-        if (anchorStep) {
-            await this.executeStep(anchorStep);
+    goto(stepId) { return `GOTO ${stepId}`; }
+    next() { return Wizard.NEXT; }
+    stop() { return Wizard.STOP; }
+    retry() { return Wizard.RETRY; }
+    wait() { return Wizard.WAIT; }
+    on(event, callback) {
+        this.events.on(event, callback);
+        return this;
+    }
+    clearStepError(stepId) {
+        const context = this.contextManager.getContext();
+        delete context[`${stepId}_error`];
+        delete context[`${stepId}_retryCount`];
+        this.contextManager.setWorkflowContext(context);
+    }
+    isStringSignal(signal) {
+        return typeof signal === 'string';
+    }
+    isBungeeJumpSignal(signal) {
+        return typeof signal === 'object' && signal !== null && signal.type === 'BUNGEE_JUMP';
+    }
+    async handleFlowControlSignal(signal) {
+        switch (signal) {
+            case Wizard.NEXT:
+                this.currentStepIndex++;
+                return true;
+            case Wizard.STOP:
+                return false;
+            case Wizard.RETRY:
+                return true;
+            case Wizard.WAIT:
+                await new Promise(resolve => setTimeout(resolve, 10 * 1000));
+                this.currentStepIndex++;
+                return true;
+            default:
+                if (this.isBungeeJumpSignal(signal)) {
+                    await this.bungeeExecutor.executeBungeePlan(signal.plan);
+                    return true;
+                }
+                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}`);
+                    }
+                    return true;
+                }
         }
+        return true;
     }
-    async processReentries() {
-        const anchorsToRetrigger = Array.from(this.pendingReentry);
-        this.pendingReentry.clear();
-        for (const anchorId of anchorsToRetrigger) {
-            await this.retriggerAnchor(anchorId);
+    async initializeRun() {
+        if (this.visualizationServer) {
+            console.log('🎯 Waiting for UI to start wizard execution...');
+            this.sendToClients({ type: 'status_update', status: { waitingForStart: true, isStepMode: false } });
+            await this.visualizationManager.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: SchemaUtils.extractSchemaFields(step.schema),
+                        status: 'pending'
+                    }));
+                }
+                else {
+                    return {
+                        id: item.id,
+                        instruction: item.instruction,
+                        fields: SchemaUtils.extractSchemaFields(item.schema),
+                        status: 'pending'
+                    };
+                }
+            }).flat();
+            this.sendToClients({ type: 'wizard_start', steps: stepsInfo });
         }
+        this.log('Wizard session started');
+        this.currentStepIndex = 0;
+        this.usageTracker.setStartTime(Date.now());
+        this.isRunning = true;
+        // Emit start event
+        this.events.emit('start', {
+            wizardId: this.id,
+            timestamp: Date.now(),
+            steps: this.steps.map(item => {
+                if (Array.isArray(item)) {
+                    return item.map(step => ({
+                        id: step.id,
+                        instruction: step.instruction,
+                        fields: SchemaUtils.extractSchemaFields(step.schema)
+                    }));
+                }
+                else {
+                    return {
+                        id: item.id,
+                        instruction: item.instruction,
+                        fields: SchemaUtils.extractSchemaFields(item.schema)
+                    };
+                }
+            }).flat()
+        });
     }
-    findStep(stepId) {
-        for (const item of this.steps) {
-            if (Array.isArray(item)) {
-                const found = item.find(s => s.id === stepId);
-                if (found)
-                    return found;
+    async executeParallelSteps(parallelSteps) {
+        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 = Wizard.NEXT;
+        for (const signal of signals) {
+            if (signal === Wizard.STOP) {
+                return Wizard.STOP;
             }
-            else {
-                if (item.id === stepId)
-                    return item;
+            if (this.isStringSignal(signal) && signal.startsWith('GOTO ')) {
+                nextSignal = signal;
+                break;
+            }
+            if (signal === Wizard.RETRY) {
+                nextSignal = Wizard.RETRY;
+            }
+        }
+        return nextSignal;
+    }
+    async executeSequentialStep(step) {
+        const signal = await this.executeStep(step);
+        if (!(await this.handleFlowControlSignal(signal)))
+            return;
+    }
+    finalizeRun(startTime) {
+        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`);
+        // Emit complete event
+        this.events.emit('complete', {
+            duration,
+            totalSteps: this.steps.length,
+            timestamp: endTime
+        });
+    }
+    createBaseActions() {
+        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(),
+        };
+    }
+    createWizardActions(anchorStepId = '') {
+        return {
+            ...this.createBaseActions(),
+            bungee: {
+                init: () => new BungeeBuilder(anchorStepId)
             }
+        };
+    }
+    createWorkerActions(telescope) {
+        return {
+            updateContext: (updates) => {
+                this.bungeeExecutor.mergeWorkerResults(updates, telescope);
+            },
+            llmClient: this.llmClient,
+            goto: () => Wizard.STOP,
+            next: () => Wizard.STOP,
+            stop: () => Wizard.STOP,
+            retry: () => Wizard.STOP,
+            wait: () => Wizard.STOP,
+            bungee: {
+                init: () => {
+                    throw new Error('Bungee not allowed in worker context');
+                }
+            }
+        };
+    }
+    findStep(stepId) {
+        const index = this.stepIndexMap.get(stepId);
+        if (index === undefined)
+            return null;
+        const item = this.steps[index];
+        if (Array.isArray(item)) {
+            return item.find(s => s.id === stepId) || null;
+        }
+        else {
+            return item.id === stepId ? item : null;
         }
-        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);
+        this.logger.log(`Starting step ${step.id}`);
+        const stepStartTime = Date.now();
+        // Emit step:start event
+        this.events.emit('step:start', {
+            stepId: step.id,
+            instruction: step.instruction,
+            timestamp: stepStartTime
+        });
+        const stepContext = step.getContext(this.contextManager.getContext());
         let processedInstruction = step.instruction;
         if (step.contextType === 'template' || step.contextType === 'both') {
             processedInstruction = this.applyTemplate(step.instruction, stepContext);
         }
-        this.sendToClients({
-            type: 'step_update',
+        this.visualizationManager.sendStepUpdate({
             stepId: step.id,
             status: 'current',
             instruction: processedInstruction,
             context: stepContext,
-            fields: this.extractSchemaFields(step.schema)
-        });
-        this.sendToClients({
-            type: 'context_update',
-            context: this.workflowContext
+            fields: SchemaUtils.extractSchemaFields(step.schema)
         });
+        this.debouncedSendContextUpdate();
         try {
             if (step.beforeRun) {
                 await step.beforeRun();
             }
-            this.log(() => `Context for step ${step.id}: ${JSON.stringify(stepContext)}`);
+            this.logger.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();
+                await this.visualizationManager.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',
+                        this.visualizationManager.sendStepUpdate({
                             stepId: step.id,
                             status: 'completed',
                             data: validatedData
@@ -692,26 +1345,41 @@ class Wizard {
             }
             if (stepData && stepData.__validationFailed) {
                 console.log(`🔄 Validation failed for step ${step.id}, retrying...`, stepData);
+                // Emit step:retry event
+                this.events.emit('step:retry', {
+                    stepId: step.id,
+                    attempt: (this.workflowContext[`${step.id}_retryCount`] || 0) + 1,
+                    error: stepData.error,
+                    timestamp: Date.now()
+                });
                 return 'RETRY';
             }
             const actions = this.createWizardActions(step.id);
             const signal = await step.update(stepData, this.workflowContext, actions);
-            this.sendToClients({
-                type: 'step_update',
+            this.visualizationManager.sendStepUpdate({
                 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;
+            this.logger.log(() => `Step ${step.id} completed with data: ${JSON.stringify(stepData)}`);
+            // Emit step:complete event
+            this.events.emit('step:complete', {
+                stepId: step.id,
+                data: stepData,
+                duration: Date.now() - stepStartTime,
+                timestamp: Date.now()
+            });
+            return this.finalizeStepExecution(step, stepData, signal);
         }
         catch (error) {
             console.log('Processing error', error);
+            // Emit step:error event
+            this.events.emit('step:error', {
+                stepId: step.id,
+                error: error,
+                retryCount: (this.workflowContext[`${step.id}_retryCount`] || 0) + 1,
+                timestamp: Date.now()
+            });
             this.updateContext({
                 [`${step.id}_error`]: error.message,
                 [`${step.id}_retryCount`]: (this.workflowContext[`${step.id}_retryCount`] || 0) + 1
@@ -719,9 +1387,7 @@ class Wizard {
             return 'RETRY';
         }
     }
-    async processStepResult(step, stepData) {
-        const actions = this.createWizardActions(step.id);
-        const signal = await step.update(stepData, this.workflowContext, actions);
+    async finalizeStepExecution(step, stepData, signal) {
         if (this.workflowContext[`${step.id}_error`]) {
             this.clearStepError(step.id);
         }
@@ -730,6 +1396,11 @@ class Wizard {
         }
         return signal;
     }
+    async processStepResult(step, stepData) {
+        const actions = this.createWizardActions(step.id);
+        const signal = await step.update(stepData, this.workflowContext, actions);
+        return this.finalizeStepExecution(step, stepData, signal);
+    }
     setContext(context) {
         this.workflowContext = { ...this.workflowContext, ...context };
         return this;
@@ -742,120 +1413,69 @@ class Wizard {
         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 => {
+        await this.initializeRun();
+        this.executionLoop();
+    }
+    startFrom(stepId) {
+        const index = this.findStepIndex(stepId);
+        if (index === -1)
+            return;
+        this.currentStepIndex = index;
+        this.isRunning = true;
+        this.isPaused = false;
+        this.isStepMode = false;
+        this.usageTracker.setStartTime(Date.now());
+        this.events.emit('start', {
+            wizardId: this.id,
+            timestamp: Date.now(),
+            steps: 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'
+                        fields: SchemaUtils.extractSchemaFields(step.schema)
                     }));
                 }
                 else {
                     return {
                         id: item.id,
                         instruction: item.instruction,
-                        fields: this.extractSchemaFields(item.schema),
-                        status: 'pending'
+                        fields: SchemaUtils.extractSchemaFields(item.schema)
                     };
                 }
-            }).flat();
-            this.sendToClients({ type: 'wizard_start', steps: stepsInfo });
-        }
-        this.log('Wizard session started');
-        this.currentStepIndex = 0;
-        this.isRunning = true;
+            }).flat()
+        });
+        this.executionLoop();
+    }
+    async executionLoop() {
+        const startTime = Date.now();
         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}`);
-                    }
-                }
+                const signal = await this.executeParallelSteps(item);
+                if (!(await this.handleFlowControlSignal(signal)))
+                    return;
             }
             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}`);
-                            }
-                        }
-                }
+                await this.executeSequentialStep(item);
             }
             if (this.isStepMode) {
                 this.isPaused = true;
-                await this.waitForResume();
+                this.events.emit('pause', {
+                    timestamp: Date.now(),
+                    currentStepId: this.steps[this.currentStepIndex]?.id
+                });
+                await this.visualizationManager.waitForResume();
+                this.events.emit('resume', {
+                    timestamp: Date.now(),
+                    currentStepId: this.steps[this.currentStepIndex]?.id
+                });
             }
-            await this.processReentries();
+            await this.bungeeExecutor.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;
-        });
+        this.finalizeRun(startTime);
     }
     async generateStepData(step, stepContext) {
         const systemContext = this.systemPrompt ? `${this.systemPrompt}\n\n` : '';
@@ -889,7 +1509,10 @@ Generate the text response now.`;
             console.log(`LLM response for step ${step.id}:`, llmResult.text);
             return llmResult.text;
         }
-        const schemaDescription = this.describeSchema(step.schema, step.id);
+        // For regular steps, use streaming
+        const parser = this.createStreamingXmlParser();
+        let latestResult = {};
+        const schemaDescription = SchemaUtils.describeSchema(step.schema, step.id);
         const prompt = `${systemContext}You are executing a wizard step. Generate data for this step.
 
 STEP: ${step.id}
@@ -903,6 +1526,13 @@ 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").
 
+ARRAY FORMATTING RULES (CRITICAL):
+- Arrays MUST be valid JSON on a SINGLE line
+- Use double quotes, not single quotes: ["a", "b"] NOT ['a', 'b']
+- NO trailing commas: ["a", "b"] NOT ["a", "b",]
+- NO line breaks inside arrays
+- Example: <items tag-category="wizard" type="array">["apple", "banana", "orange"]
+
 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
@@ -913,35 +1543,45 @@ 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>.
+Notice: Arrays are compact JSON on one line! No closing tags needed for wizard fields.
 
 Generate the XML response now.`;
         this.log(() => `Full prompt for step ${step.id}: ${prompt}`);
-        const llmResult = await this.llmClient.complete({
+        await this.llmClient.complete({
             prompt,
             model: step.model,
             maxTokens: 1000,
             temperature: 0.3,
+            stream: true,
+            onChunk: (chunk) => {
+                const parseResult = parser.push(chunk);
+                if (parseResult && !parseResult.done) {
+                    latestResult = parseResult.result;
+                    // Optionally: Send partial results to UI
+                    this.visualizationManager.sendStepUpdate({
+                        stepId: step.id,
+                        status: 'streaming',
+                        data: latestResult
+                    });
+                }
+                else if (parseResult?.done) {
+                    latestResult = parseResult.result;
+                }
+            },
+            onUsage: this.usageTracker.updateUsage.bind(this.usageTracker)
         });
-        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)}`);
+        this.log(() => `Final parsed data: ${JSON.stringify(latestResult)}`);
+        this.log(() => `Parsed JSON data for step ${step.id}: ${JSON.stringify(latestResult)}`);
         try {
-            return step.validate(jsonData);
+            return step.validate(latestResult);
         }
         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);
+                const repairedData = await this.repairSchemaData(latestResult, step.schema, validationError.message, step.id);
                 this.log(() => `Repaired data for step ${step.id}: ${JSON.stringify(repairedData)}`);
                 return step.validate(repairedData);
             }
@@ -955,7 +1595,7 @@ Generate the XML response now.`;
         const step = this.findStep(stepId);
         if (!step)
             throw new Error(`Step ${stepId} not found`);
-        const schemaDescription = this.describeSchema(schema, stepId);
+        const schemaDescription = SchemaUtils.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)}
@@ -984,81 +1624,62 @@ Fix the data to match the schema and generate the XML response now.`;
             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;
+        });
+        const repairedJsonData = this.parseXmlToJson(llmResult.text);
+        return repairedJsonData;
     }
-    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]}`;
+    createStreamingXmlParser() {
+        let buffer = '';
+        let inResponse = false;
+        const result = {};
+        let currentField = null;
+        return {
+            push: (chunk) => {
+                buffer += chunk;
+                // Detect <response> start
+                if (!inResponse && buffer.includes('<response>')) {
+                    inResponse = true;
+                    buffer = buffer.slice(buffer.indexOf('<response>') + 10);
                 }
-                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(', ');
+                if (!inResponse)
+                    return null;
+                // Parse wizard-tagged fields incrementally
+                const tagMatch = buffer.match(Wizard.WIZARD_TAG_PATTERN);
+                if (tagMatch) {
+                    // If we have a current field, finalize it
+                    if (currentField) {
+                        result[currentField.name] = this.parseValueByType(currentField.content.trim(), currentField.type);
+                    }
+                    // Start new field
+                    const typeMatch = tagMatch[2].match(/type=["']([^"']+)["']/);
+                    currentField = {
+                        name: tagMatch[1],
+                        type: typeMatch?.[1]?.toLowerCase() || 'string',
+                        content: ''
+                    };
+                    buffer = buffer.slice(tagMatch.index + tagMatch[0].length);
+                }
+                // Accumulate content for current field
+                if (currentField) {
+                    const nextTagIndex = buffer.search(/<\w+\s+[^>]*tag-category=["']wizard["']/);
+                    if (nextTagIndex !== -1) {
+                        currentField.content += buffer.slice(0, nextTagIndex);
+                        buffer = buffer.slice(nextTagIndex);
+                    }
+                    else if (buffer.includes('</response>')) {
+                        const endIndex = buffer.indexOf('</response>');
+                        currentField.content += buffer.slice(0, endIndex);
+                        result[currentField.name] = this.parseValueByType(currentField.content.trim(), currentField.type);
+                        return { done: true, result };
+                    }
+                    else {
+                        currentField.content += buffer;
+                        buffer = '';
+                    }
+                }
+                return { done: false, result: { ...result } };
             }
-            fields.push(field);
-        }
-        return fields;
+        };
     }
     parseXmlToJson(xml) {
         const responseMatch = xml.match(/<response\s*>([\s\S]*?)(?:<\/response\s*>|$)/i);
@@ -1142,6 +1763,17 @@ Fix the data to match the schema and generate the XML response now.`;
         }
         return result;
     }
+    parseValueByType(content, type) {
+        switch (type) {
+            case 'string': return content;
+            case 'number': return this.parseNumber(content);
+            case 'boolean': return this.parseBoolean(content);
+            case 'array': return this.parseArray(content);
+            case 'object': return this.parseXmlElementWithTagCategory(content);
+            case 'null': return null;
+            default: return this.inferAndParseValue(content);
+        }
+    }
     parseNumber(value) {
         const num = Number(value);
         if (isNaN(num)) {
@@ -1158,16 +1790,146 @@ Fix the data to match the schema and generate the XML response now.`;
         throw new Error(`Invalid boolean value: "${value}" (expected "true" or "false")`);
     }
     parseArray(value) {
+        const trimmed = value.trim();
+        // Strategy 1: Try direct JSON parse
         try {
-            const parsed = JSON.parse(value);
-            if (!Array.isArray(parsed)) {
-                throw new Error('Parsed value is not an array');
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch (e) {
+            // Continue to fallback strategies
+        }
+        // Strategy 2: Fix common JSON issues and retry
+        try {
+            let fixed = trimmed
+                // Remove trailing commas before closing bracket
+                .replace(/,(\s*[}\]])/g, '$1')
+                // Normalize quotes (convert single to double)
+                .replace(/'/g, '"')
+                // Remove comments if any
+                .replace(/\/\/.*$/gm, '')
+                .replace(/\/\*[\s\S]*?\*\//g, '');
+            const parsed = JSON.parse(fixed);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch (e) {
+            // Continue to manual parsing
+        }
+        // Strategy 3: Manual extraction (most robust)
+        // Extract content between first [ and last ]
+        const bracketMatch = trimmed.match(/\[([\s\S]*)\]/);
+        if (bracketMatch) {
+            const content = bracketMatch[1].trim();
+            // Empty array
+            if (!content)
+                return [];
+            // Try to parse as JSON array one more time
+            try {
+                const parsed = JSON.parse(`[${content}]`);
+                if (Array.isArray(parsed))
+                    return parsed;
+            }
+            catch (e) {
+                // Fall through to string splitting
             }
-            return parsed;
+            // Manual string splitting for simple arrays
+            const items = [];
+            let current = '';
+            let inString = false;
+            let escapeNext = false;
+            let depth = 0;
+            for (let i = 0; i < content.length; i++) {
+                const char = content[i];
+                if (escapeNext) {
+                    current += char;
+                    escapeNext = false;
+                    continue;
+                }
+                if (char === '\\') {
+                    escapeNext = true;
+                    current += char;
+                    continue;
+                }
+                if (char === '"' && depth === 0) {
+                    inString = !inString;
+                    current += char;
+                    continue;
+                }
+                if (inString) {
+                    current += char;
+                    continue;
+                }
+                // Track nested structures
+                if (char === '{' || char === '[') {
+                    depth++;
+                    current += char;
+                    continue;
+                }
+                if (char === '}' || char === ']') {
+                    depth--;
+                    current += char;
+                    continue;
+                }
+                // Split on comma at depth 0
+                if (char === ',' && depth === 0) {
+                    const item = current.trim();
+                    if (item) {
+                        items.push(this.parseArrayItem(item));
+                    }
+                    current = '';
+                    continue;
+                }
+                current += char;
+            }
+            // Don't forget the last item
+            if (current.trim()) {
+                items.push(this.parseArrayItem(current.trim()));
+            }
+            return items;
         }
-        catch (error) {
-            throw new Error(`Invalid array JSON: "${value}"`);
+        // Strategy 4: Newline-separated values (last resort)
+        const lines = trimmed
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l && l !== '[' && l !== ']');
+        if (lines.length > 0) {
+            return lines.map(line => {
+                // Remove trailing comma
+                const cleaned = line.replace(/,\s*$/, '');
+                return this.parseArrayItem(cleaned);
+            });
+        }
+        throw new Error(`Could not parse array from: "${value.substring(0, 100)}..."`);
+    }
+    parseArrayItem(item) {
+        const trimmed = item.trim();
+        // Try JSON parse first
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch (e) {
+            // Not valid JSON, continue
         }
+        // Remove quotes if present
+        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+            return trimmed.slice(1, -1);
+        }
+        // Try as number
+        if (!isNaN(Number(trimmed))) {
+            return Number(trimmed);
+        }
+        // Boolean
+        if (trimmed === 'true')
+            return true;
+        if (trimmed === 'false')
+            return false;
+        if (trimmed === 'null')
+            return null;
+        // Return as string
+        return trimmed;
     }
     inferAndParseValue(content) {
         const trimmed = content.trim();
@@ -1244,197 +2006,16 @@ Fix the data to match the schema and generate the XML response now.`;
         });
     }
     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');
+        return this.visualizationManager.visualize(port);
     }
 }
 Wizard.TEMPLATE_REGEX = /\{\{(\w+(?:\.\w+)*)\}\}/g;
 Wizard.WIZARD_TAG_PATTERN = /<(\w+)\s+([^>]*tag-category=["']wizard["'][^>]*)>/gi;
+// Flow control signals
+Wizard.NEXT = 'NEXT';
+Wizard.STOP = 'STOP';
+Wizard.RETRY = 'RETRY';
+Wizard.WAIT = 'WAIT';
 
 exports.BaseProvider = BaseProvider;
 exports.BungeeBuilder = BungeeBuilder;