Centralize tool call formatting to Python-style in one place

Created formatToolCall utility used by both:
- lettaApi.ts (historical messages from server)
- useMessageStream.ts (streaming messages)

Now formats consistently as: web_search(query="poetry", num_results=10)
Instead of: web_search({"query":"poetry","num_results":10})

Simplified extractToolArgument - no more JSON extraction, just regex.

🐾 Generated with [Letta Code](https://letta.com)

Co-Authored-By: Letta <[e-mail]>

src/api/lettaApi.ts

···
 
         // CONSTRUCT content for tool call messages (if content is empty)
         if ((type === 'tool_call_message' || type === 'tool_call') && !content && toolCall) {
+          const { formatToolCall } = require('../utils/formatToolCall');
           const name = toolCall.name || 'tool';
           const args = toolCall.arguments || '{}';
-          content = `${name}(${args})`;
+          content = formatToolCall(name, args);
         }
 
         // EXTRACT content for tool return messages (if content is empty)

src/hooks/useMessageStream.ts

···
               // Format tool call content as Python-style string (like server does)
               let content = msg.content;
               if (msg.type === 'tool_call' && msg.toolCallName) {
-                try {
-                  const argsObj = JSON.parse(msg.content);
-                  const formattedArgs = Object.entries(argsObj)
-                    .map(([k, v]) => `${k}=${typeof v === 'string' ? `"${v}"` : JSON.stringify(v)}`)
-                    .join(', ');
-                  content = `${msg.toolCallName}(${formattedArgs})`;
-                } catch (e) {
-                  // If parse fails, keep original content
-                  content = msg.content;
-                }
+                const { formatToolCall } = require('../utils/formatToolCall');
+                content = formatToolCall(msg.toolCallName, msg.content);
               }
 
               return {

src/utils/formatToolCall.ts

···
+/**
+ * Format tool call arguments as Python-style string
+ * 
+ * Input: { query: "poetry", num_results: 10 }
+ * Output: query="poetry", num_results=10
+ */
+export function formatToolArgs(args: any): string {
+  if (!args || typeof args !== 'object') {
+    return '';
+  }
+  
+  return Object.entries(args)
+    .map(([k, v]) => `${k}=${typeof v === 'string' ? `"${v}"` : JSON.stringify(v)}`)
+    .join(', ');
+}
+
+/**
+ * Format tool call as Python-style function call
+ * 
+ * Input: name="web_search", arguments='{"query":"poetry","num_results":10}'
+ * Output: web_search(query="poetry", num_results=10)
+ */
+export function formatToolCall(name: string, argumentsJson: string): string {
+  try {
+    const argsObj = JSON.parse(argumentsJson);
+    const formattedArgs = formatToolArgs(argsObj);
+    return `${name}(${formattedArgs})`;
+  } catch (e) {
+    // If JSON parse fails, wrap the raw string in parens
+    return `${name}(${argumentsJson})`;
+  }
+}

src/utils/messageLabels.ts

···
 
 /**
  * Extract a specific argument from tool call arguments
- * Handles multiple formats: Python string, JSON string, JSON-in-parens
+ * Expects Python-style format: tool(query="value", num=10)
  */
 function extractToolArgument(group: MessageGroup, argName: string): string | null {
   const argsStr = group.toolCall?.args || group.content || '';
   
-  // Try to parse as JSON first (pure JSON string)
-  if (argsStr.startsWith('{')) {
-    try {
-      const argsObj = JSON.parse(argsStr);
-      return argsObj[argName] || null;
-    } catch (e) {
-      // Not valid JSON, continue
-    }
-  }
-  
-  // Try to extract JSON from inside parens: tool_name({"key": "value"})
-  const jsonMatch = argsStr.match(/\((\{.+\})\)/);
-  if (jsonMatch) {
-    try {
-      const argsObj = JSON.parse(jsonMatch[1]);
-      return argsObj[argName] || null;
-    } catch (e) {
-      // Not valid JSON, continue
-    }
-  }
-  
-  // Try to extract from Python-style string: tool(arg="value", ...)
+  // Extract from Python-style string: tool(arg="value", ...)
   const regex = new RegExp(`${argName}=["']([^"']+)["']`);
   const match = argsStr.match(regex);
   if (match) {