graphlit-client 1.0.20250615001 → 1.0.20250615002

package/dist/model-mapping.js

@@ -106,8 +106,8 @@ const COHERE_MODEL_MAP = {
     [Types.CohereModels.CommandR_202403]: "command-r-03-2024",
     [Types.CohereModels.CommandR_202408]: "command-r-08-2024",
     [Types.CohereModels.CommandR7B_202412]: "command-r7b-12-2024",
-    [Types.CohereModels.CommandA]: "command-light",
-    [Types.CohereModels.CommandA_202503]: "command-light-nightly",
+    [Types.CohereModels.CommandA]: "command-a-03-2025",
+    [Types.CohereModels.CommandA_202503]: "command-a-03-2025",
 };
 // Mistral model mappings
 const MISTRAL_MODEL_MAP = {

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

@@ -81,8 +81,23 @@ export declare function formatMessagesForGoogle(messages: ConversationMessage[])
  * Cohere message format
  */
 export interface CohereMessage {
-    role: "USER" | "CHATBOT" | "SYSTEM";
-    message: string;
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    tool_calls?: Array<{
+        id: string;
+        name: string;
+        parameters: Record<string, any>;
+    }>;
+    tool_results?: Array<{
+        call: {
+            id: string;
+            name: string;
+            parameters: Record<string, any>;
+        };
+        outputs: Array<{
+            text: string;
+        }>;
+    }>;
 }
 /**
  * Format GraphQL conversation messages for Cohere SDK

package/dist/streaming/llm-formatters.js

@@ -273,26 +273,59 @@ export function formatMessagesForGoogle(messages) {
 export function formatMessagesForCohere(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 tool calls even if they have no text content
+        const hasContent = message.message?.trim();
+        const hasToolCalls = message.toolCalls && message.toolCalls.length > 0;
+        if (!hasContent && !hasToolCalls)
+            continue;
+        const trimmedMessage = message.message?.trim() || "";
         switch (message.role) {
             case ConversationRoleTypes.System:
                 formattedMessages.push({
-                    role: "SYSTEM",
-                    message: trimmedMessage,
+                    role: "system",
+                    content: trimmedMessage,
                 });
                 break;
             case ConversationRoleTypes.Assistant:
+                const assistantMessage = {
+                    role: "assistant",
+                    content: trimmedMessage,
+                };
+                // Add tool calls if present
+                if (message.toolCalls && message.toolCalls.length > 0) {
+                    assistantMessage.tool_calls = message.toolCalls
+                        .filter((tc) => tc !== null)
+                        .map((toolCall) => ({
+                        id: toolCall.id,
+                        name: toolCall.name,
+                        parameters: toolCall.arguments ? JSON.parse(toolCall.arguments) : {},
+                    }));
+                }
+                formattedMessages.push(assistantMessage);
+                break;
+            case ConversationRoleTypes.Tool:
+                // Cohere expects tool results as tool messages
                 formattedMessages.push({
-                    role: "CHATBOT",
-                    message: trimmedMessage,
+                    role: "tool",
+                    content: trimmedMessage,
+                    tool_results: [{
+                            call: {
+                                id: message.toolCallId || "",
+                                name: "", // Would need to be tracked from the tool call
+                                parameters: {},
+                            },
+                            outputs: [{
+                                    text: trimmedMessage,
+                                }],
+                        }],
                 });
                 break;
             default: // User messages
                 formattedMessages.push({
-                    role: "USER",
-                    message: trimmedMessage,
+                    role: "user",
+                    content: trimmedMessage,
                 });
                 break;
         }

package/dist/streaming/providers.js

@@ -27,6 +27,15 @@ function cleanSchemaForGoogle(schema) {
         if (key === "$schema" || key === "additionalProperties") {
             continue;
         }
+        // Handle format field for string types - Google only supports 'enum' and 'date-time'
+        if (key === "format" && typeof value === "string") {
+            // Only keep supported formats
+            if (value === "enum" || value === "date-time") {
+                cleaned[key] = value;
+            }
+            // Skip unsupported formats like "date", "time", "email", etc.
+            continue;
+        }
         // Recursively clean nested objects
         cleaned[key] = cleanSchemaForGoogle(value);
     }
@@ -1215,15 +1224,21 @@ onEvent, onComplete) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🤖 [Cohere] Model Config: Service=Cohere | Model=${modelName} | Temperature=${specification.cohere?.temperature} | Tools=${tools?.length || 0} | Spec="${specification.name}"`);
         }
-        // Prepare the latest user message and chat history
-        const lastMessage = messages[messages.length - 1];
-        const chatHistory = messages.slice(0, -1);
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🔍 [Cohere] Messages array length: ${messages.length}`);
+            console.log(`🔍 [Cohere] All messages:`, JSON.stringify(messages, null, 2));
+        }
+        if (messages.length === 0) {
+            throw new Error("No messages found for Cohere streaming");
+        }
         const streamConfig = {
             model: modelName,
-            message: lastMessage.message,
-            chatHistory: chatHistory,
-            temperature: specification.cohere?.temperature,
+            messages: messages, // All messages in chronological order
         };
+        // Only add temperature if it's defined
+        if (specification.cohere?.temperature !== undefined) {
+            streamConfig.temperature = specification.cohere.temperature;
+        }
         // Add tools if provided
         if (tools && tools.length > 0) {
             streamConfig.tools = tools.map((tool) => {
@@ -1231,41 +1246,71 @@ onEvent, onComplete) {
                     return {
                         name: tool.name,
                         description: tool.description,
-                        parameterDefinitions: {},
+                        parameter_definitions: {},
                     };
                 }
                 // Parse the JSON schema
                 const schema = JSON.parse(tool.schema);
                 // Convert JSON Schema to Cohere's expected format
-                const parameterDefinitions = {};
+                const parameter_definitions = {};
                 if (schema.properties) {
                     for (const [key, value] of Object.entries(schema.properties)) {
                         const prop = value;
-                        parameterDefinitions[key] = {
+                        const paramDef = {
                             type: prop.type || "string",
                             description: prop.description || "",
                             required: schema.required?.includes(key) || false,
                         };
                         // Add additional properties that Cohere might expect
                         if (prop.enum) {
-                            parameterDefinitions[key].options = prop.enum;
+                            paramDef.options = prop.enum;
                         }
                         if (prop.default !== undefined) {
-                            parameterDefinitions[key].default = prop.default;
+                            paramDef.default = prop.default;
                         }
                         if (prop.items) {
-                            parameterDefinitions[key].items = prop.items;
+                            paramDef.items = prop.items;
                         }
+                        parameter_definitions[key] = paramDef;
                     }
                 }
                 return {
                     name: tool.name,
                     description: tool.description,
-                    parameterDefinitions,
+                    parameter_definitions, // Use snake_case as expected by Cohere API
                 };
             });
         }
-        const stream = await cohereClient.chatStream(streamConfig);
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🔍 [Cohere] Final stream config:`, JSON.stringify(streamConfig, null, 2));
+            console.log(`🔍 [Cohere] Cohere client methods available:`, Object.getOwnPropertyNames(cohereClient));
+            console.log(`🔍 [Cohere] Has chatStream method:`, typeof cohereClient.chatStream === 'function');
+            console.log(`🔍 [Cohere] Has chat property:`, !!cohereClient.chat);
+            if (cohereClient.chat) {
+                console.log(`🔍 [Cohere] Chat methods:`, Object.getOwnPropertyNames(cohereClient.chat));
+            }
+            console.log(`⏱️ [Cohere] Starting stream request at: ${new Date().toISOString()}`);
+        }
+        let stream;
+        try {
+            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}`);
+                }
+                if (streamError.body) {
+                    console.error(`❌ [Cohere] Response body:`, streamError.body);
+                }
+            }
+            throw streamError;
+        }
         for await (const chunk of stream) {
             if (chunk.eventType === "text-generation") {
                 const text = chunk.text;
@@ -1313,6 +1358,18 @@ onEvent, onComplete) {
         onComplete(fullMessage, toolCalls);
     }
     catch (error) {
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.error(`❌ [Cohere] Stream error:`, error);
+            if (error instanceof Error) {
+                console.error(`❌ [Cohere] Error message: ${error.message}`);
+                console.error(`❌ [Cohere] Error stack: ${error.stack}`);
+            }
+            // Log additional error details if available
+            if (error.response) {
+                console.error(`❌ [Cohere] Response status: ${error.response.status}`);
+                console.error(`❌ [Cohere] Response data:`, error.response.data);
+            }
+        }
         throw error;
     }
 }

package/package.json

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