graphlit-client 1.0.20250612007 → 1.0.20250612009

package/dist/client.js

@@ -4,7 +4,7 @@ import { ApolloClient, InMemoryCache, createHttpLink, ApolloLink, ApolloError, }
 import * as Types from "./generated/graphql-types.js";
 import * as Documents from "./generated/graphql-documents.js";
 import * as dotenv from "dotenv";
-import { getServiceType } from "./model-mapping.js";
+import { getServiceType, getModelName } from "./model-mapping.js";
 import { UIEventAdapter } from "./streaming/ui-event-adapter.js";
 import { formatMessagesForOpenAI, formatMessagesForAnthropic, formatMessagesForGoogle, } from "./streaming/llm-formatters.js";
 import { streamWithOpenAI, streamWithAnthropic, streamWithGoogle, } from "./streaming/providers.js";
@@ -1626,11 +1626,15 @@ class Graphlit {
                 });
                 return; // Exit early after successful fallback
             }
-            // Create UI event adapter
+            // Create UI event adapter with model information
+            const modelName = fullSpec ? getModelName(fullSpec) : undefined;
+            const serviceType = fullSpec ? getServiceType(fullSpec) : undefined;
             uiAdapter = new UIEventAdapter(onEvent, actualConversationId, {
                 smoothingEnabled: options?.smoothingEnabled ?? true,
                 chunkingStrategy: options?.chunkingStrategy ?? "word",
                 smoothingDelay: options?.smoothingDelay ?? 30,
+                model: modelName,
+                modelService: serviceType,
             });
             // Start the streaming conversation
             await this.executeStreamingAgent(prompt, actualConversationId, fullSpec, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId);
@@ -1678,11 +1682,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 = [];
@@ -1695,9 +1708,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,
@@ -1714,9 +1759,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.d.ts

@@ -9,8 +9,13 @@ export declare class UIEventAdapter {
     private onEvent;
     private conversationId;
     private model?;
+    private modelService?;
+    private tokenCount;
     private currentMessage;
     private isStreaming;
+    private streamStartTime;
+    private firstTokenTime;
+    private lastTokenTime;
     private activeToolCalls;
     private lastUpdateTime;
     private updateTimer?;
@@ -21,6 +26,8 @@ export declare class UIEventAdapter {
         smoothingEnabled?: boolean;
         chunkingStrategy?: ChunkingStrategy;
         smoothingDelay?: number;
+        model?: string;
+        modelService?: string;
     });
     /**
      * Process a raw streaming event and emit appropriate UI events

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

@@ -8,8 +8,13 @@ export class UIEventAdapter {
     onEvent;
     conversationId;
     model;
+    modelService;
+    tokenCount = 0;
     currentMessage = "";
     isStreaming = false;
+    streamStartTime = 0;
+    firstTokenTime = 0;
+    lastTokenTime = 0;
     activeToolCalls = new Map();
     lastUpdateTime = 0;
     updateTimer;
@@ -20,6 +25,8 @@ export class UIEventAdapter {
         this.onEvent = onEvent;
         this.conversationId = conversationId;
         this.smoothingDelay = options.smoothingDelay ?? 30;
+        this.model = options.model;
+        this.modelService = options.modelService;
         if (options.smoothingEnabled) {
             this.chunkBuffer = new ChunkBuffer(options.chunkingStrategy || "word");
         }
@@ -84,6 +91,9 @@ export class UIEventAdapter {
     handleStart(conversationId) {
         this.conversationId = conversationId;
         this.isStreaming = true;
+        this.streamStartTime = Date.now();
+        this.firstTokenTime = 0;
+        this.lastTokenTime = 0;
         this.emitUIEvent({
             type: "conversation_started",
             conversationId,
@@ -92,6 +102,12 @@ export class UIEventAdapter {
         });
     }
     handleToken(token) {
+        // Track timing for first token
+        const now = Date.now();
+        if (this.firstTokenTime === 0) {
+            this.firstTokenTime = now;
+        }
+        this.lastTokenTime = now;
         if (this.chunkBuffer) {
             const chunks = this.chunkBuffer.addToken(token);
             // Add chunks to queue for all chunking modes (character, word, sentence)
@@ -155,14 +171,30 @@ 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
+        // Create final message with metadata
         const finalMessage = {
             __typename: "ConversationMessage",
             role: ConversationRoleTypes.Assistant,
@@ -170,7 +202,26 @@ export class UIEventAdapter {
             timestamp: new Date().toISOString(),
             tokens: undefined, // Will be set by caller if available
             toolCalls: Array.from(this.activeToolCalls.values()).map((t) => t.toolCall),
+            model: this.model,
+            modelService: this.modelService,
         };
+        // Add final timing metadata
+        if (this.streamStartTime > 0) {
+            const totalTime = Date.now() - this.streamStartTime;
+            // Final throughput (chars/second)
+            finalMessage.throughput = totalTime > 0
+                ? Math.round((this.currentMessage.length / totalTime) * 1000)
+                : 0;
+            // Total completion time in seconds
+            finalMessage.completionTime = totalTime / 1000;
+            // Add time to first token if we have it (useful metric)
+            if (this.firstTokenTime > 0) {
+                const ttft = this.firstTokenTime - this.streamStartTime;
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`⏱️ [UIEventAdapter] TTFT: ${ttft}ms | Total: ${totalTime}ms | Throughput: ${finalMessage.throughput} chars/s`);
+                }
+            }
+        }
         this.emitUIEvent({
             type: "conversation_completed",
             message: finalMessage,
@@ -258,6 +309,27 @@ export class UIEventAdapter {
             message: this.currentMessage,
             timestamp: new Date().toISOString(),
         };
+        // Add model metadata if available
+        if (this.model) {
+            message.model = this.model;
+        }
+        if (this.modelService) {
+            message.modelService = this.modelService;
+        }
+        // Add timing metadata if streaming has started
+        if (this.streamStartTime > 0) {
+            const now = Date.now();
+            const elapsedTime = now - this.streamStartTime;
+            // Calculate throughput (chars/second)
+            const throughput = elapsedTime > 0
+                ? Math.round((this.currentMessage.length / elapsedTime) * 1000)
+                : 0;
+            message.throughput = throughput;
+            // Add completion time if we have it (in seconds to match API)
+            if (elapsedTime > 0) {
+                message.completionTime = elapsedTime / 1000;
+            }
+        }
         this.emitUIEvent({
             type: "message_update",
             message,

package/package.json

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