@decido/kernel-bridge 1.0.0 → 4.0.2

package/dist/index.mjs

@@ -0,0 +1,2518 @@
+// src/kernel.ts
+import { io } from "socket.io-client";
+
+// src/ai/services/providers/LLMProvider.ts
+var providers = /* @__PURE__ */ new Map();
+function registerProvider(provider) {
+  providers.set(provider.id, provider);
+  console.log(`\u{1F50C} [LLM] Provider registered: ${provider.name} (${provider.id})`);
+}
+function getProvider(id) {
+  return providers.get(id);
+}
+function getAllProviders() {
+  return Array.from(providers.values());
+}
+
+// src/ai/services/providers/OllamaProvider.ts
+var OLLAMA_BASE_URL = "http://localhost:11434";
+var DEFAULT_MODEL = "qwen2:latest";
+var OllamaProvider = class {
+  id = "ollama";
+  name = "Ollama (Local)";
+  requiresApiKey = false;
+  defaultModel = DEFAULT_MODEL;
+  async listModels() {
+    try {
+      const res = await fetch(`${OLLAMA_BASE_URL}/api/tags`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.models || []).map((m) => m.name);
+    } catch {
+      return [];
+    }
+  }
+  async checkStatus() {
+    try {
+      const res = await fetch(`${OLLAMA_BASE_URL}/api/tags`, {
+        signal: AbortSignal.timeout(2e3)
+      });
+      return res.ok ? "available" : "error";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async chat(messages, options) {
+    const model = options?.model || this.defaultModel;
+    const start = Date.now();
+    const ollamaMessages = messages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const res = await fetch(`${OLLAMA_BASE_URL}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        messages: ollamaMessages,
+        stream: false,
+        options: {
+          temperature: options?.temperature ?? 0.7,
+          num_predict: options?.maxTokens ?? 512
+        }
+      }),
+      signal: options?.signal ?? AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      const errorText = await res.text();
+      throw new Error(`Ollama API error ${res.status}: ${errorText}`);
+    }
+    const data = await res.json();
+    const latencyMs = Date.now() - start;
+    return {
+      text: data.message?.content || "(sin respuesta)",
+      model,
+      latencyMs,
+      tokensUsed: data.eval_count
+    };
+  }
+};
+
+// src/ai/services/providers/GeminiProvider.ts
+var GEMINI_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
+var DEFAULT_MODEL2 = "gemini-flash-lite-latest";
+var AVAILABLE_MODELS = [
+  "gemini-flash-lite-latest",
+  "gemini-flash-lite-latest-lite",
+  "gemini-1.5-pro",
+  "gemini-flash-latest"
+];
+var GeminiProvider = class {
+  id = "gemini";
+  name = "Google Gemini";
+  requiresApiKey = true;
+  defaultModel = DEFAULT_MODEL2;
+  apiKey = null;
+  setApiKey(key) {
+    this.apiKey = key;
+  }
+  async listModels() {
+    return AVAILABLE_MODELS;
+  }
+  async checkStatus() {
+    if (!this.apiKey) return "unconfigured";
+    try {
+      const res = await fetch(
+        `${GEMINI_API_BASE}/models?key=${this.apiKey}`,
+        { signal: AbortSignal.timeout(5e3) }
+      );
+      return res.ok ? "available" : "error";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async chat(messages, options) {
+    if (!this.apiKey) {
+      throw new Error("Gemini API key not configured. Set it in Settings \u2192 Providers.");
+    }
+    const model = options?.model || this.defaultModel;
+    const start = Date.now();
+    const systemMsg = messages.find((m) => m.role === "system");
+    const conversationMsgs = messages.filter((m) => m.role !== "system");
+    const contents = conversationMsgs.map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    const body = {
+      contents,
+      generationConfig: {
+        temperature: options?.temperature ?? 0.7,
+        maxOutputTokens: options?.maxTokens ?? 2048
+      }
+    };
+    if (systemMsg) {
+      body.systemInstruction = {
+        parts: [{ text: systemMsg.content }]
+      };
+    }
+    const url = `${GEMINI_API_BASE}/models/${model}:generateContent?key=${this.apiKey}`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: options?.signal ?? AbortSignal.timeout(6e4)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`Gemini API error ${res.status}: ${errorBody}`);
+    }
+    const data = await res.json();
+    const latencyMs = Date.now() - start;
+    const candidate = data.candidates?.[0];
+    const text = candidate?.content?.parts?.map((p) => p.text || "").join("") || "(sin respuesta)";
+    const tokensUsed = (data.usageMetadata?.promptTokenCount || 0) + (data.usageMetadata?.candidatesTokenCount || 0);
+    return {
+      text,
+      model,
+      latencyMs,
+      tokensUsed
+    };
+  }
+};
+
+// src/ai/services/providers/AnthropicProvider.ts
+var ANTHROPIC_API_BASE = "https://api.anthropic.com/v1";
+var DEFAULT_MODEL3 = "claude-sonnet-4-20250514";
+var API_VERSION = "2023-06-01";
+var AVAILABLE_MODELS2 = [
+  "claude-sonnet-4-20250514",
+  "claude-3-5-sonnet-20241022",
+  "claude-3-5-haiku-20241022",
+  "claude-3-opus-20240229"
+];
+var AnthropicProvider = class {
+  id = "anthropic";
+  name = "Anthropic Claude";
+  requiresApiKey = true;
+  defaultModel = DEFAULT_MODEL3;
+  apiKey = null;
+  setApiKey(key) {
+    this.apiKey = key;
+  }
+  async listModels() {
+    return AVAILABLE_MODELS2;
+  }
+  async checkStatus() {
+    if (!this.apiKey) return "unconfigured";
+    try {
+      const res = await fetch(`${ANTHROPIC_API_BASE}/messages`, {
+        method: "POST",
+        headers: {
+          "x-api-key": this.apiKey,
+          "anthropic-version": API_VERSION,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.defaultModel,
+          max_tokens: 1,
+          messages: [{ role: "user", content: "ping" }]
+        }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      return res.ok || res.status === 429 ? "available" : "error";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async chat(messages, options) {
+    if (!this.apiKey) {
+      throw new Error("Anthropic API key not configured. Set it in Settings \u2192 Providers.");
+    }
+    const model = options?.model || this.defaultModel;
+    const start = Date.now();
+    const systemMsg = messages.find((m) => m.role === "system");
+    const conversationMsgs = messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const sanitized = this._sanitizeMessages(conversationMsgs);
+    const body = {
+      model,
+      max_tokens: options?.maxTokens ?? 2048,
+      messages: sanitized
+    };
+    if (options?.temperature !== void 0) {
+      body.temperature = options.temperature;
+    }
+    if (systemMsg) {
+      body.system = systemMsg.content;
+    }
+    const res = await fetch(`${ANTHROPIC_API_BASE}/messages`, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": API_VERSION,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: options?.signal ?? AbortSignal.timeout(6e4)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`Anthropic API error ${res.status}: ${errorBody}`);
+    }
+    const data = await res.json();
+    const latencyMs = Date.now() - start;
+    const text = (data.content || []).filter((block) => block.type === "text").map((block) => block.text).join("") || "(sin respuesta)";
+    const tokensUsed = (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0);
+    return { text, model, latencyMs, tokensUsed };
+  }
+  /** Stream chat completion — yields text chunks */
+  async *chatStream(messages, options) {
+    if (!this.apiKey) {
+      throw new Error("Anthropic API key not configured.");
+    }
+    const model = options?.model || this.defaultModel;
+    const systemMsg = messages.find((m) => m.role === "system");
+    const conversationMsgs = messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content }));
+    const sanitized = this._sanitizeMessages(conversationMsgs);
+    const body = {
+      model,
+      max_tokens: options?.maxTokens ?? 2048,
+      messages: sanitized,
+      stream: true
+    };
+    if (options?.temperature !== void 0) body.temperature = options.temperature;
+    if (systemMsg) body.system = systemMsg.content;
+    const res = await fetch(`${ANTHROPIC_API_BASE}/messages`, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": API_VERSION,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: options?.signal ?? AbortSignal.timeout(12e4)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`Anthropic stream error ${res.status}: ${errorBody}`);
+    }
+    const reader = res.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") return;
+        try {
+          const event = JSON.parse(data);
+          if (event.type === "content_block_delta" && event.delta?.text) {
+            yield event.delta.text;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  /** Ensure alternating user/assistant (Anthropic requires this) */
+  _sanitizeMessages(msgs) {
+    if (msgs.length === 0) return [{ role: "user", content: "..." }];
+    const result = [];
+    let lastRole = "";
+    for (const msg of msgs) {
+      if (msg.role === lastRole) {
+        result[result.length - 1].content += "\n" + msg.content;
+      } else {
+        result.push({ ...msg });
+        lastRole = msg.role;
+      }
+    }
+    if (result[0]?.role !== "user") {
+      result.unshift({ role: "user", content: "..." });
+    }
+    return result;
+  }
+};
+
+// src/ai/services/providers/OpenAIProvider.ts
+var OPENAI_API_BASE = "https://api.openai.com/v1";
+var DEFAULT_MODEL4 = "gpt-4o";
+var AVAILABLE_MODELS3 = [
+  "gpt-4o",
+  "gpt-4o-mini",
+  "gpt-4-turbo",
+  "gpt-4",
+  "gpt-3.5-turbo",
+  "o3-mini"
+];
+var OpenAIProvider = class {
+  id = "openai";
+  name = "OpenAI";
+  requiresApiKey = true;
+  defaultModel = DEFAULT_MODEL4;
+  apiKey = null;
+  baseUrl = OPENAI_API_BASE;
+  setApiKey(key) {
+    this.apiKey = key;
+  }
+  /** Override base URL for OpenAI-compatible endpoints */
+  setBaseUrl(url) {
+    this.baseUrl = url.replace(/\/$/, "");
+  }
+  async listModels() {
+    if (!this.apiKey) return AVAILABLE_MODELS3;
+    try {
+      const res = await fetch(`${this.baseUrl}/models`, {
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) return AVAILABLE_MODELS3;
+      const data = await res.json();
+      const models = (data.data || []).map((m) => m.id).filter((id) => id.startsWith("gpt-") || id.startsWith("o"));
+      return models.length > 0 ? models : AVAILABLE_MODELS3;
+    } catch {
+      return AVAILABLE_MODELS3;
+    }
+  }
+  async checkStatus() {
+    if (!this.apiKey) return "unconfigured";
+    try {
+      const res = await fetch(`${this.baseUrl}/models`, {
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        signal: AbortSignal.timeout(5e3)
+      });
+      return res.ok ? "available" : "error";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async chat(messages, options) {
+    if (!this.apiKey) {
+      throw new Error("OpenAI API key not configured. Set it in Settings \u2192 Providers.");
+    }
+    const model = options?.model || this.defaultModel;
+    const start = Date.now();
+    const body = {
+      model,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      temperature: options?.temperature ?? 0.7,
+      max_tokens: options?.maxTokens ?? 2048
+    };
+    const res = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: options?.signal ?? AbortSignal.timeout(6e4)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`OpenAI API error ${res.status}: ${errorBody}`);
+    }
+    const data = await res.json();
+    const latencyMs = Date.now() - start;
+    const text = data.choices?.[0]?.message?.content || "(sin respuesta)";
+    const tokensUsed = (data.usage?.prompt_tokens || 0) + (data.usage?.completion_tokens || 0);
+    return { text, model, latencyMs, tokensUsed };
+  }
+  /** Stream chat completion — yields text chunks */
+  async *chatStream(messages, options) {
+    if (!this.apiKey) {
+      throw new Error("OpenAI API key not configured.");
+    }
+    const model = options?.model || this.defaultModel;
+    const body = {
+      model,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      temperature: options?.temperature ?? 0.7,
+      max_tokens: options?.maxTokens ?? 2048,
+      stream: true
+    };
+    const res = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: options?.signal ?? AbortSignal.timeout(12e4)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`OpenAI stream error ${res.status}: ${errorBody}`);
+    }
+    const reader = res.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") return;
+        try {
+          const chunk = JSON.parse(data);
+          const delta = chunk.choices?.[0]?.delta?.content;
+          if (delta) yield delta;
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/ai/services/TokenWallet.ts
+var PRICING = {
+  // Ollama / local — free
+  "qwen2:latest": { input: 0, output: 0 },
+  "llama3:latest": { input: 0, output: 0 },
+  "mistral:latest": { input: 0, output: 0 },
+  "codellama:latest": { input: 0, output: 0 },
+  // Gemini
+  "gemini-flash-lite-latest": { input: 0.1, output: 0.4 },
+  "gemini-flash-lite-latest-lite": { input: 0.075, output: 0.3 },
+  "gemini-1.5-pro": { input: 1.25, output: 5 },
+  "gemini-flash-latest": { input: 0.075, output: 0.3 },
+  // Anthropic
+  "claude-sonnet-4-20250514": { input: 3, output: 15 },
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+  "claude-3-opus-20240229": { input: 15, output: 75 },
+  // OpenAI
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4": { input: 30, output: 60 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+  "o3-mini": { input: 1.1, output: 4.4 }
+};
+var DEFAULT_PRICING = { input: 1, output: 3 };
+var STORAGE_KEY = "decido-token-wallet";
+var MAX_HISTORY = 500;
+var TokenWalletImpl = class {
+  history = [];
+  sessionStart = Date.now();
+  listeners = /* @__PURE__ */ new Set();
+  constructor() {
+    this._loadFromStorage();
+  }
+  // ── Record Usage ────────────────────────────────────────
+  record(entry) {
+    const totalTokens = entry.tokensUsed ?? (entry.inputTokens ?? 0) + (entry.outputTokens ?? 0);
+    const inputTokens = entry.inputTokens ?? Math.round(totalTokens * 0.4);
+    const outputTokens = entry.outputTokens ?? totalTokens - inputTokens;
+    const pricing = this._getPricing(entry.model, entry.provider);
+    const estimatedCostUsd = inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
+    const usageEntry = {
+      provider: entry.provider,
+      model: entry.model,
+      inputTokens,
+      outputTokens,
+      totalTokens,
+      estimatedCostUsd,
+      timestamp: Date.now()
+    };
+    this.history.push(usageEntry);
+    if (this.history.length > MAX_HISTORY) {
+      this.history = this.history.slice(-MAX_HISTORY);
+    }
+    this._saveToStorage();
+    this._emit();
+    console.log(
+      `\u{1F4B0} [Wallet] ${entry.provider}/${entry.model}: ${totalTokens} tokens \u2248 $${estimatedCostUsd.toFixed(6)}`
+    );
+  }
+  // ── Summary ─────────────────────────────────────────────
+  getSummary() {
+    const byProvider = {};
+    let totalTokens = 0;
+    let totalCostUsd = 0;
+    for (const entry of this.history) {
+      totalTokens += entry.totalTokens;
+      totalCostUsd += entry.estimatedCostUsd;
+      if (!byProvider[entry.provider]) {
+        byProvider[entry.provider] = { tokens: 0, cost: 0, calls: 0 };
+      }
+      byProvider[entry.provider].tokens += entry.totalTokens;
+      byProvider[entry.provider].cost += entry.estimatedCostUsd;
+      byProvider[entry.provider].calls += 1;
+    }
+    return {
+      totalTokens,
+      totalCostUsd,
+      totalCalls: this.history.length,
+      byProvider,
+      sessionStart: this.sessionStart
+    };
+  }
+  getHistory() {
+    return [...this.history];
+  }
+  getRecentHistory(count) {
+    return this.history.slice(-count);
+  }
+  // ── Lifecycle ───────────────────────────────────────────
+  clearHistory() {
+    this.history = [];
+    this.sessionStart = Date.now();
+    this._saveToStorage();
+    this._emit();
+  }
+  // ── Subscriptions ───────────────────────────────────────
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  // ── Pricing Lookup ──────────────────────────────────────
+  _getPricing(model, provider) {
+    if (PRICING[model]) return PRICING[model];
+    if (provider === "ollama" || provider === "mlx") {
+      return { input: 0, output: 0 };
+    }
+    return DEFAULT_PRICING;
+  }
+  // ── Persistence ─────────────────────────────────────────
+  _saveToStorage() {
+    try {
+      const data = JSON.stringify({
+        history: this.history,
+        sessionStart: this.sessionStart
+      });
+      localStorage.setItem(STORAGE_KEY, data);
+    } catch {
+    }
+  }
+  _loadFromStorage() {
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      if (raw) {
+        const data = JSON.parse(raw);
+        this.history = data.history || [];
+        this.sessionStart = data.sessionStart || Date.now();
+      }
+    } catch {
+    }
+  }
+  // ── Emit ────────────────────────────────────────────────
+  _emit() {
+    const summary = this.getSummary();
+    for (const listener of this.listeners) {
+      try {
+        listener(summary);
+      } catch {
+      }
+    }
+  }
+};
+var tokenWallet = new TokenWalletImpl();
+
+// src/ai/services/InferenceRouter.ts
+var DEFAULT_CONFIG = {
+  preferredBackend: "auto",
+  maxLatencyMs: 3e4,
+  enableFallback: true,
+  temperature: 0.7,
+  maxTokens: 512
+};
+var _initialized = false;
+function ensureProviders() {
+  if (_initialized) return;
+  _initialized = true;
+  registerProvider(new OllamaProvider());
+  registerProvider(new GeminiProvider());
+  registerProvider(new AnthropicProvider());
+  registerProvider(new OpenAIProvider());
+  console.log("\u{1F50C} [InferenceRouter] 4 providers initialized (Ollama, Gemini, Anthropic, OpenAI)");
+}
+var _cachedKeys = null;
+async function getInvoke() {
+  try {
+    const tauri = await import("@tauri-apps/api/core");
+    return tauri.invoke;
+  } catch {
+    return null;
+  }
+}
+async function loadProviderKeys() {
+  if (_cachedKeys) return _cachedKeys;
+  try {
+    const invoke = await getInvoke();
+    if (invoke) {
+      const raw = await invoke("load_provider_keys");
+      if (raw) {
+        _cachedKeys = JSON.parse(raw);
+        return _cachedKeys;
+      }
+    }
+  } catch (e) {
+    console.warn("[InferenceRouter] Failed to load provider keys:", e);
+  }
+  try {
+    const stored = localStorage.getItem("macia-provider-keys");
+    if (stored) {
+      _cachedKeys = JSON.parse(stored);
+      return _cachedKeys;
+    }
+  } catch {
+  }
+  _cachedKeys = {};
+  return _cachedKeys;
+}
+async function saveProviderKeys(keys) {
+  _cachedKeys = keys;
+  try {
+    const invoke = await getInvoke();
+    if (invoke) {
+      await invoke("save_provider_keys", {
+        json: JSON.stringify(keys, null, 2)
+      });
+      return;
+    }
+  } catch (e) {
+    console.warn("[InferenceRouter] Failed to save provider keys via Tauri:", e);
+  }
+  try {
+    localStorage.setItem("macia-provider-keys", JSON.stringify(keys));
+  } catch {
+  }
+}
+async function initProviders() {
+  ensureProviders();
+  const keys = await loadProviderKeys();
+  const providerKeyMap = {
+    gemini: keys.gemini,
+    anthropic: keys.anthropic,
+    openai: keys.openai
+  };
+  for (const [id, key] of Object.entries(providerKeyMap)) {
+    if (key) {
+      const provider = getProvider(id);
+      provider?.setApiKey?.(key);
+      console.log(`\u{1F511} [InferenceRouter] ${id} API key loaded`);
+    }
+  }
+}
+async function setProviderApiKey(providerId, apiKey) {
+  const provider = getProvider(providerId);
+  if (provider?.setApiKey) {
+    provider.setApiKey(apiKey);
+  }
+  const keys = await loadProviderKeys();
+  keys[providerId] = apiKey;
+  await saveProviderKeys(keys);
+}
+async function getProviderStatuses() {
+  ensureProviders();
+  const statuses = {};
+  for (const provider of getAllProviders()) {
+    statuses[provider.id] = await provider.checkStatus();
+  }
+  return statuses;
+}
+function classifyTask(prompt) {
+  const lower = prompt.toLowerCase();
+  const toolPatterns = [
+    "ejecuta",
+    "revisa",
+    "escanea",
+    "limpia",
+    "optimiza",
+    "monitorea",
+    "diagnostica",
+    "analiza el sistema",
+    "procesos",
+    "disco",
+    "memoria",
+    "red",
+    "seguridad",
+    "git",
+    "commit",
+    "deploy",
+    "backup"
+  ];
+  if (toolPatterns.some((p) => lower.includes(p))) return "tool-calling";
+  const codePatterns = ["codigo", "funcion", "clase", "error", "debug", "refactor", "typescript", "python", "rust"];
+  if (codePatterns.some((p) => lower.includes(p))) return "code";
+  const analysisPatterns = ["analiza", "compara", "benchmark", "rendimiento", "metricas", "estadisticas"];
+  if (analysisPatterns.some((p) => lower.includes(p))) return "analysis";
+  const creativePatterns = ["genera", "crea", "escribe", "inventa", "imagina", "dise\xF1a"];
+  if (creativePatterns.some((p) => lower.includes(p))) return "creative";
+  return "chat";
+}
+async function routeChat(messages, config = {}) {
+  ensureProviders();
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const providerOrder = resolveProviderOrder(cfg.preferredBackend);
+  for (const providerId of providerOrder) {
+    const provider = getProvider(providerId);
+    if (!provider) continue;
+    const status = await provider.checkStatus();
+    if (status !== "available") {
+      if (!cfg.enableFallback) {
+        throw new Error(`Provider ${provider.name} is ${status}`);
+      }
+      continue;
+    }
+    try {
+      const result = await provider.chat(messages, {
+        model: void 0,
+        // use provider default
+        temperature: cfg.temperature,
+        maxTokens: cfg.maxTokens
+      });
+      tokenWallet.record({
+        provider: providerId,
+        model: result.model,
+        tokensUsed: result.tokensUsed
+      });
+      return {
+        ...result,
+        backend: providerId
+      };
+    } catch (err) {
+      console.warn(`[InferenceRouter] ${provider.name} failed:`, err);
+      if (!cfg.enableFallback) throw err;
+    }
+  }
+  throw new Error("No hay backends de IA disponibles. Inicia Ollama o configura una API key de Gemini.");
+}
+function resolveProviderOrder(preferred) {
+  switch (preferred) {
+    case "ollama":
+      return ["ollama", "gemini", "anthropic", "openai"];
+    case "gemini":
+      return ["gemini", "ollama", "anthropic", "openai"];
+    case "anthropic":
+      return ["anthropic", "gemini", "ollama", "openai"];
+    case "openai":
+      return ["openai", "gemini", "ollama", "anthropic"];
+    case "auto":
+    default:
+      return ["ollama", "gemini", "anthropic", "openai"];
+  }
+}
+async function routeInference(prompt, config = {}) {
+  const messages = [
+    { role: "user", content: prompt }
+  ];
+  try {
+    const result = await routeChat(messages, config);
+    return {
+      text: result.text,
+      backend: result.backend,
+      model: result.model,
+      latencyMs: result.latencyMs,
+      tokensPerSecond: result.tokensUsed ? result.tokensUsed / (result.latencyMs / 1e3) : 0,
+      toolsInvoked: []
+    };
+  } catch {
+    return {
+      text: "No hay backends disponibles. Inicia Ollama o configura un modelo.",
+      backend: "auto",
+      model: "none",
+      latencyMs: 0,
+      tokensPerSecond: 0,
+      toolsInvoked: []
+    };
+  }
+}
+var inferenceRouter = {
+  route: routeInference,
+  routeChat,
+  classifyTask,
+  initProviders,
+  getProviderStatuses,
+  setProviderApiKey,
+  loadProviderKeys,
+  getAllProviders,
+  getProvider,
+  tokenWallet
+};
+
+// src/kernel.ts
+import { createSafeEvent } from "@decido/sdk";
+async function getTauriCore() {
+  return import("@tauri-apps/api/core");
+}
+async function getTauriEvent() {
+  return import("@tauri-apps/api/event");
+}
+var TauriTransport = class {
+  name = "Anillo 0/1 (Tauri IPC)";
+  isConnectedToCloud = false;
+  unlistenFns = [];
+  connectToSwarm(tenantId, url, token) {
+    console.log(`[Kernel/Tauri] Conexi\xF3n nativa delegada a Core-Rust para tenant: ${tenantId}`);
+  }
+  async execute(tenantId, cmd, args) {
+    const { invoke } = await getTauriCore();
+    return invoke(cmd, { tenantId, ...args });
+  }
+  async notify(title, body) {
+    try {
+      const { sendNotification } = await import("@tauri-apps/plugin-notification");
+      await sendNotification({ title, body });
+    } catch (e) {
+      console.log("[Kernel/Tauri] Notification plugin not available.");
+    }
+  }
+  async vibrate(pattern) {
+    try {
+      const { vibrate: nativeVibrate } = await import("@tauri-apps/plugin-haptics");
+      await nativeVibrate(pattern);
+    } catch (e) {
+      console.log("[Kernel/Tauri] Haptics not available on this platform.");
+    }
+  }
+  async getEventHistory(tenantId, limit) {
+    return this.execute(tenantId, "get_stream_history", { limit });
+  }
+  listenEvents(onEvent) {
+    let unlistenFn = null;
+    getTauriEvent().then(({ listen }) => {
+      listen("orchestrator-event", (event) => {
+        onEvent({ type: "ipc_in", channel: "orchestrator-event", payload: event.payload });
+      }).then((fn) => {
+        unlistenFn = fn;
+        this.unlistenFns.push(fn);
+      });
+    });
+    return () => {
+      if (unlistenFn) {
+        unlistenFn();
+        this.unlistenFns = this.unlistenFns.filter((f) => f !== unlistenFn);
+      }
+    };
+  }
+};
+var WebSocketTransport = class {
+  name = "Sat\xE9lite Web (WebSocket)";
+  isConnectedToCloud = false;
+  sockets = {};
+  eventListeners = /* @__PURE__ */ new Set();
+  connectToSwarm(tenantId, url, token) {
+    if (this.sockets[tenantId]) return;
+    const socket = io(url, { auth: token ? { token } : void 0 });
+    socket.on("connect", () => {
+      this.isConnectedToCloud = true;
+      console.log(`\u2705 [Kernel/WS] Sat\xE9lite conectado al Enjambre del Tenant: ${tenantId}`);
+    });
+    socket.on("orchestrator-event", (eventPayload) => {
+      this.eventListeners.forEach((cb) => cb({ type: "ipc_in", channel: "orchestrator-event", payload: { tenantId, ...eventPayload } }));
+    });
+    socket.on("rpc_broadcast", (eventPayload) => {
+      console.log(`[Kernel] \u{1F310} Broadcast Recibido [${tenantId}]:`, eventPayload);
+      this.eventListeners.forEach((cb) => cb({ type: "ipc_in", channel: "rpc_broadcast", payload: { tenantId, ...eventPayload } }));
+    });
+    this.sockets[tenantId] = socket;
+  }
+  async execute(tenantId, cmd, args) {
+    const socket = this.sockets[tenantId];
+    if (socket) {
+      return new Promise((resolve, reject) => {
+        socket.emit("rpc_call", { cmd, args }, (response) => {
+          if (response.error) reject(new Error(response.error));
+          else resolve(response.data);
+        });
+      });
+    }
+    console.warn(`[Kernel Mock] Executing ${cmd} for tenant ${tenantId}`, args);
+    return {};
+  }
+  async notify(title, body) {
+    console.log(`[Notification Mock] ${title}: ${body}`);
+  }
+  async vibrate(pattern) {
+    if (typeof navigator !== "undefined" && navigator.vibrate) {
+      navigator.vibrate(pattern === "heavy" ? 200 : 50);
+    }
+  }
+  async getEventHistory(tenantId, limit) {
+    console.warn("[Kernel Mock] Cannot fetch stream history in Web Sandbox.");
+    return [];
+  }
+  listenEvents(onEvent) {
+    this.eventListeners.add(onEvent);
+    return () => this.eventListeners.delete(onEvent);
+  }
+};
+var DecidoKernel = class {
+  logs = [];
+  logListeners = /* @__PURE__ */ new Set();
+  universalListeners = /* @__PURE__ */ new Set();
+  transport;
+  rateLimits = /* @__PURE__ */ new Map();
+  checkRateLimit(cmd) {
+    const now = Date.now();
+    const limitWin = 1e3;
+    const maxCalls = 50;
+    let tracker = this.rateLimits.get(cmd);
+    if (!tracker || tracker.resetAt < now) {
+      tracker = { calls: 0, resetAt: now + limitWin };
+      this.rateLimits.set(cmd, tracker);
+    }
+    tracker.calls++;
+    if (tracker.calls > maxCalls) {
+      console.warn(`[Kernel Throttle] \u{1F6A8} Command ${cmd} blocked (Rate limit: >50 calls/sec). Possible plugin infinite loop.`);
+      return false;
+    }
+    return true;
+  }
+  constructor() {
+    const isTauri = typeof window !== "undefined" && "__TAURI_INTERNALS__" in window;
+    this.transport = isTauri ? new TauriTransport() : new WebSocketTransport();
+    console.log(`[Kernel] Entorno Detectado. Operando en Modo ${this.transport.name}.`);
+    this.transport.listenEvents((event) => {
+      if (event.type === "ipc_in") {
+        this.addLog({ type: "ipc_in", channel: event.channel, payload: event.payload });
+        this.notifyUniversalListeners(event.payload.payload || event.payload);
+      }
+    });
+  }
+  get isConnectedToCloud() {
+    return this.transport.isConnectedToCloud;
+  }
+  connectToSwarm(tenantId, url, token) {
+    this.transport.connectToSwarm(tenantId, url, token);
+  }
+  // Validador Zod y Notificador Universal
+  notifyUniversalListeners(rawPayload) {
+    const parsed = createSafeEvent(rawPayload);
+    if (!parsed.success) {
+      console.error("[Kernel] \u{1F6A8} Inbound Mesh Event Failed Contract Validation:", parsed.error.format());
+      this.universalListeners.forEach((cb) => cb({
+        type: "system_alert",
+        source: "kernel-bridge",
+        payload: {
+          level: "error",
+          title: "Contract Violation",
+          message: "A received event did not match the strict schema. Ignored."
+        }
+      }));
+      return;
+    }
+    this.universalListeners.forEach((cb) => cb(parsed.data));
+  }
+  injectEvent(payload) {
+    this.notifyUniversalListeners(payload);
+  }
+  addLog(entry) {
+    const log = {
+      id: typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).substring(2, 9),
+      timestamp: Date.now(),
+      ...entry
+    };
+    this.logs = [log, ...this.logs].slice(0, 500);
+    this.logListeners.forEach((listener) => listener(this.logs));
+  }
+  onLogsChange(callback) {
+    this.logListeners.add(callback);
+    callback(this.logs);
+    return () => this.logListeners.delete(callback);
+  }
+  async execute(tenantIdOrCmd, cmdOrArgs, argsOpts) {
+    let tenantId = "system";
+    let cmd = tenantIdOrCmd;
+    let args = cmdOrArgs;
+    if (typeof cmdOrArgs === "string") {
+      tenantId = tenantIdOrCmd;
+      cmd = cmdOrArgs;
+      args = argsOpts;
+    }
+    if (!this.checkRateLimit(cmd)) {
+      throw new Error(`[Kernel Throttle] Request dropped for ${cmd} (Rate limit exceeded)`);
+    }
+    const start = performance.now();
+    try {
+      const result = await this.transport.execute(tenantId, cmd, args);
+      this.addLog({ type: "ipc_out", channel: cmd, payload: { tenantId, ...args }, duration: performance.now() - start });
+      return result;
+    } catch (error) {
+      this.addLog({ type: "error", channel: cmd, payload: { tenantId, args, error }, duration: performance.now() - start });
+      throw error;
+    }
+  }
+  async notify(title, body) {
+    return this.transport.notify(title, body);
+  }
+  async vibrate(pattern = "medium") {
+    return this.transport.vibrate(pattern);
+  }
+  async captureScreen(tenantId = "system") {
+    return this.execute(tenantId, "capture_screen");
+  }
+  async getMachineId(tenantId = "system") {
+    return this.execute(tenantId, "get_machine_id");
+  }
+  async initiateSingularity(tenantId = "system") {
+    return this.execute(tenantId, "initiate_singularity");
+  }
+  async broadcastMessage(tenantId, message) {
+    return this.execute(tenantId, "broadcast_message", { message });
+  }
+  async fetchMemories(tenantId = "system", query, limit = 20) {
+    return this.execute(tenantId, "fetch_memories", { query, limit });
+  }
+  async storeMemory(tenantId = "system", text, metadata = {}) {
+    return this.execute(tenantId, "store_memory", { text, metadata });
+  }
+  async deleteMemory(tenantId = "system", id) {
+    return this.execute(tenantId, "delete_memory", { id });
+  }
+  async reasonWithMLX(base64Image, prompt, previousError) {
+    let finalPrompt = prompt;
+    if (previousError) {
+      finalPrompt += `
+
+WARNING: Your previous response failed to parse as JSON with the following error: ${previousError}. Fix the JSON syntax and return ONLY a valid JSON object.`;
+    }
+    try {
+      const response = await fetch("http://127.0.0.1:8080/v1/chat/completions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: "llava",
+          messages: [{
+            role: "user",
+            content: [
+              { type: "text", text: finalPrompt },
+              { type: "image_url", image_url: { url: base64Image } }
+            ]
+          }],
+          max_tokens: 150,
+          temperature: 0.1
+        })
+      });
+      const data = await response.json();
+      let content = data.choices[0].message.content.trim();
+      if (content.startsWith("```json")) content = content.replace(/```json\n?/, "").replace(/```$/, "").trim();
+      else if (content.startsWith("```")) content = content.replace(/```\n?/, "").replace(/```$/, "").trim();
+      return JSON.parse(content);
+    } catch (e) {
+      console.error("[MLX Bridge] Reasoning failed:", e);
+      throw e;
+    }
+  }
+  async executeAction(tenantId = "system", action) {
+    return this.execute(tenantId, "execute_action", { action });
+  }
+  async runAutonomousStep(tenantId = "system", objective) {
+    const image = await this.captureScreen(tenantId);
+    let decision = null, retries = 0, lastError = null;
+    const instruction = `You are an AI OS agent. Based on the screen image, what action should be taken to achieve: "${objective}"? Return ONLY a strict JSON object of the action, no markdown. E.g. {"type": "mouseClick", "x": 100, "y": 200, "button": "left", "count": 1}`;
+    while (retries <= 2 && !decision) {
+      try {
+        decision = await this.reasonWithMLX(image, instruction, lastError || void 0);
+      } catch (error) {
+        lastError = error.message || String(error);
+        retries++;
+      }
+    }
+    if (!decision) return;
+    await this.executeAction(tenantId, decision);
+  }
+  async askAI(prompt, taskType = "reasoning", forceProvider) {
+    const result = await inferenceRouter.route(prompt, { preferredBackend: forceProvider || "auto" });
+    return result.text;
+  }
+  onEvent(callback) {
+    this.universalListeners.add(callback);
+    return () => this.universalListeners.delete(callback);
+  }
+  async getEventHistory(tenantId, limit = 50) {
+    return this.transport.getEventHistory(tenantId, limit);
+  }
+};
+var kernel = new DecidoKernel();
+
+// src/ai/services/OllamaService.ts
+var OLLAMA_BASE_URL2 = "http://localhost:11434";
+var DEFAULT_MODEL5 = "qwen2:latest";
+function buildSystemPrompt() {
+  const liveContext = buildLiveContext();
+  const toolSchemas = "";
+  return `- Est\xE1s integrado en DecidoOS, una plataforma empresarial de escritorio
+- Corres localmente en la m\xE1quina del usuario \u2014 todo es privado
+- Puedes ejecutar herramientas del sistema para ayudar al usuario
+
+${liveContext}
+
+## Herramientas disponibles
+
+${toolSchemas}
+
+## Reglas de respuesta
+1. Responde siempre en espa\xF1ol a menos que el usuario hable en otro idioma
+2. S\xE9 directo \u2014 no des introducciones largas
+3. Si puedes resolver algo con una herramienta, USA LA HERRAMIENTA nativa en vez de solo describirla
+4. Mant\xE9n respuestas bajo 300 palabras
+5. Si no sabes algo, dilo honestamente
+6. NO inventes resultados de herramientas \u2014 espera el resultado real
+7. Cuando el usuario pregunte sobre el estado del sistema, USA LOS DATOS del "Estado actual del sistema" que tienes arriba \u2014 esos son datos reales y recientes`;
+}
+function buildLiveContext() {
+  const parts = ["## Estado actual del sistema"];
+  const now = (/* @__PURE__ */ new Date()).toLocaleString("es-CO", { hour12: false });
+  parts.push(`Hora actual: ${now}`);
+  try {
+    const watchdogModule = globalThis.__systemWatchdog;
+    if (watchdogModule) {
+      const snapshot = watchdogModule.getLastSnapshot?.();
+      if (snapshot) {
+        const metrics = [];
+        if (snapshot.cpuPercent !== null) metrics.push(`CPU: ${snapshot.cpuPercent.toFixed(1)}%`);
+        if (snapshot.memoryPercent !== null) metrics.push(`Memoria: ${snapshot.memoryPercent.toFixed(1)}%`);
+        if (snapshot.diskFreeGB !== null) metrics.push(`Disco libre: ${snapshot.diskFreeGB.toFixed(1)} GB`);
+        if (snapshot.connectionCount !== null) metrics.push(`Conexiones de red: ${snapshot.connectionCount}`);
+        if (metrics.length > 0) {
+          parts.push(`M\xE9tricas del sistema: ${metrics.join(" | ")}`);
+        }
+      }
+      const alerts = watchdogModule.getAlerts?.()?.filter((a) => !a.dismissed).slice(-5) ?? [];
+      if (alerts.length > 0) {
+        parts.push("Alertas recientes:");
+        for (const alert of alerts) {
+          const emoji = alert.severity === "critical" ? "\u{1F6A8}" : "\u26A0\uFE0F";
+          parts.push(`  ${emoji} ${alert.title}`);
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const appStore = globalThis.__appStore;
+    const ctx = appStore?.getState?.()?.contextSnapshot;
+    if (ctx) {
+      if (ctx.canvasNodeCount > 0) parts.push(`Canvas: ${ctx.canvasNodeCount} nodos`);
+      if (ctx.gitBranch) parts.push(`Git: rama ${ctx.gitBranch}${ctx.gitModifiedFiles ? ` (${ctx.gitModifiedFiles} archivos modificados)` : ""}`);
+      if (ctx.activeInsights > 0) parts.push(`Insights activos: ${ctx.activeInsights}`);
+      if (ctx.criticalInsightsSummary?.length > 0) {
+        parts.push("Insights cr\xEDticos: " + ctx.criticalInsightsSummary.slice(0, 3).join("; "));
+      }
+    }
+  } catch {
+  }
+  try {
+    const memoryModule = globalThis.__agentMemory;
+    if (memoryModule) {
+      const memContext = memoryModule.buildMemoryContext?.();
+      if (memContext) {
+        parts.push("");
+        parts.push(memContext);
+      }
+    }
+  } catch {
+  }
+  return parts.join("\n");
+}
+function parseToolCalls(message) {
+  const calls = [];
+  if (message?.tool_calls && Array.isArray(message.tool_calls)) {
+    for (const tc of message.tool_calls) {
+      if (tc.function?.name) {
+        calls.push({
+          name: tc.function.name,
+          args: tc.function.arguments || {}
+        });
+      }
+    }
+  }
+  return calls;
+}
+function stripToolCalls(text) {
+  if (!text) return "";
+  return text.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "").trim();
+}
+var conversationHistory = [];
+var MAX_HISTORY2 = 20;
+function addToHistory(msg) {
+  conversationHistory.push(msg);
+  if (conversationHistory.length > MAX_HISTORY2) {
+    conversationHistory = conversationHistory.slice(-MAX_HISTORY2);
+  }
+}
+function clearConversationHistory() {
+  conversationHistory = [];
+}
+async function isOllamaAvailable() {
+  try {
+    const res = await fetch(`${OLLAMA_BASE_URL2}/api/tags`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function listModels() {
+  try {
+    const res = await fetch(`${OLLAMA_BASE_URL2}/api/tags`);
+    if (!res.ok) return [];
+    const data = await res.json();
+    return (data.models || []).map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+async function chat(userMessage, options) {
+  const userMsg = { role: "user", content: userMessage };
+  addToHistory(userMsg);
+  const messages = [
+    { role: "system", content: buildSystemPrompt() },
+    ...conversationHistory
+  ];
+  try {
+    const result = await routeChat(messages, {
+      temperature: options?.temperature ?? 0.7,
+      maxTokens: 512
+    });
+    const assistantContent = result?.text || "";
+    addToHistory({ role: "assistant", content: assistantContent });
+    if (result) {
+      console.log(`\u{1F9E0}[Chat] Response via ${result.backend} (${result.model}) in ${result.latencyMs} ms`);
+    }
+    return assistantContent;
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "TimeoutError") {
+      return "\u23F3 La respuesta del modelo tard\xF3 demasiado. Intenta con una pregunta m\xE1s corta.";
+    }
+    throw error;
+  }
+}
+async function* chatStream(userMessage, options) {
+  const model = options?.model || DEFAULT_MODEL5;
+  const userMsg = { role: "user", content: userMessage };
+  addToHistory(userMsg);
+  const messages = [
+    { role: "system", content: buildSystemPrompt() },
+    ...conversationHistory
+  ];
+  const res = await fetch(`${OLLAMA_BASE_URL2}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages,
+      stream: true,
+      options: {
+        temperature: options?.temperature ?? 0.7,
+        num_predict: 512
+      }
+    })
+  });
+  if (!res.ok || !res.body) {
+    throw new Error(`Ollama stream error: ${res.status}`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let fullContent = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      const lines = chunk.split("\n").filter(Boolean);
+      for (const line of lines) {
+        try {
+          const data = JSON.parse(line);
+          if (data.message?.content) {
+            fullContent += data.message.content;
+            yield data.message.content;
+          }
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  addToHistory({ role: "assistant", content: fullContent });
+}
+
+// src/ai/services/MLXBridge.ts
+async function runShellCommand(cmd, args) {
+  try {
+    const { invoke } = await import("@tauri-apps/api/core");
+    const result = await invoke("run_shell_command", {
+      command: cmd,
+      args
+    });
+    return result;
+  } catch (err) {
+    console.error("[MLXBridge] Shell command failed:", err);
+    throw err;
+  }
+}
+var OLLAMA_URL = "http://localhost:11434";
+async function ollamaChat(model, prompt, temperature = 0.7) {
+  const start = Date.now();
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: prompt }],
+        stream: false,
+        options: { temperature }
+      })
+    });
+    const data = await res.json();
+    const latencyMs = Date.now() - start;
+    return {
+      text: data.message?.content ?? "",
+      tokensPerSecond: data.eval_count ? data.eval_count / (latencyMs / 1e3) : 0,
+      totalTokens: data.eval_count ?? 0,
+      latencyMs,
+      model
+    };
+  } catch {
+    return { text: "Error: Ollama no disponible", tokensPerSecond: 0, totalTokens: 0, latencyMs: Date.now() - start, model };
+  }
+}
+async function ollamaListModels() {
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/tags`);
+    if (!res.ok) return [];
+    const data = await res.json();
+    return (data.models || []).map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+async function ollamaPull(model) {
+  await fetch(`${OLLAMA_URL}/api/pull`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name: model })
+  });
+}
+async function mlxGenerate(model, prompt) {
+  const start = Date.now();
+  try {
+    const output = await runShellCommand("python3", [
+      "-m",
+      "mlx_lm.generate",
+      "--model",
+      model,
+      "--prompt",
+      prompt,
+      "--max-tokens",
+      "512"
+    ]);
+    return {
+      text: output,
+      tokensPerSecond: 0,
+      // parsed from output in production
+      totalTokens: output.split(" ").length,
+      latencyMs: Date.now() - start,
+      model
+    };
+  } catch (err) {
+    return { text: `MLX Error: ${err}`, tokensPerSecond: 0, totalTokens: 0, latencyMs: Date.now() - start, model };
+  }
+}
+async function listAvailableModels() {
+  const models = [];
+  const ollamaModels = await ollamaListModels();
+  for (const name of ollamaModels) {
+    models.push({
+      name,
+      family: "llm",
+      path: `ollama:${name}`,
+      loaded: true
+    });
+  }
+  const mlxCatalog = [
+    { name: "Qwen2.5-7B-Instruct-4bit", family: "llm", paramCount: "7B", quantization: "4bit", path: "mlx-community/Qwen2.5-7B-Instruct-4bit", loaded: false },
+    { name: "Mistral-7B-Instruct-v0.3-4bit", family: "llm", paramCount: "7B", quantization: "4bit", path: "mlx-community/Mistral-7B-Instruct-v0.3-4bit", loaded: false },
+    { name: "Llama-3.2-3B-Instruct-4bit", family: "llm", paramCount: "3B", quantization: "4bit", path: "mlx-community/Llama-3.2-3B-Instruct-4bit", loaded: false },
+    { name: "Mixtral-8x7B-Instruct-v0.1-4bit", family: "llm", paramCount: "46.7B", quantization: "4bit", path: "mlx-community/Mixtral-8x7B-Instruct-v0.1-4bit", loaded: false },
+    { name: "Whisper-large-v3", family: "audio", path: "mlx-community/whisper-large-v3", loaded: false },
+    { name: "CLIP-ViT-B-32", family: "vision", path: "openai/clip-vit-base-patch32", loaded: false },
+    { name: "FLUX.1-schnell-4bit", family: "image-gen", path: "mlx-community/FLUX.1-schnell-4bit-quantized", loaded: false },
+    { name: "Stable-Diffusion-XL", family: "image-gen", path: "mlx-community/sdxl-turbo", loaded: false }
+  ];
+  models.push(...mlxCatalog);
+  return models;
+}
+async function runInference(modelPath, prompt, options) {
+  if (modelPath.startsWith("ollama:")) {
+    const model = modelPath.replace("ollama:", "");
+    return ollamaChat(model, prompt, options?.temperature);
+  }
+  return mlxGenerate(modelPath, prompt);
+}
+async function compareModels(modelA, modelB, prompt) {
+  const [a, b] = await Promise.all([
+    runInference(modelA, prompt),
+    runInference(modelB, prompt)
+  ]);
+  return { a, b };
+}
+async function pullModel(model) {
+  if (model.startsWith("ollama:")) {
+    await ollamaPull(model.replace("ollama:", ""));
+  } else {
+    await runShellCommand("huggingface-cli", ["download", model]);
+  }
+}
+async function benchmarkModel(modelPath) {
+  const testPrompts = [
+    "Explain quantum computing in one paragraph.",
+    "Write a Python function to sort a list.",
+    "What is the capital of Colombia?"
+  ];
+  let totalTokens = 0;
+  let totalMs = 0;
+  for (const prompt of testPrompts) {
+    const result = await runInference(modelPath, prompt);
+    totalTokens += result.totalTokens;
+    totalMs += result.latencyMs;
+  }
+  return {
+    model: modelPath,
+    promptTokens: testPrompts.join(" ").split(" ").length,
+    generatedTokens: totalTokens,
+    tokensPerSecond: totalTokens / (totalMs / 1e3),
+    latencyMs: totalMs / testPrompts.length,
+    memoryMb: 0
+    // would need system metrics
+  };
+}
+function startLoRATraining(config) {
+  let stopped = false;
+  let progressCallback = null;
+  const totalSteps = (config.epochs ?? 10) * 100;
+  let step = 0;
+  const start = Date.now();
+  const interval = setInterval(() => {
+    if (stopped || step >= totalSteps) {
+      clearInterval(interval);
+      return;
+    }
+    step++;
+    const progress = {
+      epoch: Math.floor(step / 100) + 1,
+      totalEpochs: config.epochs ?? 10,
+      step,
+      totalSteps,
+      loss: 2.5 * Math.exp(-step / 200) + 0.3 + Math.random() * 0.1,
+      learningRate: config.learningRate ?? 1e-5,
+      tokensPerSecond: 150 + Math.random() * 50,
+      elapsedMs: Date.now() - start
+    };
+    progressCallback?.(progress);
+  }, 500);
+  return {
+    stop: () => {
+      stopped = true;
+      clearInterval(interval);
+    },
+    onProgress: (cb) => {
+      progressCallback = cb;
+    }
+  };
+}
+
+// src/ai/services/EmbeddingService.ts
+var OLLAMA_URL2 = "http://localhost:11434";
+var EMBED_MODEL = "nomic-embed-text";
+var TFIDF_DIMS = 256;
+async function ollamaEmbed(text) {
+  const start = Date.now();
+  try {
+    const res = await fetch(`${OLLAMA_URL2}/api/embed`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: EMBED_MODEL, input: text })
+    });
+    if (!res.ok) throw new Error(`Ollama embed failed: ${res.status}`);
+    const data = await res.json();
+    const vector = data.embeddings?.[0] || data.embedding || [];
+    return {
+      vector,
+      dimensions: vector.length,
+      model: EMBED_MODEL,
+      latencyMs: Date.now() - start
+    };
+  } catch (err) {
+    console.warn("[EmbeddingService] Ollama not available, falling back to TF-IDF", err);
+    return tfidfEmbed(text);
+  }
+}
+function tfidfEmbed(text) {
+  const start = Date.now();
+  const tokens = text.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter((t) => t.length > 2);
+  const vector = new Array(TFIDF_DIMS).fill(0);
+  for (const token of tokens) {
+    let hash = 0;
+    for (let i = 0; i < token.length; i++) {
+      hash = (hash << 5) - hash + token.charCodeAt(i) | 0;
+    }
+    const idx = Math.abs(hash) % TFIDF_DIMS;
+    vector[idx] += 1 / tokens.length;
+  }
+  const norm = Math.sqrt(vector.reduce((s, v) => s + v * v, 0));
+  if (norm > 0) {
+    for (let i = 0; i < vector.length; i++) vector[i] /= norm;
+  }
+  return {
+    vector,
+    dimensions: TFIDF_DIMS,
+    model: "tfidf-fallback",
+    latencyMs: Date.now() - start
+  };
+}
+var preferredBackend = "ollama";
+async function embed(text) {
+  if (preferredBackend === "ollama") {
+    return ollamaEmbed(text);
+  }
+  return tfidfEmbed(text);
+}
+async function embedBatch(texts) {
+  return Promise.all(texts.map((t) => embed(t)));
+}
+function setBackend(backend) {
+  preferredBackend = backend;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+var embeddingService = { embed, embedBatch, setBackend, cosineSimilarity };
+
+// src/ai/services/LocalAgentResponder.ts
+var GREETING_PATTERNS = [
+  /^(hola|hey|hi|hello|buenas|qué tal|que tal|saludos)\s*(decido|decidoos|agente|asistente)?/i,
+  /^(buenos?\s*(días|tardes|noches))/i,
+  /^(órale|oye|ey)\s*(decido)?/i
+];
+var HELP_PATTERNS = [
+  /^(ayuda|help|qué puedes hacer|que puedes hacer|comandos|tools|herramientas)/i,
+  /^(qué|que)\s*(sabes|haces|puedes)/i
+];
+var SYSTEM_PATTERNS = [
+  /^(estado|status|sistema|system)\s*(del\s*sistema)?/i,
+  /^(cómo|como)\s*(estás|estas|está|va)/i
+];
+function getTimeGreeting() {
+  const hour = (/* @__PURE__ */ new Date()).getHours();
+  if (hour < 12) return "Buenos d\xEDas";
+  if (hour < 18) return "Buenas tardes";
+  return "Buenas noches";
+}
+function getWelcomeMessage() {
+  const greeting = getTimeGreeting();
+  return `${greeting}, operador. Soy **DecidoOS Agent** \u{1F9E0}
+
+Estoy en l\xEDnea y operativo. Aqu\xED est\xE1 mi reporte de estado:
+
+\u25B8 **Modo**: Local-first (sin dependencia de Cortex)
+\u25B8 **Estado**: \u2705 ONLINE
+
+Puedo auditar tu seguridad, escanear tu flota de procesos y m\xE1s.
+
+Escribe **"ayuda"** para ver mis comandos principales.`;
+}
+function getHelpMessage() {
+  return `\u{1F6E0}\uFE0F **Capacidades de DecidoOS Agent**
+
+\u2022 "escanea puertos" \u2014 Auditar puertos abiertos
+\u2022 "escanea red" \u2014 Monitorear conexiones de red
+\u2022 "escanea flota" \u2014 Ver procesos Agent / Node / Python
+\u2022 "lista tareas" \u2014 Ver tareas / playbooks
+\u2022 "estado" \u2014 Estado del sistema
+
+**Voice Mode:**
+Presiona el bot\xF3n verde \u{1F4DE} para activar conversaci\xF3n por voz con Cortex.`;
+}
+async function getSystemStatus() {
+  let cpuInfo = "N/A";
+  let memInfo = "N/A";
+  try {
+    const { invoke } = await import("@tauri-apps/api/core");
+    const cpu = await invoke("get_cpu_usage");
+    const mem = await invoke("get_memory_usage");
+    cpuInfo = `${cpu.usage?.toFixed(1)}%`;
+    memInfo = `${(mem.used / 1024 / 1024 / 1024).toFixed(1)} GB / ${(mem.total / 1024 / 1024 / 1024).toFixed(1)} GB`;
+  } catch {
+    cpuInfo = "(requiere Tauri)";
+    memInfo = "(requiere Tauri)";
+  }
+  return `\u{1F4CA} **Estado del Sistema DecidoOS**
+
+\u25B8 **CPU**: ${cpuInfo}
+\u25B8 **RAM**: ${memInfo}
+\u25B8 **Cortex**: Local mode
+\u25B8 **Uptime Session**: ${getSessionUptime()}
+
+Todo operativo. \xBFNecesitas algo m\xE1s?`;
+}
+function getSessionUptime() {
+  const uptime = performance.now();
+  const minutes = Math.floor(uptime / 6e4);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  return `${minutes}m`;
+}
+async function processLocalMessage(input) {
+  const trimmed = input.trim();
+  if (GREETING_PATTERNS.some((p) => p.test(trimmed))) {
+    return { text: getWelcomeMessage() };
+  }
+  if (HELP_PATTERNS.some((p) => p.test(trimmed))) {
+    return { text: getHelpMessage() };
+  }
+  if (SYSTEM_PATTERNS.some((p) => p.test(trimmed))) {
+    const status = await getSystemStatus();
+    return { text: status };
+  }
+  const execMatch = trimmed.match(/^(ejecuta|run|exec|corre)\s+(.+)/i);
+  if (execMatch) {
+    const command = execMatch[2];
+    return {
+      text: `\u26A1 Ejecutando: \`${command}\`...`,
+      toolCalls: [{ name: "tactical.execute_command", args: { command } }]
+    };
+  }
+  const scanMatch = trimmed.match(/^(escanea|scan|audita|audit)\s*(puertos|ports)/i);
+  if (scanMatch) {
+    return {
+      text: "\u{1F50D} Escaneando puertos del sistema...",
+      toolCalls: [{ name: "security.audit_ports", args: { includeLoopback: false } }]
+    };
+  }
+  const networkMatch = trimmed.match(/^(escanea|scan|monitorea|monitor)\s*(red|network|conexiones|connections)/i);
+  if (networkMatch) {
+    return {
+      text: "\u{1F310} Analizando conexiones de red...",
+      toolCalls: [{ name: "security.network_monitor", args: {} }]
+    };
+  }
+  const fleetMatch = trimmed.match(/^(escanea|scan)\s*(flota|fleet|procesos|processes)/i);
+  if (fleetMatch) {
+    return {
+      text: "\u{1F6F8} Escaneando flotilla de agentes...",
+      toolCalls: [{ name: "tactical.scan_fleet", args: {} }]
+    };
+  }
+  const listMatch = trimmed.match(/^(lista|list|muestra|show)\s*(tareas|tasks|playbooks)/i);
+  if (listMatch) {
+    return {
+      text: "\u{1F4CB} Listando tareas...",
+      toolCalls: [{ name: "tactical.list_tasks", args: { status: "all" } }]
+    };
+  }
+  const forensicMatch = trimmed.match(/^(analiza|analyze|forense|forensic)\s*(proceso|process)?\s*(\d+)?/i);
+  if (forensicMatch) {
+    const pid = forensicMatch[3] ? parseInt(forensicMatch[3]) : void 0;
+    return {
+      text: pid ? `\u{1F52C} Analizando proceso PID ${pid}...` : "\u{1F52C} Escaneando procesos sospechosos...",
+      toolCalls: [{ name: "security.forensic_scan", args: { pid, deep: true } }]
+    };
+  }
+  const vulnMatch = trimmed.match(/^(vulnerabilidades|vulnerabilities|vuln|audit\s*npm)/i);
+  if (vulnMatch) {
+    return {
+      text: "\u{1F6E1}\uFE0F Escaneando vulnerabilidades en dependencias...",
+      toolCalls: [{ name: "security.scan_vulnerabilities", args: {} }]
+    };
+  }
+  return {
+    text: `\u{1F916} Entendido: "${trimmed.slice(0, 100)}"
+
+No tengo una respuesta local para esto. Para respuestas inteligentes con IA, conecta a **Cortex** (mindframe-cortex).
+
+Mientras tanto, prueba:
+\u2022 "ayuda" \u2014 ver mis capacidades
+\u2022 "ejecuta ls" \u2014 ejecutar un comando
+\u2022 "escanea puertos" \u2014 auditar seguridad
+\u2022 "estado" \u2014 ver estado del sistema`
+  };
+}
+
+// src/ai/services/PeerMesh.ts
+import { v4 as uuid } from "uuid";
+var DEFAULT_PORT = 9876;
+var HEARTBEAT_INTERVAL = 1e4;
+var PEER_TIMEOUT = 3e4;
+var MAX_PEERS = 8;
+var PeerMeshImpl = class {
+  myId = uuid();
+  myName = this._getHostname();
+  peers = /* @__PURE__ */ new Map();
+  connections = /* @__PURE__ */ new Map();
+  isHostingFlag = false;
+  isConnectedFlag = false;
+  heartbeatTimer = null;
+  cleanupTimer = null;
+  // Event listeners
+  peersListeners = /* @__PURE__ */ new Set();
+  hostingListeners = /* @__PURE__ */ new Set();
+  connectionListeners = /* @__PURE__ */ new Set();
+  resultListeners = /* @__PURE__ */ new Set();
+  // ── Host Mode ─────────────────────────────────────────
+  /**
+   * Start hosting a peer group.
+   * Note: In browser WebSocket server is not available. This method
+   * is a placeholder for Tauri (Rust-side server). In browser mode,
+   * we simulate by acting as a "relay" through a shared connection.
+   */
+  startHost(port = DEFAULT_PORT) {
+    if (this.isHostingFlag) return;
+    this.isHostingFlag = true;
+    this._emitHosting(true);
+    this._startHeartbeat();
+    console.log(`\u{1F310} [PeerMesh] Hosting on port ${port} (peer: ${this.myId.slice(0, 8)})`);
+    console.log(`\u{1F310} [PeerMesh] \u26A0\uFE0F Browser-mode: WebSocket server requires Tauri backend.`);
+    console.log(`\u{1F310} [PeerMesh]    Use connectToPeer() from another instance to connect.`);
+  }
+  stopHost() {
+    if (!this.isHostingFlag) return;
+    this.isHostingFlag = false;
+    this._stopHeartbeat();
+    this._broadcast({ type: "leave", peerId: this.myId, peerName: this.myName });
+    this._disconnectAll();
+    this._emitHosting(false);
+    console.log("\u{1F310} [PeerMesh] Stopped hosting");
+  }
+  // ── Client Mode ───────────────────────────────────────
+  connectToPeer(address) {
+    if (this.connections.size >= MAX_PEERS) {
+      console.warn(`\u{1F310} [PeerMesh] Max peers (${MAX_PEERS}) reached`);
+      return;
+    }
+    const wsUrl = address.startsWith("ws") ? address : `ws://${address}`;
+    console.log(`\u{1F310} [PeerMesh] Connecting to ${wsUrl}...`);
+    try {
+      const ws = new WebSocket(wsUrl);
+      ws.onopen = () => {
+        console.log(`\u{1F310} [PeerMesh] \u2705 Connected to ${address}`);
+        this.connections.set(address, ws);
+        this.isConnectedFlag = true;
+        this._emitConnection(true);
+        this._send(ws, {
+          type: "join",
+          peerId: this.myId,
+          peerName: this.myName
+        });
+        this._startHeartbeat();
+      };
+      ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data);
+          this._handleMessage(msg, address);
+        } catch {
+        }
+      };
+      ws.onclose = () => {
+        console.log(`\u{1F310} [PeerMesh] Disconnected from ${address}`);
+        this.connections.delete(address);
+        for (const [id, peer] of this.peers) {
+          if (peer.address === address) {
+            this.peers.delete(id);
+          }
+        }
+        this._emitPeers();
+        if (this.connections.size === 0) {
+          this.isConnectedFlag = false;
+          this._emitConnection(false);
+          this._stopHeartbeat();
+        }
+      };
+      ws.onerror = (err) => {
+        console.error(`\u{1F310} [PeerMesh] Connection error to ${address}:`, err);
+      };
+    } catch (err) {
+      console.error(`\u{1F310} [PeerMesh] Failed to connect:`, err);
+    }
+  }
+  disconnect() {
+    this._broadcast({ type: "leave", peerId: this.myId, peerName: this.myName });
+    this._disconnectAll();
+  }
+  // ── Share Results ─────────────────────────────────────
+  shareResult(result) {
+    const fullResult = {
+      ...result,
+      peerId: this.myId,
+      timestamp: Date.now()
+    };
+    this._broadcast({
+      type: "share-result",
+      peerId: this.myId,
+      peerName: this.myName,
+      payload: fullResult
+    });
+    console.log(`\u{1F310} [PeerMesh] Shared result to ${this.connections.size} peers`);
+  }
+  // ── Event Subscriptions ───────────────────────────────
+  onPeersChanged(cb) {
+    this.peersListeners.add(cb);
+    return () => {
+      this.peersListeners.delete(cb);
+    };
+  }
+  onHostingChanged(cb) {
+    this.hostingListeners.add(cb);
+    return () => {
+      this.hostingListeners.delete(cb);
+    };
+  }
+  onConnectionChanged(cb) {
+    this.connectionListeners.add(cb);
+    return () => {
+      this.connectionListeners.delete(cb);
+    };
+  }
+  onSharedResult(cb) {
+    this.resultListeners.add(cb);
+    return () => {
+      this.resultListeners.delete(cb);
+    };
+  }
+  // ── Getters ───────────────────────────────────────────
+  getPeers() {
+    return Array.from(this.peers.values());
+  }
+  getMyId() {
+    return this.myId;
+  }
+  getMyName() {
+    return this.myName;
+  }
+  // ── Message Handling ──────────────────────────────────
+  _handleMessage(msg, fromAddress) {
+    switch (msg.type) {
+      case "join":
+        this.peers.set(msg.peerId, {
+          id: msg.peerId,
+          name: msg.peerName,
+          address: fromAddress,
+          joinedAt: Date.now(),
+          lastSeen: Date.now()
+        });
+        this._emitPeers();
+        console.log(`\u{1F310} [PeerMesh] Peer joined: ${msg.peerName} (${msg.peerId.slice(0, 8)})`);
+        break;
+      case "leave":
+        this.peers.delete(msg.peerId);
+        this._emitPeers();
+        console.log(`\u{1F310} [PeerMesh] Peer left: ${msg.peerName}`);
+        break;
+      case "heartbeat":
+        if (this.peers.has(msg.peerId)) {
+          this.peers.get(msg.peerId).lastSeen = Date.now();
+        }
+        break;
+      case "share-result":
+        if (msg.payload) {
+          const result = msg.payload;
+          for (const cb of this.resultListeners) {
+            try {
+              cb(result);
+            } catch {
+            }
+          }
+        }
+        break;
+      case "peers-update":
+        if (Array.isArray(msg.payload)) {
+          for (const p of msg.payload) {
+            if (p.id !== this.myId && !this.peers.has(p.id)) {
+              this.peers.set(p.id, p);
+            }
+          }
+          this._emitPeers();
+        }
+        break;
+    }
+  }
+  // ── Internal Helpers ──────────────────────────────────
+  _send(ws, msg) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  _broadcast(msg) {
+    for (const ws of this.connections.values()) {
+      this._send(ws, msg);
+    }
+  }
+  _disconnectAll() {
+    for (const ws of this.connections.values()) {
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+    this.connections.clear();
+    this.peers.clear();
+    this.isConnectedFlag = false;
+    this._stopHeartbeat();
+    this._emitPeers();
+    this._emitConnection(false);
+  }
+  _startHeartbeat() {
+    if (this.heartbeatTimer) return;
+    this.heartbeatTimer = setInterval(() => {
+      this._broadcast({
+        type: "heartbeat",
+        peerId: this.myId,
+        peerName: this.myName
+      });
+    }, HEARTBEAT_INTERVAL);
+    this.cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      let changed = false;
+      for (const [id, peer] of this.peers) {
+        if (now - peer.lastSeen > PEER_TIMEOUT) {
+          this.peers.delete(id);
+          changed = true;
+          console.log(`\u{1F310} [PeerMesh] Peer timed out: ${peer.name}`);
+        }
+      }
+      if (changed) this._emitPeers();
+    }, PEER_TIMEOUT);
+  }
+  _stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+  // ── Event Emitters ────────────────────────────────────
+  _emitPeers() {
+    const list = this.getPeers();
+    for (const cb of this.peersListeners) {
+      try {
+        cb(list);
+      } catch {
+      }
+    }
+  }
+  _emitHosting(hosting) {
+    for (const cb of this.hostingListeners) {
+      try {
+        cb(hosting);
+      } catch {
+      }
+    }
+  }
+  _emitConnection(connected) {
+    for (const cb of this.connectionListeners) {
+      try {
+        cb(connected);
+      } catch {
+      }
+    }
+  }
+  // ── Hostname ──────────────────────────────────────────
+  _getHostname() {
+    try {
+      return `user-${Math.random().toString(36).slice(2, 6)}`;
+    } catch {
+      return "anonymous";
+    }
+  }
+};
+var peerMesh = new PeerMeshImpl();
+
+// src/ai/hooks/useTokenWallet.ts
+import { useState, useEffect, useCallback } from "react";
+function useTokenWallet() {
+  const [summary, setSummary] = useState(tokenWallet.getSummary());
+  useEffect(() => {
+    const unsubscribe = tokenWallet.subscribe(setSummary);
+    return unsubscribe;
+  }, []);
+  const clearHistory = useCallback(() => {
+    tokenWallet.clearHistory();
+  }, []);
+  const getRecentHistory = useCallback((count = 20) => {
+    return tokenWallet.getRecentHistory(count);
+  }, []);
+  return {
+    summary,
+    clearHistory,
+    getRecentHistory,
+    totalTokens: summary.totalTokens,
+    totalCost: summary.totalCostUsd,
+    totalCalls: summary.totalCalls,
+    byProvider: summary.byProvider
+  };
+}
+
+// src/ai/hooks/usePeerMesh.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useRef } from "react";
+function usePeerMesh() {
+  const [peers, setPeers] = useState2([]);
+  const [isHosting, setIsHosting] = useState2(false);
+  const [isConnected, setIsConnected] = useState2(false);
+  const [sharedResults, setSharedResults] = useState2([]);
+  const resultsRef = useRef(sharedResults);
+  resultsRef.current = sharedResults;
+  useEffect2(() => {
+    const unsubPeers = peerMesh.onPeersChanged((newPeers) => {
+      setPeers([...newPeers]);
+    });
+    const unsubHosting = peerMesh.onHostingChanged((hosting) => {
+      setIsHosting(hosting);
+    });
+    const unsubConnected = peerMesh.onConnectionChanged((connected) => {
+      setIsConnected(connected);
+    });
+    const unsubResult = peerMesh.onSharedResult((result) => {
+      setSharedResults((prev) => [...prev.slice(-49), result]);
+    });
+    return () => {
+      unsubPeers();
+      unsubHosting();
+      unsubConnected();
+      unsubResult();
+    };
+  }, []);
+  const startHost = useCallback2((port) => {
+    peerMesh.startHost(port);
+  }, []);
+  const stopHost = useCallback2(() => {
+    peerMesh.stopHost();
+  }, []);
+  const connectToPeer = useCallback2((address) => {
+    peerMesh.connectToPeer(address);
+  }, []);
+  const disconnect = useCallback2(() => {
+    peerMesh.disconnect();
+  }, []);
+  const shareResult = useCallback2((result) => {
+    peerMesh.shareResult(result);
+  }, []);
+  return {
+    peers,
+    isHosting,
+    isConnected,
+    sharedResults,
+    peerCount: peers.length,
+    startHost,
+    stopHost,
+    connectToPeer,
+    disconnect,
+    shareResult
+  };
+}
+
+// src/ai/components/TokenWalletPanel.tsx
+import { useState as useState3 } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var PROVIDER_COLORS = {
+  ollama: "text-accent-green",
+  gemini: "text-accent-blue",
+  anthropic: "text-accent-purple",
+  openai: "text-accent-cyan",
+  mlx: "text-accent-amber"
+};
+var PROVIDER_BG = {
+  ollama: "bg-emerald-500/10",
+  gemini: "bg-blue-500/10",
+  anthropic: "bg-purple-500/10",
+  openai: "bg-cyan-500/10",
+  mlx: "bg-amber-500/10"
+};
+var PROVIDER_ICONS = {
+  ollama: "\u{1F999}",
+  gemini: "\u2728",
+  anthropic: "\u{1F9E0}",
+  openai: "\u26A1",
+  mlx: "\u{1F34E}"
+};
+function formatCost(usd) {
+  if (usd === 0) return "FREE";
+  if (usd < 0.01) return `$${usd.toFixed(6)}`;
+  if (usd < 1) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(2)}`;
+}
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
+function timeAgo(ts) {
+  const diff = Date.now() - ts;
+  if (diff < 6e4) return "just now";
+  if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+  if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
+  return `${Math.floor(diff / 864e5)}d ago`;
+}
+function TokenWalletPanel() {
+  const { summary, totalTokens, totalCost, totalCalls, byProvider, clearHistory, getRecentHistory } = useTokenWallet();
+  const [showHistory, setShowHistory] = useState3(false);
+  const providers2 = Object.entries(byProvider).sort((a, b) => b[1].cost - a[1].cost);
+  const history = showHistory ? getRecentHistory(15) : [];
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3 p-4 bg-surface-secondary rounded-2xl border border-border-subtle", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx("span", { className: "text-lg", children: "\u{1F4B0}" }),
+        /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold text-text-primary", children: "Token Wallet" })
+      ] }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: clearHistory,
+          className: "text-[10px] px-2 py-0.5 rounded-md bg-surface-glass text-text-muted\n                     hover:bg-surface-tertiary hover:text-text-secondary transition-colors",
+          children: "Clear"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-3 gap-2", children: [
+      /* @__PURE__ */ jsx(StatCard, { label: "Tokens", value: formatTokens(totalTokens), accent: "text-accent-cyan" }),
+      /* @__PURE__ */ jsx(StatCard, { label: "Cost", value: formatCost(totalCost), accent: totalCost === 0 ? "text-accent-green" : "text-accent-amber" }),
+      /* @__PURE__ */ jsx(StatCard, { label: "Calls", value: String(totalCalls), accent: "text-accent-blue" })
+    ] }),
+    providers2.length > 0 && /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5 mt-1", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-[10px] font-medium text-text-muted uppercase tracking-wider", children: "By Provider" }),
+      providers2.map(([id, data]) => /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: `flex items-center justify-between px-3 py-2 rounded-xl ${PROVIDER_BG[id] || "bg-surface-glass"} transition-colors`,
+          children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+              /* @__PURE__ */ jsx("span", { className: "text-sm", children: PROVIDER_ICONS[id] || "\u{1F916}" }),
+              /* @__PURE__ */ jsx("span", { className: `text-xs font-medium ${PROVIDER_COLORS[id] || "text-text-primary"}`, children: id.charAt(0).toUpperCase() + id.slice(1) })
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3 text-[11px]", children: [
+              /* @__PURE__ */ jsxs("span", { className: "text-text-muted", children: [
+                data.calls,
+                " calls"
+              ] }),
+              /* @__PURE__ */ jsx("span", { className: "text-text-secondary font-mono", children: formatTokens(data.tokens) }),
+              /* @__PURE__ */ jsx("span", { className: "font-semibold text-text-primary font-mono", children: formatCost(data.cost) })
+            ] })
+          ]
+        },
+        id
+      ))
+    ] }),
+    providers2.length === 0 && /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center justify-center py-6 text-text-muted gap-1", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-2xl opacity-50", children: "\u{1F4CA}" }),
+      /* @__PURE__ */ jsx("span", { className: "text-xs", children: "No AI calls recorded yet" })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        onClick: () => setShowHistory(!showHistory),
+        className: "text-[10px] text-text-muted hover:text-text-secondary transition-colors self-center",
+        children: showHistory ? "\u25B2 Hide recent" : "\u25BC Show recent calls"
+      }
+    ),
+    showHistory && history.length > 0 && /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-1 max-h-48 overflow-y-auto", children: history.reverse().map((entry, i) => /* @__PURE__ */ jsx(HistoryRow, { entry }, `${entry.timestamp}-${i}`)) })
+  ] });
+}
+function StatCard({ label, value, accent }) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center p-2 rounded-xl bg-surface-tertiary/50", children: [
+    /* @__PURE__ */ jsx("span", { className: "text-[9px] text-text-muted uppercase tracking-wider", children: label }),
+    /* @__PURE__ */ jsx("span", { className: `text-base font-bold font-mono ${accent}`, children: value })
+  ] });
+}
+function HistoryRow({ entry }) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-2 py-1.5 rounded-lg bg-surface-glass text-[10px]", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+      /* @__PURE__ */ jsx("span", { children: PROVIDER_ICONS[entry.provider] || "\u{1F916}" }),
+      /* @__PURE__ */ jsx("span", { className: "text-text-secondary font-mono", children: entry.model.split("/").pop()?.slice(0, 18) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-text-muted", children: formatTokens(entry.totalTokens) }),
+      /* @__PURE__ */ jsx("span", { className: "text-text-primary font-mono", children: formatCost(entry.estimatedCostUsd) }),
+      /* @__PURE__ */ jsx("span", { className: "text-text-muted", children: timeAgo(entry.timestamp) })
+    ] })
+  ] });
+}
+
+// src/ai/components/PeerNetworkPanel.tsx
+import { useState as useState4, useCallback as useCallback3 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function timeAgo2(ts) {
+  const diff = Date.now() - ts;
+  if (diff < 6e4) return "just now";
+  if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+  return `${Math.floor(diff / 36e5)}h ago`;
+}
+function PeerNetworkPanel() {
+  const {
+    peers,
+    isHosting,
+    isConnected,
+    sharedResults,
+    peerCount,
+    startHost,
+    stopHost,
+    connectToPeer,
+    disconnect
+  } = usePeerMesh();
+  const [peerAddress, setPeerAddress] = useState4("");
+  const [hostPort, setHostPort] = useState4("9876");
+  const handleConnect = useCallback3(() => {
+    if (!peerAddress.trim()) return;
+    connectToPeer(peerAddress.trim());
+    setPeerAddress("");
+  }, [peerAddress, connectToPeer]);
+  const handleKeyDown = useCallback3((e) => {
+    if (e.key === "Enter") handleConnect();
+  }, [handleConnect]);
+  return /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-3 p-4 bg-surface-secondary rounded-2xl border border-border-subtle", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx2("span", { className: "text-lg", children: "\u{1F310}" }),
+        /* @__PURE__ */ jsx2("h3", { className: "text-sm font-semibold text-text-primary", children: "Peer Network" }),
+        peerCount > 0 && /* @__PURE__ */ jsx2("span", { className: "px-1.5 py-0.5 text-[10px] font-bold rounded-full bg-emerald-500/20 text-accent-green", children: peerCount })
+      ] }),
+      /* @__PURE__ */ jsx2(StatusBadge, { isHosting, isConnected })
+    ] }),
+    /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-2 p-3 rounded-xl bg-surface-tertiary/50", children: [
+      /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ jsxs2("div", { className: "flex flex-col", children: [
+          /* @__PURE__ */ jsx2("span", { className: "text-[11px] font-medium text-text-secondary", children: "Host a Group" }),
+          /* @__PURE__ */ jsx2("span", { className: "text-[9px] text-text-muted", children: "Others can connect to you" })
+        ] }),
+        /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx2(
+            "input",
+            {
+              className: "w-16 px-2 py-1 text-[11px] font-mono text-text-primary bg-surface-primary\n                         border border-border-subtle rounded-lg text-center\n                         focus:border-border-strong focus:outline-none transition-colors",
+              value: hostPort,
+              onChange: (e) => setHostPort(e.target.value),
+              placeholder: "Port",
+              disabled: isHosting
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              onClick: () => isHosting ? stopHost() : startHost(Number(hostPort)),
+              className: `px-3 py-1 text-[11px] font-medium rounded-lg transition-all
+                ${isHosting ? "bg-red-500/15 text-accent-red hover:bg-red-500/25" : "bg-emerald-500/15 text-accent-green hover:bg-emerald-500/25"}`,
+              children: isHosting ? "\u23F9 Stop" : "\u25B6 Start"
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx2("div", { className: "h-px bg-border-subtle" }),
+      /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-1.5", children: [
+        /* @__PURE__ */ jsx2("span", { className: "text-[11px] font-medium text-text-secondary", children: "Join a Group" }),
+        /* @__PURE__ */ jsxs2("div", { className: "flex gap-2", children: [
+          /* @__PURE__ */ jsx2(
+            "input",
+            {
+              className: "flex-1 px-3 py-1.5 text-[11px] font-mono text-text-primary bg-surface-primary\n                         border border-border-subtle rounded-lg placeholder:text-text-muted\n                         focus:border-border-strong focus:outline-none transition-colors",
+              value: peerAddress,
+              onChange: (e) => setPeerAddress(e.target.value),
+              onKeyDown: handleKeyDown,
+              placeholder: "192.168.1.10:9876",
+              disabled: isConnected
+            }
+          ),
+          isConnected ? /* @__PURE__ */ jsx2(
+            "button",
+            {
+              onClick: disconnect,
+              className: "px-3 py-1.5 text-[11px] font-medium rounded-lg bg-red-500/15 text-accent-red\n                           hover:bg-red-500/25 transition-all",
+              children: "Disconnect"
+            }
+          ) : /* @__PURE__ */ jsx2(
+            "button",
+            {
+              onClick: handleConnect,
+              className: "px-3 py-1.5 text-[11px] font-medium rounded-lg bg-cyan-500/15 text-accent-cyan\n                           hover:bg-cyan-500/25 transition-all",
+              children: "Connect"
+            }
+          )
+        ] })
+      ] })
+    ] }),
+    peers.length > 0 && /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-1.5", children: [
+      /* @__PURE__ */ jsx2("span", { className: "text-[10px] font-medium text-text-muted uppercase tracking-wider", children: "Connected Peers" }),
+      peers.map((peer) => /* @__PURE__ */ jsx2(PeerRow, { peer }, peer.id))
+    ] }),
+    !isHosting && !isConnected && peers.length === 0 && /* @__PURE__ */ jsxs2("div", { className: "flex flex-col items-center justify-center py-5 text-text-muted gap-1.5", children: [
+      /* @__PURE__ */ jsx2("span", { className: "text-2xl opacity-40", children: "\u{1F517}" }),
+      /* @__PURE__ */ jsxs2("span", { className: "text-xs text-center", children: [
+        "Host a group or connect to a peer",
+        /* @__PURE__ */ jsx2("br", {}),
+        "to share AI results"
+      ] })
+    ] }),
+    sharedResults.length > 0 && /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-1.5 mt-1", children: [
+      /* @__PURE__ */ jsxs2("span", { className: "text-[10px] font-medium text-text-muted uppercase tracking-wider", children: [
+        "Shared Results (",
+        sharedResults.length,
+        ")"
+      ] }),
+      /* @__PURE__ */ jsx2("div", { className: "flex flex-col gap-1 max-h-40 overflow-y-auto", children: sharedResults.slice(-8).reverse().map((r, i) => /* @__PURE__ */ jsxs2(
+        "div",
+        {
+          className: "px-3 py-2 rounded-xl bg-surface-glass text-[10px]",
+          children: [
+            /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between mb-1", children: [
+              /* @__PURE__ */ jsx2("span", { className: "font-medium text-accent-purple", children: r.peerId.slice(0, 8) }),
+              /* @__PURE__ */ jsx2("span", { className: "text-text-muted font-mono", children: r.model })
+            ] }),
+            /* @__PURE__ */ jsxs2("p", { className: "text-text-secondary line-clamp-2", children: [
+              r.response.slice(0, 120),
+              "..."
+            ] })
+          ]
+        },
+        `${r.timestamp}-${i}`
+      )) })
+    ] })
+  ] });
+}
+function StatusBadge({ isHosting, isConnected }) {
+  if (isHosting) {
+    return /* @__PURE__ */ jsxs2("span", { className: "flex items-center gap-1.5 px-2 py-0.5 rounded-full bg-emerald-500/15 text-[10px] font-medium text-accent-green", children: [
+      /* @__PURE__ */ jsx2("span", { className: "w-1.5 h-1.5 rounded-full bg-emerald-400 animate-pulse" }),
+      "Hosting"
+    ] });
+  }
+  if (isConnected) {
+    return /* @__PURE__ */ jsxs2("span", { className: "flex items-center gap-1.5 px-2 py-0.5 rounded-full bg-cyan-500/15 text-[10px] font-medium text-accent-cyan", children: [
+      /* @__PURE__ */ jsx2("span", { className: "w-1.5 h-1.5 rounded-full bg-cyan-400 animate-pulse" }),
+      "Connected"
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2("span", { className: "flex items-center gap-1.5 px-2 py-0.5 rounded-full bg-surface-glass text-[10px] text-text-muted", children: [
+    /* @__PURE__ */ jsx2("span", { className: "w-1.5 h-1.5 rounded-full bg-surface-tertiary" }),
+    "Offline"
+  ] });
+}
+function PeerRow({ peer }) {
+  return /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between px-3 py-2 rounded-xl bg-surface-glass transition-colors hover:bg-surface-tertiary/50", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx2("span", { className: "w-2 h-2 rounded-full bg-emerald-400" }),
+      /* @__PURE__ */ jsx2("span", { className: "text-xs font-medium text-text-primary", children: peer.name })
+    ] }),
+    /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2 text-[10px] text-text-muted", children: [
+      /* @__PURE__ */ jsx2("span", { className: "font-mono", children: peer.address }),
+      /* @__PURE__ */ jsx2("span", { children: "\xB7" }),
+      /* @__PURE__ */ jsx2("span", { children: timeAgo2(peer.lastSeen) })
+    ] })
+  ] });
+}
+
+// src/crypto.ts
+async function decryptEvent(base64Payload, base64Key) {
+  try {
+    const keyBuffer = Uint8Array.from(atob(base64Key), (c) => c.charCodeAt(0));
+    const payloadBuffer = Uint8Array.from(atob(base64Payload), (c) => c.charCodeAt(0));
+    if (payloadBuffer.byteLength < 12) {
+      throw new Error("Payload too short to contain a valid nonce");
+    }
+    const nonce = payloadBuffer.slice(0, 12);
+    const ciphertext = payloadBuffer.slice(12);
+    const cryptoKey = await crypto.subtle.importKey(
+      "raw",
+      keyBuffer,
+      { name: "AES-GCM" },
+      false,
+      ["decrypt"]
+    );
+    const decryptedBuffer = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: nonce },
+      cryptoKey,
+      ciphertext
+    );
+    const decoder = new TextDecoder();
+    const jsonString = decoder.decode(decryptedBuffer);
+    return JSON.parse(jsonString);
+  } catch (e) {
+    console.error("[Crypto Bridge] Failed to decrypt secure event:", e);
+    throw e;
+  }
+}
+
+// src/rehydration.ts
+var StateRehydrationManager = {
+  async rehydrate(swarmKey) {
+    console.log("[Rehydration] \u{1F504} Iniciando recuperaci\xF3n de estado...");
+    try {
+      const history = await kernel.execute("get_stream_history", { limit: 100 });
+      if (!Array.isArray(history)) {
+        console.warn("[Rehydration] El historial devuelto no es un array v\xE1lido.");
+        return;
+      }
+      const events = history.reverse();
+      for (const rawEvent of events) {
+        let event = rawEvent;
+        if (typeof rawEvent === "string") {
+          try {
+            event = await decryptEvent(rawEvent, swarmKey);
+          } catch (e) {
+            console.warn("[Rehydration] No se pudo descifrar un evento, saltando...");
+            continue;
+          }
+        }
+        this.replayEvent(event);
+      }
+      console.log(`[Rehydration] \u2705 Memoria restaurada: ${events.length} eventos procesados.`);
+    } catch (error) {
+      console.error("[Rehydration] Fallo cr\xEDtico en la rehidrataci\xF3n:", error);
+    }
+  },
+  replayEvent(event) {
+    try {
+      kernel.injectEvent({ ...event, is_rehydration: true });
+    } catch (e) {
+      console.warn("[Rehydration] Error inyectando evento de historial", e);
+    }
+  }
+};
+export {
+  AnthropicProvider,
+  GeminiProvider,
+  OllamaProvider,
+  OpenAIProvider,
+  PeerNetworkPanel,
+  StateRehydrationManager,
+  TokenWalletPanel,
+  chat,
+  chatStream,
+  clearConversationHistory,
+  decryptEvent,
+  embeddingService,
+  getAllProviders,
+  getProviderStatuses,
+  inferenceRouter,
+  initProviders,
+  isOllamaAvailable,
+  kernel,
+  loadProviderKeys,
+  benchmarkModel as mlxBenchmarkModel,
+  compareModels as mlxCompareModels,
+  listAvailableModels as mlxListModels,
+  pullModel as mlxPullModel,
+  runInference as mlxRunInference,
+  chat as ollamaChat,
+  chatStream as ollamaChatStream,
+  listModels as ollamaListModels,
+  parseToolCalls,
+  peerMesh,
+  processLocalMessage,
+  routeChat,
+  routeInference,
+  saveProviderKeys,
+  setProviderApiKey,
+  startLoRATraining,
+  stripToolCalls,
+  tokenWallet,
+  usePeerMesh,
+  useTokenWallet
+};