graphlit-client 1.0.20250611019 → 1.0.20250612001

package/dist/client.js

@@ -1419,26 +1419,28 @@ class Graphlit {
             if (process.env.DEBUG_GRAPHLIT_STREAMING) {
                 console.log("[supportsStreaming] Checking support for:", {
                     serviceType,
-                    hasOpenAI: this.openaiClient !== undefined,
-                    hasAnthropic: this.anthropicClient !== undefined,
-                    hasGoogle: this.googleClient !== undefined,
+                    hasOpenAI: OpenAI !== undefined || this.openaiClient !== undefined,
+                    hasAnthropic: Anthropic !== undefined || this.anthropicClient !== undefined,
+                    hasGoogle: GoogleGenerativeAI !== undefined || this.googleClient !== undefined,
                 });
             }
             switch (serviceType) {
                 case Types.ModelServiceTypes.OpenAi:
-                    return this.openaiClient !== undefined;
+                    return OpenAI !== undefined || this.openaiClient !== undefined;
                 case Types.ModelServiceTypes.Anthropic:
-                    return this.anthropicClient !== undefined;
+                    return Anthropic !== undefined || this.anthropicClient !== undefined;
                 case Types.ModelServiceTypes.Google:
-                    return this.googleClient !== undefined;
+                    return GoogleGenerativeAI !== undefined || this.googleClient !== undefined;
                 default:
                     return false;
             }
         }
         // If we have no specification, check if any client is available
-        return (this.openaiClient !== undefined ||
-            this.anthropicClient !== undefined ||
-            this.googleClient !== undefined);
+        // Check both module-level SDKs and instance-level clients
+        const hasOpenAI = OpenAI !== undefined || this.openaiClient !== undefined;
+        const hasAnthropic = Anthropic !== undefined || this.anthropicClient !== undefined;
+        const hasGoogle = GoogleGenerativeAI !== undefined || this.googleClient !== undefined;
+        return hasOpenAI || hasAnthropic || hasGoogle;
     }
     /**
      * Execute an agent with non-streaming response
@@ -1640,9 +1642,7 @@ class Graphlit {
             throw new Error("Failed to format conversation");
         }
         if (process.env.DEBUG_GRAPHLIT_STREAMING) {
-            console.log("\n📋 [formatConversation] Response:");
-            console.log("Formatted message:", formattedMessage.message);
-            console.log("Full formatConversation response:", JSON.stringify(formatResponse.formatConversation, null, 2));
+            console.log("\n📋 [formatConversation] Response", formattedMessage.message);
         }
         // Build message array with conversation history
         const messages = [];
@@ -1658,12 +1658,21 @@ class Graphlit {
         // Use the formatted message from formatConversation which already includes
         // all context, RAG results, and conversation history
         if (formattedMessage) {
-            messages.push({
+            const messageToAdd = {
                 __typename: "ConversationMessage",
                 role: formattedMessage.role || Types.ConversationRoleTypes.User,
                 message: formattedMessage.message,
                 timestamp: formattedMessage.timestamp || new Date().toISOString(),
-            });
+            };
+            // Add image data if provided
+            if (mimeType && data) {
+                messageToAdd.mimeType = mimeType;
+                messageToAdd.data = data;
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`\n🖼️ [Streaming] Adding image data to message: ${mimeType}, ${data.length} chars`);
+                }
+            }
+            messages.push(messageToAdd);
         }
         else {
             throw new Error("No formatted message returned from formatConversation");
@@ -1677,7 +1686,16 @@ class Graphlit {
             let toolCalls = [];
             let roundMessage = "";
             // Stream with appropriate provider
-            if (serviceType === Types.ModelServiceTypes.OpenAi && OpenAI) {
+            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                console.log(`\n🔀 [Streaming Decision] Service: ${serviceType}, Round: ${currentRound}`);
+                console.log(`   OpenAI available: ${!!(OpenAI || this.openaiClient)}`);
+                console.log(`   Anthropic available: ${!!(Anthropic || this.anthropicClient)}`);
+                console.log(`   Google available: ${!!(GoogleGenerativeAI || this.googleClient)}`);
+            }
+            if (serviceType === Types.ModelServiceTypes.OpenAi && (OpenAI || this.openaiClient)) {
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using OpenAI native streaming (Round ${currentRound})`);
+                }
                 const openaiMessages = formatMessagesForOpenAI(messages);
                 if (process.env.DEBUG_GRAPHLIT_STREAMING) {
                     console.log("\n🔍 [OpenAI] Formatted messages being sent to LLM:");
@@ -1688,9 +1706,15 @@ class Graphlit {
                     roundMessage = message;
                     toolCalls = calls;
                 });
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`\n🏁 [Streaming] OpenAI native streaming completed (Round ${currentRound})`);
+                }
             }
             else if (serviceType === Types.ModelServiceTypes.Anthropic &&
-                Anthropic) {
+                (Anthropic || this.anthropicClient)) {
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using Anthropic native streaming (Round ${currentRound})`);
+                }
                 const { system, messages: anthropicMessages } = formatMessagesForAnthropic(messages);
                 if (process.env.DEBUG_GRAPHLIT_STREAMING) {
                     console.log("\n🔍 [Anthropic] Formatted messages being sent to LLM:");
@@ -1702,9 +1726,15 @@ class Graphlit {
                     roundMessage = message;
                     toolCalls = calls;
                 });
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`\n🏁 [Streaming] Anthropic native streaming completed (Round ${currentRound})`);
+                }
             }
             else if (serviceType === Types.ModelServiceTypes.Google &&
-                GoogleGenerativeAI) {
+                (GoogleGenerativeAI || this.googleClient)) {
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using Google native streaming (Round ${currentRound})`);
+                }
                 const googleMessages = formatMessagesForGoogle(messages);
                 if (process.env.DEBUG_GRAPHLIT_STREAMING) {
                     console.log("\n🔍 [Google] Formatted messages being sent to LLM:");
@@ -1717,10 +1747,21 @@ class Graphlit {
                     roundMessage = message;
                     toolCalls = calls;
                 });
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`\n🏁 [Streaming] Google native streaming completed (Round ${currentRound})`);
+                }
             }
             else {
                 // Fallback to non-streaming
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`\n⚠️  [Fallback] No native streaming available for ${serviceType} (Round ${currentRound})`);
+                    console.log(`   Falling back to non-streaming promptConversation`);
+                    console.log(`   This should NOT happen if clients are properly set!`);
+                }
                 await this.fallbackToNonStreaming(prompt, conversationId, specification, tools, mimeType, data, uiAdapter, correlationId);
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`\n🏁 [Fallback] Non-streaming fallback completed (Round ${currentRound})`);
+                }
                 break;
             }
             // Update the full message
@@ -1964,8 +2005,21 @@ class Graphlit {
      * Fallback to non-streaming when streaming is not available
      */
     async fallbackToNonStreaming(prompt, conversationId, specification, tools, mimeType, data, uiAdapter, correlationId) {
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log(`\n🔄 [Fallback] Starting non-streaming fallback`);
+            console.log(`   Conversation ID: ${conversationId}`);
+            console.log(`   Specification: ${specification.name} (${specification.serviceType})`);
+            console.log(`   Prompt: "${prompt.substring(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
+            console.log(`   About to call promptConversation...`);
+        }
         const response = await this.promptConversation(prompt, conversationId, { id: specification.id }, mimeType, data, tools, false, false, correlationId);
         const message = response.promptConversation?.message;
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log(`\n✅ [Fallback] promptConversation completed`);
+            console.log(`   Response message length: ${message?.message?.length || 0} chars`);
+            console.log(`   Response preview: "${message?.message?.substring(0, 100) || 'NO MESSAGE'}${(message?.message?.length || 0) > 100 ? '...' : ''}"`);
+            console.log(`   Now simulating streaming by splitting into tokens...`);
+        }
         if (message?.message) {
             // Simulate streaming by emitting tokens
             const words = message.message.split(" ");
@@ -1974,46 +2028,72 @@ class Graphlit {
                 uiAdapter.handleEvent({ type: "token", token });
             }
             uiAdapter.handleEvent({ type: "message", message: message.message });
+            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                console.log(`\n🎯 [Fallback] Completed token simulation (${words.length} tokens)`);
+            }
         }
     }
     /**
      * Stream with OpenAI client
      */
     async streamWithOpenAI(specification, messages, tools, uiAdapter, onComplete) {
-        if (!OpenAI) {
+        // Check if we have either the OpenAI module or a provided client
+        if (!OpenAI && !this.openaiClient) {
             throw new Error("OpenAI client not available");
         }
         // Use provided client or create a new one
         const openaiClient = this.openaiClient ||
-            new OpenAI({
+            (OpenAI ? new OpenAI({
                 apiKey: process.env.OPENAI_API_KEY || "",
-            });
+            }) : (() => { throw new Error("OpenAI module not available"); })());
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n🚀 [Graphlit SDK] Routing to OpenAI streaming provider");
+            console.log(`  📋 Specification: ${specification.name} (${specification.id})`);
+            console.log(`  📝 Messages: ${messages.length}`);
+            console.log(`  🔧 Tools: ${tools?.length || 0}`);
+        }
         await streamWithOpenAI(specification, messages, tools, openaiClient, (event) => uiAdapter.handleEvent(event), onComplete);
     }
     /**
      * Stream with Anthropic client
      */
     async streamWithAnthropic(specification, messages, systemPrompt, tools, uiAdapter, onComplete) {
-        if (!Anthropic) {
+        // Check if we have either the Anthropic module or a provided client
+        if (!Anthropic && !this.anthropicClient) {
             throw new Error("Anthropic client not available");
         }
         // Use provided client or create a new one
         const anthropicClient = this.anthropicClient ||
-            new Anthropic({
+            (Anthropic ? new Anthropic({
                 apiKey: process.env.ANTHROPIC_API_KEY || "",
-            });
+            }) : (() => { throw new Error("Anthropic module not available"); })());
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n🚀 [Graphlit SDK] Routing to Anthropic streaming provider");
+            console.log(`  📋 Specification: ${specification.name} (${specification.id})`);
+            console.log(`  📝 Messages: ${messages.length}`);
+            console.log(`  🔧 Tools: ${tools?.length || 0}`);
+            console.log(`  💬 System Prompt: ${systemPrompt ? 'Yes' : 'No'}`);
+        }
         await streamWithAnthropic(specification, messages, systemPrompt, tools, anthropicClient, (event) => uiAdapter.handleEvent(event), onComplete);
     }
     /**
      * Stream with Google client
      */
     async streamWithGoogle(specification, messages, systemPrompt, tools, uiAdapter, onComplete) {
-        if (!GoogleGenerativeAI) {
+        // Check if we have either the Google module or a provided client
+        if (!GoogleGenerativeAI && !this.googleClient) {
             throw new Error("Google GenerativeAI client not available");
         }
         // Use provided client or create a new one
         const googleClient = this.googleClient ||
-            new GoogleGenerativeAI(process.env.GOOGLE_API_KEY || "");
+            (GoogleGenerativeAI ? new GoogleGenerativeAI(process.env.GOOGLE_API_KEY || "") : (() => { throw new Error("Google GenerativeAI module not available"); })());
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n🚀 [Graphlit SDK] Routing to Google streaming provider");
+            console.log(`  📋 Specification: ${specification.name} (${specification.id})`);
+            console.log(`  📝 Messages: ${messages.length}`);
+            console.log(`  🔧 Tools: ${tools?.length || 0}`);
+            console.log(`  💬 System Prompt: ${systemPrompt ? 'Yes' : 'No'}`);
+        }
         await streamWithGoogle(specification, messages, systemPrompt, tools, googleClient, (event) => uiAdapter.handleEvent(event), onComplete);
     }
     // Helper method to execute tools for promptAgent

package/dist/streaming/llm-formatters.d.ts

@@ -4,7 +4,13 @@ import { ConversationMessage } from "../generated/graphql-types.js";
  */
 export interface OpenAIMessage {
     role: "system" | "user" | "assistant" | "tool";
-    content?: string;
+    content?: string | Array<{
+        type: "text" | "image_url";
+        text?: string;
+        image_url?: {
+            url: string;
+        };
+    }>;
     tool_calls?: Array<{
         id: string;
         type: "function";
@@ -21,8 +27,13 @@ export interface OpenAIMessage {
 export interface AnthropicMessage {
     role: "user" | "assistant";
     content: string | Array<{
-        type: "text" | "tool_use" | "tool_result";
+        type: "text" | "image" | "tool_use" | "tool_result";
         text?: string;
+        source?: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
         id?: string;
         name?: string;
         input?: unknown;
@@ -37,6 +48,10 @@ export interface GoogleMessage {
     role: "user" | "model";
     parts: Array<{
         text?: string;
+        inlineData?: {
+            mimeType: string;
+            data: string;
+        };
         functionCall?: {
             name: string;
             args: unknown;

package/dist/streaming/llm-formatters.js

@@ -53,10 +53,36 @@ export function formatMessagesForOpenAI(messages) {
                 });
                 break;
             default: // User messages
-                formattedMessages.push({
-                    role: "user",
-                    content: trimmedMessage,
-                });
+                // Check if this message has image data
+                if (message.mimeType && message.data) {
+                    // Multi-modal message with image
+                    const contentParts = [];
+                    // Add text content if present
+                    if (trimmedMessage) {
+                        contentParts.push({
+                            type: "text",
+                            text: trimmedMessage,
+                        });
+                    }
+                    // Add image content
+                    contentParts.push({
+                        type: "image_url",
+                        image_url: {
+                            url: `data:${message.mimeType};base64,${message.data}`,
+                        },
+                    });
+                    formattedMessages.push({
+                        role: "user",
+                        content: contentParts,
+                    });
+                }
+                else {
+                    // Text-only message
+                    formattedMessages.push({
+                        role: "user",
+                        content: trimmedMessage,
+                    });
+                }
                 break;
         }
     }
@@ -122,10 +148,38 @@ export function formatMessagesForAnthropic(messages) {
                 });
                 break;
             default: // User messages
-                formattedMessages.push({
-                    role: "user",
-                    content: trimmedMessage,
-                });
+                // Check if this message has image data
+                if (message.mimeType && message.data) {
+                    // Multi-modal message with image
+                    const contentParts = [];
+                    // Add text content if present
+                    if (trimmedMessage) {
+                        contentParts.push({
+                            type: "text",
+                            text: trimmedMessage,
+                        });
+                    }
+                    // Add image content
+                    contentParts.push({
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            media_type: message.mimeType,
+                            data: message.data,
+                        },
+                    });
+                    formattedMessages.push({
+                        role: "user",
+                        content: contentParts,
+                    });
+                }
+                else {
+                    // Text-only message
+                    formattedMessages.push({
+                        role: "user",
+                        content: trimmedMessage,
+                    });
+                }
                 break;
         }
     }
@@ -138,9 +192,14 @@ export function formatMessagesForAnthropic(messages) {
 export function formatMessagesForGoogle(messages) {
     const formattedMessages = [];
     for (const message of messages) {
-        if (!message.role || !message.message?.trim())
+        if (!message.role)
             continue;
-        const trimmedMessage = message.message.trim();
+        // Allow messages with image data even if they have no text content
+        const hasContent = message.message?.trim();
+        const hasImageData = message.mimeType && message.data;
+        if (!hasContent && !hasImageData)
+            continue;
+        const trimmedMessage = message.message?.trim() || "";
         switch (message.role) {
             case ConversationRoleTypes.System:
                 // Google handles system prompts differently, usually as part of the first user message
@@ -176,10 +235,33 @@ export function formatMessagesForGoogle(messages) {
                 });
                 break;
             default: // User messages
-                formattedMessages.push({
-                    role: "user",
-                    parts: [{ text: trimmedMessage }],
-                });
+                // Check if this message has image data
+                if (message.mimeType && message.data) {
+                    // Multi-modal message with image
+                    const parts = [];
+                    // Add text content if present
+                    if (trimmedMessage) {
+                        parts.push({ text: trimmedMessage });
+                    }
+                    // Add image content
+                    parts.push({
+                        inlineData: {
+                            mimeType: message.mimeType,
+                            data: message.data,
+                        },
+                    });
+                    formattedMessages.push({
+                        role: "user",
+                        parts,
+                    });
+                }
+                else {
+                    // Text-only message
+                    formattedMessages.push({
+                        role: "user",
+                        parts: [{ text: trimmedMessage }],
+                    });
+                }
                 break;
         }
     }

package/dist/streaming/providers.js

@@ -18,6 +18,12 @@ export async function streamWithOpenAI(specification, messages, tools, openaiCli
 onEvent, onComplete) {
     let fullMessage = "";
     let toolCalls = [];
+    // Performance metrics
+    const startTime = Date.now();
+    let firstTokenTime = 0;
+    let tokenCount = 0;
+    let lastEventTime = 0;
+    const interTokenDelays = [];
     try {
         const modelName = getModelName(specification);
         if (!modelName) {
@@ -55,6 +61,9 @@ onEvent, onComplete) {
                 },
             }));
         }
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n⏱️  [OpenAI] Starting LLM call at:", new Date().toISOString());
+        }
         const stream = await openaiClient.chat.completions.create(streamConfig);
         for await (const chunk of stream) {
             const delta = chunk.choices[0]?.delta;
@@ -73,9 +82,23 @@ onEvent, onComplete) {
             }
             if (delta?.content) {
                 fullMessage += delta.content;
+                tokenCount++;
+                const currentTime = Date.now();
+                // Track TTFT
+                if (firstTokenTime === 0) {
+                    firstTokenTime = currentTime - startTime;
+                    if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                        console.log(`\n⚡ [OpenAI] Time to First Token (TTFT): ${firstTokenTime}ms`);
+                    }
+                }
+                // Track inter-token delays
+                if (lastEventTime > 0) {
+                    const delay = currentTime - lastEventTime;
+                    interTokenDelays.push(delay);
+                }
+                lastEventTime = currentTime;
                 if (process.env.DEBUG_GRAPHLIT_STREAMING) {
-                    console.log(`[OpenAI] Message accumulated: ${fullMessage.length} chars total`);
-                    console.log(`[OpenAI] Current full message: "${fullMessage}"`);
+                    console.log(`[OpenAI] Token #${tokenCount}: "${delta.content}" | Accumulated: ${fullMessage.length} chars`);
                 }
                 onEvent({
                     type: "token",
@@ -153,8 +176,27 @@ onEvent, onComplete) {
         if (process.env.DEBUG_GRAPHLIT_STREAMING && toolCalls.length > 0) {
             console.log(`[OpenAI] Successfully processed ${toolCalls.length} tool calls`);
         }
+        // Calculate final metrics
+        const totalTime = Date.now() - startTime;
+        const tokensPerSecond = tokenCount > 0 ? tokenCount / (totalTime / 1000) : 0;
         if (process.env.DEBUG_GRAPHLIT_STREAMING) {
-            console.log(`[OpenAI] Streaming complete. Final message: "${fullMessage}" (${fullMessage.length} chars)`);
+            console.log("\n📊 [OpenAI] Performance Metrics:");
+            console.log(`  ⏱️  Total Time: ${totalTime}ms`);
+            console.log(`  ⚡ Time to First Token (TTFT): ${firstTokenTime}ms`);
+            console.log(`  📈 Tokens Generated: ${tokenCount}`);
+            console.log(`  💨 Tokens Per Second (TPS): ${tokensPerSecond.toFixed(2)}`);
+            if (interTokenDelays.length > 0) {
+                const avgDelay = interTokenDelays.reduce((a, b) => a + b, 0) / interTokenDelays.length;
+                const sortedDelays = [...interTokenDelays].sort((a, b) => a - b);
+                const p50Delay = sortedDelays[Math.floor(sortedDelays.length * 0.5)];
+                const p95Delay = sortedDelays[Math.floor(sortedDelays.length * 0.95)];
+                const p99Delay = sortedDelays[Math.floor(sortedDelays.length * 0.99)];
+                console.log(`  ⏳ Average Inter-Token Delay: ${avgDelay.toFixed(2)}ms`);
+                console.log(`  📊 P50 Delay: ${p50Delay}ms`);
+                console.log(`  ⚠️  P95 Delay: ${p95Delay}ms`);
+                console.log(`  🚨 P99 Delay: ${p99Delay}ms`);
+            }
+            console.log(`\n✅ [OpenAI] Final message (${fullMessage.length} chars): "${fullMessage}"`);
         }
         onComplete(fullMessage, toolCalls);
     }
@@ -173,6 +215,12 @@ export async function streamWithAnthropic(specification, messages, systemPrompt,
 onEvent, onComplete) {
     let fullMessage = "";
     let toolCalls = [];
+    // Performance metrics
+    const startTime = Date.now();
+    let firstTokenTime = 0;
+    let tokenCount = 0;
+    let lastEventTime = 0;
+    const interTokenDelays = [];
     try {
         const modelName = getModelName(specification);
         if (!modelName) {
@@ -207,6 +255,9 @@ onEvent, onComplete) {
                 input_schema: tool.schema ? JSON.parse(tool.schema) : {},
             }));
         }
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n⏱️  [Anthropic] Starting LLM call at:", new Date().toISOString());
+        }
         const stream = await anthropicClient.messages.create(streamConfig);
         let activeContentBlock = false;
         for await (const chunk of stream) {
@@ -234,10 +285,25 @@ onEvent, onComplete) {
             }
             else if (chunk.type === "content_block_delta") {
                 if (chunk.delta.type === "text_delta") {
+                    fullMessage += chunk.delta.text;
+                    tokenCount++;
+                    const currentTime = Date.now();
+                    // Track TTFT
+                    if (firstTokenTime === 0) {
+                        firstTokenTime = currentTime - startTime;
+                        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                            console.log(`\n⚡ [Anthropic] Time to First Token (TTFT): ${firstTokenTime}ms`);
+                        }
+                    }
+                    // Track inter-token delays
+                    if (lastEventTime > 0) {
+                        const delay = currentTime - lastEventTime;
+                        interTokenDelays.push(delay);
+                    }
+                    lastEventTime = currentTime;
                     if (process.env.DEBUG_GRAPHLIT_STREAMING) {
-                        console.log(`[Anthropic] Text delta: "${chunk.delta.text}"`);
+                        console.log(`[Anthropic] Token #${tokenCount}: "${chunk.delta.text}" | Accumulated: ${fullMessage.length} chars`);
                     }
-                    fullMessage += chunk.delta.text;
                     onEvent({
                         type: "token",
                         token: chunk.delta.text,
@@ -336,6 +402,28 @@ onEvent, onComplete) {
             console.log(`[Anthropic] Filtered out ${toolCalls.length - validToolCalls.length} incomplete tool calls`);
             console.log(`[Anthropic] Successfully processed ${validToolCalls.length} valid tool calls`);
         }
+        // Calculate final metrics
+        const totalTime = Date.now() - startTime;
+        const tokensPerSecond = tokenCount > 0 ? tokenCount / (totalTime / 1000) : 0;
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n📊 [Anthropic] Performance Metrics:");
+            console.log(`  ⏱️  Total Time: ${totalTime}ms`);
+            console.log(`  ⚡ Time to First Token (TTFT): ${firstTokenTime}ms`);
+            console.log(`  📈 Tokens Generated: ${tokenCount}`);
+            console.log(`  💨 Tokens Per Second (TPS): ${tokensPerSecond.toFixed(2)}`);
+            if (interTokenDelays.length > 0) {
+                const avgDelay = interTokenDelays.reduce((a, b) => a + b, 0) / interTokenDelays.length;
+                const sortedDelays = [...interTokenDelays].sort((a, b) => a - b);
+                const p50Delay = sortedDelays[Math.floor(sortedDelays.length * 0.5)];
+                const p95Delay = sortedDelays[Math.floor(sortedDelays.length * 0.95)];
+                const p99Delay = sortedDelays[Math.floor(sortedDelays.length * 0.99)];
+                console.log(`  ⏳ Average Inter-Token Delay: ${avgDelay.toFixed(2)}ms`);
+                console.log(`  📊 P50 Delay: ${p50Delay}ms`);
+                console.log(`  ⚠️  P95 Delay: ${p95Delay}ms`);
+                console.log(`  🚨 P99 Delay: ${p99Delay}ms`);
+            }
+            console.log(`\n✅ [Anthropic] Final message (${fullMessage.length} chars): "${fullMessage}"`);
+        }
         onComplete(fullMessage, validToolCalls);
     }
     catch (error) {
@@ -353,6 +441,12 @@ export async function streamWithGoogle(specification, messages, systemPrompt, to
 onEvent, onComplete) {
     let fullMessage = "";
     let toolCalls = [];
+    // Performance metrics
+    const startTime = Date.now();
+    let firstTokenTime = 0;
+    let tokenCount = 0;
+    let lastEventTime = 0;
+    const interTokenDelays = [];
     try {
         const modelName = getModelName(specification);
         if (!modelName) {
@@ -559,6 +653,28 @@ onEvent, onComplete) {
         if (process.env.DEBUG_GRAPHLIT_STREAMING && toolCalls.length > 0) {
             console.log(`[Google] Successfully processed ${toolCalls.length} tool calls`);
         }
+        // Calculate final metrics
+        const totalTime = Date.now() - startTime;
+        const tokensPerSecond = tokenCount > 0 ? tokenCount / (totalTime / 1000) : 0;
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n📊 [Google] Performance Metrics:");
+            console.log(`  ⏱️  Total Time: ${totalTime}ms`);
+            console.log(`  ⚡ Time to First Token (TTFT): ${firstTokenTime}ms`);
+            console.log(`  📈 Tokens Generated: ${tokenCount}`);
+            console.log(`  💨 Tokens Per Second (TPS): ${tokensPerSecond.toFixed(2)}`);
+            if (interTokenDelays.length > 0) {
+                const avgDelay = interTokenDelays.reduce((a, b) => a + b, 0) / interTokenDelays.length;
+                const sortedDelays = [...interTokenDelays].sort((a, b) => a - b);
+                const p50Delay = sortedDelays[Math.floor(sortedDelays.length * 0.5)];
+                const p95Delay = sortedDelays[Math.floor(sortedDelays.length * 0.95)];
+                const p99Delay = sortedDelays[Math.floor(sortedDelays.length * 0.99)];
+                console.log(`  ⏳ Average Inter-Token Delay: ${avgDelay.toFixed(2)}ms`);
+                console.log(`  📊 P50 Delay: ${p50Delay}ms`);
+                console.log(`  ⚠️  P95 Delay: ${p95Delay}ms`);
+                console.log(`  🚨 P99 Delay: ${p99Delay}ms`);
+            }
+            console.log(`\n✅ [Google] Final message (${fullMessage.length} chars): "${fullMessage}"`);
+        }
         onComplete(fullMessage, toolCalls);
     }
     catch (error) {

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

@@ -150,21 +150,17 @@ export class UIEventAdapter {
         }
     }
     handleComplete() {
-        // Flush any remaining chunks from buffer
-        if (this.chunkBuffer) {
-            const remaining = this.chunkBuffer.flush();
-            this.chunkQueue.push(...remaining);
-        }
         // Clear any pending updates
         if (this.updateTimer) {
             globalThis.clearTimeout(this.updateTimer);
             this.updateTimer = undefined;
         }
-        // Immediately flush all queued chunks
-        while (this.chunkQueue.length > 0) {
-            const chunk = this.chunkQueue.shift();
-            this.currentMessage += chunk;
+        // DO NOT re-process chunks here - they should already be in currentMessage
+        // Just clear any remaining state
+        if (this.chunkBuffer) {
+            this.chunkBuffer.flush(); // Clear the buffer but don't use the result
         }
+        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.20250611019",
+  "version": "1.0.20250612001",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",