graphlit-client 1.0.20250615004 → 1.0.20250615006

package/dist/client.js

@@ -1697,12 +1697,28 @@ class Graphlit {
             }
             // 2. Initial prompt
             const promptResponse = await this.promptConversation(prompt, actualConversationId, specification, mimeType, data, tools, false, // requireTool
-            false, // includeDetails
+            true, // includeDetails - needed for context window tracking
             correlationId);
             let currentMessage = promptResponse.promptConversation?.message;
             if (!currentMessage) {
                 throw new Error("No message in prompt response");
             }
+            // Calculate and return context window usage in result
+            const details = promptResponse.promptConversation?.details;
+            let contextWindowUsage;
+            if (details?.tokenLimit && details?.messages) {
+                // Sum up all message tokens
+                const usedTokens = details.messages.reduce((sum, msg) => sum + (msg?.tokens || 0), 0);
+                contextWindowUsage = {
+                    usedTokens,
+                    maxTokens: details.tokenLimit,
+                    percentage: Math.round((usedTokens / details.tokenLimit) * 100),
+                    remainingTokens: Math.max(0, details.tokenLimit - usedTokens),
+                };
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`📊 [Context Window] Using ${usedTokens.toLocaleString()}/${details.tokenLimit.toLocaleString()} tokens (${Math.round((usedTokens / details.tokenLimit) * 100)}%)`);
+                }
+            }
             // 3. Tool calling loop
             const allToolCalls = [];
             let rounds = 0;
@@ -1759,6 +1775,7 @@ class Graphlit {
                 toolResults: allToolCalls,
                 metrics,
                 usage,
+                contextWindow: contextWindowUsage,
             };
         }
         catch (error) {
@@ -1956,6 +1973,24 @@ class Graphlit {
                 });
             }
         }
+        // Emit context window usage event
+        const details = formatResponse.formatConversation?.details;
+        if (details?.tokenLimit && details?.messages) {
+            // Sum up all message tokens
+            const usedTokens = details.messages.reduce((sum, msg) => sum + (msg?.tokens || 0), 0);
+            uiAdapter.handleEvent({
+                type: "context_window",
+                usage: {
+                    usedTokens,
+                    maxTokens: details.tokenLimit,
+                    percentage: Math.round((usedTokens / details.tokenLimit) * 100),
+                    remainingTokens: Math.max(0, details.tokenLimit - usedTokens),
+                },
+            });
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`📊 [Context Window] Using ${usedTokens.toLocaleString()}/${details.tokenLimit.toLocaleString()} tokens (${Math.round((usedTokens / details.tokenLimit) * 100)}%)`);
+            }
+        }
         // Build message array with conversation history
         const messages = [];
         // Add system prompt if specified

package/dist/streaming/providers.js

@@ -11,6 +11,36 @@ function isValidJSON(str) {
         return false;
     }
 }
+/**
+ * Simplify schema for Groq by removing complex features that may cause issues
+ */
+function simplifySchemaForGroq(schema) {
+    if (typeof schema !== "object" || schema === null) {
+        return JSON.stringify(schema);
+    }
+    // Remove complex JSON Schema features that Groq might not support
+    const simplified = {
+        type: schema.type || "object",
+        properties: {},
+        required: schema.required || []
+    };
+    // Only keep basic properties and types
+    if (schema.properties) {
+        for (const [key, value] of Object.entries(schema.properties)) {
+            const prop = value;
+            simplified.properties[key] = {
+                type: prop.type || "string",
+                description: prop.description || "",
+                // Remove complex features like patterns, formats, etc.
+            };
+            // Keep enum if present (but simplified)
+            if (prop.enum && Array.isArray(prop.enum)) {
+                simplified.properties[key].enum = prop.enum;
+            }
+        }
+    }
+    return JSON.stringify(simplified);
+}
 /**
  * Clean schema for Google Gemini by removing unsupported fields
  */
@@ -1042,8 +1072,27 @@ onEvent, onComplete) {
 export async function streamWithGroq(specification, messages, tools, groqClient, // Groq client instance (OpenAI-compatible)
 onEvent, onComplete) {
     try {
+        const modelName = getModelName(specification);
+        // Filter or simplify tools for Groq models that have issues
+        let groqTools = tools;
+        if (tools && tools.length > 0) {
+            // LLaMA 3.3 70B seems to have tool calling issues - disable tools for this model
+            if (modelName && (modelName.includes("llama-3.3") || modelName.includes("LLAMA_3_3"))) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`⚠️ [Groq] Disabling tools for ${modelName} due to known compatibility issues`);
+                }
+                groqTools = undefined;
+            }
+            else {
+                // For other models, simplify complex schemas
+                groqTools = tools.map(tool => ({
+                    ...tool,
+                    schema: tool.schema ? simplifySchemaForGroq(JSON.parse(tool.schema)) : tool.schema
+                }));
+            }
+        }
         // Groq uses the same API as OpenAI, so we can reuse the OpenAI streaming logic
-        return await streamWithOpenAI(specification, messages, tools, groqClient, onEvent, onComplete);
+        return await streamWithOpenAI(specification, messages, groqTools, groqClient, onEvent, onComplete);
     }
     catch (error) {
         // Handle Groq-specific errors
@@ -1324,66 +1373,101 @@ onEvent, onComplete) {
             throw new Error("No messages found for Cohere streaming");
         }
         // Cohere v7 expects a single message and optional chatHistory
-        // Extract the last message as the current message
-        const lastMessage = messages[messages.length - 1];
-        const chatHistory = messages.slice(0, -1);
+        // Extract system messages for preamble and filter them out of history
+        const systemMessages = messages.filter(msg => msg.role === "SYSTEM");
+        const nonSystemMessages = messages.filter(msg => msg.role !== "SYSTEM");
+        // Extract the last non-system message as the current message
+        const lastMessage = nonSystemMessages[nonSystemMessages.length - 1];
+        const chatHistory = nonSystemMessages.slice(0, -1);
         if (!lastMessage || !lastMessage.message) {
             throw new Error("Last message must have message property for Cohere streaming");
         }
+        // Build properly typed request using Cohere SDK types
         const streamConfig = {
             model: modelName,
             message: lastMessage.message, // Current message (singular)
         };
+        // Add system message as preamble if present
+        if (systemMessages.length > 0) {
+            // Combine all system messages into preamble
+            streamConfig.preamble = systemMessages.map(msg => msg.message).join("\n\n");
+        }
         // Add chat history if there are previous messages
         if (chatHistory.length > 0) {
-            // Messages already have 'message' property from formatter
-            streamConfig.chatHistory = chatHistory;
+            // Build properly typed chat history using Cohere SDK Message types
+            // Note: SYSTEM messages are already filtered out and handled as preamble
+            const cohereHistory = chatHistory.map((msg) => {
+                switch (msg.role) {
+                    case "USER":
+                        return {
+                            role: "USER",
+                            message: msg.message,
+                        };
+                    case "CHATBOT":
+                        const chatbotMsg = {
+                            role: "CHATBOT",
+                            message: msg.message,
+                        };
+                        // Add tool calls if present
+                        if (msg.tool_calls && msg.tool_calls.length > 0) {
+                            chatbotMsg.toolCalls = msg.tool_calls.map((tc) => ({
+                                name: tc.name,
+                                parameters: tc.parameters || {},
+                            }));
+                        }
+                        return chatbotMsg;
+                    case "TOOL":
+                        return {
+                            role: "TOOL",
+                            toolResults: msg.tool_results || [],
+                        };
+                    default:
+                        // Fallback - treat as USER
+                        return {
+                            role: "USER",
+                            message: msg.message,
+                        };
+                }
+            });
+            streamConfig.chatHistory = cohereHistory;
         }
         // Only add temperature if it's defined
-        if (specification.cohere?.temperature !== undefined) {
+        if (specification.cohere?.temperature !== undefined &&
+            specification.cohere.temperature !== null) {
             streamConfig.temperature = specification.cohere.temperature;
         }
         // Add tools if provided
         if (tools && tools.length > 0) {
-            streamConfig.tools = tools.map((tool) => {
+            const cohereTools = tools.map((tool) => {
                 if (!tool.schema) {
                     return {
-                        name: tool.name,
-                        description: tool.description,
-                        parameter_definitions: {},
+                        name: tool.name || "",
+                        description: tool.description || "",
+                        parameterDefinitions: {},
                     };
                 }
                 // Parse the JSON schema
                 const schema = JSON.parse(tool.schema);
                 // Convert JSON Schema to Cohere's expected format
-                const parameter_definitions = {};
+                const parameterDefinitions = {};
                 if (schema.properties) {
                     for (const [key, value] of Object.entries(schema.properties)) {
                         const prop = value;
                         const paramDef = {
-                            type: prop.type || "string",
+                            type: prop.type || "str",
                             description: prop.description || "",
                             required: schema.required?.includes(key) || false,
                         };
-                        // Add additional properties that Cohere might expect
-                        if (prop.enum) {
-                            paramDef.options = prop.enum;
-                        }
-                        if (prop.default !== undefined) {
-                            paramDef.default = prop.default;
-                        }
-                        if (prop.items) {
-                            paramDef.items = prop.items;
-                        }
-                        parameter_definitions[key] = paramDef;
+                        parameterDefinitions[key] = paramDef;
                     }
                 }
                 return {
-                    name: tool.name,
-                    description: tool.description,
-                    parameter_definitions, // Use snake_case as expected by Cohere API
+                    name: tool.name || "",
+                    description: tool.description || "",
+                    parameterDefinitions, // Use camelCase as expected by Cohere SDK
                 };
             });
+            streamConfig.tools = cohereTools;
         }
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🔍 [Cohere] Final stream config:`, JSON.stringify(streamConfig, null, 2));
@@ -1394,20 +1478,42 @@ onEvent, onComplete) {
         }
         let stream;
         try {
+            // Always log the full config when debugging Command A errors
+            if (modelName.includes("command-a") ||
+                process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`🔍 [Cohere] Full streamConfig for ${modelName}:`, JSON.stringify(streamConfig, null, 2));
+            }
             stream = await cohereClient.chatStream(streamConfig);
         }
         catch (streamError) {
-            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                console.error(`❌ [Cohere] Stream creation failed:`, streamError);
-                if (streamError.response) {
-                    console.error(`❌ [Cohere] Stream response status: ${streamError.response.status}`);
-                    console.error(`❌ [Cohere] Stream response data:`, streamError.response.data);
-                }
-                if (streamError.status) {
-                    console.error(`❌ [Cohere] Direct status: ${streamError.status}`);
+            // Enhanced error logging
+            console.error(`❌ [Cohere] Stream creation failed for model ${modelName}`);
+            console.error(`❌ [Cohere] Error type: ${streamError.constructor.name}`);
+            console.error(`❌ [Cohere] Status code: ${streamError.statusCode || streamError.status || "unknown"}`);
+            console.error(`❌ [Cohere] Error message: ${streamError.message}`);
+            // Try to read the body if it's a ReadableStream
+            if (streamError.body &&
+                typeof streamError.body.getReader === "function") {
+                try {
+                    const reader = streamError.body.getReader();
+                    let fullBody = "";
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        fullBody += new TextDecoder().decode(value);
+                    }
+                    console.error(`❌ [Cohere] Raw error body:`, fullBody);
+                    try {
+                        const parsed = JSON.parse(fullBody);
+                        console.error(`❌ [Cohere] Parsed error details:`, JSON.stringify(parsed, null, 2));
+                    }
+                    catch (e) {
+                        console.error(`❌ [Cohere] Could not parse error body as JSON`);
+                    }
                 }
-                if (streamError.body) {
-                    console.error(`❌ [Cohere] Response body:`, streamError.body);
+                catch (e) {
+                    console.error(`❌ [Cohere] Could not read error body:`, e);
                 }
             }
             throw streamError;

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

@@ -24,6 +24,7 @@ export declare class UIEventAdapter {
     private chunkBuffer?;
     private smoothingDelay;
     private chunkQueue;
+    private contextWindowUsage?;
     constructor(onEvent: (event: AgentStreamEvent) => void, conversationId: string, options?: {
         smoothingEnabled?: boolean;
         chunkingStrategy?: ChunkingStrategy;
@@ -49,6 +50,7 @@ export declare class UIEventAdapter {
     private emitNextChunk;
     private emitMessageUpdate;
     private emitUIEvent;
+    private handleContextWindow;
     /**
      * Clean up any pending timers
      */

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

@@ -23,6 +23,7 @@ export class UIEventAdapter {
     chunkBuffer;
     smoothingDelay = 30;
     chunkQueue = []; // Queue of chunks waiting to be emitted
+    contextWindowUsage;
     constructor(onEvent, conversationId, options = {}) {
         this.onEvent = onEvent;
         this.conversationId = conversationId;
@@ -66,6 +67,9 @@ export class UIEventAdapter {
             case "error":
                 this.handleError(event.error);
                 break;
+            case "context_window":
+                this.handleContextWindow(event.usage);
+                break;
         }
     }
     handleStart(conversationId) {
@@ -323,11 +327,16 @@ export class UIEventAdapter {
                 finalMetrics.streamingThroughput = Math.round((this.currentMessage.length / streamingTime) * 1000);
             }
         }
-        this.emitUIEvent({
+        // Include context window usage if available
+        const event = {
             type: "conversation_completed",
             message: finalMessage,
             metrics: finalMetrics,
-        });
+        };
+        if (this.contextWindowUsage) {
+            event.contextWindow = this.contextWindowUsage;
+        }
+        this.emitUIEvent(event);
     }
     handleError(error) {
         this.isStreaming = false;
@@ -468,6 +477,18 @@ export class UIEventAdapter {
     emitUIEvent(event) {
         this.onEvent(event);
     }
+    handleContextWindow(usage) {
+        // Store for later inclusion in completion event
+        this.contextWindowUsage = usage;
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`📊 [UIEventAdapter] Context window: ${usage.usedTokens}/${usage.maxTokens} (${usage.percentage}%)`);
+        }
+        this.emitUIEvent({
+            type: "context_window",
+            usage,
+            timestamp: new Date(),
+        });
+    }
     /**
      * Clean up any pending timers
      */

package/dist/types/agent.d.ts

@@ -13,6 +13,12 @@ export interface AgentMetrics {
     toolExecutions?: number;
     rounds?: number;
 }
+export interface ContextWindowUsage {
+    usedTokens: number;
+    maxTokens: number;
+    percentage: number;
+    remainingTokens: number;
+}
 export interface AgentResult {
     message: string;
     conversationId: string;
@@ -21,6 +27,7 @@ export interface AgentResult {
     toolResults?: ToolCallResult[];
     metrics?: AgentMetrics;
     usage?: UsageInfo;
+    contextWindow?: ContextWindowUsage;
     error?: AgentError;
 }
 export interface StreamAgentOptions {

package/dist/types/internal.d.ts

@@ -49,4 +49,12 @@ export type StreamEvent = {
 } | {
     type: "error";
     error: string;
+} | {
+    type: "context_window";
+    usage: {
+        usedTokens: number;
+        maxTokens: number;
+        percentage: number;
+        remainingTokens: number;
+    };
 };

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

@@ -3,6 +3,19 @@ import { ConversationMessage, ConversationToolCall } from "../generated/graphql-
  * Tool execution status for streaming
  */
 export type ToolExecutionStatus = "preparing" | "executing" | "ready" | "completed" | "failed";
+/**
+ * Context window usage event - emitted at start of agent interaction
+ */
+export type ContextWindowEvent = {
+    type: "context_window";
+    usage: {
+        usedTokens: number;
+        maxTokens: number;
+        percentage: number;
+        remainingTokens: number;
+    };
+    timestamp: Date;
+};
 /**
  * Simplified UI-focused streaming events using GraphQL types
  */
@@ -11,7 +24,7 @@ export type AgentStreamEvent = {
     conversationId: string;
     timestamp: Date;
     model?: string;
-} | {
+} | ContextWindowEvent | {
     type: "message_update";
     message: Partial<ConversationMessage> & {
         message: string;
@@ -43,6 +56,12 @@ export type AgentStreamEvent = {
         avgTokenDelay?: number;
         streamingThroughput?: number;
     };
+    contextWindow?: {
+        usedTokens: number;
+        maxTokens: number;
+        percentage: number;
+        remainingTokens: number;
+    };
 } | {
     type: "error";
     error: {

package/package.json

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