cli2api 0.2.2__tar.gz → 0.2.3__tar.gz

{cli2api-0.2.2 → cli2api-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli2api
-Version: 0.2.2
+Version: 0.2.3
 Summary: OpenAI-compatible API over Claude Code CLI
 Requires-Python: >=3.11
 Requires-Dist: fastapi>=0.115.0

{cli2api-0.2.2 → cli2api-0.2.3}/cli2api/prompts/tools_instruction.txt

@@ -27,6 +27,7 @@ CRITICAL RULES:
 - ALWAYS include the "arguments" key with ALL required parameters filled in
 - NEVER output {{"name": "tool_name"}} without "arguments" — this is INVALID
 - NEVER output empty arguments {{}} when the tool has required parameters
+- For optional parameters you want to omit, use JSON null (not the string "null")
 - You CAN include text explanation before/after tags
 - Do NOT execute tools yourself — just output the tags
 - If user wants to read a file -> use read_file tool
@@ -42,11 +43,21 @@ WRONG — empty arguments when tool requires parameters:
 {{"name": "execute_command", "arguments": {{}}}}
 </tool_call>
 
+WRONG — string "null" instead of JSON null for optional params:
+<tool_call>
+{{"name": "execute_command", "arguments": {{"command": "ls -la", "cwd": "null"}}}}
+</tool_call>
+
 CORRECT:
 <tool_call>
 {{"name": "execute_command", "arguments": {{"command": "ls -la"}}}}
 </tool_call>
 
+CORRECT — optional param with JSON null:
+<tool_call>
+{{"name": "execute_command", "arguments": {{"command": "ls -la", "cwd": null}}}}
+</tool_call>
+
 {tool_examples}
 
 ATTEMPT_COMPLETION USAGE:

{cli2api-0.2.2 → cli2api-0.2.3}/cli2api/providers/claude.py

@@ -249,10 +249,15 @@ class ClaudeCodeProvider:
         Claude sometimes returns structured data (arrays, objects) as
         JSON-encoded strings. Kilo Code expects native types, so we
         parse them back. E.g. follow_up: '[{"text":"Yes"}]' -> [{"text":"Yes"}]
+
+        Also converts string "null" to None — Claude sometimes generates
+        "cwd": "null" instead of "cwd": null for optional parameters.
         """
         result = {}
         for key, value in obj.items():
-            if isinstance(value, str) and value and value[0] in ('[', '{'):
+            if isinstance(value, str) and value == "null":
+                result[key] = None
+            elif isinstance(value, str) and value and value[0] in ('[', '{'):
                 try:
                     result[key] = json.loads(value)
                 except (json.JSONDecodeError, ValueError):

{cli2api-0.2.2 → cli2api-0.2.3}/cli2api/tools/validator.py

@@ -1,4 +1,4 @@
-"""Tool call argument validation against OpenAI tool schemas."""
+"""Tool call argument validation and sanitization against OpenAI tool schemas."""
 
 import json
 from typing import Optional
@@ -8,6 +8,29 @@ from cli2api.utils.logging import get_logger
 logger = get_logger(__name__)
 
 
+def sanitize_tool_arguments(arguments: dict) -> dict:
+    """Sanitize tool call arguments: convert string "null" to None.
+
+    Claude sometimes generates "cwd": "null" (string) instead of
+    "cwd": null (JSON null) for optional parameters. This causes
+    downstream errors when the consumer interprets "null" as a
+    literal directory name.
+
+    Args:
+        arguments: Parsed tool call arguments dict.
+
+    Returns:
+        Sanitized arguments dict with "null" strings replaced by None.
+    """
+    result = {}
+    for key, value in arguments.items():
+        if isinstance(value, str) and value == "null":
+            result[key] = None
+        else:
+            result[key] = value
+    return result
+
+
 def build_required_params_index(tools: list[dict]) -> dict[str, list[str]]:
     """Build a lookup: tool_name -> list of required parameter names.
 
@@ -77,11 +100,38 @@ def validate_tool_call(
     return True
 
 
+def _sanitize_tool_call(tool_call: dict) -> dict:
+    """Sanitize a single tool call's arguments in-place.
+
+    Parses the arguments JSON, applies sanitize_tool_arguments,
+    and re-serializes. Returns the (possibly modified) tool call.
+    """
+    func = tool_call.get("function", {})
+    arguments_str = func.get("arguments", "{}")
+
+    try:
+        arguments = json.loads(arguments_str)
+    except (json.JSONDecodeError, TypeError):
+        return tool_call
+
+    if not isinstance(arguments, dict):
+        return tool_call
+
+    sanitized = sanitize_tool_arguments(arguments)
+    if sanitized != arguments:
+        func["arguments"] = json.dumps(sanitized)
+
+    return tool_call
+
+
 def filter_valid_tool_calls(
     tool_calls: Optional[list[dict]],
     tools: Optional[list[dict]],
 ) -> Optional[list[dict]]:
-    """Filter tool calls, removing those with missing required params.
+    """Filter and sanitize tool calls.
+
+    1. Sanitizes arguments (e.g. string "null" -> JSON null).
+    2. Removes tool calls with missing required params.
 
     Invalid tool calls are dropped with a WARNING log.
 
@@ -95,6 +145,9 @@ def filter_valid_tool_calls(
     if not tool_calls or not tools:
         return tool_calls
 
+    # Sanitize all tool calls first
+    tool_calls = [_sanitize_tool_call(tc) for tc in tool_calls]
+
     index = build_required_params_index(tools)
     valid = [tc for tc in tool_calls if validate_tool_call(tc, index)]
 

{cli2api-0.2.2 → cli2api-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cli2api"
-version = "0.2.2"
+version = "0.2.3"
 description = "OpenAI-compatible API over Claude Code CLI"
 readme = "README.md"
 requires-python = ">=3.11"

{cli2api-0.2.2 → cli2api-0.2.3}/tests/test_providers.py

@@ -247,6 +247,13 @@ class TestDeserializeStringValues:
         result = provider._deserialize_string_values(obj)
         assert result["empty"] == ""
 
+    def test_null_string_becomes_none(self, provider):
+        """String "null" should be converted to Python None."""
+        obj = {"cwd": "null", "command": "ls -la"}
+        result = provider._deserialize_string_values(obj)
+        assert result["cwd"] is None
+        assert result["command"] == "ls -la"
+
     def test_real_kilo_code_follow_up(self, provider):
         """Reproduce exact Kilo Code ask_followup_question scenario."""
         obj = {
@@ -358,6 +365,20 @@ class TestExtractNativeToolCall:
         args = json.loads(result["function"]["arguments"])
         assert args == {}
 
+    def test_cwd_null_string_becomes_json_null(self, provider):
+        """String "null" for cwd should be converted to JSON null in arguments."""
+        block = {
+            "type": "tool_use",
+            "id": "toolu_04CWD",
+            "name": "execute_command",
+            "input": {"command": "ls -la", "cwd": "null"},
+        }
+
+        result = provider._extract_native_tool_call(block)
+        args = json.loads(result["function"]["arguments"])
+        assert args["cwd"] is None
+        assert args["command"] == "ls -la"
+
     def test_generates_id_when_missing(self, provider):
         """Should generate a call_ prefixed ID when block has no id."""
         block = {

{cli2api-0.2.2 → cli2api-0.2.3}/tests/test_tool_validator.py

@@ -7,6 +7,7 @@ import pytest
 from cli2api.tools.validator import (
     build_required_params_index,
     filter_valid_tool_calls,
+    sanitize_tool_arguments,
     validate_tool_call,
 )
 
@@ -199,3 +200,60 @@ class TestFilterValidToolCalls:
         tool_calls = [_make_tool_call("list_files", {})]
         result = filter_valid_tool_calls(tool_calls, SAMPLE_TOOLS)
         assert len(result) == 1
+
+    def test_sanitizes_null_string_to_json_null(self):
+        """filter_valid_tool_calls should convert "null" strings to JSON null."""
+        tc = _make_tool_call_raw(
+            "execute_command",
+            '{"command": "ls -la", "cwd": "null"}',
+        )
+        result = filter_valid_tool_calls([tc], SAMPLE_TOOLS)
+        assert len(result) == 1
+        args = json.loads(result[0]["function"]["arguments"])
+        assert args["cwd"] is None
+        assert args["command"] == "ls -la"
+
+    def test_sanitizes_preserves_real_null(self):
+        """JSON null should remain null after sanitization."""
+        tc = _make_tool_call_raw(
+            "execute_command",
+            '{"command": "ls -la", "cwd": null}',
+        )
+        result = filter_valid_tool_calls([tc], SAMPLE_TOOLS)
+        assert len(result) == 1
+        args = json.loads(result[0]["function"]["arguments"])
+        assert args["cwd"] is None
+        assert args["command"] == "ls -la"
+
+
+# === Tests for sanitize_tool_arguments ===
+
+
+class TestSanitizeToolArguments:
+    def test_null_string_becomes_none(self):
+        result = sanitize_tool_arguments({"cwd": "null", "command": "ls"})
+        assert result["cwd"] is None
+        assert result["command"] == "ls"
+
+    def test_none_stays_none(self):
+        result = sanitize_tool_arguments({"cwd": None, "command": "ls"})
+        assert result["cwd"] is None
+
+    def test_normal_strings_unchanged(self):
+        result = sanitize_tool_arguments({"path": "/tmp", "command": "ls"})
+        assert result["path"] == "/tmp"
+        assert result["command"] == "ls"
+
+    def test_non_string_values_unchanged(self):
+        result = sanitize_tool_arguments({"count": 5, "flag": True})
+        assert result["count"] == 5
+        assert result["flag"] is True
+
+    def test_empty_dict(self):
+        assert sanitize_tool_arguments({}) == {}
+
+    def test_string_containing_null_substring_unchanged(self):
+        """Only exact 'null' string should be converted, not substrings."""
+        result = sanitize_tool_arguments({"note": "nullable", "path": "nullify"})
+        assert result["note"] == "nullable"
+        assert result["path"] == "nullify"