linhai 0.1.0__py3-none-any.whl

linhai/__init__.py

@@ -0,0 +1,3 @@
+"""林海漫游AI Agent包。"""
+
+from . import agent, main, init, registry

linhai/__main__.py

@@ -0,0 +1,10 @@
+"""
+LinHai 命令行入口点模块。
+
+提供直接运行程序的入口。
+"""
+
+from linhai.main import main
+
+if __name__ == "__main__":
+    main()

linhai/agent/__init__.py

@@ -0,0 +1,23 @@
+"""Agent module for LinHai."""
+
+from .messages import DynamicFileContentMessage
+from .main import Agent
+from .lifecycle import Lifecycle
+from .workflow import context_forget_range_step1, context_forget_range_step2
+from .answer import AgentLlm
+from .user_message_handler import UserMessageHandler, ParsedUserMessage
+from .command_callback import CommandCallback
+from .state_machine import AgentStateMachine
+
+__all__ = [
+    "Agent",
+    "Lifecycle",
+    "DynamicFileContentMessage",
+    "context_forget_range_step1",
+    "context_forget_range_step2",
+    "AgentLlm",
+    "UserMessageHandler",
+    "ParsedUserMessage",
+    "CommandCallback",
+    "AgentStateMachine",
+]

linhai/agent/answer.py

@@ -0,0 +1,120 @@
+from typing import Tuple, TYPE_CHECKING
+import asyncio
+from linhai.base import Answer, Message
+from linhai.llm_manager import LlmManager
+from linhai.parsed_message import ParsedAnswer
+from linhai.agent.lifecycle import Lifecycle
+from linhai.agent.messages import RuntimeMessage
+from linhai.registry import Registry
+from linhai.utils.common import UiNotice
+from linhai.base import UserMessage, AssistantMessage, ToolCallMessage
+from linhai.agent.user_message_handler import UserMessageHandler
+
+if TYPE_CHECKING:
+    from linhai.agent.toolcall import AgentToolcall
+    from linhai.agent.message import AgentMessage
+    from linhai.agent.main import Agent
+
+
+class AgentLlm:
+    """AgentLlm类，负责管理LLM调用、Answer解析和打断逻辑。"""
+
+    def __init__(
+        self,
+        llm_manager: LlmManager,
+        registry: Registry,
+        toolcall_processor: "AgentToolcall",
+        message_processor: "AgentMessage",
+    ):
+        """初始化AgentLlm。
+
+        Args:
+            llm_manager: LlmManager实例
+            registry: Registry实例
+            toolcall_processor: AgentToolcall实例
+            message_processor: AgentMessage实例
+        """
+        self.llm_manager = llm_manager
+        self.registry = registry
+        self.toolcall_processor = toolcall_processor
+        self.message_processor = message_processor
+        self._current_parsed_answer: ParsedAnswer | None = None
+        self.current_answer: Answer | None = None
+
+    async def call_and_wait_llm(self) -> Tuple[Answer, ParsedAnswer, bool]:
+        """调用LLM并等待解析完成。
+
+        Returns:
+            Tuple[Answer, ParsedAnswer, bool]: (Answer, ParsedAnswer, 是否正常完成)
+        """
+        from .main import Agent
+
+        agent = self.registry.get_member_typechecked("agent", Agent)
+        lifecycle = agent.lifecycle
+
+        await lifecycle.before_message_generation.trigger()
+
+        answer: Answer = await self.llm_manager.answer_stream(
+            self.message_processor.get_messages()
+        )
+
+        self.current_answer = answer
+
+        parsed_answer = ParsedAnswer(
+            answer, lifecycle, agent=agent, registry=self.registry
+        )
+        await parsed_answer.start_parsing()
+        await lifecycle.after_new_parsed_answer.trigger(parsed_answer)
+        await self.registry.send("parsed_agent_answer", parsed_answer)
+
+        completed_normally = await parsed_answer.wait_parsing()
+        return answer, parsed_answer, completed_normally
+
+    async def interrupt(self, agent_message: str, ui_notice: str):
+        """打断当前Answer并添加自定义消息。
+
+        Args:
+            agent_message: 发送给agent的消息内容，放入RuntimeMessage
+            ui_notice: 发送给UI的通知内容，必须提供
+        """
+        from .main import Agent
+
+        message_processor = self.message_processor
+        lifecycle = self.registry.get_member_typechecked("lifecycle", Lifecycle)
+        agent = self.registry.get_member_typechecked("agent", Agent)
+
+        if self._current_parsed_answer:
+            self._current_parsed_answer.interrupt()
+
+            await message_processor.add_new_message(RuntimeMessage(agent_message))
+
+            if ui_notice is not None:
+                interrupt_msg = UiNotice(level="WARNING", content=ui_notice)
+            else:
+                interrupt_msg = UiNotice(level="WARNING", content="Agent被打断")
+
+            current_content = self._current_parsed_answer._answer.get_current_content()
+            has_tool_calls = "```json toolcall" in current_content or bool(
+                self._current_parsed_answer._openai_toolcall_segments
+            )
+            if has_tool_calls:
+                await message_processor.add_new_message(
+                    RuntimeMessage("当前所有工具调用全部被忽略，请重新调用")
+                )
+
+            self._current_parsed_answer = None
+
+            await self.registry.send_if_exists("ui_log", interrupt_msg)
+
+            from .state_machine import AgentStateMachine
+
+            state_machine = self.registry.get_member_typechecked(
+                "state_machine", AgentStateMachine
+            )
+            state_machine.transition_to_working()
+
+            user_message_handler = self.registry.get_member_typechecked(
+                "user_message_handler", UserMessageHandler
+            )
+            while user_message_handler.has_message():
+                await user_message_handler.receive_and_dispatch()

linhai/agent/callback_slot.py

@@ -0,0 +1,74 @@
+from typing import Generic, TypeVar, Callable, Awaitable
+
+R = TypeVar("R")
+
+
+class CallbackSlot(Generic[R]):
+    def __init__(self) -> None:
+        self._callbacks: list[Callable[..., Awaitable[R]]] = []
+
+    def register(self, callback: Callable[..., Awaitable[R]]) -> None:
+        self._callbacks.append(callback)
+
+
+class BroadcastSlot(CallbackSlot[None]):
+    async def trigger(self, *args, **kwargs) -> None:
+        for callback in self._callbacks:
+            await callback(*args, **kwargs)
+
+
+class ShortCircuitSlot(CallbackSlot[R]):
+    async def trigger(self, *args, **kwargs) -> R | None:
+        for callback in self._callbacks:
+            result = await callback(*args, **kwargs)
+            if result is not None:
+                return result
+        return None
+
+
+class InterruptSlot(CallbackSlot[bool]):
+    async def trigger(self, *args, **kwargs) -> bool:
+        for callback in self._callbacks:
+            if await callback(*args, **kwargs):
+                return True
+        return False
+
+
+class AfterToolcallSlot(CallbackSlot):
+    async def trigger(self, *args, **kwargs):
+        from linhai.agent.lifecycle import AfterToolcallResult
+
+        replacement = None
+        warnings = []
+        for callback in self._callbacks:
+            result = await callback(*args, **kwargs)
+            if result is None:
+                continue
+            if result.replacement is not None and replacement is None:
+                replacement = result.replacement
+            warnings.extend(result.warnings)
+        if replacement is None and not warnings:
+            return None
+        return AfterToolcallResult(replacement=replacement, warnings=warnings)
+
+
+class ChainSlot(CallbackSlot[R]):
+    def __init__(
+        self,
+        *,
+        chain_arg: int = 0,
+        should_stop: Callable[..., bool] | None = None,
+    ) -> None:
+        super().__init__()
+        self._chain_arg = chain_arg
+        self._should_stop = should_stop
+
+    async def trigger(self, *args, **kwargs) -> R:
+        args_list = list(args)
+        for callback in self._callbacks:
+            result = await callback(*args_list, **kwargs)
+            if result is not None:
+                args_list[self._chain_arg] = result
+                if self._should_stop is not None and self._should_stop(result):
+                    break
+        return args_list[self._chain_arg]

linhai/agent/command_callback.py

@@ -0,0 +1,177 @@
+from typing import Literal
+
+from linhai.base import UserMessage, ToolCallMessage
+from linhai.registry import Registry
+from linhai.utils.common import UiNotice
+from linhai.agent.user_message_handler import ParsedUserMessage
+
+
+class CommandCallback:
+    def __init__(self, registry: Registry):
+        self.registry = registry
+
+    async def __call__(self, parsed: ParsedUserMessage) -> bool | None:
+        parsed_input = parsed["parsed_input"]
+        msg = parsed["raw_message"]
+
+        if parsed_input.switch_model:
+            return await self._handle_switch_model(parsed_input.switch_model, msg)
+
+        if parsed_input.command:
+            if parsed_input.command == "context_forget_large_message":
+                return await self._handle_context_tool_command(parsed_input)
+            if parsed_input.command == "queue":
+                return await self._handle_queue_command(msg)
+            if parsed_input.command in ("quit", "exit"):
+                return await self._handle_quit_command()
+            if parsed_input.command == "help":
+                return await self._handle_help_command()
+            if parsed_input.command == "status":
+                return await self._handle_status_command()
+            if parsed_input.command == "save":
+                return await self._handle_save_command()
+
+        return None
+
+    @staticmethod
+    def get_command_completions() -> list[str]:
+        return [
+            "/queue",
+            "/help",
+            "/status",
+            "/save",
+            "/quit",
+            "/exit",
+            "/context_forget_large_message",
+        ]
+
+    async def _show_runtime_message(
+        self, level: Literal["INFO", "WARNING", "ERROR"], content: str
+    ) -> None:
+        await self.registry.send_if_exists(
+            "ui_log", UiNotice(level=level, content=content)
+        )
+
+    async def _handle_queue_command(self, msg: UserMessage) -> bool:
+        from .message import AgentMessage
+
+        agent_message = self.registry.get_member_typechecked(
+            "agent_message", AgentMessage
+        )
+        queue_content = msg.message.removeprefix("/queue").strip()
+        if not queue_content:
+            await self._show_runtime_message("ERROR", "用法: /queue <消息内容>")
+            return False
+
+        queued_msg = UserMessage(message=queue_content)
+        agent_message.add_queued_message(queued_msg)
+        return False
+
+    async def _handle_quit_command(self) -> bool:
+        await self.registry.send("exit_signal", {"return_code": 0})
+        return False
+
+    async def _handle_help_command(self) -> bool:
+        help_text = (
+            "可用命令:\n"
+            "/queue <消息> - 将消息加入排队列表,在下次回答后处理\n"
+            "\n"
+            "/status - 显示当前状态信息\n"
+            "/save - 保存当前会话状态\n"
+            "/help - 显示此帮助信息\n"
+            "/quit, /exit - 退出程序\n"
+            "@<模型名> - 切换底层LLM模型\n"
+            "\n"
+            "上下文工具:\n"
+            "/context_forget_large_message - 清理大消息\n"
+        )
+        await self._show_runtime_message("INFO", help_text)
+        return False
+
+    async def _handle_status_command(self) -> bool:
+        from .main import Agent
+
+        agent = self.registry.get_member_typechecked("agent", Agent)
+        llm_name, _llm = agent.get_current_llm_info()
+        threshold_info = agent.get_threshold_info()
+
+        from .state_machine import AgentStateMachine
+
+        state_machine = self.registry.get_member_typechecked(
+            "state_machine", AgentStateMachine
+        )
+        status_lines = [f"当前LLM: {llm_name}", f"当前状态: {state_machine.state}"]
+
+        if threshold_info:
+            usage_percent = threshold_info["usage_ratio"] * 100
+            status_lines.append(
+                f"Token使用: {threshold_info['used_tokens']}/{threshold_info['hard_limit']} ({usage_percent:.1f}%)"
+            )
+
+        await self._show_runtime_message("INFO", "\n".join(status_lines))
+        return False
+
+    async def _handle_switch_model(self, model_name: str, msg: UserMessage) -> bool:
+        from .main import Agent
+
+        agent = self.registry.get_member_typechecked("agent", Agent)
+        llm_manager = agent.llm_manager
+
+        await agent.message_processor.add_new_message(msg)
+
+        if model_name == "default":
+            await llm_manager.switch_to_llm(llm_manager.default_llm_name)
+            await self._show_runtime_message("INFO", "已将底层LLM切换为默认LLM")
+        elif model_name in llm_manager.llm_names:
+            await llm_manager.switch_to_llm(model_name)
+            await self._show_runtime_message(
+                "INFO", f"已将底层LLM切换为 {model_name!r}"
+            )
+        else:
+            await self._show_runtime_message(
+                "ERROR",
+                f"错误：LLM名称 {model_name!r} 不存在.可用的LLM包括: {', '.join(llm_manager.llm_names)}",
+            )
+
+        return True
+
+    async def _handle_save_command(self) -> bool:
+        from pathlib import Path
+        from linhai.agent.conversation_save import save_conversation
+
+        conversation_folder = self.registry.get_member_typechecked(
+            "conversation_folder", Path
+        )
+        filepath = conversation_folder / "saved.json"
+
+        await self._show_runtime_message(
+            "INFO", f"Saving conversation to {filepath}..."
+        )
+        await save_conversation(self.registry, filepath)
+        await self._show_runtime_message("INFO", f"Conversation saved to {filepath}")
+        return False
+
+    async def _handle_context_tool_command(self, parsed_input) -> bool:
+        from .main import Agent
+
+        agent = self.registry.get_member_typechecked("agent", Agent)
+
+        await self._show_runtime_message(
+            "INFO", f"正在执行命令: {parsed_input.command}"
+        )
+
+        tool_call = ToolCallMessage(
+            function_name=parsed_input.command,
+            function_arguments={},
+            assert_success=False,
+            with_secret={"in_arguments": [], "in_result": []},
+        )
+
+        await agent.toolcall_processor.call_tool(tool_call, tool_index=1)
+
+        await self._show_runtime_message(
+            "INFO",
+            f"上下文工具命令执行成功: {parsed_input.command}",
+        )
+
+        return True

linhai/agent/conversation.py

@@ -0,0 +1,152 @@
+"""对话管理系统，负责对话历史、大消息、secret等的保存。"""
+
+import json
+import time
+import uuid
+from pathlib import Path
+from typing import List
+
+from linhai.registry import Registry
+from linhai.base import Message
+
+
+def register_conversation_folder(registry: Registry) -> Path:
+    """注册conversation_folder到registry，创建并返回对话目录路径。
+
+    Args:
+        registry: Registry实例
+
+    Returns:
+        创建的对话目录路径
+    """
+    conversation_id = str(uuid.uuid4())
+    base_dir = Path.home() / ".local" / "share" / "linhai" / "conversation"
+    conversation_dir = base_dir / conversation_id
+    conversation_dir.mkdir(parents=True, exist_ok=True)
+
+    (conversation_dir / "cleaned_messages").mkdir(exist_ok=True)
+    (conversation_dir / "large_messages").mkdir(exist_ok=True)
+    (conversation_dir / "long_toolcall").mkdir(exist_ok=True)
+    (conversation_dir / "secret_intercepted").mkdir(exist_ok=True)
+    (conversation_dir / "cron").mkdir(exist_ok=True)
+
+    registry.register_member("conversation_folder", conversation_dir)
+    return conversation_dir
+
+
+def save_context(conversation_dir: Path, messages: List[Message]) -> Path:
+    """保存消息历史到context.json。
+
+    Args:
+        conversation_dir: 对话目录路径
+        messages: 消息列表
+
+    Returns:
+        保存的文件路径
+    """
+    context_file = conversation_dir / "context.json"
+
+    history_data = [
+        {"type": msg.__class__.__name__, "data": msg.to_json()} for msg in messages
+    ]
+
+    with open(context_file, "w", encoding="utf-8") as f:
+        json.dump(history_data, f, ensure_ascii=False, indent=2)
+
+    return context_file
+
+
+def save_cleaned_messages(
+    conversation_dir: Path, messages: List[Message], prefix: str
+) -> Path:
+    """保存被清理的消息到cleaned_messages目录。
+
+    Args:
+        conversation_dir: 对话目录路径
+        messages: 被清理的消息列表
+        prefix: 文件名前缀
+
+    Returns:
+        保存的文件路径
+    """
+    timestamp = int(time.time())
+    filename = f"{prefix}_{timestamp}.json"
+    cleaned_messages_dir = conversation_dir / "cleaned_messages"
+    cleaned_messages_dir.mkdir(parents=True, exist_ok=True)
+    filepath = cleaned_messages_dir / filename
+
+    history_data = [
+        {"type": msg.__class__.__name__, "data": msg.to_json()} for msg in messages
+    ]
+
+    with open(filepath, "w", encoding="utf-8") as f:
+        json.dump(history_data, f, ensure_ascii=False, indent=2)
+
+    return filepath
+
+
+def save_large_message_chunk(
+    conversation_dir: Path, content: str, chunk_index: int
+) -> Path:
+    """保存大消息分块到large_messages目录。
+
+    Args:
+        conversation_dir: 对话目录路径
+        content: 消息内容
+        chunk_index: 分块索引
+
+    Returns:
+        保存的文件路径
+    """
+    timestamp = int(time.time())
+    filename = f"large_message_{timestamp}_{chunk_index}.txt"
+    filepath = conversation_dir / "large_messages" / filename
+
+    filepath.write_text(content, encoding="utf-8")
+    return filepath
+
+
+def save_long_toolcall_output(
+    conversation_dir: Path, content: str, tool_name: str, part_index: int | None = None
+) -> Path:
+    """保存大工具输出到long_toolcall目录。
+
+    Args:
+        conversation_dir: 对话目录路径
+        content: 输出内容
+        tool_name: 工具名称
+        part_index: 分块索引，None表示不分块
+
+    Returns:
+        保存的文件路径
+    """
+    timestamp = int(time.time())
+    if part_index is not None:
+        filename = f"{tool_name}_{timestamp}_part{part_index}.txt"
+    else:
+        filename = f"{tool_name}_{timestamp}.txt"
+    filepath = conversation_dir / "long_toolcall" / filename
+
+    filepath.write_text(content, encoding="utf-8")
+    return filepath
+
+
+def save_secret_intercepted(
+    conversation_dir: Path, content: str, tool_name: str
+) -> Path:
+    """保存被拦截的含secret内容到secret_intercepted目录。
+
+    Args:
+        conversation_dir: 对话目录路径
+        content: 被拦截的内容
+        tool_name: 工具名称
+
+    Returns:
+        保存的文件路径
+    """
+    timestamp = int(time.time())
+    filename = f"secret_intercepted_{timestamp}_{tool_name}.txt"
+    filepath = conversation_dir / "secret_intercepted" / filename
+
+    filepath.write_text(content, encoding="utf-8")
+    return filepath

linhai/agent/conversation_save.py

@@ -0,0 +1,58 @@
+import json
+from pathlib import Path
+
+from linhai.agent.savable_state import SavableState
+
+CONVERSATION_VERSION = "1"
+
+
+def _get_savable_members(registry) -> dict[str, SavableState]:
+    result = {}
+    for name, obj in registry.members.items():
+        if isinstance(obj, SavableState):
+            result[name] = obj
+    return result
+
+
+async def save_conversation(registry, filepath: Path) -> None:
+    savable = _get_savable_members(registry)
+    data = {
+        "version": CONVERSATION_VERSION,
+        "members": {name: obj.serialize() for name, obj in savable.items()},
+    }
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text(
+        json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+
+
+async def restore_conversation(registry, filepath: Path) -> None:
+    content = filepath.read_text(encoding="utf-8")
+    data = json.loads(content)
+
+    if data.get("version") != CONVERSATION_VERSION:
+        raise RuntimeError(
+            f"conversation version mismatch: expected {CONVERSATION_VERSION!r}, got {data.get('version')!r}"
+        )
+
+    saved_members = set(data.get("members", {}).keys())
+    savable = _get_savable_members(registry)
+    current_members = set(savable.keys())
+
+    missing = current_members - saved_members
+    extra = saved_members - current_members
+    if missing or extra:
+        parts = []
+        if missing:
+            parts.append(f"missing members: {sorted(missing)}")
+        if extra:
+            parts.append(f"extra members: {sorted(extra)}")
+        raise RuntimeError("conversation restore failed: " + ", ".join(parts))
+
+    for name, obj in savable.items():
+        obj.restore_from(data["members"][name])
+
+    from linhai.agent.lifecycle import Lifecycle
+
+    lifecycle = registry.get_member_typechecked("lifecycle", Lifecycle)
+    await lifecycle.after_conversation_restore.trigger()