refactor(agent): decouple agent from Anthropic SDK dependency

Replace direct anthropic.AsyncAnthropic usage with a provider-agnostic
BaseLLMClient interface. This architectural change removes the tight
coupling between the agent loop and Anthropic's SDK, allowing the
system to work with different LLM providers through a unified API.

The agent loop now receives an abstract client instead of a concrete
implementation, enabling configuration-driven provider selection at
runtime without code changes.

.env.example

@@ -1,5 +1,10 @@
-# Anthropic API Key (required)
-ANTHROPIC_API_KEY=your-api-key-here
+# API Configuration
+# Option 1: Anthropic API (default)
+# ANTHROPIC_API_KEY=your-api-key-here
+
+# Option 2: OpenAI-compatible API
+OPENAI_API_KEY=your-api-key-here
+OPENAI_BASE_URL=https://api.openai.com/v1
 
 # Environment overrides (optional)
 # DOCKER_CONTAINER=1

agent/agent_loop.py

@@ -4,10 +4,10 @@ from __future__ import annotations
 
 from pathlib import Path
 
-import anthropic
 from loguru import logger
 
 from agent.context_manager import ContextManager
+from agent.llm_client import BaseLLMClient, create_client
 from tools.bash_tool import run_bash
 from tools.file_tools import run_read, run_write, run_edit
 from tools.memory_tools import run_remember, run_recall, run_journal
@@ -153,7 +153,7 @@ class AgentLoop:
 
     def __init__(
         self,
-        client: anthropic.AsyncAnthropic,
+        client: BaseLLMClient,
         system_prompt: str,
         model: str = "claude-sonnet-4-5-20250929",
         max_tokens: int = 8000,
@@ -190,14 +190,14 @@ class AgentLoop:
 
             # Call LLM
             try:
-                response = await self.client.messages.create(
+                response = await self.client.create_message(
                     model=self.model,
-                    system=self.system_prompt,
+                    system_prompt=self.system_prompt,
                     messages=messages,
                     tools=all_tools,
                     max_tokens=self.max_tokens,
                 )
-            except anthropic.APIError as e:
+            except Exception as e:
                 logger.error(f"API error: {e}")
                 messages.append({
                     "role": "assistant",
@@ -206,24 +206,23 @@ class AgentLoop:
                 break
 
             # Extract text and tool calls
-            tool_calls = []
-            for block in response.content:
-                if hasattr(block, "text") and block.text:
-                    logger.info(f"Assistant: {block.text[:200]}")
-                if block.type == "tool_use":
-                    tool_calls.append(block)
+            for block in response.content_blocks:
+                if isinstance(block, dict) and block.get("type") == "text":
+                    text = block.get("text", "")
+                    if text:
+                        logger.info(f"Assistant: {text[:200]}")
 
             # If no tool calls, conversation turn is done
             if response.stop_reason != "tool_use":
                 messages.append({
                     "role": "assistant",
-                    "content": self._serialize_content(response.content),
+                    "content": response.content_blocks,
                 })
                 break
 
             # Execute tools and collect results
             results = []
-            for tc in tool_calls:
+            for tc in response.tool_calls:
                 logger.info(f"Tool: {tc.name}({_preview_args(tc.input)})")
                 output = await self._execute_tool(tc.name, tc.input)
                 logger.debug(f"Result: {output[:200]}")
@@ -236,7 +235,7 @@ class AgentLoop:
             # Append assistant message and tool results
             messages.append({
                 "role": "assistant",
-                "content": self._serialize_content(response.content),
+                "content": response.content_blocks,
             })
             messages.append({
                 "role": "user",
@@ -292,19 +291,6 @@ class AgentLoop:
             logger.error(f"Tool execution error ({name}): {e}")
             return f"Error executing {name}: {e}"
 
-    @staticmethod
-    def _serialize_content(content) -> list[dict]:
-        """Convert Anthropic SDK content blocks to serializable dicts."""
-        result = []
-        for block in content:
-            if hasattr(block, "model_dump"):
-                result.append(block.model_dump())
-            elif isinstance(block, dict):
-                result.append(block)
-            else:
-                result.append({"type": "text", "text": str(block)})
-        return result
-
 
 def _preview_args(args: dict, max_len: int = 100) -> str:
     """Create a short preview of tool arguments for logging."""

agent/llm_client.py

@@ -0,0 +1,264 @@
+"""LLM Client abstraction layer - supports Anthropic and OpenAI-compatible APIs."""
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from typing import Any
+
+from loguru import logger
+
+
+class BaseLLMClient(ABC):
+    """Abstract base class for LLM clients."""
+
+    @abstractmethod
+    async def create_message(
+        self,
+        model: str,
+        system_prompt: str,
+        messages: list[dict],
+        tools: list[dict],
+        max_tokens: int,
+    ) -> LLMResponse:
+        """Create a message and return standardized response."""
+        pass
+
+
+class LLMResponse:
+    """Standardized LLM response."""
+
+    def __init__(
+        self,
+        content_blocks: list[dict],
+        stop_reason: str,
+        tool_calls: list[ToolCall] | None = None,
+    ):
+        self.content_blocks = content_blocks
+        self.stop_reason = stop_reason
+        self.tool_calls = tool_calls or []
+
+
+class ToolCall:
+    """Standardized tool call."""
+
+    def __init__(self, id: str, name: str, input: dict):
+        self.id = id
+        self.name = name
+        self.input = input
+
+
+class AnthropicClient(BaseLLMClient):
+    """Anthropic API client."""
+
+    def __init__(self):
+        import anthropic
+        self._client = anthropic.AsyncAnthropic()
+
+    async def create_message(
+        self,
+        model: str,
+        system_prompt: str,
+        messages: list[dict],
+        tools: list[dict],
+        max_tokens: int,
+    ) -> LLMResponse:
+        """Create message using Anthropic API."""
+        response = await self._client.messages.create(
+            model=model,
+            system=system_prompt,
+            messages=messages,
+            tools=tools,
+            max_tokens=max_tokens,
+        )
+
+        # Extract content blocks
+        content_blocks = []
+        tool_calls = []
+        for block in response.content:
+            if hasattr(block, "model_dump"):
+                content_blocks.append(block.model_dump())
+            elif isinstance(block, dict):
+                content_blocks.append(block)
+            else:
+                content_blocks.append({"type": "text", "text": str(block)})
+
+            if hasattr(block, "type") and block.type == "tool_use":
+                tool_calls.append(ToolCall(
+                    id=block.id,
+                    name=block.name,
+                    input=block.input,
+                ))
+
+        return LLMResponse(
+            content_blocks=content_blocks,
+            stop_reason=response.stop_reason,
+            tool_calls=tool_calls,
+        )
+
+
+class OpenAIClient(BaseLLMClient):
+    """OpenAI-compatible API client."""
+
+    def __init__(self, base_url: str | None = None):
+        from openai import AsyncOpenAI
+        self._client = AsyncOpenAI(
+            api_key=os.environ.get("OPENAI_API_KEY"),
+            base_url=base_url or os.environ.get("OPENAI_BASE_URL"),
+        )
+
+    async def create_message(
+        self,
+        model: str,
+        system_prompt: str,
+        messages: list[dict],
+        tools: list[dict],
+        max_tokens: int,
+    ) -> LLMResponse:
+        """Create message using OpenAI-compatible API."""
+        # Convert Anthropic-style tools to OpenAI format
+        openai_tools = self._convert_tools(tools)
+
+        # Build message list with system prompt
+        all_messages = [{"role": "system", "content": system_prompt}]
+
+        # Convert messages
+        for msg in messages:
+            converted = self._convert_message(msg)
+            if converted:
+                all_messages.append(converted)
+
+        response = await self._client.chat.completions.create(
+            model=model,
+            messages=all_messages,
+            tools=openai_tools if openai_tools else None,
+            max_tokens=max_tokens,
+        )
+
+        choice = response.choices[0]
+
+        # Extract content
+        content_blocks = []
+        tool_calls = []
+
+        if choice.message.content:
+            content_blocks.append({"type": "text", "text": choice.message.content})
+
+        if choice.message.tool_calls:
+            for tc in choice.message.tool_calls:
+                import json
+                tool_calls.append(ToolCall(
+                    id=tc.id,
+                    name=tc.function.name,
+                    input=json.loads(tc.function.arguments) if tc.function.arguments else {},
+                ))
+                content_blocks.append({
+                    "type": "tool_use",
+                    "id": tc.id,
+                    "name": tc.function.name,
+                    "input": json.loads(tc.function.arguments) if tc.function.arguments else {},
+                })
+
+        stop_reason = "tool_use" if tool_calls else "end_turn"
+        if choice.finish_reason == "length":
+            stop_reason = "max_tokens"
+
+        return LLMResponse(
+            content_blocks=content_blocks,
+            stop_reason=stop_reason,
+            tool_calls=tool_calls,
+        )
+
+    def _convert_tools(self, anthropic_tools: list[dict]) -> list[dict]:
+        """Convert Anthropic-style tools to OpenAI format."""
+        openai_tools = []
+        for tool in anthropic_tools:
+            openai_tools.append({
+                "type": "function",
+                "function": {
+                    "name": tool["name"],
+                    "description": tool.get("description", ""),
+                    "parameters": tool.get("input_schema", {}),
+                }
+            })
+        return openai_tools
+
+    def _convert_message(self, msg: dict) -> dict | None:
+        """Convert Anthropic-style message to OpenAI format."""
+        role = msg.get("role")
+        content = msg.get("content")
+
+        if role == "user":
+            if isinstance(content, str):
+                return {"role": "user", "content": content}
+            elif isinstance(content, list):
+                # Handle tool results
+                texts = []
+                tool_results = []
+                for block in content:
+                    if isinstance(block, dict):
+                        if block.get("type") == "tool_result":
+                            tool_results.append(block)
+                        elif block.get("type") == "text":
+                            texts.append(block.get("text", ""))
+
+                if tool_results:
+                    # Convert tool results to OpenAI format
+                    result_msg = {"role": "tool", "content": ""}
+                    for tr in tool_results:
+                        result_msg["tool_call_id"] = tr.get("tool_use_id", "")
+                        result_msg["content"] = tr.get("content", "")
+                    return result_msg
+                elif texts:
+                    return {"role": "user", "content": "\n".join(texts)}
+
+        elif role == "assistant":
+            if isinstance(content, str):
+                return {"role": "assistant", "content": content}
+            elif isinstance(content, list):
+                texts = []
+                tool_uses = []
+                for block in content:
+                    if isinstance(block, dict):
+                        if block.get("type") == "text":
+                            texts.append(block.get("text", ""))
+                        elif block.get("type") == "tool_use":
+                            tool_uses.append(block)
+
+                result = {"role": "assistant"}
+                if texts:
+                    result["content"] = "\n".join(texts)
+                if tool_uses:
+                    import json
+                    result["tool_calls"] = [
+                        {
+                            "id": tu.get("id", ""),
+                            "type": "function",
+                            "function": {
+                                "name": tu.get("name", ""),
+                                "arguments": json.dumps(tu.get("input", {})),
+                            }
+                        }
+                        for tu in tool_uses
+                    ]
+                return result
+
+        return None
+
+
+def create_client(provider: str = "anthropic", base_url: str | None = None) -> BaseLLMClient:
+    """Factory function to create LLM client based on provider.
+
+    Args:
+        provider: "anthropic" or "openai"
+        base_url: Base URL for OpenAI-compatible API (optional)
+
+    Returns:
+        LLM client instance.
+    """
+    if provider == "openai":
+        logger.info("Using OpenAI-compatible API")
+        return OpenAIClient(base_url=base_url)
+    else:
+        logger.info("Using Anthropic API")
+        return AnthropicClient()

config.yaml

@@ -1,6 +1,8 @@
 # Agent配置
 agent:
-  model: "claude-sonnet-4-5-20250929"
+  # API provider: "anthropic" or "openai"
+  provider: "openai"
+  model: "z-ai/glm-4.5-air:free"
   max_tokens: 8000
   temperature: 0.7
 

main.py

@@ -10,13 +10,13 @@ import sys
 from datetime import datetime
 from pathlib import Path
 
-import anthropic
 import yaml
 from dotenv import load_dotenv
 from loguru import logger
 
 from agent.agent_loop import AgentLoop
 from agent.context_manager import ContextManager
+from agent.llm_client import BaseLLMClient, create_client
 from agent.message_history import MessageHistory
 from agent.system_prompt import build_system_prompt
 from browser.client import BrowserClient
@@ -52,7 +52,7 @@ class DigitalLife:
         self.log_path = env.get_log_path()
 
         # Components (initialized in _initialize)
-        self.client: anthropic.AsyncAnthropic | None = None
+        self.client: BaseLLMClient | None = None
         self.memory_manager: MemoryManager | None = None
         self.plugin_manager: PluginManager | None = None
         self.browser_client: BrowserClient | None = None
@@ -83,11 +83,12 @@ class DigitalLife:
         logger.info(f"Environment: {env.env.value}")
         logger.info(f"Data directory: {env.data_dir}")
 
-        # Anthropic client
-        self.client = anthropic.AsyncAnthropic()
+        # LLM client
+        agent_config = self.config.get("agent", {})
+        provider = agent_config.get("provider", "anthropic")
+        self.client = create_client(provider)
 
         # Model config
-        agent_config = self.config.get("agent", {})
         model = agent_config.get("model", "claude-sonnet-4-5-20250929")
         max_tokens = agent_config.get("max_tokens", 8000)
 

requirements.txt

@@ -1,5 +1,6 @@
 # Core
 anthropic>=0.40.0
+openai>=1.0.0
 pyyaml>=6.0
 python-dotenv>=1.0.0