my-pi-agent 0.1.0

package/src/my_agent_llm/providers/openai.py

@@ -0,0 +1,364 @@
+# pyright: reportArgumentType=false, reportCallIssue=false
+"""OpenAI provider：基准实现，deepseek 以此为模板。"""
+
+import json
+from collections.abc import AsyncIterator, Iterator
+
+import openai
+
+from ..config import Config
+from ..models import Message, Response, StreamChunk, ToolCall
+from ._base import Provider
+
+
+class _ToolCallAccumulator:
+    """聚合流式 tool_calls 增量片段，产出统一形状。
+
+    OpenAI 兼容流式把 tool_call 分片送达：id/name 只出现一次，
+    arguments 是碎片 JSON 字符串，按 index 键控拼接。
+    """
+
+    def __init__(self) -> None:
+        self._by_index: dict[int, dict[str, str]] = {}
+
+    def add(self, delta) -> None:
+        """消费一个 delta 的 tool_calls 片段。"""
+        for tc in getattr(delta, "tool_calls", None) or []:
+            index = getattr(tc, "index", 0) or 0
+            slot = self._by_index.setdefault(index, {"id": "", "name": "", "arguments": ""})
+            if getattr(tc, "id", None):
+                slot["id"] = tc.id
+            fn = getattr(tc, "function", None)
+            if fn is not None:
+                if getattr(fn, "name", None):
+                    slot["name"] = fn.name
+                if getattr(fn, "arguments", None):
+                    slot["arguments"] += fn.arguments
+
+    def finish(self) -> list[ToolCall] | None:
+        """流式结束：产出完整 tool_calls（无则 None）。"""
+        if not self._by_index:
+            return None
+        out: list[ToolCall] = []
+        for _, slot in sorted(self._by_index.items()):
+            raw_args = slot["arguments"]
+            args = {}
+            error = None
+            try:
+                if raw_args.strip():
+                    parsed = json.loads(raw_args)
+                    if isinstance(parsed, dict):
+                        args = parsed
+                    else:
+                        error = f"Tool arguments must be a dict, got {type(parsed).__name__}"
+            except Exception as exc:
+                error = f"Malformed JSON arguments: {exc}"
+            out.append(
+                ToolCall(
+                    id=slot["id"],
+                    name=slot["name"],
+                    args=args,
+                    error=error,
+                )
+            )
+        return out
+
+
+class OpenAIProvider(Provider):
+    """OpenAI provider 实现。"""
+
+    def __init__(self, config: Config, client=None, async_client=None):
+        """初始化。client/async_client 可注入（测试缝隙）。"""
+        self.config = config
+        if client is not None or async_client is not None:
+            self.client = client
+            self.async_client = async_client
+            return
+        kwargs = {
+            "api_key": config.api_key,
+            "timeout": config.timeout,
+            "max_retries": config.max_retries,
+        }
+        if config.base_url:
+            kwargs["base_url"] = config.base_url
+        self.client = openai.OpenAI(**kwargs)
+        self.async_client = openai.AsyncOpenAI(**kwargs)
+
+    def _convert_messages(self, messages: list[Message]) -> list[dict]:
+        """Message → OpenAI wire dict。"""
+        result = []
+        for msg in messages:
+            if msg.role == "assistant" and msg.metadata and "tool_calls" in msg.metadata:
+                wire_calls = []
+                for tc in msg.metadata["tool_calls"]:
+                    if isinstance(tc, ToolCall):
+                        wire_calls.append(tc.to_wire_dict())
+                    elif isinstance(tc, dict):
+                        if "function" in tc:
+                            wire_calls.append(tc)
+                        else:
+                            wire_calls.append(ToolCall.model_validate(tc).to_wire_dict())
+                if wire_calls:
+                    result.append(
+                        {
+                            "role": "assistant",
+                            "content": msg.content or None,
+                            "tool_calls": wire_calls,
+                        }
+                    )
+                else:
+                    result.append({"role": "assistant", "content": msg.content or ""})
+            elif msg.role == "tool" and msg.metadata:
+                result.append(
+                    {
+                        "role": "tool",
+                        "content": msg.content,
+                        "tool_call_id": msg.metadata.get("tool_call_id", ""),
+                    }
+                )
+            else:
+                result.append({"role": msg.role, "content": msg.content})
+        return result
+
+    @staticmethod
+    def _extract_tool_calls(message) -> list[ToolCall] | None:
+        """从 OpenAI 响应 message 提取 tool_calls（统一形状）。"""
+        if not getattr(message, "tool_calls", None):
+            return None
+        out: list[ToolCall] = []
+        for tc in message.tool_calls:
+            fn = getattr(tc, "function", None)
+            name = getattr(fn, "name", "") if fn else ""
+            raw_args = getattr(fn, "arguments", "{}") if fn else "{}"
+            args = {}
+            error = None
+            try:
+                if isinstance(raw_args, str) and raw_args.strip():
+                    parsed = json.loads(raw_args)
+                    if isinstance(parsed, dict):
+                        args = parsed
+                    else:
+                        error = f"Tool arguments must be a dict, got {type(parsed).__name__}"
+                elif isinstance(raw_args, dict):
+                    args = raw_args
+            except Exception as exc:
+                error = f"Malformed JSON arguments: {exc}"
+            out.append(
+                ToolCall(
+                    id=getattr(tc, "id", ""),
+                    name=name,
+                    args=args,
+                    error=error,
+                )
+            )
+        return out
+
+    @staticmethod
+    def _extract_usage(response) -> dict[str, int] | None:
+        """从响应或流式 chunk 提取完整 usage（含 OpenAI & DeepSeek 真实 Prompt Cache）。"""
+        u = getattr(response, "usage", None)
+        if u is None:
+            return None
+
+        prompt_tokens = getattr(u, "prompt_tokens", 0) or 0
+        completion_tokens = getattr(u, "completion_tokens", 0) or 0
+        total_tokens = getattr(u, "total_tokens", 0) or (prompt_tokens + completion_tokens)
+
+        # 1. 提取 OpenAI 官方 Prompt Cache (prompt_tokens_details.cached_tokens) 与 DeepSeek 专用 Cache
+        cache_read = 0
+        try:
+            details = getattr(u, "prompt_tokens_details", None)
+            if details is not None:
+                if isinstance(details, dict):
+                    cache_read = int(details.get("cached_tokens", 0) or 0)
+                else:
+                    cache_read = int(getattr(details, "cached_tokens", 0) or 0)
+
+            if not cache_read:
+                hit = getattr(u, "prompt_cache_hit_tokens", None)
+                if hit is not None:
+                    cache_read = int(hit or 0)
+                elif isinstance(u, dict):
+                    cache_read = int(u.get("prompt_cache_hit_tokens", 0) or 0)
+        except (TypeError, ValueError):
+            cache_read = 0
+
+        # 计算净非缓存输入量
+        net_prompt = max(0, prompt_tokens - cache_read) if prompt_tokens >= cache_read else prompt_tokens
+
+        out = {
+            "prompt_tokens": net_prompt,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+        }
+        if cache_read > 0:
+            out["cache_read_tokens"] = cache_read
+        return out
+
+    def chat(
+        self,
+        messages: list[Message],
+        *,
+        model: str,
+        tools: list[dict] | None = None,
+        **kwargs,
+    ) -> Response:
+        """同步对话。"""
+        if self.client is None:
+            raise RuntimeError("client not provided; cannot run sync methods")
+        response = self.client.chat.completions.create(  # pyright: ignore[reportCallIssue, reportArgumentType]
+            model=model,
+            messages=self._convert_messages(messages),
+            tools=tools,
+            **kwargs,
+        )
+        choice = response.choices[0]
+        return Response(
+            content=choice.message.content or "",
+            model=response.model,
+            usage=self._extract_usage(response),
+            finish_reason=choice.finish_reason,
+            tool_calls=self._extract_tool_calls(choice.message),
+        )
+
+    def stream(
+        self,
+        messages: list[Message],
+        *,
+        model: str,
+        tools: list[dict] | None = None,
+        **kwargs,
+    ) -> Iterator[StreamChunk]:
+        """同步流式：逐 delta 产文本块；流式结束补发末块（完整 tool_calls + usage）。"""
+        if self.client is None:
+            raise RuntimeError("client not provided; cannot run sync methods")
+        stream = self.client.chat.completions.create(  # pyright: ignore[reportCallIssue, reportArgumentType]
+            model=model,
+            messages=self._convert_messages(messages),
+            tools=tools,
+            stream=True,
+            **kwargs,
+        )
+        accumulator = _ToolCallAccumulator()
+        text_acc = ""
+        usage = None
+        final_finish_reason: str | None = None
+        for chunk in stream:
+            chunk_usage = self._extract_usage(chunk)
+            if chunk_usage:
+                usage = chunk_usage
+            if not chunk.choices:
+                continue  # usage-only 末块（choices 为空）——usage 已捕获，流式结束
+            choice = chunk.choices[0]
+            if choice.finish_reason:
+                final_finish_reason = choice.finish_reason
+            delta = choice.delta
+            accumulator.add(delta)
+            if reasoning_delta := getattr(delta, "reasoning_content", None):
+                yield StreamChunk(
+                    content="",
+                    metadata={"reasoning_content": reasoning_delta},
+                    finish_reason=choice.finish_reason,
+                )
+            if getattr(delta, "content", None):
+                text_acc += delta.content
+                yield StreamChunk(content=delta.content, finish_reason=choice.finish_reason)
+        tool_calls = accumulator.finish()
+        final_response = Response(
+            content=text_acc,
+            model=model,
+            tool_calls=tool_calls,
+            usage=usage,
+            finish_reason=final_finish_reason,
+        )
+        yield StreamChunk(
+            content="",
+            tool_calls=tool_calls,
+            usage=usage,
+            finish_reason=final_finish_reason,
+            response=final_response,
+        )
+
+    async def achat(
+        self,
+        messages: list[Message],
+        *,
+        model: str,
+        tools: list[dict] | None = None,
+        **kwargs,
+    ) -> Response:
+        """异步对话。"""
+        if self.async_client is None:
+            raise RuntimeError("async_client not provided; cannot run async methods")
+        response = await self.async_client.chat.completions.create(  # pyright: ignore[reportCallIssue, reportArgumentType]
+            model=model,
+            messages=self._convert_messages(messages),
+            tools=tools,
+            **kwargs,
+        )
+        choice = response.choices[0]
+        return Response(
+            content=choice.message.content or "",
+            model=response.model,
+            usage=self._extract_usage(response),
+            finish_reason=choice.finish_reason,
+            tool_calls=self._extract_tool_calls(choice.message),
+        )
+
+    async def achat_stream(
+        self,
+        messages: list[Message],
+        *,
+        model: str,
+        tools: list[dict] | None = None,
+        **kwargs,
+    ) -> AsyncIterator[StreamChunk]:
+        """异步流式：逐 delta 产文本块；流式结束补发末块（完整 tool_calls + usage）。"""
+        if self.async_client is None:
+            raise RuntimeError("async_client not provided; cannot run async methods")
+        stream = await self.async_client.chat.completions.create(  # pyright: ignore[reportCallIssue, reportArgumentType]
+            model=model,
+            messages=self._convert_messages(messages),
+            tools=tools,
+            stream=True,
+            **kwargs,
+        )
+        accumulator = _ToolCallAccumulator()
+        text_acc = ""
+        usage = None
+        final_finish_reason: str | None = None
+        async for chunk in stream:
+            chunk_usage = self._extract_usage(chunk)
+            if chunk_usage:
+                usage = chunk_usage
+            if not chunk.choices:
+                continue  # usage-only 末块（choices 为空）——usage 已捕获，流式结束
+            choice = chunk.choices[0]
+            if choice.finish_reason:
+                final_finish_reason = choice.finish_reason
+            delta = choice.delta
+            accumulator.add(delta)
+            if reasoning_delta := getattr(delta, "reasoning_content", None):
+                yield StreamChunk(
+                    content="",
+                    metadata={"reasoning_content": reasoning_delta},
+                    finish_reason=choice.finish_reason,
+                )
+            if getattr(delta, "content", None):
+                text_acc += delta.content
+                yield StreamChunk(content=delta.content, finish_reason=choice.finish_reason)
+        tool_calls = accumulator.finish()
+        final_response = Response(
+            content=text_acc,
+            model=model,
+            tool_calls=tool_calls,
+            usage=usage,
+            finish_reason=final_finish_reason,
+        )
+        yield StreamChunk(
+            content="",
+            tool_calls=tool_calls,
+            usage=usage,
+            finish_reason=final_finish_reason,
+            response=final_response,
+        )

package/src/my_agent_llm/providers/registry.py

@@ -0,0 +1,16 @@
+"""Provider 注册表：provider 名 → 实现类，门面据此路由。"""
+
+from ._base import Provider
+from .anthropic import AnthropicProvider
+from .antigravity import (  # pyright: ignore[reportMissingImports]
+    AntigravityProvider,
+)
+from .deepseek import DeepSeekProvider
+from .openai import OpenAIProvider
+
+PROVIDER_REGISTRY: dict[str, type[Provider]] = {
+    "openai": OpenAIProvider,
+    "deepseek": DeepSeekProvider,
+    "anthropic": AnthropicProvider,
+    "antigravity": AntigravityProvider,
+}

package/src/my_agent_llm/stream.py

@@ -0,0 +1,218 @@
+"""通用流式累加与规范化器（对标 Tau stream.py 与 canonicalize_provider_stream）。
+
+统一在模型层维护 partial: Message，消化 Token 累加、首字启动、工具拼装、取消与异常包装。
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from typing import Any
+
+from .events import (
+    StreamDoneEvent,
+    StreamErrorEvent,
+    StreamEvent,
+    StreamStartEvent,
+    TextDeltaEvent,
+    ThinkingDeltaEvent,
+    ToolCallDoneEvent,
+)
+from .models import Message, Response, StreamChunk, ToolCall, TurnOutcome
+
+__all__ = ["StreamAccumulator"]
+
+
+class StreamAccumulator:
+    """流式累加器：维护单次请求的流式累加状态并输出高阶事件。"""
+
+    def __init__(self, role: str = "assistant") -> None:
+        self.role = role
+        self.content: str = ""
+        self.metadata: dict[str, Any] = {}
+        self.started: bool = False
+        self.tool_calls: list[ToolCall] = []
+        self.last_usage: dict[str, int] | None = None
+        self.final_response: Response | None = None
+
+    def _snapshot(self) -> Message:
+        meta = dict(self.metadata) if self.metadata else {}
+        if self.tool_calls:
+            meta["tool_calls"] = [
+                tc.model_dump() if hasattr(tc, "model_dump") else tc
+                for tc in self.tool_calls
+            ]
+        return Message(
+            role=self.role,
+            content=self.content,
+            metadata=meta if meta else None,
+        )
+
+    def feed(self, chunk: Any) -> list[StreamEvent]:
+        """消化单个底层 StreamChunk / Response 并产出对应的上层高阶事件。"""
+        events: list[StreamEvent] = []
+
+        if not self.started:
+            self.started = True
+            events.append(StreamStartEvent(partial=self._snapshot()))
+
+        # 1. 思考链增量 (Reasoning / Thinking)
+        meta = getattr(chunk, "metadata", None)
+        reasoning_delta: str | None = None
+        if isinstance(meta, dict) and "reasoning_content" in meta:
+            reasoning_delta = meta["reasoning_content"]
+        elif getattr(chunk, "reasoning_content", None):
+            reasoning_delta = chunk.reasoning_content
+
+        if reasoning_delta:
+            prev_reasoning = str(self.metadata.get("reasoning_content", ""))
+            self.metadata["reasoning_content"] = prev_reasoning + reasoning_delta
+            events.append(
+                ThinkingDeltaEvent(delta=reasoning_delta, partial=self._snapshot())
+            )
+
+        # 2. 正文文本增量 (Text Delta)
+        content = getattr(chunk, "content", "") or ""
+        if content:
+            self.content += content
+            events.append(TextDeltaEvent(delta=content, partial=self._snapshot()))
+
+        # 3. 工具调用增量 (Tool Calls)
+        tool_calls = getattr(chunk, "tool_calls", None)
+        if tool_calls:
+            self.tool_calls = []
+            for idx, tc in enumerate(tool_calls):
+                if isinstance(tc, dict):
+                    tc_obj = ToolCall.model_validate(tc)
+                else:
+                    tc_obj = tc
+                self.tool_calls.append(tc_obj)
+                events.append(
+                    ToolCallDoneEvent(
+                        index=idx,
+                        tool_call=tc_obj,
+                        partial=self._snapshot(),
+                    )
+                )
+
+        # 4. Usage 统计
+        usage = getattr(chunk, "usage", None)
+        if isinstance(usage, dict):
+            self.last_usage = usage
+            self.metadata["usage"] = usage
+
+        # 5. 终态已拼装好的 Response 实体
+        resp = getattr(chunk, "response", None)
+        if resp is not None and isinstance(resp, Response):
+            self.final_response = resp
+        elif isinstance(chunk, Response):
+            self.final_response = chunk
+
+        return events
+
+    def finish(self, stop_reason: str | None = None) -> StreamDoneEvent:
+        """完成流式会话，交付最终完型的 Message 与 Usage。"""
+        if not self.started:
+            self.started = True
+
+        if self.final_response is not None and hasattr(
+            self.final_response, "to_message"
+        ):
+            msg = self.final_response.to_message(
+                role=self.role, stop_reason=stop_reason
+            )
+            usage = self.last_usage or getattr(self.final_response, "usage", None)
+        else:
+            meta = dict(self.metadata) if self.metadata else {}
+            if self.tool_calls:
+                meta["tool_calls"] = [
+                    tc.model_dump() if hasattr(tc, "model_dump") else tc
+                    for tc in self.tool_calls
+                ]
+            effective_stop = stop_reason or (
+                TurnOutcome.TOOL_CALLS.value
+                if self.tool_calls
+                else TurnOutcome.COMPLETED.value
+            )
+            meta["stop_reason"] = effective_stop
+            msg = Message(
+                role=self.role,
+                content=self.content,
+                metadata=meta if meta else None,
+            )
+            usage = self.last_usage
+
+        return StreamDoneEvent(message=msg, usage=usage)
+
+    def fail(
+        self,
+        exc: Exception | None = None,
+        cancelled: bool = False,
+    ) -> StreamErrorEvent:
+        """遇到取消或异常时，构建安全的终态错误 Message（Never-Throw 保证）。"""
+        stop_reason = "cancelled" if cancelled else "error"
+        content = self.content
+        if exc is not None:
+            err_str = str(exc)
+            content = (
+                f"{content} (Error during model stream: {err_str})"
+                if content
+                else err_str
+            )
+
+        meta = dict(self.metadata) if self.metadata else {}
+        if self.tool_calls:
+            meta["tool_calls"] = [
+                tc.model_dump() if hasattr(tc, "model_dump") else tc
+                for tc in self.tool_calls
+            ]
+        meta["stop_reason"] = stop_reason
+
+        error_msg = Message(
+            role=self.role,
+            content=content,
+            metadata=meta if meta else None,
+        )
+        return StreamErrorEvent(error=error_msg, stop_reason=stop_reason, exc=exc)
+
+    async def stream(
+        self,
+        source: AsyncIterator[StreamChunk],
+        signal: Any | None = None,
+    ) -> AsyncIterator[StreamEvent]:
+        """全生命周期异步生成器：将底层 StreamChunk 转换为高阶 StreamEvent。"""
+        cancelled = False
+        error_exc: Exception | None = None
+
+        def is_cancelled() -> bool:
+            if signal is None:
+                return False
+            check = getattr(signal, "is_cancelled", None)
+            if callable(check):
+                return bool(check())
+            return bool(getattr(signal, "cancelled", False))
+
+        try:
+            if is_cancelled():
+                cancelled = True
+            else:
+                async for chunk in source:
+                    for ev in self.feed(chunk):
+                        yield ev
+
+                    if is_cancelled():
+                        cancelled = True
+                        break
+        except Exception as exc:
+            if is_cancelled():
+                cancelled = True
+            else:
+                error_exc = exc
+
+        if not self.started:
+            self.started = True
+            yield StreamStartEvent(partial=self._snapshot())
+
+        if cancelled or error_exc is not None:
+            yield self.fail(exc=error_exc, cancelled=cancelled)
+        else:
+            yield self.finish()

package/src/my_coding_agent/__init__.py

@@ -0,0 +1,66 @@
+"""my_coding_agent 公共 API（产品层：文件工具 + MCP + 业务装配）。"""
+
+from typing import TYPE_CHECKING
+
+from my_coding_agent.agent import CodingAgent
+from my_coding_agent.file_reference import FileReferenceParser
+from my_coding_agent.macro import MacroEngine
+from my_coding_agent.mcp import MCPClientManager, MCPConnection, MCPServerConfig
+from my_coding_agent.mutation_queue import FileMutationQueue
+from my_coding_agent.paths import AgentPaths
+from my_coding_agent.permissions import PermissionGate, PermissionMode, PermissionRequest
+from my_coding_agent.prompt import build_default_coding_prompt
+from my_coding_agent.settings import CompactionSettings, Settings, load_settings, save_settings
+from my_coding_agent.tools import (
+    EditBlock,
+    build_coding_tools,
+    make_bash_tool,
+    make_edit_tool,
+    make_find_tool,
+    make_grep_tool,
+    make_ls_tool,
+    make_read_tool,
+    make_write_tool,
+    resolve_path,
+)
+
+__all__ = [
+    "AgentPaths",
+    "CodingAgent",
+    "CompactionSettings",
+    "FileReferenceParser",
+    "MacroEngine",
+    "Settings",
+    "load_settings",
+    "save_settings",
+    "build_coding_tools",
+    "build_default_coding_prompt",
+    "FileMutationQueue",
+    "resolve_path",
+    "RpcServer",
+    "EditBlock",
+    "make_read_tool",
+    "make_write_tool",
+    "make_edit_tool",
+    "make_bash_tool",
+    "make_grep_tool",
+    "make_find_tool",
+    "make_ls_tool",
+    "MCPServerConfig",
+    "MCPConnection",
+    "MCPClientManager",
+    "PermissionGate",
+    "PermissionRequest",
+    "PermissionMode",
+]
+
+if TYPE_CHECKING:
+    from my_coding_agent.rpc_server import RpcServer
+
+
+def __getattr__(name: str):
+    if name == "RpcServer":
+        from my_coding_agent.rpc_server import RpcServer
+
+        return RpcServer
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")