IlinaEngine 0.8.1__py3-none-any.whl

IlinaEngine/__init__.py

@@ -0,0 +1,2 @@
+from .engine import Engine
+from .type import NodeEvent, NodeEventTypes, IlinaMessage, IlinaToolCall

IlinaEngine/_config_models.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel
+
+class IlinaConfig(BaseModel):
+    """ 文件夹下的 .ilinaconfig 内的数据模型 """
+    workpath: str|None = None
+    open_or_alarm: bool = False  # 如果是 True 倾向于打开文件，如果是 False 倾向于发送通知
+
+class MCPConfig(BaseModel):
+    command: str
+    args: list[str]
+
+class ModelConfig(BaseModel):
+    base_url: str
+    api_key: str
+    model_name: str
+
+class AIConfig(BaseModel):
+    """ 模型配置 """
+    main_model: ModelConfig = ModelConfig(
+        base_url='http://localhost:11434/v1/', 
+        api_key='sk-xxx', 
+        model_name='qwen3-vl:4b'
+    )
+
+    sub_model: ModelConfig = ModelConfig(
+        base_url='http://localhost:11434/v1/', 
+        api_key='sk-xxx', 
+        model_name='qwen3-vl:4b'
+    )
+
+    mcps: dict[str, MCPConfig] = {}
+    default_system_prompt_template: str = '当前工作目录为 {{workpath}}，当你编辑文件之后，你应该{{open_or_alarm}}'

IlinaEngine/_ilina_message.py

@@ -0,0 +1,25 @@
+# Ilina Message
+from typing import Literal
+from pydantic import BaseModel
+
+class IlinaToolDefinition(BaseModel):
+    """ 工具定义 """
+    name: str  # 工具名称
+    description: str  # 工具说明
+    arguments: dict[str, object]  # 参数的 JSON Schema
+
+class IlinaToolCall(BaseModel):
+    """ 工具调用 """
+    name: str = ''
+    arguments: str = ''
+    tool_call_id: str = ''
+
+class IlinaMessage(BaseModel):
+    """ 对话消息 """
+    role: Literal['user', 'assistant', 'system', 'tool', 'error']
+    content: str = ''
+    reasoning_content: str = ''  # 仅在 assistant 中使用
+    tool_calls: list[IlinaToolCall] = []  # 仅在 assistant 中使用
+    tool_call_id: str = ''  # 仅在 tool 中使用
+    tool_name: str = ''  # 保存工具名，仅在 tool 中使用
+    # tool_readable_content: str = ''  # 返回一个人类可读的消息，如果指定了这一项，那么渲染时建议用这个替换content

IlinaEngine/call_openai.py

@@ -0,0 +1,222 @@
+# 调用 API
+
+from enum import Enum
+from typing import Generator
+from logging import getLogger
+from dataclasses import dataclass
+from FovesConfig import ConfigLoader
+
+
+# from tools import Toolset
+from .tree import Node
+from .sync_mcp import MCPLoader
+from ._config_models import AIConfig
+from ._ilina_message import IlinaMessage, IlinaToolCall
+from openai import OpenAI
+from openai.types.chat import (
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionMessageFunctionToolCallParam,
+    ChatCompletionUserMessageParam,
+    ChatCompletionSystemMessageParam,
+    ChatCompletionToolMessageParam,
+
+    ChatCompletionMessageParam,
+    ChatCompletionChunk,
+    ChatCompletion,
+)
+
+class NodeEventTypes(str, Enum):
+    CREATED = 'CREATED'
+    UPDATED = 'UPDATED'
+    FINISNED = 'FINISHED'
+    ERROR = 'ERROR'
+
+@dataclass
+class NodeEvent:
+    """ 节点发生变化的事件 """
+    node: Node
+    _type: NodeEventTypes
+
+class OpenAIClient:
+    def __init__(self, is_main_model: bool, mcp_loader: MCPLoader):
+        with ConfigLoader('./configs/ai.json', AIConfig) as config:
+            if is_main_model:
+                modelcfg = config.main_model
+            else:
+                modelcfg = config.sub_model
+        self.client = OpenAI(base_url=modelcfg.base_url, api_key=modelcfg.api_key)
+        self.model = modelcfg.model_name
+        # self.toolset = Toolset()
+        self.mcp_loader = mcp_loader
+        self.log = getLogger(f"Model_{self.model}")
+    
+    def ilina_to_openai(self, ilina: IlinaMessage) -> ChatCompletionMessageParam|None:
+        """ 将 IlinaMessage 转化为  ChatCompletionMessageParam, 会过滤掉 error 类型"""
+        if ilina.role == 'assistant':
+            tool_calls = []
+            for tool_call in ilina.tool_calls:
+                tool_calls.append(ChatCompletionMessageFunctionToolCallParam(
+                    type='function',
+                    id=tool_call.tool_call_id,
+                    function={
+                        'name': tool_call.name,
+                        'arguments': tool_call.arguments
+                    }
+                ))
+
+            if len(tool_calls) > 0:
+                return ChatCompletionAssistantMessageParam(
+                    role='assistant',
+                    content=ilina.content,
+                    tool_calls=tool_calls
+                )
+            else:
+                return ChatCompletionAssistantMessageParam(
+                    role='assistant',
+                    content=ilina.content,
+                )
+        
+        elif ilina.role == 'user':
+            return ChatCompletionUserMessageParam(
+                role='user',
+                content=ilina.content
+            )
+        
+        elif ilina.role == 'system':
+            return ChatCompletionSystemMessageParam(
+                role='system',
+                content=ilina.content
+            )
+        
+        elif ilina.role == 'tool':
+            return ChatCompletionToolMessageParam(
+                role='tool',
+                content=ilina.content,
+                tool_call_id=ilina.tool_call_id
+            )
+        
+        elif ilina.role == 'error':
+            return None
+
+    def chat(self, messages: list[IlinaMessage]) -> Generator[NodeEvent, None, None]:
+        """ 调用模型，会首先用生成器返回流失输出结果，最后return合并的Node """
+        new_messages: list[IlinaMessage] = []  # 存储本轮调用生成的消息
+        stop_reason: str = ''  # 存储停止原因
+        self.log.info('开始调用模型')
+        while stop_reason != 'stop':
+            # 发起请求
+            self.log.info('发起 API 请求')
+            try:
+                # 首先将 messages 转换成 openai 格式
+                openai_messages = []
+                for item in map(self.ilina_to_openai, messages + new_messages):
+                    if item is not None:
+                        openai_messages.append(item)
+
+                # 发起调用
+                res = self.client.chat.completions.create(
+                    messages=openai_messages,
+                    model=self.model,
+                    tools=self.mcp_loader.get_list_openai(),
+                    stream=True
+                ) 
+            except Exception as e:
+                yield NodeEvent(Node(IlinaMessage(role='error', content=f'{e}')), NodeEventTypes.ERROR)
+                return
+            
+            assistant_node = Node(IlinaMessage(role='assistant'))
+            # 传递节点开始事件
+            yield NodeEvent(assistant_node, NodeEventTypes.CREATED)
+
+            # 逐帧解析
+            tool_call_nodes: dict[str, Node] = {}  # 保存工具 ID 对应的节点
+            for chunk in res:
+                chunk: ChatCompletionChunk
+                delta = chunk.choices[0].delta
+
+                # 保存流式信息
+                if delta.content:
+                    assistant_node.message.content += delta.content
+                    yield NodeEvent(assistant_node, NodeEventTypes.UPDATED)
+
+                # 保存思考信息                
+                reasoning_content_delta = ''
+                try:
+                    self.log.debug(delta)
+                    if hasattr(delta, 'reasoning_content'):  # Deepseek：用 reasoning_content 输出思考流
+                        reasoning_content_delta = delta.reasoning_content or '' # pyright: ignore[reportAttributeAccessIssue]
+                    elif hasattr(delta, 'reasoning'):  # Ollama: 用 reasoning 输出思考流
+                        reasoning_content_delta = delta.reasoning or '' # pyright: ignore[reportAttributeAccessIssue]
+                except AttributeError:  # 如果获取不到，也设置成空
+                    reasoning_content_delta = ''
+                    
+                assistant_node.message.reasoning_content += reasoning_content_delta
+                yield NodeEvent(assistant_node, NodeEventTypes.UPDATED)
+                
+                # 保存工具调用
+                if delta.tool_calls:  # 如果工具调用不为 None
+                    for tool_call in delta.tool_calls:  # 对于工具调用列表中的每个工具
+                        try:  # 尝试直接追加到现有索引处
+                            if tool_call.id:  # 覆写 ID
+                                assistant_node.message.tool_calls[tool_call.index].tool_call_id = tool_call.id
+
+                            if tool_call.function:  # 更新 function
+                                if tool_call.function.name:  # 覆写 name
+                                    assistant_node.message.tool_calls[tool_call.index].name = tool_call.function.name
+                                    if tool_call.id:
+                                        tool_call_nodes[tool_call.id].message.tool_name = tool_call.function.name
+                                if tool_call.function.arguments:  # 追加 arguments
+                                    assistant_node.message.tool_calls[tool_call.index].arguments += tool_call.function.arguments
+                            
+                            yield NodeEvent(assistant_node, NodeEventTypes.UPDATED)
+
+                        except IndexError:  # 不存在则新增
+                            assert tool_call.id is not None
+                            assert tool_call.function is not None
+                            assert tool_call.function.name is not None
+                            assert tool_call.function.arguments is not None
+                            assistant_node.message.tool_calls.append(IlinaToolCall(
+                                tool_call_id=tool_call.id,
+                                name=tool_call.function.name,
+                                arguments=tool_call.function.arguments
+                            ))
+                            tool_call_node = Node(IlinaMessage(role='tool', tool_call_id=tool_call.id, tool_name=tool_call.function.name))
+                            tool_call_nodes[tool_call.id] = tool_call_node
+                            yield NodeEvent(tool_call_node, NodeEventTypes.CREATED)
+                            yield NodeEvent(assistant_node, NodeEventTypes.UPDATED)
+
+            # 更新停止原因
+            if chunk.choices[0].finish_reason:
+                stop_reason = chunk.choices[0].finish_reason
+            self.log.info(f'停止原因：{stop_reason}')
+
+            # 添加助手信息
+            new_messages.append(assistant_node.message)
+            yield NodeEvent(assistant_node, NodeEventTypes.FINISNED)
+
+            # 调用并添加工具信息
+            # 返回流式传输的工具块
+            for call in assistant_node.message.tool_calls:
+                self.log.info(f'调用工具 {call.name}')
+                result = self.mcp_loader.call(call)
+                self.log.info(f'工具返回 {result}')
+                # 根据 ID 获取对应的节点并进行修改和发送
+                tool_call_node = tool_call_nodes[call.tool_call_id]
+                tool_call_node.message.content = result
+                # 向新消息列表中添加工具消息
+                new_messages.append(tool_call_node.message)
+                yield NodeEvent(tool_call_node, NodeEventTypes.UPDATED)
+                yield NodeEvent(tool_call_node, NodeEventTypes.FINISNED)
+
+            self.log.debug(f'当前的new_messages:\n{'\n'.join([str(m) for m in new_messages])}')
+
+    def once(self, sysprompt: str, user_input: str) -> str|None:
+        """ 进行一次调用 """ 
+        res: ChatCompletion = self.client.chat.completions.create(
+            messages=[
+                {'role': 'system', 'content': sysprompt},
+                {'role': 'user', 'content': user_input}
+            ],
+            model=self.model,
+        )
+        return res.choices[0].message.content

IlinaEngine/engine.py

@@ -0,0 +1,147 @@
+# 引擎层
+import logging
+from uuid import UUID
+from typing import Generator
+
+from FovesLog import LoggedTask
+from .tree import Tree, Node
+from .call_openai import *
+from ._ilina_message import IlinaMessage
+from .exceptions import *
+
+class Engine:
+    def __init__(self, filename: str) -> None:
+        self.log = logging.getLogger('对话引擎')
+        self.log.setLevel(logging.INFO)
+
+        with LoggedTask('初始化', logger=self.log) as task:
+            self.tree = Tree(filename)
+            task.checkpoint(f'建立文件树')
+            self.mcp_loader = MCPLoader()
+            task.checkpoint(f'建立MCP工具')
+            self.main_model = OpenAIClient(True, self.mcp_loader)
+    
+    @property
+    def workpath(self) -> str:
+        """ 获取工作目录 """
+        return str(self.tree.workpath)
+
+    @property
+    def name(self) -> str:
+        """ 获取树的名字 """
+        return self.tree.name
+    
+    @name.setter
+    def name(self, value: str):
+        self.tree.name = value
+    
+    def set_name(self, new_name: str):
+        """ 设置名字的函数版本，适用于某些无法使用属性赋值的情况
+        
+        说的就是你, lambda 语句
+        """
+        self.name = new_name
+    
+    @property
+    def message_list(self) -> tuple[list[UUID], list[IlinaMessage]]:
+        """ 获取当前的消息链 """
+        return self.tree.root_node._to_message_list()
+
+    @property
+    def readonly_root_node(self) -> Node:
+        """ 获取根节点。注意：只应该用来获取树结构 """
+        return self.tree.root_node
+
+    @property
+    def readonly_leaves(self) -> list[Node]:
+        """ 获取所有叶子节点。注意：只应该用来获取树结构 """
+        return self.tree.root_node._get_leaves()
+
+    @property
+    def readonly_now_node(self) -> UUID:
+        """ 获取当前最新节点的 UUID """
+        return self.tree.root_node._get_now().uuid
+
+    def get_message_by_uuid(self, uuid: UUID) -> IlinaMessage:
+        """ 通过 UUID 获取消息内容 """
+        return self.tree.uuid_to_node_table[uuid].message
+
+    def get_parent(self, uuid: UUID) -> UUID:
+        """ 获取某个节点的父节点。对于根节点和其他找不到父节点的节点会报错 """
+        parent = self.tree.root_node._get_parent(uuid)
+        if parent:
+            return parent
+        else:
+            raise ParentNotFoundError(uuid)
+
+    def edit_node(self, target: UUID, new_message: IlinaMessage) -> UUID:
+        """ 修改节点内容，不会实际修改，而是作为父节点的新子节点插入，会返回新节点的 UUID """
+        new_node = Node(new_message)
+        with self.tree as tree:
+            tree.insert(new_node, self.get_parent(target))
+        return new_node.uuid
+
+    def invoke(self, start_from: UUID|None=None) -> Generator[NodeEvent, bool, None]:
+        """ 将当前的对话发送给主模型，并获取其回复，默认从最新分支开始
+            并会自动将 NodeFinished 事件的节点添加到节点树中
+            如果指定了 start_from，会从那里截断并插入节点。
+            如果 start_from 不在当前分支，会首先切换过去。
+        """
+        self.log.info(f'调用 AI')
+
+        # 如果未指定 start_from，就设置到当前的末尾
+        if start_from is None:
+            start_from = self.readonly_now_node
+
+        # 如果不在当前分支，就切换过去
+        uuids, messages = self.message_list
+        if start_from not in uuids:
+            self.move_to_node(start_from)
+            uuids, messages = self.message_list
+
+        # 如果节点类型是 assistant，就获从其父节点出截断，否则从节点处截断
+        if self.get_message_by_uuid(start_from).role == 'assistant':
+            messages = messages[:uuids.index(start_from)]
+            append_point_uuid = self.get_parent(start_from)
+        else:
+            messages = messages[:uuids.index(start_from) + 1]
+            append_point_uuid = start_from
+
+        # 调用并进行处理
+        for event in self.main_model.chat(messages):
+            stop: bool|None = yield event
+
+            if event._type == NodeEventTypes.ERROR:
+                stop = True
+            elif event._type == NodeEventTypes.FINISNED:
+                with self.tree as tree:
+                    tree.insert(event.node, append_point_uuid)
+                    append_point_uuid = event.node.uuid
+            
+            if stop:
+                return
+    
+    def send(self, message: IlinaMessage) -> UUID:
+        """ 将消息插入到当前节点之后，会返回新节点的 UUID """
+        self.log.info(f'插入用户消息...')
+        new_node = Node(message)
+        with self.tree as tree:
+            if not tree.insert(new_node, tree.now_node.uuid):
+                raise NodeNotFoundError(tree.now_node.uuid)
+        return new_node.uuid
+
+    
+    def move_to_node(self, uuid: UUID):
+        """ 将指针设置到指定 UUID 所在分支的末尾 """
+        self.log.info(f'移动指针到 {uuid}')
+        with self.tree as tree:
+            if not tree.set_pointer(uuid):
+                raise NodeNotFoundError(uuid)
+
+    
+    def delete_node(self, uuid: UUID):
+        """ 删除指定 UUID 的节点 """
+        self.log.info(f'删除节点： {uuid}')
+        with self.tree as root_node:
+            if not root_node.delete(uuid):
+                raise NodeNotFoundError(uuid)

IlinaEngine/exceptions.py

@@ -0,0 +1,23 @@
+# 自定义异常
+
+from uuid import UUID
+
+class NodeNotFoundError(Exception):
+    """ 未找到指定 UUID 所对应的节点 """
+    def __init__(self, uuid: UUID, *args: object) -> None:
+        message = f'未找到 UUID 为 {uuid} 的节点'
+        super().__init__(message, *args)
+        self.message = message
+    
+    def __str__(self):
+        return self.message
+
+class ParentNotFoundError(Exception):
+    """ 未找到指定 UUID 所对应的父节点 """
+    def __init__(self, uuid: UUID, *args: object) -> None:
+        message = f'未找到 UUID 为 {uuid} 的节点的父节点'
+        super().__init__(message, *args)
+        self.message = message
+    
+    def __str__(self):
+        return self.message

IlinaEngine/sync_mcp.py

@@ -0,0 +1,173 @@
+# sync_mcp.py
+import json
+import asyncio
+import threading
+import logging
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from openai.types.chat import ChatCompletionFunctionToolParam
+from openai.types.shared_params import FunctionDefinition
+from FovesConfig import ConfigLoader
+
+from ._ilina_message import IlinaToolDefinition, IlinaToolCall
+from ._config_models import AIConfig
+from FovesLog import LoggedTask
+
+class SyncMcpClient:
+    """
+    同步 MCP 客户端 — 内部维护一个后台事件循环，对外暴露同步方法。
+    可以直接嵌入同步的模型调用循环。
+    """
+
+    def __init__(self, name: str):
+        self._loop: asyncio.AbstractEventLoop|None = None
+        self._thread: threading.Thread|None = None
+        self._session: ClientSession|None = None
+        self._ready = threading.Event()
+        self._ctx = None
+        self.name = name
+        self.log = logging.getLogger('MCP Client')
+        logging.getLogger('mcp').setLevel(logging.DEBUG)
+
+    # ── 连接 ──────────────────────────────────
+    def connect(self, command: str, args: list[str]):
+        """
+        启动后台线程，连接 MCP Server。
+        调用会阻塞直到握手完成。
+        """
+
+        async def _connect():
+            server_params = StdioServerParameters(
+                command=command,
+                args=args,
+                env={"PYTHONUNBUFFERED": "1"},  # 禁用 stdout 缓冲，确保 JSON-RPC 响应即时发送
+            )
+            # 注意：不能用 async with，因为要跨调用保持连接
+            self._ctx = stdio_client(server_params)
+            read, write = await self._ctx.__aenter__()
+            self._session = ClientSession(read, write)
+            await self._session.__aenter__()
+            await self._session.initialize()
+            self._ready.set()  # 通知主线程：好了
+
+        def _run_loop():
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+            self._loop.run_until_complete(_connect())
+            # 连接完成后，事件循环继续跑，处理后续调用
+            self._loop.run_forever()
+
+        self._thread = threading.Thread(target=_run_loop, daemon=True)
+        self._thread.start()
+        self._ready.wait()  # 阻塞直到连接完成
+
+    # ── 工具列表 ──────────────────────────────
+    def list_tools(self) -> list[IlinaToolDefinition]:
+        """同步获取工具列表"""
+        async def _list():
+            assert self._session is not None
+            result = await self._session.list_tools()
+            return [
+                IlinaToolDefinition(
+                    name=self.name + '_' + t.name,
+                    description=t.description or '',
+                    arguments=t.inputSchema
+                ) for t in result.tools
+            ]
+        return self._run(_list())
+
+    # ── 调用工具 ★ 你最常用的 ─────────────────
+    def call_tool(self, name: str, arguments: dict) -> str:
+        """
+        同步调用 MCP 工具，返回文本结果。
+        直接嵌入你的工具调用循环。
+        """
+        self.log.info(f'正在调用工具：{name}, args:\n{arguments}')
+        # 去除 MCP 服务器名的前缀
+        name = name[len(self.name) + 1:]
+        async def _call():
+            assert self._session is not None
+
+            self.log.debug(f'调用工具')
+            result = self._session.call_tool(name, arguments)
+            self.log.debug(f'await 等待 result')
+            result = await result
+            # [2026/06/07] 无论如何都不要把上面的调用方式改成下面这种。会卡住。
+            # result = await self._session.call_tool(name, arguments)
+            self.log.debug(f'{result=}')
+
+            # 优先结构化输出
+            if result.structuredContent:
+                return str(result.structuredContent)
+            # 降级：拼接文本
+            self.log.warning(f'降级了消息输出，使用拼接文本')
+            parts = []
+            for block in result.content:
+                if hasattr(block, "text"):
+                    parts.append(block.text) # pyright: ignore[reportAttributeAccessIssue]
+                
+            self.log.debug(f'return={"\\n".join(parts) if parts else str(result.content)}')
+            return "\n".join(parts) if parts else str(result.content)
+
+        return self._run(_call())
+
+    # ── 关闭 ──────────────────────────────────
+    def close(self):
+        """清理资源"""
+        async def _close():
+            if self._session:
+                await self._session.__aexit__(None, None, None)
+            if self._ctx:
+                await self._ctx.__aexit__(None, None, None) # pyright: ignore[reportGeneralTypeIssues]
+
+        if self._loop and self._loop.is_running():
+            self._loop.call_soon_threadsafe(self._loop.stop)
+        if self._thread:
+            self._thread.join(timeout=5)
+
+    # ── 内部 ──────────────────────────────────
+    def _run(self, coro):
+        """把协程丢到后台事件循环里跑，阻塞等结果"""
+        assert self._loop is not None
+        fut = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return fut.result()  # 阻塞直到完成
+
+
+class MCPLoader:
+    ''' 负责管理和调用 MCP 工具 '''
+    def __init__(self):
+        self.log = logging.getLogger(f'MCP Loader')
+        self.log.setLevel(logging.INFO)
+        #  从配置中读取MCP工具
+        self.clients: dict[str, SyncMcpClient] = {}
+        with ConfigLoader('./configs/ai.json', AIConfig) as config:
+            with LoggedTask('加载 MCP 服务', logger=self.log) as task:
+                try:
+                    for mcp_name in config.mcps:
+                        self.clients[mcp_name] = SyncMcpClient(mcp_name)
+                        self.clients[mcp_name].connect(config.mcps[mcp_name].command, config.mcps[mcp_name].args)
+                except TypeError:
+                    self.clients = {}
+    
+    def get_list_openai(self) -> list[ChatCompletionFunctionToolParam]:
+        """ 返回可以传给OpenAI模型调用的列表 """
+        total: list[ChatCompletionFunctionToolParam] = []
+        for client in self.clients.values():
+            ilina_tools = client.list_tools()
+            for tool in ilina_tools:
+                total.append(ChatCompletionFunctionToolParam(
+                    type='function',
+                    function=FunctionDefinition(
+                        name=tool.name,
+                        description=tool.description,
+                        parameters=tool.arguments,
+                )))
+        return total
+
+    def call(self, call: IlinaToolCall) -> str:
+        """ 调用MCP工具 """
+        for client_name in self.clients:
+            if call.name.startswith(client_name):
+                return self.clients[client_name].call_tool(call.name, json.loads(call.arguments))
+        return f'未找到工具“{call.name}”，请检查名称'

IlinaEngine/sysprompt.py

@@ -0,0 +1,19 @@
+# 负责处理系统提示相关的内容
+import os
+from FovesConfig import ConfigLoader
+from ._config_models import AIConfig
+from ._ilina_message import IlinaMessage
+
+def load_default_sysprompt(replace_dict: dict[str, str]) -> IlinaMessage:
+    """ 警告：尽量减少向系统提示里放置的东西。 """
+    with ConfigLoader('./configs/ai.json', AIConfig) as config:
+        if os.path.exists(config.default_system_prompt_template):
+            with open(config.default_system_prompt_template, 'r', encoding='utf-8') as f:
+                prompt = f.read()
+        else:
+            prompt = config.default_system_prompt_template
+    
+    for key in replace_dict:
+        prompt = prompt.replace('{{'+ key +'}}', replace_dict[key])
+
+    return IlinaMessage(role='system', content=prompt)

IlinaEngine/tools.py

@@ -0,0 +1,72 @@
+# 管理工具和技能。
+import json
+import inspect
+from pydantic import create_model
+from typing import Callable, get_type_hints
+from ._ilina_message import IlinaMessage
+
+def func_to_openai_tool(func, description: str|None = None):
+    """
+    把一个 Python 函数直接变成 OpenAI tools 列表中的一项。
+
+    OpenAI tools 格式:
+    {
+        "type": "function",
+        "function": {
+            "name": "...",
+            "description": "...",
+            "parameters": { ... JSON Schema ... }
+        }
+    }
+    """
+    sig = inspect.signature(func)
+    hints = get_type_hints(func)
+
+    # 工具描述：显式传入 > docstring 第一段
+    desc = description
+    if desc is None and func.__doc__:
+        desc = func.__doc__.split("\n\n")[0].strip()
+
+    # 构建参数字段
+    fields = {}
+    for name, param in sig.parameters.items():
+        if name in ("self", "cls"):
+            continue
+        py_type = hints.get(name, str)
+        default = ... if param.default is inspect.Parameter.empty else param.default
+        fields[name] = (py_type, default)
+
+    Model = create_model(f"{func.__name__}_params", **fields)
+    params_schema = Model.model_json_schema()
+
+    return {
+        "type": "function",
+        "function": {
+            "name": func.__name__,
+            "description": desc or "",
+            "parameters": params_schema,
+        }
+    }
+
+class Toolset:
+    def __init__(self):
+        self.tool_functions: dict[str, Callable] = {}  # 键是工具名称，值是工具函数。
+        self.tool_explains: dict[str, dict] = {}  # 键是工具名称，值是工具说明。
+    
+    def to_toollist(self) -> list[dict]:
+        return list(self.tool_explains.values())
+    
+    def add_tool(self, func: Callable):
+        tool_name = func.__name__
+        self.tool_functions[tool_name] = func
+        self.tool_explains[tool_name] = func_to_openai_tool(func)
+    
+    def call_tool(self, tools: list[list[str]]) -> list[IlinaMessage]:
+        results = []
+        for tool in tools:
+            name, param, call_id = tool
+            func = self.tool_functions[name]
+            param_dict = json.loads(param)
+            result = func(**param_dict)
+            results.append(IlinaMessage(role='tool', content=result, tool_call_id=call_id))
+        return results

IlinaEngine/tree.py

@@ -0,0 +1,344 @@
+import os
+import json
+import copy
+import time
+import logging
+from uuid import UUID, uuid4
+from typing import TypedDict, Required, get_type_hints, Generator
+from pathlib import Path
+from pydantic import ValidationError
+from FovesLog import LoggedTask
+from FovesConfig import ConfigLoader
+
+from .sysprompt import load_default_sysprompt
+from ._ilina_message import IlinaMessage
+from ._config_models import IlinaConfig
+
+class Node:
+    def __init__(self, 
+                 message: IlinaMessage,
+                 uuid: UUID|None = None,
+                 pointer: UUID|None = None,
+                 children: list["Node"]|None = None,
+                 ):
+        
+        self.message: IlinaMessage = copy.deepcopy(message)
+        self.uuid: UUID = uuid or uuid4()
+        self.pointer: UUID|None = pointer or None
+        self.children: list[Node] = copy.deepcopy(children) or []
+    
+    def _get_pointed_child(self) -> "Node|None":
+        """ 返回指向的节点 """
+        for child in self.children:
+            if child.uuid == self.pointer:
+                return child
+        return None
+
+    def _get_leaves(self) -> list["Node"]:
+        """ 返回所有的叶子节点 """
+        if len(self.children) == 0:
+            return [self]
+        else:
+            leaves = []
+            for child in self.children:
+                leaves += child._get_leaves()
+            return leaves
+
+    def _insert(self, new_node: "Node", uuid: UUID) -> bool:
+        """ 在 uuid 的节点新增一个子节点 new_node，会自动向下搜索。如果没有找到，就会返回 False"""
+        if self.uuid == uuid:
+            self.children.append(new_node)
+            self.pointer = new_node.uuid
+            return True
+        else:
+            for child in self.children:
+                if child._insert(new_node, uuid):
+                    return True
+            return False
+    
+    def _set_pointer(self, uuid: UUID) -> bool:
+        """ 设置指针到某个 UUID 的节点，会自动向下搜索。如果没有找到，就会返回 False，会自动设置整个链路的指针 """
+        if self.uuid == uuid:
+            return True
+        else:
+            for child in self.children:
+                if child._set_pointer(uuid):
+                    self.pointer = child.uuid
+                    return True
+            return False
+    
+    def _delete(self, uuid: UUID) -> bool:
+        """ 删除某个 UUID 的节点，会自动向下搜索。如果没有找到，就会返回 False """
+        length = len(self.children)
+        self.children = list(filter(lambda child: child.uuid != uuid, self.children))
+        # 移动指针
+        if self.pointer not in self.children:
+            if len(self.children) == 0:
+                self.pointer = None
+            else:
+                self.pointer = self.children[0].uuid
+
+        if len(self.children) < length:
+            return True
+        else:
+            for child in self.children:
+                if child._delete(uuid):
+                    return True
+            return False
+        
+    def _get_parent(self, uuid: UUID) -> UUID|None:
+        """ 返回指定节点的父节点的 UUID，None 表示未找到 """
+        for child in self.children:
+            if child.uuid == uuid:
+                return self.uuid
+            else:
+                result = child._get_parent(uuid)
+                if result:
+                    return result
+    
+    def _get_now(self) -> 'Node':
+        """ 返回当前指向的最深的节点 """
+        for child in self.children:
+            if child.uuid == self.pointer:
+                return child._get_now()
+        return self
+    
+    def walk(self) -> Generator["Node", None, None]:
+        yield self
+        for child in self.children:
+            yield from child.walk()
+
+    def __hash__(self) -> int:
+        return hash(self.uuid)
+    
+    def __eq__(self, value: object) -> bool:
+        return (isinstance(value, Node) and self.uuid == value.uuid)
+
+    def __str__(self) -> str:
+        s = f'[{self.message.role}]: {self.message.content}\n'
+        for child in self.children:
+            if child.uuid == self.pointer:
+                s += str(child)
+        return s
+
+    def __repr__(self) -> str:
+        role = self.message.role
+        content = self.message.content
+        if isinstance(content, list):
+            content = "[...]"
+        preview = str(content)[:20].replace('\n', '\\n') + ("..." if len(str(content)) > 20 else "")
+        result = f'Node [{role}] {preview}  ({str(self.uuid)})'
+        if not self.children:
+            return result
+        for i, child in enumerate(self.children):
+            is_last = (i == len(self.children) - 1)
+            is_pointer = (child.uuid == self.pointer)
+            branch = '└── ' if is_last else '├── '
+            indent = '    ' if is_last else '│   '
+            marker = '▶ ' if is_pointer else ''
+            child_lines = repr(child).split('\n')
+            result += '\n' + branch + marker + child_lines[0]
+            for line in child_lines[1:]:
+                result += '\n' + indent + line
+        return result  
+    
+    def _to_message_list(self) -> tuple[list[UUID], list[IlinaMessage]]:
+        """ 将现在的列表转化为可以传递给 AI 的消息列表 """
+        uuids = [self.uuid]
+        messages = [self.message]
+        for child in self.children:
+            if child.uuid == self.pointer:
+                new_uuid, new_messages = child._to_message_list()
+                uuids += new_uuid
+                messages += new_messages
+        return (uuids, messages)
+
+    def _to_list(self) -> list['Node']:
+        """ 获取当前所指向的节点链 """
+        s: list[Node] = [self]
+        for child in self.children:
+            if child.uuid == self.pointer:
+                s += child._to_list()
+        return s
+
+def node_json_dump(obj):
+    if isinstance(obj, Node):
+        return {
+            "message": obj.message.model_dump(),
+            "uuid": str(obj.uuid),
+            "pointer": str(obj.pointer) if obj.pointer else None,
+            "children": [node_json_dump(child) for child in obj.children],
+        }
+    else:
+        return obj
+
+def node_json_load(obj):
+    if isinstance(obj, dict):
+        if "message" in obj:
+            return Node(
+                message=IlinaMessage(**obj["message"]),  
+                uuid=UUID(obj["uuid"]),
+                pointer=UUID(obj["pointer"]) if obj["pointer"] else None,
+                children=[node_json_load(child) for child in obj["children"]], # pyright: ignore[reportArgumentType]
+            )
+        else:
+            return obj
+    else:
+        return obj
+
+class SaveData(TypedDict):  # 这是保存的文件里面的内容
+    create_time: Required[int|float]
+    root_node: Required[Node]
+
+class Tree:
+    """ 对话树，会同步到文件 """
+    def __init__(self, full_path: str|Path):  # 创建新的树，或者从文件加载树。
+        self.log = logging.getLogger(f'对话树')
+        self.log.setLevel(logging.INFO)
+        if isinstance(full_path, str):
+            full_path = Path(full_path)
+        self._update_paths(full_path)
+        self.uuid_to_node_table: dict[UUID, Node] = {}
+        self._load()
+    
+    def _update_paths(self, new_path: Path): 
+        """ 修改树中的各种路径 """
+        self.full_path: Path = new_path
+        self.workpath: Path = new_path.parent
+        self.file_name: str = new_path.stem
+
+    @property
+    def name(self) -> str:
+        return self.file_name
+
+    @name.setter
+    def name(self, value: str):
+        new_path = self.full_path.with_stem(value)
+        if self.full_path.is_file():
+            self.full_path.rename(new_path)
+        self._update_paths(new_path)
+        self._save()
+    
+    @property
+    def root_node(self) -> Node:
+        return self.save_data["root_node"]
+
+    def insert(self, new_node: "Node", uuid: UUID) -> bool:
+        """ 会同步更新 UUID 到节点映射表的 insert
+        不要直接调用根节点的 _insert
+        """
+        if self.root_node._insert(new_node, uuid):
+            self.uuid_to_node_table[new_node.uuid] = new_node
+            return True
+        else:
+            return False
+    
+    def delete(self, uuid: UUID) -> bool:
+        """ 会同步更新 UUID 到节点映射表的删除
+        不要直接调用根节点的 _delete
+        如果没找到返回 False
+        
+        """
+        if self.root_node._delete(uuid):
+            del self.uuid_to_node_table[uuid]
+            return True
+        else:
+            return False
+
+    @property
+    def now_node(self) -> Node:
+        """ 获取当前指向的叶子节点 """
+        return self.root_node._get_now()
+
+    def set_pointer(self, uuid: UUID) -> bool:
+        """ 设置pointer """
+        return self.root_node._set_pointer(uuid)
+
+    def _save(self) -> None:
+        """ 将 save_data 同步到文件 """
+        with LoggedTask('将树写入到文件', logger=self.log):
+            os.makedirs(self.full_path.parent, exist_ok=True)
+            with open(self.full_path, 'w', encoding='utf-8') as f:
+                json.dump(self.save_data, f, default=node_json_dump, indent=4, ensure_ascii=False)
+    
+    def _get_default_save_data(self) -> SaveData:
+        self._load_floder_config()
+        config_name = self.full_path.parent / '.ilinaconfig'
+        if config_name.exists() and config_name.is_file():
+            config = ConfigLoader(config_name, IlinaConfig).readonly() # 只读
+        else:
+            config = IlinaConfig()
+        return SaveData(  # 创建初始信息
+                    create_time=time.time(),
+                    root_node=Node(message=load_default_sysprompt(
+                        replace_dict={
+                            'workpath': str(self.workpath),
+                            'open_or_alarm': '打开那个文件且不发送通知' if config.open_or_alarm else '不打开那个文件而是发送通知'
+                        })))
+
+    def _load(self) -> None:
+        """ 从文件同步 save_data """
+        with LoggedTask('从文件加载节点树', logger=self.log) as task:
+            try:
+                with open(self.full_path, 'r', encoding='utf-8') as f:
+                    data: SaveData = json.load(f, object_hook=node_json_load)
+                    if data == {}:
+                        self.save_data: SaveData = self._get_default_save_data()
+                        self._save()
+                        return
+            except FileNotFoundError:  # 如果文件不存在，就用现有信息保存
+                self.save_data: SaveData = self._get_default_save_data()
+                self._save()
+                return
+            except json.JSONDecodeError:
+                with open(self.full_path, 'r', encoding='utf-8') as f:
+                    if f.read().strip() == '':
+                        self.save_data: SaveData = self._get_default_save_data()
+                        self._save()
+                        return
+                raise ValueError(f'文件 "{self.full_path}" 的格式错误：不是有效的 JSON')
+            except ValidationError:
+                raise ValueError(f'文件 "{self.full_path}" 的格式错误：不是有效的 JSON')
+            task.checkpoint(f'读取完成')
+            
+            # 进行格式检查
+            hints = get_type_hints(SaveData)
+            for key in hints.keys():
+                try:
+                    if not isinstance(data[key], hints[key]):
+                        raise ValueError(f'文件"{self.full_path}"的格式错误："{key}" 的类型应为 "{hints[key]}", 却找到了 "{type(data[key])}"')
+                except KeyError:
+                    raise ValueError(f'文件"{self.full_path}"的格式错误：缺少键 "{key}"')
+            self.save_data = data
+            task.checkpoint(f'格式检查完成')
+
+            # 产生节点映射表
+            for node in self.root_node.walk():
+                self.uuid_to_node_table[node.uuid] = node
+            task.checkpoint(f'节点映射表编写完成')
+
+            self._load_floder_config()
+    
+    def _load_floder_config(self):
+        with LoggedTask('查找并加载工作区配置', logger=self.log) as task:
+            config_name = self.full_path.parent / '.ilinaconfig'
+            if config_name.exists() and config_name.is_file():
+                with ConfigLoader(config_name, IlinaConfig) as config:
+                    if config.workpath:
+                        self.workpath = Path(config.workpath)
+                        self.log.info(f'将工作目录更新为：{self.workpath}')
+            else:
+                self.log.info(f'工作区配置未找到')
+    
+    def __enter__(self) -> "Tree":
+        self._load()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: object | None,
+    ) -> None:
+        self.log.debug(f'预备保存的对话树：\n{repr(self.save_data["root_node"])}')
+        self._save()

IlinaEngine/type.py

@@ -0,0 +1,8 @@
+from .call_openai import (
+    NodeEvent,
+    NodeEventTypes,
+)
+
+from ._ilina_message import IlinaMessage, IlinaToolCall
+
+from .tree import Node

ilinaengine-0.8.1.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: IlinaEngine
+Version: 0.8.1
+Summary: Ilina Engine 是一个以对话树为核心的 AI 聊天后端系统。支持树状对话、读写文件、MCP 和 Skills
+Project-URL: Repository, https://github.com/Foves7017/IlinaEngine
+Author: Foves7017
+License: MIT License
+        
+        Copyright (c) 2026 Foves7017
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: fovesconfig
+Requires-Dist: foveslog
+Requires-Dist: mcp
+Requires-Dist: openai
+Description-Content-Type: text/markdown
+
+# IlinaEngine
+Ilina Engine 是一个以对话树为核心的 AI 聊天后端系统。支持树状对话、读写文件、MCP 和 Skills
+
+## 重要说明
+当前版本 (0.8.x) 还是一个开发中版本，许多功能也许不稳定，也有可能会增删接口，请务必注意。
+
+关于版本更新的详细内容请见后文。
+
+## 安装方法
+Ilina Engine 已经发布到 PyPI，你可以使用下面的命令安装：
+
+```
+pip install IlinaEngine
+```
+
+你也可以前往这个页面，看看我为 Ilina Engine 开发的 GUI，然后直接使用。
+https://github.com/Foves7017/IlinaGUI
+
+本项目的地址：
+https://github.com/Foves7017/IlinaEngine
+
+# 配置 IlinaEngine
+首次启动后，IlinaEngine会使用默认配置创建 `./configs/ai.json`，你可以在启动前手动创建它，也可以启动后手动修改，但之后可能需要重新运行程序。
+[这里](./docs/config.md)介绍了所有的配置项。
+
+请首先至少配置可用的主要模型和辅助模型。
+# 对话引擎
+对于对话树的操作全部可以通过 Engine 模块实现，Engine 模块同时也提供了直接调用 API 生成回复的能力。
+[这里](./docs/engine.md)记录了所有引擎可以调用的接口，上述的 GUI 则是使用这些接口的示例。
+
+# 对话树（Conversation Tree）
+
+与传统聊天软件的线性消息列表不同，IlinaEngine 使用**树结构（Tree）**存储整个对话。
+
+每一条消息都是一个节点（Node），节点之间通过父子关系连接，形成一棵完整的对话树。
+
+## 基本结构
+
+```text
+System
+└── User：你好
+    └── Assistant：你好，请问有什么可以帮助你？
+        ├── User：介绍一下 Python
+        │   └── Assistant：Python 是一种...
+        │
+        └── User：介绍一下 C++
+            └── Assistant：C++ 是一种...
+```
+
+每个节点都可以是：
+
+* User（用户消息）
+* Assistant（模型回复）
+* Tool（工具调用结果）
+* System（系统提示词）
+* Error（错误节点）
+
+树中的每一条路径都代表一次完整的对话上下文。
+
+---
+
+## 分支机制
+
+在任意节点上：
+
+* 修改消息
+* 重新生成回答
+* 从历史节点继续对话
+
+都不会覆盖原有内容。
+
+系统会创建一个新的子节点作为新的分支。
+
+例如：
+
+```text
+User：推荐一本书
+└── Assistant：推荐《三体》
+    ├── User：为什么？
+    │   └── Assistant：因为...
+    │
+    └── User：换一本
+        └── Assistant：推荐《银河帝国》
+```
+
+原始对话会被完整保留。
+
+你可以随时切换到任意分支继续对话。
+
+---
+
+## 当前分支
+
+每个节点都记录一个指向子节点的指针（Pointer）。
+
+Pointer 用来标记：
+
+> “当前正在使用哪一条分支”。
+
+例如：
+
+```text
+User
+└── Assistant
+    ├── User A
+    │   └── Assistant A
+    │
+    └▶ User B
+        └▶ Assistant B
+```
+
+带有 `▶` 标记的路径就是当前活跃分支。
+
+当模型生成回复时，系统会沿着这条路径向下收集消息，构造发送给模型的上下文。
+
+---
+
+## 修改历史
+
+由于所有旧节点都会被保留，因此：
+
+* 可以查看任意历史版本
+* 可以比较不同回答
+* 可以回到过去的任意时间点
+* 可以从任意节点创建新的对话路线
+
+整个对话过程类似于 Git 的提交树：
+
+```text
+A
+└── B
+    ├── C
+    │   └── D
+    │
+    └── E
+        └── F
+```
+
+不同的是，这里的节点不是代码提交，而是一次次对话消息。
+
+---
+
+## 优势
+
+相比传统线性聊天记录，对话树能够：
+
+* 保留所有历史版本
+* 支持无限分支探索
+* 支持多次重新生成而不丢失旧结果
+* 支持修改任意历史消息
+* 支持从任意节点继续对话
+* 为 AI Agent、工具调用与长期记忆提供更灵活的上下文管理能力
+
+对话不再是一条线，而是一张不断生长的思维树。

ilinaengine-0.8.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+IlinaEngine/__init__.py,sha256=aguBEuGH-tkbx1dWOi_tNk1DOx4p0WMyA9jo0mGYbEM,100
+IlinaEngine/_config_models.py,sha256=AbTDCNt-JhGVzyQKhSGxP-okFHKXlwgPH2ZLgkOIzXY,985
+IlinaEngine/_ilina_message.py,sha256=mg-S6pg6DVIpNvuCaeHKPgZPoM876Nrpuu5SvwEFMus,961
+IlinaEngine/call_openai.py,sha256=J-KcQ4mLVe2iB8m4wgtdGFp7j5JN6gFXWZmEXEkHGI0,10053
+IlinaEngine/engine.py,sha256=IVGcedVBZHuYSc8L6WoRlikw5fpkrDxrlBc6hd__KEI,5603
+IlinaEngine/exceptions.py,sha256=K28BRBlG-JKfanEk426Y9xZIOtKXmUZ_SWHUShy7l0U,745
+IlinaEngine/sync_mcp.py,sha256=yJtvStrv46SdHqkRQMPuZVVd0SmX4kycHgbFiNJBNqg,7533
+IlinaEngine/sysprompt.py,sha256=FXoe8XmOJFzGKz4fwWHpQ7c8CusOh7aMNMQA2tEHAHA,814
+IlinaEngine/tools.py,sha256=kxp4j8f2h_73RGS2CXe4ZfRAoe0PImaDT624AzVVUTo,2387
+IlinaEngine/tree.py,sha256=iaYtWFN0I8wM0HZVjLucE57-rn8FQFmHliZ1YGxT92U,13469
+IlinaEngine/type.py,sha256=H8QeO3Rba56MCop7AAkpBTQfg8H4JOhN_P2zY_xDNro,151
+ilinaengine-0.8.1.dist-info/METADATA,sha256=tQRRBs6Jr0R04BQIbGGEjJwVPCHIQ7YiM4n_6Ehm0Wk,5690
+ilinaengine-0.8.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+ilinaengine-0.8.1.dist-info/licenses/LICENSE,sha256=lXz0pZeICx_-HWjVeatkJhfuZp5Wd4jOPYzVs57mLfM,1087
+ilinaengine-0.8.1.dist-info/RECORD,,

ilinaengine-0.8.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

ilinaengine-0.8.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Foves7017
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.