graphlit-client 1.0.20250611018 → 1.0.20250611020

package/dist/client.js

@@ -1419,26 +1419,28 @@ class Graphlit {
             if (process.env.DEBUG_GRAPHLIT_STREAMING) {
                 console.log("[supportsStreaming] Checking support for:", {
                     serviceType,
-                    hasOpenAI: OpenAI !== undefined,
-                    hasAnthropic: Anthropic !== undefined,
-                    hasGoogle: GoogleGenerativeAI !== 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 OpenAI !== undefined;
+                    return OpenAI !== undefined || this.openaiClient !== undefined;
                 case Types.ModelServiceTypes.Anthropic:
-                    return Anthropic !== undefined;
+                    return Anthropic !== undefined || this.anthropicClient !== undefined;
                 case Types.ModelServiceTypes.Google:
-                    return GoogleGenerativeAI !== undefined;
+                    return GoogleGenerativeAI !== undefined || this.googleClient !== undefined;
                 default:
                     return false;
             }
         }
-        // If we have no specification, check if OpenAI client is available
-        // We default to OpenAI GPT-4o if no specification provider.
-        const hasOpenAI = OpenAI !== undefined;
-        return hasOpenAI;
+        // If we have no specification, check if any client is available
+        // 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 = [];
@@ -1677,7 +1677,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 +1697,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 +1717,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 +1738,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 +1996,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,6 +2019,9 @@ 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)`);
+            }
         }
     }
     /**
@@ -1988,6 +2036,12 @@ class Graphlit {
             new OpenAI({
                 apiKey: process.env.OPENAI_API_KEY || "",
             });
+        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);
     }
     /**
@@ -2002,6 +2056,13 @@ class Graphlit {
             new Anthropic({
                 apiKey: process.env.ANTHROPIC_API_KEY || "",
             });
+        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);
     }
     /**
@@ -2014,6 +2075,13 @@ class Graphlit {
         // Use provided client or create a new one
         const googleClient = this.googleClient ||
             new GoogleGenerativeAI(process.env.GOOGLE_API_KEY || "");
+        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/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.20250611018",
+  "version": "1.0.20250611020",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",