agent-hustle-demo 1.0.1

package/dist/providers/index.cjs

@@ -0,0 +1,844 @@
+'use strict';
+
+var react = require('react');
+var emblemAuthSdk = require('emblem-auth-sdk');
+var jsxRuntime = require('react/jsx-runtime');
+var hustleIncognito = require('hustle-incognito');
+
+var globalSDKInstance = null;
+var isSDKInitializing = false;
+var EmblemAuthContext = react.createContext(void 0);
+function EmblemAuthProvider({
+  children,
+  appId,
+  apiUrl,
+  modalUrl,
+  debug = false
+}) {
+  const [session, setSession] = react.useState(null);
+  const [isAuthenticated, setIsAuthenticated] = react.useState(false);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [vaultInfo, setVaultInfo] = react.useState(null);
+  const [authSDK, setAuthSDK] = react.useState(globalSDKInstance);
+  const initialized = react.useRef(false);
+  const log = react.useCallback(
+    (message, ...args) => {
+      if (debug) {
+        console.log(`[EmblemAuth] ${message}`, ...args);
+      }
+    },
+    [debug]
+  );
+  const fetchVaultInfo = react.useCallback(
+    async (sdk) => {
+      try {
+        const info = await sdk.getVaultInfo();
+        if (info) {
+          setVaultInfo(info);
+          log("Vault info loaded:", info);
+        }
+      } catch (err) {
+        log("Failed to fetch vault info:", err);
+      }
+    },
+    [log]
+  );
+  const handleAuthSuccess = react.useCallback(
+    (newSession, sdk) => {
+      log("Auth success - session:", newSession);
+      setSession(newSession);
+      setIsAuthenticated(true);
+      setIsLoading(false);
+      setError(null);
+      fetchVaultInfo(sdk);
+    },
+    [log, fetchVaultInfo]
+  );
+  const handleAuthError = react.useCallback(
+    (err) => {
+      log("Auth error:", err);
+      setError(err);
+      setIsLoading(false);
+      setIsAuthenticated(false);
+      setSession(null);
+    },
+    [log]
+  );
+  const handleSessionExpired = react.useCallback(() => {
+    log("Session expired");
+    setSession(null);
+    setIsAuthenticated(false);
+    setVaultInfo(null);
+  }, [log]);
+  react.useEffect(() => {
+    if (initialized.current || globalSDKInstance || isSDKInitializing) {
+      if (globalSDKInstance && !authSDK) {
+        setAuthSDK(globalSDKInstance);
+        const existingSession2 = globalSDKInstance.getSession();
+        if (existingSession2) {
+          handleAuthSuccess(existingSession2, globalSDKInstance);
+        }
+      }
+      return;
+    }
+    initialized.current = true;
+    isSDKInitializing = true;
+    log("Initializing SDK with appId:", appId);
+    const sdk = new emblemAuthSdk.EmblemAuthSDK({
+      appId,
+      apiUrl,
+      modalUrl,
+      onSuccess: (newSession) => {
+        handleAuthSuccess(newSession, sdk);
+      },
+      onError: (err) => {
+        handleAuthError(err);
+      }
+    });
+    globalSDKInstance = sdk;
+    isSDKInitializing = false;
+    setAuthSDK(sdk);
+    const existingSession = sdk.getSession();
+    if (existingSession) {
+      log("Found existing session");
+      handleAuthSuccess(existingSession, sdk);
+    }
+    const handleSessionUpdate = (updatedSession) => {
+      if (updatedSession) {
+        setSession(updatedSession);
+        setIsAuthenticated(true);
+      } else {
+        handleSessionExpired();
+      }
+    };
+    sdk.on("session", handleSessionUpdate);
+    sdk.on("sessionExpired", handleSessionExpired);
+    return () => {
+      sdk.off("session", handleSessionUpdate);
+      sdk.off("sessionExpired", handleSessionExpired);
+    };
+  }, [appId, apiUrl, modalUrl, log, handleAuthSuccess, handleAuthError, handleSessionExpired, authSDK]);
+  const openAuthModal = react.useCallback(async () => {
+    if (!authSDK) {
+      setError(new Error("Auth SDK not initialized"));
+      return;
+    }
+    log("Opening auth modal");
+    setIsLoading(true);
+    setError(null);
+    try {
+      await authSDK.openAuthModal();
+    } catch (err) {
+      setIsLoading(false);
+      setError(err instanceof Error ? err : new Error("Failed to open auth modal"));
+    }
+  }, [authSDK, log]);
+  const logout = react.useCallback(() => {
+    if (!authSDK) return;
+    log("Logging out");
+    authSDK.logout();
+    setSession(null);
+    setIsAuthenticated(false);
+    setVaultInfo(null);
+    setError(null);
+  }, [authSDK, log]);
+  const refreshSession = react.useCallback(async () => {
+    if (!authSDK) return null;
+    log("Refreshing session");
+    try {
+      const refreshedSession = await authSDK.refreshSession();
+      if (refreshedSession) {
+        setSession(refreshedSession);
+        setIsAuthenticated(true);
+        return refreshedSession;
+      }
+      return null;
+    } catch (err) {
+      log("Failed to refresh session:", err);
+      setError(err instanceof Error ? err : new Error("Failed to refresh session"));
+      return null;
+    }
+  }, [authSDK, log]);
+  const vaultId = session?.user?.vaultId ?? null;
+  const walletAddress = session?.user?.evmAddress ?? null;
+  const value = {
+    // State
+    session,
+    isAuthenticated,
+    isLoading,
+    error,
+    vaultInfo,
+    // Derived
+    vaultId,
+    walletAddress,
+    // Actions
+    openAuthModal,
+    logout,
+    refreshSession,
+    // For Hustle integration
+    authSDK
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(EmblemAuthContext.Provider, { value, children });
+}
+function useEmblemAuth() {
+  const context = react.useContext(EmblemAuthContext);
+  if (context === void 0) {
+    throw new Error("useEmblemAuth must be used within an EmblemAuthProvider");
+  }
+  return context;
+}
+function resetAuthSDK() {
+  globalSDKInstance = null;
+  isSDKInitializing = false;
+}
+
+// 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] = react.useState([]);
+  react.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 = react.useCallback((plugin) => {
+    pluginRegistry.register(plugin, true, instanceId);
+  }, [instanceId]);
+  const unregisterPlugin = react.useCallback((name) => {
+    pluginRegistry.unregister(name, instanceId);
+  }, [instanceId]);
+  const enablePlugin = react.useCallback((name) => {
+    pluginRegistry.setEnabled(name, true, instanceId);
+  }, [instanceId]);
+  const disablePlugin = react.useCallback((name) => {
+    pluginRegistry.setEnabled(name, false, instanceId);
+  }, [instanceId]);
+  const isRegistered = react.useCallback(
+    (name) => plugins.some((p) => p.name === name),
+    [plugins]
+  );
+  const isEnabled = react.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 = react.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
+}) {
+  const [resolvedInstanceId] = react.useState(() => {
+    if (explicitInstanceId) {
+      return explicitInstanceId;
+    }
+    const autoId = `instance-${++instanceCounter}`;
+    mountedAutoInstances.add(autoId);
+    return autoId;
+  });
+  const isAutoInstance = !explicitInstanceId;
+  react.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 { authSDK, isAuthenticated } = useEmblemAuth();
+  const { enabledPlugins } = usePlugins(resolvedInstanceId);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [models, setModels] = react.useState([]);
+  const registeredPluginsRef = react.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] = react.useState(initialSettings.selectedModel);
+  const [systemPrompt, setSystemPromptState] = react.useState(initialSettings.systemPrompt);
+  const [skipServerPrompt, setSkipServerPromptState] = react.useState(initialSettings.skipServerPrompt);
+  const saveSettings = react.useCallback((settings) => {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(SETTINGS_KEY, JSON.stringify(settings));
+    } catch {
+    }
+  }, []);
+  const setSelectedModel = react.useCallback((value2) => {
+    setSelectedModelState(value2);
+    saveSettings({ selectedModel: value2, systemPrompt, skipServerPrompt });
+  }, [systemPrompt, skipServerPrompt, saveSettings]);
+  const setSystemPrompt = react.useCallback((value2) => {
+    setSystemPromptState(value2);
+    saveSettings({ selectedModel, systemPrompt: value2, skipServerPrompt });
+  }, [selectedModel, skipServerPrompt, saveSettings]);
+  const setSkipServerPrompt = react.useCallback((value2) => {
+    setSkipServerPromptState(value2);
+    saveSettings({ selectedModel, systemPrompt, skipServerPrompt: value2 });
+  }, [selectedModel, systemPrompt, saveSettings]);
+  const log = react.useCallback(
+    (message, ...args) => {
+      if (debug) {
+        console.log(`[Hustle] ${message}`, ...args);
+      }
+    },
+    [debug]
+  );
+  const client = react.useMemo(() => {
+    if (!authSDK || !isAuthenticated) {
+      log("Client not created - auth not ready");
+      return null;
+    }
+    log("Creating HustleIncognitoClient with auth SDK");
+    try {
+      const hustleClient = new hustleIncognito.HustleIncognitoClient({
+        sdk: authSDK,
+        // CORRECT: Pass auth SDK instance, NOT apiKey
+        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;
+    }
+  }, [authSDK, isAuthenticated, hustleApiUrl, debug, log]);
+  const isReady = client !== null;
+  react.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 = react.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]);
+  react.useEffect(() => {
+    if (client) {
+      loadModels();
+    }
+  }, [client, loadModels]);
+  const chat = react.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 (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 error2 = err instanceof Error ? err : new Error("Chat request failed");
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, selectedModel, systemPrompt, skipServerPrompt, log]
+  );
+  const chatStreamImpl = react.useCallback(
+    (options) => {
+      if (!client) {
+        return {
+          [Symbol.asyncIterator]: async function* () {
+            yield { type: "error", value: { message: "Hustle client not ready. Please authenticate first." } };
+          }
+        };
+      }
+      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 (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 error2 = err instanceof Error ? err : new Error("Stream failed");
+            setError(error2);
+            yield { type: "error", value: { message: error2.message } };
+          }
+        }
+      };
+    },
+    [client, selectedModel, systemPrompt, skipServerPrompt, log]
+  );
+  const uploadFile = react.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 error2 = err instanceof Error ? err : new Error("File upload failed");
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, log]
+  );
+  const value = {
+    // Instance ID for scoped storage
+    instanceId: resolvedInstanceId,
+    // State
+    isReady,
+    isLoading,
+    error,
+    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__ */ jsxRuntime.jsx(HustleContext.Provider, { value, children });
+}
+function useHustle() {
+  const context = react.useContext(HustleContext);
+  if (context === void 0) {
+    throw new Error("useHustle must be used within a HustleProvider (which requires EmblemAuthProvider)");
+  }
+  return context;
+}
+
+exports.EmblemAuthProvider = EmblemAuthProvider;
+exports.HustleProvider = HustleProvider;
+exports.resetAuthSDK = resetAuthSDK;
+exports.useEmblemAuth = useEmblemAuth;
+exports.useHustle = useHustle;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map