@trustgraph/react-state 0.3.1 → 1.1.0

package/dist/index.cjs

@@ -6,6 +6,7 @@ var react = require('react');
 var zustand = require('zustand');
 var reactQuery = require('@tanstack/react-query');
 var uuid = require('uuid');
+var similarity = require('compute-cosine-similarity');
 
 // Create context for notification handler
 const NotificationContext = react.createContext(null);
@@ -170,6 +171,16 @@ const useConversation = zustand.create()((set) => ({
             },
         ],
     })),
+    updateLastMessage: (text) => set((state) => {
+        if (state.messages.length === 0)
+            return state;
+        const messages = [...state.messages];
+        messages[messages.length - 1] = {
+            ...messages[messages.length - 1],
+            text: text,
+        };
+        return { messages };
+    }),
     setInput: (v) => set(() => ({
         input: v,
     })),
@@ -1409,273 +1420,6 @@ const useGraphEmbeddings = ({ flow, vecs, limit, collection }) => {
     };
 };
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-/**
-* FUNCTION: isArray( value )
-*	Validates if a value is an array.
-*
-* @param {*} value - value to be validated
-* @returns {Boolean} boolean indicating whether value is an array
-*/
-function isArray$3( value ) {
-	return Object.prototype.toString.call( value ) === '[object Array]';
-} // end FUNCTION isArray()
-
-// EXPORTS //
-
-var lib$4 = Array.isArray || isArray$3;
-
-/**
-*
-*	VALIDATE: function
-*
-*
-*	DESCRIPTION:
-*		- Validates if a value is a function.
-*
-*
-*	NOTES:
-*		[1]
-*
-*
-*	TODO:
-*		[1]
-*
-*
-*	LICENSE:
-*		MIT
-*
-*	Copyright (c) 2014. Athan Reines.
-*
-*
-*	AUTHOR:
-*		Athan Reines. kgryte@gmail.com. 2014.
-*
-*/
-
-/**
-* FUNCTION: isFunction( value )
-*	Validates if a value is a function.
-*
-* @param {*} value - value to be validated
-* @returns {Boolean} boolean indicating whether value is a function
-*/
-function isFunction$3( value ) {
-	return ( typeof value === 'function' );
-} // end FUNCTION isFunction()
-
-
-// EXPORTS //
-
-var lib$3 = isFunction$3;
-
-// MODULES //
-
-var isArray$2 = lib$4,
-	isFunction$2 = lib$3;
-
-
-// DOT PRODUCT //
-
-/**
-* FUNCTION: dot( x, y[, accessor] )
-*	Computes the dot product between two arrays.
-*
-* @param {Array} x - input array
-* @param {Array} y - input array
-* @param {Function} [accessor] - accessor function for accessing array values
-* @returns {Number|Null} dot product
-*/
-function dot$1( x, y, clbk ) {
-	if ( !isArray$2( x ) ) {
-		throw new TypeError( 'dot()::invalid input argument. First argument must be an array. Value: `' + x + '`.' );
-	}
-	if ( !isArray$2( y ) ) {
-		throw new TypeError( 'dot()::invalid input argument. Second argument must be an array. Value: `' + y + '`.' );
-	}
-	if ( arguments.length > 2 ) {
-		if ( !isFunction$2( clbk ) ) {
-			throw new TypeError( 'dot()::invalid input argument. Accessor must be a function. Value: `' + clbk + '`.' );
-		}
-	}
-	var len = x.length,
-		sum = 0,
-		i;
-
-	if ( len !== y.length ) {
-		throw new Error( 'dot()::invalid input argument. Arrays must be of equal length.' );
-	}
-	if ( !len ) {
-		return null;
-	}
-	if ( clbk ) {
-		for ( i = 0; i < len; i++ ) {
-			sum += clbk( x[ i ], i, 0 ) * clbk( y[ i ], i, 1 );
-		}
-	} else {
-		for ( i = 0; i < len; i++ ) {
-			sum += x[ i ] * y[ i ];
-		}
-	}
-	return sum;
-} // end FUNCTION dot()
-
-
-// EXPORTS //
-
-var lib$2 = dot$1;
-
-// MODULES //
-
-var isArray$1 = lib$4,
-	isFunction$1 = lib$3;
-
-
-// L2NORM //
-
-/**
-* FUNCTION: l2norm( arr[, accessor] )
-*	Calculates the L2 norm (Euclidean norm) of an array.
-*
-* @param {Array} arr - input array
-* @param {Function} [accessor] - accessor function for accessing array values
-* @returns {Number|Null} L2 norm or null
-*/
-function l2norm$1( arr, clbk ) {
-	if ( !isArray$1( arr ) ) {
-		throw new TypeError( 'l2norm()::invalid input argument. Must provide an array.  Value: `' + arr + '`.' );
-	}
-	if ( arguments.length > 1 ) {
-		if ( !isFunction$1( clbk ) ) {
-			throw new TypeError( 'l2norm()::invalid input argument. Accessor must be a function. Value: `' + clbk + '`.' );
-		}
-	}
-	var len = arr.length,
-		t = 0,
-		s = 1,
-		r,
-		val,
-		abs,
-		i;
-
-	if ( !len ) {
-		return null;
-	}
-	if ( clbk ) {
-		for ( i = 0; i < len; i++ ) {
-			val = clbk( arr[ i ], i );
-			abs = ( val < 0 ) ? -val : val;
-			if ( abs > 0 ) {
-				if ( abs > t ) {
-					r = t / val;
-					s = 1 + s*r*r;
-					t = abs;
-				} else {
-					r = val / t;
-					s = s + r*r;
-				}
-			}
-		}
-	} else {
-		for ( i = 0; i < len; i++ ) {
-			val = arr[ i ];
-			abs = ( val < 0 ) ? -val : val;
-			if ( abs > 0 ) {
-				if ( abs > t ) {
-					r = t / val;
-					s = 1 + s*r*r;
-					t = abs;
-				} else {
-					r = val / t;
-					s = s + r*r;
-				}
-			}
-		}
-	}
-	return t * Math.sqrt( s );
-} // end FUNCTION l2norm()
-
-
-// EXPORTS //
-
-var lib$1 = l2norm$1;
-
-// MODULES //
-
-var dot = lib$2,
-	l2norm = lib$1,
-	isArray = lib$4,
-	isFunction = lib$3;
-
-
-// FUNCTIONS //
-
-/**
-* Partially applied function from the right.
-*
-* @private
-* @param {Function} fn - input function
-* @param {number} j - array index
-* @returns {Function} partially applied function
-*/
-function partial( fn, j ) {
-	return function accessor( d, i ) {
-		return fn( d, i, j );
-	};
-}
-
-
-// MAIN //
-
-/**
-* Computes the cosine similarity between two arrays.
-*
-* @param {number[]|Array} x - input array
-* @param {number[]|Array} y - input array
-* @param {Function} [accessor] - accessor function for accessing array values
-* @returns {number|null} cosine similarity or null
-*/
-function similarity( x, y, clbk ) {
-	var a, b, c;
-	if ( !isArray( x ) ) {
-		throw new TypeError( 'cosine-similarity()::invalid input argument. First argument must be an array. Value: `' + x + '`.' );
-	}
-	if ( !isArray( y ) ) {
-		throw new TypeError( 'cosine-similarity()::invalid input argument. Second argument must be an array. Value: `' + y + '`.' );
-	}
-	if ( arguments.length > 2 ) {
-		if ( !isFunction( clbk ) ) {
-			throw new TypeError( 'cosine-similarity()::invalid input argument. Accessor must be a function. Value: `' + clbk + '`.' );
-		}
-	}
-	if ( x.length !== y.length ) {
-		throw new Error( 'cosine-similarity()::invalid input argument. Input arrays must have the same length.' );
-	}
-	if ( !x.length ) {
-		return null;
-	}
-	if ( clbk ) {
-		a = dot( x, y, clbk );
-		b = l2norm( x, partial( clbk, 0 ) );
-		c = l2norm( y, partial( clbk, 1 ) );
-	} else {
-		a = dot( x, y );
-		b = l2norm( x );
-		c = l2norm( y );
-	}
-	return a / ( b*c );
-}
-
-
-// EXPORTS //
-
-var lib = similarity;
-
-var similarity$1 = /*@__PURE__*/getDefaultExportFromCjs(lib);
-
 // Take the embeddings, and lookup entities using graph
 // embeddings, add embedding to each entity row, just an easy
 // place to put it
@@ -1795,7 +1539,7 @@ const addRowEmbeddings = (socket, add, remove) => (entities) => {
 };
 // Rest of the procecess is not async, so not adding progress
 const computeCosineSimilarity = () => (entities) => entities.map((ent) => {
-    const sim = similarity$1(ent.target, ent.embeddings);
+    const sim = similarity(ent.target, ent.embeddings);
     return {
         uri: ent.uri,
         label: ent.label,
@@ -1965,11 +1709,27 @@ const useInference = () => {
      * Graph RAG inference with entity discovery
      */
     const graphRagMutation = reactQuery.useMutation({
-        mutationFn: async ({ input, options, collection, }) => {
-            // Execute Graph RAG request
-            const response = await socket
-                .flow(flowId)
-                .graphRag(input, options || {}, collection);
+        mutationFn: async ({ input, options, collection, callbacks, }) => {
+            // If callbacks provided, use streaming API
+            const response = callbacks
+                ? await new Promise((resolve, reject) => {
+                    let accumulated = "";
+                    const onChunk = (chunk, complete) => {
+                        accumulated += chunk;
+                        callbacks?.onChunk?.(chunk, complete);
+                        if (complete) {
+                            resolve(accumulated);
+                        }
+                    };
+                    const onError = (error) => {
+                        callbacks?.onError?.(error);
+                        reject(new Error(error));
+                    };
+                    socket
+                        .flow(flowId)
+                        .graphRagStreaming(input, onChunk, onError, options, collection);
+                })
+                : await socket.flow(flowId).graphRag(input, options || {}, collection);
             // Get embeddings for entity discovery
             const embeddings = await socket.flow(flowId).embeddings(input);
             // Query graph embeddings to find entities
@@ -1983,8 +1743,27 @@ const useInference = () => {
      * Basic LLM text completion
      */
     const textCompletionMutation = reactQuery.useMutation({
-        mutationFn: async ({ systemPrompt, input, }) => {
-            return await socket.flow(flowId).textCompletion(systemPrompt, input);
+        mutationFn: async ({ systemPrompt, input, callbacks, }) => {
+            // If callbacks provided, use streaming API
+            return callbacks
+                ? await new Promise((resolve, reject) => {
+                    let accumulated = "";
+                    const onChunk = (chunk, complete) => {
+                        accumulated += chunk;
+                        callbacks?.onChunk?.(chunk, complete);
+                        if (complete) {
+                            resolve(accumulated);
+                        }
+                    };
+                    const onError = (error) => {
+                        callbacks?.onError?.(error);
+                        reject(new Error(error));
+                    };
+                    socket
+                        .flow(flowId)
+                        .textCompletionStreaming(systemPrompt, input, onChunk, onError);
+                })
+                : await socket.flow(flowId).textCompletion(systemPrompt, input);
         },
     });
     /**
@@ -1993,15 +1772,19 @@ const useInference = () => {
     const agentMutation = reactQuery.useMutation({
         mutationFn: async ({ input, callbacks, }) => {
             return new Promise((resolve, reject) => {
-                const onThink = (thought) => {
-                    callbacks?.onThink?.(thought);
+                let fullAnswer = "";
+                const onThink = (thought, complete) => {
+                    callbacks?.onThink?.(thought, complete);
                 };
-                const onObserve = (observation) => {
-                    callbacks?.onObserve?.(observation);
+                const onObserve = (observation, complete) => {
+                    callbacks?.onObserve?.(observation, complete);
                 };
-                const onAnswer = (answer) => {
-                    callbacks?.onAnswer?.(answer);
-                    resolve(answer);
+                const onAnswer = (answer, complete) => {
+                    fullAnswer += answer;
+                    callbacks?.onAnswer?.(answer, complete);
+                    if (complete) {
+                        resolve(fullAnswer);
+                    }
                 };
                 const onError = (error) => {
                     callbacks?.onError?.(error);
@@ -2033,6 +1816,7 @@ const useChatSession = () => {
     const notify = useNotification();
     // Conversation state
     const addMessage = useConversation((state) => state.addMessage);
+    const updateLastMessage = useConversation((state) => state.updateLastMessage);
     const setInput = useConversation((state) => state.setInput);
     const chatMode = useConversation((state) => state.chatMode);
     // Progress and activity management
@@ -2052,8 +1836,10 @@ const useChatSession = () => {
         const ragActivity = "Graph RAG: " + input;
         const embActivity = "Find entities: " + input;
         addActivity(ragActivity);
+        let accumulated = "";
+        let messageAdded = false;
         try {
-            // Execute Graph RAG with entity discovery
+            // Execute Graph RAG with streaming and entity discovery
             const result = await inference.graphRag({
                 input,
                 options: {
@@ -2063,8 +1849,21 @@ const useChatSession = () => {
                     pathLength: settings.graphrag.pathLength,
                 },
                 collection: settings.collection,
+                callbacks: {
+                    onChunk: (chunk, complete) => {
+                        accumulated += chunk;
+                        if (!messageAdded) {
+                            // Add empty message on first chunk
+                            addMessage("ai", accumulated);
+                            messageAdded = true;
+                        }
+                        else {
+                            // Update existing message with accumulated text
+                            updateLastMessage(accumulated);
+                        }
+                    },
+                },
             });
-            addMessage("ai", result.response);
             removeActivity(ragActivity);
             // Start embeddings activity
             addActivity(embActivity);
@@ -2108,12 +1907,27 @@ const useChatSession = () => {
     const handleBasicLlm = async (input) => {
         const activity = "Text completion: " + input;
         addActivity(activity);
+        let accumulated = "";
+        let messageAdded = false;
         try {
             const response = await inference.textCompletion({
                 systemPrompt: "You are a helpful assistant. Provide clear and concise responses.",
                 input,
+                callbacks: {
+                    onChunk: (chunk, complete) => {
+                        accumulated += chunk;
+                        if (!messageAdded) {
+                            // Add empty message on first chunk
+                            addMessage("ai", accumulated);
+                            messageAdded = true;
+                        }
+                        else {
+                            // Update existing message with accumulated text
+                            updateLastMessage(accumulated);
+                        }
+                    },
+                },
             });
-            addMessage("ai", response);
             removeActivity(activity);
             setEntities([]);
             return response;
@@ -2129,13 +1943,54 @@ const useChatSession = () => {
     const handleAgent = async (input) => {
         const activity = "Agent: " + input;
         addActivity(activity);
+        let thinkingAccumulated = "";
+        let thinkingMessageAdded = false;
+        let observationAccumulated = "";
+        let observationMessageAdded = false;
+        let answerAccumulated = "";
+        let answerMessageAdded = false;
         try {
             const response = await inference.agent({
                 input,
                 callbacks: {
-                    onThink: (thought) => addMessage("ai", thought, "thinking"),
-                    onObserve: (observation) => addMessage("ai", observation, "observation"),
-                    onAnswer: (answer) => addMessage("ai", answer, "answer"),
+                    onThink: (thought, complete) => {
+                        thinkingAccumulated += thought;
+                        if (!thinkingMessageAdded) {
+                            addMessage("ai", thinkingAccumulated, "thinking");
+                            thinkingMessageAdded = true;
+                        }
+                        else {
+                            updateLastMessage(thinkingAccumulated);
+                        }
+                        if (complete) {
+                            thinkingAccumulated = "";
+                            thinkingMessageAdded = false;
+                        }
+                    },
+                    onObserve: (observation, complete) => {
+                        observationAccumulated += observation;
+                        if (!observationMessageAdded) {
+                            addMessage("ai", observationAccumulated, "observation");
+                            observationMessageAdded = true;
+                        }
+                        else {
+                            updateLastMessage(observationAccumulated);
+                        }
+                        if (complete) {
+                            observationAccumulated = "";
+                            observationMessageAdded = false;
+                        }
+                    },
+                    onAnswer: (answer, complete) => {
+                        answerAccumulated += answer;
+                        if (!answerMessageAdded) {
+                            addMessage("ai", answerAccumulated, "answer");
+                            answerMessageAdded = true;
+                        }
+                        else {
+                            updateLastMessage(answerAccumulated);
+                        }
+                    },
                 },
             });
             removeActivity(activity);