@emblemvault/hustle-react 1.0.0

package/dist/hooks/index.js

@@ -0,0 +1,691 @@
+import { createContext, useState, useEffect, useCallback, useRef, useMemo, useContext } from 'react';
+import { HustleIncognitoClient } from 'hustle-incognito';
+import { useEmblemAuthOptional } from '@emblemvault/emblem-auth-react';
+import { jsx } from 'react/jsx-runtime';
+
+// 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 [error, 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, ...args) => {
+      if (debug) {
+        console.log(`[Hustle] ${message}`, ...args);
+      }
+    },
+    [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 error2 = err instanceof Error ? err : new Error("Chat request failed");
+        setError(error2);
+        throw error2;
+      } 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 error2 = err instanceof Error ? err : new Error("Stream failed");
+            setError(error2);
+            yield { type: "error", value: { message: error2.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 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,
+    // Auth mode
+    isApiKeyMode,
+    // 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__ */ 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;
+}
+
+export { HustleProvider, useHustle, usePlugins };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map