wuwei 0.1.0__py3-none-any.whl

wuwei/__init__.py

@@ -0,0 +1,30 @@
+from wuwei.agent import Agent, AgentSession, BaseAgent, BaseSessionAgent, PlanAgent
+from wuwei.llm import FunctionCall, LLMGateway, LLMResponse, LLMResponseChunk, Message, ToolCall
+from wuwei.memory import Context
+from wuwei.planning import Planner, Task, TaskList
+from wuwei.runtime import AgentRunner, PlannerExecutorRunner
+from wuwei.tools import Tool, ToolExecutor, ToolParameters, ToolRegistry
+
+__all__ = [
+    "Agent",
+    "AgentRunner",
+    "AgentSession",
+    "BaseAgent",
+    "BaseSessionAgent",
+    "Context",
+    "FunctionCall",
+    "LLMGateway",
+    "LLMResponse",
+    "LLMResponseChunk",
+    "Message",
+    "PlanAgent",
+    "Planner",
+    "PlannerExecutorRunner",
+    "Task",
+    "TaskList",
+    "Tool",
+    "ToolCall",
+    "ToolExecutor",
+    "ToolParameters",
+    "ToolRegistry",
+]

wuwei/agent/__init__.py

@@ -0,0 +1,15 @@
+from wuwei.agent.agent import Agent
+from wuwei.agent.base import BaseAgent, BaseSessionAgent
+from wuwei.agent.plan_agent import PlanAgent
+from wuwei.agent.session import AgentSession
+from wuwei.runtime import AgentRunner, PlannerExecutorRunner
+
+__all__ = [
+    "Agent",
+    "AgentRunner",
+    "AgentSession",
+    "BaseAgent",
+    "BaseSessionAgent",
+    "PlanAgent",
+    "PlannerExecutorRunner",
+]

wuwei/agent/agent.py

@@ -0,0 +1,47 @@
+from typing import Any
+
+from wuwei.agent.base import BaseSessionAgent
+from wuwei.agent.session import AgentSession
+from wuwei.llm import LLMGateway
+from wuwei.runtime import AgentRunner
+from wuwei.tools import Tool, ToolRegistry
+
+
+class Agent(BaseSessionAgent):
+    """普通单 agent 门面对象。"""
+
+    def __init__(
+        self,
+        llm: LLMGateway,
+        tools: list[Tool] | ToolRegistry | None = None,
+        default_system_prompt: str = "你是一个有用的助手",
+        default_max_steps: int = 10,
+        default_parallel_tool_calls: bool = False,
+    ) -> None:
+        super().__init__(
+            llm=llm,
+            tools=tools,
+            default_system_prompt=default_system_prompt,
+            default_max_steps=default_max_steps,
+            default_parallel_tool_calls=default_parallel_tool_calls,
+        )
+
+    def create_runner(self, session: AgentSession) -> AgentRunner:
+        """为普通 agent 会话创建执行器。"""
+        return AgentRunner(
+            llm=self.llm,
+            tools=self.tool_registry.list_tools(),
+            tool_executor=self.tool_executor,
+            session=session,
+        )
+
+    async def run(
+        self,
+        user_input: str,
+        session: AgentSession | None = None,
+        stream: bool = False,
+    ) -> Any:
+        """运行一次普通 agent。"""
+        current_session = session or self.create_or_get_session()
+        runner = self.create_runner(current_session)
+        return await runner.run(user_input, stream=stream)

wuwei/agent/base.py

@@ -0,0 +1,93 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from uuid import uuid4
+
+from wuwei.agent.session import AgentSession
+from wuwei.llm import LLMGateway
+from wuwei.tools import Tool, ToolExecutor, ToolRegistry
+
+
+class BaseAgent(ABC):
+    """所有 agent 的最小抽象基类。"""
+
+    @abstractmethod
+    async def run(self, user_input: str, session: Any | None = None, stream: bool = False) -> Any:
+        """运行一次 agent。"""
+
+
+class BaseSessionAgent(BaseAgent):
+    """
+    带会话能力的公共基类。
+
+    这个类负责收敛 Agent 和 PlanAgent 里重复的公共逻辑：
+    - llm / tools / tool_executor 初始化
+    - 默认 system_prompt / max_steps / parallel_tool_calls
+    - session 的创建与复用
+    """
+
+    def __init__(
+        self,
+        llm: LLMGateway,
+        tools: list[Tool] | ToolRegistry | None = None,
+        default_system_prompt: str = "你是一个有用的助手",
+        default_max_steps: int = 10,
+        default_parallel_tool_calls: bool = False,
+    ) -> None:
+        """初始化公共依赖和默认会话配置。"""
+        self.llm = llm
+        self.default_system_prompt = default_system_prompt
+        self.default_max_steps = default_max_steps
+        self.default_parallel_tool_calls = default_parallel_tool_calls
+
+        if isinstance(tools, ToolRegistry):
+            self.tool_registry = tools
+        else:
+            self.tool_registry = ToolRegistry()
+            for tool in tools or []:
+                self.tool_registry.register(tool)
+
+        self.tool_executor = ToolExecutor(self.tool_registry)
+        self._sessions: dict[str, AgentSession] = {}
+
+    def create_session(
+        self,
+        session_id: str | None = None,
+        system_prompt: str | None = None,
+        max_steps: int | None = None,
+        parallel_tool_calls: bool | None = None,
+    ) -> AgentSession:
+        """创建一个新会话，并写入默认 system prompt。"""
+        session = AgentSession(
+            session_id=session_id or uuid4().hex,
+            system_prompt=system_prompt or self.default_system_prompt,
+            max_steps=max_steps if max_steps is not None else self.default_max_steps,
+            parallel_tool_calls=(
+                parallel_tool_calls
+                if parallel_tool_calls is not None
+                else self.default_parallel_tool_calls
+            ),
+        )
+        self._sessions[session.session_id] = session
+        return session
+
+    def create_or_get_session(
+        self,
+        session_id: str | None = None,
+        system_prompt: str | None = None,
+        max_steps: int | None = None,
+        parallel_tool_calls: bool | None = None,
+    ) -> AgentSession:
+        """按 session_id 复用会话；如果不存在则新建。"""
+        if session_id is not None and session_id in self._sessions:
+            return self._sessions[session_id]
+
+        return self.create_session(
+            session_id=session_id,
+            system_prompt=system_prompt,
+            max_steps=max_steps,
+            parallel_tool_calls=parallel_tool_calls,
+        )
+
+    @abstractmethod
+    def create_runner(self, session: AgentSession) -> Any:
+        """子类负责返回对应的 runner。"""

wuwei/agent/plan_agent.py

@@ -0,0 +1,73 @@
+from typing import Any
+
+from wuwei.agent.base import BaseSessionAgent
+from wuwei.agent.session import AgentSession
+from wuwei.llm import LLMGateway
+from wuwei.planning import Planner, Task
+from wuwei.runtime import PlannerExecutorRunner
+from wuwei.tools import Tool, ToolRegistry
+
+
+class PlanAgent(BaseSessionAgent):
+    """Plan-and-execute 门面对象。"""
+
+    def __init__(
+        self,
+        llm: LLMGateway,
+        tools: list[Tool] | ToolRegistry | None = None,
+        planner: Planner | None = None,
+        default_system_prompt: str = "你是一个有用的助手",
+        default_max_steps: int = 10,
+        default_parallel_tool_calls: bool = False,
+    ) -> None:
+        super().__init__(
+            llm=llm,
+            tools=tools,
+            default_system_prompt=default_system_prompt,
+            default_max_steps=default_max_steps,
+            default_parallel_tool_calls=default_parallel_tool_calls,
+        )
+        self.planner = planner or Planner.create_planner(llm=self.llm)
+
+    def create_runner(self, session: AgentSession) -> PlannerExecutorRunner:
+        """为 plan-and-execute 会话创建执行器。"""
+        return PlannerExecutorRunner(
+            llm=self.llm,
+            tools=self.tool_registry.list_tools(),
+            tool_executor=self.tool_executor,
+            session=session,
+            planner=self.planner,
+        )
+
+    async def plan(
+        self,
+        goal: str,
+        session: AgentSession | None = None,
+    ) -> list[Task]:
+        """只做任务规划，不执行任务。"""
+        current_session = session or self.create_or_get_session()
+        runner = self.create_runner(current_session)
+        return await runner.plan(goal)
+
+    async def execute(
+        self,
+        goal: str,
+        tasks: list[Task],
+        session: AgentSession | None = None,
+        stream: bool = False,
+    ) -> Any:
+        """执行已经规划好的任务列表。"""
+        current_session = session or self.create_or_get_session()
+        runner = self.create_runner(current_session)
+        return await runner.execute(goal, tasks, stream=stream)
+
+    async def run(
+        self,
+        user_input: str,
+        session: AgentSession | None = None,
+        stream: bool = False,
+    ) -> Any:
+        """对外统一入口：先规划，再执行。"""
+        current_session = session or self.create_or_get_session()
+        runner = self.create_runner(current_session)
+        return await runner.run(user_input, stream=stream)

wuwei/agent/session.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass, field
+
+from wuwei.memory import Context
+
+
+@dataclass
+class AgentSession:
+    """保存一次会话的配置和上下文。"""
+
+    session_id: str
+    system_prompt: str = "你是一个有用的助手"
+    max_steps: int = 10
+    parallel_tool_calls: bool = False
+    context: Context = field(init=False)
+
+    def __post_init__(self) -> None:
+        """初始化后立刻重置上下文。"""
+        self.reset()
+
+    def reset(self) -> None:
+        """清空上下文，并重新写入 system prompt。"""
+        self.context = Context()
+        self.context.add_system_message(self.system_prompt)

wuwei/llm/__init__.py

@@ -0,0 +1,13 @@
+from .types import Message, ToolCall, FunctionCall, LLMResponse, LLMResponseChunk
+
+from .gateway import LLMGateway
+
+__all__ = [
+    "LLMGateway",
+    "Message",
+    "ToolCall",
+    "FunctionCall",
+    "LLMResponse",
+    "LLMResponseChunk",
+]
+

wuwei/llm/adapters/__init__.py

@@ -0,0 +1,3 @@
+from .base import BaseAdapter
+from .openai import OpenAIAdapter
+__all__ = ['BaseAdapter', 'OpenAIAdapter']

wuwei/llm/adapters/base.py

@@ -0,0 +1,26 @@
+from abc import ABC,abstractmethod
+from typing import Any
+
+from ..types import Message, LLMResponse,LLMResponseChunk
+
+
+class BaseAdapter(ABC):
+    @abstractmethod
+    def build_request(self,
+                      messages:list[Message],
+                      tools:list[dict]|None=None,
+                      stream:bool|None=False,
+                        **kwargs)-> Any:
+        pass
+
+    @abstractmethod
+    def call(self,request:Any)-> Any:
+        pass
+
+    @abstractmethod
+    def parse_response(self,raw_response:Any)->LLMResponse:
+        pass
+
+    @abstractmethod
+    def parse_stream_chunk(self,chunk:Any)->dict[str, Any] | None:
+        pass

wuwei/llm/adapters/openai.py

@@ -0,0 +1,109 @@
+import json
+from typing import Any
+
+from openai import AsyncOpenAI
+
+from .base import BaseAdapter
+from ..types import LLMResponse, Message, ToolCall, FunctionCall
+from ...tools import Tool
+
+
+class OpenAIAdapter(BaseAdapter):
+    def __init__(self,api_key:str,model:str|None="gpt-5.4",base_url:str|None="https://api.openai.com/v1",**kwargs):
+        self.client=AsyncOpenAI(api_key=api_key,base_url=base_url)
+        self.model = model
+        self.default_params = kwargs
+    def build_request(self, messages: list[Message], tools: list[Tool] | None = None, stream: bool | None = False,
+                      **kwargs) -> dict[str, Any]:
+        openai_messages = []
+        for msg in messages:
+            m = {"role": msg.role, "content": msg.content}
+            if msg.tool_calls:
+                m["tool_calls"]=[
+                    {
+                        "id": tc.id,
+                        "type": tc.type,
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": json.dumps(tc.function.arguments)
+                        }
+                    }
+                    for tc in msg.tool_calls
+                ]
+
+            if msg.tool_call_id:
+                m["tool_call_id"] = msg.tool_call_id
+            openai_messages.append(m)
+
+        request = {
+            "model": self.model,
+            "messages": openai_messages,
+            "stream": stream,
+            **self.default_params,
+            **kwargs,
+        }
+        if tools:
+            request["tools"] = [tool.to_schema() for tool in tools]
+
+        return request
+
+    async def call(self, request: dict[str, Any]) -> Any:
+        return await self.client.chat.completions.create(**request)
+
+    def parse_response(self, raw_response: Any) -> LLMResponse:
+        """解析非流式响应"""
+        choice = raw_response.choices[0]
+        message = choice.message
+
+        tool_calls = None
+        if message.tool_calls:
+            tool_calls = [
+                ToolCall(
+                    id=tc.id,
+                    type="function",
+                    function=FunctionCall(
+                        name=tc.function.name,
+                        arguments=json.loads(tc.function.arguments)
+                    )
+                )
+                for tc in message.tool_calls
+            ]
+
+        internal_msg = Message(
+            role="assistant",
+            content=message.content,
+            tool_calls=tool_calls,
+        )
+
+        return LLMResponse(
+            message=internal_msg,
+            finish_reason=choice.finish_reason,
+            usage={
+                "prompt_tokens": raw_response.usage.prompt_tokens,
+                "completion_tokens": raw_response.usage.completion_tokens,
+                "total_tokens": raw_response.usage.total_tokens,
+            },
+            model=raw_response.model,
+            latency_ms=0,  # 由网关填充
+        )
+
+    def parse_stream_chunk(self, chunk: Any) -> dict[str, Any] | None:
+        if not chunk.choices:
+            return None
+        delta = chunk.choices[0].delta
+        result = {
+            "content": delta.content or "",
+            "finish_reason": chunk.choices[0].finish_reason,
+        }
+        if delta.tool_calls:
+            result["tool_calls_delta"] = []
+            for tc in delta.tool_calls:
+                item = {"index": tc.index}
+                if tc.id:
+                    item["id"] = tc.id
+                if tc.function.name:
+                    item["name"] = tc.function.name
+                if tc.function.arguments:
+                    item["arguments"] = tc.function.arguments
+                result["tool_calls_delta"].append(item)
+        return result

wuwei/llm/gateway.py

@@ -0,0 +1,244 @@
+import asyncio
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any, AsyncIterator, Union
+
+from .adapters import OpenAIAdapter
+from .adapters.base import BaseAdapter
+from .types import FunctionCall, LLMResponse, LLMResponseChunk, Message, ToolCall
+from ..tools import Tool
+
+
+class LLMGateway:
+    _DEFAULT_ENV_SEARCH_DEPTH = 3
+    _DEFAULT_ENV_FILES = (".env", "env")
+    _DEFAULT_ENV_PREFIX = "OPENAI"
+
+    def __init__(self, config: dict[str, Any]):
+        """根据显式配置初始化模型网关。"""
+        self.adapter: BaseAdapter
+        provider = config.get("provider", "openai")
+
+        if provider == "openai":
+            adapter_kwargs = {
+                "api_key": config["api_key"],
+                "model": config.get("model", "gpt-5.4"),
+                "temperature": config.get("temperature", 0.2),
+                "max_tokens": config.get("max_tokens", 4096),
+            }
+            if config.get("base_url"):
+                adapter_kwargs["base_url"] = config["base_url"]
+
+            self.adapter = OpenAIAdapter(**adapter_kwargs)
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+
+        self.retry_policy = config.get("retry", {"max_attempts": 3})
+        self.timeout = config.get("timeout", 60)
+
+    @classmethod
+    def from_env(
+        cls,
+        *,
+        env_prefix: str | None = None,
+        env_file: str | None = None,
+        base_url: str | None = None,
+        model: str | None = None,
+        **config: Any,
+    ) -> "LLMGateway":
+        """
+        从环境变量创建 LLMGateway。
+
+        这个方法只保留少量高频参数：
+        - `env_prefix`：决定读取哪组环境变量，默认是 `OPENAI`
+        - `env_file`：显式指定 env 文件
+        - `model` / `base_url`：作为显式覆盖值
+
+        环境变量命名固定为：
+        - `{PREFIX}_API_KEY`
+        - `{PREFIX}_BASE_URL`
+        - `{PREFIX}_MODEL`
+
+        框架内部会自动在当前目录和最多 3 层父目录中查找 `.env` / `env`，
+        这部分不再暴露给用户配置，保持接口简单。
+        """
+        prefix = (env_prefix or cls._DEFAULT_ENV_PREFIX).upper()
+        api_key_env = f"{prefix}_API_KEY"
+        base_url_env = f"{prefix}_BASE_URL"
+        model_env = f"{prefix}_MODEL"
+
+        file_values = cls._load_env_file(env_file=env_file)
+
+        api_key = os.getenv(api_key_env) or file_values.get(api_key_env)
+        if not api_key:
+            raise ValueError(f"Missing required environment variable: {api_key_env}")
+
+        env_config: dict[str, Any] = {
+            "provider": "openai",
+            "api_key": api_key,
+        }
+
+        resolved_base_url = base_url or os.getenv(base_url_env) or file_values.get(base_url_env)
+        if resolved_base_url:
+            env_config["base_url"] = resolved_base_url
+
+        resolved_model = model or os.getenv(model_env) or file_values.get(model_env)
+        if resolved_model:
+            env_config["model"] = resolved_model
+
+        env_config.update(config)
+        return cls(env_config)
+
+    @staticmethod
+    def _load_env_file(env_file: str | None = None) -> dict[str, str]:
+        """
+        尝试从 env 文件读取变量。
+
+        规则：
+        1. 如果显式传入 `env_file`，只读取这个文件
+        2. 否则自动查找当前目录和最多 3 层父目录中的 `.env` / `env`
+
+        注意：
+        - 这里只返回解析结果，不会修改 `os.environ`
+        - 这是一个轻量实现，不依赖 `python-dotenv`
+        """
+        candidate_paths: list[Path] = []
+        if env_file:
+            candidate_paths.append(Path(env_file))
+        else:
+            directories = [Path.cwd(), *Path.cwd().parents[: LLMGateway._DEFAULT_ENV_SEARCH_DEPTH]]
+            for directory in directories:
+                for filename in LLMGateway._DEFAULT_ENV_FILES:
+                    candidate_paths.append(directory / filename)
+
+        for path in candidate_paths:
+            if not path.exists() or not path.is_file():
+                continue
+
+            values: dict[str, str] = {}
+            for raw_line in path.read_text(encoding="utf-8").splitlines():
+                line = raw_line.strip()
+                if not line or line.startswith("#") or "=" not in line:
+                    continue
+
+                key, value = line.split("=", 1)
+                key = key.strip()
+                value = value.strip()
+
+                if not key:
+                    continue
+
+                if value and value[0] == value[-1] and value[0] in {"'", '"'}:
+                    value = value[1:-1]
+
+                values[key] = value
+
+            return values
+
+        return {}
+
+    async def generate(
+        self,
+        messages: list[Message],
+        tools: list[Tool] | None = None,
+        stream: bool = False,
+        **kwargs,
+    ) -> Union[LLMResponse, AsyncIterator[LLMResponseChunk]]:
+        """统一处理单次和流式生成请求。"""
+        if stream:
+            return self._generate_stream(messages=messages, tools=tools, **kwargs)
+        return await self._generate_single(messages=messages, tools=tools, **kwargs)
+
+    async def _generate_single(
+        self,
+        messages: list[Message],
+        tools: list[Tool] | None,
+        **kwargs,
+    ) -> LLMResponse:
+        """发送一次非流式请求。"""
+        request = self.adapter.build_request(messages=messages, tools=tools, stream=False, **kwargs)
+        start = time.monotonic()
+        last_exception = None
+
+        for attempt in range(self.retry_policy["max_attempts"]):
+            try:
+                raw = await asyncio.wait_for(self.adapter.call(request), timeout=self.timeout)
+                response = self.adapter.parse_response(raw)
+                response.latency_ms = int((time.monotonic() - start) * 1000)
+                return response
+            except Exception as exc:
+                last_exception = exc
+                if attempt == self.retry_policy["max_attempts"] - 1:
+                    raise
+                wait_time = 2**attempt
+                await asyncio.sleep(wait_time)
+
+        raise last_exception
+
+    async def _generate_stream(
+        self,
+        messages: list[Message],
+        tools: list[Tool] | None,
+        **kwargs,
+    ) -> AsyncIterator[LLMResponseChunk]:
+        """发送一次流式请求，并把 tool call 增量拼成完整结构。"""
+        request = self.adapter.build_request(messages, tools, stream=True, **kwargs)
+        stream = await self.adapter.call(request)
+
+        # 按 index 累积工具调用增量。
+        pending: dict[int, dict[str, Any]] = {}
+
+        async for chunk in stream:
+            data = self.adapter.parse_stream_chunk(chunk)
+            if not data:
+                continue
+
+            content = data.get("content", "")
+            finish_reason = data.get("finish_reason")
+            tool_calls_delta = data.get("tool_calls_delta")
+
+            if tool_calls_delta:
+                for delta_item in tool_calls_delta:
+                    idx = delta_item["index"]
+                    if idx not in pending:
+                        pending[idx] = {"id": "", "name": "", "arguments": ""}
+                    if "id" in delta_item:
+                        pending[idx]["id"] = delta_item["id"]
+                    if "name" in delta_item:
+                        pending[idx]["name"] = delta_item["name"]
+                    if "arguments" in delta_item:
+                        pending[idx]["arguments"] += delta_item["arguments"]
+
+            out_chunk = LLMResponseChunk(content=content)
+
+            if finish_reason == "tool_calls":
+                complete: list[ToolCall] = []
+                for item in pending.values():
+                    if not item["id"] or not item["name"]:
+                        continue
+                    try:
+                        args = json.loads(item["arguments"]) if item["arguments"] else {}
+                    except json.JSONDecodeError:
+                        args = {}
+                    complete.append(
+                        ToolCall(
+                            id=item["id"],
+                            type="function",
+                            function=FunctionCall(name=item["name"], arguments=args),
+                        )
+                    )
+                out_chunk.tool_calls_complete = complete
+                out_chunk.finish_reason = finish_reason
+            elif finish_reason == "stop":
+                out_chunk.finish_reason = finish_reason
+
+            if hasattr(chunk, "usage") and chunk.usage:
+                out_chunk.usage = {
+                    "prompt_tokens": chunk.usage.prompt_tokens,
+                    "completion_tokens": chunk.usage.completion_tokens,
+                    "total_tokens": chunk.usage.total_tokens,
+                }
+
+            yield out_chunk