graphlit-client 1.0.20250922001 → 1.0.20250924002

package/dist/client.js

@@ -6,7 +6,7 @@ import { RetryLink } from "@apollo/client/link/retry/index.js";
 import * as Types from "./generated/graphql-types.js";
 import * as Documents from "./generated/graphql-documents.js";
 import * as dotenv from "dotenv";
-import { getServiceType, getModelName } from "./model-mapping.js";
+import { getServiceType, getModelName, getModelEnum } from "./model-mapping.js";
 import { UIEventAdapter } from "./streaming/ui-event-adapter.js";
 import { formatMessagesForOpenAI, formatMessagesForAnthropic, formatMessagesForGoogle, formatMessagesForMistral, formatMessagesForBedrock, } from "./streaming/llm-formatters.js";
 import { streamWithOpenAI, streamWithAnthropic, streamWithGoogle, streamWithGroq, streamWithCerebras, streamWithCohere, streamWithMistral, streamWithBedrock, streamWithDeepseek, streamWithXai, } from "./streaming/providers.js";
@@ -2174,12 +2174,14 @@ class Graphlit {
             }
             // Create UI event adapter with model information
             const modelName = fullSpec ? getModelName(fullSpec) : undefined;
+            const modelEnum = fullSpec ? getModelEnum(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,
+                model: modelEnum,
+                modelName: modelName,
                 modelService: serviceType,
             });
             // Start the streaming conversation
@@ -2486,7 +2488,7 @@ class Graphlit {
                 // Mistral API requires that we don't pass tools when sending tool results
                 const shouldPassTools = toolResponseCount === 0 ? tools : undefined;
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                    console.log(`🔍 [Mistral] Passing tools: ${shouldPassTools ? 'YES' : 'NO'} (tool responses in messages: ${toolResponseCount})`);
+                    console.log(`🔍 [Mistral] Passing tools: ${shouldPassTools ? "YES" : "NO"} (tool responses in messages: ${toolResponseCount})`);
                 }
                 await this.streamWithMistral(specification, mistralMessages, shouldPassTools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;

package/dist/model-mapping.d.ts

@@ -16,3 +16,9 @@ export declare function isStreamingSupported(serviceType?: string): boolean;
  * @returns The service type string
  */
 export declare function getServiceType(specification: any): string | undefined;
+/**
+ * Get the model enum value from specification
+ * @param specification - The specification object
+ * @returns The model enum value
+ */
+export declare function getModelEnum(specification: any): string | undefined;

package/dist/model-mapping.js

@@ -264,3 +264,35 @@ export function isStreamingSupported(serviceType) {
 export function getServiceType(specification) {
     return specification?.serviceType;
 }
+/**
+ * Get the model enum value from specification
+ * @param specification - The specification object
+ * @returns The model enum value
+ */
+export function getModelEnum(specification) {
+    const serviceType = specification?.serviceType;
+    switch (serviceType) {
+        case Types.ModelServiceTypes.OpenAi:
+            return specification?.openAI?.model;
+        case Types.ModelServiceTypes.Anthropic:
+            return specification?.anthropic?.model;
+        case Types.ModelServiceTypes.Google:
+            return specification?.google?.model;
+        case Types.ModelServiceTypes.Groq:
+            return specification?.groq?.model;
+        case Types.ModelServiceTypes.Cerebras:
+            return specification?.cerebras?.model;
+        case Types.ModelServiceTypes.Cohere:
+            return specification?.cohere?.model;
+        case Types.ModelServiceTypes.Mistral:
+            return specification?.mistral?.model;
+        case Types.ModelServiceTypes.Bedrock:
+            return specification?.bedrock?.model;
+        case Types.ModelServiceTypes.Deepseek:
+            return specification?.deepseek?.model;
+        case Types.ModelServiceTypes.Xai:
+            return specification?.xai?.model;
+        default:
+            return undefined;
+    }
+}

package/dist/streaming/llm-formatters.js

@@ -108,56 +108,57 @@ export function formatMessagesForAnthropic(messages) {
                 systemPrompt = trimmedMessage;
                 break;
             case ConversationRoleTypes.Assistant:
-                const content = []; // Use any[] to allow thinking blocks
-                // Handle thinking blocks for extended thinking preservation
-                if (trimmedMessage && trimmedMessage.includes("<thinking")) {
-                    // Extract thinking content and signature if present
-                    const thinkingMatch = trimmedMessage.match(/<thinking(?:\s+signature="([^"]*)")?>([\s\S]*?)<\/thinking>/);
-                    if (thinkingMatch) {
-                        const signature = thinkingMatch[1]; // Optional signature
-                        const thinkingContent = thinkingMatch[2].trim();
-                        // Add thinking block for conversation history preservation
-                        if (thinkingContent) {
-                            const thinkingBlock = {
-                                type: "thinking",
-                                thinking: thinkingContent,
-                            };
-                            // Add signature if present (required by Anthropic API)
-                            if (signature) {
-                                thinkingBlock.signature = signature;
-                            }
-                            else {
-                                // Provide a default signature if none captured
-                                thinkingBlock.signature = "";
-                            }
-                            content.push(thinkingBlock);
-                        }
-                        // Remove thinking tags from the main text and add remaining content
-                        const textWithoutThinking = trimmedMessage
-                            .replace(/<thinking(?:\s+[^>]*)?>[\s\S]*?<\/thinking>/g, "")
-                            .trim();
-                        if (textWithoutThinking) {
-                            content.push({
-                                type: "text",
-                                text: textWithoutThinking,
-                            });
+                const content = [];
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`🔍 [formatMessagesForAnthropic] Processing assistant message: "${trimmedMessage.substring(0, 200)}..."`);
+                    console.log(`🔍 [formatMessagesForAnthropic] Has tool calls: ${message.toolCalls?.length || 0}`);
+                }
+                // Check if message contains thinking content (for Anthropic compatibility)
+                const hasThinking = trimmedMessage.includes('<thinking');
+                if (hasThinking) {
+                    // Parse thinking and text content separately for proper Anthropic format
+                    const thinkingMatch = trimmedMessage.match(/<thinking(?:\s+signature="([^"]*)")?\s*>(.*?)<\/thinking>/s);
+                    const thinkingSignature = thinkingMatch ? thinkingMatch[1] : '';
+                    const thinkingContent = thinkingMatch ? thinkingMatch[2].trim() : '';
+                    const textContent = trimmedMessage.replace(/<thinking(?:\s+signature="[^"]*")?\s*>.*?<\/thinking>/s, '').trim();
+                    if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                        console.log(`🔍 [formatMessagesForAnthropic] Found thinking content: ${thinkingContent.length} chars`);
+                        console.log(`🔍 [formatMessagesForAnthropic] Text content after thinking: "${textContent}"`);
+                        console.log(`🔍 [formatMessagesForAnthropic] Signature: "${thinkingSignature}"`);
+                    }
+                    // CRITICAL: When thinking is enabled, thinking block must come first
+                    if (thinkingContent) {
+                        const thinkingBlock = {
+                            type: "thinking",
+                            thinking: thinkingContent,
+                        };
+                        // Include signature if present
+                        if (thinkingSignature) {
+                            thinkingBlock.signature = thinkingSignature;
                         }
+                        content.push(thinkingBlock);
                     }
-                    else {
-                        // No valid thinking blocks found, add as regular text
+                    // Add text content after thinking block
+                    if (textContent) {
                         content.push({
                             type: "text",
-                            text: trimmedMessage,
+                            text: textContent,
                         });
                     }
                 }
                 else if (trimmedMessage) {
-                    // Add regular text content
+                    // Regular text content
+                    if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                        console.log(`🔍 [formatMessagesForAnthropic] No thinking found, adding text content`);
+                    }
                     content.push({
                         type: "text",
                         text: trimmedMessage,
                     });
                 }
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`🔍 [formatMessagesForAnthropic] Content array: ${content.map(c => c.type).join(', ')}`);
+                }
                 // Add tool uses if present
                 if (message.toolCalls && message.toolCalls.length > 0) {
                     for (const toolCall of message.toolCalls) {

package/dist/streaming/providers.js

@@ -421,15 +421,17 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
         if (!modelName) {
             throw new Error(`No model name found for Anthropic specification: ${specification.name}`);
         }
+        // Calculate smart default for max_tokens based on thinking mode
+        const defaultMaxTokens = thinkingConfig ? 32768 : 8192;
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-            console.log(`🤖 [Anthropic] Model Config: Service=Anthropic | Model=${modelName} | Temperature=${specification.anthropic?.temperature} | MaxTokens=${specification.anthropic?.completionTokenLimit || 8192} | SystemPrompt=${systemPrompt ? "Yes" : "No"} | Tools=${tools?.length || 0} | Spec="${specification.name}"`);
+            console.log(`🤖 [Anthropic] Model Config: Service=Anthropic | Model=${modelName} | Temperature=${specification.anthropic?.temperature} | MaxTokens=${specification.anthropic?.completionTokenLimit || defaultMaxTokens} | SystemPrompt=${systemPrompt ? "Yes" : "No"} | Tools=${tools?.length || 0} | Thinking=${!!thinkingConfig} | Spec="${specification.name}"`);
         }
         // Use proper Anthropic SDK types for the config
         const streamConfig = {
             model: modelName,
             messages,
             stream: true,
-            max_tokens: specification.anthropic?.completionTokenLimit || 8192, // required
+            max_tokens: specification.anthropic?.completionTokenLimit || defaultMaxTokens,
         };
         // Handle temperature based on thinking configuration
         if (thinkingConfig) {
@@ -496,14 +498,17 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
                     console.log(`[Anthropic] Usage data captured from message_start.message:`, usageData);
                 }
             }
-            else if (chunk.type === "message_delta" && chunk.usage && !usageData?.input_tokens) {
+            else if (chunk.type === "message_delta" &&
+                chunk.usage &&
+                !usageData?.input_tokens) {
                 // Only use message_delta if we don't have input_tokens yet
                 usageData = chunk.usage;
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`[Anthropic] Usage data captured from ${chunk.type}:`, usageData);
                 }
             }
-            else if ((chunk.type === "message_delta" || chunk.type === "message_start") && chunk.usage) {
+            else if ((chunk.type === "message_delta" || chunk.type === "message_start") &&
+                chunk.usage) {
                 // Merge usage data if we have partial data
                 if (usageData) {
                     usageData = { ...usageData, ...chunk.usage };
@@ -746,14 +751,24 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
                 }
             }
         }
-        // Final check: filter out any remaining incomplete tool calls
-        const validToolCalls = toolCalls.filter((tc, idx) => {
+        // Final check: normalize and validate tool calls
+        const validToolCalls = toolCalls
+            .map((tc, idx) => {
+            // For tools with no parameters, Anthropic doesn't send input_json_delta
+            // So we need to convert empty arguments to valid JSON
+            if (tc.arguments === "") {
+                tc.arguments = "{}";
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[Anthropic] Normalized empty arguments to "{}" for tool ${tc.name}`);
+                }
+            }
             if (!isValidJSON(tc.arguments)) {
                 console.warn(`[Anthropic] Filtering out incomplete tool call ${idx} (${tc.name}) with INVALID JSON (${tc.arguments.length} chars)`);
-                return false;
+                return null;
             }
-            return true;
-        });
+            return tc;
+        })
+            .filter((tc) => tc !== null);
         if (toolCalls.length !== validToolCalls.length) {
             console.log(`[Anthropic] Filtered out ${toolCalls.length - validToolCalls.length} incomplete tool calls`);
             console.log(`[Anthropic] Successfully processed ${validToolCalls.length} valid tool calls`);
@@ -825,19 +840,26 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
             }
             console.log(`✅ [Anthropic] Final message (${fullMessage.length} chars): "${fullMessage}"`);
         }
-        // Include thinking content in the final message for conversation history preservation
-        let finalMessage = fullMessage;
-        if (completeThinkingContent.trim()) {
-            // Wrap thinking content with signature in special tags that formatMessagesForAnthropic can parse
-            const thinkingBlock = completeThinkingSignature.trim()
+        // Include thinking content in message when there are tool calls (required by Anthropic API)
+        let messageWithThinking = fullMessage;
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🧠 [Anthropic] Debug - validToolCalls: ${validToolCalls.length}, thinking content: ${completeThinkingContent.length} chars, fullMessage: ${fullMessage.length} chars`);
+        }
+        if (validToolCalls.length > 0 && completeThinkingContent.trim()) {
+            // Include thinking content with signature for API compatibility
+            const thinkingXml = completeThinkingSignature
                 ? `<thinking signature="${completeThinkingSignature}">${completeThinkingContent}</thinking>`
                 : `<thinking>${completeThinkingContent}</thinking>`;
-            finalMessage = `${thinkingBlock}${fullMessage}`;
+            messageWithThinking = `${thinkingXml}\n${fullMessage}`.trim();
             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                console.log(`🧠 [Anthropic] Including thinking content (${completeThinkingContent.length} chars) and signature (${completeThinkingSignature.length} chars) in conversation history`);
+                console.log(`🧠 [Anthropic] Including thinking content with message due to tool calls (${completeThinkingContent.length} chars, signature: ${completeThinkingSignature?.length || 0})`);
+                console.log(`🧠 [Anthropic] Final stored message: "${messageWithThinking}"`);
             }
         }
-        onComplete(finalMessage, validToolCalls, usageData);
+        else if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING && completeThinkingContent.trim()) {
+            console.log(`🧠 [Anthropic] Thinking content captured (${completeThinkingContent.length} chars) - not including (no tool calls)`);
+        }
+        onComplete(messageWithThinking, validToolCalls, usageData);
     }
     catch (error) {
         // Handle Anthropic-specific errors
@@ -1095,7 +1117,8 @@ onEvent, onComplete, abortSignal) {
                             continue;
                         }
                         // Only add if it's not already included in fullMessage
-                        if (!fullMessage.includes(finalText) && !fullMessage.endsWith(finalText)) {
+                        if (!fullMessage.includes(finalText) &&
+                            !fullMessage.endsWith(finalText)) {
                             fullMessage += finalText;
                             onEvent({
                                 type: "token",
@@ -1526,7 +1549,8 @@ onEvent, onComplete, abortSignal) {
                         }
                     }
                     // Check for finish reason
-                    if (chunk.choices[0].finish_reason === "tool_calls" && toolCalls.length > 0) {
+                    if (chunk.choices[0].finish_reason === "tool_calls" &&
+                        toolCalls.length > 0) {
                         // Emit tool_call_parsed events for completed tool calls
                         for (const toolCall of toolCalls) {
                             onEvent({
@@ -2227,7 +2251,7 @@ onEvent, onComplete, abortSignal) {
             }));
         }
         else {
-            console.log(`[Mistral] No tools provided - tools parameter is ${tools === undefined ? 'undefined' : 'empty array'}`);
+            console.log(`[Mistral] No tools provided - tools parameter is ${tools === undefined ? "undefined" : "empty array"}`);
         }
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`[Mistral] Stream config:`, JSON.stringify({
@@ -2274,7 +2298,7 @@ onEvent, onComplete, abortSignal) {
                 console.log(`[Mistral] Attempting to create stream with retry configuration`);
             }
             // Log final config being sent
-            console.log(`[Mistral] Sending request with tools: ${streamConfig.tools ? 'YES' : 'NO'}`);
+            console.log(`[Mistral] Sending request with tools: ${streamConfig.tools ? "YES" : "NO"}`);
             stream = await mistralClient.chat.stream(streamConfig, {
                 retries: {
                     strategy: "backoff",

package/dist/streaming/ui-event-adapter.d.ts

@@ -9,6 +9,7 @@ export declare class UIEventAdapter {
     private onEvent;
     private conversationId;
     private model?;
+    private modelName?;
     private modelService?;
     private tokenCount;
     private currentMessage;
@@ -26,6 +27,7 @@ export declare class UIEventAdapter {
     private chunkQueue;
     private contextWindowUsage?;
     private finalMetrics?;
+    private roundThinkingContent?;
     private reasoningContent;
     private reasoningFormat?;
     private reasoningSignature?;
@@ -38,6 +40,7 @@ export declare class UIEventAdapter {
         chunkingStrategy?: ChunkingStrategy;
         smoothingDelay?: number;
         model?: string;
+        modelName?: string;
         modelService?: string;
     });
     /**
@@ -82,4 +85,8 @@ export declare class UIEventAdapter {
      * Set usage data from native provider
      */
     setUsageData(usage: any): void;
+    /**
+     * Set thinking content for this round (for conversation history formatting)
+     */
+    setRoundThinkingContent(thinkingContent: string): void;
 }

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

@@ -7,7 +7,8 @@ import { ChunkBuffer } from "./chunk-buffer.js";
 export class UIEventAdapter {
     onEvent;
     conversationId;
-    model;
+    model; // This will now be the enum value
+    modelName; // This will be the actual model name (e.g., "claude-sonnet-4-0")
     modelService;
     tokenCount = 0;
     currentMessage = "";
@@ -25,6 +26,7 @@ export class UIEventAdapter {
     chunkQueue = []; // Queue of chunks waiting to be emitted
     contextWindowUsage;
     finalMetrics;
+    roundThinkingContent; // Store thinking content for conversation history
     reasoningContent = "";
     reasoningFormat;
     reasoningSignature;
@@ -37,6 +39,7 @@ export class UIEventAdapter {
         this.conversationId = conversationId;
         this.smoothingDelay = options.smoothingDelay ?? 30;
         this.model = options.model;
+        this.modelName = options.modelName;
         this.modelService = options.modelService;
         this.conversationStartTime = Date.now(); // Capture when conversation began
         if (options.smoothingEnabled) {
@@ -130,14 +133,16 @@ export class UIEventAdapter {
         this.lastTokenTime = now;
         this.tokenCount++;
         // Check if we're resuming after tool calls and need to add newlines
-        if (this.hadToolCallsBeforeResume && this.hasToolCallsInProgress === false) {
+        if (this.hadToolCallsBeforeResume &&
+            this.hasToolCallsInProgress === false) {
             // We had tool calls before and now we're receiving content again
             // Add double newline to separate the content from tool results
-            if (this.currentMessage.length > 0 && !this.currentMessage.endsWith('\n\n')) {
+            if (this.currentMessage.length > 0 &&
+                !this.currentMessage.endsWith("\n\n")) {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`📝 [UIEventAdapter] Adding newlines after tool calls before resuming content`);
                 }
-                this.currentMessage += '\n\n';
+                this.currentMessage += "\n\n";
             }
             // Reset the flag now that we've added the newlines
             this.hadToolCallsBeforeResume = false;
@@ -330,6 +335,7 @@ export class UIEventAdapter {
             tokens: tokens, // Now we have the actual LLM token count!
             toolCalls: Array.from(this.activeToolCalls.values()).map((t) => t.toolCall),
             model: this.model,
+            modelName: this.modelName,
             modelService: this.modelService,
         };
         // Add final timing metadata
@@ -383,6 +389,17 @@ export class UIEventAdapter {
         }
         // Store final metrics for later retrieval
         this.finalMetrics = finalMetrics;
+        // Check if there are tool calls that haven't been executed yet
+        const hasPendingToolCalls = Array.from(this.activeToolCalls.values()).some((toolData) => toolData.status === "ready" ||
+            toolData.status === "preparing" ||
+            toolData.status === "executing");
+        if (hasPendingToolCalls) {
+            // Don't emit conversation_completed yet - tool execution will continue
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`🔄 [UIEventAdapter] Skipping conversation_completed - ${this.activeToolCalls.size} tool calls pending execution`);
+            }
+            return; // Exit without emitting conversation_completed
+        }
         // Include context window usage if available
         const event = {
             type: "conversation_completed",
@@ -395,10 +412,19 @@ export class UIEventAdapter {
         // Add native provider usage data if available
         if (this.usageData) {
             event.usage = {
-                promptTokens: this.usageData.prompt_tokens || this.usageData.promptTokens || this.usageData.input_tokens || 0,
-                completionTokens: this.usageData.completion_tokens || this.usageData.completionTokens || this.usageData.output_tokens || 0,
-                totalTokens: this.usageData.total_tokens || this.usageData.totalTokens ||
-                    ((this.usageData.input_tokens || 0) + (this.usageData.output_tokens || 0)) || 0,
+                promptTokens: this.usageData.prompt_tokens ||
+                    this.usageData.promptTokens ||
+                    this.usageData.input_tokens ||
+                    0,
+                completionTokens: this.usageData.completion_tokens ||
+                    this.usageData.completionTokens ||
+                    this.usageData.output_tokens ||
+                    0,
+                totalTokens: this.usageData.total_tokens ||
+                    this.usageData.totalTokens ||
+                    (this.usageData.input_tokens || 0) +
+                        (this.usageData.output_tokens || 0) ||
+                    0,
                 model: this.model,
                 provider: this.modelService,
             };
@@ -491,6 +517,9 @@ export class UIEventAdapter {
         if (this.model) {
             message.model = this.model;
         }
+        if (this.modelName) {
+            message.modelName = this.modelName;
+        }
         if (this.modelService) {
             message.modelService = this.modelService;
         }
@@ -635,4 +664,13 @@ export class UIEventAdapter {
             console.log(`📊 [UIEventAdapter] Usage data set:`, usage);
         }
     }
+    /**
+     * Set thinking content for this round (for conversation history formatting)
+     */
+    setRoundThinkingContent(thinkingContent) {
+        this.roundThinkingContent = thinkingContent;
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🧠 [UIEventAdapter] Thinking content set for conversation history (${thinkingContent.length} chars)`);
+        }
+    }
 }

package/dist/types/ui-events.d.ts

@@ -20,6 +20,13 @@ export type ContextWindowEvent = {
     };
     timestamp: Date;
 };
+/**
+ * Extended conversation message with additional streaming metadata
+ */
+export type StreamingConversationMessage = Partial<ConversationMessage> & {
+    message: string;
+    modelName?: string;
+};
 /**
  * Simplified UI-focused streaming events using GraphQL types
  */
@@ -30,9 +37,7 @@ export type AgentStreamEvent = {
     model?: string;
 } | ContextWindowEvent | {
     type: "message_update";
-    message: Partial<ConversationMessage> & {
-        message: string;
-    };
+    message: StreamingConversationMessage;
     isStreaming: boolean;
     metrics?: {
         ttft?: number;
@@ -55,7 +60,7 @@ export type AgentStreamEvent = {
     isComplete: boolean;
 } | {
     type: "conversation_completed";
-    message: ConversationMessage;
+    message: StreamingConversationMessage;
     metrics?: {
         ttft?: number;
         totalTime: number;

package/package.json

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