@lantos1618/better-ui 0.3.1 → 0.4.0

package/dist/index.mjs

@@ -1,3 +1,7 @@
+import {
+  __require
+} from "./chunk-Y6FXYEAI.mjs";
+
 // src/tool.tsx
 import { memo } from "react";
 import { jsx } from "react/jsx-runtime";
@@ -10,6 +14,10 @@ var Tool = class {
     this.tags = config.tags || [];
     this.cacheConfig = config.cache;
     this.clientFetchConfig = config.clientFetch;
+    this.confirm = config.confirm ?? false;
+    this.hints = config.hints ?? {};
+    this.groupKey = config.groupKey;
+    this.autoRespond = config.autoRespond ?? false;
     this._initView();
   }
   /**
@@ -37,6 +45,14 @@ var Tool = class {
     this._initView();
     return this;
   }
+  /**
+   * Define streaming implementation
+   * The handler receives a `stream` callback to push partial updates.
+   */
+  stream(handler) {
+    this._stream = handler;
+    return this;
+  }
   /**
    * Execute the tool
    * Automatically uses server or client handler based on environment
@@ -111,6 +127,72 @@ var Tool = class {
   async call(input, ctx) {
     return this.run(input, ctx);
   }
+  /**
+   * Execute with streaming - returns async generator of partial results.
+   * Falls back to run() if no stream handler is defined.
+   */
+  async *runStream(input, ctx) {
+    const validated = this.inputSchema.parse(input);
+    if (!this._stream) {
+      const result = await this.run(input, ctx);
+      yield { partial: result, done: true };
+      return;
+    }
+    const isServer = ctx?.isServer ?? typeof window === "undefined";
+    const context = {
+      cache: ctx?.cache || /* @__PURE__ */ new Map(),
+      fetch: ctx?.fetch || globalThis.fetch?.bind(globalThis),
+      isServer,
+      ...isServer ? {
+        env: ctx?.env,
+        headers: ctx?.headers,
+        cookies: ctx?.cookies,
+        user: ctx?.user,
+        session: ctx?.session
+      } : {
+        optimistic: ctx?.optimistic
+      }
+    };
+    const queue = [];
+    let waiter = null;
+    const notify = () => {
+      waiter?.();
+      waiter = null;
+    };
+    const wait = () => new Promise((r) => {
+      waiter = r;
+    });
+    const streamFn = (partial) => {
+      queue.push({ partial });
+      notify();
+    };
+    let error = null;
+    let isDone = false;
+    this._stream(validated, { ...context, stream: streamFn }).then((result) => {
+      queue.push({ done: true, result });
+      isDone = true;
+      notify();
+    }).catch((err) => {
+      error = err instanceof Error ? err : new Error(String(err));
+      isDone = true;
+      notify();
+    });
+    while (true) {
+      while (queue.length > 0) {
+        const item = queue.shift();
+        if ("done" in item) {
+          let finalResult = item.result;
+          if (this.outputSchema) finalResult = this.outputSchema.parse(finalResult);
+          yield { partial: finalResult, done: true };
+          return;
+        }
+        yield { partial: item.partial, done: false };
+      }
+      if (error) throw error;
+      if (isDone && queue.length === 0) return;
+      await wait();
+    }
+  }
   /**
    * Default client fetch when no .client() is defined
    *
@@ -146,6 +228,7 @@ var Tool = class {
       }
       return viewFn(props.data, {
         loading: props.loading,
+        streaming: props.streaming,
         error: props.error,
         onAction: props.onAction
       });
@@ -154,6 +237,7 @@ var Tool = class {
     this.View = memo(ViewComponent, (prevProps, nextProps) => {
       if (prevProps.data !== nextProps.data) return false;
       if (prevProps.loading !== nextProps.loading) return false;
+      if (prevProps.streaming !== nextProps.streaming) return false;
       if (prevProps.error !== nextProps.error) return false;
       return true;
     });
@@ -176,6 +260,43 @@ var Tool = class {
   get hasClient() {
     return !!this._client;
   }
+  /**
+   * Check if tool has a streaming implementation
+   */
+  get hasStream() {
+    return !!this._stream;
+  }
+  /**
+   * Check if tool requires human confirmation before executing (HITL)
+   * Returns true if `confirm` is truthy (boolean true or a function) OR `hints.destructive: true`
+   */
+  get requiresConfirmation() {
+    return !!this.confirm || this.hints.destructive === true;
+  }
+  /**
+   * Determine if a specific input should trigger user confirmation.
+   * - If `confirm` is a function, calls it with input
+   * - If `confirm` is boolean, returns it
+   * - If `hints.destructive`, returns true
+   */
+  shouldConfirm(input) {
+    if (typeof this.confirm === "function") {
+      if (input == null) return false;
+      return this.confirm(input);
+    }
+    if (typeof this.confirm === "boolean") {
+      return this.confirm;
+    }
+    return this.hints.destructive === true;
+  }
+  /**
+   * Get the entity group key for a given input.
+   * Returns `"toolName:groupKey(input)"` if groupKey is defined, otherwise undefined.
+   */
+  getGroupKey(input) {
+    if (!this.groupKey || input == null) return void 0;
+    return `${this.name}:${this.groupKey(input)}`;
+  }
   /**
    * Convert to plain object (for serialization)
    *
@@ -190,14 +311,28 @@ var Tool = class {
       hasServer: this.hasServer,
       hasClient: this.hasClient,
       hasView: this.hasView,
-      hasCache: !!this.cacheConfig
+      hasStream: this.hasStream,
+      hasCache: !!this.cacheConfig,
+      confirm: !!this.confirm,
+      hints: this.hints,
+      requiresConfirmation: this.requiresConfirmation
       // Intentionally NOT included: handlers, schemas, clientFetchConfig
     };
   }
   /**
    * Convert to AI SDK format (Vercel AI SDK v5 compatible)
+   *
+   * If `confirm` is true, the execute function is omitted so the AI SDK
+   * leaves the tool call at `state: 'input-available'`, enabling HITL
+   * confirmation on the client before execution.
    */
   toAITool() {
+    if (this.requiresConfirmation) {
+      return {
+        description: this.description || this.name,
+        inputSchema: this.inputSchema
+      };
+    }
     return {
       description: this.description || this.name,
       inputSchema: this.inputSchema,
@@ -254,6 +389,26 @@ var ToolBuilder = class {
     this._clientFetch = config;
     return this;
   }
+  /** Require human confirmation before executing (HITL) */
+  requireConfirm(value = true) {
+    this._confirm = value;
+    return this;
+  }
+  /** Set a groupKey function for collapsing related tool calls */
+  groupBy(fn) {
+    this._groupKey = fn;
+    return this;
+  }
+  /** Auto-send updated state to AI after user interacts with this tool's UI */
+  autoRespondAfterAction(value = true) {
+    this._autoRespond = value;
+    return this;
+  }
+  /** Set behavioral hints for the tool */
+  hints(hints) {
+    this._hints = hints;
+    return this;
+  }
   server(handler) {
     this._serverHandler = handler;
     return this;
@@ -262,6 +417,10 @@ var ToolBuilder = class {
     this._clientHandler = handler;
     return this;
   }
+  stream(handler) {
+    this._streamHandler = handler;
+    return this;
+  }
   view(component) {
     this._viewComponent = component;
     return this;
@@ -280,10 +439,15 @@ var ToolBuilder = class {
       output: this._output,
       tags: this._tags,
       cache: this._cache,
-      clientFetch: this._clientFetch
+      clientFetch: this._clientFetch,
+      confirm: this._confirm,
+      hints: this._hints,
+      groupKey: this._groupKey,
+      autoRespond: this._autoRespond
     });
     if (this._serverHandler) t.server(this._serverHandler);
     if (this._clientHandler) t.client(this._clientHandler);
+    if (this._streamHandler) t.stream(this._streamHandler);
     if (this._viewComponent) t.view(this._viewComponent);
     return t;
   }
@@ -293,6 +457,9 @@ var ToolBuilder = class {
   async run(input, ctx) {
     return this.build().run(input, ctx);
   }
+  async *runStream(input, ctx) {
+    yield* this.build().runStream(input, ctx);
+  }
   get View() {
     return this.build().View;
   }
@@ -304,188 +471,87 @@ var ToolBuilder = class {
   }
 };
 
-// src/react/useTool.ts
-import { useState, useCallback, useEffect, useRef } from "react";
-function useTool(tool2, initialInput, options = {}) {
-  const [data, setData] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const [executed, setExecuted] = useState(false);
-  const inputRef = useRef(initialInput);
-  const optionsRef = useRef(options);
-  optionsRef.current = options;
-  const executionIdRef = useRef(0);
-  const pendingCountRef = useRef(0);
-  const execute = useCallback(
-    async (input) => {
-      const finalInput = input ?? inputRef.current;
-      if (finalInput === void 0) {
-        const err = new Error("No input provided to tool");
-        setError(err);
-        optionsRef.current.onError?.(err);
-        return null;
-      }
-      const currentExecutionId = ++executionIdRef.current;
-      pendingCountRef.current++;
-      setLoading(true);
-      setError(null);
-      try {
-        const context = {
-          cache: /* @__PURE__ */ new Map(),
-          fetch: globalThis.fetch?.bind(globalThis),
-          isServer: false,
-          ...optionsRef.current.context
-        };
-        const result = await tool2.run(finalInput, context);
-        if (currentExecutionId === executionIdRef.current) {
-          setData(result);
-          setExecuted(true);
-          optionsRef.current.onSuccess?.(result);
-        }
-        return result;
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error(String(err));
-        if (currentExecutionId === executionIdRef.current) {
-          setError(error2);
-          optionsRef.current.onError?.(error2);
-        }
-        return null;
-      } finally {
-        pendingCountRef.current--;
-        if (pendingCountRef.current === 0) {
-          setLoading(false);
-        }
-      }
-    },
-    [tool2]
-  );
-  const reset = useCallback(() => {
-    setData(null);
-    setError(null);
-    setLoading(false);
-    setExecuted(false);
-  }, []);
-  useEffect(() => {
-    if (options.auto && initialInput !== void 0) {
-      inputRef.current = initialInput;
-      execute(initialInput);
+// src/providers/openai.ts
+function createOpenAIProvider(config) {
+  return {
+    type: "openai",
+    modelId: config.model,
+    model: () => {
+      const id = "@ai-sdk/openai";
+      const { openai } = __require(id);
+      return openai(config.model);
     }
-  }, [options.auto, initialInput, execute]);
+  };
+}
+
+// src/providers/anthropic.ts
+function createAnthropicProvider(config) {
   return {
-    data,
-    loading,
-    error,
-    execute,
-    reset,
-    executed
+    type: "anthropic",
+    modelId: config.model,
+    model: () => {
+      const id = "@ai-sdk/anthropic";
+      const { anthropic } = __require(id);
+      return anthropic(config.model);
+    }
   };
 }
-function useTools(tools, options = {}) {
-  const toolsRef = useRef(tools);
-  const optionsRef = useRef(options);
-  optionsRef.current = options;
-  if (process.env.NODE_ENV !== "production") {
-    const prevKeys = Object.keys(toolsRef.current);
-    const currKeys = Object.keys(tools);
-    if (prevKeys.length !== currKeys.length || !currKeys.every((k) => prevKeys.includes(k))) {
-      console.warn(
-        "useTools: The tools object keys changed between renders. This may cause unexpected behavior. Define tools outside the component or memoize with useMemo."
-      );
+
+// src/providers/google.ts
+function createGoogleProvider(config) {
+  return {
+    type: "google",
+    modelId: config.model,
+    model: () => {
+      const id = "@ai-sdk/google";
+      const { google } = __require(id);
+      return google(config.model);
     }
-    toolsRef.current = tools;
-  }
-  const [state, setState] = useState(() => {
-    const initial = {};
-    for (const name of Object.keys(tools)) {
-      initial[name] = {
-        data: null,
-        loading: false,
-        error: null,
-        executed: false
-      };
+  };
+}
+
+// src/providers/openrouter.ts
+function createOpenRouterProvider(config) {
+  return {
+    type: "openrouter",
+    modelId: config.model,
+    model: () => {
+      const id = "@ai-sdk/openai";
+      const { createOpenAI } = __require(id);
+      const openrouter = createOpenAI({
+        baseURL: config.baseURL || "https://openrouter.ai/api/v1",
+        apiKey: config.apiKey,
+        ...config.options
+      });
+      return openrouter(config.model);
+    }
+  };
+}
+
+// src/providers/index.ts
+function createProvider(config) {
+  switch (config.provider) {
+    case "openai":
+      return createOpenAIProvider(config);
+    case "anthropic":
+      return createAnthropicProvider(config);
+    case "google":
+      return createGoogleProvider(config);
+    case "openrouter":
+      return createOpenRouterProvider(config);
+    default: {
+      const exhaustiveCheck = config.provider;
+      throw new Error(`Unknown provider: ${exhaustiveCheck}`);
     }
-    return initial;
-  });
-  const createExecute = useCallback(
-    (toolName, tool2) => {
-      return async (input) => {
-        if (input === void 0) {
-          const err = new Error("No input provided to tool");
-          setState((prev) => ({
-            ...prev,
-            [toolName]: { ...prev[toolName], error: err }
-          }));
-          optionsRef.current.onError?.(err);
-          return null;
-        }
-        setState((prev) => ({
-          ...prev,
-          [toolName]: { ...prev[toolName], loading: true, error: null }
-        }));
-        try {
-          const context = {
-            cache: /* @__PURE__ */ new Map(),
-            fetch: globalThis.fetch?.bind(globalThis),
-            isServer: false,
-            ...optionsRef.current.context
-          };
-          const result = await tool2.run(input, context);
-          setState((prev) => ({
-            ...prev,
-            [toolName]: {
-              data: result,
-              loading: false,
-              error: null,
-              executed: true
-            }
-          }));
-          optionsRef.current.onSuccess?.(result);
-          return result;
-        } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err));
-          setState((prev) => ({
-            ...prev,
-            [toolName]: { ...prev[toolName], loading: false, error }
-          }));
-          optionsRef.current.onError?.(error);
-          return null;
-        }
-      };
-    },
-    []
-  );
-  const createReset = useCallback((toolName) => {
-    return () => {
-      setState((prev) => ({
-        ...prev,
-        [toolName]: {
-          data: null,
-          loading: false,
-          error: null,
-          executed: false
-        }
-      }));
-    };
-  }, []);
-  const results = {};
-  for (const [name, tool2] of Object.entries(tools)) {
-    const toolName = name;
-    const toolState = state[toolName];
-    results[toolName] = {
-      data: toolState?.data ?? null,
-      loading: toolState?.loading ?? false,
-      error: toolState?.error ?? null,
-      executed: toolState?.executed ?? false,
-      execute: createExecute(toolName, tool2),
-      reset: createReset(toolName)
-    };
   }
-  return results;
 }
 export {
   Tool,
   ToolBuilder,
-  tool,
-  useTool,
-  useTools
+  createAnthropicProvider,
+  createGoogleProvider,
+  createOpenAIProvider,
+  createOpenRouterProvider,
+  createProvider,
+  tool
 };

package/dist/persistence/index.d.mts

@@ -0,0 +1,11 @@
+import { P as PersistenceAdapter } from '../types-CAOfGUPH.mjs';
+export { T as Thread } from '../types-CAOfGUPH.mjs';
+import 'ai';
+
+/**
+ * In-memory persistence adapter.
+ * Useful for development and testing. Data is lost on page refresh.
+ */
+declare function createMemoryAdapter(): PersistenceAdapter;
+
+export { PersistenceAdapter, createMemoryAdapter };

package/dist/persistence/index.d.ts

@@ -0,0 +1,11 @@
+import { P as PersistenceAdapter } from '../types-CAOfGUPH.js';
+export { T as Thread } from '../types-CAOfGUPH.js';
+import 'ai';
+
+/**
+ * In-memory persistence adapter.
+ * Useful for development and testing. Data is lost on page refresh.
+ */
+declare function createMemoryAdapter(): PersistenceAdapter;
+
+export { PersistenceAdapter, createMemoryAdapter };

package/dist/persistence/index.js

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/persistence/index.ts
+var persistence_exports = {};
+__export(persistence_exports, {
+  createMemoryAdapter: () => createMemoryAdapter
+});
+module.exports = __toCommonJS(persistence_exports);
+
+// src/persistence/memory.ts
+function createMemoryAdapter() {
+  const threads = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Map();
+  let counter = 0;
+  return {
+    async listThreads() {
+      return Array.from(threads.values()).sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+    },
+    async getThread(id) {
+      return threads.get(id) ?? null;
+    },
+    async createThread(title) {
+      const id = `thread-${++counter}`;
+      const now = /* @__PURE__ */ new Date();
+      const thread = { id, title, createdAt: now, updatedAt: now };
+      threads.set(id, thread);
+      messages.set(id, []);
+      return thread;
+    },
+    async deleteThread(id) {
+      threads.delete(id);
+      messages.delete(id);
+    },
+    async getMessages(threadId) {
+      return messages.get(threadId) ?? [];
+    },
+    async saveMessages(threadId, msgs) {
+      messages.set(threadId, msgs);
+      const thread = threads.get(threadId);
+      if (thread) {
+        thread.updatedAt = /* @__PURE__ */ new Date();
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMemoryAdapter
+});

package/dist/persistence/index.mjs

@@ -0,0 +1,41 @@
+import "../chunk-Y6FXYEAI.mjs";
+
+// src/persistence/memory.ts
+function createMemoryAdapter() {
+  const threads = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Map();
+  let counter = 0;
+  return {
+    async listThreads() {
+      return Array.from(threads.values()).sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+    },
+    async getThread(id) {
+      return threads.get(id) ?? null;
+    },
+    async createThread(title) {
+      const id = `thread-${++counter}`;
+      const now = /* @__PURE__ */ new Date();
+      const thread = { id, title, createdAt: now, updatedAt: now };
+      threads.set(id, thread);
+      messages.set(id, []);
+      return thread;
+    },
+    async deleteThread(id) {
+      threads.delete(id);
+      messages.delete(id);
+    },
+    async getMessages(threadId) {
+      return messages.get(threadId) ?? [];
+    },
+    async saveMessages(threadId, msgs) {
+      messages.set(threadId, msgs);
+      const thread = threads.get(threadId);
+      if (thread) {
+        thread.updatedAt = /* @__PURE__ */ new Date();
+      }
+    }
+  };
+}
+export {
+  createMemoryAdapter
+};