wu-framework 1.1.8 → 1.1.9

package/src/ai/wu-ai-provider.js

@@ -88,6 +88,24 @@ class OpenAIAdapter extends BaseAdapter {
     if (options.temperature !== undefined) body.temperature = options.temperature;
     if (options.maxTokens) body.max_tokens = options.maxTokens;
     if (options.stream) body.stream = true;
+
+    // Structured output / JSON mode
+    if (options.responseFormat) {
+      const rf = options.responseFormat;
+      if (rf === 'json' || rf?.type === 'json_object') {
+        body.response_format = { type: 'json_object' };
+      } else if (rf?.type === 'json_schema') {
+        body.response_format = {
+          type: 'json_schema',
+          json_schema: {
+            name: rf.name || 'response',
+            schema: rf.schema,
+            strict: rf.strict !== false,
+          },
+        };
+      }
+    }
+
     return body;
   }
 
@@ -207,6 +225,26 @@ class AnthropicAdapter extends BaseAdapter {
     if (systemMsgs.length) {
       body.system = systemMsgs.map(m => m.content).join('\n\n');
     }
+
+    // Structured output / JSON mode (Anthropic has no native support)
+    // Strategy: augment system prompt + prefill assistant turn with '{'
+    if (options.responseFormat) {
+      const rf = options.responseFormat;
+      const jsonInstruction = '\n\nYou MUST respond with valid JSON only. No markdown, no explanation.';
+
+      if (rf === 'json' || rf?.type === 'json_object') {
+        body.system = (body.system || '') + jsonInstruction;
+      } else if (rf?.type === 'json_schema') {
+        const schemaStr = JSON.stringify(rf.schema, null, 2);
+        body.system = (body.system || '') +
+          jsonInstruction +
+          `\n\nYour response MUST conform to this JSON schema:\n${schemaStr}`;
+      }
+
+      // Prefill assistant message with '{' to force JSON output
+      body.messages.push({ role: 'assistant', content: '{' });
+    }
+
     if (options.tools?.length) {
       body.tools = options.tools.map(t => ({
         name: t.name,
@@ -307,6 +345,17 @@ class OllamaAdapter extends BaseAdapter {
     }
     if (options.temperature !== undefined) body.options = { temperature: options.temperature };
     if (options.stream !== undefined) body.stream = options.stream;
+
+    // Structured output / JSON mode
+    if (options.responseFormat) {
+      const rf = options.responseFormat;
+      if (rf === 'json' || rf?.type === 'json_object') {
+        body.format = 'json';
+      } else if (rf?.type === 'json_schema') {
+        body.format = rf.schema;
+      }
+    }
+
     return body;
   }
 
@@ -431,9 +480,7 @@ export class WuAIProvider {
    * @returns {Promise<{ content: string, tool_calls?: Array, usage?: object }>}
    */
   async send(messages, options = {}) {
-    this._ensureActive();
-    const adapter = this._active;
-    const config = this._activeConfig;
+    const { adapter, config } = this._resolveProvider(options.provider);
 
     // Custom adapter: call user function directly
     if (adapter.isCustom && adapter._sendFn) {
@@ -457,7 +504,25 @@ export class WuAIProvider {
     });
 
     const data = await response.json();
-    return adapter.parseResponse(data);
+    const result = adapter.parseResponse(data);
+
+    // Anthropic prefill compensation: we prepended '{' to force JSON,
+    // so the response content is the continuation — restore the full JSON
+    if (adapter instanceof AnthropicAdapter && options.responseFormat && result.content) {
+      result.content = '{' + result.content;
+    }
+
+    // Validate JSON when responseFormat was requested
+    if (options.responseFormat && result.content) {
+      try {
+        result.parsed = JSON.parse(result.content);
+      } catch {
+        result.parseError = 'Response is not valid JSON';
+        logger.wuDebug('[wu-ai] responseFormat requested but LLM returned invalid JSON');
+      }
+    }
+
+    return result;
   }
 
   /**
@@ -468,9 +533,7 @@ export class WuAIProvider {
    * @yields {StreamChunk}
    */
   async *stream(messages, options = {}) {
-    this._ensureActive();
-    const adapter = this._active;
-    const config = this._activeConfig;
+    const { adapter, config } = this._resolveProvider(options.provider);
 
     // Custom adapter: call user generator directly
     if (adapter.isCustom && adapter._streamFn) {
@@ -502,6 +565,10 @@ export class WuAIProvider {
     const decoder = new TextDecoder();
     let buffer = '';
 
+    // Anthropic prefill compensation for streaming:
+    // emit the '{' we used as prefill before the first real chunk
+    let needsPrefill = adapter instanceof AnthropicAdapter && !!options.responseFormat;
+
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -516,7 +583,13 @@ export class WuAIProvider {
           if (!trimmed) continue;
 
           const chunk = adapter.parseStreamChunk(trimmed);
-          if (chunk) yield chunk;
+          if (chunk) {
+            if (needsPrefill && chunk.type === 'text') {
+              chunk.content = '{' + chunk.content;
+              needsPrefill = false;
+            }
+            yield chunk;
+          }
           if (chunk?.type === 'done') return;
         }
       }
@@ -552,10 +625,13 @@ export class WuAIProvider {
           }
         }
 
-        // 4xx (except 429) — don't retry
-        throw new Error(`[wu-ai] Request failed: ${response.status} ${response.statusText}`);
+        // 4xx (except 429) — don't retry, fail immediately
+        const clientError = new Error(`[wu-ai] Request failed: ${response.status} ${response.statusText}`);
+        clientError._noRetry = true;
+        throw clientError;
       } catch (err) {
         if (err.name === 'AbortError') throw err;
+        if (err._noRetry) throw err; // 4xx — don't retry
         lastError = err;
         if (attempt < this._retryConfig.maxRetries) {
           const delay = this._retryConfig.baseDelayMs * Math.pow(2, attempt);
@@ -579,6 +655,25 @@ export class WuAIProvider {
     return endpoint;
   }
 
+  /**
+   * Resolve which provider/adapter to use for a request.
+   * Supports per-call selection: options.provider = 'anthropic'
+   *
+   * @param {string} [providerName] - Optional provider name override
+   * @returns {{ adapter: BaseAdapter, config: object }}
+   */
+  _resolveProvider(providerName) {
+    if (providerName) {
+      const entry = this._providers.get(providerName);
+      if (!entry) {
+        throw new Error(`[wu-ai] Provider '${providerName}' not registered. Available: ${[...this._providers.keys()].join(', ')}`);
+      }
+      return { adapter: entry.adapter, config: entry.config };
+    }
+    this._ensureActive();
+    return { adapter: this._active, config: this._activeConfig };
+  }
+
   _ensureActive() {
     if (!this._active) {
       throw new Error(

package/src/ai/wu-ai.js

@@ -6,19 +6,35 @@
  *
  * Architecture:
  *   WuAI (this file)
- *     ├── WuAIProvider      → BYOL provider management
- *     ├── WuAIPermissions   → Security, rate limiting, circuit breaker
- *     ├── WuAIContext        → Auto context collection for LLM
- *     ├── WuAIActions        → Tool/action registry and execution
- *     ├── WuAIConversation   → Multi-turn conversation manager
- *     └── WuAITriggers       → Event-to-AI bridge (reactive AI)
+ *     ├── WuAIProvider         → BYOL provider management (OpenAI, Anthropic, Ollama, Custom)
+ *     ├── WuAIPermissions      → 4-layer security (perms, rate limit, circuit breaker, loop guard)
+ *     ├── WuAIContext           → Auto context collection with token budget
+ *     ├── WuAIActions           → Tool/action registry and sandboxed execution
+ *     ├── WuAIConversation      → Multi-turn conversation manager with namespaces
+ *     ├── WuAITriggers          → Event-to-AI reactive bridge
+ *     ├── WuAIAgent             → Autonomous agent loop (goal → steps → done)
+ *     ├── WuAIOrchestrate       → Cross-micro-app AI coordination (capabilities + intents)
+ *     └── BrowserPrimitives     → Shared screenshot, click, type, a11y tree, interceptors
+ *
+ * Four Paradigms:
+ *   1. App → LLM    send/stream/json → conversation with tool loops
+ *   2. LLM → App    tools/execute/expose → external agents call into the app
+ *   3. AI Director  agent(goal) → autonomous multi-step loop
+ *   4. MF Glue      capability/intent → cross-app coordination via AI
  *
  * Public API (accessible via wu.ai):
  *   wu.ai.provider(name, config)   → Register LLM provider
  *   wu.ai.send(message, opts)      → Send message (non-streaming)
  *   wu.ai.stream(message, opts)    → Send message (streaming)
+ *   wu.ai.json(message, schema?)   → Send and get parsed JSON back
+ *   wu.ai.agent(goal, opts)        → Run autonomous agent loop
  *   wu.ai.action(name, config)     → Register an action/tool
  *   wu.ai.trigger(name, config)    → Register an event trigger
+ *   wu.ai.capability(app, name, c) → Register app-scoped capability
+ *   wu.ai.intent(desc, opts)       → Resolve cross-app intent
+ *   wu.ai.removeApp(appName)       → Remove app capabilities (unmount)
+ *   wu.ai.workflow(name, config)   → Register reusable AI workflow
+ *   wu.ai.runWorkflow(name, params)→ Execute workflow (async generator)
  *   wu.ai.context.configure(...)   → Configure context collection
  *   wu.ai.abort(namespace?)        → Abort active request
  *
@@ -35,6 +51,8 @@ import { WuAIContext } from './wu-ai-context.js';
 import { WuAIActions } from './wu-ai-actions.js';
 import { WuAIConversation } from './wu-ai-conversation.js';
 import { WuAITriggers } from './wu-ai-triggers.js';
+import { WuAIAgent } from './wu-ai-agent.js';
+import { WuAIOrchestrate } from './wu-ai-orchestrate.js';
 import { registerBrowserActions } from './wu-ai-browser.js';
 
 export class WuAI {
@@ -125,10 +143,38 @@ export class WuAI {
       this._modules.triggers.configure(config.triggers);
     }
 
+    // 7. Agent (depends on conversation, actions, context, permissions, eventBus)
+    this._modules.agent = new WuAIAgent({
+      conversation: this._modules.conversation,
+      actions: this._modules.actions,
+      context: this._modules.context,
+      permissions: this._modules.permissions,
+      eventBus: this._eventBus,
+    });
+    if (config.agent) {
+      this._modules.agent.configure(config.agent);
+    }
+
+    // 8. Orchestrate — Paradigm 4: AI as microfrontend glue
+    //    Agent ref is passed so workflows can delegate to the agent loop
+    //    Store ref is passed for deterministic setState steps
+    this._modules.orchestrate = new WuAIOrchestrate({
+      actions: this._modules.actions,
+      conversation: this._modules.conversation,
+      context: this._modules.context,
+      permissions: this._modules.permissions,
+      eventBus: this._eventBus,
+      agent: this._modules.agent,
+      store: this._store,
+    });
+    if (config.orchestrate) {
+      this._modules.orchestrate.configure(config.orchestrate);
+    }
+
     this._initialized = true;
     logger.wuInfo('[wu-ai] Initialized');
 
-    // 7. Browser automation actions (screenshot, click, type, network, etc.)
+    // 9. Browser automation actions (screenshot, click, type, network, etc.)
     // Must be AFTER _initialized = true to prevent recursive init loop
     if (typeof window !== 'undefined') {
       registerBrowserActions(this, this._core);
@@ -177,7 +223,12 @@ export class WuAI {
    * Send a message to the LLM and get a complete response.
    *
    * @param {string} message - User message
-   * @param {object} [options] - { namespace, systemPrompt, templateVars, temperature, maxTokens, signal }
+   * @param {object} [options] - { namespace, systemPrompt, templateVars, temperature, maxTokens, provider, responseFormat, signal }
+   * @param {string} [options.provider] - Use a specific registered provider (e.g., 'anthropic', 'openai')
+   * @param {string|object} [options.responseFormat] - Request JSON output.
+   *   - `'json'` — simple JSON mode (OpenAI: json_object, Ollama: format:"json", Anthropic: prompt injection)
+   *   - `{ type: 'json_schema', schema: {...}, name?: string }` — structured output with JSON Schema
+   *     (OpenAI: native json_schema mode, Ollama: schema in format, Anthropic: schema in system prompt)
    * @returns {Promise<{ content: string, tool_results?: Array, usage?: object, namespace: string }>}
    *
    * @example
@@ -186,6 +237,21 @@ export class WuAI {
    *
    * // With namespace for separate conversation
    * const response = await wu.ai.send('Analyze this chart', { namespace: 'analytics' });
+   *
+   * // Use a specific provider for this message
+   * const response = await wu.ai.send('Translate this', { provider: 'anthropic' });
+   *
+   * // Simple JSON mode
+   * const response = await wu.ai.send('List 5 colors', { responseFormat: 'json' });
+   *
+   * // Structured output with JSON Schema
+   * const response = await wu.ai.send('List 5 colors', {
+   *   responseFormat: {
+   *     type: 'json_schema',
+   *     schema: { type: 'object', properties: { colors: { type: 'array', items: { type: 'string' } } } },
+   *     name: 'color_list',
+   *   },
+   * });
    */
   async send(message, options = {}) {
     this._ensureInit();
@@ -210,6 +276,71 @@ export class WuAI {
     yield* this._modules.conversation.stream(message, options);
   }
 
+  /**
+   * Send a message and get a parsed JSON response.
+   * Shortcut for send() with responseFormat + automatic JSON.parse().
+   *
+   * @param {string} message - User message
+   * @param {object} [options] - All send() options plus:
+   * @param {object} [options.schema] - JSON Schema for structured output
+   * @param {string} [options.schemaName='response'] - Schema name (required by OpenAI)
+   * @returns {Promise<{ data: object|null, raw: string, error?: string, usage?: object, namespace: string }>}
+   *
+   * @example
+   * // Simple JSON (no schema)
+   * const { data } = await wu.ai.json('List 5 colors as a JSON array');
+   * // data = ["red", "blue", ...]
+   *
+   * // With schema
+   * const { data } = await wu.ai.json('List 5 colors', {
+   *   schema: { type: 'object', properties: { colors: { type: 'array', items: { type: 'string' } } } },
+   * });
+   * // data = { colors: ["red", "blue", ...] }
+   *
+   * // With schema + provider
+   * const { data } = await wu.ai.json('List 5 colors', {
+   *   schema: mySchema,
+   *   provider: 'openai',
+   *   temperature: 0,
+   * });
+   */
+  async json(message, options = {}) {
+    this._ensureInit();
+
+    const { schema, schemaName, ...rest } = options;
+
+    let responseFormat;
+    if (schema) {
+      responseFormat = { type: 'json_schema', schema, name: schemaName || 'response' };
+    } else {
+      responseFormat = options.responseFormat || 'json';
+    }
+
+    const response = await this._modules.conversation.send(message, { ...rest, responseFormat });
+
+    // The provider already attempts parse and sets response.parsed / response.parseError
+    let data = null;
+    let error;
+
+    if (response.parsed !== undefined) {
+      data = response.parsed;
+    } else if (response.content) {
+      try {
+        data = JSON.parse(response.content);
+      } catch {
+        error = 'LLM response is not valid JSON';
+      }
+    }
+
+    return {
+      data,
+      raw: response.content || '',
+      error: error || response.parseError,
+      usage: response.usage,
+      namespace: response.namespace,
+    };
+  }
+
   /**
    * Abort active request(s).
    *
@@ -300,6 +431,199 @@ export class WuAI {
     return this._modules.triggers.fire(name, eventData);
   }
 
+  // ─── Agent (Paradigm 3: Autonomous AI) ─────────────────────────
+
+  /**
+   * Run an autonomous agent that pursues a goal using available tools.
+   * Returns an async generator that yields step-by-step results.
+   *
+   * @param {string} goal - What the agent should accomplish
+   * @param {object} [options]
+   * @param {number} [options.maxSteps=10] - Maximum autonomous steps
+   * @param {string} [options.provider] - Which LLM provider to use
+   * @param {string} [options.namespace] - Conversation namespace
+   * @param {string} [options.systemPrompt] - Override system prompt
+   * @param {Function} [options.onStep] - Callback per step: (stepResult) => void
+   * @param {Function} [options.shouldContinue] - Human-in-the-loop: (stepResult) => boolean|Promise<boolean>
+   * @param {AbortSignal} [options.signal] - Abort signal
+   * @returns {AsyncGenerator<AgentStepResult>}
+   *
+   * @example
+   * // Basic usage
+   * for await (const step of wu.ai.agent('Find all orders above $100 and summarize them')) {
+   *   console.log(`Step ${step.step}: ${step.content?.slice(0, 100)}`);
+   *   if (step.done) console.log('Agent finished!');
+   * }
+   *
+   * // With human-in-the-loop
+   * for await (const step of wu.ai.agent('Reorganize the product catalog', {
+   *   shouldContinue: (step) => confirm(`Continue? Step ${step.step}: ${step.content?.slice(0, 50)}`),
+   * })) {
+   *   updateUI(step);
+   * }
+   */
+  async *agent(goal, options = {}) {
+    this._ensureInit();
+    yield* this._modules.agent.run(goal, options);
+  }
+
+  // ─── Paradigm 4: AI as Microfrontend Glue ─────────────────────
+
+  /**
+   * Register a capability scoped to a specific micro-app.
+   *
+   * Each micro-app calls this to declare what it can do. The AI uses
+   * the capability map to resolve cross-app intents.
+   *
+   * @param {string} appName - The micro-app name (e.g., 'orders', 'dashboard')
+   * @param {string} actionName - The capability name (e.g., 'getRecent', 'updateKPIs')
+   * @param {object} config - Same as wu.ai.action() config:
+   *   { description, parameters, handler, confirm?, permissions?, dangerous? }
+   *
+   * @example
+   * // In orders micro-app (React):
+   * wu.ai.capability('orders', 'getRecent', {
+   *   description: 'Get the N most recent orders',
+   *   parameters: { limit: { type: 'number' } },
+   *   handler: async (params) => fetchOrders({ limit: params.limit || 10 }),
+   * });
+   *
+   * // In dashboard micro-app (Svelte):
+   * wu.ai.capability('dashboard', 'updateKPIs', {
+   *   description: 'Refresh the KPI cards with latest data',
+   *   handler: async () => { refreshKPIs(); return { updated: true }; },
+   * });
+   */
+  capability(appName, actionName, config) {
+    this._ensureInit();
+    this._modules.orchestrate.register(appName, actionName, config);
+    return this;
+  }
+
+  /**
+   * Resolve a cross-app intent in a single conversation turn.
+   *
+   * The AI receives the full capability map (what each app can do),
+   * current application state, and mounted apps. It resolves the
+   * intent by calling the right capabilities across app boundaries.
+   *
+   * @param {string} description - Natural language intent
+   * @param {object} [options]
+   * @param {string[]} [options.plan] - Optional action sequence hint
+   * @param {string} [options.provider] - LLM provider override
+   * @param {number} [options.temperature] - Temperature override
+   * @param {number} [options.maxTokens] - Max tokens override
+   * @param {AbortSignal} [options.signal] - Abort signal
+   * @param {string|object} [options.responseFormat] - Response format
+   * @returns {Promise<{ content: string, tool_results: Array, usage: object|null, resolved: boolean, appsInvolved: string[] }>}
+   *
+   * @example
+   * // Simple cross-app query
+   * const result = await wu.ai.intent('Show me the top customer by order count');
+   * // AI calls orders:getRecent → aggregates → returns answer
+   *
+   * // With plan hint
+   * const result = await wu.ai.intent('Update all views after a new order', {
+   *   plan: ['orders:getRecent', 'dashboard:updateKPIs', 'analytics:refresh'],
+   * });
+   *
+   * // With JSON response
+   * const result = await wu.ai.intent('Get order stats by status', {
+   *   responseFormat: 'json',
+   * });
+   */
+  async intent(description, options = {}) {
+    this._ensureInit();
+    return this._modules.orchestrate.resolve(description, options);
+  }
+
+  /**
+   * Remove all capabilities for a micro-app.
+   * Call this when a micro-app is unmounted to prevent stale
+   * capabilities from appearing in the AI's capability map.
+   *
+   * @param {string} appName - The micro-app name
+   *
+   * @example
+   * // In unmount lifecycle:
+   * wu.ai.removeApp('orders');
+   */
+  removeApp(appName) {
+    this._ensureInit();
+    this._modules.orchestrate.removeApp(appName);
+    return this;
+  }
+
+  /**
+   * Register a reusable AI workflow — a named, step-by-step recipe
+   * that the AI agent follows using browser automation.
+   *
+   * @param {string} name - Workflow name (e.g., 'register-user')
+   * @param {object} config
+   * @param {string} config.description - What this workflow does
+   * @param {string[]} config.steps - Step-by-step instructions
+   *   Use {{paramName}} for parameter interpolation.
+   * @param {object} [config.parameters] - Parameter definitions
+   * @param {number} [config.maxSteps=15] - Max agent steps
+   * @param {string} [config.provider] - LLM provider
+   *
+   * @example
+   * wu.ai.workflow('register-user', {
+   *   description: 'Register a new user in the system',
+   *   steps: [
+   *     'Navigate to the Customers section',
+   *     'Click the "Add Customer" button',
+   *     'Type "{{name}}" into the name field',
+   *     'Type "{{email}}" into the email field',
+   *     'Click Submit',
+   *     'Verify the success message appears',
+   *   ],
+   *   parameters: {
+   *     name: { type: 'string', required: true },
+   *     email: { type: 'string', required: true },
+   *   },
+   * });
+   */
+  workflow(name, config) {
+    this._ensureInit();
+    this._modules.orchestrate.registerWorkflow(name, config);
+    return this;
+  }
+
+  /**
+   * Execute a registered workflow. Returns an async generator
+   * so you can observe each step in real time.
+   *
+   * @param {string} name - Workflow name
+   * @param {object} [params={}] - Parameters to fill into the steps
+   * @param {object} [options={}]
+   * @param {Function} [options.onStep] - Callback per step
+   * @param {Function} [options.shouldContinue] - Human-in-the-loop gate
+   * @param {AbortSignal} [options.signal] - Abort signal
+   * @returns {AsyncGenerator<AgentStepResult>}
+   *
+   * @example
+   * // Run and watch every step
+   * for await (const step of wu.ai.runWorkflow('register-user', {
+   *   name: 'Juan Pérez',
+   *   email: 'juan@test.com',
+   * })) {
+   *   console.log(`Step ${step.step}: ${step.content}`);
+   *   if (step.type === 'done') console.log('Workflow complete!');
+   * }
+   *
+   * // With human approval per step
+   * for await (const step of wu.ai.runWorkflow('register-user', params, {
+   *   shouldContinue: (s) => confirm(`Continue? ${s.content?.slice(0, 60)}`),
+   * })) {
+   *   renderStep(step);
+   * }
+   */
+  async *runWorkflow(name, params = {}, options = {}) {
+    this._ensureInit();
+    yield* this._modules.orchestrate.executeWorkflow(name, params, options);
+  }
+
   // ─── Context ───────────────────────────────────────────────────
 
   /**
@@ -436,6 +760,8 @@ export class WuAI {
       actions: this._modules.actions.getStats(),
       conversation: this._modules.conversation.getStats(),
       triggers: this._modules.triggers.getStats(),
+      agent: this._modules.agent.getStats(),
+      orchestrate: this._modules.orchestrate.getStats(),
     };
   }
 
@@ -445,6 +771,8 @@ export class WuAI {
   destroy() {
     if (!this._initialized) return;
 
+    this._modules.orchestrate.destroy();
+    this._modules.agent.destroy();
     this._modules.conversation.abortAll();
     this._modules.triggers.destroy();
     this._modules = {};
@@ -470,5 +798,7 @@ export class WuAI {
     if (config.context) this._modules.context.configure(config.context);
     if (config.conversation) this._modules.conversation.configure(config.conversation);
     if (config.triggers) this._modules.triggers.configure(config.triggers);
+    if (config.agent) this._modules.agent.configure(config.agent);
+    if (config.orchestrate) this._modules.orchestrate.configure(config.orchestrate);
   }
 }

package/src/core/wu-cache.js

@@ -16,8 +16,7 @@ export class WuCache {
       maxItems: options.maxItems || 100,
       defaultTTL: options.defaultTTL || 3600000, // 1 hour
       persistent: options.persistent !== false,
-      storage: options.storage || 'memory',
-      compression: options.compression || false
+      storage: options.storage || 'memory'
     };
 
     // 🔐 Rate limiting configuration

package/src/core/wu-core.js

@@ -123,7 +123,7 @@ export class WuCore {
 
   /**
    * Registrar una aplicacion
-   * @param {Object} appConfig - { name, url }
+   * @param {Object} appConfig - { name, url, keepAlive, sandbox, container, ... }
    */
   async registerApp(appConfig) {
     const { name, url } = appConfig;
@@ -135,10 +135,9 @@ export class WuCore {
       const manifestData = await this.manifest.load(url);
       this.manifests.set(name, manifestData);
 
-      // Registrar la app
+      // Registrar la app — preserve all config fields (keepAlive, sandbox, container, etc.)
       this.apps.set(name, {
-        name,
-        url,
+        ...appConfig,
         manifest: manifestData,
         status: 'registered'
       });