Possible Bug in tool calls & Feature Request: Way to debug tool errors

[ddevz]

I got a "Failed to parse tool call" ... "undetermined string literal (detected at line 1) (, line 1)" on a UpdateTodoList call. However, I dont see anything wrong with what the AI json request.

FEATURE REQUEST:
So my feature request is a "/tool" command to be able to run tool calls myself

It's for testing purposes. I'd like to cut and paste a copy of the AI json to the tool to recreate the error, so something like:

/tool {"name": "UpdateTodoList", "arguments": {"content": "whatever it said"}}

to regenerate the error, then start using variations to find what the issue is.

POSSIBLE BUG:
"undetermined string literal (detected at line 1) (, line 1)"

the UpdateTodoList request had a \n in the content string between each todo item... could that be the parsing problem?

cecli v0.95.11
Model: ollama/quen3-coder:30B with agent edit format
MCP servers configured: Local

[dwash96]

I'm pretty sure this is the qwen coder model printing json like:

{"key": "value1
value2"}

With a literal new line (which is invalid JSON), instead of

{"key": "value1\nvalue2"}

With an encoded new line

[ddevz]

ok so "\n" is valid (which is what it used in the '{"content": "' section)

The green text of the json request line breaks in the middle of each sentence, but oddly the last word of each line goes to the last column, and the next word starts the next line in the first column (no leading space, which one would expect if a space followed the last character of the previous line). I'll investigate.

Any chance of getting a /tool command that would allow debugging situations like this?

[dwash96]

I'll whip up a custom command for this later today, partially for this, partially to test the custom slash command system itself from:
https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/custom-commands.md

[ddevz]

Neat! Thanks

[dwash96]

Alright, pop this in a folder somewhere and reference it like:

custom:
    command-paths: ["{path to custom commands folder}"]
    prompt-map: {}

import json
import traceback
from typing import List
from cecli.commands.utils.base_command import BaseCommand
from cecli.commands.utils.helpers import format_command_result


class CustomCommand(BaseCommand):
    NORM_NAME = "tool"
    DESCRIPTION = "Execute tool calls manually for debugging purposes"

    @classmethod
    async def execute(cls, io, coder, args, **kwargs):
        """
        Execute a tool call manually for debugging.
        
        Usage: /tool {"name": "UpdateTodoList", "arguments": {"content": "test"}}
        """
        if not args.strip():
            return format_command_result(
                io, 
                cls.NORM_NAME, 
                "Error: No JSON provided. Usage: /tool {\"name\": \"ToolName\", \"arguments\": {...}}"
            )
        
        # Check if coder is available (required for tool execution)
        if coder is None:
            return format_command_result(
                io,
                cls.NORM_NAME,
                "Error: No coder available. Tool commands require an active coder session."
            )
        
        try:
            # Parse the JSON tool call
            tool_call_data = json.loads(args.strip())
            
            # Validate the structure
            if "name" not in tool_call_data:
                return format_command_result(
                    io,
                    cls.NORM_NAME,
                    "Error: Tool call JSON must contain 'name' field"
                )
            
            tool_name = tool_call_data["name"]
            arguments = tool_call_data.get("arguments", {})
            
            io.tool_output(f"Executing tool: {tool_name}")
            io.tool_output(f"Arguments: {json.dumps(arguments, indent=2)}")
            
            # Normalize tool name (tools use lowercase names in registry)
            norm_tool_name = tool_name.lower()
            
            # Try to execute via the tool registry
            from cecli.tools.utils.registry import ToolRegistry
            
            # First, ensure the registry is built
            agent_config = {}
            if hasattr(coder, '_get_agent_config'):
                agent_config = coder._get_agent_config()
            
            ToolRegistry.build_registry(agent_config)
            
            # Get the tool class
            tool_class = ToolRegistry.get_tool(norm_tool_name)
            if not tool_class:
                # Try with the original name as well
                tool_class = ToolRegistry.get_tool(tool_name)
                
            if tool_class:
                # Execute the tool using process_response method
                result = tool_class.process_response(coder, arguments)
                
                # Handle async results
                import asyncio
                if asyncio.iscoroutine(result):
                    result = await result
            else:
                # Get available tools for error message
                available_tools = ToolRegistry.list_tools()
                return format_command_result(
                    io,
                    cls.NORM_NAME,
                    f"Error: Tool '{tool_name}' not found in registry. "
                    f"Available tools: {', '.join(sorted(available_tools))}"
                )
            
            return format_command_result(
                io,
                cls.NORM_NAME,
                f"Tool '{tool_name}' executed successfully. Result: {result}"
            )
            
        except json.JSONDecodeError as e:
            return format_command_result(
                io,
                cls.NORM_NAME,
                f"Error: Invalid JSON - {str(e)}"
            )
        except Exception as e:
            error_details = traceback.format_exc()
            return format_command_result(
                io,
                cls.NORM_NAME,
                f"Error executing tool: {str(e)}\n\nTraceback:\n{error_details}"
            )

    @classmethod
    def get_completions(cls, io, coder, args) -> List[str]:
        """Get completion options for the tool command."""
        # Return empty list for now - could implement tool name completions later
        return []

    @classmethod
    def get_help(cls) -> str:
        """Get help text for the tool command."""
        help_text = super().get_help()
        help_text += "\n"
        help_text += "Execute tool calls manually for debugging purposes.\n"
        help_text += "\n"
        help_text += "Usage: /tool {\"name\": \"ToolName\", \"arguments\": {...}}\n"
        help_text += "\n"
        help_text += "Examples:\n"
        help_text += "  /tool {\"name\": \"UpdateTodoList\", \"arguments\": {\"content\": \"test todo\"}}\n"
        help_text += "  /tool {\"name\": \"Grep\", \"arguments\": {\"pattern\": \"def test\", \"file_pattern\": \"*.py\"}}\n"
        help_text += "\n"
        help_text += "This command is useful for debugging tool call errors by allowing you to\n"
        help_text += "manually execute tool calls with specific parameters to reproduce issues."
        return help_text

[dwash96]

So extremely roundabout but I think this commit:
70f601b

In 0.96.10

Should solve this problem. The discord has a lot more details on what I think is happening here (system clock shenanigans and how LiteLLM orders model response chunks as a result)