cli2api 0.2.0__tar.gz → 0.2.2__tar.gz

cli2api-0.2.2/.env.example

@@ -0,0 +1,32 @@
+# CLI2API Configuration
+# Copy this file to .env and customize as needed
+
+# Server settings
+CLI2API_HOST=0.0.0.0
+CLI2API_PORT=8000
+CLI2API_DEBUG=false
+
+# CLI executable path (auto-detected if not set)
+# Auto-detection checks (in order):
+#   1. Cached path (~/.cache/cli2api/claude_cli_path)
+#   2. System PATH (shutil.which)
+#   3. Running Claude processes (ps aux / wmic)
+#   4. VSCode extensions (~/.vscode/extensions/anthropic.claude-code-*)
+#   5. NPM global packages
+#   6. Common paths (/opt/homebrew/bin, /usr/local/bin, ~/.local/bin)
+#
+# Explicitly set if auto-detection fails or you want to override:
+# CLI2API_CLAUDE_CLI_PATH=/opt/homebrew/bin/claude
+# CLI2API_CLAUDE_CLI_PATH=/Users/username/.vscode/extensions/anthropic.claude-code-2.1.31-darwin-arm64/resources/native-binary/claude
+
+# Timeout (in seconds)
+CLI2API_DEFAULT_TIMEOUT=300
+
+# Default model
+CLI2API_DEFAULT_MODEL=sonnet
+
+# Custom models (comma-separated)
+# CLI2API_CLAUDE_MODELS=sonnet,opus,haiku
+
+# Logging
+CLI2API_LOG_LEVEL=INFO

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

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

{cli2api-0.2.0 → cli2api-0.2.2}/cli2api/__init__.py

@@ -1,3 +1,3 @@
 """CLI2API - OpenAI-compatible API over CLI tools."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.2"

{cli2api-0.2.0 → cli2api-0.2.2}/cli2api/api/dependencies.py

@@ -29,7 +29,27 @@ def get_provider() -> ClaudeCodeProvider:
     """
     settings = get_settings()
     if not settings.claude_cli_path:
-        raise RuntimeError("Claude CLI not found. Set CLI2API_CLAUDE_CLI_PATH.")
+        error_msg = """
+Claude CLI not found. Please:
+
+1. Install Claude Code: https://docs.anthropic.com/en/docs/claude-code
+2. Or set environment variable: export CLI2API_CLAUDE_CLI_PATH=/path/to/claude
+3. Or ensure Claude is in your PATH
+
+Auto-detection checked:
+- Cached path (~/.cache/cli2api/claude_cli_path)
+- System PATH (shutil.which)
+- Running processes (ps aux / wmic)
+- VSCode extensions (platform-specific)
+- NPM global packages
+- Common paths (platform-specific)
+
+For debugging, run: CLI2API_LOG_LEVEL=DEBUG cli2api
+
+Note: Detected path is cached in ~/.cache/cli2api/claude_cli_path
+To force re-detection, delete the cache file.
+"""
+        raise RuntimeError(error_msg.strip())
 
     return ClaudeCodeProvider(
         executable_path=Path(settings.claude_cli_path),

{cli2api-0.2.0 → cli2api-0.2.2}/cli2api/config/settings.py

@@ -1,6 +1,5 @@
 """Application settings."""
 
-import shutil
 from pathlib import Path
 from typing import Optional
 
@@ -68,19 +67,33 @@ class Settings(BaseSettings):
     @classmethod
     def detect_claude_cli(cls, v: Optional[str]) -> Optional[str]:
         """Auto-detect claude CLI path if not provided."""
+        from cli2api.utils.cli_detector import (
+            cache_path,
+            detect_claude_cli,
+            verify_claude_executable,
+        )
+        from cli2api.utils.logging import get_logger
+
+        logger = get_logger(__name__)
+
         if v:
-            return v
-        # Try which first
-        path = shutil.which("claude")
-        if path:
-            return path
-        # Fallback to common paths
-        common_paths = [
-            "/opt/homebrew/bin/claude",
-            "/usr/local/bin/claude",
-            Path.home() / ".local/bin/claude",
-        ]
-        for p in common_paths:
-            if Path(p).exists():
-                return str(p)
+            # User explicitly set path - verify it
+            path = Path(v)
+            if verify_claude_executable(path):
+                logger.info(f"Using explicitly set Claude CLI path: {v}")
+                # Cache explicitly set path
+                cache_path(path)
+                return v
+            logger.warning(f"Explicitly set Claude CLI path is invalid: {v}")
+
+        # Auto-detect (includes cache check)
+        detected_path = detect_claude_cli()
+
+        if detected_path:
+            logger.info(f"Auto-detected Claude CLI: {detected_path}")
+            # Cache detected path for next startup
+            cache_path(detected_path)
+            return str(detected_path)
+
+        logger.error("Claude CLI not found")
         return None

cli2api-0.2.2/cli2api/prompts/tools_instruction.txt

@@ -0,0 +1,58 @@
+You have access to the following tools:
+
+{tool_definitions}
+
+---
+RESPONSE FORMAT:
+
+When calling tools, wrap EACH tool call in <tool_call> tags.
+You may include explanatory text before or after the tags.
+
+For a SINGLE tool call:
+<tool_call>
+{{"name": "TOOL_NAME", "arguments": {{...}}}}
+</tool_call>
+
+For MULTIPLE tool calls, use SEPARATE tags for each:
+<tool_call>
+{{"name": "read_file", "arguments": {{"path": "file1.py"}}}}
+</tool_call>
+<tool_call>
+{{"name": "read_file", "arguments": {{"path": "file2.py"}}}}
+</tool_call>
+
+CRITICAL RULES:
+- ALWAYS wrap tool calls in <tool_call>...</tool_call> tags
+- Each tool call must be in its own tag pair
+- 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
+- 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
+- If user wants to list files -> use list_files tool
+
+WRONG — missing arguments:
+<tool_call>
+{{"name": "execute_command"}}
+</tool_call>
+
+WRONG — empty arguments when tool requires parameters:
+<tool_call>
+{{"name": "execute_command", "arguments": {{}}}}
+</tool_call>
+
+CORRECT:
+<tool_call>
+{{"name": "execute_command", "arguments": {{"command": "ls -la"}}}}
+</tool_call>
+
+{tool_examples}
+
+ATTEMPT_COMPLETION USAGE:
+When using attempt_completion, ALWAYS include the 'result' parameter:
+<tool_call>
+{{"name": "attempt_completion", "arguments": {{"result": "Your response text here"}}}}
+</tool_call>
+- The 'result' parameter is REQUIRED and must contain your final response
+- Use attempt_completion ONLY after you have gathered all needed information

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

@@ -2,13 +2,16 @@
 
 import asyncio
 import json
+import uuid
 from pathlib import Path
 from typing import Any, AsyncIterator, Optional
 
+from cli2api.constants import ID_HEX_LENGTH, TOOL_CALL_ID_PREFIX
 from cli2api.schemas.internal import ProviderChunk, ProviderResult
 from cli2api.schemas.openai import ChatMessage
 from cli2api.streaming.tool_parser import StreamingToolParser
 from cli2api.tools.handler import ToolHandler
+from cli2api.tools.validator import filter_valid_tool_calls
 from cli2api.utils.logging import get_logger
 
 logger = get_logger(__name__)
@@ -221,7 +224,9 @@ class ClaudeCodeProvider:
     ) -> tuple[str, Optional[list[dict]]]:
         """Parse content for tool calls if tools are provided."""
         if tools and content:
-            return ToolHandler.parse_tool_calls(content)
+            remaining, tool_calls = ToolHandler.parse_tool_calls(content)
+            tool_calls = filter_valid_tool_calls(tool_calls, tools)
+            return remaining, tool_calls
         return content, None
 
     def _create_final_chunk(
@@ -237,12 +242,27 @@ class ClaudeCodeProvider:
             usage=usage,
         )
 
+    @staticmethod
+    def _deserialize_string_values(obj: dict) -> dict:
+        """Deserialize JSON-encoded string values in tool arguments.
+
+        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"}]
+        """
+        result = {}
+        for key, value in obj.items():
+            if isinstance(value, str) and value and value[0] in ('[', '{'):
+                try:
+                    result[key] = json.loads(value)
+                except (json.JSONDecodeError, ValueError):
+                    result[key] = value
+            else:
+                result[key] = value
+        return result
+
     def _extract_native_tool_call(self, block: dict) -> Optional[dict]:
         """Extract tool call from Claude native tool_use block."""
-        import json
-        import uuid
-        from cli2api.constants import ID_HEX_LENGTH, TOOL_CALL_ID_PREFIX
-
         tool_name = block.get("name")
         tool_input = block.get("input", {})
         tool_id = block.get("id", f"{TOOL_CALL_ID_PREFIX}{uuid.uuid4().hex[:ID_HEX_LENGTH]}")
@@ -250,6 +270,9 @@ class ClaudeCodeProvider:
         if not tool_name:
             return None
 
+        if isinstance(tool_input, dict):
+            tool_input = self._deserialize_string_values(tool_input)
+
         return {
             "id": tool_id,
             "type": "function",
@@ -391,12 +414,14 @@ class ClaudeCodeProvider:
                             # Native tool calling (stop_reason=tool_use)
                             if stop_reason == "tool_use":
                                 tool_calls = native_tool_calls if native_tool_calls else None
+                                tool_calls = filter_valid_tool_calls(tool_calls, tools)
                                 logger.info(f"[STREAM] Native tool_calls: {len(tool_calls) if tool_calls else 0}")
                             elif tool_parser:
                                 final_result = tool_parser.finalize()
                                 if final_result.text:
                                     yield ProviderChunk(content=final_result.text)
                                 tool_calls = tool_parser.get_all_tool_calls()
+                                tool_calls = filter_valid_tool_calls(tool_calls, tools)
                             else:
                                 _, tool_calls = self._handle_tool_calls_in_content(
                                     accumulated_content, tools
@@ -433,6 +458,7 @@ class ClaudeCodeProvider:
                         if final_result.text:
                             yield ProviderChunk(content=final_result.text)
                         tool_calls = tool_parser.get_all_tool_calls()
+                        tool_calls = filter_valid_tool_calls(tool_calls, tools)
                     else:
                         _, tool_calls = self._handle_tool_calls_in_content(
                             accumulated_content, tools
@@ -476,6 +502,7 @@ class ClaudeCodeProvider:
                         if final_result.text:
                             yield ProviderChunk(content=final_result.text)
                         tool_calls = tool_parser.get_all_tool_calls()
+                        tool_calls = filter_valid_tool_calls(tool_calls, tools)
                     else:
                         _, tool_calls = self._handle_tool_calls_in_content(
                             accumulated_content, tools
@@ -489,6 +516,7 @@ class ClaudeCodeProvider:
                 if final_result.text:
                     yield ProviderChunk(content=final_result.text)
                 tool_calls = tool_parser.get_all_tool_calls()
+                tool_calls = filter_valid_tool_calls(tool_calls, tools)
             else:
                 _, tool_calls = self._handle_tool_calls_in_content(accumulated_content, tools)
 

{cli2api-0.2.0 → cli2api-0.2.2}/cli2api/tools/handler.py

@@ -3,6 +3,8 @@
 import json
 import re
 import uuid
+from functools import lru_cache
+from pathlib import Path
 from typing import Any, Optional
 
 from cli2api.constants import (
@@ -14,6 +16,13 @@ from cli2api.constants import (
 from cli2api.schemas.openai import ChatMessage
 
 
+@lru_cache(maxsize=4)
+def _load_prompt_template(filename: str) -> str:
+    """Load prompt template from cli2api/prompts/ directory."""
+    path = Path(__file__).parent.parent / "prompts" / filename
+    return path.read_text()
+
+
 # ==================== Message Helpers ====================
 
 
@@ -86,9 +95,8 @@ class ToolHandler:
             key=lambda t: t.get("function", {}).get("name", "")
         )
 
-        lines = [
-            "You have access to the following tools:\n",
-        ]
+        tool_definitions = []
+        tool_examples = []
 
         for tool in tools:
             if tool.get("type") != "function":
@@ -98,14 +106,10 @@ class ToolHandler:
             name = func.get("name", "unknown")
             description = func.get("description", "No description")
             params = func.get("parameters", {})
-
-            lines.append(f"## {name}")
-            lines.append(f"{description}\n")
-
-            # Format parameters
             properties = params.get("properties", {})
             required = params.get("required", [])
 
+            lines = [f"## {name}", f"{description}\n"]
             if properties:
                 lines.append("Parameters:")
                 for pname, pinfo in properties.items():
@@ -114,45 +118,23 @@ class ToolHandler:
                     req = " (required)" if pname in required else " (optional)"
                     lines.append(f"- {pname} ({ptype}{req}): {pdesc}")
                 lines.append("")
-
-        lines.append("\n---")
-        lines.append("RESPONSE FORMAT:")
-        lines.append("")
-        lines.append("When calling tools, wrap EACH tool call in <tool_call> tags.")
-        lines.append("You may include explanatory text before or after the tags.")
-        lines.append("")
-        lines.append("For a SINGLE tool call:")
-        lines.append("<tool_call>")
-        lines.append('{"name": "TOOL_NAME", "arguments": {...}}')
-        lines.append("</tool_call>")
-        lines.append("")
-        lines.append("For MULTIPLE tool calls, use SEPARATE tags for each:")
-        lines.append("<tool_call>")
-        lines.append('{"name": "read_file", "arguments": {"path": "file1.py"}}')
-        lines.append("</tool_call>")
-        lines.append("<tool_call>")
-        lines.append('{"name": "read_file", "arguments": {"path": "file2.py"}}')
-        lines.append("</tool_call>")
-        lines.append("")
-        lines.append("CRITICAL RULES:")
-        lines.append("- ALWAYS wrap tool calls in <tool_call>...</tool_call> tags")
-        lines.append("- Each tool call must be in its own tag pair")
-        lines.append("- When reading multiple files, include multiple <tool_call> tags")
-        lines.append("- You CAN include text explanation before/after tags")
-        lines.append("- Do NOT execute tools yourself - just output the tags")
-        lines.append("- If user wants to read a file -> use read_file tool")
-        lines.append("- If user wants to list files -> use list_files tool")
-        lines.append("- ALWAYS include ALL required parameters for each tool")
-        lines.append("")
-        lines.append("ATTEMPT_COMPLETION USAGE:")
-        lines.append("When using attempt_completion, ALWAYS include the 'result' parameter:")
-        lines.append("<tool_call>")
-        lines.append('{"name": "attempt_completion", "arguments": {"result": "Your response text here"}}')
-        lines.append("</tool_call>")
-        lines.append("- The 'result' parameter is REQUIRED and must contain your final response")
-        lines.append("- Use attempt_completion ONLY after you have gathered all needed information")
-
-        return "\n".join(lines)
+            tool_definitions.append("\n".join(lines))
+
+            # Generate example call for tools with required parameters
+            if required:
+                example_args = {p: "<value>" for p in required}
+                example_json = json.dumps({"name": name, "arguments": example_args})
+                tool_examples.append(f"<tool_call>\n{example_json}\n</tool_call>")
+
+        template = _load_prompt_template("tools_instruction.txt")
+        examples_section = ""
+        if tool_examples:
+            examples_section = "Required parameter examples:\n" + "\n".join(tool_examples)
+
+        return template.format(
+            tool_definitions="\n".join(tool_definitions),
+            tool_examples=examples_section,
+        )
 
     @staticmethod
     def generate_tool_call_id() -> str:

cli2api-0.2.2/cli2api/tools/validator.py

@@ -0,0 +1,105 @@
+"""Tool call argument validation against OpenAI tool schemas."""
+
+import json
+from typing import Optional
+
+from cli2api.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def build_required_params_index(tools: list[dict]) -> dict[str, list[str]]:
+    """Build a lookup: tool_name -> list of required parameter names.
+
+    Args:
+        tools: OpenAI-format tool definitions.
+
+    Returns:
+        Dict mapping tool name to list of required param names.
+    """
+    index = {}
+    for tool in tools:
+        if tool.get("type") != "function":
+            continue
+        func = tool.get("function", {})
+        name = func.get("name")
+        if not name:
+            continue
+        params = func.get("parameters", {})
+        index[name] = params.get("required", [])
+    return index
+
+
+def validate_tool_call(
+    tool_call: dict,
+    required_params_index: dict[str, list[str]],
+) -> bool:
+    """Validate a single tool call has all required arguments.
+
+    Args:
+        tool_call: Parsed tool call in OpenAI format.
+        required_params_index: From build_required_params_index().
+
+    Returns:
+        True if valid (all required params present), False otherwise.
+    """
+    func = tool_call.get("function", {})
+    name = func.get("name", "")
+    arguments_str = func.get("arguments", "{}")
+
+    required = required_params_index.get(name)
+    if required is None:
+        # Unknown tool — can't validate, let it pass
+        return True
+
+    if not required:
+        # Tool has no required params — always valid
+        return True
+
+    try:
+        arguments = json.loads(arguments_str)
+    except (json.JSONDecodeError, TypeError):
+        logger.warning(f"Tool call '{name}' has unparseable arguments: {arguments_str!r}")
+        return False
+
+    if not isinstance(arguments, dict):
+        logger.warning(f"Tool call '{name}' arguments is not a dict: {type(arguments)}")
+        return False
+
+    missing = [p for p in required if p not in arguments]
+    if missing:
+        logger.warning(
+            f"Tool call '{name}' missing required params: {missing}. "
+            f"Got: {list(arguments.keys())}"
+        )
+        return False
+
+    return True
+
+
+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.
+
+    Invalid tool calls are dropped with a WARNING log.
+
+    Args:
+        tool_calls: Parsed tool calls (may be None).
+        tools: Original tool definitions (may be None).
+
+    Returns:
+        Filtered list, or None if empty/input was None.
+    """
+    if not tool_calls or not tools:
+        return tool_calls
+
+    index = build_required_params_index(tools)
+    valid = [tc for tc in tool_calls if validate_tool_call(tc, index)]
+
+    if len(valid) < len(tool_calls):
+        dropped = len(tool_calls) - len(valid)
+        logger.warning(f"Dropped {dropped} invalid tool call(s) with missing required params")
+
+    return valid if valid else None