dev: coerce semantics of tool calls/use in messages

If these APIs were standardized this would have been so much less
painful, but alas, tool calls are implemented completely differently
between Claude and OpenAI. Good job guys.

Author: KernelDeimos

src/backend/src/modules/puterai/OpenAICompletionService.js

@@ -294,6 +294,36 @@ class OpenAICompletionService extends BaseService {
                 if ( o.type ) continue;
                 o.type = 'image_url';
             }
+
+            // coerce tool calls
+            for ( let i = content.length - 1 ; i >= 0 ; i-- ) {
+                const content_block = content[i];
+
+                if ( content_block.type === 'tool_use' ) {
+                    if ( ! msg.hasOwnProperty('tool_calls') ) {
+                        msg.tool_calls = [];
+                    }
+                    msg.tool_calls.push({
+                        id: content_block.id,
+                        type: 'function',
+                        function: {
+                            name: content_block.name,
+                            arguments: JSON.stringify(content_block.input),
+                        }
+                    });
+                    content.splice(i, 1);
+                }
+            }
+
+            // coerce tool results
+            // (we assume multiple tool results were already split into separate messages)
+            for ( let i = content.length - 1 ; i >= 0 ; i-- ) {
+                const content_block = content[i];
+                if ( content_block.type !== 'tool_result' ) continue;
+                msg.role = 'tool';
+                msg.tool_call_id = content_block.tool_use_id;
+                msg.content = content_block.content;
+            }
         }
 
         console.log('MODEL IN USE ------- ', model);

src/backend/src/modules/puterai/lib/Messages.js

@@ -19,13 +19,24 @@ module.exports = class Messages {
         }
         if ( ! message.content ) {
             if ( message.tool_calls ) {
-                return message;
+                message.content = [];
+                for ( let i=0 ; i < message.tool_calls.length ; i++ ) {
+                    const tool_call = message.tool_calls[i];
+                    message.content.push({
+                        type: 'tool_use',
+                        id: tool_call.id,
+                        name: tool_call.function.name,
+                        input: tool_call.function.arguments,
+                    });
+                }
+                delete message.tool_calls;
             }
             throw new Error(`each message must have a 'content' property`);
         }
         if ( whatis(message.content) !== 'array' ) {
             message.content = [message.content];
         }
+        // Coerce each content block into an object
         for ( let i=0 ; i < message.content.length ; i++ ) {
             if ( whatis(message.content[i]) === 'string' ) {
                 message.content[i] = {
@@ -41,6 +52,16 @@ module.exports = class Messages {
             }
         }
 
+        // Remove "text" properties from content blocks with type=tool_result
+        for ( let i=0 ; i < message.content.length ; i++ ) {
+            if ( message.content[i].type !== 'tool_use' ) {
+                continue;
+            }
+            if ( message.content[i].hasOwnProperty('text') ) {
+                delete message.content[i].text;
+            }
+        }
+
         console.log('???', message)
         return message;
     }
@@ -49,6 +70,28 @@ module.exports = class Messages {
             messages[i] = this.normalize_single_message(messages[i], params);
         }
 
+        // Split messages with tool_use content into separate messages
+        // TODO: unit test this
+        messages = [...messages];
+        for ( let i=0 ; i < messages.length ; i++ ) {
+            let message = messages[i];
+            let separated_messages = [];
+            for ( let j=0 ; j < message.content.length ; j++ ) {
+                if ( message.content[j].type === 'tool_result' ) {
+                    separated_messages.push({
+                        role: message.role,
+                        content: [message.content[j]],
+                    });
+                } else {
+                    separated_messages.push({
+                        role: message.role,
+                        content: [message.content[j]],
+                    });
+                }
+            }
+            messages.splice(i, 1, ...separated_messages);
+        }
+
         // If multiple messages are from the same role, merge them
         let merged_messages = [];
         let current_role = null;