@emblemvault/hustle-react 1.0.0

package/dist/index.js

@@ -0,0 +1,3547 @@
+import { createContext, useState, useEffect, useCallback, useRef, useMemo, useContext } from 'react';
+import { HustleIncognitoClient } from 'hustle-incognito';
+import { useEmblemAuthOptional } from '@emblemvault/emblem-auth-react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { marked } from 'marked';
+import hljs from 'highlight.js/lib/core';
+import javascript from 'highlight.js/lib/languages/javascript';
+import typescript from 'highlight.js/lib/languages/typescript';
+import python from 'highlight.js/lib/languages/python';
+import json from 'highlight.js/lib/languages/json';
+import bash from 'highlight.js/lib/languages/bash';
+import shell from 'highlight.js/lib/languages/shell';
+import css from 'highlight.js/lib/languages/css';
+import xml from 'highlight.js/lib/languages/xml';
+import markdown from 'highlight.js/lib/languages/markdown';
+import sql from 'highlight.js/lib/languages/sql';
+import yaml from 'highlight.js/lib/languages/yaml';
+import rust from 'highlight.js/lib/languages/rust';
+import go from 'highlight.js/lib/languages/go';
+import java from 'highlight.js/lib/languages/java';
+import cpp from 'highlight.js/lib/languages/cpp';
+import csharp from 'highlight.js/lib/languages/csharp';
+import php from 'highlight.js/lib/languages/php';
+import ruby from 'highlight.js/lib/languages/ruby';
+import swift from 'highlight.js/lib/languages/swift';
+import kotlin from 'highlight.js/lib/languages/kotlin';
+
+// src/utils/pluginRegistry.ts
+var PLUGINS_KEY = "hustle-plugins";
+function getEnabledStateKey(instanceId) {
+  return `hustle-plugin-state-${instanceId}`;
+}
+function serializeFunction(fn) {
+  return fn.toString();
+}
+function deserializeExecutor(code) {
+  try {
+    return eval(`(${code})`);
+  } catch (err) {
+    console.error("[Hustle] Failed to deserialize executor:", err);
+    return async () => ({ error: "Failed to deserialize executor", code });
+  }
+}
+function deserializeHook(code) {
+  try {
+    return eval(`(${code})`);
+  } catch (err) {
+    console.error("[Hustle] Failed to deserialize hook:", err);
+    return (() => {
+    });
+  }
+}
+function serializePluginTools(tools, executors) {
+  if (!tools) return [];
+  return tools.map((tool) => ({
+    ...tool,
+    executorCode: executors?.[tool.name] ? serializeFunction(executors[tool.name]) : void 0
+  }));
+}
+function serializeHooks(hooks) {
+  if (!hooks) return void 0;
+  const serialized = {};
+  if (hooks.onRegister) {
+    serialized.onRegisterCode = serializeFunction(hooks.onRegister);
+  }
+  if (hooks.beforeRequest) {
+    serialized.beforeRequestCode = serializeFunction(hooks.beforeRequest);
+  }
+  if (hooks.afterResponse) {
+    serialized.afterResponseCode = serializeFunction(hooks.afterResponse);
+  }
+  if (hooks.onError) {
+    serialized.onErrorCode = serializeFunction(hooks.onError);
+  }
+  return Object.keys(serialized).length > 0 ? serialized : void 0;
+}
+function hydratePlugin(stored) {
+  const executors = {};
+  if (stored.tools) {
+    for (const tool of stored.tools) {
+      if (tool.executorCode) {
+        executors[tool.name] = deserializeExecutor(tool.executorCode);
+      }
+    }
+  }
+  let hooks;
+  if (stored.hooksCode) {
+    hooks = {};
+    if (stored.hooksCode.onRegisterCode) {
+      hooks.onRegister = deserializeHook(stored.hooksCode.onRegisterCode);
+    }
+    if (stored.hooksCode.beforeRequestCode) {
+      hooks.beforeRequest = deserializeHook(stored.hooksCode.beforeRequestCode);
+    }
+    if (stored.hooksCode.afterResponseCode) {
+      hooks.afterResponse = deserializeHook(stored.hooksCode.afterResponseCode);
+    }
+    if (stored.hooksCode.onErrorCode) {
+      hooks.onError = deserializeHook(stored.hooksCode.onErrorCode);
+    }
+  }
+  return {
+    ...stored,
+    executors: Object.keys(executors).length > 0 ? executors : void 0,
+    hooks
+  };
+}
+var PluginRegistry = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get listeners for a specific instance
+   */
+  getListeners(instanceId) {
+    if (!this.listeners.has(instanceId)) {
+      this.listeners.set(instanceId, /* @__PURE__ */ new Set());
+    }
+    return this.listeners.get(instanceId);
+  }
+  /**
+   * Load installed plugins (global)
+   */
+  loadInstalledPlugins() {
+    if (typeof window === "undefined") return [];
+    try {
+      const stored = localStorage.getItem(PLUGINS_KEY);
+      return stored ? JSON.parse(stored) : [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Save installed plugins (global)
+   * Serializes executors as executorCode strings
+   */
+  saveInstalledPlugins(plugins) {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(PLUGINS_KEY, JSON.stringify(plugins));
+  }
+  /**
+   * Load enabled state for an instance
+   */
+  loadEnabledState(instanceId) {
+    if (typeof window === "undefined") return {};
+    try {
+      const stored = localStorage.getItem(getEnabledStateKey(instanceId));
+      return stored ? JSON.parse(stored) : {};
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Save enabled state for an instance
+   */
+  saveEnabledState(state, instanceId) {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(getEnabledStateKey(instanceId), JSON.stringify(state));
+  }
+  /**
+   * Load plugins with instance-specific enabled state
+   * Combines global plugin list with per-instance enabled state
+   */
+  loadFromStorage(instanceId = "default") {
+    const installed = this.loadInstalledPlugins();
+    const enabledState = this.loadEnabledState(instanceId);
+    return installed.map((plugin) => ({
+      ...plugin,
+      // Default to enabled if no state exists for this instance
+      enabled: enabledState[plugin.name] ?? true
+    }));
+  }
+  /**
+   * Register a new plugin (global - available to all instances)
+   * Serializes executors as executorCode for persistence
+   *
+   * @param plugin The plugin to install
+   * @param enabled Initial enabled state for this instance (default: true)
+   * @param instanceId Instance to set initial enabled state for
+   */
+  register(plugin, enabled = true, instanceId = "default") {
+    const installed = this.loadInstalledPlugins();
+    const existing = installed.findIndex((p) => p.name === plugin.name);
+    const storedPlugin = {
+      name: plugin.name,
+      version: plugin.version,
+      description: plugin.description,
+      tools: serializePluginTools(plugin.tools, plugin.executors),
+      hooksCode: serializeHooks(plugin.hooks),
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (existing >= 0) {
+      installed[existing] = storedPlugin;
+    } else {
+      installed.push(storedPlugin);
+    }
+    this.saveInstalledPlugins(installed);
+    const enabledState = this.loadEnabledState(instanceId);
+    enabledState[plugin.name] = enabled;
+    this.saveEnabledState(enabledState, instanceId);
+    this.notifyListeners(instanceId);
+  }
+  /**
+   * Unregister a plugin (global - removes from all instances)
+   */
+  unregister(pluginName, instanceId = "default") {
+    const installed = this.loadInstalledPlugins().filter((p) => p.name !== pluginName);
+    this.saveInstalledPlugins(installed);
+    const enabledState = this.loadEnabledState(instanceId);
+    delete enabledState[pluginName];
+    this.saveEnabledState(enabledState, instanceId);
+    this.notifyListeners(instanceId);
+  }
+  /**
+   * Enable or disable a plugin (instance-scoped)
+   */
+  setEnabled(pluginName, enabled, instanceId = "default") {
+    const enabledState = this.loadEnabledState(instanceId);
+    enabledState[pluginName] = enabled;
+    this.saveEnabledState(enabledState, instanceId);
+    this.notifyListeners(instanceId);
+  }
+  /**
+   * Check if a plugin is installed (global)
+   */
+  isRegistered(pluginName) {
+    return this.loadInstalledPlugins().some((p) => p.name === pluginName);
+  }
+  /**
+   * Get a specific plugin with instance-specific enabled state
+   */
+  getPlugin(pluginName, instanceId = "default") {
+    return this.loadFromStorage(instanceId).find((p) => p.name === pluginName);
+  }
+  /**
+   * Get all enabled plugins for an instance (hydrated with executors)
+   */
+  getEnabledPlugins(instanceId = "default") {
+    return this.loadFromStorage(instanceId).filter((p) => p.enabled).map(hydratePlugin);
+  }
+  /**
+   * Subscribe to plugin changes for a specific instance
+   */
+  onChange(callback, instanceId = "default") {
+    const listeners = this.getListeners(instanceId);
+    listeners.add(callback);
+    return () => listeners.delete(callback);
+  }
+  /**
+   * Notify all listeners for a specific instance
+   */
+  notifyListeners(instanceId = "default") {
+    const plugins = this.loadFromStorage(instanceId);
+    const listeners = this.getListeners(instanceId);
+    listeners.forEach((cb) => cb(plugins));
+  }
+  /**
+   * Clear enabled state for an instance (plugins remain installed globally)
+   */
+  clear(instanceId = "default") {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(getEnabledStateKey(instanceId));
+    this.notifyListeners(instanceId);
+  }
+  /**
+   * Clear all installed plugins globally
+   */
+  clearAll() {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(PLUGINS_KEY);
+  }
+};
+var pluginRegistry = new PluginRegistry();
+
+// src/hooks/usePlugins.ts
+function getStorageKey(instanceId) {
+  return `hustle-plugins-${instanceId}`;
+}
+function usePlugins(instanceId = "default") {
+  const [plugins, setPlugins] = useState([]);
+  useEffect(() => {
+    setPlugins(pluginRegistry.loadFromStorage(instanceId));
+    const unsubscribe = pluginRegistry.onChange(setPlugins, instanceId);
+    const storageKey = getStorageKey(instanceId);
+    const handleStorage = (e) => {
+      if (e.key === storageKey) {
+        setPlugins(pluginRegistry.loadFromStorage(instanceId));
+      }
+    };
+    window.addEventListener("storage", handleStorage);
+    return () => {
+      unsubscribe();
+      window.removeEventListener("storage", handleStorage);
+    };
+  }, [instanceId]);
+  const registerPlugin = useCallback((plugin) => {
+    pluginRegistry.register(plugin, true, instanceId);
+  }, [instanceId]);
+  const unregisterPlugin = useCallback((name) => {
+    pluginRegistry.unregister(name, instanceId);
+  }, [instanceId]);
+  const enablePlugin = useCallback((name) => {
+    pluginRegistry.setEnabled(name, true, instanceId);
+  }, [instanceId]);
+  const disablePlugin = useCallback((name) => {
+    pluginRegistry.setEnabled(name, false, instanceId);
+  }, [instanceId]);
+  const isRegistered = useCallback(
+    (name) => plugins.some((p) => p.name === name),
+    [plugins]
+  );
+  const isEnabled = useCallback(
+    (name) => plugins.some((p) => p.name === name && p.enabled),
+    [plugins]
+  );
+  const enabledPlugins = plugins.filter((p) => p.enabled).map(hydratePlugin);
+  return {
+    plugins,
+    enabledPlugins,
+    registerPlugin,
+    unregisterPlugin,
+    enablePlugin,
+    disablePlugin,
+    isRegistered,
+    isEnabled
+  };
+}
+var HustleContext = createContext(void 0);
+var DEFAULT_HUSTLE_API_URL = "https://agenthustle.ai";
+var instanceCounter = 0;
+var mountedAutoInstances = /* @__PURE__ */ new Set();
+function HustleProvider({
+  children,
+  hustleApiUrl = DEFAULT_HUSTLE_API_URL,
+  debug = false,
+  instanceId: explicitInstanceId,
+  apiKey,
+  vaultId
+}) {
+  const [resolvedInstanceId] = useState(() => {
+    if (explicitInstanceId) {
+      return explicitInstanceId;
+    }
+    const autoId = `instance-${++instanceCounter}`;
+    mountedAutoInstances.add(autoId);
+    return autoId;
+  });
+  const isAutoInstance = !explicitInstanceId;
+  useEffect(() => {
+    if (isAutoInstance && mountedAutoInstances.size > 1 && process.env.NODE_ENV !== "production") {
+      console.warn(
+        `[Hustle] Multiple HustleProviders detected without explicit instanceId. For stable settings persistence, consider adding instanceId prop:
+  <HustleProvider instanceId="my-chat-name">`
+      );
+    }
+    return () => {
+      if (isAutoInstance) {
+        mountedAutoInstances.delete(resolvedInstanceId);
+      }
+    };
+  }, [isAutoInstance, resolvedInstanceId]);
+  const isApiKeyMode = Boolean(apiKey && vaultId);
+  const authContext = useEmblemAuthOptional();
+  const authSDK = isApiKeyMode ? null : authContext?.authSDK ?? null;
+  const isAuthenticated = isApiKeyMode ? true : authContext?.isAuthenticated ?? false;
+  const { enabledPlugins } = usePlugins(resolvedInstanceId);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error2, setError] = useState(null);
+  const [models, setModels] = useState([]);
+  const registeredPluginsRef = useRef(/* @__PURE__ */ new Set());
+  const SETTINGS_KEY = `hustle-settings-${resolvedInstanceId}`;
+  const loadSettings = () => {
+    if (typeof window === "undefined") return { selectedModel: "", systemPrompt: "", skipServerPrompt: false };
+    try {
+      const stored = localStorage.getItem(SETTINGS_KEY);
+      if (stored) {
+        return JSON.parse(stored);
+      }
+    } catch {
+    }
+    return { selectedModel: "", systemPrompt: "", skipServerPrompt: false };
+  };
+  const initialSettings = loadSettings();
+  const [selectedModel, setSelectedModelState] = useState(initialSettings.selectedModel);
+  const [systemPrompt, setSystemPromptState] = useState(initialSettings.systemPrompt);
+  const [skipServerPrompt, setSkipServerPromptState] = useState(initialSettings.skipServerPrompt);
+  const saveSettings = useCallback((settings) => {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(SETTINGS_KEY, JSON.stringify(settings));
+    } catch {
+    }
+  }, []);
+  const setSelectedModel = useCallback((value2) => {
+    setSelectedModelState(value2);
+    saveSettings({ selectedModel: value2, systemPrompt, skipServerPrompt });
+  }, [systemPrompt, skipServerPrompt, saveSettings]);
+  const setSystemPrompt = useCallback((value2) => {
+    setSystemPromptState(value2);
+    saveSettings({ selectedModel, systemPrompt: value2, skipServerPrompt });
+  }, [selectedModel, skipServerPrompt, saveSettings]);
+  const setSkipServerPrompt = useCallback((value2) => {
+    setSkipServerPromptState(value2);
+    saveSettings({ selectedModel, systemPrompt, skipServerPrompt: value2 });
+  }, [selectedModel, systemPrompt, saveSettings]);
+  const log = useCallback(
+    (message, ...args2) => {
+      if (debug) {
+        console.log(`[Hustle] ${message}`, ...args2);
+      }
+    },
+    [debug]
+  );
+  const client = useMemo(() => {
+    if (isApiKeyMode && apiKey && vaultId) {
+      log("Creating HustleIncognitoClient with API key");
+      try {
+        const hustleClient = new HustleIncognitoClient({
+          apiKey,
+          vaultId,
+          hustleApiUrl,
+          debug
+        });
+        hustleClient.on("tool_start", (event) => {
+          log("Tool start:", event);
+        });
+        hustleClient.on("tool_end", (event) => {
+          log("Tool end:", event);
+        });
+        hustleClient.on("stream_end", (event) => {
+          log("Stream end:", event);
+        });
+        return hustleClient;
+      } catch (err) {
+        log("Failed to create client:", err);
+        setError(err instanceof Error ? err : new Error("Failed to create Hustle client"));
+        return null;
+      }
+    }
+    if (!authSDK || !isAuthenticated) {
+      log("Client not created - auth not ready");
+      return null;
+    }
+    log("Creating HustleIncognitoClient with auth SDK");
+    try {
+      const hustleClient = new HustleIncognitoClient({
+        sdk: authSDK,
+        hustleApiUrl,
+        debug
+      });
+      hustleClient.on("tool_start", (event) => {
+        log("Tool start:", event);
+      });
+      hustleClient.on("tool_end", (event) => {
+        log("Tool end:", event);
+      });
+      hustleClient.on("stream_end", (event) => {
+        log("Stream end:", event);
+      });
+      return hustleClient;
+    } catch (err) {
+      log("Failed to create client:", err);
+      setError(err instanceof Error ? err : new Error("Failed to create Hustle client"));
+      return null;
+    }
+  }, [isApiKeyMode, apiKey, vaultId, authSDK, isAuthenticated, hustleApiUrl, debug, log]);
+  const isReady = client !== null;
+  useEffect(() => {
+    if (!client) return;
+    const registerPlugins = async () => {
+      const enabledNames = new Set(enabledPlugins.map((p) => p.name));
+      for (const name of registeredPluginsRef.current) {
+        if (!enabledNames.has(name)) {
+          log("Unregistering plugin:", name);
+          try {
+            await client.unuse(name);
+            registeredPluginsRef.current.delete(name);
+            log("Plugin unregistered:", name);
+          } catch (err) {
+            log("Failed to unregister plugin:", name, err);
+          }
+        }
+      }
+      for (const plugin of enabledPlugins) {
+        if (!registeredPluginsRef.current.has(plugin.name)) {
+          log("Registering plugin:", plugin.name);
+          try {
+            if (plugin.executors || plugin.hooks) {
+              await client.use({
+                name: plugin.name,
+                version: plugin.version,
+                tools: plugin.tools,
+                executors: plugin.executors,
+                hooks: plugin.hooks
+              });
+              registeredPluginsRef.current.add(plugin.name);
+              log("Plugin registered:", plugin.name);
+            } else {
+              log("Plugin has no executors/hooks, skipping registration:", plugin.name);
+            }
+          } catch (err) {
+            log("Failed to register plugin:", plugin.name, err);
+          }
+        }
+      }
+    };
+    registerPlugins();
+  }, [client, enabledPlugins, log]);
+  const loadModels = useCallback(async () => {
+    if (!client) {
+      log("Cannot load models - client not ready");
+      return [];
+    }
+    log("Loading models");
+    setIsLoading(true);
+    try {
+      const modelList = await client.getModels();
+      setModels(modelList);
+      log("Loaded models:", modelList.length);
+      return modelList;
+    } catch (err) {
+      log("Failed to load models:", err);
+      setError(err instanceof Error ? err : new Error("Failed to load models"));
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, log]);
+  useEffect(() => {
+    if (client) {
+      loadModels();
+    }
+  }, [client, loadModels]);
+  const chat = useCallback(
+    async (options) => {
+      if (!client) {
+        throw new Error("Hustle client not ready. Please authenticate first.");
+      }
+      log("Chat request:", options.messages.length, "messages");
+      setIsLoading(true);
+      setError(null);
+      try {
+        const effectiveSystemPrompt = options.systemPrompt || systemPrompt;
+        const messagesWithSystem = [];
+        if (effectiveSystemPrompt) {
+          messagesWithSystem.push({ role: "system", content: effectiveSystemPrompt });
+        }
+        messagesWithSystem.push(...options.messages);
+        const sdkOptions = {
+          messages: messagesWithSystem,
+          processChunks: true
+        };
+        if (isApiKeyMode && vaultId) {
+          sdkOptions.vaultId = vaultId;
+        }
+        if (options.model || selectedModel) {
+          sdkOptions.model = options.model || selectedModel;
+        }
+        if (options.overrideSystemPrompt ?? skipServerPrompt) {
+          sdkOptions.overrideSystemPrompt = true;
+        }
+        if (options.attachments) {
+          sdkOptions.attachments = options.attachments;
+        }
+        const response = await client.chat(sdkOptions);
+        log("Chat response received");
+        return response;
+      } catch (err) {
+        log("Chat error:", err);
+        const error3 = err instanceof Error ? err : new Error("Chat request failed");
+        setError(error3);
+        throw error3;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, isApiKeyMode, vaultId, selectedModel, systemPrompt, skipServerPrompt, log]
+  );
+  const chatStreamImpl = useCallback(
+    (options) => {
+      if (!client) {
+        return {
+          [Symbol.asyncIterator]: async function* () {
+            yield { type: "error", value: { message: "Hustle client not ready. Please authenticate first." } };
+          },
+          response: Promise.resolve({ content: "", messageId: void 0 })
+        };
+      }
+      log("Chat stream request:", options.messages.length, "messages");
+      setError(null);
+      const effectiveSystemPrompt = options.systemPrompt || systemPrompt;
+      const messagesWithSystem = [];
+      if (effectiveSystemPrompt) {
+        messagesWithSystem.push({ role: "system", content: effectiveSystemPrompt });
+      }
+      messagesWithSystem.push(...options.messages);
+      const sdkOptions = {
+        messages: messagesWithSystem,
+        processChunks: options.processChunks ?? true
+      };
+      if (isApiKeyMode && vaultId) {
+        sdkOptions.vaultId = vaultId;
+      }
+      if (options.model || selectedModel) {
+        sdkOptions.model = options.model || selectedModel;
+      }
+      if (options.overrideSystemPrompt ?? skipServerPrompt) {
+        sdkOptions.overrideSystemPrompt = true;
+      }
+      if (options.attachments) {
+        sdkOptions.attachments = options.attachments;
+      }
+      const stream = client.chatStream(sdkOptions);
+      return {
+        [Symbol.asyncIterator]: async function* () {
+          try {
+            for await (const chunk of stream) {
+              const typedChunk = chunk;
+              if (typedChunk.type === "text") {
+                const textValue = typedChunk.value;
+                log("Stream text chunk:", textValue?.substring(0, 50));
+                yield { type: "text", value: textValue };
+              } else if (typedChunk.type === "tool_call") {
+                log("Stream tool call:", typedChunk.value);
+                yield { type: "tool_call", value: typedChunk.value };
+              } else if (typedChunk.type === "tool_result") {
+                log("Stream tool result");
+                yield { type: "tool_result", value: typedChunk.value };
+              } else if (typedChunk.type === "error") {
+                const errorValue = typedChunk.value;
+                log("Stream error:", errorValue);
+                setError(new Error(errorValue?.message || "Stream error"));
+                yield { type: "error", value: { message: errorValue?.message || "Stream error" } };
+              } else {
+                yield chunk;
+              }
+            }
+          } catch (err) {
+            log("Stream error:", err);
+            const error3 = err instanceof Error ? err : new Error("Stream failed");
+            setError(error3);
+            yield { type: "error", value: { message: error3.message } };
+          }
+        },
+        // Forward the response promise from the SDK stream (includes afterResponse hook modifications)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        response: stream.response
+      };
+    },
+    [client, isApiKeyMode, vaultId, selectedModel, systemPrompt, skipServerPrompt, log]
+  );
+  const uploadFile = useCallback(
+    async (file) => {
+      if (!client) {
+        throw new Error("Hustle client not ready. Please authenticate first.");
+      }
+      log("Uploading file:", file.name);
+      setIsLoading(true);
+      try {
+        const attachment = await client.uploadFile(file);
+        log("File uploaded:", attachment);
+        return attachment;
+      } catch (err) {
+        log("Upload error:", err);
+        const error3 = err instanceof Error ? err : new Error("File upload failed");
+        setError(error3);
+        throw error3;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, log]
+  );
+  const value = {
+    // Instance ID for scoped storage
+    instanceId: resolvedInstanceId,
+    // Auth mode
+    isApiKeyMode,
+    // State
+    isReady,
+    isLoading,
+    error: error2,
+    models,
+    // Client (for advanced use)
+    client,
+    // Chat methods
+    chat,
+    chatStream: chatStreamImpl,
+    // File upload
+    uploadFile,
+    // Data fetching
+    loadModels,
+    // Settings
+    selectedModel,
+    setSelectedModel,
+    systemPrompt,
+    setSystemPrompt,
+    skipServerPrompt,
+    setSkipServerPrompt
+  };
+  return /* @__PURE__ */ jsx(HustleContext.Provider, { value, children });
+}
+function useHustle() {
+  const context = useContext(HustleContext);
+  if (context === void 0) {
+    throw new Error("useHustle must be used within a HustleProvider (which requires EmblemAuthProvider)");
+  }
+  return context;
+}
+
+// src/plugins/predictionMarket.ts
+var DOME_API_BASE = "https://api.domeapi.io/v1";
+var predictionMarketPlugin = {
+  name: "prediction-market-alpha",
+  version: "1.1.0",
+  description: "Search and analyze prediction markets on Polymarket and Kalshi",
+  tools: [
+    {
+      name: "get_supported_platforms",
+      description: "Get a list of supported prediction market platforms. Call this first to know which platforms are available for querying.",
+      parameters: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "search_prediction_markets",
+      description: "Search for prediction markets. Find markets about politics, crypto, sports, and more. Returns market titles, current odds, volume, and status. You MUST provide tags to filter results.",
+      parameters: {
+        type: "object",
+        properties: {
+          platform: {
+            type: "string",
+            enum: ["polymarket", "kalshi"],
+            description: "The prediction market platform to search (default: polymarket)"
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: 'REQUIRED: Single word categories or tags to identify a market segment (e.g., "politics", "crypto", "sports", "finance", "entertainment", "ai")'
+          },
+          status: {
+            type: "string",
+            enum: ["open", "closed"],
+            description: "Filter by market status"
+          },
+          limit: {
+            type: "number",
+            description: "Number of results (1-100)",
+            default: 10
+          }
+        },
+        required: ["tags"]
+      }
+    },
+    {
+      name: "get_market_details",
+      description: "Get detailed information about a specific prediction market including current prices, trading history, and resolution source.",
+      parameters: {
+        type: "object",
+        properties: {
+          platform: {
+            type: "string",
+            enum: ["polymarket", "kalshi"],
+            description: "The prediction market platform (default: polymarket)"
+          },
+          market_slug: {
+            type: "string",
+            description: "The market slug/identifier (ticker for Kalshi)"
+          }
+        },
+        required: ["market_slug"]
+      }
+    },
+    {
+      name: "get_market_prices",
+      description: "Get current prices/odds for a prediction market. Shows probability for each outcome.",
+      parameters: {
+        type: "object",
+        properties: {
+          platform: {
+            type: "string",
+            enum: ["polymarket", "kalshi"],
+            description: "The prediction market platform (default: polymarket)"
+          },
+          market_slug: {
+            type: "string",
+            description: "The market slug/identifier (ticker for Kalshi)"
+          }
+        },
+        required: ["market_slug"]
+      }
+    },
+    {
+      name: "get_market_trades",
+      description: "Get recent orders/trading activity for a prediction market.",
+      parameters: {
+        type: "object",
+        properties: {
+          platform: {
+            type: "string",
+            enum: ["polymarket", "kalshi"],
+            description: "The prediction market platform (default: polymarket)"
+          },
+          market_slug: {
+            type: "string",
+            description: "The market slug/identifier (ticker for Kalshi)"
+          },
+          limit: {
+            type: "number",
+            description: "Number of orders to return (max 100)",
+            default: 20
+          }
+        },
+        required: ["market_slug"]
+      }
+    }
+  ],
+  executors: {
+    get_supported_platforms: async () => {
+      return {
+        platforms: [
+          {
+            id: "polymarket",
+            name: "Polymarket",
+            description: "Decentralized prediction market on Polygon",
+            features: ["tags", "volume_filtering"]
+          },
+          {
+            id: "kalshi",
+            name: "Kalshi",
+            description: "CFTC-regulated prediction market exchange",
+            features: ["regulated", "event_based"]
+          }
+        ]
+      };
+    },
+    search_prediction_markets: async (args2) => {
+      const platform = args2.platform || "polymarket";
+      const params = new URLSearchParams();
+      if (args2.limit) params.append("limit", String(args2.limit));
+      if (platform === "polymarket") {
+        if (args2.tags) params.append("tags", args2.tags.join(","));
+        if (args2.status) params.append("status", args2.status);
+        const response = await fetch(`${DOME_API_BASE}/polymarket/markets?${params}`);
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+          platform: "polymarket",
+          markets: data.markets?.map((m) => ({
+            slug: m.market_slug,
+            title: m.title,
+            status: m.status,
+            volume: m.volume_total,
+            tags: m.tags,
+            outcomes: [
+              { label: m.side_a?.label, id: m.side_a?.id },
+              { label: m.side_b?.label, id: m.side_b?.id }
+            ],
+            winner: m.winning_side
+          })) || [],
+          total: data.pagination?.total || 0,
+          hasMore: data.pagination?.has_more || false
+        };
+      } else if (platform === "kalshi") {
+        if (args2.status) params.append("status", args2.status);
+        const response = await fetch(`${DOME_API_BASE}/kalshi/markets?${params}`);
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+          platform: "kalshi",
+          markets: data.markets?.map((m) => ({
+            ticker: m.ticker,
+            title: m.title,
+            status: m.status,
+            category: m.category,
+            subtitle: m.subtitle,
+            yesAsk: m.yes_ask,
+            yesBid: m.yes_bid,
+            volume: m.volume
+          })) || [],
+          total: data.pagination?.total || 0,
+          hasMore: data.pagination?.has_more || false
+        };
+      }
+      throw new Error(`Unsupported platform: ${platform}`);
+    },
+    get_market_details: async (args2) => {
+      const platform = args2.platform || "polymarket";
+      if (platform === "polymarket") {
+        const response = await fetch(
+          `${DOME_API_BASE}/polymarket/markets?market_slug=${args2.market_slug}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const market = data.markets?.[0];
+        if (!market) {
+          throw new Error(`Market not found: ${args2.market_slug}`);
+        }
+        return {
+          platform: "polymarket",
+          slug: market.market_slug,
+          title: market.title,
+          status: market.status,
+          startTime: market.start_time ? new Date(market.start_time * 1e3).toISOString() : null,
+          endTime: market.end_time ? new Date(market.end_time * 1e3).toISOString() : null,
+          volume: {
+            total: market.volume_total,
+            week: market.volume_1_week,
+            month: market.volume_1_month
+          },
+          resolutionSource: market.resolution_source,
+          outcomes: [
+            { label: market.side_a?.label, id: market.side_a?.id },
+            { label: market.side_b?.label, id: market.side_b?.id }
+          ],
+          winner: market.winning_side,
+          tags: market.tags
+        };
+      } else if (platform === "kalshi") {
+        const response = await fetch(
+          `${DOME_API_BASE}/kalshi/markets?ticker=${args2.market_slug}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const market = data.markets?.[0];
+        if (!market) {
+          throw new Error(`Market not found: ${args2.market_slug}`);
+        }
+        return {
+          platform: "kalshi",
+          ticker: market.ticker,
+          title: market.title,
+          subtitle: market.subtitle,
+          status: market.status,
+          category: market.category,
+          yesAsk: market.yes_ask,
+          yesBid: market.yes_bid,
+          volume: market.volume,
+          openInterest: market.open_interest
+        };
+      }
+      throw new Error(`Unsupported platform: ${platform}`);
+    },
+    get_market_prices: async (args2) => {
+      const platform = args2.platform || "polymarket";
+      if (platform === "polymarket") {
+        const response = await fetch(
+          `${DOME_API_BASE}/polymarket/market-price?market_slug=${args2.market_slug}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return { platform: "polymarket", ...data };
+      } else if (platform === "kalshi") {
+        const response = await fetch(
+          `${DOME_API_BASE}/kalshi/markets?ticker=${args2.market_slug}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const market = data.markets?.[0];
+        if (!market) {
+          throw new Error(`Market not found: ${args2.market_slug}`);
+        }
+        return {
+          platform: "kalshi",
+          ticker: market.ticker,
+          yesAsk: market.yes_ask,
+          yesBid: market.yes_bid,
+          lastPrice: market.last_price
+        };
+      }
+      throw new Error(`Unsupported platform: ${platform}`);
+    },
+    get_market_trades: async (args2) => {
+      const platform = args2.platform || "polymarket";
+      const limit = String(args2.limit || 20);
+      if (platform === "polymarket") {
+        const params = new URLSearchParams({
+          market_slug: args2.market_slug,
+          limit
+        });
+        const response = await fetch(
+          `${DOME_API_BASE}/polymarket/orders?${params}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return { platform: "polymarket", ...data };
+      } else if (platform === "kalshi") {
+        const params = new URLSearchParams({
+          ticker: args2.market_slug,
+          limit
+        });
+        const response = await fetch(
+          `${DOME_API_BASE}/kalshi/trades?${params}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return { platform: "kalshi", ...data };
+      }
+      throw new Error(`Unsupported platform: ${platform}`);
+    }
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[Plugin] Prediction Market Alpha v1.1.0 registered (Polymarket + Kalshi)");
+    }
+  }
+};
+
+// src/plugins/migrateFun.ts
+var QA = [
+  { id: "migration-steps-bonk", question: "What are all the steps for migrations to Bonk?", answer: `Here's how MigrateFun migrates your token to BonkFun:
+1) The creator/team sets up a migration portal through migratefun - Create new CA for BonkFun (Ticker, name, image, supply) and set timeline period (1-30 days, 14 days average)
+2) After portal setup, holders commit their tokens to migration - tokens are locked in migration vault until time period ends
+3) Once migration ends, ALL tokens are market sold in a single candle to retrieve as much SOL as possible from the locked liquidity pool
+4) The recovered SOL seeds the new LP paired with appropriate amount of tokens. Set market cap at or slightly below current market cap
+5) Claims open for 90 days - users burn MFTs and receive new tokens`, keywords: ["bonk", "bonkfun", "steps", "process", "how"], category: "process" },
+  { id: "migration-steps-pumpfun", question: "How does a migration work to Pump Fun?", answer: `Here's how the migration to Pump Fun works:
+1) Set up a new CA for pumpfun using MigrateFun creator dashboard (Ticker, CA, image)
+2) Users migrate their tokens in the migration portal for a specific time period
+3) Once migration ends, MigrateFun sells all migrated tokens
+4) MigrateFun takes all recovered SOL and buys out new token's bonding curve + purchases until it reaches old market cap levels
+5) Users return to migratefun and claim their new tokens
+6) 90-day claim period for all users, regardless if they migrated on time or late
+7) The claim period can also be used to swap tokens with centralized exchanges
+8) After 90 days, all unclaimed tokens and remaining SOL are returned to the team`, keywords: ["pump", "pumpfun", "steps", "process", "how"], category: "process" },
+  { id: "migration-steps-raydium", question: "How does Migrate Fun migrate tokens to Raydium?", answer: `1) The creator/team sets up a migration portal through migratefun.com - Create new CA (Ticker, name, image, supply) and set timeline period (1-30 days, 14 days average)
+2) After portal setup, holders commit their tokens to migration and get MFTs in exchange - tokens are locked in migration vault until time period ends
+3) Once migration ends, ALL old tokens are market sold in a single candle to retrieve as much SOL as possible
+4) The recovered SOL seeds the new LP paired with appropriate amount of new tokens. Market Cap is set by the user
+5) Claims open for 90 days - users burn MFTs and receive new tokens. Late migrators can swap at discounted rate
+6) At the end of the 90 day claim window all remaining tokens can be claimed by the team`, keywords: ["raydium", "steps", "process", "how"], category: "process" },
+  { id: "post-migration-checklist", question: "What are the steps I need to do after the migration?", answer: `Admin Checklist - places to register your new CA:
+
+PRIMARY:
+- Coingecko (Free + migration application process)
+- Dexscreener ($300)
+- GeckoTerminal (free for 5 days wait)
+- Holderscan (Listing free, Verify $125)
+
+SECONDARY:
+- Solscan (if metadata updates needed)
+- CoinMarketCap ($5000 for immediate listing)
+- Dextools ($300 for verification)
+- Photon (2 SOL)
+- Cookie.fun (Free, DM needed) [For AI accounts]
+- Kaito (DM needed) [For AI accounts]
+
+Note: Coingecko and CoinMarketCap will ask for a post from official twitter with migration details and new CA.`, keywords: ["after", "post", "checklist", "listing", "dexscreener", "coingecko"], category: "post-migration" },
+  { id: "post-migration-approval", question: "Do we need to do anything after the migration ends?", answer: `Yes, the team needs to approve several steps in the migration portal including:
+1) Selling the migrated tokens into the old LP
+2) Setting the new market cap
+3) Opening the claim portal
+
+Video tutorial: https://www.youtube.com/watch?v=SjPN-1DnXtM`, keywords: ["after", "ends", "approve", "portal"], category: "post-migration" },
+  { id: "market-cap-setting", question: "What market cap should we set?", answer: `Set at or slightly below the ending market cap at migration. For example, if your ending market cap is $1 million, set it to around $950,000. This accounts for the fact you won't receive 1:1 liquidity from the old pool compared to the new pool, which is determined by migration participation.`, keywords: ["market cap", "marketcap", "set", "recommend"], category: "settings" },
+  { id: "migrate-fun-cost", question: "What does Migrate Fun cost?", answer: `Migrate Fun charges a flat 3.75% fee on the total SOL unlocked from the old Liquidity Pool. This fee is taken automatically during the migration process.`, keywords: ["cost", "fee", "price", "charge", "3.75", "percent"], category: "fees" },
+  { id: "claim-fees-bonk", question: "How does the team claim their fees on Bonk Fun?", answer: `Go to https://bonk.fun/creator-rewards to claim your creator fees.`, keywords: ["claim", "fees", "bonk", "creator", "rewards"], category: "fees" },
+  { id: "claim-fees-raydium", question: "How do I claim fees on Raydium?", answer: `You can claim fees from https://raydium.io/portfolio/ with the same wallet that set up the migration.`, keywords: ["claim", "fees", "raydium", "portfolio"], category: "fees" },
+  { id: "claim-fees-pumpfun", question: "How do I claim fees on Pump Fun?", answer: `Fees are paid automatically to the wallet used to set up the migration. Once migrated to PumpSwap you will receive creator rewards based on their Ascend Program. Details: https://pump.fun/docs/fees`, keywords: ["claim", "fees", "pump", "pumpfun", "automatic"], category: "fees" },
+  { id: "audit-info", question: "Has Migrate Fun been audited?", answer: `Yes. Migrate Fun was audited by Halborn, the same auditing firm used by the Solana Foundation.
+Audit: https://www.halborn.com/audits/emblem-vault/migratefun-8ad34b
+Announcement: https://x.com/HalbornSecurity/status/1978869642744811933`, keywords: ["audit", "audited", "security", "halborn", "safe"], category: "security" },
+  { id: "user-experience", question: "What is the process like for the user?", answer: `Super easy - takes less than 20 seconds.
+1) During migration: users swap old tokens for Migrate Fun Tokens (MFTs)
+2) Once migration ends: claim period opens for 90 days, users burn MFTs to claim new tokens
+3) Late migrators: can swap old tokens for new at a discounted rate set by the team
+
+Video guides:
+- Migration: https://x.com/MigrateFun/status/1971259552856408433
+- Claims: https://x.com/MigrateFun/status/1976376597906325767`, keywords: ["user", "experience", "process", "simple", "easy"], category: "user-experience" },
+  { id: "what-is-migrate-fun", question: "What is Migrate Fun?", answer: `Migrate Fun is the category-defining platform that created the migration meta. It allows users to migrate locked liquidity from one launchpad to another.
+
+As of October 2025: 15 migrations completed, $5+ million in liquidity moved, largest migration was $35M market cap project. Supports migrations to Bonk Fun, Raydium, and Pump Fun.
+
+Links:
+- Website: https://migrate.fun/
+- X: https://x.com/MigrateFun
+- Docs: https://github.com/EmblemCompany/Migrate-fun-docs/
+- Audit: https://www.halborn.com/audits/emblem-vault/migratefun-8ad34b
+- Calculator: https://migrate.fun/migration-calculator`, keywords: ["what", "migrate fun", "about", "general", "overview"], category: "general" },
+  { id: "sol-recovery-estimate", question: "How can I see how much SOL we can get from the old LP?", answer: `Use the migration calculator to estimate SOL recovery based on participation percentages: https://migrate.fun/migration-calculator`, keywords: ["sol", "recovery", "estimate", "calculator", "liquidity", "how much"], category: "tools" },
+  { id: "documentation", question: "Do you have documentation?", answer: `Yes, documentation is available at: https://github.com/EmblemCompany/Migrate-fun-docs/`, keywords: ["documentation", "docs", "guide", "help"], category: "general" },
+  { id: "rebrand", question: "What if I want to rebrand?", answer: `The migration enables a full rebrand - reset metadata, image, logo, name, everything. Or keep it all the same if you prefer.`, keywords: ["rebrand", "change", "name", "logo", "image", "metadata"], category: "features" },
+  { id: "sniper-protection", question: "How do you prevent snipers when migrating to Pump Fun?", answer: `On Solana you can stack transactions. When deploying the bonding curve, you are first to purchase so you can buyout the bonding curve and more in the first transaction, preventing snipers.`, keywords: ["sniper", "snipers", "protection", "front-run", "mev"], category: "security" },
+  { id: "claim-period-flexibility", question: "Is there flexibility on the 90 day claim period?", answer: `The 90-day claim period is mandatory. Reasons:
+- All users need time to claim tokens after migration
+- Those who missed migration need a window
+- Users don't get tokens until after migration completes
+- Allowing team to withdraw during claims would be risky (potential rug)`, keywords: ["90 day", "claim", "period", "flexibility", "change"], category: "settings" },
+  { id: "migration-duration", question: "How long is the migration?", answer: `You can set the migration window for as long as you'd like. Average is 14 days. Some teams choose 7 days (works great), some go up to 30 days.
+
+Note: Majority of participation happens in the first and last 24 hours. Example: 76% participation with 50%+ migrating in first 24 hours and additional 10% on the last day.`, keywords: ["how long", "duration", "time", "days", "period", "window"], category: "settings" },
+  { id: "migration-performance", question: "Can you give examples of token performance after migration?", answer: `Migration squeeze: When large percentage of old tokens migrate, sell pressure reduces, often causing market cap spike near migration end.
+
+Example charts:
+- ZERA Old: https://dexscreener.com/solana/95at5r4i85gfqeew2yr6byfg8rlry1d9ztps7qrskdvc
+  New: https://dexscreener.com/solana/nn9vmhjtqgg9l9f8sp3geufwc5zvuhradcwehh7n7di
+- HUSTLE Old: https://dexscreener.com/solana/gjckb2eesjk65nuvpaw4tn2rabnr8wmfcwcwpagk5dzs
+  New: https://dexscreener.com/solana/hxo1wrcrdewek8l2j6rxswnolumej2mweh38gajxtw7y
+
+Thread: https://x.com/jakegallen_/status/1973051293213028468`, keywords: ["performance", "charts", "example", "before", "after", "squeeze"], category: "examples" },
+  { id: "why-migrate", question: "Why would teams want to migrate?", answer: `Top reasons:
+- Access to creator rewards
+- Rebrand opportunity
+- Fresh chart
+- Reclaim part of the token supply
+- Reinvigorated community on the other side`, keywords: ["why", "reasons", "benefits", "advantages", "should"], category: "general" },
+  { id: "migration-recommendation-steps", question: "What steps do you recommend when considering a migration?", answer: `1) Discuss with Migrate Fun team: process details, where to move LP (Raydium, Bonk Fun, or Pump Fun)
+2) Discuss benefits with your community, especially whale holders - get buy-in
+3) Announce on all social channels - maximize awareness for maximum participation`, keywords: ["recommend", "steps", "considering", "planning", "prepare"], category: "process" },
+  { id: "multiple-wallets", question: "Do holders with multiple wallets need to consolidate?", answer: `No. Migration is linear - users can migrate all tokens together or separately. Makes no difference.`, keywords: ["multiple", "wallets", "consolidate", "separate"], category: "user-experience" },
+  { id: "mft-value", question: "Do MFTs show value in wallets?", answer: `MFTs (Migrate Fun Tokens) are just placeholder tokens for the migration. They are valueless.`, keywords: ["mft", "migrate fun tokens", "value", "placeholder"], category: "user-experience" },
+  { id: "announcement-examples", question: "Can you give me sample migration announcements?", answer: `Here are announcements made by teams:
+- https://x.com/radrdotfun/status/1952127168101949620
+- https://x.com/project_89/status/1951345024656089368
+- https://x.com/HKittyOnSol/status/1948925330032349210
+- https://x.com/ModernStoicAI/status/1948129627362218483
+- https://x.com/pokithehamster/status/1950238636928327927
+- https://x.com/IQ6900_/status/1953002036599173499
+- https://x.com/TheBongoCat/status/1965538945132843333`, keywords: ["announcement", "sample", "example", "post", "twitter"], category: "examples" },
+  { id: "graphics", question: "Does Migrate Fun provide graphics for announcements?", answer: `No. For your own migration announcement you create the graphic. Migrate Fun's designer creates group migration announcements only.`, keywords: ["graphics", "images", "design", "announcement"], category: "general" },
+  { id: "developer-required", question: "Do I need to be a developer to migrate?", answer: `No development required. The entire process is a few clicks for both pre-migration and post-migration.`, keywords: ["developer", "technical", "coding", "code"], category: "general" },
+  { id: "exchange-tokens", question: "What happens to tokens on exchanges or locked in Streamflow?", answer: `They will miss the migration as those tokens are considered circulating supply onchain. Options:
+1) Join as late migrator during 90-day claim window
+2) After 90-day period, team takes possession of unclaimed tokens and can reimburse directly`, keywords: ["exchange", "streamflow", "locked", "vested", "cex"], category: "edge-cases" },
+  { id: "unclaimed-tokens", question: "Can we get unclaimed tokens?", answer: `After the 90-day claim period ends, all unclaimed tokens are returned to whichever wallet set up the migration (the team).`, keywords: ["unclaimed", "supply", "remaining", "tokens", "team"], category: "post-migration" },
+  { id: "participation-rate", question: "What is typical participation percentage?", answer: `Nearly all projects have had over 50% migration participation. View all stats at https://migrate.fun/projects`, keywords: ["participation", "percentage", "rate", "typical", "average"], category: "statistics" },
+  { id: "late-penalty", question: "What penalty can teams set for late migrators?", answer: `Teams can set 0-100% penalty for late migrators who swap during the 90-day claim window. 25% seems to be a good balance - encourages participation without being overly punishing.`, keywords: ["penalty", "late", "discount", "punish", "percent"], category: "settings" },
+  { id: "new-ca", question: "Will we get a new CA or just change the pair?", answer: `A new CA. If migrating to Bonk Fun your CA will end with "bonk". If migrating to Pump Fun it will end with "pump".`, keywords: ["ca", "contract", "address", "new", "pair"], category: "process" },
+  { id: "vanity-ca", question: "Can we create a vanity CA?", answer: `Yes, but if migrating to Bonk Fun it needs to end with "bonk", or for Pump Fun it needs to end with "pump".`, keywords: ["vanity", "ca", "custom", "address", "contract"], category: "features" },
+  { id: "vested-tokens", question: "What about team tokens locked with Streamflow?", answer: `Those tokens can't be migrated. They won't be lost - you'll recapture that supply post-migration. Any unmigrated tokens return to team at full or discounted rate depending on your late migrator penalty setting.`, keywords: ["vested", "streamflow", "locked", "team"], category: "edge-cases" },
+  { id: "wallet-tracking", question: "Can I track wallet addresses post-migration?", answer: `At the end of migration, there's a snapshot tool that lets you download a CSV of all wallets holding the old token.`, keywords: ["wallet", "track", "snapshot", "csv", "addresses"], category: "tools" },
+  { id: "old-listings", question: "What happens to old token listings?", answer: `You will need to apply to new directories. Migrate Fun provides a list once you begin the migration process.`, keywords: ["listings", "directories", "old", "new", "update"], category: "post-migration" },
+  { id: "lp-locking", question: "Does the new LP get locked?", answer: `If migrating to Bonk Fun or Pump Fun: LP is locked (their rules). If migrating to Raydium: LP is unlocked and you control it.`, keywords: ["lp", "locked", "liquidity", "pool", "control"], category: "process" },
+  { id: "sol-pairs", question: "Are Bonk migrations confined to SOL pairs?", answer: `As of October 2025, they are SOL migrations. Check with the team to see if USD1 pairs are possible.`, keywords: ["sol", "pair", "usd1", "usdc", "bonk"], category: "settings" },
+  { id: "change-penalty", question: "Can I change the penalty after setup?", answer: `No. The penalty must be set during migration creation and cannot be changed after.`, keywords: ["change", "penalty", "modify", "update", "after"], category: "settings" },
+  { id: "unhappy-holders", question: "What if someone is unhappy about the migration?", answer: `They can sell their tokens and not participate. Migrations are a fresh start - holders who migrate are voting with their tokens that they support the team and believe in the project's future.`, keywords: ["unhappy", "disagree", "against", "sell"], category: "user-experience" },
+  { id: "sample-announcement", question: "What is a good announcement template?", answer: `Sample for Bonk Fun migration:
+
+"We're excited to announce that we're migrating with @MigrateFun and officially joining the @bonk_inu ecosystem next month!
+
+With our 1-year anniversary less than a month away, this migration to @bonk_fun marks the beginning of our next chapter.
+
+Why Bonk Fun?
+\u{1F9F0} Purpose-built tools for community projects
+\u{1F4B8} Transaction fee rev share
+\u{1F501} Seamless LP migration
+\u{1F91D} Strategic alignment with top meme coin teams
+
+Our migration timeline + holder instructions drop soon."`, keywords: ["announcement", "template", "sample", "post"], category: "examples" },
+  { id: "share-link", question: "Do you have a link to share explaining Migrate Fun?", answer: `Overview thread: https://x.com/migratefun/status/1957492884355314035
+Deep dive docs: https://github.com/EmblemCompany/Migrate-fun-docs/`, keywords: ["link", "share", "explain", "overview"], category: "general" },
+  { id: "exchange-rate", question: "Is the exchange rate always 1:1?", answer: `Yes, 1 old token = 1 new token for users who participate in migration. Users who miss can swap during the 90-day claim window at a discounted rate set by the team.`, keywords: ["exchange", "rate", "1:1", "ratio", "same"], category: "process" },
+  { id: "change-supply", question: "Can I change the total supply?", answer: `Generally yes, with some constraints depending on destination platform. Reach out to Migrate Fun team to discuss specifics.`, keywords: ["supply", "change", "total", "amount"], category: "features" },
+  { id: "contact", question: "How can I get in touch with the Migrate Fun team?", answer: `Send a direct message to the Migrate Fun X account: https://x.com/MigrateFun`, keywords: ["contact", "reach", "touch", "dm", "message", "talk"], category: "general" },
+  { id: "ready-to-migrate", question: "I am ready to migrate, what is next?", answer: `Send a direct message to the Migrate Fun X account: https://x.com/MigrateFun`, keywords: ["ready", "start", "begin", "next"], category: "general" },
+  { id: "risks", question: "What are the risks of migrating?", answer: `Main risk: Failed migration where not enough tokens migrate to fund the new LP. In that case, migrated tokens are sold into the old LP and SOL is returned to community members who participated.`, keywords: ["risk", "danger", "fail", "problem", "issue"], category: "security" },
+  { id: "how-detect-non-migrators", question: "How does Migrate Fun know who did not migrate?", answer: `Migrate Fun has a snapshot and claim tool that puts onchain all wallets holding old tokens at migration end. This enables late migrators to swap old tokens for new during the 90-day claim window at the team-set discount.`, keywords: ["snapshot", "detect", "know", "non-migrators"], category: "tools" },
+  { id: "no-penalty", question: "What if I do not want to penalize non-migrators?", answer: `Set the late claim penalty to zero. Holders who didn't migrate can then swap old tokens for new at a 1:1 rate during the 90-day claim window.`, keywords: ["no penalty", "zero", "fair"], category: "settings" },
+  { id: "missed-claim-window", question: "What happens if holders miss both migration and claim window?", answer: `They won't have access to new tokens through Migrate Fun platform. All remaining tokens go to the team after 90-day window closes. The team has a snapshot of all old token holders and can handle at their discretion.`, keywords: ["missed", "both", "claim", "window", "late"], category: "edge-cases" },
+  { id: "exchange-options", question: "What options do exchanges have to swap tokens?", answer: `Two options:
+
+Option 1: Participate onchain through the migration portal (same as retail). Load tokens into Phantom wallet, migrate, then claim. ~10 seconds each step.
+
+Option 2: Admin withdraw function during 90-day claim period. Migration admin can withdraw new tokens from claims vault and manually swap with exchange.
+- 90-day window for exchange procedures
+- Exchange can observe migration complete before acting
+- Can receive new tokens before sending old
+- Can pause trading during process`, keywords: ["exchange", "cex", "swap", "options", "centralized"], category: "edge-cases" },
+  { id: "buy-prevent-dump", question: "Can we buy supply before migration to prevent dumping?", answer: `I would recommend buying now. There is no arb opportunity as you set the market cap of the new token.
+
+To regain control of non-migrated tokens, you can penalize non-migrators. Example: If 60% migrate, 40% didn't. With a 50% penalty on non-migrators, you'd recoup 20% of total supply if everyone claimed.`, keywords: ["buy", "dump", "supply", "control", "arb"], category: "strategy" }
+];
+var migrateFunPlugin = {
+  name: "migrate-fun-knowledge",
+  version: "1.0.0",
+  description: "Search Migrate.fun knowledge base for token migration answers",
+  tools: [
+    {
+      name: "search_migrate_fun_docs",
+      description: "Search the Migrate.fun knowledge base for answers about token migrations. Use this tool when users ask about: how migrations work (Bonk Fun, Pump Fun, Raydium), costs/fees/timelines, post-migration steps, user experience, technical details (LP, CA, penalties), or examples. Returns ranked Q&A pairs from real support conversations.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query - user question or key terms about token migrations"
+          },
+          topK: {
+            type: "number",
+            description: "Number of results to return (default: 5, max: 10)"
+          }
+        },
+        required: ["query"]
+      }
+    }
+  ],
+  executors: {
+    search_migrate_fun_docs: async (args2) => {
+      const query = args2.query;
+      const topK = Math.min(Math.max(1, args2.topK || 5), 10);
+      const queryLower = query.toLowerCase();
+      const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 2);
+      const scored = QA.map((qa) => {
+        let score = 0;
+        const questionLower = qa.question.toLowerCase();
+        const answerLower = qa.answer.toLowerCase();
+        const keywordsStr = qa.keywords.join(" ").toLowerCase();
+        const fullText = `${questionLower} ${answerLower} ${keywordsStr}`;
+        if (questionLower.includes(queryLower)) score += 15;
+        if (fullText.includes(queryLower)) score += 8;
+        for (const word of queryWords) {
+          if (qa.keywords.some((kw) => kw.toLowerCase().includes(word) || word.includes(kw.toLowerCase()))) {
+            score += 4;
+          }
+          if (questionLower.includes(word)) score += 3;
+          if (answerLower.includes(word)) score += 1;
+        }
+        return { ...qa, score };
+      });
+      const results = scored.filter((qa) => qa.score > 0).sort((a, b) => b.score - a.score).slice(0, topK).map((qa, i) => ({
+        rank: i + 1,
+        relevance: Math.round(qa.score / 30 * 100) / 100,
+        question: qa.question,
+        answer: qa.answer,
+        category: qa.category
+      }));
+      return {
+        success: true,
+        query,
+        resultCount: results.length,
+        results,
+        hint: results.length === 0 ? "No matches found. Suggest contacting @MigrateFun on X: https://x.com/MigrateFun" : "Use these Q&A pairs to answer. Include relevant links from the answers."
+      };
+    }
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[Plugin] Migrate.fun Knowledge Base v1.0.0 registered");
+    }
+  }
+};
+
+// src/plugins/piiProtection.ts
+var TOKEN_MAP_KEY = "__piiTokenMaps";
+var PERSISTENT_MAP_KEY = "__piiPersistentMap";
+function getTokenMaps() {
+  const storage = typeof window !== "undefined" ? window : global;
+  if (!storage[TOKEN_MAP_KEY]) {
+    storage[TOKEN_MAP_KEY] = /* @__PURE__ */ new Map();
+  }
+  return storage[TOKEN_MAP_KEY];
+}
+function getPersistentMap() {
+  const storage = typeof window !== "undefined" ? window : global;
+  if (!storage[PERSISTENT_MAP_KEY]) {
+    storage[PERSISTENT_MAP_KEY] = {
+      piiToToken: /* @__PURE__ */ new Map(),
+      tokenToPii: /* @__PURE__ */ new Map(),
+      counter: { value: 0 }
+    };
+  }
+  return storage[PERSISTENT_MAP_KEY];
+}
+var piiProtectionPlugin = {
+  name: "pii-protection",
+  version: "1.0.0",
+  description: "Tokenizes PII before sending to AI, restores in responses",
+  tools: [],
+  executors: {},
+  hooks: {
+    onRegister: () => {
+      console.log("[PII Protection] Plugin registered - PII will be tokenized in requests");
+    },
+    beforeRequest: (request) => {
+      const maps = getTokenMaps();
+      const persistent = getPersistentMap();
+      const requestId = Date.now().toString();
+      const requestTokenMap = /* @__PURE__ */ new Map();
+      const tokenize = (text) => {
+        if (typeof text !== "string") return text;
+        return text.replace(/\b\d{3}-\d{2}-\d{4}\b/g, (match) => {
+          if (persistent.piiToToken.has(match)) {
+            const existingToken = persistent.piiToToken.get(match);
+            requestTokenMap.set(existingToken, match);
+            return existingToken;
+          }
+          const token = `{{SSN_${++persistent.counter.value}}}`;
+          persistent.piiToToken.set(match, token);
+          persistent.tokenToPii.set(token, match);
+          requestTokenMap.set(token, match);
+          return token;
+        }).replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/gi, (match) => {
+          if (persistent.piiToToken.has(match)) {
+            const existingToken = persistent.piiToToken.get(match);
+            requestTokenMap.set(existingToken, match);
+            return existingToken;
+          }
+          const token = `{{EMAIL_${++persistent.counter.value}}}`;
+          persistent.piiToToken.set(match, token);
+          persistent.tokenToPii.set(token, match);
+          requestTokenMap.set(token, match);
+          return token;
+        }).replace(/\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g, (match) => {
+          if (persistent.piiToToken.has(match)) {
+            const existingToken = persistent.piiToToken.get(match);
+            requestTokenMap.set(existingToken, match);
+            return existingToken;
+          }
+          const token = `{{PHONE_${++persistent.counter.value}}}`;
+          persistent.piiToToken.set(match, token);
+          persistent.tokenToPii.set(token, match);
+          requestTokenMap.set(token, match);
+          return token;
+        }).replace(/\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g, (match) => {
+          if (persistent.piiToToken.has(match)) {
+            const existingToken = persistent.piiToToken.get(match);
+            requestTokenMap.set(existingToken, match);
+            return existingToken;
+          }
+          const token = `{{CARD_${++persistent.counter.value}}}`;
+          persistent.piiToToken.set(match, token);
+          persistent.tokenToPii.set(token, match);
+          requestTokenMap.set(token, match);
+          return token;
+        });
+      };
+      const anonymizedMessages = request.messages.map((msg) => ({
+        ...msg,
+        content: typeof msg.content === "string" ? tokenize(msg.content) : msg.content
+      }));
+      if (requestTokenMap.size > 0) {
+        maps.set(requestId, requestTokenMap);
+        console.log(`[PII Protection] Tokenized ${requestTokenMap.size} PII values`);
+      }
+      return { ...request, messages: anonymizedMessages };
+    },
+    afterResponse: (response) => {
+      const persistent = getPersistentMap();
+      if (typeof response.content === "string") {
+        let restored = response.content;
+        let restoredCount = 0;
+        for (const [token, original] of persistent.tokenToPii.entries()) {
+          if (restored.includes(token)) {
+            restored = restored.split(token).join(original);
+            restoredCount++;
+          }
+        }
+        if (restoredCount > 0) {
+          response.content = restored;
+          console.log(`[PII Protection] Restored ${restoredCount} PII values`);
+        }
+      }
+    }
+  }
+};
+
+// src/plugins/userQuestion.ts
+function ensureModalStyles() {
+  if (typeof document === "undefined") return;
+  const styleId = "user-question-modal-styles";
+  if (document.getElementById(styleId)) return;
+  const styles2 = document.createElement("style");
+  styles2.id = styleId;
+  styles2.textContent = `
+    .user-question-overlay {
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: rgba(0, 0, 0, 0.6);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 10000;
+      animation: uqFadeIn 0.2s ease-out;
+    }
+
+    @keyframes uqFadeIn {
+      from { opacity: 0; }
+      to { opacity: 1; }
+    }
+
+    .user-question-modal {
+      background: #1a1a2e;
+      border: 1px solid #333;
+      border-radius: 12px;
+      padding: 24px;
+      max-width: 480px;
+      width: 90%;
+      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.4);
+      animation: uqSlideUp 0.2s ease-out;
+    }
+
+    @keyframes uqSlideUp {
+      from { transform: translateY(20px); opacity: 0; }
+      to { transform: translateY(0); opacity: 1; }
+    }
+
+    .user-question-title {
+      font-size: 18px;
+      font-weight: 600;
+      color: #fff;
+      margin: 0 0 16px 0;
+    }
+
+    .user-question-choices {
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+      margin-bottom: 20px;
+    }
+
+    .user-question-choice {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      padding: 12px 16px;
+      background: #252540;
+      border: 1px solid #333;
+      border-radius: 8px;
+      cursor: pointer;
+      transition: all 0.15s ease;
+    }
+
+    .user-question-choice:hover {
+      background: #2a2a4a;
+      border-color: #4a4a6a;
+    }
+
+    .user-question-choice.selected {
+      background: #2a3a5a;
+      border-color: #4a7aff;
+    }
+
+    .user-question-choice input {
+      margin: 0;
+      accent-color: #4a7aff;
+    }
+
+    .user-question-choice label {
+      flex: 1;
+      color: #e0e0e0;
+      cursor: pointer;
+      font-size: 14px;
+    }
+
+    .user-question-actions {
+      display: flex;
+      gap: 12px;
+      justify-content: flex-end;
+    }
+
+    .user-question-btn {
+      padding: 10px 20px;
+      border-radius: 6px;
+      font-size: 14px;
+      font-weight: 500;
+      cursor: pointer;
+      transition: all 0.15s ease;
+    }
+
+    .user-question-btn-cancel {
+      background: transparent;
+      border: 1px solid #444;
+      color: #aaa;
+    }
+
+    .user-question-btn-cancel:hover {
+      background: #333;
+      color: #fff;
+    }
+
+    .user-question-btn-submit {
+      background: #4a7aff;
+      border: none;
+      color: #fff;
+    }
+
+    .user-question-btn-submit:hover {
+      background: #5a8aff;
+    }
+
+    .user-question-btn-submit:disabled {
+      background: #333;
+      color: #666;
+      cursor: not-allowed;
+    }
+  `;
+  document.head.appendChild(styles2);
+}
+var askUserTool = {
+  name: "ask_user",
+  description: `Ask the user a multiple choice question and wait for their response. Use this when you need user input to proceed - for example: clarifying requirements, getting preferences, or confirming actions. The tool blocks until the user responds.`,
+  parameters: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "The question to ask the user"
+      },
+      choices: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of choices to present (2-6 options recommended)"
+      },
+      allowMultiple: {
+        type: "boolean",
+        description: "If true, user can select multiple choices. Default: false"
+      }
+    },
+    required: ["question", "choices"]
+  }
+};
+var askUserExecutor = async (args2) => {
+  const { question, choices, allowMultiple = false } = args2;
+  if (!question || !choices || !Array.isArray(choices) || choices.length === 0) {
+    return {
+      question: question || "",
+      selectedChoices: [],
+      answered: false
+    };
+  }
+  if (typeof document === "undefined") {
+    console.log(`[User Question] Question: ${question}`);
+    console.log(`[User Question] Choices: ${choices.join(", ")}`);
+    return {
+      question,
+      selectedChoices: [choices[0]],
+      answered: true
+    };
+  }
+  ensureModalStyles();
+  return new Promise((resolve) => {
+    const selected = /* @__PURE__ */ new Set();
+    const overlay = document.createElement("div");
+    overlay.className = "user-question-overlay";
+    const modal = document.createElement("div");
+    modal.className = "user-question-modal";
+    const title = document.createElement("h3");
+    title.className = "user-question-title";
+    title.textContent = question;
+    modal.appendChild(title);
+    const choicesDiv = document.createElement("div");
+    choicesDiv.className = "user-question-choices";
+    const inputType = allowMultiple ? "checkbox" : "radio";
+    const inputName = `uq-${Date.now()}`;
+    choices.forEach((choice, index) => {
+      const choiceDiv = document.createElement("div");
+      choiceDiv.className = "user-question-choice";
+      const input = document.createElement("input");
+      input.type = inputType;
+      input.name = inputName;
+      input.id = `${inputName}-${index}`;
+      input.value = choice;
+      const label = document.createElement("label");
+      label.htmlFor = input.id;
+      label.textContent = choice;
+      choiceDiv.appendChild(input);
+      choiceDiv.appendChild(label);
+      const handleSelect = () => {
+        if (allowMultiple) {
+          if (selected.has(choice)) {
+            selected.delete(choice);
+            choiceDiv.classList.remove("selected");
+          } else {
+            selected.add(choice);
+            choiceDiv.classList.add("selected");
+          }
+        } else {
+          selected.clear();
+          selected.add(choice);
+          choicesDiv.querySelectorAll(".user-question-choice").forEach((c) => c.classList.remove("selected"));
+          choiceDiv.classList.add("selected");
+        }
+        updateSubmitButton();
+      };
+      input.addEventListener("change", handleSelect);
+      choiceDiv.addEventListener("click", (e) => {
+        if (e.target !== input) {
+          input.checked = !input.checked || !allowMultiple;
+          handleSelect();
+        }
+      });
+      choicesDiv.appendChild(choiceDiv);
+    });
+    modal.appendChild(choicesDiv);
+    const actions = document.createElement("div");
+    actions.className = "user-question-actions";
+    const cancelBtn = document.createElement("button");
+    cancelBtn.className = "user-question-btn user-question-btn-cancel";
+    cancelBtn.textContent = "Skip";
+    cancelBtn.onclick = () => {
+      cleanup();
+      resolve({
+        question,
+        selectedChoices: [],
+        answered: false
+      });
+    };
+    const submitBtn = document.createElement("button");
+    submitBtn.className = "user-question-btn user-question-btn-submit";
+    submitBtn.textContent = "Submit";
+    submitBtn.disabled = true;
+    submitBtn.onclick = () => {
+      cleanup();
+      resolve({
+        question,
+        selectedChoices: Array.from(selected),
+        answered: true
+      });
+    };
+    const updateSubmitButton = () => {
+      submitBtn.disabled = selected.size === 0;
+    };
+    actions.appendChild(cancelBtn);
+    actions.appendChild(submitBtn);
+    modal.appendChild(actions);
+    overlay.appendChild(modal);
+    document.body.appendChild(overlay);
+    const cleanup = () => {
+      overlay.remove();
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        document.removeEventListener("keydown", handleEscape);
+        cleanup();
+        resolve({
+          question,
+          selectedChoices: [],
+          answered: false
+        });
+      }
+    };
+    document.addEventListener("keydown", handleEscape);
+  });
+};
+var userQuestionPlugin = {
+  name: "user-question",
+  version: "1.0.0",
+  description: "Allows AI to ask users multiple choice questions via modal",
+  tools: [askUserTool],
+  executors: {
+    ask_user: askUserExecutor
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[User Question] Plugin registered - AI can now ask you questions");
+    }
+  }
+};
+
+// src/plugins/alert.ts
+var sendAlertTool = {
+  name: "send_alert",
+  description: "Display a browser alert popup with a message to the user",
+  parameters: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "The message to display in the alert popup"
+      }
+    },
+    required: ["message"]
+  }
+};
+var sendAlertExecutor = async (args2) => {
+  const message = args2.message;
+  if (typeof window === "undefined") {
+    console.log(`[Alert] ${message}`);
+    return { success: true, message, environment: "server" };
+  }
+  alert(message);
+  return { success: true, message };
+};
+var alertPlugin = {
+  name: "alert",
+  version: "1.0.0",
+  description: "Display browser alert popups",
+  tools: [sendAlertTool],
+  executors: {
+    send_alert: sendAlertExecutor
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[Alert] Plugin registered");
+    }
+  }
+};
+
+// src/plugins/jsExecutor.ts
+var executeJsTool = {
+  name: "execute_javascript",
+  description: `Execute JavaScript code in the browser and return the results. The code runs in the page context with access to DOM, window, localStorage, etc.
+
+IMPORTANT USAGE NOTES:
+- Use console.log() to output values that will be captured and returned
+- The last expression's value OR explicit return statement will be captured as 'returnValue'
+- All console.log calls are captured in the 'logs' array
+- For multi-line code, escape newlines or use semicolons: "const x = 1; const y = 2; console.log(x + y);"
+- Example: "const prices = [100, 200, 150]; const avg = prices.reduce((a,b) => a+b, 0) / prices.length; console.log('Average:', avg); return avg;"
+- Can access: document, window, localStorage, fetch, etc.`,
+  parameters: {
+    type: "object",
+    properties: {
+      code: {
+        type: "string",
+        description: "The JavaScript code to execute. Use console.log() for output and/or return a value."
+      }
+    },
+    required: ["code"]
+  }
+};
+var executeJsExecutor = async (args) => {
+  const code = args.code;
+  if (typeof window === "undefined") {
+    return {
+      success: false,
+      returnValue: null,
+      logs: [],
+      error: { message: "JavaScript execution requires browser environment" }
+    };
+  }
+  const logs = [];
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+  console.log = (...logArgs) => {
+    logs.push({
+      type: "log",
+      args: logArgs.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+    });
+    originalLog.apply(console, logArgs);
+  };
+  console.warn = (...logArgs) => {
+    logs.push({
+      type: "warn",
+      args: logArgs.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+    });
+    originalWarn.apply(console, logArgs);
+  };
+  console.error = (...logArgs) => {
+    logs.push({
+      type: "error",
+      args: logArgs.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+    });
+    originalError.apply(console, logArgs);
+  };
+  let returnValue;
+  let error = null;
+  try {
+    const wrappedCode = "(async () => { " + code + " })()";
+    returnValue = await eval(wrappedCode);
+  } catch (e) {
+    const err = e;
+    error = { message: err.message, stack: err.stack };
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+  return {
+    success: !error,
+    returnValue: returnValue !== void 0 ? typeof returnValue === "object" ? JSON.stringify(returnValue) : String(returnValue) : null,
+    logs,
+    error
+  };
+};
+var jsExecutorPlugin = {
+  name: "js-executor",
+  version: "1.0.0",
+  description: "Execute JavaScript code in the browser",
+  tools: [executeJsTool],
+  executors: {
+    execute_javascript: executeJsExecutor
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[JS Executor] Plugin registered - AI can now execute JavaScript");
+    }
+  }
+};
+
+// src/plugins/screenshot.ts
+var screenshotTool = {
+  name: "take_screenshot",
+  description: `Take a screenshot of the current page and upload it. Returns the URL of the uploaded image that can be used in conversation or for analysis.
+
+The screenshot captures the visible viewport of the page. The image is uploaded to the server and a permanent URL is returned.
+
+Use this when:
+- User asks to see what's on their screen
+- You need to analyze the current page visually
+- User wants to share/save the current view`,
+  parameters: {
+    type: "object",
+    properties: {
+      selector: {
+        type: "string",
+        description: "Optional CSS selector to capture a specific element instead of the full page. Leave empty for full page screenshot."
+      }
+    }
+  }
+};
+var screenshotExecutor = async (args2) => {
+  const selector = args2.selector;
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return {
+      success: false,
+      error: "Screenshot requires browser environment"
+    };
+  }
+  try {
+    if (!window.html2canvas) {
+      await new Promise((resolve, reject) => {
+        const script = document.createElement("script");
+        script.src = "https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js";
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error("Failed to load html2canvas"));
+        document.head.appendChild(script);
+      });
+    }
+    const target = selector ? document.querySelector(selector) : document.body;
+    if (!target) {
+      return { success: false, error: "Element not found: " + selector };
+    }
+    const canvas = await window.html2canvas(target, {
+      useCORS: true,
+      allowTaint: true,
+      backgroundColor: "#000000",
+      scale: 1
+    });
+    const blob = await new Promise((resolve) => {
+      canvas.toBlob(resolve, "image/png", 0.9);
+    });
+    if (!blob) {
+      return { success: false, error: "Failed to create image blob" };
+    }
+    const formData = new FormData();
+    formData.append("file", blob, "screenshot-" + Date.now() + ".png");
+    const response = await fetch("/api/files/upload", {
+      method: "POST",
+      body: formData
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      return { success: false, error: errorData.error || "Upload failed" };
+    }
+    const data = await response.json();
+    return {
+      success: true,
+      url: data.url,
+      contentType: data.contentType,
+      message: "Screenshot captured and uploaded successfully"
+    };
+  } catch (e) {
+    const err = e;
+    return {
+      success: false,
+      error: err.message || "Screenshot failed"
+    };
+  }
+};
+var screenshotPlugin = {
+  name: "screenshot",
+  version: "1.0.0",
+  description: "Take screenshots of the current page",
+  tools: [screenshotTool],
+  executors: {
+    take_screenshot: screenshotExecutor
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[Screenshot] Plugin registered - AI can now take screenshots");
+    }
+  }
+};
+
+// src/plugins/index.ts
+var availablePlugins = [
+  {
+    ...predictionMarketPlugin,
+    description: "Search and analyze Polymarket and Kalshi prediction markets"
+  },
+  {
+    ...migrateFunPlugin,
+    description: "Search Migrate.fun knowledge base for token migration answers"
+  },
+  {
+    ...piiProtectionPlugin,
+    description: "Tokenizes PII before sending to AI, restores in responses"
+  },
+  {
+    ...userQuestionPlugin,
+    description: "Allows AI to ask users multiple choice questions via modal"
+  },
+  {
+    ...alertPlugin,
+    description: "Display browser alert popups"
+  },
+  {
+    ...jsExecutorPlugin,
+    description: "Execute JavaScript code in the browser"
+  },
+  {
+    ...screenshotPlugin,
+    description: "Take screenshots of the current page"
+  }
+];
+function getAvailablePlugin(name) {
+  return availablePlugins.find((p) => p.name === name);
+}
+
+// src/styles/tokens.ts
+var defaults = {
+  colors: {
+    // Backgrounds
+    bgPrimary: "#0b0d10",
+    bgSecondary: "#12161b",
+    bgTertiary: "#1a1f25",
+    bgHover: "#252b33",
+    bgOverlay: "rgba(0, 0, 0, 0.7)",
+    // Borders
+    borderPrimary: "#222b35",
+    borderSecondary: "#333",
+    borderHover: "#444",
+    // Text
+    textPrimary: "#e6eef8",
+    textSecondary: "#8892a4",
+    textTertiary: "#6b7280",
+    textInverse: "#fff",
+    // Accent - Primary (blue)
+    accentPrimary: "#4c9aff",
+    accentPrimaryHover: "#7bb6ff",
+    accentPrimaryBg: "rgba(76, 154, 255, 0.1)",
+    // Accent - Success (green)
+    accentSuccess: "#10b981",
+    accentSuccessHover: "#34d399",
+    accentSuccessBg: "rgba(16, 185, 129, 0.1)",
+    // Accent - Warning (yellow/orange)
+    accentWarning: "#f59e0b",
+    accentWarningBg: "rgba(245, 158, 11, 0.1)",
+    // Accent - Error (red)
+    accentError: "#dc2626",
+    accentErrorHover: "#ef4444",
+    accentErrorBg: "rgba(239, 68, 68, 0.1)",
+    // Messages
+    msgUser: "#1e3a5f",
+    msgAssistant: "#1a2633"
+  },
+  typography: {
+    fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+    fontFamilyMono: '"SF Mono", Monaco, monospace',
+    fontSizeXs: "11px",
+    fontSizeSm: "13px",
+    fontSizeMd: "14px",
+    fontSizeLg: "16px",
+    fontSizeXl: "18px",
+    fontWeightNormal: "400",
+    fontWeightMedium: "500",
+    fontWeightSemibold: "600",
+    lineHeightTight: "1.3",
+    lineHeightNormal: "1.5",
+    lineHeightRelaxed: "1.7"
+  },
+  spacing: {
+    xs: "4px",
+    sm: "8px",
+    md: "12px",
+    lg: "16px",
+    xl: "20px",
+    xxl: "24px"
+  },
+  radius: {
+    sm: "4px",
+    md: "6px",
+    lg: "8px",
+    xl: "12px",
+    pill: "20px",
+    full: "50%"
+  },
+  shadows: {
+    sm: "0 2px 8px rgba(0,0,0,0.2)",
+    md: "0 4px 16px rgba(0,0,0,0.3)",
+    lg: "0 8px 32px rgba(0,0,0,0.4)",
+    xl: "0 16px 48px rgba(0,0,0,0.5)"
+  },
+  // Glow effects (for enhanced themes)
+  glows: {
+    primary: "rgba(76, 154, 255, 0.4)",
+    success: "rgba(16, 185, 129, 0.4)",
+    error: "rgba(239, 68, 68, 0.4)",
+    ambient: "rgba(76, 154, 255, 0.08)"
+  },
+  transitions: {
+    fast: "0.15s ease",
+    normal: "0.2s ease",
+    slow: "0.3s ease"
+  },
+  zIndex: {
+    dropdown: "100",
+    modal: "1000",
+    fullscreen: "1000",
+    modalOverFullscreen: "10000"
+  }
+};
+function toVarName(category, key) {
+  const kebab = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+  return `--hustle-${category}-${kebab}`;
+}
+function generateCSSVariables() {
+  const lines = [":root {"];
+  for (const [key, value] of Object.entries(defaults.colors)) {
+    lines.push(`  ${toVarName("color", key)}: ${value};`);
+  }
+  for (const [key, value] of Object.entries(defaults.typography)) {
+    lines.push(`  ${toVarName("font", key)}: ${value};`);
+  }
+  for (const [key, value] of Object.entries(defaults.spacing)) {
+    lines.push(`  ${toVarName("space", key)}: ${value};`);
+  }
+  for (const [key, value] of Object.entries(defaults.radius)) {
+    lines.push(`  ${toVarName("radius", key)}: ${value};`);
+  }
+  for (const [key, value] of Object.entries(defaults.shadows)) {
+    lines.push(`  ${toVarName("shadow", key)}: ${value};`);
+  }
+  for (const [key, value] of Object.entries(defaults.glows)) {
+    lines.push(`  ${toVarName("glow", key)}: ${value};`);
+  }
+  for (const [key, value] of Object.entries(defaults.transitions)) {
+    lines.push(`  ${toVarName("transition", key)}: ${value};`);
+  }
+  for (const [key, value] of Object.entries(defaults.zIndex)) {
+    lines.push(`  ${toVarName("z", key)}: ${value};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+generateCSSVariables();
+function createColorTokens() {
+  const result = {};
+  for (const [key, defaultValue] of Object.entries(defaults.colors)) {
+    result[key] = `var(${toVarName("color", key)}, ${defaultValue})`;
+  }
+  return result;
+}
+function createTypographyTokens() {
+  const result = {};
+  for (const [key, defaultValue] of Object.entries(defaults.typography)) {
+    result[key] = `var(${toVarName("font", key)}, ${defaultValue})`;
+  }
+  return result;
+}
+function createSpacingTokens() {
+  const result = {};
+  for (const [key, defaultValue] of Object.entries(defaults.spacing)) {
+    result[key] = `var(${toVarName("space", key)}, ${defaultValue})`;
+  }
+  return result;
+}
+function createRadiusTokens() {
+  const result = {};
+  for (const [key, defaultValue] of Object.entries(defaults.radius)) {
+    result[key] = `var(${toVarName("radius", key)}, ${defaultValue})`;
+  }
+  return result;
+}
+function createShadowTokens() {
+  const result = {};
+  for (const [key, defaultValue] of Object.entries(defaults.shadows)) {
+    result[key] = `var(${toVarName("shadow", key)}, ${defaultValue})`;
+  }
+  return result;
+}
+function createGlowTokens() {
+  const result = {};
+  for (const [key, defaultValue] of Object.entries(defaults.glows)) {
+    result[key] = `var(${toVarName("glow", key)}, ${defaultValue})`;
+  }
+  return result;
+}
+function createTransitionTokens() {
+  const result = {};
+  for (const [key, defaultValue] of Object.entries(defaults.transitions)) {
+    result[key] = `var(${toVarName("transition", key)}, ${defaultValue})`;
+  }
+  return result;
+}
+function createZIndexTokens() {
+  const result = {};
+  for (const [key, defaultValue] of Object.entries(defaults.zIndex)) {
+    result[key] = parseInt(defaultValue, 10);
+  }
+  return result;
+}
+var tokens = {
+  colors: createColorTokens(),
+  typography: createTypographyTokens(),
+  spacing: createSpacingTokens(),
+  radius: createRadiusTokens(),
+  shadows: createShadowTokens(),
+  glows: createGlowTokens(),
+  transitions: createTransitionTokens(),
+  zIndex: createZIndexTokens()
+};
+var presets = {
+  base: {
+    fontFamily: tokens.typography.fontFamily,
+    fontSize: tokens.typography.fontSizeMd,
+    lineHeight: tokens.typography.lineHeightNormal,
+    color: tokens.colors.textPrimary
+  },
+  card: {
+    background: tokens.colors.bgSecondary,
+    border: `1px solid ${tokens.colors.borderPrimary}`,
+    borderRadius: tokens.radius.xl
+  },
+  input: {
+    background: tokens.colors.bgTertiary,
+    border: `1px solid ${tokens.colors.borderSecondary}`,
+    borderRadius: tokens.radius.lg,
+    color: tokens.colors.textPrimary,
+    fontSize: tokens.typography.fontSizeMd,
+    padding: `${tokens.spacing.md} ${tokens.spacing.lg}`,
+    transition: `border-color ${tokens.transitions.normal}`
+  },
+  button: {
+    gap: tokens.spacing.sm,
+    padding: `${tokens.spacing.sm} ${tokens.spacing.lg}`,
+    borderRadius: tokens.radius.lg,
+    fontSize: tokens.typography.fontSizeMd,
+    fontWeight: tokens.typography.fontWeightMedium,
+    transition: `all ${tokens.transitions.normal}`,
+    border: `1px solid ${tokens.colors.borderSecondary}`},
+  buttonPrimary: {
+    background: tokens.colors.accentPrimary,
+    color: tokens.colors.textInverse,
+    borderColor: tokens.colors.accentPrimary
+  },
+  buttonSecondary: {
+    background: tokens.colors.bgTertiary,
+    color: tokens.colors.textPrimary,
+    borderColor: tokens.colors.borderSecondary
+  },
+  buttonIcon: {
+    width: "36px",
+    height: "36px",
+    padding: 0,
+    // background inherited from global button styles
+    color: tokens.colors.textSecondary
+  },
+  mono: {
+    fontFamily: tokens.typography.fontFamilyMono,
+    fontSize: tokens.typography.fontSizeSm
+  },
+  label: {
+    fontSize: tokens.typography.fontSizeXs,
+    color: tokens.colors.textTertiary,
+    marginBottom: tokens.spacing.xs
+  }
+};
+var animations = `
+@keyframes hustle-spin {
+  to { transform: rotate(360deg); }
+}
+@keyframes hustle-pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.5; }
+}
+@keyframes hustle-glow {
+  0%, 100% {
+    opacity: 1;
+    text-shadow: 0 0 4px ${defaults.colors.accentPrimaryBg};
+  }
+  50% {
+    opacity: 0.6;
+    text-shadow: 0 0 8px ${defaults.colors.accentPrimary};
+  }
+}
+`;
+hljs.registerLanguage("javascript", javascript);
+hljs.registerLanguage("js", javascript);
+hljs.registerLanguage("typescript", typescript);
+hljs.registerLanguage("ts", typescript);
+hljs.registerLanguage("python", python);
+hljs.registerLanguage("py", python);
+hljs.registerLanguage("json", json);
+hljs.registerLanguage("bash", bash);
+hljs.registerLanguage("sh", bash);
+hljs.registerLanguage("shell", shell);
+hljs.registerLanguage("css", css);
+hljs.registerLanguage("xml", xml);
+hljs.registerLanguage("html", xml);
+hljs.registerLanguage("markdown", markdown);
+hljs.registerLanguage("md", markdown);
+hljs.registerLanguage("sql", sql);
+hljs.registerLanguage("yaml", yaml);
+hljs.registerLanguage("yml", yaml);
+hljs.registerLanguage("rust", rust);
+hljs.registerLanguage("go", go);
+hljs.registerLanguage("java", java);
+hljs.registerLanguage("cpp", cpp);
+hljs.registerLanguage("c", cpp);
+hljs.registerLanguage("csharp", csharp);
+hljs.registerLanguage("cs", csharp);
+hljs.registerLanguage("php", php);
+hljs.registerLanguage("ruby", ruby);
+hljs.registerLanguage("rb", ruby);
+hljs.registerLanguage("swift", swift);
+hljs.registerLanguage("kotlin", kotlin);
+hljs.registerLanguage("kt", kotlin);
+var containerStyle = {
+  fontFamily: tokens.typography.fontFamily,
+  fontSize: tokens.typography.fontSizeMd,
+  lineHeight: 1.5,
+  color: "inherit",
+  wordBreak: "break-word"
+};
+var scopedStyles = `
+.hljs-md p {
+  margin: 0 0 0.5em 0;
+}
+.hljs-md p:last-child {
+  margin-bottom: 0;
+}
+.hljs-md ul,
+.hljs-md ol {
+  margin: 0.25em 0 0.5em 0;
+  padding-left: 1.5em;
+}
+.hljs-md li {
+  margin: 0.1em 0;
+  line-height: 1.4;
+}
+.hljs-md li > p {
+  margin: 0;
+  display: inline;
+}
+.hljs-md li > ul,
+.hljs-md li > ol {
+  margin: 0.1em 0;
+}
+.hljs-md .code-block-wrapper {
+  position: relative;
+  margin: 0.5em 0;
+}
+.hljs-md .code-block-wrapper pre {
+  position: relative;
+  margin: 0;
+  padding: 0.75em 1em;
+  border-radius: 6px;
+  background: #1e1e1e;
+  overflow-x: auto;
+}
+.hljs-md .code-block-toolbar {
+  position: absolute;
+  top: 6px;
+  right: 6px;
+  display: flex;
+  gap: 4px;
+  z-index: 10;
+}
+.hljs-md .code-block-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 26px;
+  height: 26px;
+  padding: 0;
+  background: #2d2d2d;
+  border: 1px solid #404040;
+  border-radius: 4px;
+  color: #888;
+  cursor: pointer;
+  transition: all 0.15s ease;
+  opacity: 0.7;
+}
+.hljs-md .code-block-wrapper:hover .code-block-btn {
+  opacity: 1;
+}
+.hljs-md .code-block-btn:hover {
+  background: #3d3d3d;
+  border-color: #555;
+  color: #ccc;
+}
+.hljs-md .code-block-btn.copied {
+  color: ${tokens.colors.accentSuccess};
+}
+.hljs-md code {
+  font-family: ${tokens.typography.fontFamilyMono};
+  font-size: 0.9em;
+}
+.hljs-md :not(pre) > code {
+  padding: 0.15em 0.4em;
+  border-radius: 4px;
+  background: rgba(255, 255, 255, 0.1);
+}
+.hljs-md pre code {
+  padding: 0;
+  background: transparent;
+  font-size: 0.875em;
+  line-height: 1.5;
+}
+.hljs-md h1, .hljs-md h2, .hljs-md h3, .hljs-md h4 {
+  margin: 0.5em 0 0.25em 0;
+  font-weight: 600;
+  line-height: 1.3;
+}
+.hljs-md h1:first-child, .hljs-md h2:first-child, .hljs-md h3:first-child {
+  margin-top: 0;
+}
+.hljs-md h1 { font-size: 1.5em; }
+.hljs-md h2 { font-size: 1.25em; }
+.hljs-md h3 { font-size: 1.1em; }
+.hljs-md h4 { font-size: 1em; }
+.hljs-md blockquote {
+  margin: 0.5em 0;
+  padding: 0.5em 0 0.5em 1em;
+  border-left: 3px solid ${tokens.colors.borderSecondary};
+  color: ${tokens.colors.textSecondary};
+}
+.hljs-md a {
+  color: ${tokens.colors.accentPrimary};
+  text-decoration: underline;
+}
+.hljs-md hr {
+  margin: 1em 0;
+  border: none;
+  border-top: 1px solid ${tokens.colors.borderSecondary};
+}
+.hljs-md table {
+  width: 100%;
+  margin: 0.5em 0;
+  border-collapse: collapse;
+}
+.hljs-md th, .hljs-md td {
+  padding: 0.5em;
+  border: 1px solid ${tokens.colors.borderPrimary};
+  text-align: left;
+}
+.hljs-md th {
+  font-weight: 600;
+  background: rgba(255, 255, 255, 0.05);
+}
+
+/* highlight.js dark theme (VS Code Dark+ inspired) */
+.hljs {
+  color: #d4d4d4;
+  background: #1e1e1e;
+}
+.hljs-keyword,
+.hljs-selector-tag,
+.hljs-title,
+.hljs-section,
+.hljs-doctag,
+.hljs-name,
+.hljs-strong {
+  color: #569cd6;
+  font-weight: normal;
+}
+.hljs-built_in,
+.hljs-literal,
+.hljs-type,
+.hljs-params,
+.hljs-meta,
+.hljs-link {
+  color: #4ec9b0;
+}
+.hljs-string,
+.hljs-symbol,
+.hljs-bullet,
+.hljs-addition {
+  color: #ce9178;
+}
+.hljs-number {
+  color: #b5cea8;
+}
+.hljs-comment,
+.hljs-quote,
+.hljs-deletion {
+  color: #6a9955;
+}
+.hljs-variable,
+.hljs-template-variable,
+.hljs-attr {
+  color: #9cdcfe;
+}
+.hljs-regexp,
+.hljs-selector-id,
+.hljs-selector-class {
+  color: #d7ba7d;
+}
+.hljs-emphasis {
+  font-style: italic;
+}
+`;
+marked.use({
+  gfm: true,
+  breaks: false
+});
+function highlightCode(code2, lang) {
+  if (lang && hljs.getLanguage(lang)) {
+    try {
+      return hljs.highlight(code2, { language: lang }).value;
+    } catch {
+    }
+  }
+  try {
+    return hljs.highlightAuto(code2).value;
+  } catch {
+    return code2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+}
+var codeBlockCounter = 0;
+function generateCodeBlockId() {
+  return `code-block-${++codeBlockCounter}`;
+}
+function renderMarkdown(content) {
+  const html = marked.parse(content, { async: false });
+  const codeBlockRegex = /<pre><code class="language-(\w+)">([\s\S]*?)<\/code><\/pre>/g;
+  let result = html.replace(codeBlockRegex, (_, lang, code2) => {
+    const decoded = code2.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"');
+    const highlighted = highlightCode(decoded, lang);
+    const id = generateCodeBlockId();
+    const encodedCode = encodeURIComponent(decoded);
+    return `<div class="code-block-wrapper" data-code-id="${id}" data-code="${encodedCode}"><pre><code class="hljs language-${lang}">${highlighted}</code></pre><div class="code-block-toolbar"><button class="code-block-btn" data-action="copy" data-code-id="${id}" title="Copy code"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg></button><button class="code-block-btn" data-action="emblem" data-code-id="${id}" title="Open in Emblem AI"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="16 18 22 12 16 6"></polyline><polyline points="8 6 2 12 8 18"></polyline></svg></button></div></div>`;
+  });
+  const plainCodeRegex = /<pre><code>([\s\S]*?)<\/code><\/pre>/g;
+  result = result.replace(plainCodeRegex, (_, code2) => {
+    const decoded = code2.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"');
+    const highlighted = highlightCode(decoded, "");
+    const id = generateCodeBlockId();
+    const encodedCode = encodeURIComponent(decoded);
+    return `<div class="code-block-wrapper" data-code-id="${id}" data-code="${encodedCode}"><pre><code class="hljs">${highlighted}</code></pre><div class="code-block-toolbar"><button class="code-block-btn" data-action="copy" data-code-id="${id}" title="Copy code"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg></button><button class="code-block-btn" data-action="emblem" data-code-id="${id}" title="Open in Emblem AI"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="16 18 22 12 16 6"></polyline><polyline points="8 6 2 12 8 18"></polyline></svg></button></div></div>`;
+  });
+  return result;
+}
+function MarkdownContent({ content, className }) {
+  const [rendered, setRendered] = useState("");
+  const containerRef = useRef(null);
+  useEffect(() => {
+    try {
+      const html = renderMarkdown(content);
+      setRendered(html);
+    } catch (err) {
+      console.error("[MarkdownContent] Render error:", err);
+      setRendered(
+        content.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\n/g, "<br>")
+      );
+    }
+  }, [content]);
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const handleClick = async (e) => {
+      const target = e.target;
+      const button = target.closest("[data-action]");
+      if (!button) return;
+      const action = button.dataset.action;
+      const codeId = button.dataset.codeId;
+      if (!codeId) return;
+      const wrapper = container.querySelector(`[data-code-id="${codeId}"]`);
+      if (!wrapper) return;
+      const encodedCode = wrapper.dataset.code;
+      if (!encodedCode) return;
+      const code2 = decodeURIComponent(encodedCode);
+      if (action === "copy") {
+        e.preventDefault();
+        try {
+          await navigator.clipboard.writeText(code2);
+          button.classList.add("copied");
+          button.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <polyline points="20 6 9 17 4 12"></polyline>
+          </svg>`;
+          setTimeout(() => {
+            button.classList.remove("copied");
+            button.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+              <rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect>
+              <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>
+            </svg>`;
+          }, 2e3);
+        } catch (err) {
+          console.error("Failed to copy:", err);
+        }
+      } else if (action === "emblem") {
+        e.preventDefault();
+        const url = `https://build.emblemvault.ai/?q=${encodeURIComponent(code2)}`;
+        window.open(url, "_blank", "noopener,noreferrer");
+      }
+    };
+    container.addEventListener("click", handleClick);
+    return () => container.removeEventListener("click", handleClick);
+  }, [rendered]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("style", { children: scopedStyles }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: containerRef,
+        style: containerStyle,
+        className: `hljs-md ${className || ""}`,
+        dangerouslySetInnerHTML: { __html: rendered }
+      }
+    )
+  ] });
+}
+var styles = {
+  // Container
+  container: {
+    display: "flex",
+    flexDirection: "column",
+    height: "100%",
+    background: tokens.colors.bgSecondary,
+    borderRadius: tokens.radius.xl,
+    border: `1px solid ${tokens.colors.borderPrimary}`,
+    fontFamily: tokens.typography.fontFamily,
+    color: tokens.colors.textPrimary
+  },
+  // Not ready / auth required states
+  placeholder: {
+    padding: tokens.spacing.xxl,
+    background: tokens.colors.bgSecondary,
+    borderRadius: tokens.radius.xl,
+    border: `1px solid ${tokens.colors.borderPrimary}`
+  },
+  placeholderContent: {
+    color: tokens.colors.textSecondary
+  },
+  placeholderTitle: {
+    fontSize: tokens.typography.fontSizeLg,
+    fontWeight: tokens.typography.fontWeightMedium,
+    marginBottom: tokens.spacing.xs
+  },
+  placeholderText: {
+    fontSize: tokens.typography.fontSizeSm,
+    color: tokens.colors.textTertiary
+  },
+  loadingSpinner: {
+    border: `2px solid ${tokens.colors.textTertiary}`,
+    borderRadius: tokens.radius.full,
+    marginBottom: tokens.spacing.sm
+  },
+  // Header - darker shade
+  header: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+    padding: `${tokens.spacing.md} ${tokens.spacing.lg}`,
+    background: tokens.colors.bgPrimary,
+    borderBottom: `1px solid ${tokens.colors.borderPrimary}`,
+    borderRadius: `${tokens.radius.xl} ${tokens.radius.xl} 0 0`
+  },
+  headerTitle: {
+    fontWeight: tokens.typography.fontWeightSemibold,
+    color: tokens.colors.textPrimary,
+    fontSize: tokens.typography.fontSizeMd
+  },
+  headerActions: {
+    display: "flex",
+    alignItems: "center",
+    gap: tokens.spacing.sm
+  },
+  // Model selector
+  select: {
+    fontSize: tokens.typography.fontSizeSm,
+    padding: `${tokens.spacing.xs} ${tokens.spacing.sm}`,
+    border: `1px solid ${tokens.colors.borderSecondary}`,
+    borderRadius: tokens.radius.md,
+    background: tokens.colors.bgTertiary,
+    color: tokens.colors.textPrimary},
+  // Settings button
+  settingsBtn: {
+    ...presets.buttonIcon,
+    borderRadius: tokens.radius.md
+  },
+  settingsBtnActive: {
+    background: tokens.colors.accentPrimaryBg,
+    color: tokens.colors.accentPrimary
+  },
+  settingsBtnInactive: {
+    color: tokens.colors.textSecondary
+  },
+  // Settings Modal
+  modalOverlay: {
+    position: "fixed",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    background: tokens.colors.bgOverlay,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    zIndex: tokens.zIndex.modal
+  },
+  modal: {
+    background: tokens.colors.bgSecondary,
+    borderRadius: tokens.radius.xl,
+    border: `1px solid ${tokens.colors.borderPrimary}`,
+    width: "100%",
+    maxWidth: "440px",
+    maxHeight: "90vh",
+    overflow: "auto",
+    boxShadow: tokens.shadows.xl
+  },
+  modalHeader: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+    padding: `${tokens.spacing.lg} ${tokens.spacing.xl}`,
+    borderBottom: `1px solid ${tokens.colors.borderPrimary}`
+  },
+  modalTitle: {
+    fontSize: tokens.typography.fontSizeLg,
+    fontWeight: tokens.typography.fontWeightSemibold,
+    color: tokens.colors.textPrimary
+  },
+  modalClose: {
+    background: "transparent",
+    border: "none",
+    color: tokens.colors.textTertiary,
+    fontSize: "20px",
+    cursor: "pointer",
+    padding: tokens.spacing.xs,
+    lineHeight: 1,
+    transition: `color ${tokens.transitions.fast}`
+  },
+  modalBody: {
+    padding: tokens.spacing.xl
+  },
+  // Settings sections
+  settingGroup: {
+    marginBottom: tokens.spacing.xl
+  },
+  settingLabel: {
+    display: "block",
+    fontSize: tokens.typography.fontSizeMd,
+    fontWeight: tokens.typography.fontWeightMedium,
+    color: tokens.colors.textPrimary,
+    marginBottom: tokens.spacing.xs
+  },
+  settingDescription: {
+    fontSize: tokens.typography.fontSizeSm,
+    color: tokens.colors.textTertiary,
+    marginBottom: tokens.spacing.md
+  },
+  settingSelect: {
+    width: "100%",
+    padding: `${tokens.spacing.md} ${tokens.spacing.lg}`,
+    fontSize: tokens.typography.fontSizeMd,
+    background: tokens.colors.bgTertiary,
+    border: `1px solid ${tokens.colors.borderSecondary}`,
+    borderRadius: tokens.radius.lg,
+    color: tokens.colors.textPrimary,
+    outline: "none",
+    cursor: "pointer",
+    appearance: "none",
+    backgroundImage: `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%238892a4' d='M6 8L1 3h10z'/%3E%3C/svg%3E")`,
+    backgroundRepeat: "no-repeat",
+    backgroundPosition: "right 12px center",
+    paddingRight: "36px"
+  },
+  modelInfo: {
+    fontSize: tokens.typography.fontSizeXs,
+    color: tokens.colors.textTertiary,
+    marginTop: tokens.spacing.sm
+  },
+  // Toggle switch row
+  toggleRow: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+    padding: `${tokens.spacing.md} ${tokens.spacing.lg}`,
+    background: tokens.colors.bgTertiary,
+    borderRadius: tokens.radius.lg,
+    marginBottom: tokens.spacing.sm
+  },
+  toggleLabel: {
+    fontSize: tokens.typography.fontSizeMd,
+    color: tokens.colors.textPrimary
+  },
+  toggleSwitch: {
+    position: "relative",
+    width: "44px",
+    height: "24px",
+    background: tokens.colors.borderSecondary,
+    borderRadius: "12px",
+    cursor: "pointer",
+    transition: `background ${tokens.transitions.fast}`
+  },
+  toggleSwitchActive: {
+    background: tokens.colors.accentPrimary
+  },
+  toggleKnob: {
+    position: "absolute",
+    top: "2px",
+    left: "2px",
+    width: "20px",
+    height: "20px",
+    background: tokens.colors.textPrimary,
+    borderRadius: tokens.radius.full,
+    transition: `transform ${tokens.transitions.fast}`
+  },
+  toggleKnobActive: {
+    transform: "translateX(20px)"
+  },
+  // Settings textarea
+  settingTextarea: {
+    width: "100%",
+    minHeight: "100px",
+    padding: tokens.spacing.lg,
+    fontSize: tokens.typography.fontSizeMd,
+    background: tokens.colors.bgTertiary,
+    border: `1px solid ${tokens.colors.borderSecondary}`,
+    borderRadius: tokens.radius.lg,
+    color: tokens.colors.textPrimary,
+    outline: "none",
+    resize: "vertical",
+    fontFamily: tokens.typography.fontFamily
+  },
+  // Messages area
+  messagesArea: {
+    flex: 1,
+    overflowY: "auto",
+    padding: tokens.spacing.lg,
+    background: tokens.colors.bgSecondary
+  },
+  messagesEmpty: {
+    textAlign: "center",
+    color: tokens.colors.textTertiary,
+    padding: tokens.spacing.xxl
+  },
+  messagesContainer: {
+    display: "flex",
+    flexDirection: "column",
+    gap: tokens.spacing.lg
+  },
+  // Tool calls indicator
+  toolCallsIndicator: {
+    display: "flex",
+    flexWrap: "wrap",
+    gap: tokens.spacing.sm,
+    padding: `0 ${tokens.spacing.lg}`
+  },
+  toolCallBadge: {
+    display: "inline-flex",
+    alignItems: "center",
+    gap: tokens.spacing.xs,
+    padding: `${tokens.spacing.xs} ${tokens.spacing.sm}`,
+    fontSize: tokens.typography.fontSizeXs,
+    background: tokens.colors.accentWarningBg,
+    color: tokens.colors.accentWarning,
+    borderRadius: tokens.radius.pill
+  },
+  toolCallDot: {
+    width: "8px",
+    height: "8px",
+    background: tokens.colors.accentWarning,
+    borderRadius: tokens.radius.full,
+    animation: "hustle-pulse 1s ease-in-out infinite"
+  },
+  // Attachments preview
+  attachmentsPreview: {
+    padding: `${tokens.spacing.sm} ${tokens.spacing.lg}`,
+    borderTop: `1px solid ${tokens.colors.borderPrimary}`,
+    display: "flex",
+    flexWrap: "wrap",
+    gap: tokens.spacing.sm
+  },
+  attachmentItem: {
+    display: "inline-flex",
+    alignItems: "center",
+    gap: tokens.spacing.xs,
+    padding: `${tokens.spacing.xs} ${tokens.spacing.sm}`,
+    background: tokens.colors.bgTertiary,
+    borderRadius: tokens.radius.md,
+    fontSize: tokens.typography.fontSizeSm
+  },
+  attachmentName: {
+    maxWidth: "100px",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap"
+  },
+  attachmentRemove: {
+    background: "none",
+    border: "none",
+    color: tokens.colors.textTertiary,
+    cursor: "pointer",
+    fontSize: "14px",
+    padding: 0,
+    lineHeight: 1
+  },
+  // Input area - slightly darker than messages
+  inputArea: {
+    padding: tokens.spacing.lg,
+    background: tokens.colors.bgPrimary,
+    borderTop: `1px solid ${tokens.colors.borderPrimary}`,
+    borderRadius: `0 0 ${tokens.radius.xl} ${tokens.radius.xl}`
+  },
+  inputRow: {
+    display: "flex",
+    alignItems: "center",
+    gap: tokens.spacing.sm
+  },
+  inputContainer: {
+    flex: 1,
+    display: "flex",
+    alignItems: "center",
+    background: tokens.colors.bgTertiary,
+    border: `1px solid ${tokens.colors.borderSecondary}`,
+    borderRadius: tokens.radius.lg,
+    overflow: "hidden"
+  },
+  attachBtn: {
+    width: "40px",
+    height: "40px",
+    padding: 0,
+    background: "transparent",
+    border: "none",
+    borderRadius: 0,
+    color: tokens.colors.textTertiary,
+    flexShrink: 0
+  },
+  inputWrapper: {
+    flex: 1
+  },
+  input: {
+    width: "100%",
+    padding: `${tokens.spacing.md} ${tokens.spacing.sm}`,
+    background: "transparent",
+    border: "none",
+    color: tokens.colors.textPrimary,
+    fontSize: tokens.typography.fontSizeMd,
+    outline: "none",
+    resize: "none"
+  },
+  inputDisabled: {
+    background: tokens.colors.bgTertiary,
+    cursor: "not-allowed"
+  },
+  sendBtn: {
+    // Inherits global button styles from CSS
+    height: "40px",
+    padding: `0 ${tokens.spacing.lg}`,
+    fontWeight: tokens.typography.fontWeightMedium
+  },
+  sendBtnDisabled: {
+    opacity: 0.5,
+    cursor: "not-allowed"
+  },
+  sendSpinner: {
+    display: "inline-block",
+    width: "16px",
+    height: "16px",
+    border: "2px solid currentColor",
+    borderTopColor: "transparent",
+    borderRadius: tokens.radius.full,
+    animation: "hustle-spin 0.8s linear infinite"
+  },
+  // Error display
+  errorBox: {
+    marginTop: tokens.spacing.sm,
+    padding: `${tokens.spacing.sm} ${tokens.spacing.md}`,
+    background: tokens.colors.accentErrorBg,
+    color: tokens.colors.accentError,
+    fontSize: tokens.typography.fontSizeSm,
+    borderRadius: tokens.radius.md
+  },
+  // Message bubbles
+  messageBubbleContainer: {
+    display: "flex"
+  },
+  messageBubbleUser: {
+    justifyContent: "flex-end"
+  },
+  messageBubbleAssistant: {
+    justifyContent: "flex-start"
+  },
+  messageBubble: {
+    maxWidth: "80%",
+    padding: `${tokens.spacing.sm} ${tokens.spacing.lg}`,
+    borderRadius: tokens.radius.lg
+  },
+  messageBubbleUserStyle: {
+    background: tokens.colors.msgUser,
+    color: tokens.colors.textPrimary
+  },
+  messageBubbleAssistantStyle: {
+    background: tokens.colors.msgAssistant,
+    color: tokens.colors.textPrimary
+  },
+  messageBubbleSystemStyle: {
+    background: tokens.colors.bgTertiary,
+    color: tokens.colors.textSecondary,
+    fontSize: tokens.typography.fontSizeSm,
+    fontStyle: "italic"
+  },
+  messageContent: {
+    whiteSpace: "pre-wrap",
+    wordBreak: "break-word",
+    lineHeight: tokens.typography.lineHeightRelaxed
+  },
+  streamingCursor: {
+    display: "inline-block",
+    width: "2px",
+    height: "16px",
+    marginLeft: tokens.spacing.xs,
+    background: "currentColor",
+    animation: "hustle-pulse 0.8s ease-in-out infinite"
+  },
+  // Tool calls debug
+  toolCallsDebug: {
+    marginTop: tokens.spacing.sm,
+    paddingTop: tokens.spacing.sm,
+    borderTop: `1px solid ${tokens.colors.borderSecondary}`,
+    fontSize: tokens.typography.fontSizeXs
+  },
+  toolCallsDebugTitle: {
+    fontWeight: tokens.typography.fontWeightMedium,
+    color: tokens.colors.textSecondary,
+    marginBottom: tokens.spacing.xs
+  },
+  toolCallDebugItem: {
+    background: "rgba(255,255,255,0.05)",
+    borderRadius: tokens.radius.sm,
+    padding: tokens.spacing.xs,
+    marginTop: tokens.spacing.xs
+  },
+  toolCallDebugName: {
+    ...presets.mono
+  },
+  toolCallDebugArgs: {
+    ...presets.mono,
+    marginTop: tokens.spacing.xs,
+    fontSize: "10px",
+    overflow: "auto"
+  },
+  // Plugin management styles
+  settingDivider: {
+    height: "1px",
+    background: tokens.colors.borderPrimary,
+    margin: `${tokens.spacing.xl} 0`
+  },
+  pluginList: {
+    display: "flex",
+    flexDirection: "column",
+    gap: tokens.spacing.sm
+  },
+  pluginRow: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+    padding: `${tokens.spacing.md} ${tokens.spacing.lg}`,
+    background: tokens.colors.bgTertiary,
+    borderRadius: tokens.radius.lg
+  },
+  pluginInfo: {
+    display: "flex",
+    alignItems: "center",
+    gap: tokens.spacing.md,
+    flex: 1,
+    minWidth: 0
+  },
+  pluginIcon: {
+    fontSize: "20px",
+    flexShrink: 0
+  },
+  pluginDetails: {
+    flex: 1,
+    minWidth: 0
+  },
+  pluginName: {
+    display: "block",
+    fontWeight: tokens.typography.fontWeightMedium,
+    color: tokens.colors.textPrimary,
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis"
+  },
+  pluginMeta: {
+    display: "block",
+    fontSize: tokens.typography.fontSizeXs,
+    color: tokens.colors.textTertiary
+  },
+  pluginEmpty: {
+    padding: tokens.spacing.lg,
+    textAlign: "center",
+    color: tokens.colors.textTertiary,
+    fontSize: tokens.typography.fontSizeSm
+  },
+  availablePluginsHeader: {
+    fontSize: tokens.typography.fontSizeXs,
+    fontWeight: tokens.typography.fontWeightSemibold,
+    color: tokens.colors.textSecondary,
+    textTransform: "uppercase",
+    letterSpacing: "0.5px",
+    marginTop: tokens.spacing.lg,
+    marginBottom: tokens.spacing.sm
+  },
+  installBtn: {
+    padding: `${tokens.spacing.xs} ${tokens.spacing.md}`,
+    fontSize: tokens.typography.fontSizeSm,
+    background: "transparent",
+    border: `1px solid ${tokens.colors.accentPrimary}`,
+    borderRadius: tokens.radius.md,
+    color: tokens.colors.accentPrimary,
+    cursor: "pointer",
+    transition: `all ${tokens.transitions.fast}`,
+    whiteSpace: "nowrap"
+  },
+  uninstallBtn: {
+    padding: `${tokens.spacing.xs} ${tokens.spacing.md}`,
+    fontSize: tokens.typography.fontSizeSm,
+    background: "transparent",
+    border: `1px solid ${tokens.colors.accentError}`,
+    borderRadius: tokens.radius.md,
+    color: tokens.colors.accentError,
+    cursor: "pointer",
+    transition: `all ${tokens.transitions.fast}`,
+    whiteSpace: "nowrap"
+  }
+};
+function generateId() {
+  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function HustleChat({
+  className = "",
+  placeholder = "Type a message...",
+  showSettings = false,
+  showDebug = false,
+  initialSystemPrompt = "",
+  onMessage,
+  onToolCall,
+  onResponse
+}) {
+  const {
+    instanceId,
+    isApiKeyMode,
+    isReady,
+    isLoading,
+    error: error2,
+    models,
+    chatStream,
+    uploadFile,
+    selectedModel,
+    setSelectedModel,
+    systemPrompt,
+    setSystemPrompt,
+    skipServerPrompt,
+    setSkipServerPrompt
+  } = useHustle();
+  const authContext = useEmblemAuthOptional();
+  const isAuthenticated = isApiKeyMode || (authContext?.isAuthenticated ?? false);
+  const {
+    plugins,
+    registerPlugin,
+    unregisterPlugin,
+    enablePlugin,
+    disablePlugin
+  } = usePlugins(instanceId);
+  const [messages, setMessages] = useState([]);
+  const [inputValue, setInputValue] = useState("");
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [attachments, setAttachments] = useState([]);
+  const [currentToolCalls, setCurrentToolCalls] = useState([]);
+  const [showSettingsPanel, setShowSettingsPanel] = useState(false);
+  const messagesEndRef = useRef(null);
+  const fileInputRef = useRef(null);
+  useEffect(() => {
+    if (initialSystemPrompt && !systemPrompt) {
+      setSystemPrompt(initialSystemPrompt);
+    }
+  }, [initialSystemPrompt, systemPrompt, setSystemPrompt]);
+  useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages]);
+  const handleFileSelect = useCallback(
+    async (e) => {
+      const files = e.target.files;
+      if (!files || files.length === 0) return;
+      for (const file of Array.from(files)) {
+        try {
+          const attachment = await uploadFile(file);
+          setAttachments((prev) => [...prev, attachment]);
+        } catch (err) {
+          console.error("Upload failed:", err);
+        }
+      }
+      if (fileInputRef.current) {
+        fileInputRef.current.value = "";
+      }
+    },
+    [uploadFile]
+  );
+  const removeAttachment = useCallback((index) => {
+    setAttachments((prev) => prev.filter((_, i) => i !== index));
+  }, []);
+  const sendMessage = useCallback(async () => {
+    const content = inputValue.trim();
+    if (!content || isStreaming || !isReady) return;
+    const userMessage = {
+      id: generateId(),
+      role: "user",
+      content
+    };
+    setMessages((prev) => [...prev, userMessage]);
+    setInputValue("");
+    onMessage?.(userMessage);
+    const assistantMessage = {
+      id: generateId(),
+      role: "assistant",
+      content: "",
+      isStreaming: true,
+      toolCalls: []
+    };
+    setMessages((prev) => [...prev, assistantMessage]);
+    setIsStreaming(true);
+    setCurrentToolCalls([]);
+    try {
+      const chatMessages = messages.filter((m) => !m.isStreaming).map((m) => ({ role: m.role, content: m.content }));
+      chatMessages.push({ role: "user", content });
+      const stream = chatStream({
+        messages: chatMessages,
+        attachments: attachments.length > 0 ? attachments : void 0,
+        processChunks: true
+      });
+      setAttachments([]);
+      let fullContent = "";
+      const toolCallsAccumulated = [];
+      for await (const chunk of stream) {
+        if (chunk.type === "text") {
+          fullContent += chunk.value;
+          setMessages(
+            (prev) => prev.map(
+              (m) => m.id === assistantMessage.id ? { ...m, content: fullContent } : m
+            )
+          );
+        } else if (chunk.type === "tool_call") {
+          const toolCall = chunk.value;
+          toolCallsAccumulated.push(toolCall);
+          setCurrentToolCalls([...toolCallsAccumulated]);
+          setMessages(
+            (prev) => prev.map(
+              (m) => m.id === assistantMessage.id ? { ...m, toolCalls: [...toolCallsAccumulated] } : m
+            )
+          );
+          onToolCall?.(toolCall);
+        } else if (chunk.type === "error") {
+          console.error("Stream error:", chunk.value);
+        }
+      }
+      const processedResponse = await stream.response;
+      const finalContent = processedResponse?.content || fullContent || "(No response)";
+      setMessages(
+        (prev) => prev.map(
+          (m) => m.id === assistantMessage.id ? { ...m, isStreaming: false, content: finalContent } : m
+        )
+      );
+      onResponse?.(finalContent);
+    } catch (err) {
+      console.error("Chat error:", err);
+      setMessages(
+        (prev) => prev.map(
+          (m) => m.id === assistantMessage.id ? { ...m, isStreaming: false, content: `Error: ${err instanceof Error ? err.message : "Unknown error"}` } : m
+        )
+      );
+    } finally {
+      setIsStreaming(false);
+      setCurrentToolCalls([]);
+    }
+  }, [inputValue, isStreaming, isReady, messages, chatStream, attachments, onMessage, onToolCall, onResponse]);
+  const handleKeyPress = useCallback(
+    (e) => {
+      if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        sendMessage();
+      }
+    },
+    [sendMessage]
+  );
+  const getPlaceholderMessage = () => {
+    if (!isAuthenticated) {
+      return "Connect to start chatting...";
+    }
+    if (!isReady) {
+      return "Initializing...";
+    }
+    return "Start a conversation...";
+  };
+  const canChat = isAuthenticated && isReady;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("style", { children: animations }),
+    /* @__PURE__ */ jsxs("div", { className, style: styles.container, children: [
+      /* @__PURE__ */ jsxs("div", { style: styles.header, children: [
+        /* @__PURE__ */ jsx("h2", { style: styles.headerTitle, children: "Chat" }),
+        /* @__PURE__ */ jsxs("div", { style: styles.headerActions, children: [
+          selectedModel && /* @__PURE__ */ jsx("span", { style: { fontSize: tokens.typography.fontSizeSm, color: tokens.colors.textSecondary }, children: selectedModel.split("/").pop() }),
+          showSettings && /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => setShowSettingsPanel(!showSettingsPanel),
+              style: {
+                ...styles.settingsBtn,
+                ...showSettingsPanel ? styles.settingsBtnActive : styles.settingsBtnInactive
+              },
+              title: "Settings",
+              children: /* @__PURE__ */ jsx(SettingsIcon, {})
+            }
+          )
+        ] })
+      ] }),
+      showSettings && showSettingsPanel && /* @__PURE__ */ jsx("div", { style: styles.modalOverlay, onClick: () => setShowSettingsPanel(false), children: /* @__PURE__ */ jsxs("div", { style: styles.modal, onClick: (e) => e.stopPropagation(), children: [
+        /* @__PURE__ */ jsxs("div", { style: styles.modalHeader, children: [
+          /* @__PURE__ */ jsx("span", { style: styles.modalTitle, children: "Settings" }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              style: styles.modalClose,
+              onClick: () => setShowSettingsPanel(false),
+              children: "\xD7"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { style: styles.modalBody, children: [
+          /* @__PURE__ */ jsxs("div", { style: styles.settingGroup, children: [
+            /* @__PURE__ */ jsx("label", { style: styles.settingLabel, children: "Model" }),
+            /* @__PURE__ */ jsx("p", { style: styles.settingDescription, children: "Select the AI model to use for chat responses" }),
+            /* @__PURE__ */ jsxs(
+              "select",
+              {
+                value: selectedModel,
+                onChange: (e) => setSelectedModel(e.target.value),
+                style: styles.settingSelect,
+                children: [
+                  /* @__PURE__ */ jsx("option", { value: "", children: "Default (server decides)" }),
+                  (() => {
+                    const grouped = {};
+                    models.forEach((model) => {
+                      const [provider] = model.id.split("/");
+                      if (!grouped[provider]) grouped[provider] = [];
+                      grouped[provider].push(model);
+                    });
+                    return Object.entries(grouped).map(([provider, providerModels]) => /* @__PURE__ */ jsx("optgroup", { label: provider.charAt(0).toUpperCase() + provider.slice(1), children: providerModels.map((model) => /* @__PURE__ */ jsx("option", { value: model.id, children: model.name }, model.id)) }, provider));
+                  })()
+                ]
+              }
+            ),
+            selectedModel && (() => {
+              const model = models.find((m) => m.id === selectedModel);
+              if (!model) return null;
+              const contextK = Math.round(model.context_length / 1e3);
+              const promptCost = parseFloat(model.pricing?.prompt || "0") * 1e6;
+              const completionCost = parseFloat(model.pricing?.completion || "0") * 1e6;
+              return /* @__PURE__ */ jsxs("div", { style: styles.modelInfo, children: [
+                "Context: ",
+                contextK,
+                "K tokens | Cost: $",
+                promptCost.toFixed(2),
+                "/$",
+                completionCost.toFixed(2),
+                " per 1M tokens"
+              ] });
+            })()
+          ] }),
+          /* @__PURE__ */ jsxs("div", { style: styles.settingGroup, children: [
+            /* @__PURE__ */ jsx("label", { style: styles.settingLabel, children: "Server System Prompt" }),
+            /* @__PURE__ */ jsxs(
+              "div",
+              {
+                style: styles.toggleRow,
+                onClick: () => setSkipServerPrompt(!skipServerPrompt),
+                children: [
+                  /* @__PURE__ */ jsx("span", { style: styles.toggleLabel, children: "Skip server-provided system prompt" }),
+                  /* @__PURE__ */ jsx("div", { style: {
+                    ...styles.toggleSwitch,
+                    ...skipServerPrompt ? styles.toggleSwitchActive : {}
+                  }, children: /* @__PURE__ */ jsx("div", { style: {
+                    ...styles.toggleKnob,
+                    ...skipServerPrompt ? styles.toggleKnobActive : {}
+                  } }) })
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx("p", { style: styles.settingDescription, children: "When enabled, the server's default system prompt will not be used" })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { style: styles.settingGroup, children: [
+            /* @__PURE__ */ jsx("label", { style: styles.settingLabel, children: "Custom System Prompt" }),
+            /* @__PURE__ */ jsx("p", { style: styles.settingDescription, children: "Provide instructions for how the AI should behave" }),
+            /* @__PURE__ */ jsx(
+              "textarea",
+              {
+                value: systemPrompt,
+                onChange: (e) => setSystemPrompt(e.target.value),
+                placeholder: "You are a helpful assistant...",
+                style: styles.settingTextarea
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx("div", { style: styles.settingDivider }),
+          /* @__PURE__ */ jsxs("div", { style: { ...styles.settingGroup, marginBottom: 0 }, children: [
+            /* @__PURE__ */ jsx("label", { style: styles.settingLabel, children: "Plugins" }),
+            /* @__PURE__ */ jsx("p", { style: styles.settingDescription, children: "Extend the AI with custom tools" }),
+            plugins.length > 0 ? /* @__PURE__ */ jsx("div", { style: styles.pluginList, children: plugins.map((plugin) => /* @__PURE__ */ jsxs("div", { style: styles.pluginRow, children: [
+              /* @__PURE__ */ jsxs("div", { style: styles.pluginInfo, children: [
+                /* @__PURE__ */ jsx("span", { style: styles.pluginIcon, children: plugin.enabled ? "\u{1F50C}" : "\u26AA" }),
+                /* @__PURE__ */ jsxs("div", { style: styles.pluginDetails, children: [
+                  /* @__PURE__ */ jsx("span", { style: styles.pluginName, children: plugin.name }),
+                  /* @__PURE__ */ jsxs("span", { style: styles.pluginMeta, children: [
+                    "v",
+                    plugin.version,
+                    " \u2022 ",
+                    plugin.tools?.length || 0,
+                    " tools"
+                  ] })
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: tokens.spacing.sm }, children: [
+                /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    style: {
+                      ...styles.toggleSwitch,
+                      ...plugin.enabled ? styles.toggleSwitchActive : {}
+                    },
+                    onClick: () => plugin.enabled ? disablePlugin(plugin.name) : enablePlugin(plugin.name),
+                    children: /* @__PURE__ */ jsx("div", { style: {
+                      ...styles.toggleKnob,
+                      ...plugin.enabled ? styles.toggleKnobActive : {}
+                    } })
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    style: styles.uninstallBtn,
+                    onClick: () => unregisterPlugin(plugin.name),
+                    children: "Remove"
+                  }
+                )
+              ] })
+            ] }, plugin.name)) }) : /* @__PURE__ */ jsx("div", { style: styles.pluginEmpty, children: "No plugins installed" }),
+            availablePlugins.filter((p) => !plugins.some((installed) => installed.name === p.name)).length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx("div", { style: styles.availablePluginsHeader, children: "Available" }),
+              /* @__PURE__ */ jsx("div", { style: styles.pluginList, children: availablePlugins.filter((p) => !plugins.some((installed) => installed.name === p.name)).map((plugin) => /* @__PURE__ */ jsxs("div", { style: styles.pluginRow, children: [
+                /* @__PURE__ */ jsxs("div", { style: styles.pluginInfo, children: [
+                  /* @__PURE__ */ jsx("span", { style: styles.pluginIcon, children: "\u{1F4E6}" }),
+                  /* @__PURE__ */ jsxs("div", { style: styles.pluginDetails, children: [
+                    /* @__PURE__ */ jsx("span", { style: styles.pluginName, children: plugin.name }),
+                    /* @__PURE__ */ jsx("span", { style: styles.pluginMeta, children: plugin.description })
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    style: styles.installBtn,
+                    onClick: () => registerPlugin(plugin),
+                    children: "+ Install"
+                  }
+                )
+              ] }, plugin.name)) })
+            ] })
+          ] })
+        ] })
+      ] }) }),
+      /* @__PURE__ */ jsxs("div", { style: styles.messagesArea, children: [
+        messages.length === 0 && /* @__PURE__ */ jsx("div", { style: styles.messagesEmpty, children: /* @__PURE__ */ jsx("p", { children: getPlaceholderMessage() }) }),
+        /* @__PURE__ */ jsx("div", { style: styles.messagesContainer, children: messages.map((message) => /* @__PURE__ */ jsx(
+          MessageBubble,
+          {
+            message,
+            showDebug
+          },
+          message.id
+        )) }),
+        currentToolCalls.length > 0 && /* @__PURE__ */ jsx("div", { style: styles.toolCallsIndicator, children: currentToolCalls.map((tool) => /* @__PURE__ */ jsxs("span", { style: styles.toolCallBadge, children: [
+          /* @__PURE__ */ jsx("span", { style: styles.toolCallDot }),
+          tool.toolName
+        ] }, tool.toolCallId)) }),
+        /* @__PURE__ */ jsx("div", { ref: messagesEndRef })
+      ] }),
+      attachments.length > 0 && /* @__PURE__ */ jsx("div", { style: styles.attachmentsPreview, children: attachments.map((att, index) => /* @__PURE__ */ jsxs("div", { style: styles.attachmentItem, children: [
+        /* @__PURE__ */ jsx("span", { style: styles.attachmentName, children: att.name }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => removeAttachment(index),
+            style: styles.attachmentRemove,
+            children: "\xD7"
+          }
+        )
+      ] }, index)) }),
+      /* @__PURE__ */ jsxs("div", { style: styles.inputArea, children: [
+        /* @__PURE__ */ jsxs("div", { style: styles.inputRow, children: [
+          /* @__PURE__ */ jsxs("div", { style: styles.inputContainer, children: [
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                onClick: () => fileInputRef.current?.click(),
+                style: styles.attachBtn,
+                title: "Attach file",
+                children: /* @__PURE__ */ jsx(AttachIcon, {})
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                ref: fileInputRef,
+                type: "file",
+                accept: "image/*",
+                multiple: true,
+                onChange: handleFileSelect,
+                style: { display: "none" }
+              }
+            ),
+            /* @__PURE__ */ jsx("div", { style: styles.inputWrapper, children: /* @__PURE__ */ jsx(
+              "textarea",
+              {
+                value: inputValue,
+                onChange: (e) => setInputValue(e.target.value),
+                onKeyPress: handleKeyPress,
+                placeholder,
+                disabled: !canChat || isStreaming || isLoading,
+                rows: 1,
+                style: {
+                  ...styles.input,
+                  ...!canChat || isStreaming || isLoading ? styles.inputDisabled : {}
+                }
+              }
+            ) })
+          ] }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: sendMessage,
+              disabled: !canChat || !inputValue.trim() || isStreaming || isLoading,
+              style: {
+                ...styles.sendBtn,
+                ...!canChat || !inputValue.trim() || isStreaming || isLoading ? styles.sendBtnDisabled : {}
+              },
+              children: isStreaming ? /* @__PURE__ */ jsx("span", { style: styles.sendSpinner }) : "Send"
+            }
+          )
+        ] }),
+        error2 && /* @__PURE__ */ jsx("div", { style: styles.errorBox, children: error2.message })
+      ] })
+    ] })
+  ] });
+}
+function MessageBubble({ message, showDebug }) {
+  const isUser = message.role === "user";
+  const isSystem = message.role === "system";
+  const containerStyle2 = {
+    ...styles.messageBubbleContainer,
+    ...isUser ? styles.messageBubbleUser : styles.messageBubbleAssistant
+  };
+  const bubbleStyle = {
+    ...styles.messageBubble,
+    ...isUser ? styles.messageBubbleUserStyle : isSystem ? styles.messageBubbleSystemStyle : styles.messageBubbleAssistantStyle
+  };
+  return /* @__PURE__ */ jsx("div", { style: containerStyle2, children: /* @__PURE__ */ jsxs("div", { style: bubbleStyle, children: [
+    /* @__PURE__ */ jsxs("div", { style: styles.messageContent, children: [
+      isUser || isSystem ? (
+        // User and system messages: plain text
+        message.content
+      ) : (
+        // Assistant messages: render markdown
+        /* @__PURE__ */ jsx(MarkdownContent, { content: message.content })
+      ),
+      message.isStreaming && /* @__PURE__ */ jsx("span", { style: styles.streamingCursor })
+    ] }),
+    showDebug && message.toolCalls && message.toolCalls.length > 0 && /* @__PURE__ */ jsxs("div", { style: styles.toolCallsDebug, children: [
+      /* @__PURE__ */ jsx("div", { style: styles.toolCallsDebugTitle, children: "Tool calls:" }),
+      message.toolCalls.map((tool) => /* @__PURE__ */ jsxs("div", { style: styles.toolCallDebugItem, children: [
+        /* @__PURE__ */ jsx("span", { style: styles.toolCallDebugName, children: tool.toolName }),
+        tool.args && /* @__PURE__ */ jsx("pre", { style: styles.toolCallDebugArgs, children: JSON.stringify(tool.args, null, 2) })
+      ] }, tool.toolCallId))
+    ] })
+  ] }) });
+}
+function SettingsIcon() {
+  return /* @__PURE__ */ jsxs("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+    /* @__PURE__ */ jsx("circle", { cx: "12", cy: "12", r: "3" }),
+    /* @__PURE__ */ jsx("path", { d: "M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z" })
+  ] });
+}
+function AttachIcon() {
+  return /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: /* @__PURE__ */ jsx("path", { d: "M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48" }) });
+}
+
+// src/utils/index.ts
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+function debounce(fn, delay) {
+  let timeoutId;
+  return (...args2) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn(...args2), delay);
+  };
+}
+var STORAGE_KEYS = {
+  AUTH_SESSION: "emblem_auth_session",
+  HUSTLE_SETTINGS: "hustle_settings",
+  CHAT_HISTORY: "hustle_chat_history",
+  PLUGINS: "hustle-plugins"
+};
+var DEFAULTS = {
+  HUSTLE_API_URL: "https://agenthustle.ai",
+  EMBLEM_API_URL: "https://api.emblemvault.ai",
+  EMBLEM_MODAL_URL: "https://emblemvault.ai/connect"
+};
+
+export { DEFAULTS, HustleChat, HustleProvider, MarkdownContent, STORAGE_KEYS, availablePlugins, debounce, formatFileSize, getAvailablePlugin, hydratePlugin, migrateFunPlugin, pluginRegistry, predictionMarketPlugin, tokens, useHustle, usePlugins };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map