rootengine-core 0.5.0__py3-none-any.whl

rootengine_core/__init__.py

@@ -0,0 +1,5 @@
+
+from .conversation import NoToolConversation
+from .tool import Tool
+from .llm import BaseLLM
+from .llm.openai_adapter import OpenAIAdapter,BaseLLMAdapter

rootengine_core/constants/conversation.py

@@ -0,0 +1,5 @@
+CONVERSATION_ROLE = [
+    "system",
+    "user",
+    "assistant"
+]

rootengine_core/constants/framework.py

@@ -0,0 +1,17 @@
+VERSION = {
+    "reif_version":"1.0",
+    "conversation":"0.1.0",
+    "tool_registry":"0.1.0",
+    "tool_call":"0.1.0",
+    "tool_results":"0.1.0",
+    "tool_record":"0.1.0",
+
+}
+
+REIF_CATEGORY = [
+    "agent_card",
+    "conversation",
+    "tool_registry",
+    "tool_record"
+
+    ]

rootengine_core/conversation/__init__.py

@@ -0,0 +1 @@
+from .no_tool_conversation import NoToolConversation

rootengine_core/conversation/no_tool_conversation.py

@@ -0,0 +1,106 @@
+
+from ..constants.conversation import CONVERSATION_ROLE
+from pathlib import Path
+from ..utils.reif_func import reif_create,reif_validate
+from ..utils.time import get_iso_timestamp
+
+
+from jsonschema import validate
+
+
+from ..schema_runtime.reif_schema import get_json
+SCHEMA = get_json("conversation.no_tool_conversation")
+
+class NoToolConversation:
+    def __init__(self, conversation_entry: dict = None):
+        # 如果未传自动创建新的
+        if conversation_entry is None:
+             self.create()
+        else:
+            self.entry = conversation_entry
+
+        self.messages = self.entry["reif_content"]
+
+
+    def create(self)   -> NoToolConversation:
+        """创建新会话"""
+        self.entry = reif_create({"category": "conversation"})
+        # 确保 reif_content 存在且为空列表
+        self.entry["reif_content"] = []
+        # 链接
+        self.messages = self.entry["reif_content"]
+
+        return self
+
+    def add(
+            self ,
+            role: str,
+            content: str = None,
+            created_at: str = None,
+            extra: dict = None,
+            )   -> NoToolConversation :
+
+        """
+        向会话添加一条消息。
+
+        :param role: 消息角色，必须为 system/user/assistant/tool 之一。
+        :param content: 文本内容（对 system/user/assistant 必填，对 tool 可选）。
+
+        :param extra: 可选的扩展字典，任意附加信息。
+        :param created_at: 可选时间戳，若不提供则自动生成。
+        :return: self，支持链式调用。
+        """
+        #检验角色
+        if role not in CONVERSATION_ROLE:
+            raise ValueError(f"未知角色: {role}")
+
+        # 生成时间戳
+        if created_at is None:
+            created_at = get_iso_timestamp()
+
+
+        # 构造消息字典
+        item = {
+            "role": role,
+            "content": content,
+            "created_at": created_at
+        }
+
+        if extra:
+            item["extra"] = extra
+
+        self.messages.append(item)
+        return self
+
+    def delete(self, index: int = None):
+        """
+
+        :param index: 索引，若不填默认删除最后一个
+        :return:
+        """
+
+        if index is None:
+            self.messages.pop()
+        else:
+            self.messages.pop(index)
+        return self
+
+
+
+    def load_entry(self,entry: dict) -> NoToolConversation :
+        """加载整个 conversation 条目"""
+        self.entry = entry
+        self.messages = self.entry["reif_content"]
+        return self
+    def load_messages(self,messages: list) -> NoToolConversation :
+        self.messages = messages
+        self.entry["reif_content"] = self.messages
+        return self
+
+    def validate_schema(self) -> bool:
+        if self.reif_entry is None:
+            raise RuntimeError("无会话可校验")
+        reif_validate(self.entry)
+        validate(instance=self.messages, schema = SCHEMA)
+        return True
+

rootengine_core/llm/__init__.py

@@ -0,0 +1,2 @@
+from .llm import BaseLLM
+from .openai_adapter import BaseLLMAdapter,OpenAIAdapter

rootengine_core/llm/llm.py

@@ -0,0 +1,37 @@
+from typing import Optional,Dict,List,Any
+
+from abc import ABC,abstractmethod
+
+
+class BaseLLM(ABC):
+
+
+    @abstractmethod
+
+    def call(self,
+             messages:List[dict[str,Any]],
+             tool_registry:Optional[List[Dict[str, Any]]],
+             tool_choice: Optional[str],
+             **kwargs)\
+            -> Dict[str, Any]:
+        """
+
+        :param messages: 消息列表 参考 ../schema/source/llm/llm_message.json
+        :param tool_registry: 工具注册表 参考 ../schema/source/tool/tool_registry.json
+        :param tool_choice: 工具选择策略 参考 ../schema/source/llm/tool_choice.json
+        :param kwargs: 拓展任意字段
+        :return: 参考 ../schema/source/llm/llm_output.json
+
+        """
+        pass
+
+
+
+
+
+
+
+
+
+
+

rootengine_core/llm/openai_adapter.py

@@ -0,0 +1,235 @@
+"""
+LLM Provider 适配器：框架格式 ↔ 各 Provider 格式
+
+用法：
+    adapter = OpenAIAdapter(model="gpt-4", api_key="...")
+    openai_params = adapter.to_provider(messages, tool_registry, tool_choice)
+    # 调用 OpenAI API...
+    llm_output = adapter.from_provider(openai_response)
+"""
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Union
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 基类
+# ─────────────────────────────────────────────────────────────────────────────
+
+class BaseLLMAdapter(ABC):
+    """LLM 适配器基类，所有 Provider 适配器需继承此类"""
+
+    @abstractmethod
+    def to_provider(
+        self,
+        messages: List[Dict[str, Any]],
+        tool_registry: Optional[Dict[str, Any]] = None,
+        tool_choice: Optional[Union[str, Dict]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        框架格式 → Provider 格式
+
+        :param messages: 框架消息列表 (llm_message[])
+        :param tool_registry: 框架工具注册表
+        :param tool_choice: 工具选择策略
+        :return: Provider API 调用参数
+        """
+        pass
+
+    @abstractmethod
+    def from_provider(self, response: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Provider 响应格式 → 框架格式 (llm_output)
+
+        :param response: Provider API 返回的原始响应
+        :return: 框架 llm_output 格式
+        """
+        pass
+
+    @abstractmethod
+    def message_to_frame(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        单条 Provider 消息 → 框架格式 (llm_message)
+
+        用于把 Provider 返回的消息转成框架格式后再存入 messages 列表
+
+        :param message: Provider 格式的单条消息
+        :return: 框架 llm_message 格式
+        """
+        pass
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# OpenAI 适配器
+# ─────────────────────────────────────────────────────────────────────────────
+
+class OpenAIAdapter(BaseLLMAdapter):
+    """OpenAI 兼容 API 适配器"""
+
+    def __init__(
+        self,
+        model: str = "gpt-4",
+        **config
+    ):
+        """
+        :param model: 模型名称
+        :param config: 其他 OpenAI API 配置（temperature, timeout 等）
+        """
+        self.model = model
+        self.config = config
+
+    def to_provider(
+        self,
+        messages: List[Dict[str, Any]],
+        tool_registry: Optional[Dict[str, Any]] = None,
+        tool_choice: Optional[Union[str, Dict]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        result = {
+            "model": self.model,
+            "messages": self._convert_messages(messages),
+        }
+
+        if tool_registry:
+            result["tools"] = self._convert_tool_registry(tool_registry)
+
+        if tool_choice is not None:
+            result["tool_choice"] = self._convert_tool_choice(tool_choice)
+
+        result.update(self.config)
+        result.update(kwargs)
+        return result
+
+    def from_provider(self, response: Dict[str, Any]) -> Dict[str, Any]:
+        content = response.get("content")
+        tool_calls = response.get("tool_calls")
+
+        if content is None and not tool_calls:
+            llm_content = None
+        else:
+            llm_content = content
+
+        llm_tool_calls = None
+        if tool_calls:
+            llm_tool_calls = self._convert_tool_calls_from_openai(tool_calls)
+
+        return {
+            "content": llm_content,
+            "tool_calls": llm_tool_calls,
+            "usage": self._normalize_usage(response.get("usage")),
+            "created_at": response.get("created") or response.get("created_at"),
+        }
+
+    def message_to_frame(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        role = message["role"]
+        frame_msg = {
+            "role": role,
+            "created_at": message.get("created_at") or message.get("created"),
+        }
+
+        if role == "tool":
+            frame_msg["tool_call_id"] = message["tool_call_id"]
+            frame_msg["content"] = {
+                "call_id": message["tool_call_id"],
+                "type": "function",
+                "function": {
+                    "result_content": message["content"],
+                    "status": "success",
+                },
+                "created_at": frame_msg["created_at"],
+            }
+        else:
+            frame_msg["content"] = message.get("content")
+
+            if role == "assistant" and message.get("tool_calls"):
+                frame_msg["tool_calls"] = self._convert_tool_calls_from_openai(message["tool_calls"])
+
+        return frame_msg
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # 内部转换方法
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def _convert_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """框架消息列表 → OpenAI 消息列表"""
+        openai_messages = []
+        for msg in messages:
+            role = msg["role"]
+            openai_msg = {"role": role}
+
+            content = msg.get("content")
+            if role == "tool":
+                if isinstance(content, dict):
+                    openai_msg["content"] = content.get("result_content", "")
+                else:
+                    openai_msg["content"] = content or ""
+            else:
+                openai_msg["content"] = content
+
+            if role == "assistant" and msg.get("tool_calls"):
+                openai_msg["tool_calls"] = self._convert_tool_calls_to_openai(msg["tool_calls"])
+
+            openai_messages.append(openai_msg)
+        return openai_messages
+
+    def _convert_tool_calls_to_openai(self, tool_calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """框架 tool_calls → OpenAI tool_calls"""
+        return [
+            {
+                "id": call["id"],
+                "type": call["type"],
+                "function": {
+                    "name": call["function"]["registry_id"],
+                    "arguments": call["function"]["arguments"],
+                },
+            }
+            for call in tool_calls
+        ]
+
+    def _convert_tool_calls_from_openai(self, tool_calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """OpenAI tool_calls → 框架 tool_calls"""
+        from ..utils.time import get_iso_timestamp
+        created_at = get_iso_timestamp()
+        return [
+            {
+                "id": call["id"],
+                "type": call["type"],
+                "function": {
+                    "registry_id": call["function"]["name"],
+                    "arguments": call["function"]["arguments"],
+                },
+                "created_at": created_at,
+            }
+            for call in tool_calls
+        ]
+
+    def _convert_tool_registry(self, tool_registry: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """框架工具注册表 → OpenAI tools"""
+        openai_tools = []
+        for registry_id, tool_info in tool_registry.items():
+            func_info = tool_info.get("function", {})
+            openai_tools.append({
+                "type": "function",
+                "function": {
+                    "name": registry_id,
+                    "description": func_info.get("description", ""),
+                    "parameters": func_info.get("parameters", {"type": "object", "properties": {}}),
+                },
+            })
+        return openai_tools
+
+    def _convert_tool_choice(self, tool_choice: Union[str, Dict]) -> Union[str, Dict]:
+        """工具选择策略转换"""
+        if isinstance(tool_choice, str):
+            return tool_choice
+        return tool_choice
+
+    def _normalize_usage(self, usage: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+        """标准化 usage"""
+        if usage is None:
+            return None
+        return {
+            "prompt_tokens": usage.get("prompt_tokens", 0),
+            "completion_tokens": usage.get("completion_tokens", 0),
+            "total_tokens": usage.get("total_tokens", 0),
+        }

rootengine_core/schema/source/conversation/no_tool_conversation.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "reif_content_base_conversation",
+  "description": "基础对话消息列表（无工具字段）",
+  "type": "array",
+  "items": {
+    "type": "object",
+    "properties": {
+      "role": {
+        "type": "string",
+        "enum": [
+          "system",
+          "user",
+          "assistant"
+        ]
+      },
+      "content": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "created_at": {
+        "type": "string",
+        "format": "date-time"
+      },
+      "extra": {
+        "type": [
+          "object",
+          "null"
+        ],
+        "additionalProperties": true
+      }
+    },
+    "required": [
+      "role",
+      "created_at"
+    ]
+  }
+}

rootengine_core/schema/source/llm/llm_message.json

@@ -0,0 +1,96 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "llm_message",
+  "description": "LLM 对话消息单条格式，与 OpenAI 格式解耦",
+  "type": "object",
+  "properties": {
+    "role": {
+      "type": "string",
+      "enum": ["system", "user", "assistant", "tool"],
+      "description": "消息角色"
+    },
+    "content": {
+      "description": "消息内容",
+      "oneOf": [
+        {
+          "type": "null",
+          "description": "assistant 无文字内容时（如纯工具调用）"
+        },
+        {
+          "type": "string",
+          "description": "system/user/assistant 普通文字内容"
+        },
+        {
+          "type": "object",
+          "description": "tool 角色时为 tool_result 对象"
+        }
+      ]
+    },
+    "tool_calls": {
+      "type": "array",
+      "description": "LLM 工具调用列表，仅 assistant 消息可能包含",
+      "items": {
+        "$ref": "../tool/tool_call.json"
+      }
+    },
+    "tool_call_id": {
+      "type": "string",
+      "pattern": "^[0-9a-fA-F]{32}$",
+      "description": "tool 角色必填，关联到 assistant 消息 tool_calls 中对应 call 的 id"
+    },
+    "created_at": {
+      "type": "string",
+      "format": "date-time",
+      "description": "创建时间 ISO 8601"
+    },
+    "extra": {
+      "type": ["object", "null"],
+      "additionalProperties": true,
+      "description": "扩展数据"
+    }
+  },
+  "required": ["role", "created_at"],
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "role": {
+            "const": "tool"
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "content": {
+            "type": "object",
+            "description": "tool 角色的 content 必须为 tool_result 对象"
+          },
+          "tool_call_id": {
+            "type": "string",
+            "pattern": "^[0-9a-fA-F]{32}$"
+          }
+        },
+        "required": ["tool_call_id"]
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "role": {
+            "const": "assistant"
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "tool_calls": {
+            "type": "array",
+            "items": {
+              "$ref": "tool/tool_call.json"
+            }
+          }
+        }
+      }
+    }
+  ]
+}

rootengine_core/schema/source/llm/llm_output.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "llm_output",
+  "description": "LLM 单次调用的返回格式",
+  "type": "object",
+  "properties": {
+    "content": {
+      "description": "LLM 回复的文字内容，无文字时为 null（纯工具调用场景）",
+      "oneOf": [
+        { "type": "null" },
+        { "type": "string" }
+      ]
+    },
+    "tool_calls": {
+      "type": "array",
+      "description": "LLM 发起的工具调用列表，无工具调用时为 null",
+      "items": {
+        "$ref": "../tool/tool_call.json"
+      }
+    },
+    "usage": {
+      "type": "object",
+      "description": "Token 用量统计",
+      "properties": {
+        "prompt_tokens": {
+          "type": "integer",
+          "description": "输入 prompt 消耗的 token 数"
+        },
+        "completion_tokens": {
+          "type": "integer",
+          "description": "生成回复消耗的 token 数"
+        },
+        "total_tokens": {
+          "type": "integer",
+          "description": "总 token 数"
+        }
+      }
+    },
+    "created_at": {
+      "type": "string",
+      "format": "date-time",
+      "description": "LLM 返回时间，ISO 8601 格式"
+    },
+    "extra": {
+      "type": ["object", "null"],
+      "additionalProperties": true,
+      "description": "扩展数据"
+    }
+  }
+}

rootengine_core/schema/source/llm/tool_choice.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": " Tool Choice Schema(仿openai，其中function.name 改成了 func.registry_id)",
+  "description": "Controls how the model uses tools. Can be a simple string mode or an object specifying a forced function call.",
+  "type": ["string", "object"],
+  "oneOf": [
+    {
+      "title": "Simple Mode",
+      "type": "string",
+      "enum": ["auto", "none", "required"],
+      "description": "Auto: model decides; None: no tool call; Required: model must call at least one tool."
+    },
+    {
+      "title": "Specific Function Call",
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "const": "function",
+          "description": "Must be 'function'."
+        },
+        "function": {
+          "type": "object",
+          "properties": {
+            "registry_id": {
+              "type": "string",
+              "format": "uuid",
+              "description": "tool 在注册表的 registry_id "
+            }
+          },
+          "required": ["registry_id"],
+          "additionalProperties": false
+        }
+      },
+      "required": ["type", "function"],
+      "additionalProperties": false
+    }
+  ]
+}