tekimax-ts 0.1.7 → 0.1.8

package/dist/react/index.cjs

@@ -0,0 +1,216 @@
+"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/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  useChat: () => useChat
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/useChat.ts
+var import_react = require("react");
+function useChat({
+  adapter,
+  client,
+  model,
+  initialMessages = [],
+  tools,
+  onFinish,
+  onError,
+  think
+}) {
+  const [messages, setMessages] = (0, import_react.useState)(initialMessages);
+  const [input, setInput] = (0, import_react.useState)("");
+  const [isLoading, setIsLoading] = (0, import_react.useState)(false);
+  const abortControllerRef = (0, import_react.useRef)(null);
+  const handleInputChange = (0, import_react.useCallback)(
+    (e) => {
+      setInput(e.target.value);
+    },
+    []
+  );
+  const stop = (0, import_react.useCallback)(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+      setIsLoading(false);
+    }
+  }, []);
+  const processChat = (0, import_react.useCallback)(
+    async (currentMessages) => {
+      setIsLoading(true);
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+      try {
+        setMessages((prev) => [...prev, { role: "assistant", content: "" }]);
+        let stream;
+        const toolDefinitions = tools ? Object.values(tools).map((t) => ({
+          type: "function",
+          function: t.function
+        })) : void 0;
+        const options = {
+          model,
+          messages: currentMessages,
+          tools: toolDefinitions,
+          signal: abortController.signal,
+          think
+        };
+        if (client) {
+          stream = client.text.generateStream(options);
+        } else if (adapter) {
+          stream = adapter.chatStream(options);
+        } else {
+          throw new Error("useChat: No client or adapter provided");
+        }
+        let fullContent = "";
+        let toolCallAccumulator = {};
+        for await (const chunk of stream) {
+          if (abortController.signal.aborted) break;
+          fullContent += chunk.delta;
+          if (chunk.toolCallDelta) {
+            const tc = chunk.toolCallDelta;
+            if (!toolCallAccumulator[tc.index]) {
+              toolCallAccumulator[tc.index] = {
+                index: tc.index,
+                id: tc.id,
+                type: "function",
+                function: { name: "", arguments: "" }
+              };
+            }
+            const acc = toolCallAccumulator[tc.index];
+            if (tc.id) acc.id = tc.id;
+            if (tc.function?.name) acc.function.name += tc.function.name;
+            if (tc.function?.arguments) acc.function.arguments += tc.function.arguments;
+          }
+          setMessages((prev) => {
+            const newMessages = [...prev];
+            const lastMsg = newMessages[newMessages.length - 1];
+            if (lastMsg && lastMsg.role === "assistant") {
+              lastMsg.content = fullContent;
+            }
+            return newMessages;
+          });
+        }
+        const finalToolCalls = Object.values(toolCallAccumulator).map((tc) => ({
+          id: tc.id || `call_${Math.random().toString(36).slice(2)}`,
+          type: "function",
+          function: {
+            name: tc.function.name,
+            arguments: tc.function.arguments
+          }
+        }));
+        if (finalToolCalls.length > 0) {
+          let assistantMessage = {
+            role: "assistant",
+            content: fullContent || null,
+            // Ensure explicitly null if empty string provided there are tool calls? OpenAI allows content + tool_calls.
+            toolCalls: finalToolCalls
+          };
+          setMessages((prev) => {
+            const newMessages = [...prev];
+            newMessages[newMessages.length - 1] = assistantMessage;
+            return newMessages;
+          });
+          const toolResultMessages = [];
+          for (const tc of finalToolCalls) {
+            const tool = tools?.[tc.function.name];
+            if (tool) {
+              try {
+                const args = JSON.parse(tc.function.arguments);
+                const result = await tool.execute(args);
+                toolResultMessages.push({
+                  role: "tool",
+                  toolCallId: tc.id,
+                  name: tc.function.name,
+                  content: JSON.stringify(result)
+                });
+              } catch (e) {
+                toolResultMessages.push({
+                  role: "tool",
+                  toolCallId: tc.id,
+                  name: tc.function.name,
+                  content: JSON.stringify({ error: e.message })
+                });
+              }
+            } else {
+              toolResultMessages.push({
+                role: "tool",
+                toolCallId: tc.id,
+                name: tc.function.name,
+                content: JSON.stringify({ error: "Tool not found on client" })
+              });
+            }
+          }
+          setMessages((prev) => [...prev, ...toolResultMessages]);
+          if (!abortController.signal.aborted) {
+            await processChat([...currentMessages, assistantMessage, ...toolResultMessages]);
+          }
+        } else {
+          if (onFinish && !abortController.signal.aborted) {
+            onFinish({ role: "assistant", content: fullContent });
+          }
+        }
+      } catch (err) {
+        if (err.name === "AbortError") {
+          return;
+        }
+        if (onError) onError(err);
+      } finally {
+        if (abortControllerRef.current === abortController) {
+          setIsLoading(false);
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    [adapter, client, model, tools, onFinish, onError, think]
+  );
+  const append = (0, import_react.useCallback)(
+    async (messageOrContent) => {
+      if (isLoading) return;
+      const userMessage = typeof messageOrContent === "string" ? { role: "user", content: messageOrContent } : messageOrContent;
+      setMessages((prev) => [...prev, userMessage]);
+      await processChat([...messages, userMessage]);
+    },
+    [isLoading, messages, processChat]
+  );
+  const handleSubmit = (0, import_react.useCallback)(
+    (e) => {
+      e.preventDefault();
+      if (!input.trim()) return;
+      append(input);
+      setInput("");
+    },
+    [input, append]
+  );
+  return {
+    messages,
+    setMessages,
+    input,
+    handleInputChange,
+    handleSubmit,
+    append,
+    stop,
+    isLoading
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useChat
+});

package/dist/react/index.d.cts

@@ -0,0 +1,25 @@
+import { M as Message, A as AIProvider, l as Tekimax, T as Tool } from '../tekimax-C-DJ0z27.cjs';
+
+interface UseChatOptions {
+    adapter?: AIProvider;
+    client?: Tekimax;
+    model: string;
+    initialMessages?: Array<Message>;
+    tools?: Record<string, Tool>;
+    onFinish?: (message: Message) => void;
+    onError?: (error: Error) => void;
+    think?: boolean;
+}
+interface UseChatHelpers {
+    messages: Array<Message>;
+    setMessages: (messages: Message[] | ((prev: Message[]) => Message[])) => void;
+    input: string;
+    handleInputChange: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    handleSubmit: (e: React.FormEvent<HTMLFormElement>) => void;
+    append: (message: Message | string) => Promise<void>;
+    stop: () => void;
+    isLoading: boolean;
+}
+declare function useChat({ adapter, client, model, initialMessages, tools, onFinish, onError, think, }: UseChatOptions): UseChatHelpers;
+
+export { type UseChatHelpers, type UseChatOptions, useChat };

package/dist/react/index.d.ts

@@ -0,0 +1,25 @@
+import { M as Message, A as AIProvider, l as Tekimax, T as Tool } from '../tekimax-C-DJ0z27.js';
+
+interface UseChatOptions {
+    adapter?: AIProvider;
+    client?: Tekimax;
+    model: string;
+    initialMessages?: Array<Message>;
+    tools?: Record<string, Tool>;
+    onFinish?: (message: Message) => void;
+    onError?: (error: Error) => void;
+    think?: boolean;
+}
+interface UseChatHelpers {
+    messages: Array<Message>;
+    setMessages: (messages: Message[] | ((prev: Message[]) => Message[])) => void;
+    input: string;
+    handleInputChange: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    handleSubmit: (e: React.FormEvent<HTMLFormElement>) => void;
+    append: (message: Message | string) => Promise<void>;
+    stop: () => void;
+    isLoading: boolean;
+}
+declare function useChat({ adapter, client, model, initialMessages, tools, onFinish, onError, think, }: UseChatOptions): UseChatHelpers;
+
+export { type UseChatHelpers, type UseChatOptions, useChat };

package/dist/react/index.js

@@ -0,0 +1,191 @@
+import "../chunk-MLKGABMK.js";
+
+// src/react/useChat.ts
+import { useCallback, useRef, useState } from "react";
+function useChat({
+  adapter,
+  client,
+  model,
+  initialMessages = [],
+  tools,
+  onFinish,
+  onError,
+  think
+}) {
+  const [messages, setMessages] = useState(initialMessages);
+  const [input, setInput] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const abortControllerRef = useRef(null);
+  const handleInputChange = useCallback(
+    (e) => {
+      setInput(e.target.value);
+    },
+    []
+  );
+  const stop = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+      setIsLoading(false);
+    }
+  }, []);
+  const processChat = useCallback(
+    async (currentMessages) => {
+      setIsLoading(true);
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+      try {
+        setMessages((prev) => [...prev, { role: "assistant", content: "" }]);
+        let stream;
+        const toolDefinitions = tools ? Object.values(tools).map((t) => ({
+          type: "function",
+          function: t.function
+        })) : void 0;
+        const options = {
+          model,
+          messages: currentMessages,
+          tools: toolDefinitions,
+          signal: abortController.signal,
+          think
+        };
+        if (client) {
+          stream = client.text.generateStream(options);
+        } else if (adapter) {
+          stream = adapter.chatStream(options);
+        } else {
+          throw new Error("useChat: No client or adapter provided");
+        }
+        let fullContent = "";
+        let toolCallAccumulator = {};
+        for await (const chunk of stream) {
+          if (abortController.signal.aborted) break;
+          fullContent += chunk.delta;
+          if (chunk.toolCallDelta) {
+            const tc = chunk.toolCallDelta;
+            if (!toolCallAccumulator[tc.index]) {
+              toolCallAccumulator[tc.index] = {
+                index: tc.index,
+                id: tc.id,
+                type: "function",
+                function: { name: "", arguments: "" }
+              };
+            }
+            const acc = toolCallAccumulator[tc.index];
+            if (tc.id) acc.id = tc.id;
+            if (tc.function?.name) acc.function.name += tc.function.name;
+            if (tc.function?.arguments) acc.function.arguments += tc.function.arguments;
+          }
+          setMessages((prev) => {
+            const newMessages = [...prev];
+            const lastMsg = newMessages[newMessages.length - 1];
+            if (lastMsg && lastMsg.role === "assistant") {
+              lastMsg.content = fullContent;
+            }
+            return newMessages;
+          });
+        }
+        const finalToolCalls = Object.values(toolCallAccumulator).map((tc) => ({
+          id: tc.id || `call_${Math.random().toString(36).slice(2)}`,
+          type: "function",
+          function: {
+            name: tc.function.name,
+            arguments: tc.function.arguments
+          }
+        }));
+        if (finalToolCalls.length > 0) {
+          let assistantMessage = {
+            role: "assistant",
+            content: fullContent || null,
+            // Ensure explicitly null if empty string provided there are tool calls? OpenAI allows content + tool_calls.
+            toolCalls: finalToolCalls
+          };
+          setMessages((prev) => {
+            const newMessages = [...prev];
+            newMessages[newMessages.length - 1] = assistantMessage;
+            return newMessages;
+          });
+          const toolResultMessages = [];
+          for (const tc of finalToolCalls) {
+            const tool = tools?.[tc.function.name];
+            if (tool) {
+              try {
+                const args = JSON.parse(tc.function.arguments);
+                const result = await tool.execute(args);
+                toolResultMessages.push({
+                  role: "tool",
+                  toolCallId: tc.id,
+                  name: tc.function.name,
+                  content: JSON.stringify(result)
+                });
+              } catch (e) {
+                toolResultMessages.push({
+                  role: "tool",
+                  toolCallId: tc.id,
+                  name: tc.function.name,
+                  content: JSON.stringify({ error: e.message })
+                });
+              }
+            } else {
+              toolResultMessages.push({
+                role: "tool",
+                toolCallId: tc.id,
+                name: tc.function.name,
+                content: JSON.stringify({ error: "Tool not found on client" })
+              });
+            }
+          }
+          setMessages((prev) => [...prev, ...toolResultMessages]);
+          if (!abortController.signal.aborted) {
+            await processChat([...currentMessages, assistantMessage, ...toolResultMessages]);
+          }
+        } else {
+          if (onFinish && !abortController.signal.aborted) {
+            onFinish({ role: "assistant", content: fullContent });
+          }
+        }
+      } catch (err) {
+        if (err.name === "AbortError") {
+          return;
+        }
+        if (onError) onError(err);
+      } finally {
+        if (abortControllerRef.current === abortController) {
+          setIsLoading(false);
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    [adapter, client, model, tools, onFinish, onError, think]
+  );
+  const append = useCallback(
+    async (messageOrContent) => {
+      if (isLoading) return;
+      const userMessage = typeof messageOrContent === "string" ? { role: "user", content: messageOrContent } : messageOrContent;
+      setMessages((prev) => [...prev, userMessage]);
+      await processChat([...messages, userMessage]);
+    },
+    [isLoading, messages, processChat]
+  );
+  const handleSubmit = useCallback(
+    (e) => {
+      e.preventDefault();
+      if (!input.trim()) return;
+      append(input);
+      setInput("");
+    },
+    [input, append]
+  );
+  return {
+    messages,
+    setMessages,
+    input,
+    handleInputChange,
+    handleSubmit,
+    append,
+    stop,
+    isLoading
+  };
+}
+export {
+  useChat
+};