litecoo 1.0.0__py3-none-any.whl

litecoo/agent_loop.py

@@ -0,0 +1,107 @@
+"""
+Server-side agentic loop for litecoo.
+When X-Agent-Loop: server header is set on /v1/messages requests,
+litecoo executes tool calls internally instead of returning them to the client.
+The loop continues until stop_reason=end_turn or max_turns is reached.
+"""
+
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger("litecoo.agent_loop")
+
+
+async def run_agent_loop(
+    initial_messages: list[dict],
+    system: str,
+    tools: list[dict],
+    kwargs: dict,
+    alias: str,
+    router: Any,
+    session_id: str = None,
+    max_turns: int = 10,
+    execute_tool_fn: Optional[Any] = None,
+) -> dict:
+    """
+    Execute the agentic tool loop server-side.
+    Returns a final Anthropic-format response dict.
+    """
+    from .main import openai_response_to_anthropic  # late import to avoid circular
+
+    messages = list(initial_messages)
+
+    # Ensure system message is prepended if not already present
+    if system and (not messages or messages[0].get("role") != "system"):
+        messages = [{"role": "system", "content": system}] + messages
+
+    last_anthropic_resp: dict = {}
+
+    for turn in range(max_turns):
+        call_kwargs = dict(kwargs)
+        call_kwargs["messages"] = messages
+        call_kwargs["stream"] = False
+        if tools:
+            call_kwargs["tools"] = tools
+
+        oai_resp = await router.acompletion(model=alias, **call_kwargs)
+        raw = oai_resp.model_dump() if hasattr(oai_resp, "model_dump") else dict(oai_resp)
+
+        # Determine request_model from alias for response
+        anthropic_resp = openai_response_to_anthropic(raw, alias)
+        last_anthropic_resp = anthropic_resp
+        stop_reason = anthropic_resp.get("stop_reason", "end_turn")
+
+        if stop_reason == "end_turn":
+            logger.info(f"[agent_loop] done after {turn + 1} turn(s)")
+            return anthropic_resp
+
+        if stop_reason == "max_tokens":
+            logger.info(f"[agent_loop] max_tokens hit at turn {turn + 1}")
+            return anthropic_resp
+
+        if stop_reason == "tool_use":
+            # Build the assistant message from the OAI response
+            choice = (raw.get("choices") or [{}])[0]
+            asst_msg = choice.get("message", {})
+            if hasattr(asst_msg, "model_dump"):
+                asst_msg = asst_msg.model_dump()
+            messages.append({"role": "assistant", **asst_msg})
+
+            # Execute each tool and append results to messages in OpenAI format
+            for block in anthropic_resp.get("content", []):
+                if block.get("type") != "tool_use":
+                    continue
+                tool_name = block.get("name", "")
+                tool_input = block.get("input", {})
+                tool_id = block.get("id", "")
+
+                logger.info(f"[agent_loop] executing tool '{tool_name}' (turn {turn + 1})")
+                
+                if "_error_invalid_json" in tool_input:
+                    error_msg = tool_input["_error_invalid_json"]
+                    raw_args = tool_input.get("raw_arguments", "")
+                    result = f"Error: Invalid JSON arguments for tool '{tool_name}'. {error_msg}. Raw input was: {raw_args}. Please correct the JSON syntax and try again."
+                else:
+                    fn = execute_tool_fn if execute_tool_fn else (lambda n, i, sid: __import__("tools").execute_tool(n, i, sid))
+                    import inspect
+                    sig = inspect.signature(fn)
+                    if "session_id" in sig.parameters:
+                        result = await fn(tool_name, tool_input, session_id=session_id)
+                    else:
+                        result = await fn(tool_name, tool_input)
+
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_id,
+                    "content": str(result),
+                })
+            continue
+
+        # Unknown stop reason — return what we have
+        break
+
+    # max_turns exceeded — annotate and return
+    logger.warning(f"[agent_loop] max_turns ({max_turns}) exceeded")
+    if last_anthropic_resp:
+        last_anthropic_resp["stop_reason"] = "end_turn"
+    return last_anthropic_resp

litecoo/cli.py

@@ -0,0 +1,18 @@
+import argparse
+import sys
+import uvicorn
+
+def main():
+    parser = argparse.ArgumentParser(description="litecoo - Free LLM proxy for Cowork")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind (default: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind (default: 8000)")
+    parser.add_argument("--env-file", default=".env", help="Environment file to load")
+    
+    args = parser.parse_args()
+    
+    # We pass the import string instead of the object to enable hot-reloading if needed,
+    # and to ensure uvicorn runs correctly across platforms.
+    uvicorn.run("litecoo.main:app", host=args.host, port=args.port, env_file=args.env_file)
+
+if __name__ == "__main__":
+    main()

litecoo/context.py

@@ -0,0 +1,57 @@
+"""
+Sliding window context management for litecoo.
+Prevents ContextWindowExceededError by trimming old messages when needed.
+"""
+
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger("litecoo.context")
+
+MAX_TOKENS_ESTIMATE: int = int(os.getenv("litecoo_MAX_CONTEXT_TOKENS", "50000"))
+SUMMARY_KEEP_MESSAGES: int = 6
+
+
+async def fit_to_context(messages: list[dict], alias: str, router: Any) -> list[dict]:
+    """
+    Trim messages to stay within the context window by summarising the middle section.
+    Returns the original list unchanged on any error (never crash the request).
+    """
+    try:
+        estimate = sum(len(str(m.get("content", ""))) for m in messages) // 4
+        if estimate < MAX_TOKENS_ESTIMATE:
+            return messages
+
+        # Separate system messages (always keep)
+        system_msgs = [m for m in messages if m.get("role") == "system"]
+        non_system = [m for m in messages if m.get("role") != "system"]
+
+        if len(non_system) <= SUMMARY_KEEP_MESSAGES:
+            return messages  # Nothing to trim
+
+        keep_tail = non_system[-SUMMARY_KEEP_MESSAGES:]
+        middle = non_system[:-SUMMARY_KEEP_MESSAGES]
+
+        if not middle:
+            return messages
+
+        # Drop middle messages entirely to save context, but leave a note
+        # that the agent can use a memory search tool if needed.
+        # (Assuming you implement a search_memory tool)
+        
+        summary_msg: dict = {
+            "role": "user",
+            "content": f"[System Note: {len(middle)} messages have been removed from the middle of this conversation to save context window. If you need to recall past events, rely on your tools or ask the user.]",
+        }
+
+        compacted = system_msgs + [summary_msg] + list(keep_tail)
+        logger.info(
+            f"[context] compacted {len(messages)} → {len(compacted)} messages "
+            f"(estimate was {estimate} tokens)"
+        )
+        return compacted
+
+    except Exception as exc:
+        logger.warning(f"[context] fit_to_context error (returning original): {exc}")
+        return messages

litecoo/custom_router.py

@@ -0,0 +1,260 @@
+import os
+import json
+import logging
+import time
+import httpx
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+logger = logging.getLogger("litecoo.router")
+
+class RouterException(Exception):
+    def __init__(self, message: str, status_code: int = 500, response: Optional[Any] = None):
+        self.message = message
+        self.status_code = status_code
+        self.response = response
+        super().__init__(message)
+
+# Aliases kept for compatibility inside main.py
+LiteLLMException = RouterException
+
+class RateLimitError(RouterException):
+    pass
+
+class AuthenticationError(RouterException):
+    pass
+
+class ContextWindowExceededError(RouterException):
+    pass
+
+# Mock response classes
+class ChoiceMessage:
+    def __init__(self, role: str, content: Optional[str], tool_calls: Optional[list] = None):
+        self.role = role
+        self.content = content
+        self.tool_calls = tool_calls or []
+    def model_dump(self) -> dict:
+        res = {"role": self.role, "content": self.content}
+        if self.tool_calls:
+            res["tool_calls"] = self.tool_calls
+        return res
+
+class Choice:
+    def __init__(self, message: ChoiceMessage, finish_reason: str = "stop"):
+        self.message = message
+        self.finish_reason = finish_reason
+
+class Usage:
+    def __init__(self, prompt_tokens: int, completion_tokens: int, total_tokens: int):
+        self.prompt_tokens = prompt_tokens
+        self.completion_tokens = completion_tokens
+        self.total_tokens = total_tokens
+
+class ChatCompletionResponse:
+    def __init__(self, raw_dict: dict):
+        self._dict = raw_dict
+        self.choices = []
+        for choice_data in raw_dict.get("choices", []):
+            msg_data = choice_data.get("message", {})
+            msg = ChoiceMessage(
+                role=msg_data.get("role", "assistant"),
+                content=msg_data.get("content"),
+                tool_calls=msg_data.get("tool_calls")
+            )
+            self.choices.append(Choice(message=msg, finish_reason=choice_data.get("finish_reason", "stop")))
+        
+        usage_data = raw_dict.get("usage", {})
+        self.usage = Usage(
+            prompt_tokens=usage_data.get("prompt_tokens", 0),
+            completion_tokens=usage_data.get("completion_tokens", 0),
+            total_tokens=usage_data.get("total_tokens", 0)
+        )
+        self.id = raw_dict.get("id", "")
+        self.model = raw_dict.get("model", "")
+        
+    def model_dump(self) -> dict:
+        return self._dict
+
+# Streaming support classes
+class ToolCallFunction:
+    def __init__(self, name: Optional[str], arguments: Optional[str]):
+        self.name = name
+        self.arguments = arguments
+
+class ToolCallDelta:
+    def __init__(self, index: int, id: Optional[str], function: Optional[ToolCallFunction]):
+        self.index = index
+        self.id = id
+        self.function = function
+
+class Delta:
+    def __init__(self, content: Optional[str] = None, tool_calls: Optional[list] = None):
+        self.content = content
+        self.tool_calls = tool_calls
+
+class StreamingChoice:
+    def __init__(self, delta: Delta):
+        self.delta = delta
+
+class StreamingChunk:
+    def __init__(self, raw_dict: dict):
+        self._dict = raw_dict
+        self.choices = []
+        for choice_data in raw_dict.get("choices", []):
+            delta_data = choice_data.get("delta", {})
+            tc_list = []
+            if "tool_calls" in delta_data:
+                for tc in delta_data.get("tool_calls", []):
+                    fn_data = tc.get("function", {})
+                    fn = ToolCallFunction(
+                        name=fn_data.get("name"),
+                        arguments=fn_data.get("arguments")
+                    )
+                    tc_list.append(ToolCallDelta(
+                        index=tc.get("index", 0),
+                        id=tc.get("id"),
+                        function=fn
+                    ))
+            delta = Delta(
+                content=delta_data.get("content"),
+                tool_calls=tc_list if "tool_calls" in delta_data else None
+            )
+            self.choices.append(StreamingChoice(delta=delta))
+            
+    def json(self) -> str:
+        return json.dumps(self._dict)
+        
+    def model_dump_json(self, **kwargs) -> str:
+        return json.dumps(self._dict)
+
+def _resolve_env_vars(config_val: Any) -> Any:
+    """Recursively resolve values starting with 'os.environ/' to actual env variables."""
+    if isinstance(config_val, str):
+        if config_val.startswith("os.environ/"):
+            env_var = config_val.removeprefix("os.environ/")
+            return os.getenv(env_var, "")
+        return config_val
+    elif isinstance(config_val, dict):
+        return {k: _resolve_env_vars(v) for k, v in config_val.items()}
+    elif isinstance(config_val, list):
+        return [_resolve_env_vars(i) for i in config_val]
+    return config_val
+
+class Router:
+    def __init__(self, model_list: List[Dict], **kwargs):
+        self.model_list = model_list
+        self.client = httpx.AsyncClient(timeout=60.0)
+
+    async def acompletion(self, model: str, **kwargs) -> Any:
+        # 1. Find the target model configuration in model_list
+        config_item = None
+        for item in self.model_list:
+            if item.get("model_name") == model:
+                config_item = item
+                break
+        
+        if not config_item:
+            logger.warning(f"Model {model} not found in model_list configuration. Using as-is.")
+            config_item = {"litellm_params": {"model": model}}
+
+        params = config_item.get("provider_params") or config_item.get("litellm_params", {})
+        # Resolve any env variables (e.g. API keys) in parameters
+        resolved_params = _resolve_env_vars(params)
+
+        target_model = resolved_params.get("model", model)
+        api_base = resolved_params.get("api_base")
+        api_key = resolved_params.get("api_key")
+        extra_headers = resolved_params.get("extra_headers") or {}
+
+        # 2. Determine target API Base URL
+        if target_model.startswith("openrouter/"):
+            target_model = target_model.removeprefix("openrouter/")
+            if not api_base:
+                api_base = "https://openrouter.ai/api/v1"
+        elif target_model.startswith("openai/"):
+            target_model = target_model.removeprefix("openai/")
+
+        if not api_base:
+            api_base = "https://api.openai.com/v1"
+
+        # 3. Construct headers
+        headers = {
+            "Content-Type": "application/json",
+            **extra_headers
+        }
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+
+        # 4. Construct payload
+        payload = {
+            "model": target_model,
+            **{k: v for k, v in kwargs.items() if k not in ("model", "api_base", "api_key")}
+        }
+
+        # 5. Make request
+        url = f"{api_base.rstrip('/')}/chat/completions"
+        logger.info(f"Forwarding completion request to: {url} (model: {target_model})")
+
+        try:
+            if payload.get("stream"):
+                async def stream_generator():
+                    req = self.client.build_request("POST", url, json=payload, headers=headers)
+                    resp = await self.client.send(req, stream=True)
+                    try:
+                        if resp.status_code != 200:
+                            await resp.aread()
+                            self._handle_error_status(resp.status_code, resp.text, resp)
+                        
+                        buffer = ""
+                        async for chunk_bytes in resp.aiter_bytes():
+                            buffer += chunk_bytes.decode("utf-8")
+                            while "\n" in buffer:
+                                line, buffer = buffer.split("\n", 1)
+                                line = line.strip()
+                                if not line:
+                                    continue
+                                if line == "data: [DONE]":
+                                    break
+                                if line.startswith("data:"):
+                                    data_part = line.removeprefix("data:").strip()
+                                    if data_part == "[DONE]":
+                                        break
+                                    try:
+                                        chunk_dict = json.loads(data_part)
+                                        yield StreamingChunk(chunk_dict)
+                                    except Exception as err:
+                                        logger.warning(f"Failed to parse streaming chunk: {err}. Line: {line}")
+                    finally:
+                        await resp.aclose()
+                return stream_generator()
+            else:
+                resp = await self.client.post(url, json=payload, headers=headers)
+                if resp.status_code != 200:
+                    self._handle_error_status(resp.status_code, resp.text, resp)
+                
+                return ChatCompletionResponse(resp.json())
+
+        except httpx.HTTPStatusError as e:
+            self._handle_error_status(e.response.status_code, e.response.text, e.response)
+        except httpx.RequestError as e:
+            logger.error(f"HTTP request error: {e}")
+            raise RouterException(f"Provider HTTP request failed: {e}", status_code=500)
+
+    def _handle_error_status(self, status_code: int, response_text: str, response_obj: Optional[httpx.Response] = None):
+        logger.error(f"Upstream provider error status: {status_code}. Response: {response_text}")
+        
+        msg = f"Provider failed with status {status_code}"
+        try:
+            err_json = json.loads(response_text)
+            if "error" in err_json:
+                msg = err_json["error"].get("message", msg)
+        except Exception:
+            pass
+
+        if status_code == 429:
+            raise RateLimitError(msg, status_code=status_code, response=response_obj)
+        elif status_code in (401, 403):
+            raise AuthenticationError(msg, status_code=status_code, response=response_obj)
+        elif status_code == 400 and "context_length" in msg.lower():
+            raise ContextWindowExceededError(msg, status_code=status_code, response=response_obj)
+        else:
+            raise RouterException(msg, status_code=status_code, response=response_obj)