@plucky-ai/react 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -1,38 +1,56 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let __plucky_ai_chat_sdk = require("@plucky-ai/chat-sdk");
-__plucky_ai_chat_sdk = __toESM(__plucky_ai_chat_sdk);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _plucky_ai_chat_sdk = require("@plucky-ai/chat-sdk");
 let react = require("react");
-react = __toESM(react);
-
 //#region src/hooks/useChat.ts
+/**
+* React hook that initializes the Plucky chat widget.
+*
+* Calls {@link Plucky} on mount to inject the widget scripts into the page.
+* The widget is only attached once — subsequent renders with different params
+* will not re-initialize it.
+*
+* Pair with {@link useTools} to register custom tools the AI assistant can invoke.
+*
+* @param params - Widget configuration. Required fields are `appId` and `baseUrl`.
+*   See {@link UseChatParams} (alias for `PluckySettingsParams`) for the full
+*   list of options including `user`, `mode`, `autoOpen`, and `triggerButton`.
+*
+* @example
+* ```tsx
+* import { useChat } from '@plucky-ai/react'
+*
+* function App() {
+*   useChat({
+*     appId: 'your-app-id',
+*     baseUrl: 'https://widget.plucky.ai',
+*     user: { id: 'user-123', name: 'Jane' },
+*     mode: 'push',
+*     autoOpen: false,
+*   })
+*
+*   return <div>My App</div>
+* }
+* ```
+*
+* @example With inline mode
+* ```tsx
+* function ChatPage() {
+*   useChat({
+*     appId: 'your-app-id',
+*     baseUrl: 'https://widget.plucky.ai',
+*     mode: 'inline',
+*     containerId: 'chat-container',
+*   })
+*
+*   return <div id="chat-container" style={{ height: '600px' }} />
+* }
+* ```
+*/
 function useChat(params) {
 	(0, react.useEffect)(() => {
-		(0, __plucky_ai_chat_sdk.Plucky)(params);
+		(0, _plucky_ai_chat_sdk.Plucky)(params);
 	}, [params]);
 }
-
 //#endregion
 //#region src/hooks/useTools.ts
 function useLatest(value) {
@@ -42,6 +60,60 @@ function useLatest(value) {
 	}, [value]);
 	return ref;
 }
+/**
+* React hook that registers custom tools the AI assistant can invoke.
+*
+* Tools are registered on mount (via {@link addTools}) and automatically
+* unregistered on unmount or when the `tools` array reference changes.
+*
+* The `context` parameter is kept up-to-date via a ref, so tool callbacks
+* always receive the latest value even if React state has changed since
+* the tools were registered.
+*
+* @typeParam TContext - Type of the shared context object passed to every
+*   tool callback as the second argument.
+*
+* @param params - Tool registration parameters.
+* @param params.tools - Array of tool definitions. Each must have `name`,
+*   `description`, and `cb`. Optionally include `inputSchema` (Zod or JSON Schema),
+*   `defaultLoadingText`, and `defaultSuccessText`.
+*   See {@link UseToolsParams} for the full type definition.
+* @param params.context - Shared context passed as the second argument to every
+*   tool callback. Useful for injecting API clients, user state, or other
+*   dependencies that may change between renders.
+*
+* @example
+* ```tsx
+* import { useChat, useTools } from '@plucky-ai/react'
+* import { z } from 'zod'
+*
+* function App() {
+*   useChat({ appId: 'my-app', baseUrl: 'https://widget.plucky.ai' })
+*
+*   const [user] = useState({ id: 'user-123' })
+*   const apiClient = useApiClient()
+*
+*   useTools({
+*     context: { apiClient, user },
+*     tools: [
+*       {
+*         name: 'getOrders',
+*         description: 'Fetches recent orders for the current user',
+*         inputSchema: z.object({
+*           limit: z.number().optional().describe('Max results to return'),
+*         }),
+*         cb: async ({ limit }, ctx) => {
+*           const orders = await ctx.apiClient.getOrders(ctx.user.id, { limit })
+*           return JSON.stringify(orders)
+*         },
+*       },
+*     ],
+*   })
+*
+*   return <div>My App</div>
+* }
+* ```
+*/
 function useTools(params) {
 	const contextRef = useLatest(params.context);
 	const { tools } = params;
@@ -57,14 +129,14 @@ function useTools(params) {
 	}), [tools, contextRef]);
 	(0, react.useEffect)(() => {
 		if (!tools || tools.length === 0) return;
-		(0, __plucky_ai_chat_sdk.addTools)(wrappedTools);
+		(0, _plucky_ai_chat_sdk.addTools)(wrappedTools);
 		return () => {
-			(0, __plucky_ai_chat_sdk.removeTools)(wrappedTools.map((tool) => tool.name));
+			(0, _plucky_ai_chat_sdk.removeTools)(wrappedTools.map((tool) => tool.name));
 		};
 	}, [wrappedTools]);
 }
-
 //#endregion
 exports.useChat = useChat;
 exports.useTools = useTools;
+
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../src/hooks/useChat.ts","../src/hooks/useTools.ts"],"sourcesContent":["import { UseChatParams } from '@/types'\nimport { Plucky } from '@plucky-ai/chat-sdk'\nimport { useEffect } from 'react'\n\nexport function useChat(params: UseChatParams) {\n  useEffect(() => {\n    Plucky(params)\n  }, [params])\n}\n","import { UseToolsParams } from '@/types'\nimport { addTools, removeTools } from '@plucky-ai/chat-sdk'\nimport { useEffect, useMemo, useRef } from 'react'\nfunction useLatest<T>(value: T) {\n  const ref = useRef(value)\n  useEffect(() => {\n    ref.current = value\n  }, [value])\n  return ref\n}\n\nexport function useTools<TContext = Record<string, unknown>>(\n  params: UseToolsParams<TContext>,\n) {\n  const contextRef = useLatest(params.context)\n\n  const { tools } = params\n  const wrappedTools = useMemo(\n    () =>\n      tools.map((tool) => {\n        const originalCb = tool.cb\n        return {\n          ...tool,\n          cb: async (input: Record<string, unknown>) => {\n            if (!contextRef.current) return 'Tool not yet loaded.'\n            return originalCb(input, contextRef.current)\n          },\n        }\n      }),\n    [tools, contextRef],\n  )\n\n  useEffect(() => {\n    if (!tools || tools.length === 0) return\n    addTools(wrappedTools)\n    return () => {\n      removeTools(wrappedTools.map((tool) => tool.name))\n    }\n  }, [wrappedTools])\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,SAAgB,QAAQ,QAAuB;AAC7C,4BAAgB;AACd,mCAAO,OAAO;IACb,CAAC,OAAO,CAAC;;;;;ACJd,SAAS,UAAa,OAAU;CAC9B,MAAM,wBAAa,MAAM;AACzB,4BAAgB;AACd,MAAI,UAAU;IACb,CAAC,MAAM,CAAC;AACX,QAAO;;AAGT,SAAgB,SACd,QACA;CACA,MAAM,aAAa,UAAU,OAAO,QAAQ;CAE5C,MAAM,EAAE,UAAU;CAClB,MAAM,wCAEF,MAAM,KAAK,SAAS;EAClB,MAAM,aAAa,KAAK;AACxB,SAAO;GACL,GAAG;GACH,IAAI,OAAO,UAAmC;AAC5C,QAAI,CAAC,WAAW,QAAS,QAAO;AAChC,WAAO,WAAW,OAAO,WAAW,QAAQ;;GAE/C;GACD,EACJ,CAAC,OAAO,WAAW,CACpB;AAED,4BAAgB;AACd,MAAI,CAAC,SAAS,MAAM,WAAW,EAAG;AAClC,qCAAS,aAAa;AACtB,eAAa;AACX,yCAAY,aAAa,KAAK,SAAS,KAAK,KAAK,CAAC;;IAEnD,CAAC,aAAa,CAAC"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/hooks/useChat.ts","../src/hooks/useTools.ts"],"sourcesContent":["import { UseChatParams } from '@/types'\nimport { Plucky } from '@plucky-ai/chat-sdk'\nimport { useEffect } from 'react'\n\n/**\n * React hook that initializes the Plucky chat widget.\n *\n * Calls {@link Plucky} on mount to inject the widget scripts into the page.\n * The widget is only attached once — subsequent renders with different params\n * will not re-initialize it.\n *\n * Pair with {@link useTools} to register custom tools the AI assistant can invoke.\n *\n * @param params - Widget configuration. Required fields are `appId` and `baseUrl`.\n *   See {@link UseChatParams} (alias for `PluckySettingsParams`) for the full\n *   list of options including `user`, `mode`, `autoOpen`, and `triggerButton`.\n *\n * @example\n * ```tsx\n * import { useChat } from '@plucky-ai/react'\n *\n * function App() {\n *   useChat({\n *     appId: 'your-app-id',\n *     baseUrl: 'https://widget.plucky.ai',\n *     user: { id: 'user-123', name: 'Jane' },\n *     mode: 'push',\n *     autoOpen: false,\n *   })\n *\n *   return <div>My App</div>\n * }\n * ```\n *\n * @example With inline mode\n * ```tsx\n * function ChatPage() {\n *   useChat({\n *     appId: 'your-app-id',\n *     baseUrl: 'https://widget.plucky.ai',\n *     mode: 'inline',\n *     containerId: 'chat-container',\n *   })\n *\n *   return <div id=\"chat-container\" style={{ height: '600px' }} />\n * }\n * ```\n */\nexport function useChat(params: UseChatParams) {\n  useEffect(() => {\n    Plucky(params)\n  }, [params])\n}\n","import { UseToolsParams } from '@/types'\nimport { addTools, removeTools } from '@plucky-ai/chat-sdk'\nimport { useEffect, useMemo, useRef } from 'react'\nfunction useLatest<T>(value: T) {\n  const ref = useRef(value)\n  useEffect(() => {\n    ref.current = value\n  }, [value])\n  return ref\n}\n\n/**\n * React hook that registers custom tools the AI assistant can invoke.\n *\n * Tools are registered on mount (via {@link addTools}) and automatically\n * unregistered on unmount or when the `tools` array reference changes.\n *\n * The `context` parameter is kept up-to-date via a ref, so tool callbacks\n * always receive the latest value even if React state has changed since\n * the tools were registered.\n *\n * @typeParam TContext - Type of the shared context object passed to every\n *   tool callback as the second argument.\n *\n * @param params - Tool registration parameters.\n * @param params.tools - Array of tool definitions. Each must have `name`,\n *   `description`, and `cb`. Optionally include `inputSchema` (Zod or JSON Schema),\n *   `defaultLoadingText`, and `defaultSuccessText`.\n *   See {@link UseToolsParams} for the full type definition.\n * @param params.context - Shared context passed as the second argument to every\n *   tool callback. Useful for injecting API clients, user state, or other\n *   dependencies that may change between renders.\n *\n * @example\n * ```tsx\n * import { useChat, useTools } from '@plucky-ai/react'\n * import { z } from 'zod'\n *\n * function App() {\n *   useChat({ appId: 'my-app', baseUrl: 'https://widget.plucky.ai' })\n *\n *   const [user] = useState({ id: 'user-123' })\n *   const apiClient = useApiClient()\n *\n *   useTools({\n *     context: { apiClient, user },\n *     tools: [\n *       {\n *         name: 'getOrders',\n *         description: 'Fetches recent orders for the current user',\n *         inputSchema: z.object({\n *           limit: z.number().optional().describe('Max results to return'),\n *         }),\n *         cb: async ({ limit }, ctx) => {\n *           const orders = await ctx.apiClient.getOrders(ctx.user.id, { limit })\n *           return JSON.stringify(orders)\n *         },\n *       },\n *     ],\n *   })\n *\n *   return <div>My App</div>\n * }\n * ```\n */\nexport function useTools<TContext = Record<string, unknown>>(params: UseToolsParams<TContext>) {\n  const contextRef = useLatest(params.context)\n\n  const { tools } = params\n  const wrappedTools = useMemo(\n    () =>\n      tools.map((tool) => {\n        const originalCb = tool.cb\n        return {\n          ...tool,\n          cb: async (input: Record<string, unknown>) => {\n            if (!contextRef.current) return 'Tool not yet loaded.'\n            return originalCb(input, contextRef.current)\n          },\n        }\n      }),\n    [tools, contextRef],\n  )\n\n  useEffect(() => {\n    if (!tools || tools.length === 0) return\n    addTools(wrappedTools)\n    return () => {\n      removeTools(wrappedTools.map((tool) => tool.name))\n    }\n  }, [wrappedTools])\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,QAAQ,QAAuB;AAC7C,EAAA,GAAA,MAAA,iBAAgB;AACd,GAAA,GAAA,oBAAA,QAAO,OAAO;IACb,CAAC,OAAO,CAAC;;;;AChDd,SAAS,UAAa,OAAU;CAC9B,MAAM,OAAA,GAAA,MAAA,QAAa,MAAM;AACzB,EAAA,GAAA,MAAA,iBAAgB;AACd,MAAI,UAAU;IACb,CAAC,MAAM,CAAC;AACX,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDT,SAAgB,SAA6C,QAAkC;CAC7F,MAAM,aAAa,UAAU,OAAO,QAAQ;CAE5C,MAAM,EAAE,UAAU;CAClB,MAAM,gBAAA,GAAA,MAAA,eAEF,MAAM,KAAK,SAAS;EAClB,MAAM,aAAa,KAAK;AACxB,SAAO;GACL,GAAG;GACH,IAAI,OAAO,UAAmC;AAC5C,QAAI,CAAC,WAAW,QAAS,QAAO;AAChC,WAAO,WAAW,OAAO,WAAW,QAAQ;;GAE/C;GACD,EACJ,CAAC,OAAO,WAAW,CACpB;AAED,EAAA,GAAA,MAAA,iBAAgB;AACd,MAAI,CAAC,SAAS,MAAM,WAAW,EAAG;AAClC,GAAA,GAAA,oBAAA,UAAS,aAAa;AACtB,eAAa;AACX,IAAA,GAAA,oBAAA,aAAY,aAAa,KAAK,SAAS,KAAK,KAAK,CAAC;;IAEnD,CAAC,aAAa,CAAC"}

package/dist/index.d.cts

@@ -1,19 +1,354 @@
 import { ToolConfig } from "@plucky-ai/chat-sdk";
-import { PluckySettingsParams, ToolCallbackResult } from "@plucky-ai/loader-types";
 
+//#region ../loader-types/dist/index.d.mts
+//#region src/index.d.ts
+/**
+ * Configuration options for initializing the Plucky chat widget.
+ *
+ * Pass this object to {@link Plucky} (chat-sdk) or {@link useChat} (React)
+ * to embed the widget on the page.
+ *
+ * @example
+ * ```ts
+ * Plucky({
+ *   appId: 'my-app-id',
+ *   baseUrl: 'https://widget.plucky.ai',
+ *   user: { id: 'user-123', name: 'Jane Doe', email: 'jane@example.com' },
+ *   mode: 'push',
+ *   autoOpen: false,
+ * })
+ * ```
+ */
+type PluckySettingsParams = {
+  /**
+   * Base URL of the Plucky widget server (e.g., `'https://widget.plucky.ai'`).
+   * The loader script and widget iframe are served from this origin.
+   */
+  baseUrl: string;
+  /**
+   * Unique identifier for your Plucky app, obtained from the Plucky dashboard.
+   */
+  appId: string;
+  /**
+   * Optional user identification and metadata. When provided, the widget
+   * associates conversations with this user and displays their name/email
+   * in the dashboard.
+   *
+   * @example
+   * ```ts
+   * user: {
+   *   id: 'user-123',
+   *   name: 'Jane Doe',
+   *   email: 'jane@example.com',
+   *   createdAt: '2024-01-15T00:00:00Z',
+   *   metadata: { plan: 'pro', company: 'Acme' },
+   * }
+   * ```
+   */
+  user?: {
+    /** Unique identifier for the user in your system. */id: string; /** Display name shown in the Plucky dashboard. */
+    name?: string; /** Email address shown in the Plucky dashboard. */
+    email?: string;
+    /**
+     * ISO 8601 timestamp of when the user was created in your system.
+     * Used for analytics and segmentation in the dashboard.
+     */
+    createdAt?: string;
+    /**
+     * Arbitrary key-value metadata attached to the user.
+     * Visible in the Plucky dashboard and can be used for filtering.
+     */
+    metadata?: Record<string, any>;
+  };
+  /**
+   * Built-in system tools to enable for the AI assistant.
+   *
+   * @example
+   * ```ts
+   * systemTools: { readPage: true }
+   * ```
+   */
+  systemTools?: {
+    /**
+     * When `true`, enables the `readPage` system tool that allows the AI
+     * assistant to read the content of the current page. Defaults to `false`.
+     */
+    readPage?: boolean;
+  };
+  /**
+   * Display mode for the widget.
+   * - `'push'` (default) — fixed sidebar that pushes page content.
+   * - `'overlay'` — fixed sidebar that overlays page content.
+   * - `'inline'` — widget is mounted inside a container element specified by {@link containerId}.
+   */
+  mode?: 'push' | 'overlay' | 'inline';
+  /**
+   * The `id` of the container element to mount the widget into.
+   * Required when `mode` is `'inline'`. The element must exist in the DOM
+   * before calling init / mounting the widget.
+   */
+  containerId?: string;
+  /**
+   * Whether to auto-open the widget when it loads. Defaults to `true`.
+   * Set to `false` to start with the widget closed.
+   */
+  autoOpen?: boolean;
+  /**
+   * Whether to show a floating trigger button in the bottom-right corner.
+   * When clicked, the trigger button toggles the widget open/closed.
+   * Defaults to `false`.
+   */
+  triggerButton?: boolean;
+  /**
+   * URL patterns the widget should be **visible** on.
+   * Uses Chrome-style match patterns (e.g. `'https://*.example.com/app/*'`).
+   * When omitted or empty, every page is included by default.
+   * If a URL matches both `include` and `exclude`, `exclude` wins.
+   */
+  include?: string[];
+  /**
+   * URL patterns the widget should be **hidden** on.
+   * Uses Chrome-style match patterns (e.g. `'https://example.com/login'`).
+   * Takes priority over `include` — if a URL matches both, it is excluded.
+   * The widget stays mounted but is hidden on excluded pages.
+   */
+  exclude?: string[];
+};
+/**
+ * Serializable subset of a tool definition sent across the iframe boundary.
+ * This does not include the callback — only metadata used by the widget
+ * to display tool information and validate inputs.
+ *
+ * @see {@link ToolConfig} for the full tool definition including the callback.
+ */
+/**
+ * Return type for a tool callback. Either a plain string (used as the tool
+ * result content) or an object with `content` and an optional `successText`
+ * override.
+ *
+ * @example
+ * ```ts
+ * // Simple string result
+ * cb: async ({ city }) => `The weather in ${city} is sunny.`
+ *
+ * // Object result with custom success text
+ * cb: async ({ city }) => ({
+ *   content: JSON.stringify({ temp: 72, condition: 'sunny' }),
+ *   successText: `Fetched weather for ${city}`,
+ * })
+ * ```
+ */
+type ToolCallbackResult = string | {
+  /** The content returned to the AI assistant as the tool result. */content: string; /** Optional override for the success text displayed in the chat UI after the tool completes. */
+  successText?: string;
+};
+/**
+ * Full tool definition including the callback function.
+ *
+ * Register tools with {@link addTools} (chat-sdk) or {@link useTools} (React)
+ * to let the AI assistant invoke custom functions on the host page.
+ *
+ * @typeParam TInputSchema - The type of the input schema (Zod object or plain JSON Schema).
+ *   When a Zod schema is provided, the callback `input` parameter is automatically
+ *   inferred from it.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * const weatherTool: ToolConfig = {
+ *   name: 'getWeather',
+ *   description: 'Fetches current weather for a city',
+ *   inputSchema: z.object({
+ *     city: z.string().describe('City name'),
+ *   }),
+ *   cb: async ({ city }) => `The weather in ${city} is sunny.`,
+ * }
+ * ```
+ */
+//#endregion
 //#region src/types.d.ts
+/**
+ * Parameters for the {@link useChat} hook.
+ *
+ * This is an alias for {@link PluckySettingsParams} — see that type for
+ * the full list of configuration properties.
+ *
+ * @example
+ * ```tsx
+ * useChat({
+ *   appId: 'your-app-id',
+ *   baseUrl: 'https://widget.plucky.ai',
+ *   user: { id: 'user-123', name: 'Jane' },
+ * })
+ * ```
+ */
 type UseChatParams = PluckySettingsParams;
+/**
+ * Parameters for the {@link useTools} hook.
+ *
+ * @typeParam TContext - Type of the shared context object passed as the second
+ *   argument to every tool callback. Defaults to `Record<string, unknown>`.
+ *
+ * @example
+ * ```tsx
+ * useTools({
+ *   context: { apiClient, currentUser },
+ *   tools: [
+ *     {
+ *       name: 'getOrders',
+ *       description: 'Fetches recent orders for the user',
+ *       cb: async (input, ctx) => {
+ *         const orders = await ctx.apiClient.getOrders(ctx.currentUser.id)
+ *         return JSON.stringify(orders)
+ *       },
+ *     },
+ *   ],
+ * })
+ * ```
+ */
 type UseToolsParams<TContext = Record<string, unknown>> = {
+  /**
+   * Shared context object passed as the second argument to every tool callback.
+   * Use this to give tools access to React state, API clients, or other
+   * dependencies without closing over stale values.
+   *
+   * The context ref is kept up-to-date on every render, so callbacks always
+   * receive the latest value.
+   */
   context?: TContext;
+  /**
+   * Array of tool definitions to register with the Plucky widget.
+   *
+   * Each tool extends {@link ToolConfig} but replaces the `cb` callback
+   * signature to include the `context` as a second parameter.
+   *
+   * Tools are automatically registered on mount and unregistered on unmount
+   * or when the `tools` array reference changes.
+   *
+   * | Property | Type | Description |
+   * |---|---|---|
+   * | `name` | `string` | **(required)** Unique tool name. |
+   * | `description` | `string` | **(required)** Tells the AI when to use this tool. |
+   * | `inputSchema` | `ZodObject \| Record<string, unknown>` | Schema describing expected input. |
+   * | `cb` | `(input, context) => ToolCallbackResult` | Callback invoked by the AI. Receives `context` as second arg. |
+   * | `defaultLoadingText` | `string \| null` | Text shown while the tool runs. |
+   * | `defaultSuccessText` | `string \| null` | Text shown on completion. |
+   */
   tools: Array<Omit<ToolConfig, 'cb'> & {
+    /**
+     * Callback executed when the AI assistant invokes this tool.
+     *
+     * @param input - The input arguments from the AI assistant.
+     * @param context - The current value of {@link UseToolsParams.context}.
+     * @returns The tool result — either a plain string or `{ content, successText? }`.
+     */
     cb: (input: Record<string, unknown>, context: TContext) => Promise<ToolCallbackResult> | ToolCallbackResult;
   }>;
 };
 //#endregion
 //#region src/hooks/useChat.d.ts
+/**
+ * React hook that initializes the Plucky chat widget.
+ *
+ * Calls {@link Plucky} on mount to inject the widget scripts into the page.
+ * The widget is only attached once — subsequent renders with different params
+ * will not re-initialize it.
+ *
+ * Pair with {@link useTools} to register custom tools the AI assistant can invoke.
+ *
+ * @param params - Widget configuration. Required fields are `appId` and `baseUrl`.
+ *   See {@link UseChatParams} (alias for `PluckySettingsParams`) for the full
+ *   list of options including `user`, `mode`, `autoOpen`, and `triggerButton`.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from '@plucky-ai/react'
+ *
+ * function App() {
+ *   useChat({
+ *     appId: 'your-app-id',
+ *     baseUrl: 'https://widget.plucky.ai',
+ *     user: { id: 'user-123', name: 'Jane' },
+ *     mode: 'push',
+ *     autoOpen: false,
+ *   })
+ *
+ *   return <div>My App</div>
+ * }
+ * ```
+ *
+ * @example With inline mode
+ * ```tsx
+ * function ChatPage() {
+ *   useChat({
+ *     appId: 'your-app-id',
+ *     baseUrl: 'https://widget.plucky.ai',
+ *     mode: 'inline',
+ *     containerId: 'chat-container',
+ *   })
+ *
+ *   return <div id="chat-container" style={{ height: '600px' }} />
+ * }
+ * ```
+ */
 declare function useChat(params: UseChatParams): void;
 //#endregion
 //#region src/hooks/useTools.d.ts
+/**
+ * React hook that registers custom tools the AI assistant can invoke.
+ *
+ * Tools are registered on mount (via {@link addTools}) and automatically
+ * unregistered on unmount or when the `tools` array reference changes.
+ *
+ * The `context` parameter is kept up-to-date via a ref, so tool callbacks
+ * always receive the latest value even if React state has changed since
+ * the tools were registered.
+ *
+ * @typeParam TContext - Type of the shared context object passed to every
+ *   tool callback as the second argument.
+ *
+ * @param params - Tool registration parameters.
+ * @param params.tools - Array of tool definitions. Each must have `name`,
+ *   `description`, and `cb`. Optionally include `inputSchema` (Zod or JSON Schema),
+ *   `defaultLoadingText`, and `defaultSuccessText`.
+ *   See {@link UseToolsParams} for the full type definition.
+ * @param params.context - Shared context passed as the second argument to every
+ *   tool callback. Useful for injecting API clients, user state, or other
+ *   dependencies that may change between renders.
+ *
+ * @example
+ * ```tsx
+ * import { useChat, useTools } from '@plucky-ai/react'
+ * import { z } from 'zod'
+ *
+ * function App() {
+ *   useChat({ appId: 'my-app', baseUrl: 'https://widget.plucky.ai' })
+ *
+ *   const [user] = useState({ id: 'user-123' })
+ *   const apiClient = useApiClient()
+ *
+ *   useTools({
+ *     context: { apiClient, user },
+ *     tools: [
+ *       {
+ *         name: 'getOrders',
+ *         description: 'Fetches recent orders for the current user',
+ *         inputSchema: z.object({
+ *           limit: z.number().optional().describe('Max results to return'),
+ *         }),
+ *         cb: async ({ limit }, ctx) => {
+ *           const orders = await ctx.apiClient.getOrders(ctx.user.id, { limit })
+ *           return JSON.stringify(orders)
+ *         },
+ *       },
+ *     ],
+ *   })
+ *
+ *   return <div>My App</div>
+ * }
+ * ```
+ */
 declare function useTools<TContext = Record<string, unknown>>(params: UseToolsParams<TContext>): void;
 //#endregion
 export { UseChatParams, UseToolsParams, useChat, useTools };

package/dist/index.d.mts

@@ -0,0 +1,355 @@
+import { ToolConfig } from "@plucky-ai/chat-sdk";
+
+//#region ../loader-types/dist/index.d.mts
+//#region src/index.d.ts
+/**
+ * Configuration options for initializing the Plucky chat widget.
+ *
+ * Pass this object to {@link Plucky} (chat-sdk) or {@link useChat} (React)
+ * to embed the widget on the page.
+ *
+ * @example
+ * ```ts
+ * Plucky({
+ *   appId: 'my-app-id',
+ *   baseUrl: 'https://widget.plucky.ai',
+ *   user: { id: 'user-123', name: 'Jane Doe', email: 'jane@example.com' },
+ *   mode: 'push',
+ *   autoOpen: false,
+ * })
+ * ```
+ */
+type PluckySettingsParams = {
+  /**
+   * Base URL of the Plucky widget server (e.g., `'https://widget.plucky.ai'`).
+   * The loader script and widget iframe are served from this origin.
+   */
+  baseUrl: string;
+  /**
+   * Unique identifier for your Plucky app, obtained from the Plucky dashboard.
+   */
+  appId: string;
+  /**
+   * Optional user identification and metadata. When provided, the widget
+   * associates conversations with this user and displays their name/email
+   * in the dashboard.
+   *
+   * @example
+   * ```ts
+   * user: {
+   *   id: 'user-123',
+   *   name: 'Jane Doe',
+   *   email: 'jane@example.com',
+   *   createdAt: '2024-01-15T00:00:00Z',
+   *   metadata: { plan: 'pro', company: 'Acme' },
+   * }
+   * ```
+   */
+  user?: {
+    /** Unique identifier for the user in your system. */id: string; /** Display name shown in the Plucky dashboard. */
+    name?: string; /** Email address shown in the Plucky dashboard. */
+    email?: string;
+    /**
+     * ISO 8601 timestamp of when the user was created in your system.
+     * Used for analytics and segmentation in the dashboard.
+     */
+    createdAt?: string;
+    /**
+     * Arbitrary key-value metadata attached to the user.
+     * Visible in the Plucky dashboard and can be used for filtering.
+     */
+    metadata?: Record<string, any>;
+  };
+  /**
+   * Built-in system tools to enable for the AI assistant.
+   *
+   * @example
+   * ```ts
+   * systemTools: { readPage: true }
+   * ```
+   */
+  systemTools?: {
+    /**
+     * When `true`, enables the `readPage` system tool that allows the AI
+     * assistant to read the content of the current page. Defaults to `false`.
+     */
+    readPage?: boolean;
+  };
+  /**
+   * Display mode for the widget.
+   * - `'push'` (default) — fixed sidebar that pushes page content.
+   * - `'overlay'` — fixed sidebar that overlays page content.
+   * - `'inline'` — widget is mounted inside a container element specified by {@link containerId}.
+   */
+  mode?: 'push' | 'overlay' | 'inline';
+  /**
+   * The `id` of the container element to mount the widget into.
+   * Required when `mode` is `'inline'`. The element must exist in the DOM
+   * before calling init / mounting the widget.
+   */
+  containerId?: string;
+  /**
+   * Whether to auto-open the widget when it loads. Defaults to `true`.
+   * Set to `false` to start with the widget closed.
+   */
+  autoOpen?: boolean;
+  /**
+   * Whether to show a floating trigger button in the bottom-right corner.
+   * When clicked, the trigger button toggles the widget open/closed.
+   * Defaults to `false`.
+   */
+  triggerButton?: boolean;
+  /**
+   * URL patterns the widget should be **visible** on.
+   * Uses Chrome-style match patterns (e.g. `'https://*.example.com/app/*'`).
+   * When omitted or empty, every page is included by default.
+   * If a URL matches both `include` and `exclude`, `exclude` wins.
+   */
+  include?: string[];
+  /**
+   * URL patterns the widget should be **hidden** on.
+   * Uses Chrome-style match patterns (e.g. `'https://example.com/login'`).
+   * Takes priority over `include` — if a URL matches both, it is excluded.
+   * The widget stays mounted but is hidden on excluded pages.
+   */
+  exclude?: string[];
+};
+/**
+ * Serializable subset of a tool definition sent across the iframe boundary.
+ * This does not include the callback — only metadata used by the widget
+ * to display tool information and validate inputs.
+ *
+ * @see {@link ToolConfig} for the full tool definition including the callback.
+ */
+/**
+ * Return type for a tool callback. Either a plain string (used as the tool
+ * result content) or an object with `content` and an optional `successText`
+ * override.
+ *
+ * @example
+ * ```ts
+ * // Simple string result
+ * cb: async ({ city }) => `The weather in ${city} is sunny.`
+ *
+ * // Object result with custom success text
+ * cb: async ({ city }) => ({
+ *   content: JSON.stringify({ temp: 72, condition: 'sunny' }),
+ *   successText: `Fetched weather for ${city}`,
+ * })
+ * ```
+ */
+type ToolCallbackResult = string | {
+  /** The content returned to the AI assistant as the tool result. */content: string; /** Optional override for the success text displayed in the chat UI after the tool completes. */
+  successText?: string;
+};
+/**
+ * Full tool definition including the callback function.
+ *
+ * Register tools with {@link addTools} (chat-sdk) or {@link useTools} (React)
+ * to let the AI assistant invoke custom functions on the host page.
+ *
+ * @typeParam TInputSchema - The type of the input schema (Zod object or plain JSON Schema).
+ *   When a Zod schema is provided, the callback `input` parameter is automatically
+ *   inferred from it.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * const weatherTool: ToolConfig = {
+ *   name: 'getWeather',
+ *   description: 'Fetches current weather for a city',
+ *   inputSchema: z.object({
+ *     city: z.string().describe('City name'),
+ *   }),
+ *   cb: async ({ city }) => `The weather in ${city} is sunny.`,
+ * }
+ * ```
+ */
+//#endregion
+//#region src/types.d.ts
+/**
+ * Parameters for the {@link useChat} hook.
+ *
+ * This is an alias for {@link PluckySettingsParams} — see that type for
+ * the full list of configuration properties.
+ *
+ * @example
+ * ```tsx
+ * useChat({
+ *   appId: 'your-app-id',
+ *   baseUrl: 'https://widget.plucky.ai',
+ *   user: { id: 'user-123', name: 'Jane' },
+ * })
+ * ```
+ */
+type UseChatParams = PluckySettingsParams;
+/**
+ * Parameters for the {@link useTools} hook.
+ *
+ * @typeParam TContext - Type of the shared context object passed as the second
+ *   argument to every tool callback. Defaults to `Record<string, unknown>`.
+ *
+ * @example
+ * ```tsx
+ * useTools({
+ *   context: { apiClient, currentUser },
+ *   tools: [
+ *     {
+ *       name: 'getOrders',
+ *       description: 'Fetches recent orders for the user',
+ *       cb: async (input, ctx) => {
+ *         const orders = await ctx.apiClient.getOrders(ctx.currentUser.id)
+ *         return JSON.stringify(orders)
+ *       },
+ *     },
+ *   ],
+ * })
+ * ```
+ */
+type UseToolsParams<TContext = Record<string, unknown>> = {
+  /**
+   * Shared context object passed as the second argument to every tool callback.
+   * Use this to give tools access to React state, API clients, or other
+   * dependencies without closing over stale values.
+   *
+   * The context ref is kept up-to-date on every render, so callbacks always
+   * receive the latest value.
+   */
+  context?: TContext;
+  /**
+   * Array of tool definitions to register with the Plucky widget.
+   *
+   * Each tool extends {@link ToolConfig} but replaces the `cb` callback
+   * signature to include the `context` as a second parameter.
+   *
+   * Tools are automatically registered on mount and unregistered on unmount
+   * or when the `tools` array reference changes.
+   *
+   * | Property | Type | Description |
+   * |---|---|---|
+   * | `name` | `string` | **(required)** Unique tool name. |
+   * | `description` | `string` | **(required)** Tells the AI when to use this tool. |
+   * | `inputSchema` | `ZodObject \| Record<string, unknown>` | Schema describing expected input. |
+   * | `cb` | `(input, context) => ToolCallbackResult` | Callback invoked by the AI. Receives `context` as second arg. |
+   * | `defaultLoadingText` | `string \| null` | Text shown while the tool runs. |
+   * | `defaultSuccessText` | `string \| null` | Text shown on completion. |
+   */
+  tools: Array<Omit<ToolConfig, 'cb'> & {
+    /**
+     * Callback executed when the AI assistant invokes this tool.
+     *
+     * @param input - The input arguments from the AI assistant.
+     * @param context - The current value of {@link UseToolsParams.context}.
+     * @returns The tool result — either a plain string or `{ content, successText? }`.
+     */
+    cb: (input: Record<string, unknown>, context: TContext) => Promise<ToolCallbackResult> | ToolCallbackResult;
+  }>;
+};
+//#endregion
+//#region src/hooks/useChat.d.ts
+/**
+ * React hook that initializes the Plucky chat widget.
+ *
+ * Calls {@link Plucky} on mount to inject the widget scripts into the page.
+ * The widget is only attached once — subsequent renders with different params
+ * will not re-initialize it.
+ *
+ * Pair with {@link useTools} to register custom tools the AI assistant can invoke.
+ *
+ * @param params - Widget configuration. Required fields are `appId` and `baseUrl`.
+ *   See {@link UseChatParams} (alias for `PluckySettingsParams`) for the full
+ *   list of options including `user`, `mode`, `autoOpen`, and `triggerButton`.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from '@plucky-ai/react'
+ *
+ * function App() {
+ *   useChat({
+ *     appId: 'your-app-id',
+ *     baseUrl: 'https://widget.plucky.ai',
+ *     user: { id: 'user-123', name: 'Jane' },
+ *     mode: 'push',
+ *     autoOpen: false,
+ *   })
+ *
+ *   return <div>My App</div>
+ * }
+ * ```
+ *
+ * @example With inline mode
+ * ```tsx
+ * function ChatPage() {
+ *   useChat({
+ *     appId: 'your-app-id',
+ *     baseUrl: 'https://widget.plucky.ai',
+ *     mode: 'inline',
+ *     containerId: 'chat-container',
+ *   })
+ *
+ *   return <div id="chat-container" style={{ height: '600px' }} />
+ * }
+ * ```
+ */
+declare function useChat(params: UseChatParams): void;
+//#endregion
+//#region src/hooks/useTools.d.ts
+/**
+ * React hook that registers custom tools the AI assistant can invoke.
+ *
+ * Tools are registered on mount (via {@link addTools}) and automatically
+ * unregistered on unmount or when the `tools` array reference changes.
+ *
+ * The `context` parameter is kept up-to-date via a ref, so tool callbacks
+ * always receive the latest value even if React state has changed since
+ * the tools were registered.
+ *
+ * @typeParam TContext - Type of the shared context object passed to every
+ *   tool callback as the second argument.
+ *
+ * @param params - Tool registration parameters.
+ * @param params.tools - Array of tool definitions. Each must have `name`,
+ *   `description`, and `cb`. Optionally include `inputSchema` (Zod or JSON Schema),
+ *   `defaultLoadingText`, and `defaultSuccessText`.
+ *   See {@link UseToolsParams} for the full type definition.
+ * @param params.context - Shared context passed as the second argument to every
+ *   tool callback. Useful for injecting API clients, user state, or other
+ *   dependencies that may change between renders.
+ *
+ * @example
+ * ```tsx
+ * import { useChat, useTools } from '@plucky-ai/react'
+ * import { z } from 'zod'
+ *
+ * function App() {
+ *   useChat({ appId: 'my-app', baseUrl: 'https://widget.plucky.ai' })
+ *
+ *   const [user] = useState({ id: 'user-123' })
+ *   const apiClient = useApiClient()
+ *
+ *   useTools({
+ *     context: { apiClient, user },
+ *     tools: [
+ *       {
+ *         name: 'getOrders',
+ *         description: 'Fetches recent orders for the current user',
+ *         inputSchema: z.object({
+ *           limit: z.number().optional().describe('Max results to return'),
+ *         }),
+ *         cb: async ({ limit }, ctx) => {
+ *           const orders = await ctx.apiClient.getOrders(ctx.user.id, { limit })
+ *           return JSON.stringify(orders)
+ *         },
+ *       },
+ *     ],
+ *   })
+ *
+ *   return <div>My App</div>
+ * }
+ * ```
+ */
+declare function useTools<TContext = Record<string, unknown>>(params: UseToolsParams<TContext>): void;
+//#endregion
+export { UseChatParams, UseToolsParams, useChat, useTools };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,140 @@
+import { Plucky, addTools, removeTools } from "@plucky-ai/chat-sdk";
+import { useEffect, useMemo, useRef } from "react";
+//#region src/hooks/useChat.ts
+/**
+* React hook that initializes the Plucky chat widget.
+*
+* Calls {@link Plucky} on mount to inject the widget scripts into the page.
+* The widget is only attached once — subsequent renders with different params
+* will not re-initialize it.
+*
+* Pair with {@link useTools} to register custom tools the AI assistant can invoke.
+*
+* @param params - Widget configuration. Required fields are `appId` and `baseUrl`.
+*   See {@link UseChatParams} (alias for `PluckySettingsParams`) for the full
+*   list of options including `user`, `mode`, `autoOpen`, and `triggerButton`.
+*
+* @example
+* ```tsx
+* import { useChat } from '@plucky-ai/react'
+*
+* function App() {
+*   useChat({
+*     appId: 'your-app-id',
+*     baseUrl: 'https://widget.plucky.ai',
+*     user: { id: 'user-123', name: 'Jane' },
+*     mode: 'push',
+*     autoOpen: false,
+*   })
+*
+*   return <div>My App</div>
+* }
+* ```
+*
+* @example With inline mode
+* ```tsx
+* function ChatPage() {
+*   useChat({
+*     appId: 'your-app-id',
+*     baseUrl: 'https://widget.plucky.ai',
+*     mode: 'inline',
+*     containerId: 'chat-container',
+*   })
+*
+*   return <div id="chat-container" style={{ height: '600px' }} />
+* }
+* ```
+*/
+function useChat(params) {
+	useEffect(() => {
+		Plucky(params);
+	}, [params]);
+}
+//#endregion
+//#region src/hooks/useTools.ts
+function useLatest(value) {
+	const ref = useRef(value);
+	useEffect(() => {
+		ref.current = value;
+	}, [value]);
+	return ref;
+}
+/**
+* React hook that registers custom tools the AI assistant can invoke.
+*
+* Tools are registered on mount (via {@link addTools}) and automatically
+* unregistered on unmount or when the `tools` array reference changes.
+*
+* The `context` parameter is kept up-to-date via a ref, so tool callbacks
+* always receive the latest value even if React state has changed since
+* the tools were registered.
+*
+* @typeParam TContext - Type of the shared context object passed to every
+*   tool callback as the second argument.
+*
+* @param params - Tool registration parameters.
+* @param params.tools - Array of tool definitions. Each must have `name`,
+*   `description`, and `cb`. Optionally include `inputSchema` (Zod or JSON Schema),
+*   `defaultLoadingText`, and `defaultSuccessText`.
+*   See {@link UseToolsParams} for the full type definition.
+* @param params.context - Shared context passed as the second argument to every
+*   tool callback. Useful for injecting API clients, user state, or other
+*   dependencies that may change between renders.
+*
+* @example
+* ```tsx
+* import { useChat, useTools } from '@plucky-ai/react'
+* import { z } from 'zod'
+*
+* function App() {
+*   useChat({ appId: 'my-app', baseUrl: 'https://widget.plucky.ai' })
+*
+*   const [user] = useState({ id: 'user-123' })
+*   const apiClient = useApiClient()
+*
+*   useTools({
+*     context: { apiClient, user },
+*     tools: [
+*       {
+*         name: 'getOrders',
+*         description: 'Fetches recent orders for the current user',
+*         inputSchema: z.object({
+*           limit: z.number().optional().describe('Max results to return'),
+*         }),
+*         cb: async ({ limit }, ctx) => {
+*           const orders = await ctx.apiClient.getOrders(ctx.user.id, { limit })
+*           return JSON.stringify(orders)
+*         },
+*       },
+*     ],
+*   })
+*
+*   return <div>My App</div>
+* }
+* ```
+*/
+function useTools(params) {
+	const contextRef = useLatest(params.context);
+	const { tools } = params;
+	const wrappedTools = useMemo(() => tools.map((tool) => {
+		const originalCb = tool.cb;
+		return {
+			...tool,
+			cb: async (input) => {
+				if (!contextRef.current) return "Tool not yet loaded.";
+				return originalCb(input, contextRef.current);
+			}
+		};
+	}), [tools, contextRef]);
+	useEffect(() => {
+		if (!tools || tools.length === 0) return;
+		addTools(wrappedTools);
+		return () => {
+			removeTools(wrappedTools.map((tool) => tool.name));
+		};
+	}, [wrappedTools]);
+}
+//#endregion
+export { useChat, useTools };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/hooks/useChat.ts","../src/hooks/useTools.ts"],"sourcesContent":["import { UseChatParams } from '@/types'\nimport { Plucky } from '@plucky-ai/chat-sdk'\nimport { useEffect } from 'react'\n\n/**\n * React hook that initializes the Plucky chat widget.\n *\n * Calls {@link Plucky} on mount to inject the widget scripts into the page.\n * The widget is only attached once — subsequent renders with different params\n * will not re-initialize it.\n *\n * Pair with {@link useTools} to register custom tools the AI assistant can invoke.\n *\n * @param params - Widget configuration. Required fields are `appId` and `baseUrl`.\n *   See {@link UseChatParams} (alias for `PluckySettingsParams`) for the full\n *   list of options including `user`, `mode`, `autoOpen`, and `triggerButton`.\n *\n * @example\n * ```tsx\n * import { useChat } from '@plucky-ai/react'\n *\n * function App() {\n *   useChat({\n *     appId: 'your-app-id',\n *     baseUrl: 'https://widget.plucky.ai',\n *     user: { id: 'user-123', name: 'Jane' },\n *     mode: 'push',\n *     autoOpen: false,\n *   })\n *\n *   return <div>My App</div>\n * }\n * ```\n *\n * @example With inline mode\n * ```tsx\n * function ChatPage() {\n *   useChat({\n *     appId: 'your-app-id',\n *     baseUrl: 'https://widget.plucky.ai',\n *     mode: 'inline',\n *     containerId: 'chat-container',\n *   })\n *\n *   return <div id=\"chat-container\" style={{ height: '600px' }} />\n * }\n * ```\n */\nexport function useChat(params: UseChatParams) {\n  useEffect(() => {\n    Plucky(params)\n  }, [params])\n}\n","import { UseToolsParams } from '@/types'\nimport { addTools, removeTools } from '@plucky-ai/chat-sdk'\nimport { useEffect, useMemo, useRef } from 'react'\nfunction useLatest<T>(value: T) {\n  const ref = useRef(value)\n  useEffect(() => {\n    ref.current = value\n  }, [value])\n  return ref\n}\n\n/**\n * React hook that registers custom tools the AI assistant can invoke.\n *\n * Tools are registered on mount (via {@link addTools}) and automatically\n * unregistered on unmount or when the `tools` array reference changes.\n *\n * The `context` parameter is kept up-to-date via a ref, so tool callbacks\n * always receive the latest value even if React state has changed since\n * the tools were registered.\n *\n * @typeParam TContext - Type of the shared context object passed to every\n *   tool callback as the second argument.\n *\n * @param params - Tool registration parameters.\n * @param params.tools - Array of tool definitions. Each must have `name`,\n *   `description`, and `cb`. Optionally include `inputSchema` (Zod or JSON Schema),\n *   `defaultLoadingText`, and `defaultSuccessText`.\n *   See {@link UseToolsParams} for the full type definition.\n * @param params.context - Shared context passed as the second argument to every\n *   tool callback. Useful for injecting API clients, user state, or other\n *   dependencies that may change between renders.\n *\n * @example\n * ```tsx\n * import { useChat, useTools } from '@plucky-ai/react'\n * import { z } from 'zod'\n *\n * function App() {\n *   useChat({ appId: 'my-app', baseUrl: 'https://widget.plucky.ai' })\n *\n *   const [user] = useState({ id: 'user-123' })\n *   const apiClient = useApiClient()\n *\n *   useTools({\n *     context: { apiClient, user },\n *     tools: [\n *       {\n *         name: 'getOrders',\n *         description: 'Fetches recent orders for the current user',\n *         inputSchema: z.object({\n *           limit: z.number().optional().describe('Max results to return'),\n *         }),\n *         cb: async ({ limit }, ctx) => {\n *           const orders = await ctx.apiClient.getOrders(ctx.user.id, { limit })\n *           return JSON.stringify(orders)\n *         },\n *       },\n *     ],\n *   })\n *\n *   return <div>My App</div>\n * }\n * ```\n */\nexport function useTools<TContext = Record<string, unknown>>(params: UseToolsParams<TContext>) {\n  const contextRef = useLatest(params.context)\n\n  const { tools } = params\n  const wrappedTools = useMemo(\n    () =>\n      tools.map((tool) => {\n        const originalCb = tool.cb\n        return {\n          ...tool,\n          cb: async (input: Record<string, unknown>) => {\n            if (!contextRef.current) return 'Tool not yet loaded.'\n            return originalCb(input, contextRef.current)\n          },\n        }\n      }),\n    [tools, contextRef],\n  )\n\n  useEffect(() => {\n    if (!tools || tools.length === 0) return\n    addTools(wrappedTools)\n    return () => {\n      removeTools(wrappedTools.map((tool) => tool.name))\n    }\n  }, [wrappedTools])\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,QAAQ,QAAuB;AAC7C,iBAAgB;AACd,SAAO,OAAO;IACb,CAAC,OAAO,CAAC;;;;AChDd,SAAS,UAAa,OAAU;CAC9B,MAAM,MAAM,OAAO,MAAM;AACzB,iBAAgB;AACd,MAAI,UAAU;IACb,CAAC,MAAM,CAAC;AACX,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDT,SAAgB,SAA6C,QAAkC;CAC7F,MAAM,aAAa,UAAU,OAAO,QAAQ;CAE5C,MAAM,EAAE,UAAU;CAClB,MAAM,eAAe,cAEjB,MAAM,KAAK,SAAS;EAClB,MAAM,aAAa,KAAK;AACxB,SAAO;GACL,GAAG;GACH,IAAI,OAAO,UAAmC;AAC5C,QAAI,CAAC,WAAW,QAAS,QAAO;AAChC,WAAO,WAAW,OAAO,WAAW,QAAQ;;GAE/C;GACD,EACJ,CAAC,OAAO,WAAW,CACpB;AAED,iBAAgB;AACd,MAAI,CAAC,SAAS,MAAM,WAAW,EAAG;AAClC,WAAS,aAAa;AACtB,eAAa;AACX,eAAY,aAAa,KAAK,SAAS,KAAK,KAAK,CAAC;;IAEnD,CAAC,aAAa,CAAC"}

package/dist/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@plucky-ai/react",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
     }
   },

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "@plucky-ai/react",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
     }
   },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "dependencies": {
     "react": "^19.2.3",
     "zod": "^4.1.11",
-    "@plucky-ai/chat-sdk": "^0.6.0"
+    "@plucky-ai/chat-sdk": "^0.7.0"
   },
   "devDependencies": {
     "@types/react": "19.1.13",
-    "tsdown": "^0.15.12",
+    "tsdown": "^0.21.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "@plucky-ai/loader-types": "^0.4.0"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
   "scripts": {
     "build:watch": "pnpm exec tsdown --watch ./src",
     "build": "pnpm exec tsdown --config tsdown.config.ts"

package/dist/index.d.ts

@@ -1,20 +0,0 @@
-import { ToolConfig } from "@plucky-ai/chat-sdk";
-import { PluckySettingsParams, ToolCallbackResult } from "@plucky-ai/loader-types";
-
-//#region src/types.d.ts
-type UseChatParams = PluckySettingsParams;
-type UseToolsParams<TContext = Record<string, unknown>> = {
-  context?: TContext;
-  tools: Array<Omit<ToolConfig, 'cb'> & {
-    cb: (input: Record<string, unknown>, context: TContext) => Promise<ToolCallbackResult> | ToolCallbackResult;
-  }>;
-};
-//#endregion
-//#region src/hooks/useChat.d.ts
-declare function useChat(params: UseChatParams): void;
-//#endregion
-//#region src/hooks/useTools.d.ts
-declare function useTools<TContext = Record<string, unknown>>(params: UseToolsParams<TContext>): void;
-//#endregion
-export { UseChatParams, UseToolsParams, useChat, useTools };
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,44 +0,0 @@
-import { Plucky, addTools, removeTools } from "@plucky-ai/chat-sdk";
-import { useEffect, useMemo, useRef } from "react";
-
-//#region src/hooks/useChat.ts
-function useChat(params) {
-	useEffect(() => {
-		Plucky(params);
-	}, [params]);
-}
-
-//#endregion
-//#region src/hooks/useTools.ts
-function useLatest(value) {
-	const ref = useRef(value);
-	useEffect(() => {
-		ref.current = value;
-	}, [value]);
-	return ref;
-}
-function useTools(params) {
-	const contextRef = useLatest(params.context);
-	const { tools } = params;
-	const wrappedTools = useMemo(() => tools.map((tool) => {
-		const originalCb = tool.cb;
-		return {
-			...tool,
-			cb: async (input) => {
-				if (!contextRef.current) return "Tool not yet loaded.";
-				return originalCb(input, contextRef.current);
-			}
-		};
-	}), [tools, contextRef]);
-	useEffect(() => {
-		if (!tools || tools.length === 0) return;
-		addTools(wrappedTools);
-		return () => {
-			removeTools(wrappedTools.map((tool) => tool.name));
-		};
-	}, [wrappedTools]);
-}
-
-//#endregion
-export { useChat, useTools };
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/hooks/useChat.ts","../src/hooks/useTools.ts"],"sourcesContent":["import { UseChatParams } from '@/types'\nimport { Plucky } from '@plucky-ai/chat-sdk'\nimport { useEffect } from 'react'\n\nexport function useChat(params: UseChatParams) {\n  useEffect(() => {\n    Plucky(params)\n  }, [params])\n}\n","import { UseToolsParams } from '@/types'\nimport { addTools, removeTools } from '@plucky-ai/chat-sdk'\nimport { useEffect, useMemo, useRef } from 'react'\nfunction useLatest<T>(value: T) {\n  const ref = useRef(value)\n  useEffect(() => {\n    ref.current = value\n  }, [value])\n  return ref\n}\n\nexport function useTools<TContext = Record<string, unknown>>(\n  params: UseToolsParams<TContext>,\n) {\n  const contextRef = useLatest(params.context)\n\n  const { tools } = params\n  const wrappedTools = useMemo(\n    () =>\n      tools.map((tool) => {\n        const originalCb = tool.cb\n        return {\n          ...tool,\n          cb: async (input: Record<string, unknown>) => {\n            if (!contextRef.current) return 'Tool not yet loaded.'\n            return originalCb(input, contextRef.current)\n          },\n        }\n      }),\n    [tools, contextRef],\n  )\n\n  useEffect(() => {\n    if (!tools || tools.length === 0) return\n    addTools(wrappedTools)\n    return () => {\n      removeTools(wrappedTools.map((tool) => tool.name))\n    }\n  }, [wrappedTools])\n}\n"],"mappings":";;;;AAIA,SAAgB,QAAQ,QAAuB;AAC7C,iBAAgB;AACd,SAAO,OAAO;IACb,CAAC,OAAO,CAAC;;;;;ACJd,SAAS,UAAa,OAAU;CAC9B,MAAM,MAAM,OAAO,MAAM;AACzB,iBAAgB;AACd,MAAI,UAAU;IACb,CAAC,MAAM,CAAC;AACX,QAAO;;AAGT,SAAgB,SACd,QACA;CACA,MAAM,aAAa,UAAU,OAAO,QAAQ;CAE5C,MAAM,EAAE,UAAU;CAClB,MAAM,eAAe,cAEjB,MAAM,KAAK,SAAS;EAClB,MAAM,aAAa,KAAK;AACxB,SAAO;GACL,GAAG;GACH,IAAI,OAAO,UAAmC;AAC5C,QAAI,CAAC,WAAW,QAAS,QAAO;AAChC,WAAO,WAAW,OAAO,WAAW,QAAQ;;GAE/C;GACD,EACJ,CAAC,OAAO,WAAW,CACpB;AAED,iBAAgB;AACd,MAAI,CAAC,SAAS,MAAM,WAAW,EAAG;AAClC,WAAS,aAAa;AACtB,eAAa;AACX,eAAY,aAAa,KAAK,SAAS,KAAK,KAAK,CAAC;;IAEnD,CAAC,aAAa,CAAC"}