graphlit-client 1.0.20250612006 → 1.0.20250612008

package/dist/client.js

@@ -1417,11 +1417,15 @@ class Graphlit {
         if (specification) {
             const serviceType = specification.serviceType;
             if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
-                console.log("[supportsStreaming] Checking support for:", {
+                console.log("[supportsStreaming] Checking support for specification:", {
+                    specificationName: specification.name,
                     serviceType,
-                    hasOpenAI: OpenAI !== undefined || this.openaiClient !== undefined,
-                    hasAnthropic: Anthropic !== undefined || this.anthropicClient !== undefined,
-                    hasGoogle: GoogleGenerativeAI !== undefined || this.googleClient !== undefined,
+                    moduleOpenAI: OpenAI !== undefined,
+                    instanceOpenAI: this.openaiClient !== undefined,
+                    moduleAnthropic: Anthropic !== undefined,
+                    instanceAnthropic: this.anthropicClient !== undefined,
+                    moduleGoogle: GoogleGenerativeAI !== undefined,
+                    instanceGoogle: this.googleClient !== undefined,
                 });
             }
             switch (serviceType) {
@@ -1674,11 +1678,20 @@ class Graphlit {
         // Format conversation once at the beginning
         const formatResponse = await this.formatConversation(prompt, conversationId, { id: specification.id }, tools, true, correlationId);
         const formattedMessage = formatResponse.formatConversation?.message;
+        const conversationHistory = formatResponse.formatConversation?.details?.messages;
         if (!formattedMessage?.message) {
             throw new Error("Failed to format conversation");
         }
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-            console.log("\n📋 [formatConversation] Response", formattedMessage.message);
+            console.log("\n📋 [formatConversation] Full response:", JSON.stringify(formatResponse, null, 2));
+            console.log("\n📋 [formatConversation] Response - current message:", formattedMessage.message);
+            console.log(`📋 [formatConversation] Conversation history: ${conversationHistory?.length || 0} messages`);
+            if (conversationHistory && conversationHistory.length > 0) {
+                console.log("📋 [formatConversation] History messages:");
+                conversationHistory.forEach((msg, i) => {
+                    console.log(`  ${i + 1}. [${msg?.role}] ${msg?.message?.substring(0, 100)}...`);
+                });
+            }
         }
         // Build message array with conversation history
         const messages = [];
@@ -1691,9 +1704,41 @@ class Graphlit {
                 timestamp: new Date().toISOString(),
             });
         }
-        // Use the formatted message from formatConversation which already includes
-        // all context, RAG results, and conversation history
-        if (formattedMessage) {
+        // Use the full conversation history from formatConversation if available
+        if (conversationHistory && conversationHistory.length > 0) {
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`🔄 [formatConversation] Using full conversation history with ${conversationHistory.length} messages`);
+            }
+            for (const historyMessage of conversationHistory) {
+                if (historyMessage) {
+                    const messageToAdd = {
+                        __typename: "ConversationMessage",
+                        role: historyMessage.role || Types.ConversationRoleTypes.User,
+                        message: historyMessage.message || "",
+                        timestamp: historyMessage.timestamp || new Date().toISOString(),
+                    };
+                    // Add optional fields if present
+                    if (historyMessage.author)
+                        messageToAdd.author = historyMessage.author;
+                    if (historyMessage.data)
+                        messageToAdd.data = historyMessage.data;
+                    if (historyMessage.mimeType)
+                        messageToAdd.mimeType = historyMessage.mimeType;
+                    if (historyMessage.toolCalls)
+                        messageToAdd.toolCalls = historyMessage.toolCalls;
+                    if (historyMessage.toolCallId)
+                        messageToAdd.toolCallId = historyMessage.toolCallId;
+                    if (historyMessage.toolCallResponse)
+                        messageToAdd.toolCallResponse = historyMessage.toolCallResponse;
+                    messages.push(messageToAdd);
+                }
+            }
+        }
+        else {
+            // Fallback to single formatted message (for backward compatibility)
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log("⚠️ [formatConversation] No conversation history available, using single formatted message");
+            }
             const messageToAdd = {
                 __typename: "ConversationMessage",
                 role: formattedMessage.role || Types.ConversationRoleTypes.User,
@@ -1710,9 +1755,6 @@ class Graphlit {
             }
             messages.push(messageToAdd);
         }
-        else {
-            throw new Error("No formatted message returned from formatConversation");
-        }
         const serviceType = getServiceType(specification);
         // Handle tool calling loop locally
         while (currentRound < maxRounds) {

package/dist/streaming/ui-event-adapter.js

@@ -155,12 +155,28 @@ export class UIEventAdapter {
             globalThis.clearTimeout(this.updateTimer);
             this.updateTimer = undefined;
         }
-        // DO NOT re-process chunks here - they should already be in currentMessage
-        // Just clear any remaining state
+        // Process any remaining chunks before completing
+        if (this.chunkQueue.length > 0) {
+            // Add all remaining chunks to current message
+            const remainingChunks = this.chunkQueue.join('');
+            const chunkCount = this.chunkQueue.length;
+            this.currentMessage += remainingChunks;
+            this.chunkQueue.length = 0; // Clear the queue after processing
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`🔚 [UIEventAdapter] Processed ${chunkCount} remaining chunks: "${remainingChunks}"`);
+            }
+        }
+        // Flush any remaining content from the buffer
         if (this.chunkBuffer) {
-            this.chunkBuffer.flush(); // Clear the buffer but don't use the result
+            const finalChunks = this.chunkBuffer.flush();
+            if (finalChunks.length > 0) {
+                const finalContent = finalChunks.join('');
+                this.currentMessage += finalContent;
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`🔚 [UIEventAdapter] Flushed buffer with ${finalChunks.length} chunks: "${finalContent}"`);
+                }
+            }
         }
-        this.chunkQueue.length = 0; // Clear any remaining queue
         this.isStreaming = false;
         // Create final message
         const finalMessage = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20250612006",
+  "version": "1.0.20250612008",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",