@aizu-chat/react 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -997,6 +997,26 @@ var useChatContext = () => {
 
 // src/sdk/client.ts
 var AizuClient = class {
+  /**
+   * Creates a new AizuClient instance
+   *
+   * @param config - Configuration options for the client
+   * @param config.hostUrl - The base URL of the Aizu API (e.g., 'https://api.aizu.chat')
+   * @param config.apiKey - Your API key for authentication
+   * @param config.timeout - Request timeout in milliseconds (default: 30000)
+   *
+   * @throws {Error} If hostUrl is not a non-empty string
+   * @throws {Error} If apiKey is not a non-empty string
+   *
+   * @example
+   * ```typescript
+   * const client = new AizuClient({
+   *   hostUrl: 'https://api.aizu.chat',
+   *   apiKey: 'sk_test_123456',
+   *   timeout: 60000 // 60 seconds
+   * });
+   * ```
+   */
   constructor(config) {
     const { hostUrl, apiKey, timeout } = config;
     if (typeof hostUrl !== "string" || hostUrl.trim().length === 0) {
@@ -1013,6 +1033,26 @@ var AizuClient = class {
     this.apiKey = apiKey;
     this.timeout = timeout != null ? timeout : 3e4;
   }
+  /**
+   * Internal method for making HTTP requests to the API
+   *
+   * Handles timeout management, abort signal combination, and error handling.
+   * Supports both user-initiated cancellation and automatic timeout.
+   *
+   * @template T - The expected response type
+   * @template TBody - The request body type
+   *
+   * @param path - API endpoint path (e.g., '/chat/query')
+   * @param options - Request options including body and signal
+   *
+   * @returns Promise resolving to the API response
+   *
+   * @throws {Error} "Request cancelled by user" - If the request is cancelled via AbortSignal
+   * @throws {Error} "Request timeout: The server took too long to respond" - If the request exceeds the timeout
+   * @throws {Error} "API Error: {status} {statusText}" - If the API returns an error status
+   *
+   * @private
+   */
   request(_0) {
     return __async(this, arguments, function* (path, options = {}) {
       const url = `${this.hostUrl}${path}`;
@@ -1083,6 +1123,64 @@ var AizuClient = class {
       }
     });
   }
+  /**
+   * Sends a chat query to the Aizu API
+   *
+   * @param params - Chat request parameters
+   * @param params.query - The user's message/question (required, non-empty)
+   * @param params.conversationId - Optional conversation ID to continue an existing conversation
+   * @param options - Additional options
+   * @param options.signal - Optional AbortSignal to cancel the request
+   *
+   * @returns Promise resolving to the chat response from the API
+   *
+   * @throws {Error} "Query is required" - If query is empty or whitespace only
+   * @throws {Error} "Request cancelled by user" - If the request is cancelled
+   * @throws {Error} "Request timeout: The server took too long to respond" - If the request times out
+   * @throws {Error} "API Error: {status} {statusText}" - If the API returns an error
+   *
+   * @example
+   * ```typescript
+   * // Simple query
+   * const response = await client.chat({
+   *   query: 'What is the weather today?'
+   * });
+   * console.log(response.answer);
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Continue conversation
+   * const response1 = await client.chat({
+   *   query: 'What is the weather today?'
+   * });
+   *
+   * const response2 = await client.chat({
+   *   query: 'And tomorrow?',
+   *   conversationId: response1.conversationId
+   * });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // With cancellation support
+   * const controller = new AbortController();
+   *
+   * const promise = client.chat(
+   *   { query: 'Long running query...' },
+   *   { signal: controller.signal }
+   * );
+   *
+   * // Cancel after 5 seconds
+   * setTimeout(() => controller.abort(), 5000);
+   *
+   * try {
+   *   const response = await promise;
+   * } catch (error) {
+   *   console.error('Request was cancelled:', error);
+   * }
+   * ```
+   */
   chat(params, options) {
     return __async(this, null, function* () {
       if (!params.query.trim()) {
@@ -1201,12 +1299,15 @@ import {
 
 // src/hooks/use-keyboard.ts
 import { useCallback as useCallback6, useEffect as useEffect3, useRef as useRef4, useState as useState4 } from "react";
+var MAX_LENGTH = 300;
 var useKeyboard = ({ userMessages, isLoading, onSend }) => {
   const [value, setValue] = useState4("");
   const [historyIndex, setHistoryIndex] = useState4((userMessages == null ? void 0 : userMessages.length) || 0);
   const textareaRef = useRef4(null);
   const handleChange = (e) => {
-    setValue(e.target.value);
+    const currentValue = e.target.value;
+    const truncatedValue = currentValue.length > MAX_LENGTH ? currentValue.slice(0, MAX_LENGTH) : currentValue;
+    setValue(truncatedValue);
   };
   const handleSubmit = (e) => {
     e.preventDefault();
@@ -1230,17 +1331,21 @@ var useKeyboard = ({ userMessages, isLoading, onSend }) => {
     if (key === "ArrowUp") {
       e.preventDefault();
       if (userMessages.length === 0) return;
-      const next = historyIndex === userMessages.length ? userMessages.length - 1 : Math.max(0, historyIndex - 1);
-      setHistoryIndex(next);
-      setValue((_b = (_a = userMessages[next]) == null ? void 0 : _a.text) != null ? _b : "");
+      const nextIndex = historyIndex === userMessages.length ? userMessages.length - 1 : Math.max(0, historyIndex - 1);
+      setHistoryIndex(nextIndex);
+      const nextValue = (_b = (_a = userMessages[nextIndex]) == null ? void 0 : _a.text) != null ? _b : "";
+      const truncatedValue = nextValue.slice(0, MAX_LENGTH);
+      setValue(truncatedValue);
       return;
     }
     if (key === "ArrowDown") {
       e.preventDefault();
       if (userMessages.length === 0) return;
-      const next = historyIndex >= userMessages.length - 1 ? userMessages.length : historyIndex + 1;
-      setHistoryIndex(next);
-      setValue(next === userMessages.length ? "" : (_d = (_c = userMessages[next]) == null ? void 0 : _c.text) != null ? _d : "");
+      const nextIndex = historyIndex >= userMessages.length - 1 ? userMessages.length : historyIndex + 1;
+      setHistoryIndex(nextIndex);
+      const nextValue = nextIndex === userMessages.length ? "" : (_d = (_c = userMessages[nextIndex]) == null ? void 0 : _c.text) != null ? _d : "";
+      const truncatedValue = nextValue.slice(0, MAX_LENGTH);
+      setValue(truncatedValue);
     }
   };
   const adjustTextareaHeight = useCallback6(() => {

package/dist/sdk.d.mts

@@ -0,0 +1,55 @@
+interface AizuClientConfig {
+    hostUrl: string;
+    apiKey: string;
+    timeout?: number;
+}
+interface ChatRequest {
+    query: string;
+    thread_id?: string;
+    resource_id?: string;
+}
+interface ChatResponse {
+    thread_id: string;
+    resource_id: string;
+    response: string;
+    products?: Product[];
+    type?: TypeResponse;
+}
+interface Product {
+    product_id: string;
+    spu?: string;
+    sku: string;
+    title: string;
+    description: string;
+    handle: string;
+    price: number;
+    stock: number;
+    thumbnail?: string | null;
+    rating?: number;
+    review_count?: number;
+    estimated_delivery_days?: number;
+    similarity?: number;
+}
+declare enum TypeResponse {
+    SUGGEST_PRODUCTS = "suggest_products",
+    REQUEST_CLARIFICATION = "request_clarification",
+    START_SHOPPING = "start_shopping"
+}
+
+declare class AizuClient {
+    private hostUrl;
+    private apiKey;
+    private timeout;
+    constructor(config: AizuClientConfig);
+    private request;
+    chat(params: ChatRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<ChatResponse>;
+}
+declare const createAizuClient: ({ hostUrl, apiKey, timeout, }: {
+    hostUrl: string;
+    apiKey: string;
+    timeout?: number;
+}) => AizuClient;
+
+export { AizuClient, type AizuClientConfig, type ChatRequest, type ChatResponse, type Product, TypeResponse, createAizuClient };

package/dist/sdk.d.ts

@@ -0,0 +1,55 @@
+interface AizuClientConfig {
+    hostUrl: string;
+    apiKey: string;
+    timeout?: number;
+}
+interface ChatRequest {
+    query: string;
+    thread_id?: string;
+    resource_id?: string;
+}
+interface ChatResponse {
+    thread_id: string;
+    resource_id: string;
+    response: string;
+    products?: Product[];
+    type?: TypeResponse;
+}
+interface Product {
+    product_id: string;
+    spu?: string;
+    sku: string;
+    title: string;
+    description: string;
+    handle: string;
+    price: number;
+    stock: number;
+    thumbnail?: string | null;
+    rating?: number;
+    review_count?: number;
+    estimated_delivery_days?: number;
+    similarity?: number;
+}
+declare enum TypeResponse {
+    SUGGEST_PRODUCTS = "suggest_products",
+    REQUEST_CLARIFICATION = "request_clarification",
+    START_SHOPPING = "start_shopping"
+}
+
+declare class AizuClient {
+    private hostUrl;
+    private apiKey;
+    private timeout;
+    constructor(config: AizuClientConfig);
+    private request;
+    chat(params: ChatRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<ChatResponse>;
+}
+declare const createAizuClient: ({ hostUrl, apiKey, timeout, }: {
+    hostUrl: string;
+    apiKey: string;
+    timeout?: number;
+}) => AizuClient;
+
+export { AizuClient, type AizuClientConfig, type ChatRequest, type ChatResponse, type Product, TypeResponse, createAizuClient };

package/dist/sdk.js

@@ -0,0 +1,200 @@
+'use client'
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/sdk/index.ts
+var sdk_exports = {};
+__export(sdk_exports, {
+  AizuClient: () => AizuClient,
+  TypeResponse: () => TypeResponse,
+  createAizuClient: () => createAizuClient
+});
+module.exports = __toCommonJS(sdk_exports);
+
+// src/sdk/client.ts
+var AizuClient = class {
+  constructor(config) {
+    const { hostUrl, apiKey, timeout } = config;
+    if (typeof hostUrl !== "string" || hostUrl.trim().length === 0) {
+      throw new Error(
+        "Invalid AizuClient configuration: 'hostUrl' must be a non-empty string."
+      );
+    }
+    if (typeof apiKey !== "string" || apiKey.trim().length === 0) {
+      throw new Error(
+        "Invalid AizuClient configuration: 'apiKey' must be a non-empty string."
+      );
+    }
+    this.hostUrl = hostUrl;
+    this.apiKey = apiKey;
+    this.timeout = timeout != null ? timeout : 3e4;
+  }
+  request(_0) {
+    return __async(this, arguments, function* (path, options = {}) {
+      const url = `${this.hostUrl}${path}`;
+      const _a = options, { body, signal: externalSignal } = _a, restOptions = __objRest(_a, ["body", "signal"]);
+      const timeoutController = new AbortController();
+      const timeoutId = setTimeout(() => timeoutController.abort(), this.timeout);
+      let abortController = null;
+      let abortHandler = null;
+      let abortReason = null;
+      const combinedSignal = externalSignal ? (() => {
+        abortController = new AbortController();
+        const userAbortHandler = () => {
+          if (!abortReason) abortReason = "user";
+          abortController == null ? void 0 : abortController.abort();
+          clearTimeout(timeoutId);
+        };
+        const timeoutAbortHandler = () => {
+          if (!abortReason) abortReason = "timeout";
+          abortController == null ? void 0 : abortController.abort();
+        };
+        const listeners = [
+          { signal: externalSignal, handler: userAbortHandler },
+          { signal: timeoutController.signal, handler: timeoutAbortHandler }
+        ];
+        listeners.forEach(({ signal, handler }) => {
+          signal.addEventListener("abort", handler);
+        });
+        abortHandler = () => {
+          listeners.forEach(({ signal, handler }) => {
+            signal.removeEventListener("abort", handler);
+          });
+        };
+        return abortController.signal;
+      })() : timeoutController.signal;
+      try {
+        const response = yield fetch(url, __spreadProps(__spreadValues({}, restOptions), {
+          signal: combinedSignal,
+          headers: __spreadValues({
+            "Content-Type": "application/json",
+            "x-api-key": this.apiKey
+          }, options.headers),
+          body: body ? JSON.stringify(body) : void 0
+        }));
+        if (!response.ok) {
+          const errorBody = yield response.text().catch(() => "");
+          const errorMessage = `API Error: ${response.status} ${response.statusText}${errorBody ? ` - ${errorBody}` : ""}`;
+          throw new Error(errorMessage);
+        }
+        return yield response.json();
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          if (abortReason === "user") {
+            throw new Error("Request cancelled by user");
+          }
+          if (abortReason === "timeout") {
+            throw new Error(
+              "Request timeout: The server took too long to respond"
+            );
+          }
+          throw new Error("Request was aborted");
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeoutId);
+        if (abortHandler) {
+          abortHandler();
+        }
+      }
+    });
+  }
+  chat(params, options) {
+    return __async(this, null, function* () {
+      if (!params.query.trim()) {
+        throw new Error("Query is required");
+      }
+      return this.request("/chat/query", {
+        method: "POST",
+        body: params,
+        signal: options == null ? void 0 : options.signal
+      });
+    });
+  }
+};
+var createAizuClient = ({
+  hostUrl,
+  apiKey,
+  timeout
+}) => {
+  return new AizuClient({ hostUrl, apiKey, timeout });
+};
+
+// src/sdk/types.ts
+var TypeResponse = /* @__PURE__ */ ((TypeResponse2) => {
+  TypeResponse2["SUGGEST_PRODUCTS"] = "suggest_products";
+  TypeResponse2["REQUEST_CLARIFICATION"] = "request_clarification";
+  TypeResponse2["START_SHOPPING"] = "start_shopping";
+  return TypeResponse2;
+})(TypeResponse || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AizuClient,
+  TypeResponse,
+  createAizuClient
+});

package/dist/sdk.mjs

@@ -0,0 +1,12 @@
+'use client'
+import {
+  AizuClient,
+  TypeResponse,
+  createAizuClient
+} from "./chunk-NBQP747C.mjs";
+import "./chunk-33CPD3DF.mjs";
+export {
+  AizuClient,
+  TypeResponse,
+  createAizuClient
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aizu-chat/react",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"main": "./dist/index.js",
 	"module": "./dist/index.mjs",
 	"types": "./dist/index.d.ts",
@@ -49,4 +49,4 @@
 		"clsx": "^2.1.1",
 		"tailwind-merge": "^3.4.0"
 	}
-}
+}