@atzentis/ai-react 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,6 +1,715 @@
-// src/index.ts
-var VERSION = "0.0.1";
+import { AiClient } from '@atzentis/ai-sdk';
+import { createContext, useMemo, useContext, useState, useRef, useEffect, useCallback, createElement } from 'react';
+import { jsx } from 'react/jsx-runtime';
 
-export { VERSION };
+// src/provider/ai-provider.tsx
+var AiContext = createContext(null);
+function AiProvider({ apiKey, baseUrl, client, children }) {
+  const instance = useMemo(
+    () => client ?? new AiClient(baseUrl !== void 0 ? { apiKey, baseUrl } : { apiKey }),
+    [apiKey, baseUrl, client]
+  );
+  return /* @__PURE__ */ jsx(AiContext.Provider, { value: instance, children });
+}
+
+// src/helpers/errors.ts
+var AiReactError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AiReactError";
+  }
+};
+function useAi() {
+  const client = useContext(AiContext);
+  if (client === null) {
+    throw new AiReactError("useAi must be used within AiProvider");
+  }
+  return client;
+}
+function useChat(options) {
+  const atz = useAi();
+  const [messages, setMessages] = useState(options?.initialMessages ?? []);
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const readerRef = useRef(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      void readerRef.current?.return();
+    };
+  }, []);
+  const send = useCallback(
+    async (content) => {
+      const userMessage = { role: "user", content };
+      const history = [...messages, userMessage];
+      setMessages([...history, { role: "assistant", content: "" }]);
+      setIsLoading(true);
+      setError(null);
+      try {
+        const reader = atz.chat.stream({ messages: history });
+        readerRef.current = reader;
+        let assistantText = "";
+        let firstChunk = true;
+        for await (const chunk of reader) {
+          if (!mountedRef.current) {
+            return;
+          }
+          if (firstChunk) {
+            setIsLoading(false);
+            setIsStreaming(true);
+            firstChunk = false;
+          }
+          assistantText += chunk.content;
+          setMessages([...history, { role: "assistant", content: assistantText }]);
+        }
+        if (mountedRef.current) {
+          setIsStreaming(false);
+          setIsLoading(false);
+        }
+      } catch (err) {
+        if (!mountedRef.current) {
+          return;
+        }
+        if (err instanceof DOMException && err.name === "AbortError") {
+          setIsStreaming(false);
+          setIsLoading(false);
+          return;
+        }
+        const normalized = err instanceof Error ? err : new Error(String(err));
+        setError(normalized);
+        setIsStreaming(false);
+        setIsLoading(false);
+        options?.onError?.(normalized);
+      } finally {
+        readerRef.current = null;
+      }
+    },
+    [atz, messages, options]
+  );
+  const stop = useCallback(() => {
+    void readerRef.current?.return();
+    readerRef.current = null;
+    setIsStreaming(false);
+  }, []);
+  const reset = useCallback(() => {
+    void readerRef.current?.return();
+    readerRef.current = null;
+    setMessages([]);
+    setError(null);
+    setIsLoading(false);
+    setIsStreaming(false);
+  }, []);
+  return { messages, isStreaming, isLoading, error, send, stop, reset };
+}
+function useRag() {
+  const atz = useAi();
+  const [results, setResults] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const query = useCallback(
+    async (options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await atz.rag.query(options);
+        setResults(result);
+        return result;
+      } catch (err) {
+        const normalized = err instanceof Error ? err : new Error(String(err));
+        setError(normalized);
+        throw normalized;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [atz]
+  );
+  const upload = useCallback(
+    async (options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        return await atz.rag.upload(options);
+      } catch (err) {
+        const normalized = err instanceof Error ? err : new Error(String(err));
+        setError(normalized);
+        throw normalized;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [atz]
+  );
+  const reset = useCallback(() => {
+    setResults(null);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  return { results, isLoading, error, query, upload, reset };
+}
+function useAgent() {
+  const atz = useAi();
+  const [session, setSession] = useState(null);
+  const [steps, setSteps] = useState([]);
+  const [result, setResult] = useState(null);
+  const [isRunning, setIsRunning] = useState(false);
+  const [error, setError] = useState(null);
+  const readerRef = useRef(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      void readerRef.current?.return();
+    };
+  }, []);
+  const create = useCallback(
+    async (options) => {
+      setError(null);
+      try {
+        const created = await atz.agents.create(options);
+        setSession(created);
+        return created;
+      } catch (err) {
+        const normalized = err instanceof Error ? err : new Error(String(err));
+        setError(normalized);
+        throw normalized;
+      }
+    },
+    [atz]
+  );
+  const run = useCallback(
+    async (options) => {
+      if (session === null) {
+        throw new AiReactError("No active session \u2014 call create() first");
+      }
+      setIsRunning(true);
+      setError(null);
+      try {
+        const runResult = await atz.agents.run(session.id, options);
+        setResult(runResult);
+        return runResult;
+      } catch (err) {
+        const normalized = err instanceof Error ? err : new Error(String(err));
+        setError(normalized);
+        throw normalized;
+      } finally {
+        setIsRunning(false);
+      }
+    },
+    [atz, session]
+  );
+  const stream = useCallback(
+    async (options) => {
+      if (session === null) {
+        throw new AiReactError("No active session \u2014 call create() first");
+      }
+      setIsRunning(true);
+      setSteps([]);
+      setError(null);
+      try {
+        const reader = atz.agents.stream(session.id, options);
+        readerRef.current = reader;
+        const collected = [];
+        for await (const event of reader) {
+          if (!mountedRef.current) {
+            return;
+          }
+          collected.push(event);
+          setSteps([...collected]);
+        }
+        if (mountedRef.current) {
+          setIsRunning(false);
+        }
+      } catch (err) {
+        if (!mountedRef.current) {
+          return;
+        }
+        if (err instanceof DOMException && err.name === "AbortError") {
+          setIsRunning(false);
+          return;
+        }
+        const normalized = err instanceof Error ? err : new Error(String(err));
+        setError(normalized);
+        setIsRunning(false);
+      } finally {
+        readerRef.current = null;
+      }
+    },
+    [atz, session]
+  );
+  const stop = useCallback(() => {
+    void readerRef.current?.return();
+    readerRef.current = null;
+    setIsRunning(false);
+  }, []);
+  const reset = useCallback(() => {
+    void readerRef.current?.return();
+    readerRef.current = null;
+    setSession(null);
+    setSteps([]);
+    setResult(null);
+    setError(null);
+    setIsRunning(false);
+  }, []);
+  return { session, steps, result, isRunning, error, create, run, stream, stop, reset };
+}
+function useVoice() {
+  const atz = useAi();
+  const [isRecording, setIsRecording] = useState(false);
+  const [transcript, setTranscript] = useState(null);
+  const [audioUrl, setAudioUrl] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const recorderRef = useRef(null);
+  const chunksRef = useRef([]);
+  const startRecording = useCallback(async () => {
+    setError(null);
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      const recorder = new MediaRecorder(stream);
+      chunksRef.current = [];
+      recorder.ondataavailable = (event) => {
+        if (event.data.size > 0) {
+          chunksRef.current.push(event.data);
+        }
+      };
+      recorder.onstop = async () => {
+        const blob = new Blob(chunksRef.current, { type: "audio/webm" });
+        setIsLoading(true);
+        try {
+          const result = await atz.voice.stt({ audio: blob, format: "webm" });
+          setTranscript(result);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        } finally {
+          setIsLoading(false);
+        }
+        for (const track of stream.getTracks()) {
+          track.stop();
+        }
+      };
+      recorderRef.current = recorder;
+      recorder.start();
+      setIsRecording(true);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [atz]);
+  const stopRecording = useCallback(() => {
+    recorderRef.current?.stop();
+    recorderRef.current = null;
+    setIsRecording(false);
+  }, []);
+  const speak = useCallback(
+    async (options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const buffer = await atz.voice.tts(options);
+        const url = URL.createObjectURL(new Blob([buffer], { type: "audio/mpeg" }));
+        setAudioUrl(url);
+        return url;
+      } catch (err) {
+        const normalized = err instanceof Error ? err : new Error(String(err));
+        setError(normalized);
+        throw normalized;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [atz]
+  );
+  const reset = useCallback(() => {
+    setTranscript(null);
+    setAudioUrl(null);
+    setError(null);
+    setIsLoading(false);
+    setIsRecording(false);
+  }, []);
+  return {
+    isRecording,
+    transcript,
+    audioUrl,
+    isLoading,
+    error,
+    startRecording,
+    stopRecording,
+    speak,
+    reset
+  };
+}
+function useContent() {
+  const atz = useAi();
+  const [result, setResult] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const wrap = useCallback((call) => {
+    setIsLoading(true);
+    setError(null);
+    return call().then((value) => {
+      setResult(value);
+      return value;
+    }).catch((err) => {
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      setError(normalized);
+      throw normalized;
+    }).finally(() => {
+      setIsLoading(false);
+    });
+  }, []);
+  const generate = useCallback(
+    (options) => wrap(() => atz.content.generate(options)),
+    [atz, wrap]
+  );
+  const summarize = useCallback(
+    (options) => wrap(() => atz.content.summarize(options)),
+    [atz, wrap]
+  );
+  const translate = useCallback(
+    (options) => wrap(() => atz.content.translate(options)),
+    [atz, wrap]
+  );
+  const rewrite = useCallback(
+    (options) => wrap(() => atz.content.rewrite(options)),
+    [atz, wrap]
+  );
+  const moderate = useCallback(
+    (options) => wrap(() => atz.content.moderate(options)),
+    [atz, wrap]
+  );
+  const analyze = useCallback(
+    (options) => wrap(() => atz.content.analyze(options)),
+    [atz, wrap]
+  );
+  const extract = useCallback(
+    (options) => wrap(() => atz.content.extract(options)),
+    [atz, wrap]
+  );
+  const seo = useCallback(
+    (options) => wrap(() => atz.content.seo(options)),
+    [atz, wrap]
+  );
+  const reset = useCallback(() => {
+    setResult(null);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  return {
+    result,
+    isLoading,
+    error,
+    generate,
+    summarize,
+    translate,
+    rewrite,
+    moderate,
+    analyze,
+    extract,
+    seo,
+    reset
+  };
+}
+function useSocial() {
+  const atz = useAi();
+  const [post, setPost] = useState(null);
+  const [variants, setVariants] = useState(null);
+  const [analyticsResult, setAnalyticsResult] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const run = useCallback((call, store) => {
+    setIsLoading(true);
+    setError(null);
+    return call().then((value) => {
+      store?.(value);
+      return value;
+    }).catch((err) => {
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      setError(normalized);
+      throw normalized;
+    }).finally(() => {
+      setIsLoading(false);
+    });
+  }, []);
+  const generate = useCallback(
+    (options) => run(() => atz.social.generate(options), setPost),
+    [atz, run]
+  );
+  const generateVariants = useCallback(
+    (options) => run(() => atz.social.generateVariants(options), setVariants),
+    [atz, run]
+  );
+  const schedule = useCallback(
+    (options) => run(() => atz.social.schedule(options)),
+    [atz, run]
+  );
+  const analytics = useCallback(
+    (options) => run(() => atz.social.analytics(options), setAnalyticsResult),
+    [atz, run]
+  );
+  const reset = useCallback(() => {
+    setPost(null);
+    setVariants(null);
+    setAnalyticsResult(null);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  return {
+    post,
+    variants,
+    analyticsResult,
+    isLoading,
+    error,
+    generate,
+    generateVariants,
+    schedule,
+    analytics,
+    reset
+  };
+}
+function useSearch() {
+  const atz = useAi();
+  const [hits, setHits] = useState(null);
+  const [sql, setSql] = useState(null);
+  const [sentimentResult, setSentimentResult] = useState(null);
+  const [entitiesResult, setEntitiesResult] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const run = useCallback((call, store) => {
+    setIsLoading(true);
+    setError(null);
+    return call().then((value) => {
+      store(value);
+      return value;
+    }).catch((err) => {
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      setError(normalized);
+      throw normalized;
+    }).finally(() => {
+      setIsLoading(false);
+    });
+  }, []);
+  const semantic = useCallback(
+    (options) => run(() => atz.search.semantic(options), setHits),
+    [atz, run]
+  );
+  const nl2sql = useCallback(
+    (options) => run(() => atz.search.nl2sql(options), setSql),
+    [atz, run]
+  );
+  const sentiment = useCallback(
+    (options) => run(() => atz.search.sentiment(options), setSentimentResult),
+    [atz, run]
+  );
+  const entities = useCallback(
+    (options) => run(() => atz.search.entities(options), setEntitiesResult),
+    [atz, run]
+  );
+  const reset = useCallback(() => {
+    setHits(null);
+    setSql(null);
+    setSentimentResult(null);
+    setEntitiesResult(null);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  return {
+    hits,
+    sql,
+    sentimentResult,
+    entitiesResult,
+    isLoading,
+    error,
+    semantic,
+    nl2sql,
+    sentiment,
+    entities,
+    reset
+  };
+}
+function useVideo() {
+  const atz = useAi();
+  const [job, setJob] = useState(null);
+  const [status, setStatus] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const run = useCallback((call, store) => {
+    setIsLoading(true);
+    setError(null);
+    return call().then((value) => {
+      store?.(value);
+      return value;
+    }).catch((err) => {
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      setError(normalized);
+      throw normalized;
+    }).finally(() => {
+      setIsLoading(false);
+    });
+  }, []);
+  const generateScene = useCallback(
+    (input) => run(() => atz.video.generateScene(input), setJob),
+    [atz, run]
+  );
+  const generateAvatar = useCallback(
+    (input) => run(() => atz.video.generateAvatar(input), setJob),
+    [atz, run]
+  );
+  const renderRemotion = useCallback(
+    (input) => run(() => atz.video.renderRemotion(input), setJob),
+    [atz, run]
+  );
+  const poll = useCallback(
+    (jobId) => run(() => atz.video.poll({ jobId }), setStatus),
+    [atz, run]
+  );
+  const cancel = useCallback((jobId) => run(() => atz.video.cancel({ jobId })), [atz, run]);
+  const reset = useCallback(() => {
+    setJob(null);
+    setStatus(null);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  return {
+    job,
+    status,
+    isLoading,
+    error,
+    generateScene,
+    generateAvatar,
+    renderRemotion,
+    poll,
+    cancel,
+    reset
+  };
+}
+function useSkills() {
+  const atz = useAi();
+  const [skills, setSkills] = useState(null);
+  const [job, setJob] = useState(null);
+  const [events, setEvents] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const abortRef = useRef(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      abortRef.current?.abort();
+    };
+  }, []);
+  const run = useCallback((call, store) => {
+    setIsLoading(true);
+    setError(null);
+    return call().then((value) => {
+      store?.(value);
+      return value;
+    }).catch((err) => {
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      setError(normalized);
+      throw normalized;
+    }).finally(() => {
+      setIsLoading(false);
+    });
+  }, []);
+  const list = useCallback(() => run(() => atz.skills.list(), setSkills), [atz, run]);
+  const runSkill = useCallback(
+    (input) => run(
+      () => atz.skills.run(input),
+      (value) => setJob(value)
+    ),
+    [atz, run]
+  );
+  const getRun = useCallback(
+    (jobId) => run(() => atz.skills.getRun({ jobId })),
+    [atz, run]
+  );
+  const cancel = useCallback(
+    (jobId) => run(() => atz.skills.cancel({ jobId })),
+    [atz, run]
+  );
+  const subscribe = useCallback(
+    async (jobId) => {
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setEvents([]);
+      setError(null);
+      try {
+        const collected = [];
+        for await (const event of atz.skills.subscribe({ jobId, signal: controller.signal })) {
+          if (!mountedRef.current) {
+            return;
+          }
+          collected.push(event);
+          setEvents([...collected]);
+        }
+      } catch (err) {
+        if (!mountedRef.current) {
+          return;
+        }
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        abortRef.current = null;
+      }
+    },
+    [atz]
+  );
+  const stop = useCallback(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+  }, []);
+  const reset = useCallback(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    setSkills(null);
+    setJob(null);
+    setEvents([]);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  return {
+    skills,
+    job,
+    events,
+    isLoading,
+    error,
+    list,
+    run: runSkill,
+    getRun,
+    subscribe,
+    cancel,
+    stop,
+    reset
+  };
+}
+function ChatMessages({ messages, isStreaming, className }) {
+  if (messages.length === 0) {
+    return null;
+  }
+  const lastIndex = messages.length - 1;
+  return /* @__PURE__ */ jsx("div", { className, children: messages.map((message, index) => /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-role": message.role,
+      "data-streaming": index === lastIndex && isStreaming ? "true" : void 0,
+      children: message.content
+    },
+    index
+  )) });
+}
+function StreamingText({ text, isStreaming, className, as = "span" }) {
+  return createElement(
+    as,
+    { className },
+    text,
+    isStreaming ? createElement("span", { "data-cursor": "true" }) : null
+  );
+}
+
+export { AiContext, AiProvider, AiReactError, ChatMessages, StreamingText, useAgent, useAi, useChat, useContent, useRag, useSearch, useSkills, useSocial, useVideo, useVoice };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map