x-agent-kit 0.2.0__py3-none-any.whl

x_agent_kit/__init__.py

@@ -0,0 +1,4 @@
+from x_agent_kit.agent import Agent
+from x_agent_kit.tools.base import tool
+from x_agent_kit.plan import Plan, PlanStep, PlanManager
+from x_agent_kit.conversation import ConversationManager

x_agent_kit/agent.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Any, Callable
+from loguru import logger
+from x_agent_kit.config import Config, load_config
+from x_agent_kit.i18n import t, set_locale
+from x_agent_kit.models import BrainResponse, Message
+from x_agent_kit.progress import ProgressRenderer
+from x_agent_kit.skills.loader import SkillLoader
+from x_agent_kit.tools.builtin import create_list_skills_tool, create_load_skill_tool, create_notify_tool, create_request_approval_tool, create_save_memory_tool, create_recall_memories_tool, create_search_memory_tool, create_clear_memory_tool, create_plan_tool, create_submit_plan_tool, create_get_plan_tool, create_execute_approved_steps_tool, create_update_step_tool, create_resubmit_step_tool
+from x_agent_kit.tools.registry import ToolRegistry
+
+def create_brain(config: Config):
+    provider_name = config.brain.provider
+    provider = config.providers.get(provider_name)
+    if provider is None:
+        raise ValueError(f"Provider '{provider_name}' not configured")
+    model = config.brain.model or provider.default_model
+    if provider.type == "api" and provider_name == "gemini":
+        from x_agent_kit.brain.gemini import GeminiBrain
+        return GeminiBrain(api_key=provider.resolve_api_key(), model=model)
+    elif provider.type == "api" and provider_name == "openai":
+        from x_agent_kit.brain.openai_brain import OpenAIBrain
+        return OpenAIBrain(api_key=provider.resolve_api_key(), model=model)
+    elif provider.type == "cli":
+        from x_agent_kit.brain.claude import ClaudeBrain
+        return ClaudeBrain()
+    else:
+        raise ValueError(f"Unknown provider type: {provider.type}")
+
+def create_channels(config: Config) -> dict[str, Any]:
+    channels = {}
+    raw = config.channels
+    default_name = raw.get("default", "cli") if isinstance(raw, dict) else "cli"
+    from x_agent_kit.channels.cli_channel import CLIChannel
+    channels["cli"] = CLIChannel()
+    if isinstance(raw, dict) and "feishu" in raw and isinstance(raw["feishu"], dict):
+        import os
+        fc = raw["feishu"]
+        app_id = os.environ.get(fc.get("app_id_env", ""), "")
+        app_secret = os.environ.get(fc.get("app_secret_env", ""), "")
+        chat_id = os.environ.get(fc.get("default_chat_id_env", ""), "")
+        if app_id and app_secret and chat_id:
+            from x_agent_kit.channels.feishu import FeishuChannel
+            channels["feishu"] = FeishuChannel(app_id, app_secret, chat_id)
+    channels["default"] = channels.get(default_name, channels["cli"])
+    return channels
+
+class Agent:
+    def __init__(self, config_dir: str = ".agent", stop_condition: Callable[[str, Any], bool] | None = None) -> None:
+        self._config = load_config(config_dir)
+        set_locale(self._config.locale)
+        self._stop_condition = stop_condition
+        self._brain = create_brain(self._config)
+        self._tools = ToolRegistry()
+        self._skills = SkillLoader(self._config.skills.paths)
+        self._channels = create_channels(self._config)
+        self._tools.register(create_load_skill_tool(self._skills))
+        self._tools.register(create_list_skills_tool(self._skills))
+        self._tools.register(create_notify_tool(self._channels))
+
+        self._memory = None
+        self._approval_queue = None
+        self._reply_mode = False
+        if self._config.memory.enabled:
+            from x_agent_kit.memory import Memory
+            from x_agent_kit.approval_queue import ApprovalQueue
+            self._memory = Memory(memory_dir=self._config.memory.dir)
+            self._approval_queue = ApprovalQueue(db_path=str(Path(self._config.memory.dir) / "memory.db"))
+            self._tools.register(create_save_memory_tool(self._memory))
+            self._tools.register(create_recall_memories_tool(self._memory))
+            self._tools.register(create_search_memory_tool(self._memory))
+            self._tools.register(create_clear_memory_tool(self._memory))
+
+            # Wire up feishu channel for async execution (WebSocket started in serve() only)
+            feishu = self._channels.get("feishu")
+            if feishu and hasattr(feishu, 'set_approval_queue'):
+                feishu.set_approval_queue(self._approval_queue)
+                feishu.set_tool_executor(lambda name, args: self._tools.execute(name, args))
+
+        self._tools.register(create_request_approval_tool(self._channels, self._approval_queue))
+
+        # Plan manager (requires memory enabled)
+        self._plan_manager = None
+        self._conversation = None
+        if self._config.memory.enabled:
+            from x_agent_kit.plan import PlanManager
+            from x_agent_kit.conversation import ConversationManager
+            plan_db = str(Path(self._config.memory.dir) / "plans.db") if self._config.memory.dir != ":memory:" else ":memory:"
+            self._plan_manager = PlanManager(db_path=plan_db)
+            self._conversation = ConversationManager()
+
+            tool_executor = lambda name, args: self._tools.execute(name, args)
+            self._tools.register(create_plan_tool(self._plan_manager))
+            self._tools.register(create_submit_plan_tool(self._plan_manager, self._channels))
+            self._tools.register(create_get_plan_tool(self._plan_manager))
+            self._tools.register(create_execute_approved_steps_tool(self._plan_manager, tool_executor, self._channels))
+            self._tools.register(create_update_step_tool(self._plan_manager))
+            self._tools.register(create_resubmit_step_tool(self._plan_manager, self._channels))
+
+            feishu = self._channels.get("feishu")
+            if feishu and hasattr(feishu, 'set_plan_manager'):
+                feishu.set_plan_manager(self._plan_manager)
+
+    def register_tools(self, tools: list) -> None:
+        for t in tools:
+            self._tools.register(t)
+
+    def run(self, task: str) -> str:
+        if self._memory is not None:
+            mem_summary = self._memory.summary()
+            task_with_memory = f"{mem_summary}\n\n{task}"
+        else:
+            task_with_memory = task
+        messages = [Message(role="user", content=task_with_memory)]
+        max_iter = self._config.agent.max_iterations
+        notified = False
+        notify_content = ""
+        loaded_skills = set()
+
+        reply_mode = getattr(self, "_reply_mode", False)
+        default_ch = self._channels.get("default")
+        renderer = ProgressRenderer(channel=default_ch, enabled=not reply_mode)
+
+        for i in range(max_iter):
+            logger.info(f"Agent iteration {i+1}/{max_iter}")
+            renderer.update_text(t("agent.thinking"))
+
+            response = self._brain.think(messages=messages, tools=self._tools.schemas())
+            if response.done or (response.text and not response.tool_calls):
+                final = notify_content or response.text or t("agent.complete")
+                renderer.finish(t("agent.complete_title"), final, "green")
+                return notify_content or response.text or ""
+
+            if response.tool_calls:
+                for call in response.tool_calls:
+                    if call.name == "notify":
+                        if notified:
+                            messages.append(Message(
+                                role="tool_result", content="Already sent.",
+                                tool_call_id=call.name,
+                            ))
+                            continue
+                        notified = True
+                        notify_content = call.arguments.get("message", "")
+                        renderer.update_text(notify_content)
+                        if not renderer._card:
+                            self._tools.execute(call.name, call.arguments)
+                        messages.append(Message(role="tool_result", content="OK", tool_call_id=call.name))
+                        continue
+
+                    if call.name == "request_approval":
+                        meta = self._tools.get_meta(call.name)
+                        label = meta.label if meta and meta.label else f"📋 {call.arguments.get('action', '')}"
+                        renderer.add_step(label)
+                        logger.info(f"Tool call: {call.name}({call.arguments})")
+                        result = self._tools.execute(call.name, call.arguments)
+                        renderer.complete_step(label)
+                        messages.append(Message(role="tool_result", content=str(result), tool_call_id=call.name))
+                        continue
+
+                    if call.name == "load_skill":
+                        skill_name = call.arguments.get("name", "")
+                        if skill_name in loaded_skills:
+                            logger.info(f"Skipping duplicate load_skill: {skill_name}")
+                            messages.append(Message(
+                                role="tool_result", content=f"Skill '{skill_name}' already loaded.",
+                                tool_call_id=call.name,
+                            ))
+                            continue
+                        loaded_skills.add(skill_name)
+
+                    meta = self._tools.get_meta(call.name)
+                    label = meta.label if meta and meta.label else f"🔧 {call.name}"
+                    if call.name == "load_skill":
+                        label = f"📚 {call.arguments.get('name', 'skill')}"
+                    renderer.add_step(label)
+
+                    logger.info(f"Tool call: {call.name}({call.arguments})")
+                    result = self._tools.execute(call.name, call.arguments)
+                    messages.append(Message(role="tool_result", content=str(result), tool_call_id=call.name))
+                    renderer.complete_step(label)
+
+                    if self._stop_condition and self._stop_condition(call.name, result):
+                        logger.info(f"Stop condition met after {call.name}")
+                        final = notify_content or t("agent.complete")
+                        renderer.finish(t("agent.complete_title"), final, "green")
+                        return response.text or ""
+
+            if response.text:
+                messages.append(Message(role="assistant", content=response.text))
+
+        renderer.warn(t("agent.max_iterations"))
+        return "Max iterations reached"
+
+    def serve(self, schedules: list | None = None) -> None:
+        """Start scheduled agent. If schedules not provided, reads from config."""
+        feishu = self._channels.get("feishu")
+
+        # Register message handler BEFORE starting WebSocket so it gets registered
+        if self._conversation and feishu and hasattr(feishu, 'set_message_handler'):
+            def on_message(chat_id: str, text: str, message_id: str = ""):
+                logger.info(f"Incoming message from {chat_id}: {text[:50]}...")
+                # Show "processing" reaction immediately
+                reaction_id = None
+                if message_id and hasattr(feishu, 'add_reaction'):
+                    reaction_id = feishu.add_reaction(message_id, "OnIt")
+                self._conversation.add_message("user", text, chat_id)
+                ctx = self._conversation.get_context(chat_id)
+                context_str = "\n".join(f"[{m['role']}] {m['content']}" for m in ctx[:-1]) if len(ctx) > 1 else ""
+                task = f"对话上下文:\n{context_str}\n\n用户消息: {text}" if context_str else text
+                # Run agent without streaming card (reply mode)
+                self._reply_mode = True
+                try:
+                    result = self.run(task)
+                finally:
+                    self._reply_mode = False
+                self._conversation.add_message("assistant", result, chat_id)
+                # Reply to original message
+                if message_id and hasattr(feishu, 'reply_text'):
+                    feishu.reply_text(message_id, result)
+                    # Replace "processing" reaction with "done"
+                    if reaction_id:
+                        feishu.remove_reaction(message_id, reaction_id)
+                    feishu.add_reaction(message_id, "DONE")
+                    logger.info(f"Replied to message {message_id[:20]}...")
+            feishu.set_message_handler(on_message)
+            logger.info("Feishu message handler registered for bidirectional comms")
+
+        # Start WebSocket AFTER handlers are registered
+        if feishu and hasattr(feishu, "_ensure_ws"):
+            feishu._ensure_ws()
+            logger.info("Feishu WebSocket started (card actions + message receive)")
+
+        from x_agent_kit.scheduler import Scheduler
+        sched = Scheduler()
+        items = schedules or self._config.schedules
+        for s in items:
+            cron_expr = s.cron if hasattr(s, 'cron') else s['cron']
+            task_str = s.task if hasattr(s, 'task') else s['task']
+            logger.info(f"Schedule: {cron_expr} -> {task_str[:50]}...")
+            sched.add(cron_expr, lambda t=task_str: self.run(t))
+        sched.start()

x_agent_kit/approval_queue.py

@@ -0,0 +1,60 @@
+"""Async approval queue — stores pending approvals and executes on button click."""
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from loguru import logger
+
+
+class ApprovalQueue:
+    """SQLite-backed pending approval queue."""
+
+    def __init__(self, db_path: str = ".agent/memory/memory.db") -> None:
+        self._db_path = db_path
+        self._conn = sqlite3.connect(db_path, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._init_db()
+
+    def _init_db(self) -> None:
+        self._conn.executescript("""
+            CREATE TABLE IF NOT EXISTS pending_approvals (
+                request_id TEXT PRIMARY KEY,
+                action TEXT NOT NULL,
+                details TEXT NOT NULL,
+                tool_name TEXT NOT NULL,
+                tool_args TEXT NOT NULL,
+                status TEXT DEFAULT 'pending',
+                created_at TEXT NOT NULL,
+                resolved_at TEXT
+            );
+        """)
+        self._conn.commit()
+
+    def add(self, request_id: str, action: str, details: str, tool_name: str, tool_args: dict) -> None:
+        self._conn.execute(
+            "INSERT OR REPLACE INTO pending_approvals (request_id, action, details, tool_name, tool_args, status, created_at) VALUES (?, ?, ?, ?, ?, 'pending', ?)",
+            (request_id, action, details, tool_name, json.dumps(tool_args, ensure_ascii=False), datetime.now().isoformat()),
+        )
+        self._conn.commit()
+        logger.info(f"Approval queued: {request_id} → {tool_name}")
+
+    def get(self, request_id: str) -> dict | None:
+        row = self._conn.execute("SELECT * FROM pending_approvals WHERE request_id = ?", (request_id,)).fetchone()
+        if not row:
+            return None
+        return dict(row)
+
+    def resolve(self, request_id: str, status: str) -> None:
+        self._conn.execute(
+            "UPDATE pending_approvals SET status = ?, resolved_at = ? WHERE request_id = ?",
+            (status, datetime.now().isoformat(), request_id),
+        )
+        self._conn.commit()
+
+    def pending_count(self) -> int:
+        row = self._conn.execute("SELECT COUNT(*) as c FROM pending_approvals WHERE status = 'pending'").fetchone()
+        return row["c"]

x_agent_kit/brain/base.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+from x_agent_kit.models import BrainResponse, Message
+
+class BaseBrain:
+    def think(self, messages: list[Message], tools: list[dict], system_prompt: str = "") -> BrainResponse:
+        raise NotImplementedError

x_agent_kit/brain/claude.py

@@ -0,0 +1,264 @@
+"""Claude Brain — uses claude CLI with session resume and streaming.
+
+Approach (inspired by OpenClaw):
+- First call: start new session with --session-id, stream-json output
+- Subsequent calls: --resume session, pipe new messages via stdin
+- Supports multi-turn conversation without re-sending full history
+- Uses local Claude auth (OAuth), no API key needed
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+import uuid
+from typing import Any
+
+from loguru import logger
+
+from x_agent_kit.brain.base import BaseBrain
+from x_agent_kit.models import BrainResponse, Message, ToolCall
+
+
+class ClaudeBrain(BaseBrain):
+    """Claude via CLI subprocess with session persistence."""
+
+    def __init__(self, timeout: int = 300, model: str = "") -> None:
+        self._timeout = timeout
+        self._model = model
+        self._session_id = str(uuid.uuid4())
+        self._first_call = True
+
+    def think(
+        self,
+        messages: list[Message],
+        tools: list[dict],
+        system_prompt: str = "",
+    ) -> BrainResponse:
+        if self._first_call:
+            return self._first_think(messages, tools, system_prompt)
+        else:
+            return self._resume_think(messages, tools)
+
+    def _first_think(
+        self, messages: list[Message], tools: list[dict], system_prompt: str
+    ) -> BrainResponse:
+        """First call: start a new session."""
+        prompt = self._build_prompt(messages, tools)
+
+        cmd = [
+            "claude", "-p",
+            "--output-format", "json",
+            "--session-id", self._session_id,
+            "--permission-mode", "bypassPermissions",
+        ]
+        if self._model:
+            cmd.extend(["--model", self._model])
+        if system_prompt:
+            cmd.extend(["--system-prompt", system_prompt])
+
+        cmd.append(prompt)
+
+        result = self._run(cmd)
+        self._first_call = False
+        return result
+
+    def _resume_think(
+        self, messages: list[Message], tools: list[dict]
+    ) -> BrainResponse:
+        """Subsequent calls: resume existing session."""
+        # Build only the new messages (tool results) as the prompt
+        new_content = self._build_resume_prompt(messages, tools)
+
+        cmd = [
+            "claude", "-p",
+            "--output-format", "json",
+            "--resume", self._session_id,
+            "--permission-mode", "bypassPermissions",
+        ]
+        cmd.append(new_content)
+
+        return self._run(cmd)
+
+    def _run(self, cmd: list[str]) -> BrainResponse:
+        """Execute claude CLI and parse response."""
+        logger.debug(f"Claude CLI call: session={self._session_id[:8]}...")
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=self._timeout,
+            )
+            if result.returncode != 0:
+                stderr = result.stderr[:500] if result.stderr else ""
+                logger.error(f"Claude CLI error: {stderr}")
+                return BrainResponse(text=f"Claude CLI error: {stderr}")
+
+            raw = result.stdout.strip()
+            logger.debug(f"Claude CLI raw output ({len(raw)} chars): {raw[:300]}...")
+            return self._parse_output(raw)
+
+        except FileNotFoundError:
+            logger.error("Claude CLI not found in PATH")
+            return BrainResponse(text="Claude CLI not found")
+        except subprocess.TimeoutExpired:
+            logger.error(f"Claude CLI timeout ({self._timeout}s)")
+            return BrainResponse(text=f"Claude CLI timeout after {self._timeout}s")
+
+    def _build_prompt(
+        self, messages: list[Message], tools: list[dict]
+    ) -> str:
+        """Build the initial prompt with tool definitions."""
+        parts = []
+
+        if tools:
+            # Compact tool descriptions (not full JSON schema)
+            tool_list = []
+            for t in tools:
+                func = t.get("function", {})
+                name = func.get("name", "")
+                desc = func.get("description", "")
+                params = func.get("parameters", {}).get("properties", {})
+                param_str = ", ".join(
+                    f"{k}: {v.get('type', 'string')}"
+                    for k, v in params.items()
+                )
+                tool_list.append(f"- {name}({param_str}) — {desc}")
+
+            parts.append("You have these tools available:\n" + "\n".join(tool_list))
+            parts.append(
+                "\nTo call a tool, respond with ONLY a JSON object like this:\n"
+                '{"tool_calls": [{"name": "tool_name", "arguments": {"param": "value"}}]}\n'
+                "To give a final answer, respond with:\n"
+                '{"text": "your answer", "done": true}\n'
+                "Always respond with valid JSON. No other text."
+            )
+
+        for msg in messages:
+            if msg.role == "user":
+                parts.append(f"\nUser: {msg.content}")
+            elif msg.role == "tool_result":
+                parts.append(f"\nTool result ({msg.tool_call_id}): {msg.content}")
+            elif msg.role == "assistant":
+                parts.append(f"\nAssistant: {msg.content}")
+
+        return "\n".join(parts)
+
+    def _build_resume_prompt(
+        self, messages: list[Message], tools: list[dict]
+    ) -> str:
+        """Build prompt for resume — only include recent tool results."""
+        parts = []
+        # Find the last assistant message and only include messages after it
+        last_assistant_idx = -1
+        for i, msg in enumerate(messages):
+            if msg.role == "assistant":
+                last_assistant_idx = i
+
+        recent = messages[last_assistant_idx + 1:] if last_assistant_idx >= 0 else messages[-3:]
+
+        for msg in recent:
+            if msg.role == "tool_result":
+                parts.append(f"Tool result ({msg.tool_call_id}): {msg.content}")
+            elif msg.role == "user":
+                parts.append(msg.content)
+
+        if not parts:
+            parts.append("Continue with the next step.")
+
+        parts.append(
+            "\nRespond with JSON: "
+            '{"tool_calls": [...]} or {"text": "...", "done": true}'
+        )
+
+        return "\n".join(parts)
+
+    def _parse_output(self, output: str) -> BrainResponse:
+        """Parse claude CLI JSON output."""
+        if not output:
+            return BrainResponse(text="")
+
+        try:
+            data = json.loads(output)
+
+            # claude --output-format json wraps in {"type":"result","result":"..."}
+            if isinstance(data, dict) and "result" in data:
+                inner = data["result"]
+                if isinstance(inner, str):
+                    # Try to parse the inner result as JSON (tool calls)
+                    # Handle mixed text+JSON: "Some text\n\n{\"tool_calls\": [...]}"
+                    result = self._parse_inner(inner)
+                    if result.text and not result.tool_calls:
+                        # Maybe JSON is embedded in text, try to extract it
+                        extracted = self._extract_json_from_text(inner)
+                        if extracted.tool_calls:
+                            return extracted
+                    return result
+                return BrainResponse(text=str(inner))
+
+            # Direct JSON response
+            return self._parse_inner(output)
+
+        except json.JSONDecodeError:
+            # Try to extract JSON from mixed text
+            return self._extract_json_from_text(output)
+
+    def _parse_inner(self, text: str) -> BrainResponse:
+        """Parse the inner content which may contain tool calls."""
+        try:
+            data = json.loads(text) if isinstance(text, str) else text
+        except (json.JSONDecodeError, TypeError):
+            return BrainResponse(text=str(text))
+
+        if isinstance(data, dict):
+            tool_calls = None
+            if data.get("tool_calls"):
+                tool_calls = [
+                    ToolCall(
+                        id=tc.get("name", str(i)),
+                        name=tc["name"],
+                        arguments=tc.get("arguments", {}),
+                    )
+                    for i, tc in enumerate(data["tool_calls"])
+                ]
+            return BrainResponse(
+                text=data.get("text"),
+                tool_calls=tool_calls,
+                done=data.get("done", False),
+            )
+
+        return BrainResponse(text=str(data))
+
+    def _extract_json_from_text(self, text: str) -> BrainResponse:
+        """Try to find JSON in text that may have extra content."""
+        import re
+        # Find the start of a JSON object containing tool_calls
+        idx = text.find('{"tool_calls"')
+        if idx == -1:
+            idx = text.find('{ "tool_calls"')
+        if idx >= 0:
+            # Extract from { to the end, try parsing progressively shorter substrings
+            candidate = text[idx:]
+            for end in range(len(candidate), 0, -1):
+                try:
+                    data = json.loads(candidate[:end])
+                    return self._parse_inner(candidate[:end])
+                except (json.JSONDecodeError, ValueError):
+                    continue
+
+        # Fallback: regex for any JSON with tool_calls
+        match = re.search(r'\{.*"tool_calls".*\}', text, re.DOTALL)
+        if match:
+            try:
+                return self._parse_inner(match.group())
+            except Exception:
+                pass
+
+        match = re.search(r'\{[^{}]*"text"[^{}]*\}', text, re.DOTALL)
+        if match:
+            try:
+                return self._parse_inner(match.group())
+            except Exception:
+                pass
+
+        return BrainResponse(text=text)

x_agent_kit/brain/gemini.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+from typing import Any
+from google import genai
+from google.genai import types
+from loguru import logger
+from x_agent_kit.brain.base import BaseBrain
+from x_agent_kit.models import BrainResponse, Message, ToolCall
+
+class GeminiBrain(BaseBrain):
+    def __init__(self, api_key: str, model: str = "gemini-2.5-flash") -> None:
+        self._client = genai.Client(api_key=api_key)
+        self._model = model
+
+    def think(self, messages: list[Message], tools: list[dict], system_prompt: str = "") -> BrainResponse:
+        contents = self._build_contents(messages)
+        gemini_tools = self._convert_tools(tools) if tools else None
+        config = types.GenerateContentConfig()
+        if system_prompt:
+            config.system_instruction = system_prompt
+        if gemini_tools:
+            config.tools = gemini_tools
+        response = self._client.models.generate_content(model=self._model, contents=contents, config=config)
+        return self._parse_response(response)
+
+    def _build_contents(self, messages: list[Message]) -> list[dict[str, Any]]:
+        contents = []
+        for msg in messages:
+            if msg.role == "user":
+                contents.append({"role": "user", "parts": [{"text": msg.content}]})
+            elif msg.role == "assistant":
+                contents.append({"role": "model", "parts": [{"text": msg.content}]})
+            elif msg.role == "tool_result":
+                contents.append({"role": "user", "parts": [{"function_response": {"name": msg.tool_call_id or "unknown", "response": {"result": msg.content}}}]})
+        return contents
+
+    def _convert_tools(self, tools: list[dict]) -> list[types.Tool]:
+        declarations = []
+        for t in tools:
+            func = t.get("function", {})
+            declarations.append(types.FunctionDeclaration(name=func.get("name", ""), description=func.get("description", ""), parameters=func.get("parameters", {})))
+        return [types.Tool(function_declarations=declarations)]
+
+    def _parse_response(self, response) -> BrainResponse:
+        if not response.candidates:
+            return BrainResponse(text="")
+        content = response.candidates[0].content
+        parts = content.parts if content and content.parts else []
+        text_parts = []
+        tool_calls = []
+        for part in parts:
+            if part.function_call:
+                fc = part.function_call
+                tool_calls.append(ToolCall(id=fc.name, name=fc.name, arguments=dict(fc.args) if fc.args else {}))
+            elif part.text:
+                text_parts.append(part.text)
+        return BrainResponse(text="".join(text_parts) if text_parts else None, tool_calls=tool_calls if tool_calls else None)

x_agent_kit/brain/openai_brain.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+import json
+import openai
+from loguru import logger
+from x_agent_kit.brain.base import BaseBrain
+from x_agent_kit.models import BrainResponse, Message, ToolCall
+
+class OpenAIBrain(BaseBrain):
+    def __init__(self, api_key: str, model: str = "gpt-4o") -> None:
+        self._client = openai.OpenAI(api_key=api_key)
+        self._model = model
+
+    def think(self, messages: list[Message], tools: list[dict], system_prompt: str = "") -> BrainResponse:
+        oai_messages = self._build_messages(messages, system_prompt)
+        kwargs = {"model": self._model, "messages": oai_messages}
+        if tools:
+            kwargs["tools"] = tools
+        response = self._client.chat.completions.create(**kwargs)
+        return self._parse_response(response)
+
+    def _build_messages(self, messages: list[Message], system_prompt: str) -> list[dict]:
+        oai = []
+        if system_prompt:
+            oai.append({"role": "system", "content": system_prompt})
+        for msg in messages:
+            if msg.role == "tool_result":
+                oai.append({"role": "tool", "content": msg.content, "tool_call_id": msg.tool_call_id or ""})
+            else:
+                oai.append({"role": msg.role, "content": msg.content})
+        return oai
+
+    def _parse_response(self, response) -> BrainResponse:
+        choice = response.choices[0]
+        msg = choice.message
+        tool_calls = None
+        if msg.tool_calls:
+            tool_calls = [ToolCall(id=tc.id, name=tc.function.name, arguments=json.loads(tc.function.arguments)) for tc in msg.tool_calls]
+        return BrainResponse(text=msg.content, tool_calls=tool_calls)