sourcebot 0.1.0__py3-none-any.whl

sourcebot/docker_sandbox/docker_sandbox.py

@@ -0,0 +1,113 @@
+# sourcebot/docker_sandbox/dockersandbox.py
+import asyncio
+import docker
+import shlex
+from typing import Optional
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+class DockerSandbox:
+    def __init__(
+        self,
+        image: str = "python:3.11-slim",
+        workdir: str = "/workspace",          # Working directory within the container
+        host_workspace: str | None = None,    # Host directory
+    ):
+        self.client = docker.from_env()
+        self.image = image
+        self.workdir = workdir
+        if not host_workspace:
+            raise ValueError("host_workspace must be provided")
+        self.host_workspace = str(Path(host_workspace).resolve())
+        Path(self.host_workspace).mkdir(parents=True, exist_ok=True)
+        self.container = None
+
+    # Secure Start (async wrapper)
+    async def start(self):
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, self._start_sync)
+
+    def _start_sync(self):
+        logger.debug(f"Starting Docker sandbox with image {self.image}")
+        logger.debug(f"Host workspace: {self.host_workspace}")
+
+        try:
+            try:
+                self.client.images.get(self.image)
+            except docker.errors.ImageNotFound:
+                logger.info(f"Pulling image {self.image}")
+                self.client.images.pull(self.image)
+
+            self.container = self.client.containers.create(
+                self.image,
+                command="sleep infinity",
+                tty=True,
+                volumes={
+                    self.host_workspace: {
+                        "bind": self.workdir,
+                        "mode": "rw",
+                    }
+                },
+                working_dir=self.workdir,
+            )
+            self.container.start()
+            logger.debug(f"Docker sandbox started: {self.container.id}")
+
+        except Exception as e:
+            logger.error(f"Failed to start Docker sandbox: {e}")
+            self.container = None
+            raise
+
+    async def execute(self, cmd: str, timeout: Optional[int] = 300) -> str:
+        """
+        Execute commands in a Docker container
+        """
+        if not self.container:
+            raise RuntimeError("DockerSandbox not started")
+        
+        logger.debug(f"Executing command in Docker: {cmd}")
+        exec_instance = self.client.api.exec_create(
+            container = self.container.id,
+            cmd = ["bash", "-c", cmd],
+            workdir = self.workdir,
+            stdout = True,
+            stderr = True,
+            tty = True,
+        )
+        output = self.client.api.exec_start(exec_instance['Id'], detach=False, tty=True)
+        exit_code = self.client.api.exec_inspect(exec_instance['Id'])['ExitCode']
+
+        result = output.decode("utf-8").strip()
+        if exit_code != 0:
+            logger.warning(f"Command failed (exit {exit_code}): {result}")
+        else:
+            logger.debug(f"Command succeeded: {result}")
+        return result
+
+
+    # Safe stop
+    async def stop(self):
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, self._stop_sync)
+
+    def _stop_sync(self):
+        if self.container:
+            logger.debug(f"Stopping Docker sandbox {self.container.id}")
+            try:
+                self.container.kill()
+            except Exception as e:
+                logger.warning(f"Error killing container: {e}")
+            try:
+                self.container.remove(force=True)
+            except Exception as e:
+                logger.warning(f"Error removing container: {e}")
+            self.container = None
+            logger.debug("Docker sandbox stopped")
+
+    async def __aenter__(self):
+        await self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.stop()

sourcebot/llm/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.llm.llm_client_factory import LLMClientFactory
+
+__all__ = ["LLMClientFactory"]

sourcebot/llm/anthropic/__init__.py

@@ -0,0 +1,2 @@
+from sourcebot.llm.anthropic.anthropic_llm_client import AnthropicLLMClient
+__all__ = ["AnthropicLLMClient"]

sourcebot/llm/anthropic/adapter.py

@@ -0,0 +1,30 @@
+# sourcebot/llm/anthropic/adapter.py
+from sourcebot.llm.core.adapter import BaseAdapter
+from sourcebot.llm.core.response import LLMResponse, ToolCall
+
+
+class AnthropicAdapter(BaseAdapter):
+
+    def from_response(self, response) -> LLMResponse:
+        text_parts = []
+        tool_calls = []
+
+        for block in response.content:
+            if block.type == "text":
+                text_parts.append(block.text)
+
+            elif block.type == "tool_use":
+                tool_calls.append(
+                    ToolCall(
+                        id=block.id,
+                        name=block.name,
+                        arguments=block.input,
+                    )
+                )
+
+        return LLMResponse(
+            content="\n".join(text_parts) if text_parts else None,
+            tool_calls=tool_calls,
+            finish_reason=response.stop_reason,
+            raw=response,
+        )

sourcebot/llm/anthropic/anthropic_llm_client.py

@@ -0,0 +1,38 @@
+# sourcebot/llm/anthropic/anthropic_llm_client.py
+from sourcebot.config import ConfigManager
+from anthropic import AsyncAnthropic
+from sourcebot.llm.core.client import BaseLLMClient
+from .adapter import AnthropicAdapter
+from sourcebot.llm.anthropic.converter import to_anthropic_messages, to_anthropic_tools
+from sourcebot.llm.core.tool_converter import normalize_tools
+
+class AnthropicLLMClient(BaseLLMClient):
+
+    def __init__(self, config_manager, provider_name: str = "anthropic", model_name: str = "claude-3-opus-20240229"):
+        provider_config = config_manager.get_provider_config(provider_name)
+        self.client = AsyncAnthropic(
+            api_key = provider_config.api_key,
+            base_url = provider_config.api_base
+        )
+        self.temperature = provider_config.temperature
+        self.model_name = model_name
+        self.adapter = AnthropicAdapter()
+
+    async def complete(self, messages, tools = None):
+        tools = normalize_tools(tools)
+        system, amsgs = to_anthropic_messages(messages)
+        req = {
+            "model": self.model_name,
+            "messages": amsgs,
+            "max_tokens": 4096,
+        }
+        
+        if system:
+            req["system"] = system
+
+        if tools:
+            req["tools"] = to_anthropic_tools(tools)
+
+        resp = await self.client.messages.create(**req)
+
+        return self.adapter.from_response(resp)

sourcebot/llm/anthropic/converter.py

@@ -0,0 +1,59 @@
+# sourcebot/llm/anthropic/converter.py
+from sourcebot.llm.core.message import Message
+
+def to_anthropic_messages(messages: list[Message]):
+    system = None
+    result = []
+    for msg in messages:
+        if msg.role == "system":
+            system = msg.content
+            continue
+        if msg.role == "tool":
+            # tool_result → user
+            for tr in msg.tool_results:
+                result.append({
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": tr.tool_call_id,
+                            "content": tr.content,
+                        }
+                    ],
+                })
+            continue
+
+        content_blocks = []
+
+        if msg.content:
+            content_blocks.append({
+                "type": "text",
+                "text": msg.content
+            })
+
+        # tool_call → tool_use
+        for tc in msg.tool_calls:
+            content_blocks.append({
+                "type": "tool_use",
+                "id": tc.id,
+                "name": tc.name,
+                "input": tc.arguments,
+            })
+
+        result.append({
+            "role": msg.role,
+            "content": content_blocks if content_blocks else ""
+        })
+
+    return system, result
+
+
+def to_anthropic_tools(tools):
+    return [
+        {
+            "name": t.name,
+            "description": t.description,
+            "input_schema": t.parameters,
+        }
+        for t in tools
+    ]

sourcebot/llm/core/adapter.py

@@ -0,0 +1,16 @@
+# sourcebot/llm/core/adapter.py
+
+from abc import ABC, abstractmethod
+from .response import LLMResponse
+from .delta import LLMDelta
+
+
+class BaseAdapter(ABC):
+
+    @abstractmethod
+    def from_response(self, response) -> LLMResponse:
+        pass
+
+    def stream_chunk(self, chunk) -> LLMDelta:
+        """Optional: Streaming parsing"""
+        return LLMDelta()

sourcebot/llm/core/client.py

@@ -0,0 +1,16 @@
+# sourcebot/llm/core/client.py
+
+from abc import ABC, abstractmethod
+from typing import AsyncGenerator
+from .response import LLMResponse
+from .delta import LLMDelta
+
+
+class BaseLLMClient(ABC):
+
+    @abstractmethod
+    async def complete(self, messages, tools = None) -> LLMResponse:
+        pass
+
+    async def stream(self, messages, tools = None) -> AsyncGenerator[LLMDelta, None]:
+        raise NotImplementedError

sourcebot/llm/core/delta.py

@@ -0,0 +1,12 @@
+# sourcebot/llm/core/delta.py
+
+class LLMDelta:
+    def __init__(
+        self,
+        content: str = "",
+        tool_call_delta: dict = None,
+        finish_reason: str = None,
+    ):
+        self.content = content
+        self.tool_call_delta = tool_call_delta
+        self.finish_reason = finish_reason

sourcebot/llm/core/message.py

@@ -0,0 +1,53 @@
+# sourcebot/llm/core/message.py
+
+from typing import List, Optional, Any
+
+
+class ToolCall:
+    def __init__(self, id: str, name: str, arguments: Any):
+        self.id = id
+        self.name = name
+        self.arguments = arguments
+
+
+class ToolResult:
+    def __init__(self, tool_call_id: str, content: str):
+        self.tool_call_id = tool_call_id
+        self.content = content
+
+
+class Message:
+    def __init__(
+        self,
+        role: str,
+        content: Optional[str] = None,
+        tool_calls: Optional[List[ToolCall]] = None,
+        tool_results: Optional[List[ToolResult]] = None,
+        metadata: dict = None,
+    ):
+        self.role = role
+        self.content = content
+        self.tool_calls = tool_calls or []
+        self.tool_results = tool_results or []
+        self.metadata = metadata or {}
+
+    # Convert to dictionary (for storage)
+    def to_dict(self) -> dict:
+        return {
+            "role": self.role,
+            "content": self.content,
+            "tool_calls": [tc.to_dict() for tc in self.tool_calls],
+            "tool_results": [tr.to_dict() for tr in self.tool_results],
+            "metadata": self.metadata,
+        }
+
+    # Restore from dict
+    @staticmethod
+    def from_dict(data: dict) -> "Message":
+        return Message(
+            role=data.get("role"),
+            content=data.get("content"),
+            tool_calls=[ToolCall.from_dict(tc) for tc in data.get("tool_calls", [])],
+            tool_results=[ToolResult.from_dict(tr) for tr in data.get("tool_results", [])],
+            metadata=data.get("metadata", {}),
+        )

sourcebot/llm/core/message_converter.py

@@ -0,0 +1,33 @@
+# sourcebot/llm/core/message_converter.py
+from sourcebot.llm.core.message import Message, ToolCall, ToolResult
+
+def dict_to_message(msg: dict) -> Message:
+    role = msg["role"]
+    content = msg.get("content")
+
+    tool_calls = []
+    for tc in msg.get("tool_calls", []):
+        tool_calls.append(
+            ToolCall(
+                id=tc["id"],
+                name=tc["function"]["name"],
+                arguments=tc["function"]["arguments"],
+            )
+        )
+
+    tool_results = []
+    if role == "tool":
+        tool_results.append(
+            ToolResult(
+                tool_call_id=msg["tool_call_id"],
+                content=content,
+            )
+        )
+
+    return Message(
+        role=role,
+        content=content,
+        tool_calls=tool_calls,
+        tool_results=tool_results,
+    )
+

sourcebot/llm/core/response.py

@@ -0,0 +1,30 @@
+# sourcebot/llm/core/response.py
+
+from typing import List, Optional, Dict, Any
+
+
+class ToolCall:
+    def __init__(self, id: str, name: str, arguments: Any):
+        self.id = id
+        self.name = name
+        self.arguments = arguments
+
+
+class LLMResponse:
+    def __init__(
+        self,
+        content: Optional[str],
+        tool_calls: Optional[List[ToolCall]] = None,
+        finish_reason: Optional[str] = None,
+        usage: Optional[Dict[str, int]] = None,
+        raw = None,
+    ):
+        self.content = content
+        self.tool_calls = tool_calls or []
+        self.finish_reason = finish_reason
+        self.usage = usage
+        self.raw = raw
+
+    @property
+    def has_tool_calls(self):
+        return len(self.tool_calls) > 0

sourcebot/llm/core/tool.py

@@ -0,0 +1,7 @@
+# sourcebot/llm/core/tool.py
+
+class Tool:
+    def __init__(self, name: str, description: str, parameters: dict):
+        self.name = name
+        self.description = description
+        self.parameters = parameters

sourcebot/llm/core/tool_converter.py

@@ -0,0 +1,30 @@
+# sourcebot/llm/core/tool_converter.py
+
+from sourcebot.llm.core.tool import Tool
+
+
+def dict_to_tool(t: dict) -> Tool:
+    fn = t["function"]
+
+    return Tool(
+        name=fn["name"],
+        description=fn.get("description", ""),
+        parameters=fn["parameters"],
+    )
+
+
+def normalize_tools(tools):
+    if not tools:
+        return []
+
+    normalized = []
+
+    for t in tools:
+        if hasattr(t, "name"):
+            normalized.append(t)
+        elif isinstance(t, dict):
+            normalized.append(dict_to_tool(t))
+        else:
+            raise TypeError(f"Unsupported tool type: {type(t)}")
+
+    return normalized

sourcebot/llm/core/tool_delta_aggregator.py

@@ -0,0 +1,38 @@
+# sourcebot/llm/core/tool_delta_aggregator.py
+
+class ToolCallAggregator:
+
+    def __init__(self):
+        self.calls = {}
+
+    def apply_delta(self, delta_tool_calls):
+        """
+        delta_tool_calls: OpenAI chunk delta.tool_calls
+        """
+
+        for tc in delta_tool_calls:
+            idx = tc.index
+
+            if idx not in self.calls:
+                self.calls[idx] = {
+                    "id": tc.id,
+                    "name": tc.function.name,
+                    "arguments": "",
+                }
+
+            if tc.function.arguments:
+                self.calls[idx]["arguments"] += tc.function.arguments
+
+    def build(self):
+        from sourcebot.llm.core.message import ToolCall
+
+        result = []
+        for c in self.calls.values():
+            result.append(
+                ToolCall(
+                    id=c["id"],
+                    name=c["name"],
+                    arguments=c["arguments"],
+                )
+            )
+        return result

sourcebot/llm/llm_client_factory.py

@@ -0,0 +1,13 @@
+# sourcebot/llm/llm_client_factory.py
+from sourcebot.llm.openai import OpenAILLMClient
+from sourcebot.llm.anthropic import AnthropicLLMClient
+
+class LLMClientFactory:
+    @staticmethod
+    def create_client(config_manager, provider_name: str, model_name: str = None):
+        """Create the corresponding client based on the provider."""
+
+        if provider_name in ["anthropic", "claude"]:
+            return AnthropicLLMClient(config_manager, provider_name, model_name)
+        else:
+            return OpenAILLMClient(config_manager, provider_name, model_name)

sourcebot/llm/openai/__init__.py

@@ -0,0 +1,2 @@
+from sourcebot.llm.openai.openai_llm_client import OpenAILLMClient
+__all__ = ["OpenAILLMClient"]

sourcebot/llm/openai/adapter.py

@@ -0,0 +1,27 @@
+# sourcebot/llm/openai/adapter.py
+
+from sourcebot.llm.core.adapter import BaseAdapter
+from sourcebot.llm.core.response import LLMResponse, ToolCall
+
+
+class OpenAIAdapter(BaseAdapter):
+
+    def from_response(self, response) -> LLMResponse:
+        msg = response.choices[0].message
+
+        tool_calls = []
+        for tc in msg.tool_calls or []:
+            tool_calls.append(
+                ToolCall(
+                    id=tc.id,
+                    name=tc.function.name,
+                    arguments=tc.function.arguments,
+                )
+            )
+
+        return LLMResponse(
+            content=msg.content,
+            tool_calls=tool_calls,
+            finish_reason=response.choices[0].finish_reason,
+            raw=response,
+        )

sourcebot/llm/openai/converter.py

@@ -0,0 +1,53 @@
+# sourcebot/llm/openai/converter.py
+
+from sourcebot.llm.core.message import Message, ToolCall, ToolResult
+
+
+def to_openai_messages(messages: list[Message]):
+    result = []
+
+    for msg in messages:
+        if msg.role == "tool":
+            # tool result
+            for tr in msg.tool_results:
+                result.append({
+                    "role": "tool",
+                    "tool_call_id": tr.tool_call_id,
+                    "content": tr.content,
+                })
+            continue
+
+        m = {
+            "role": msg.role,
+            "content": msg.content,
+        }
+
+        if msg.tool_calls:
+            m["tool_calls"] = [
+                {
+                    "id": tc.id,
+                    "type": "function",
+                    "function": {
+                        "name": tc.name,
+                        "arguments": tc.arguments,
+                    },
+                }
+                for tc in msg.tool_calls
+            ]
+
+        result.append(m)
+
+    return result
+
+def to_openai_tools(tools):
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": t.name,
+                "description": t.description,
+                "parameters": t.parameters,
+            },
+        }
+        for t in tools
+    ]

sourcebot/llm/openai/openai_llm_client.py

@@ -0,0 +1,47 @@
+# sourcebot/llm/openai/openai_llm_client.py
+from openai import AsyncOpenAI
+from sourcebot.llm.core.client import BaseLLMClient
+from .adapter import OpenAIAdapter
+from sourcebot.config import ConfigManager
+from sourcebot.llm.openai.converter import to_openai_messages, to_openai_tools
+from sourcebot.llm.core.tool_converter import normalize_tools
+class OpenAILLMClient(BaseLLMClient):
+
+    def __init__(self, config_manager, provider_name: str = "dashscope", model_name: str = "qwen3.5-plus"):
+        provider_config = config_manager.get_provider_config(provider_name)
+        self.client = AsyncOpenAI(
+            api_key = provider_config.api_key,
+            base_url = provider_config.api_base
+        )
+        self.temperature = provider_config.temperature
+        self.model = model_name
+        self.adapter = OpenAIAdapter()
+
+    async def complete(self, messages, tools = None):
+        # messages = normalize_messages(messages)
+        oai_msgs = to_openai_messages(messages)
+        tools = normalize_tools(tools)
+        oai_tools = to_openai_tools(tools) if tools else None
+        resp = await self.client.chat.completions.create(
+            model = self.model,
+            messages = oai_msgs,
+            temperature = self.temperature,
+            tools = oai_tools,
+        )
+        return self.adapter.from_response(resp)
+
+    async def stream(self, messages, tools=None):
+        stream = await self.client.chat.completions.create(
+            model = self.model,
+            messages = messages,
+            tools = tools,
+            stream = True,
+        )
+
+        async for chunk in stream:
+            delta = chunk.choices[0].delta
+
+            yield {
+                "content": delta.content or "",
+                "tool_calls": delta.tool_calls,
+            }

sourcebot/logging/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.logging.setup import setup_logging
+
+__all__ = ["setup_logging"]

sourcebot/logging/setup.py

@@ -0,0 +1,33 @@
+import logging
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+
+def setup_logging(level=logging.INFO, log_dir="runs/logs"):
+    Path(log_dir).mkdir(parents=True, exist_ok=True)
+
+    log_file = Path(log_dir) / "sourcebot.log"
+
+    formatter = logging.Formatter(
+        "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+        "%Y-%m-%d %H:%M:%S"
+    )
+
+    console = logging.StreamHandler()
+    console.setFormatter(formatter)
+
+    file_handler = RotatingFileHandler(
+        log_file,
+        maxBytes=10 * 1024 * 1024,
+        backupCount=5
+    )
+    file_handler.setFormatter(formatter)
+
+    logger = logging.getLogger()
+    logger.setLevel(level)
+
+    logger.addHandler(console)
+    logger.addHandler(file_handler)
+    # Third party
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)