diff --git a/bench/eval_reme_old.py b/bench/eval_reme_old.py index 41fde3b1..51265da7 100644 --- a/bench/eval_reme_old.py +++ b/bench/eval_reme_old.py @@ -10,8 +10,8 @@ from datetime import datetime, timezone from tqdm import tqdm -from reme_ai.core_old.enumeration import Role -from reme_ai.core_old.schema import Message, MemoryNode +from reme_ai.core.enumeration import Role +from reme_ai.core.schema import Message, MemoryNode from reme_ai.reme import ReMe TEMPLATE_REME = """Memories for user {user_id}: diff --git a/bench/halumem/eval_reme.py b/bench/halumem/eval_reme.py index 3254c332..2b943143 100644 --- a/bench/halumem/eval_reme.py +++ b/bench/halumem/eval_reme.py @@ -35,8 +35,8 @@ from eval_tools import ( evaluation_for_update_memory, ) from llms import llm_request -from reme_ai.core_old.enumeration import MemoryType -from reme_ai.core_old.schema import MemoryNode +from reme_ai.core.enumeration import MemoryType +from reme_ai.core.schema import MemoryNode from reme_ai.reme import ReMe # Template for formatting memories (from shared YAML config) diff --git a/bench/halumem/eval_reme_simple.py b/bench/halumem/eval_reme_simple.py index 4635c556..17671def 100644 --- a/bench/halumem/eval_reme_simple.py +++ b/bench/halumem/eval_reme_simple.py @@ -26,8 +26,8 @@ from typing import Any from loguru import logger from eval_tools import evaluation_for_question2 -from reme_ai.core_old.enumeration import MemoryType -from reme_ai.core_old.schema import MemoryNode +from reme_ai.core.enumeration import MemoryType +from reme_ai.core.schema import MemoryNode from reme_ai.reme import ReMe diff --git a/bench/halumem/eval_reme_simple_v3.py b/bench/halumem/eval_reme_simple_v3.py index 43cee5d9..469102ba 100644 --- a/bench/halumem/eval_reme_simple_v3.py +++ b/bench/halumem/eval_reme_simple_v3.py @@ -27,8 +27,8 @@ from typing import Any from loguru import logger from eval_tools import evaluation_for_question2 -from reme_ai.core_old.enumeration import MemoryType -from reme_ai.core_old.schema import MemoryNode +from reme_ai.core.enumeration import MemoryType +from reme_ai.core.schema import MemoryNode from reme_ai.reme import ReMe diff --git a/bench/halumem/eval_reme_simple_v4.py b/bench/halumem/eval_reme_simple_v4.py index 63cb4f37..c68ee4d1 100644 --- a/bench/halumem/eval_reme_simple_v4.py +++ b/bench/halumem/eval_reme_simple_v4.py @@ -27,8 +27,8 @@ from typing import Any from loguru import logger from eval_tools import evaluation_for_question2, answer_question_with_memories -from reme_ai.core_old.enumeration import MemoryType -from reme_ai.core_old.schema import MemoryNode +from reme_ai.core.enumeration import MemoryType +from reme_ai.core.schema import MemoryNode from reme_ai.reme import ReMe diff --git a/bench/halumem/llms.py b/bench/halumem/llms.py index 5a59b2b2..73577575 100644 --- a/bench/halumem/llms.py +++ b/bench/halumem/llms.py @@ -5,8 +5,8 @@ import re from tenacity import retry, stop_after_attempt, wait_random_exponential, before_sleep_log -from reme_ai.core_old.schema import Message -from reme_ai.core_old.utils import load_env +from reme_ai.core.schema import Message +from reme_ai.core.utils import load_env from reme_ai.reme import ReMe logger = logging.getLogger(__name__) diff --git a/bench/human_in_the_loop/reevaluate_qa.py b/bench/human_in_the_loop/reevaluate_qa.py index a013616c..6b9cac8f 100644 --- a/bench/human_in_the_loop/reevaluate_qa.py +++ b/bench/human_in_the_loop/reevaluate_qa.py @@ -16,8 +16,8 @@ from collections import defaultdict from pathlib import Path from typing import Any -from reme_ai.core_old.schema import Message -from reme_ai.core_old.utils import load_env +from reme_ai.core.schema import Message +from reme_ai.core.utils import load_env from reme_ai.reme import ReMe from tenacity import retry, stop_after_attempt, wait_random_exponential diff --git a/bench/human_in_the_loop2/reevaluate_qa.py b/bench/human_in_the_loop2/reevaluate_qa.py index a5e6d0fd..fbc44015 100644 --- a/bench/human_in_the_loop2/reevaluate_qa.py +++ b/bench/human_in_the_loop2/reevaluate_qa.py @@ -16,8 +16,8 @@ from collections import defaultdict from pathlib import Path from typing import Any -from reme_ai.core_old.schema import Message -from reme_ai.core_old.utils import load_env +from reme_ai.core.schema import Message +from reme_ai.core.utils import load_env from reme_ai.reme import ReMe from tenacity import retry, stop_after_attempt, wait_random_exponential diff --git a/reme/__init__.py b/reme/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/reme/core/__init__.py b/reme/core/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/reme/core/context/__init__.py b/reme/core/context/__init__.py new file mode 100644 index 00000000..27957fd2 --- /dev/null +++ b/reme/core/context/__init__.py @@ -0,0 +1,11 @@ +"""context""" + +from .base_context import BaseContext +from .prompt_handler import PromptHandler +from .registry_factory import R + +__all__ = [ + "BaseContext", + "PromptHandler", + "R", +] diff --git a/reme_ai/core_old/context/base_context.py b/reme/core/context/base_context.py similarity index 100% rename from reme_ai/core_old/context/base_context.py rename to reme/core/context/base_context.py diff --git a/reme/core/context/prompt_handler.py b/reme/core/context/prompt_handler.py new file mode 100644 index 00000000..e6b6d737 --- /dev/null +++ b/reme/core/context/prompt_handler.py @@ -0,0 +1,363 @@ +"""Module for managing and formatting prompt templates from files or dictionaries. + +This module provides a PromptHandler class that: +- Loads prompts from YAML/JSON files or dictionaries +- Supports multi-language prompts with automatic suffix handling +- Provides conditional line filtering using boolean flags +- Formats prompts with template variable substitution +- Validates format strings and provides helpful error messages +""" + +import json +from pathlib import Path +from string import Formatter +from typing import Any, Dict, Optional, Union + +import yaml +from loguru import logger + +from .base_context import BaseContext + + +class PromptNotFoundError(KeyError): + """Exception raised when a requested prompt template is not found.""" + + def __init__(self, prompt_name: str, available_prompts: list[str]): + self.prompt_name = prompt_name + self.available_prompts = available_prompts + super().__init__( + f"Prompt '{prompt_name}' not found. " + f"Available prompts: {', '.join(available_prompts[:10])}" + f"{'...' if len(available_prompts) > 10 else ''}", + ) + + +class PromptFormattingError(ValueError): + """Exception raised when prompt formatting fails.""" + + +class PromptHandler(BaseContext): + """A context-aware handler for loading, retrieving, and formatting prompt templates. + + This handler supports: + - Loading prompts from YAML/JSON files or dictionaries + - Multi-language prompt support with automatic language suffix + - Conditional line filtering using boolean flags (e.g., [debug], [verbose]) + - Template variable substitution with validation + - Method chaining for fluent API + + Examples: + >>> handler = PromptHandler(language="en") + >>> handler.load_prompt_dict({ + ... "greeting_en": "Hello, {name}!", + ... "farewell_en": "[debug]Debug mode\\nGoodbye, {name}!" + ... }) + >>> handler.prompt_format("greeting", name="Alice") + 'Hello, Alice!' + >>> handler.prompt_format("farewell", name="Bob", debug=False) + 'Goodbye, Bob!' + """ + + def __init__(self, language: str = "", **kwargs): + """Initialize the PromptHandler with optional language configuration. + + Args: + language: Language code to append as suffix (e.g., "en", "zh", "ja"). + If provided, get_prompt will automatically try to find + prompts with this suffix (e.g., "greeting" -> "greeting_en"). + **kwargs: Additional key-value pairs to initialize the context. + """ + super().__init__(**kwargs) + self.language: str = language.strip() + + def load_prompt_by_file( + self, + prompt_file_path: Optional[Union[Path, str]] = None, + overwrite: bool = True, + ) -> "PromptHandler": + """Load prompt configurations from a YAML or JSON file into the context. + + Supports both YAML (.yaml, .yml) and JSON (.json) file formats. + Non-existent files are silently skipped. + + Args: + prompt_file_path: Path to the prompt configuration file. + If None, returns self without changes. + overwrite: If True, allows overwriting existing prompts with warnings. + If False, skips existing prompts without overwriting. + + Returns: + Self for method chaining. + + Raises: + ValueError: If file format is not supported. + yaml.YAMLError: If YAML parsing fails. + json.JSONDecodeError: If JSON parsing fails. + """ + if prompt_file_path is None: + return self + + if isinstance(prompt_file_path, str): + prompt_file_path = Path(prompt_file_path) + + if not prompt_file_path.exists(): + logger.warning(f"Prompt file not found: {prompt_file_path}") + return self + + suffix = prompt_file_path.suffix.lower() + + try: + with prompt_file_path.open(encoding="utf-8") as f: + if suffix in [".yaml", ".yml"]: + prompt_dict = yaml.safe_load(f) + elif suffix == ".json": + prompt_dict = json.load(f) + else: + raise ValueError( + f"Unsupported file format: {suffix}. " f"Supported formats: .yaml, .yml, .json", + ) + + logger.info(f"Loaded {len(prompt_dict or {})} prompts from {prompt_file_path}") + self.load_prompt_dict(prompt_dict, overwrite=overwrite) + + except (yaml.YAMLError, json.JSONDecodeError) as e: + logger.error(f"Failed to parse prompt file {prompt_file_path}: {e}") + raise + + return self + + def load_prompt_dict( + self, + prompt_dict: Optional[Dict[str, Any]] = None, + overwrite: bool = True, + ) -> "PromptHandler": + """Merge a dictionary of prompt strings into the current context. + + Only string values are stored as prompts. Non-string values are skipped. + + Args: + prompt_dict: Dictionary mapping prompt names to prompt template strings. + overwrite: If True, allows overwriting existing prompts with warnings. + If False, skips existing prompts without overwriting. + + Returns: + Self for method chaining. + """ + if not prompt_dict: + return self + + for key, value in prompt_dict.items(): + if not isinstance(value, str): + logger.debug(f"Skipping non-string prompt: key={key}, type={type(value)}") + continue + + if key in self: + if overwrite: + logger.warning( + f"Overwriting prompt '{key}': " f"old length={len(self[key])}, new length={len(value)}", + ) + self[key] = value + else: + logger.debug(f"Skipping existing prompt: key={key}") + else: + logger.debug(f"Adding new prompt: key={key}, length={len(value)}") + self[key] = value + + return self + + def get_prompt(self, prompt_name: str, fallback_to_base: bool = True) -> str: + """Retrieve a prompt by name with automatic language suffix handling. + + If a language is configured, this method will: + 1. First try to find the prompt with language suffix (e.g., "greeting_en") + 2. If not found and fallback_to_base is True, try the base name (e.g., "greeting") + 3. Otherwise, raise PromptNotFoundError + + Args: + prompt_name: Name of the prompt to retrieve. + fallback_to_base: If True and language-specific prompt not found, + fallback to prompt without language suffix. + + Returns: + The prompt template string, stripped of leading/trailing whitespace. + + Raises: + PromptNotFoundError: If the prompt is not found. + """ + # Try with language suffix first + if self.language and not prompt_name.endswith(f"_{self.language}"): + key_with_lang = f"{prompt_name}_{self.language}" + if key_with_lang in self: + return self[key_with_lang].strip() + + # Try base name + if prompt_name in self: + return self[prompt_name].strip() + + # Try fallback if enabled + if fallback_to_base and self.language: + # Check if prompt_name already has language suffix, try without it + if prompt_name.endswith(f"_{self.language}"): + base_name = prompt_name[: -(len(self.language) + 1)] + if base_name in self: + return self[base_name].strip() + + # Not found, raise error with helpful message + available = list(self.keys()) + raise PromptNotFoundError(prompt_name, available) + + def has_prompt(self, prompt_name: str) -> bool: + """Check if a prompt exists (with or without language suffix). + + Args: + prompt_name: Name of the prompt to check. + + Returns: + True if the prompt exists, False otherwise. + """ + try: + self.get_prompt(prompt_name) + return True + except PromptNotFoundError: + return False + + def list_prompts(self, language_filter: Optional[str] = None) -> list[str]: + """List all available prompt names. + + Args: + language_filter: If provided, only return prompts for this language. + If None, return all prompts. + + Returns: + List of prompt names. + """ + if language_filter is None: + return list(self.keys()) + + suffix = f"_{language_filter.strip()}" + return [key for key in self.keys() if key.endswith(suffix)] + + @staticmethod + def _extract_format_fields(template: str) -> set[str]: + """Extract all format field names from a template string. + + Args: + template: Template string with {variable} placeholders. + + Returns: + Set of field names used in the template. + """ + return {field_name for _, field_name, _, _ in Formatter().parse(template) if field_name is not None} + + @staticmethod + def _filter_conditional_lines(prompt: str, flags: Dict[str, bool]) -> str: + """Filter lines based on boolean flags. + + Lines starting with [flag_name] are conditionally included based on + the value of flags[flag_name]. If True, the line is included (without + the flag marker). If False, the line is excluded. + + Args: + prompt: The prompt text with conditional markers. + flags: Dictionary of flag names to boolean values. + + Returns: + Filtered prompt text. + """ + filtered_lines = [] + + for line in prompt.split("\n"): + # Check each flag + matched_flag = None + for flag_name in flags: + marker = f"[{flag_name}]" + if line.startswith(marker): + matched_flag = flag_name + break + + if matched_flag is None: + # No flag marker, always include + filtered_lines.append(line) + elif flags[matched_flag]: + # Flag is True, include without marker + marker = f"[{matched_flag}]" + filtered_lines.append(line[len(marker) :]) + # else: Flag is False, skip this line + + return "\n".join(filtered_lines) + + def prompt_format( + self, + prompt_name: str, + validate: bool = True, + **kwargs, + ) -> str: + """Format a prompt with conditional line filtering and variable substitution. + + This method performs two-stage formatting: + 1. Conditional line filtering: Lines marked with [flag] are included only + if the corresponding boolean kwarg is True. + 2. Variable substitution: Template variables {var} are replaced with + provided values. + + Args: + prompt_name: Name of the prompt to format. + validate: If True, check that all required template variables are provided. + **kwargs: Keyword arguments for formatting. Boolean values are treated as + conditional flags, other values are used for template substitution. + + Returns: + Formatted prompt string. + + Raises: + PromptNotFoundError: If the prompt is not found. + PromptFormattingError: If validation fails or formatting errors occur. + + Examples: + >>> handler = PromptHandler() + >>> handler["test"] = "[debug]Debug: {info}\\nResult: {value}" + >>> handler.prompt_format("test", debug=False, info="test", value=42) + 'Result: 42' + >>> handler.prompt_format("test", debug=True, info="test", value=42) + 'Debug: test\\nResult: 42' + """ + # Get the prompt template + prompt = self.get_prompt(prompt_name) + + # Separate boolean flags from format variables + flag_kwargs = {k: v for k, v in kwargs.items() if isinstance(v, bool)} + format_kwargs = {k: v for k, v in kwargs.items() if not isinstance(v, bool)} + + # Step 1: Filter conditional lines + if flag_kwargs: + prompt = self._filter_conditional_lines(prompt, flag_kwargs) + + # Step 2: Validate required fields if requested + if validate: + required_fields = self._extract_format_fields(prompt) + missing_fields = required_fields - set(format_kwargs.keys()) + + if missing_fields: + raise PromptFormattingError( + f"Missing required format variables for prompt '{prompt_name}': " + f"{', '.join(sorted(missing_fields))}", + ) + + # Step 3: Format with variables + try: + if format_kwargs: + prompt = prompt.format(**format_kwargs) + except KeyError as e: + raise PromptFormattingError( + f"Format error in prompt '{prompt_name}': missing variable {e}", + ) from e + except (ValueError, IndexError) as e: + raise PromptFormattingError( + f"Format error in prompt '{prompt_name}': {e}", + ) from e + + return prompt.strip() + + def __repr__(self) -> str: + """Return a string representation of the PromptHandler.""" + return f"PromptHandler(language='{self.language}', " f"num_prompts={len(self)})" diff --git a/reme_ai/core/context/registry_factory.py b/reme/core/context/registry_factory.py similarity index 100% rename from reme_ai/core/context/registry_factory.py rename to reme/core/context/registry_factory.py diff --git a/reme_ai/core_old/enumeration/__init__.py b/reme/core/enumeration/__init__.py similarity index 100% rename from reme_ai/core_old/enumeration/__init__.py rename to reme/core/enumeration/__init__.py diff --git a/reme_ai/core_old/enumeration/chunk_enum.py b/reme/core/enumeration/chunk_enum.py similarity index 100% rename from reme_ai/core_old/enumeration/chunk_enum.py rename to reme/core/enumeration/chunk_enum.py diff --git a/reme_ai/core_old/enumeration/http_enum.py b/reme/core/enumeration/http_enum.py similarity index 100% rename from reme_ai/core_old/enumeration/http_enum.py rename to reme/core/enumeration/http_enum.py diff --git a/reme/core/enumeration/json_schema_enum.py b/reme/core/enumeration/json_schema_enum.py new file mode 100644 index 00000000..d66882e2 --- /dev/null +++ b/reme/core/enumeration/json_schema_enum.py @@ -0,0 +1,38 @@ +"""Defines the standard data types supported by JSON Schema. + +This enum maps common JSON Schema primitive types to their corresponding +Python runtime types, and provides a convenient string representation +compatible with JSON Schema (`"string"`, `"number"`, etc.). +""" + +from enum import Enum + + +class JsonSchemaEnum(Enum): + """Enumeration of valid JSON Schema data types. + + The enum value is the corresponding Python type, while the string + representation (`str(...)`) is the canonical JSON Schema type name. + """ + + # Textual data + STRING = str + + # Numeric values, including integers and floats + NUMBER = float + + # Integer-only numeric values + INTEGER = int + + # JSON objects (key-value mappings) + OBJECT = dict + + # Ordered JSON lists/arrays + ARRAY = list + + # Boolean values: true / false + BOOLEAN = bool + + def __str__(self) -> str: + """Return the lowercase JSON Schema type name for this enum member.""" + return self.name.lower() diff --git a/reme/core/enumeration/memory_type.py b/reme/core/enumeration/memory_type.py new file mode 100644 index 00000000..b9f5ed29 --- /dev/null +++ b/reme/core/enumeration/memory_type.py @@ -0,0 +1,33 @@ +"""Defines the high-level categories of memory managed by ReMe. + +This enumeration is used across the system to tag, route, and store different +kinds of memories (identity, personal context, procedures, tools, etc.). +""" + +from enum import Enum + + +class MemoryType(str, Enum): + """Enumeration of memory categories used by the memory subsystem. + + These types describe *what* a piece of memory is about, which guides + storage, retrieval, and summarization strategies. + """ + + # Long‑term, relatively stable attributes about the user (name, roles, etc.) + IDENTITY = "identity" + + # User-specific preferences, habits, and evolving personal context + PERSONAL = "personal" + + # How‑to knowledge, workflows, and step‑by‑step instructions + PROCEDURAL = "procedural" + + # Information learned about tools, APIs, and their usage patterns + TOOL = "tool" + + # Condensed representation of larger memory collections + SUMMARY = "summary" + + # Raw chronological interaction history, typically before summarization + HISTORY = "history" diff --git a/reme_ai/core_old/enumeration/registry_enum.py b/reme/core/enumeration/registry_enum.py similarity index 100% rename from reme_ai/core_old/enumeration/registry_enum.py rename to reme/core/enumeration/registry_enum.py diff --git a/reme_ai/core_old/enumeration/role.py b/reme/core/enumeration/role.py similarity index 100% rename from reme_ai/core_old/enumeration/role.py rename to reme/core/enumeration/role.py diff --git a/reme_ai/core_old/schema/__init__.py b/reme/core/schema/__init__.py similarity index 100% rename from reme_ai/core_old/schema/__init__.py rename to reme/core/schema/__init__.py diff --git a/reme_ai/core_old/schema/memory_node.py b/reme/core/schema/memory_node.py similarity index 91% rename from reme_ai/core_old/schema/memory_node.py rename to reme/core/schema/memory_node.py index 304dfe5c..67ed7c43 100644 --- a/reme_ai/core_old/schema/memory_node.py +++ b/reme/core/schema/memory_node.py @@ -6,7 +6,6 @@ memories in the ReMe system. import datetime import hashlib -import json from typing import Any from pydantic import BaseModel, Field, model_validator @@ -146,30 +145,6 @@ class MemoryNode(BaseModel): metadata=metadata, ) - def format_memory(self) -> str: - """Format memory as human-readable string. - - Returns: - str: Formatted string with when_to_use, content, and ref_memory_id. - """ - parts: list[str] = [ - f"memory_id={self.memory_id}", - ] - - if self.when_to_use: - parts.append(self.when_to_use) - - if self.content: - parts.append(self.content) - - if self.metadata: - parts.append(f"metadata={json.dumps(self.metadata, ensure_ascii=False)}") - - if self.ref_memory_id: - parts.append(f"ref_memory_id={self.ref_memory_id}") - - return " ".join(parts) - @classmethod def from_vector_node(cls, node: VectorNode) -> "MemoryNode": """Reconstruct MemoryNode from VectorNode. diff --git a/reme_ai/core_old/schema/message.py b/reme/core/schema/message.py similarity index 96% rename from reme_ai/core_old/schema/message.py rename to reme/core/schema/message.py index 6c3299e7..321dd8c8 100644 --- a/reme_ai/core_old/schema/message.py +++ b/reme/core/schema/message.py @@ -132,7 +132,7 @@ class Message(BaseModel): def strip_md_func(line): if strip_markdown_headers: - line = re.sub(r'\n##+ +', '\n', line) + line = re.sub(r"\n##+ +", "\n", line) return line if add_reasoning and self.reasoning_content: @@ -143,8 +143,9 @@ class Message(BaseModel): elif isinstance(self.content, list): for block in self.content: - text = block.content if isinstance(block.content, str) else \ - json.dumps(block.content, ensure_ascii=False) + text = ( + block.content if isinstance(block.content, str) else json.dumps(block.content, ensure_ascii=False) + ) text = str(text) lines.append(strip_md_func(text)) diff --git a/reme_ai/core_old/schema/request.py b/reme/core/schema/request.py similarity index 100% rename from reme_ai/core_old/schema/request.py rename to reme/core/schema/request.py diff --git a/reme_ai/core_old/schema/response.py b/reme/core/schema/response.py similarity index 100% rename from reme_ai/core_old/schema/response.py rename to reme/core/schema/response.py diff --git a/reme_ai/core_old/schema/service_config.py b/reme/core/schema/service_config.py similarity index 96% rename from reme_ai/core_old/schema/service_config.py rename to reme/core/schema/service_config.py index 4c6eb543..e1ae9df7 100644 --- a/reme_ai/core_old/schema/service_config.py +++ b/reme/core/schema/service_config.py @@ -101,7 +101,7 @@ class ServiceConfig(BaseModel): init_logger: bool = Field(default=True) disabled_flows: List[str] = Field(default_factory=list) enabled_flows: List[str] = Field(default_factory=list) - mcp_servers: Dict[str, dict] = Field(default_factory=dict, description="External MCP Server configuration") + mcp_servers: Dict[str, dict] = Field(default_factory=dict) mcp: MCPConfig = Field(default_factory=MCPConfig) http: HttpConfig = Field(default_factory=HttpConfig) diff --git a/reme_ai/core_old/schema/stream_chunk.py b/reme/core/schema/stream_chunk.py similarity index 100% rename from reme_ai/core_old/schema/stream_chunk.py rename to reme/core/schema/stream_chunk.py diff --git a/reme_ai/core_old/schema/tool_call.py b/reme/core/schema/tool_call.py similarity index 98% rename from reme_ai/core_old/schema/tool_call.py rename to reme/core/schema/tool_call.py index 3c01cdcd..70355d60 100644 --- a/reme_ai/core_old/schema/tool_call.py +++ b/reme/core/schema/tool_call.py @@ -1,6 +1,4 @@ -""" -MCP Tool Schema definitions for recursive JSON Schema representation. -""" +"""MCP Tool Schema definitions for recursive JSON Schema representation.""" import json from typing import Any, Dict, List, Optional, Union @@ -147,23 +145,17 @@ class ToolCall(BaseModel): }, } - @classmethod - def from_mcp_tool(cls, tool: Tool) -> "ToolCall": - """Creates a ToolCall instance from an MCP Tool object.""" - # MCP Tool inputSchema maps directly to our parameters ToolAttr - return cls( - name=tool.name, - description=tool.description or "", - parameters=ToolAttr(**tool.inputSchema), - ) - - def to_mcp_tool(self) -> Tool: - """Converts the instance back into an MCP Tool object.""" - return Tool( - name=self.name, - description=self.description, - inputSchema=self.parameters.simple_input_dump(), - ) + def simple_output_dump(self) -> dict: + """Convert ToolCall to output format dictionary for API responses.""" + return { + "index": self.index, + "id": self.id, + self.type: { + "arguments": self.arguments, + "name": self.name, + }, + "type": self.type, + } @property def argument_dict(self) -> dict: @@ -208,21 +200,27 @@ class ToolCall(BaseModel): return True except json.JSONDecodeError: # Try removing last character - if sanitized[-1] in ']}': + if sanitized[-1] in "]}": sanitized = sanitized[:-1].rstrip() else: break return False - def simple_output_dump(self) -> dict: - """Convert ToolCall to output format dictionary for API responses.""" - return { - "index": self.index, - "id": self.id, - self.type: { - "arguments": self.arguments, - "name": self.name, - }, - "type": self.type, - } + @classmethod + def from_mcp_tool(cls, tool: Tool) -> "ToolCall": + """Creates a ToolCall instance from an MCP Tool object.""" + # MCP Tool inputSchema maps directly to our parameters ToolAttr + return cls( + name=tool.name, + description=tool.description or "", + parameters=ToolAttr(**tool.inputSchema), + ) + + def to_mcp_tool(self) -> Tool: + """Converts the instance back into an MCP Tool object.""" + return Tool( + name=self.name, + description=self.description, + inputSchema=self.parameters.simple_input_dump(), + ) diff --git a/reme_ai/core_old/schema/vector_node.py b/reme/core/schema/vector_node.py similarity index 100% rename from reme_ai/core_old/schema/vector_node.py rename to reme/core/schema/vector_node.py diff --git a/reme/core/utils/__init__.py b/reme/core/utils/__init__.py new file mode 100644 index 00000000..ce9d9b2d --- /dev/null +++ b/reme/core/utils/__init__.py @@ -0,0 +1,7 @@ +"""utils""" + +from .singleton import singleton + +__all__ = [ + "singleton", +] diff --git a/reme_ai/core/utils/singleton.py b/reme/core/utils/singleton.py similarity index 100% rename from reme_ai/core/utils/singleton.py rename to reme/core/utils/singleton.py diff --git a/reme_ai/core/__init__.py b/reme_ai/core/__init__.py index e69de29b..8eab5792 100644 --- a/reme_ai/core/__init__.py +++ b/reme_ai/core/__init__.py @@ -0,0 +1,17 @@ +"""Core module for ReMe AI framework.""" + +# pylint: disable=wrong-import-position +# flake8: noqa: F401 + +from . import config +from . import context +from . import embedding +from . import enumeration +from . import flow +from . import llm +from . import op +from . import schema +from . import service +from . import token_counter +from . import utils +from . import vector_store diff --git a/reme_ai/core_old/application.py b/reme_ai/core/application.py similarity index 100% rename from reme_ai/core_old/application.py rename to reme_ai/core/application.py diff --git a/reme_ai/core_old/config/__init__.py b/reme_ai/core/config/__init__.py similarity index 100% rename from reme_ai/core_old/config/__init__.py rename to reme_ai/core/config/__init__.py diff --git a/reme_ai/core_old/config/default.yaml b/reme_ai/core/config/default.yaml similarity index 100% rename from reme_ai/core_old/config/default.yaml rename to reme_ai/core/config/default.yaml diff --git a/reme_ai/core_old/config/reme_config_parser.py b/reme_ai/core/config/reme_config_parser.py similarity index 100% rename from reme_ai/core_old/config/reme_config_parser.py rename to reme_ai/core/config/reme_config_parser.py diff --git a/reme_ai/core/context/__init__.py b/reme_ai/core/context/__init__.py index 27957fd2..7f26d600 100644 --- a/reme_ai/core/context/__init__.py +++ b/reme_ai/core/context/__init__.py @@ -2,10 +2,15 @@ from .base_context import BaseContext from .prompt_handler import PromptHandler -from .registry_factory import R +from .registry import Registry +from .runtime_context import RuntimeContext +from .service_context import ServiceContext, C __all__ = [ "BaseContext", "PromptHandler", - "R", + "Registry", + "RuntimeContext", + "ServiceContext", + "C", ] diff --git a/reme_ai/core/context/prompt_handler.py b/reme_ai/core/context/prompt_handler.py index e6b6d737..b428b163 100644 --- a/reme_ai/core/context/prompt_handler.py +++ b/reme_ai/core/context/prompt_handler.py @@ -1,99 +1,24 @@ -"""Module for managing and formatting prompt templates from files or dictionaries. +"""Module for managing and formatting prompt templates from files or dictionaries.""" -This module provides a PromptHandler class that: -- Loads prompts from YAML/JSON files or dictionaries -- Supports multi-language prompts with automatic suffix handling -- Provides conditional line filtering using boolean flags -- Formats prompts with template variable substitution -- Validates format strings and provides helpful error messages -""" - -import json from pathlib import Path -from string import Formatter -from typing import Any, Dict, Optional, Union import yaml from loguru import logger from .base_context import BaseContext - - -class PromptNotFoundError(KeyError): - """Exception raised when a requested prompt template is not found.""" - - def __init__(self, prompt_name: str, available_prompts: list[str]): - self.prompt_name = prompt_name - self.available_prompts = available_prompts - super().__init__( - f"Prompt '{prompt_name}' not found. " - f"Available prompts: {', '.join(available_prompts[:10])}" - f"{'...' if len(available_prompts) > 10 else ''}", - ) - - -class PromptFormattingError(ValueError): - """Exception raised when prompt formatting fails.""" +from .service_context import C class PromptHandler(BaseContext): - """A context-aware handler for loading, retrieving, and formatting prompt templates. - - This handler supports: - - Loading prompts from YAML/JSON files or dictionaries - - Multi-language prompt support with automatic language suffix - - Conditional line filtering using boolean flags (e.g., [debug], [verbose]) - - Template variable substitution with validation - - Method chaining for fluent API - - Examples: - >>> handler = PromptHandler(language="en") - >>> handler.load_prompt_dict({ - ... "greeting_en": "Hello, {name}!", - ... "farewell_en": "[debug]Debug mode\\nGoodbye, {name}!" - ... }) - >>> handler.prompt_format("greeting", name="Alice") - 'Hello, Alice!' - >>> handler.prompt_format("farewell", name="Bob", debug=False) - 'Goodbye, Bob!' - """ + """A context-aware handler for loading, retrieving, and formatting prompt templates.""" def __init__(self, language: str = "", **kwargs): - """Initialize the PromptHandler with optional language configuration. - - Args: - language: Language code to append as suffix (e.g., "en", "zh", "ja"). - If provided, get_prompt will automatically try to find - prompts with this suffix (e.g., "greeting" -> "greeting_en"). - **kwargs: Additional key-value pairs to initialize the context. - """ + """Initialize the handler with a specific language and optional context data.""" super().__init__(**kwargs) - self.language: str = language.strip() + self.language: str = language or C.language - def load_prompt_by_file( - self, - prompt_file_path: Optional[Union[Path, str]] = None, - overwrite: bool = True, - ) -> "PromptHandler": - """Load prompt configurations from a YAML or JSON file into the context. - - Supports both YAML (.yaml, .yml) and JSON (.json) file formats. - Non-existent files are silently skipped. - - Args: - prompt_file_path: Path to the prompt configuration file. - If None, returns self without changes. - overwrite: If True, allows overwriting existing prompts with warnings. - If False, skips existing prompts without overwriting. - - Returns: - Self for method chaining. - - Raises: - ValueError: If file format is not supported. - yaml.YAMLError: If YAML parsing fails. - json.JSONDecodeError: If JSON parsing fails. - """ + def load_prompt_by_file(self, prompt_file_path: Path | str = None): + """Load prompt configurations from a YAML file into the context.""" if prompt_file_path is None: return self @@ -101,263 +26,70 @@ class PromptHandler(BaseContext): prompt_file_path = Path(prompt_file_path) if not prompt_file_path.exists(): - logger.warning(f"Prompt file not found: {prompt_file_path}") return self - suffix = prompt_file_path.suffix.lower() - - try: - with prompt_file_path.open(encoding="utf-8") as f: - if suffix in [".yaml", ".yml"]: - prompt_dict = yaml.safe_load(f) - elif suffix == ".json": - prompt_dict = json.load(f) - else: - raise ValueError( - f"Unsupported file format: {suffix}. " f"Supported formats: .yaml, .yml, .json", - ) - - logger.info(f"Loaded {len(prompt_dict or {})} prompts from {prompt_file_path}") - self.load_prompt_dict(prompt_dict, overwrite=overwrite) - - except (yaml.YAMLError, json.JSONDecodeError) as e: - logger.error(f"Failed to parse prompt file {prompt_file_path}: {e}") - raise - + with prompt_file_path.open(encoding="utf-8") as f: + # Load YAML content using the full loader + prompt_dict = yaml.load(f, yaml.FullLoader) + self.load_prompt_dict(prompt_dict) return self - def load_prompt_dict( - self, - prompt_dict: Optional[Dict[str, Any]] = None, - overwrite: bool = True, - ) -> "PromptHandler": - """Merge a dictionary of prompt strings into the current context. - - Only string values are stored as prompts. Non-string values are skipped. - - Args: - prompt_dict: Dictionary mapping prompt names to prompt template strings. - overwrite: If True, allows overwriting existing prompts with warnings. - If False, skips existing prompts without overwriting. - - Returns: - Self for method chaining. - """ + def load_prompt_dict(self, prompt_dict: dict = None): + """Merge a dictionary of prompt strings into the current context.""" if not prompt_dict: return self for key, value in prompt_dict.items(): - if not isinstance(value, str): - logger.debug(f"Skipping non-string prompt: key={key}, type={type(value)}") - continue - - if key in self: - if overwrite: - logger.warning( - f"Overwriting prompt '{key}': " f"old length={len(self[key])}, new length={len(value)}", - ) - self[key] = value + if isinstance(value, str): + if key in self: + logger.warning(f"Overwriting prompt key={key}, old_value={self[key]}, new_value={value}") else: - logger.debug(f"Skipping existing prompt: key={key}") - else: - logger.debug(f"Adding new prompt: key={key}, length={len(value)}") + logger.debug(f"Adding new prompt key={key}, value={value}") self[key] = value - return self - def get_prompt(self, prompt_name: str, fallback_to_base: bool = True) -> str: - """Retrieve a prompt by name with automatic language suffix handling. + def get_prompt(self, prompt_name: str): + """Retrieve a prompt by name, automatically appending the language suffix if needed.""" + key: str = prompt_name + if self.language and not key.endswith(self.language.strip()): + key += "_" + self.language.strip() - If a language is configured, this method will: - 1. First try to find the prompt with language suffix (e.g., "greeting_en") - 2. If not found and fallback_to_base is True, try the base name (e.g., "greeting") - 3. Otherwise, raise PromptNotFoundError + assert key in self, f"prompt_name={key} not found." + return self[key].strip() - Args: - prompt_name: Name of the prompt to retrieve. - fallback_to_base: If True and language-specific prompt not found, - fallback to prompt without language suffix. - - Returns: - The prompt template string, stripped of leading/trailing whitespace. - - Raises: - PromptNotFoundError: If the prompt is not found. - """ - # Try with language suffix first - if self.language and not prompt_name.endswith(f"_{self.language}"): - key_with_lang = f"{prompt_name}_{self.language}" - if key_with_lang in self: - return self[key_with_lang].strip() - - # Try base name - if prompt_name in self: - return self[prompt_name].strip() - - # Try fallback if enabled - if fallback_to_base and self.language: - # Check if prompt_name already has language suffix, try without it - if prompt_name.endswith(f"_{self.language}"): - base_name = prompt_name[: -(len(self.language) + 1)] - if base_name in self: - return self[base_name].strip() - - # Not found, raise error with helpful message - available = list(self.keys()) - raise PromptNotFoundError(prompt_name, available) - - def has_prompt(self, prompt_name: str) -> bool: - """Check if a prompt exists (with or without language suffix). - - Args: - prompt_name: Name of the prompt to check. - - Returns: - True if the prompt exists, False otherwise. - """ - try: - self.get_prompt(prompt_name) - return True - except PromptNotFoundError: - return False - - def list_prompts(self, language_filter: Optional[str] = None) -> list[str]: - """List all available prompt names. - - Args: - language_filter: If provided, only return prompts for this language. - If None, return all prompts. - - Returns: - List of prompt names. - """ - if language_filter is None: - return list(self.keys()) - - suffix = f"_{language_filter.strip()}" - return [key for key in self.keys() if key.endswith(suffix)] - - @staticmethod - def _extract_format_fields(template: str) -> set[str]: - """Extract all format field names from a template string. - - Args: - template: Template string with {variable} placeholders. - - Returns: - Set of field names used in the template. - """ - return {field_name for _, field_name, _, _ in Formatter().parse(template) if field_name is not None} - - @staticmethod - def _filter_conditional_lines(prompt: str, flags: Dict[str, bool]) -> str: - """Filter lines based on boolean flags. - - Lines starting with [flag_name] are conditionally included based on - the value of flags[flag_name]. If True, the line is included (without - the flag marker). If False, the line is excluded. - - Args: - prompt: The prompt text with conditional markers. - flags: Dictionary of flag names to boolean values. - - Returns: - Filtered prompt text. - """ - filtered_lines = [] - - for line in prompt.split("\n"): - # Check each flag - matched_flag = None - for flag_name in flags: - marker = f"[{flag_name}]" - if line.startswith(marker): - matched_flag = flag_name - break - - if matched_flag is None: - # No flag marker, always include - filtered_lines.append(line) - elif flags[matched_flag]: - # Flag is True, include without marker - marker = f"[{matched_flag}]" - filtered_lines.append(line[len(marker) :]) - # else: Flag is False, skip this line - - return "\n".join(filtered_lines) - - def prompt_format( - self, - prompt_name: str, - validate: bool = True, - **kwargs, - ) -> str: - """Format a prompt with conditional line filtering and variable substitution. - - This method performs two-stage formatting: - 1. Conditional line filtering: Lines marked with [flag] are included only - if the corresponding boolean kwarg is True. - 2. Variable substitution: Template variables {var} are replaced with - provided values. - - Args: - prompt_name: Name of the prompt to format. - validate: If True, check that all required template variables are provided. - **kwargs: Keyword arguments for formatting. Boolean values are treated as - conditional flags, other values are used for template substitution. - - Returns: - Formatted prompt string. - - Raises: - PromptNotFoundError: If the prompt is not found. - PromptFormattingError: If validation fails or formatting errors occur. - - Examples: - >>> handler = PromptHandler() - >>> handler["test"] = "[debug]Debug: {info}\\nResult: {value}" - >>> handler.prompt_format("test", debug=False, info="test", value=42) - 'Result: 42' - >>> handler.prompt_format("test", debug=True, info="test", value=42) - 'Debug: test\\nResult: 42' - """ - # Get the prompt template + def prompt_format(self, prompt_name: str, **kwargs) -> str: + """Format a prompt by filtering flagged lines and filling template variables.""" prompt = self.get_prompt(prompt_name) - # Separate boolean flags from format variables + # Separate boolean flags from string formatting arguments flag_kwargs = {k: v for k, v in kwargs.items() if isinstance(v, bool)} - format_kwargs = {k: v for k, v in kwargs.items() if not isinstance(v, bool)} + other_kwargs = {k: v for k, v in kwargs.items() if not isinstance(v, bool)} - # Step 1: Filter conditional lines if flag_kwargs: - prompt = self._filter_conditional_lines(prompt, flag_kwargs) + split_prompt = [] + for line in prompt.strip().split("\n"): + hit = False + hit_flag = True + for key, flag in flag_kwargs.items(): + if not line.startswith(f"[{key}]"): + continue - # Step 2: Validate required fields if requested - if validate: - required_fields = self._extract_format_fields(prompt) - missing_fields = required_fields - set(format_kwargs.keys()) + hit = True + hit_flag = flag + # Remove the flag prefix from the line + line = line.strip(f"[{key}]") + break - if missing_fields: - raise PromptFormattingError( - f"Missing required format variables for prompt '{prompt_name}': " - f"{', '.join(sorted(missing_fields))}", - ) + # Include line if no flag is present or if the flag evaluates to True + if not hit: + split_prompt.append(line) + elif hit_flag: + split_prompt.append(line) - # Step 3: Format with variables - try: - if format_kwargs: - prompt = prompt.format(**format_kwargs) - except KeyError as e: - raise PromptFormattingError( - f"Format error in prompt '{prompt_name}': missing variable {e}", - ) from e - except (ValueError, IndexError) as e: - raise PromptFormattingError( - f"Format error in prompt '{prompt_name}': {e}", - ) from e + prompt = "\n".join(split_prompt) - return prompt.strip() + if other_kwargs: + # Apply standard Python string formatting + prompt = prompt.format(**other_kwargs) - def __repr__(self) -> str: - """Return a string representation of the PromptHandler.""" - return f"PromptHandler(language='{self.language}', " f"num_prompts={len(self)})" + return prompt diff --git a/reme_ai/core_old/context/registry.py b/reme_ai/core/context/registry.py similarity index 100% rename from reme_ai/core_old/context/registry.py rename to reme_ai/core/context/registry.py diff --git a/reme_ai/core_old/context/runtime_context.py b/reme_ai/core/context/runtime_context.py similarity index 100% rename from reme_ai/core_old/context/runtime_context.py rename to reme_ai/core/context/runtime_context.py diff --git a/reme_ai/core_old/context/service_context.py b/reme_ai/core/context/service_context.py similarity index 100% rename from reme_ai/core_old/context/service_context.py rename to reme_ai/core/context/service_context.py diff --git a/reme_ai/core_old/embedding/__init__.py b/reme_ai/core/embedding/__init__.py similarity index 100% rename from reme_ai/core_old/embedding/__init__.py rename to reme_ai/core/embedding/__init__.py diff --git a/reme_ai/core_old/embedding/base_embedding_model.py b/reme_ai/core/embedding/base_embedding_model.py similarity index 100% rename from reme_ai/core_old/embedding/base_embedding_model.py rename to reme_ai/core/embedding/base_embedding_model.py diff --git a/reme_ai/core_old/embedding/openai_embedding_model.py b/reme_ai/core/embedding/openai_embedding_model.py similarity index 100% rename from reme_ai/core_old/embedding/openai_embedding_model.py rename to reme_ai/core/embedding/openai_embedding_model.py diff --git a/reme_ai/core_old/embedding/openai_embedding_model_sync.py b/reme_ai/core/embedding/openai_embedding_model_sync.py similarity index 100% rename from reme_ai/core_old/embedding/openai_embedding_model_sync.py rename to reme_ai/core/embedding/openai_embedding_model_sync.py diff --git a/reme_ai/core/enumeration/json_schema_enum.py b/reme_ai/core/enumeration/json_schema_enum.py index d66882e2..507645f4 100644 --- a/reme_ai/core/enumeration/json_schema_enum.py +++ b/reme_ai/core/enumeration/json_schema_enum.py @@ -1,38 +1,18 @@ -"""Defines the standard data types supported by JSON Schema. - -This enum maps common JSON Schema primitive types to their corresponding -Python runtime types, and provides a convenient string representation -compatible with JSON Schema (`"string"`, `"number"`, etc.). -""" +"""Defines the standard data types supported by JSON Schema.""" from enum import Enum class JsonSchemaEnum(Enum): - """Enumeration of valid JSON Schema data types. + """Enumeration of valid JSON Schema data types.""" - The enum value is the corresponding Python type, while the string - representation (`str(...)`) is the canonical JSON Schema type name. - """ - - # Textual data STRING = str - - # Numeric values, including integers and floats NUMBER = float - - # Integer-only numeric values INTEGER = int - - # JSON objects (key-value mappings) OBJECT = dict - - # Ordered JSON lists/arrays ARRAY = list - - # Boolean values: true / false BOOLEAN = bool def __str__(self) -> str: - """Return the lowercase JSON Schema type name for this enum member.""" + """Returns the string representation of the enum value.""" return self.name.lower() diff --git a/reme_ai/core/enumeration/memory_type.py b/reme_ai/core/enumeration/memory_type.py index b9f5ed29..22d35481 100644 --- a/reme_ai/core/enumeration/memory_type.py +++ b/reme_ai/core/enumeration/memory_type.py @@ -1,33 +1,25 @@ -"""Defines the high-level categories of memory managed by ReMe. - -This enumeration is used across the system to tag, route, and store different -kinds of memories (identity, personal context, procedures, tools, etc.). -""" +"""Memory type enumeration for the three-layer memory architecture.""" from enum import Enum class MemoryType(str, Enum): - """Enumeration of memory categories used by the memory subsystem. + """ + Three-layer memory architecture for agent memory management. - These types describe *what* a piece of memory is about, which guides - storage, retrieval, and summarization strategies. + Layer 1 - High-level Abstraction Memory: + - IDENTITY: Self-cognition (identity, personality, current state) + - PERSONAL: Person-specific memory (preferences and context about specific individuals) + - PROCEDURAL: Procedural memory (how-to knowledge, e.g., 4 steps to write financial reports) + - TOOL: Tool memory (tool usage patterns, success rates, token consumption, latency) + + Layer 2 - Summary Memory (Compressed): Summarized digest of raw message history + Layer 3 - History Memory (Raw): Raw message history """ - # Long‑term, relatively stable attributes about the user (name, roles, etc.) IDENTITY = "identity" - - # User-specific preferences, habits, and evolving personal context PERSONAL = "personal" - - # How‑to knowledge, workflows, and step‑by‑step instructions PROCEDURAL = "procedural" - - # Information learned about tools, APIs, and their usage patterns TOOL = "tool" - - # Condensed representation of larger memory collections SUMMARY = "summary" - - # Raw chronological interaction history, typically before summarization HISTORY = "history" diff --git a/reme_ai/core_old/flow/__init__.py b/reme_ai/core/flow/__init__.py similarity index 100% rename from reme_ai/core_old/flow/__init__.py rename to reme_ai/core/flow/__init__.py diff --git a/reme_ai/core_old/flow/base_flow.py b/reme_ai/core/flow/base_flow.py similarity index 100% rename from reme_ai/core_old/flow/base_flow.py rename to reme_ai/core/flow/base_flow.py diff --git a/reme_ai/core_old/flow/cmd_flow.py b/reme_ai/core/flow/cmd_flow.py similarity index 100% rename from reme_ai/core_old/flow/cmd_flow.py rename to reme_ai/core/flow/cmd_flow.py diff --git a/reme_ai/core_old/flow/expression_flow.py b/reme_ai/core/flow/expression_flow.py similarity index 100% rename from reme_ai/core_old/flow/expression_flow.py rename to reme_ai/core/flow/expression_flow.py diff --git a/reme_ai/core_old/flow/simple_flow.py b/reme_ai/core/flow/simple_flow.py similarity index 100% rename from reme_ai/core_old/flow/simple_flow.py rename to reme_ai/core/flow/simple_flow.py diff --git a/reme_ai/core_old/llm/__init__.py b/reme_ai/core/llm/__init__.py similarity index 100% rename from reme_ai/core_old/llm/__init__.py rename to reme_ai/core/llm/__init__.py diff --git a/reme_ai/core_old/llm/base_llm.py b/reme_ai/core/llm/base_llm.py similarity index 100% rename from reme_ai/core_old/llm/base_llm.py rename to reme_ai/core/llm/base_llm.py diff --git a/reme_ai/core_old/llm/lite_llm.py b/reme_ai/core/llm/lite_llm.py similarity index 100% rename from reme_ai/core_old/llm/lite_llm.py rename to reme_ai/core/llm/lite_llm.py diff --git a/reme_ai/core_old/llm/lite_llm_sync.py b/reme_ai/core/llm/lite_llm_sync.py similarity index 100% rename from reme_ai/core_old/llm/lite_llm_sync.py rename to reme_ai/core/llm/lite_llm_sync.py diff --git a/reme_ai/core_old/llm/openai_llm.py b/reme_ai/core/llm/openai_llm.py similarity index 100% rename from reme_ai/core_old/llm/openai_llm.py rename to reme_ai/core/llm/openai_llm.py diff --git a/reme_ai/core_old/llm/openai_llm_sync.py b/reme_ai/core/llm/openai_llm_sync.py similarity index 100% rename from reme_ai/core_old/llm/openai_llm_sync.py rename to reme_ai/core/llm/openai_llm_sync.py diff --git a/reme_ai/core_old/main.py b/reme_ai/core/main.py similarity index 100% rename from reme_ai/core_old/main.py rename to reme_ai/core/main.py diff --git a/reme_ai/core_old/op/__init__.py b/reme_ai/core/op/__init__.py similarity index 100% rename from reme_ai/core_old/op/__init__.py rename to reme_ai/core/op/__init__.py diff --git a/reme_ai/core_old/op/base_op.py b/reme_ai/core/op/base_op.py similarity index 100% rename from reme_ai/core_old/op/base_op.py rename to reme_ai/core/op/base_op.py diff --git a/reme_ai/core_old/op/base_ray_op.py b/reme_ai/core/op/base_ray_op.py similarity index 100% rename from reme_ai/core_old/op/base_ray_op.py rename to reme_ai/core/op/base_ray_op.py diff --git a/reme_ai/core_old/op/mcp_tool.py b/reme_ai/core/op/mcp_tool.py similarity index 100% rename from reme_ai/core_old/op/mcp_tool.py rename to reme_ai/core/op/mcp_tool.py diff --git a/reme_ai/core_old/op/parallel_op.py b/reme_ai/core/op/parallel_op.py similarity index 100% rename from reme_ai/core_old/op/parallel_op.py rename to reme_ai/core/op/parallel_op.py diff --git a/reme_ai/core_old/op/sequential_op.py b/reme_ai/core/op/sequential_op.py similarity index 100% rename from reme_ai/core_old/op/sequential_op.py rename to reme_ai/core/op/sequential_op.py diff --git a/reme_ai/core_old/reme.py b/reme_ai/core/reme.py similarity index 100% rename from reme_ai/core_old/reme.py rename to reme_ai/core/reme.py diff --git a/reme_ai/core/schema/memory_node.py b/reme_ai/core/schema/memory_node.py index 67ed7c43..304dfe5c 100644 --- a/reme_ai/core/schema/memory_node.py +++ b/reme_ai/core/schema/memory_node.py @@ -6,6 +6,7 @@ memories in the ReMe system. import datetime import hashlib +import json from typing import Any from pydantic import BaseModel, Field, model_validator @@ -145,6 +146,30 @@ class MemoryNode(BaseModel): metadata=metadata, ) + def format_memory(self) -> str: + """Format memory as human-readable string. + + Returns: + str: Formatted string with when_to_use, content, and ref_memory_id. + """ + parts: list[str] = [ + f"memory_id={self.memory_id}", + ] + + if self.when_to_use: + parts.append(self.when_to_use) + + if self.content: + parts.append(self.content) + + if self.metadata: + parts.append(f"metadata={json.dumps(self.metadata, ensure_ascii=False)}") + + if self.ref_memory_id: + parts.append(f"ref_memory_id={self.ref_memory_id}") + + return " ".join(parts) + @classmethod def from_vector_node(cls, node: VectorNode) -> "MemoryNode": """Reconstruct MemoryNode from VectorNode. diff --git a/reme_ai/core/schema/message.py b/reme_ai/core/schema/message.py index 321dd8c8..6c3299e7 100644 --- a/reme_ai/core/schema/message.py +++ b/reme_ai/core/schema/message.py @@ -132,7 +132,7 @@ class Message(BaseModel): def strip_md_func(line): if strip_markdown_headers: - line = re.sub(r"\n##+ +", "\n", line) + line = re.sub(r'\n##+ +', '\n', line) return line if add_reasoning and self.reasoning_content: @@ -143,9 +143,8 @@ class Message(BaseModel): elif isinstance(self.content, list): for block in self.content: - text = ( - block.content if isinstance(block.content, str) else json.dumps(block.content, ensure_ascii=False) - ) + text = block.content if isinstance(block.content, str) else \ + json.dumps(block.content, ensure_ascii=False) text = str(text) lines.append(strip_md_func(text)) diff --git a/reme_ai/core/schema/service_config.py b/reme_ai/core/schema/service_config.py index e1ae9df7..4c6eb543 100644 --- a/reme_ai/core/schema/service_config.py +++ b/reme_ai/core/schema/service_config.py @@ -101,7 +101,7 @@ class ServiceConfig(BaseModel): init_logger: bool = Field(default=True) disabled_flows: List[str] = Field(default_factory=list) enabled_flows: List[str] = Field(default_factory=list) - mcp_servers: Dict[str, dict] = Field(default_factory=dict) + mcp_servers: Dict[str, dict] = Field(default_factory=dict, description="External MCP Server configuration") mcp: MCPConfig = Field(default_factory=MCPConfig) http: HttpConfig = Field(default_factory=HttpConfig) diff --git a/reme_ai/core/schema/tool_call.py b/reme_ai/core/schema/tool_call.py index 70355d60..3c01cdcd 100644 --- a/reme_ai/core/schema/tool_call.py +++ b/reme_ai/core/schema/tool_call.py @@ -1,4 +1,6 @@ -"""MCP Tool Schema definitions for recursive JSON Schema representation.""" +""" +MCP Tool Schema definitions for recursive JSON Schema representation. +""" import json from typing import Any, Dict, List, Optional, Union @@ -145,17 +147,23 @@ class ToolCall(BaseModel): }, } - def simple_output_dump(self) -> dict: - """Convert ToolCall to output format dictionary for API responses.""" - return { - "index": self.index, - "id": self.id, - self.type: { - "arguments": self.arguments, - "name": self.name, - }, - "type": self.type, - } + @classmethod + def from_mcp_tool(cls, tool: Tool) -> "ToolCall": + """Creates a ToolCall instance from an MCP Tool object.""" + # MCP Tool inputSchema maps directly to our parameters ToolAttr + return cls( + name=tool.name, + description=tool.description or "", + parameters=ToolAttr(**tool.inputSchema), + ) + + def to_mcp_tool(self) -> Tool: + """Converts the instance back into an MCP Tool object.""" + return Tool( + name=self.name, + description=self.description, + inputSchema=self.parameters.simple_input_dump(), + ) @property def argument_dict(self) -> dict: @@ -200,27 +208,21 @@ class ToolCall(BaseModel): return True except json.JSONDecodeError: # Try removing last character - if sanitized[-1] in "]}": + if sanitized[-1] in ']}': sanitized = sanitized[:-1].rstrip() else: break return False - @classmethod - def from_mcp_tool(cls, tool: Tool) -> "ToolCall": - """Creates a ToolCall instance from an MCP Tool object.""" - # MCP Tool inputSchema maps directly to our parameters ToolAttr - return cls( - name=tool.name, - description=tool.description or "", - parameters=ToolAttr(**tool.inputSchema), - ) - - def to_mcp_tool(self) -> Tool: - """Converts the instance back into an MCP Tool object.""" - return Tool( - name=self.name, - description=self.description, - inputSchema=self.parameters.simple_input_dump(), - ) + def simple_output_dump(self) -> dict: + """Convert ToolCall to output format dictionary for API responses.""" + return { + "index": self.index, + "id": self.id, + self.type: { + "arguments": self.arguments, + "name": self.name, + }, + "type": self.type, + } diff --git a/reme_ai/core_old/service/__init__.py b/reme_ai/core/service/__init__.py similarity index 100% rename from reme_ai/core_old/service/__init__.py rename to reme_ai/core/service/__init__.py diff --git a/reme_ai/core_old/service/base_service.py b/reme_ai/core/service/base_service.py similarity index 100% rename from reme_ai/core_old/service/base_service.py rename to reme_ai/core/service/base_service.py diff --git a/reme_ai/core_old/service/cmd_service.py b/reme_ai/core/service/cmd_service.py similarity index 100% rename from reme_ai/core_old/service/cmd_service.py rename to reme_ai/core/service/cmd_service.py diff --git a/reme_ai/core_old/service/http_service.py b/reme_ai/core/service/http_service.py similarity index 100% rename from reme_ai/core_old/service/http_service.py rename to reme_ai/core/service/http_service.py diff --git a/reme_ai/core_old/service/mcp_service.py b/reme_ai/core/service/mcp_service.py similarity index 100% rename from reme_ai/core_old/service/mcp_service.py rename to reme_ai/core/service/mcp_service.py diff --git a/reme_ai/core_old/token_counter/__init__.py b/reme_ai/core/token_counter/__init__.py similarity index 100% rename from reme_ai/core_old/token_counter/__init__.py rename to reme_ai/core/token_counter/__init__.py diff --git a/reme_ai/core_old/token_counter/base_token_counter.py b/reme_ai/core/token_counter/base_token_counter.py similarity index 100% rename from reme_ai/core_old/token_counter/base_token_counter.py rename to reme_ai/core/token_counter/base_token_counter.py diff --git a/reme_ai/core_old/token_counter/hf_token_counter.py b/reme_ai/core/token_counter/hf_token_counter.py similarity index 100% rename from reme_ai/core_old/token_counter/hf_token_counter.py rename to reme_ai/core/token_counter/hf_token_counter.py diff --git a/reme_ai/core_old/token_counter/openai_token_counter.py b/reme_ai/core/token_counter/openai_token_counter.py similarity index 100% rename from reme_ai/core_old/token_counter/openai_token_counter.py rename to reme_ai/core/token_counter/openai_token_counter.py diff --git a/reme_ai/core/utils/__init__.py b/reme_ai/core/utils/__init__.py index ce9d9b2d..23396f97 100644 --- a/reme_ai/core/utils/__init__.py +++ b/reme_ai/core/utils/__init__.py @@ -1,7 +1,47 @@ """utils""" +from .cache_handler import CacheHandler +from .case_converter import snake_to_camel, camel_to_snake +from .common_utils import run_coro_safely, execute_stream_task +from .env_utils import load_env +from .execute_tuils import exec_code, run_shell_command +from .http_client import HttpClient +from .llm_utils import extract_content, format_messages, deduplicate_memories +from .logger_utils import init_logger +from .logo_utils import print_logo + +# Make MCPClient import optional to avoid breaking if MCP dependencies are not available +try: + from .mcp_client import MCPClient + _HAS_MCP = True +except ImportError: + MCPClient = None + _HAS_MCP = False + +from .pydantic_config_parser import PydanticConfigParser +from .pydantic_utils import create_pydantic_model from .singleton import singleton +from .time import timer, get_now_time __all__ = [ + "CacheHandler", + "snake_to_camel", + "camel_to_snake", + "run_coro_safely", + "execute_stream_task", + "load_env", + "exec_code", + "run_shell_command", + "HttpClient", + "extract_content", + "format_messages", + "deduplicate_memories", + "init_logger", + "print_logo", + "MCPClient", + "PydanticConfigParser", + "create_pydantic_model", "singleton", + "timer", + "get_now_time", ] diff --git a/reme_ai/core_old/utils/cache_handler.py b/reme_ai/core/utils/cache_handler.py similarity index 100% rename from reme_ai/core_old/utils/cache_handler.py rename to reme_ai/core/utils/cache_handler.py diff --git a/reme_ai/core_old/utils/case_converter.py b/reme_ai/core/utils/case_converter.py similarity index 100% rename from reme_ai/core_old/utils/case_converter.py rename to reme_ai/core/utils/case_converter.py diff --git a/reme_ai/core_old/utils/common_utils.py b/reme_ai/core/utils/common_utils.py similarity index 100% rename from reme_ai/core_old/utils/common_utils.py rename to reme_ai/core/utils/common_utils.py diff --git a/reme_ai/core_old/utils/env_utils.py b/reme_ai/core/utils/env_utils.py similarity index 100% rename from reme_ai/core_old/utils/env_utils.py rename to reme_ai/core/utils/env_utils.py diff --git a/reme_ai/core_old/utils/execute_tuils.py b/reme_ai/core/utils/execute_tuils.py similarity index 100% rename from reme_ai/core_old/utils/execute_tuils.py rename to reme_ai/core/utils/execute_tuils.py diff --git a/reme_ai/core_old/utils/http_client.py b/reme_ai/core/utils/http_client.py similarity index 100% rename from reme_ai/core_old/utils/http_client.py rename to reme_ai/core/utils/http_client.py diff --git a/reme_ai/core_old/utils/llm_utils.py b/reme_ai/core/utils/llm_utils.py similarity index 100% rename from reme_ai/core_old/utils/llm_utils.py rename to reme_ai/core/utils/llm_utils.py diff --git a/reme_ai/core_old/utils/logger_utils.py b/reme_ai/core/utils/logger_utils.py similarity index 100% rename from reme_ai/core_old/utils/logger_utils.py rename to reme_ai/core/utils/logger_utils.py diff --git a/reme_ai/core_old/utils/logo_utils.py b/reme_ai/core/utils/logo_utils.py similarity index 100% rename from reme_ai/core_old/utils/logo_utils.py rename to reme_ai/core/utils/logo_utils.py diff --git a/reme_ai/core_old/utils/mcp_client.py b/reme_ai/core/utils/mcp_client.py similarity index 100% rename from reme_ai/core_old/utils/mcp_client.py rename to reme_ai/core/utils/mcp_client.py diff --git a/reme_ai/core_old/utils/pydantic_config_parser.py b/reme_ai/core/utils/pydantic_config_parser.py similarity index 100% rename from reme_ai/core_old/utils/pydantic_config_parser.py rename to reme_ai/core/utils/pydantic_config_parser.py diff --git a/reme_ai/core_old/utils/pydantic_utils.py b/reme_ai/core/utils/pydantic_utils.py similarity index 100% rename from reme_ai/core_old/utils/pydantic_utils.py rename to reme_ai/core/utils/pydantic_utils.py diff --git a/reme_ai/core_old/utils/time.py b/reme_ai/core/utils/time.py similarity index 100% rename from reme_ai/core_old/utils/time.py rename to reme_ai/core/utils/time.py diff --git a/reme_ai/core_old/vector_store/__init__.py b/reme_ai/core/vector_store/__init__.py similarity index 100% rename from reme_ai/core_old/vector_store/__init__.py rename to reme_ai/core/vector_store/__init__.py diff --git a/reme_ai/core_old/vector_store/base_vector_store.py b/reme_ai/core/vector_store/base_vector_store.py similarity index 97% rename from reme_ai/core_old/vector_store/base_vector_store.py rename to reme_ai/core/vector_store/base_vector_store.py index 158af0d9..a4a8ca8e 100644 --- a/reme_ai/core_old/vector_store/base_vector_store.py +++ b/reme_ai/core/vector_store/base_vector_store.py @@ -5,9 +5,9 @@ from abc import ABC, abstractmethod from collections.abc import Callable from functools import partial -from reme_ai.core_old.context import C -from reme_ai.core_old.embedding import BaseEmbeddingModel -from reme_ai.core_old.schema import VectorNode +from reme_ai.core.context import C +from reme_ai.core.embedding import BaseEmbeddingModel +from reme_ai.core.schema import VectorNode class BaseVectorStore(ABC): diff --git a/reme_ai/core_old/vector_store/chroma_vector_store.py b/reme_ai/core/vector_store/chroma_vector_store.py similarity index 100% rename from reme_ai/core_old/vector_store/chroma_vector_store.py rename to reme_ai/core/vector_store/chroma_vector_store.py diff --git a/reme_ai/core_old/vector_store/es_vector_store.py b/reme_ai/core/vector_store/es_vector_store.py similarity index 100% rename from reme_ai/core_old/vector_store/es_vector_store.py rename to reme_ai/core/vector_store/es_vector_store.py diff --git a/reme_ai/core_old/vector_store/local_vector_store.py b/reme_ai/core/vector_store/local_vector_store.py similarity index 100% rename from reme_ai/core_old/vector_store/local_vector_store.py rename to reme_ai/core/vector_store/local_vector_store.py diff --git a/reme_ai/core_old/vector_store/pgvector_store.py b/reme_ai/core/vector_store/pgvector_store.py similarity index 100% rename from reme_ai/core_old/vector_store/pgvector_store.py rename to reme_ai/core/vector_store/pgvector_store.py diff --git a/reme_ai/core_old/vector_store/qdrant_vector_store.py b/reme_ai/core/vector_store/qdrant_vector_store.py similarity index 100% rename from reme_ai/core_old/vector_store/qdrant_vector_store.py rename to reme_ai/core/vector_store/qdrant_vector_store.py diff --git a/reme_ai/core_old/__init__.py b/reme_ai/core_old/__init__.py deleted file mode 100644 index 8eab5792..00000000 --- a/reme_ai/core_old/__init__.py +++ /dev/null @@ -1,17 +0,0 @@ -"""Core module for ReMe AI framework.""" - -# pylint: disable=wrong-import-position -# flake8: noqa: F401 - -from . import config -from . import context -from . import embedding -from . import enumeration -from . import flow -from . import llm -from . import op -from . import schema -from . import service -from . import token_counter -from . import utils -from . import vector_store diff --git a/reme_ai/core_old/context/__init__.py b/reme_ai/core_old/context/__init__.py deleted file mode 100644 index 7f26d600..00000000 --- a/reme_ai/core_old/context/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -"""context""" - -from .base_context import BaseContext -from .prompt_handler import PromptHandler -from .registry import Registry -from .runtime_context import RuntimeContext -from .service_context import ServiceContext, C - -__all__ = [ - "BaseContext", - "PromptHandler", - "Registry", - "RuntimeContext", - "ServiceContext", - "C", -] diff --git a/reme_ai/core_old/context/prompt_handler.py b/reme_ai/core_old/context/prompt_handler.py deleted file mode 100644 index b428b163..00000000 --- a/reme_ai/core_old/context/prompt_handler.py +++ /dev/null @@ -1,95 +0,0 @@ -"""Module for managing and formatting prompt templates from files or dictionaries.""" - -from pathlib import Path - -import yaml -from loguru import logger - -from .base_context import BaseContext -from .service_context import C - - -class PromptHandler(BaseContext): - """A context-aware handler for loading, retrieving, and formatting prompt templates.""" - - def __init__(self, language: str = "", **kwargs): - """Initialize the handler with a specific language and optional context data.""" - super().__init__(**kwargs) - self.language: str = language or C.language - - def load_prompt_by_file(self, prompt_file_path: Path | str = None): - """Load prompt configurations from a YAML file into the context.""" - if prompt_file_path is None: - return self - - if isinstance(prompt_file_path, str): - prompt_file_path = Path(prompt_file_path) - - if not prompt_file_path.exists(): - return self - - with prompt_file_path.open(encoding="utf-8") as f: - # Load YAML content using the full loader - prompt_dict = yaml.load(f, yaml.FullLoader) - self.load_prompt_dict(prompt_dict) - return self - - def load_prompt_dict(self, prompt_dict: dict = None): - """Merge a dictionary of prompt strings into the current context.""" - if not prompt_dict: - return self - - for key, value in prompt_dict.items(): - if isinstance(value, str): - if key in self: - logger.warning(f"Overwriting prompt key={key}, old_value={self[key]}, new_value={value}") - else: - logger.debug(f"Adding new prompt key={key}, value={value}") - self[key] = value - return self - - def get_prompt(self, prompt_name: str): - """Retrieve a prompt by name, automatically appending the language suffix if needed.""" - key: str = prompt_name - if self.language and not key.endswith(self.language.strip()): - key += "_" + self.language.strip() - - assert key in self, f"prompt_name={key} not found." - return self[key].strip() - - def prompt_format(self, prompt_name: str, **kwargs) -> str: - """Format a prompt by filtering flagged lines and filling template variables.""" - prompt = self.get_prompt(prompt_name) - - # Separate boolean flags from string formatting arguments - flag_kwargs = {k: v for k, v in kwargs.items() if isinstance(v, bool)} - other_kwargs = {k: v for k, v in kwargs.items() if not isinstance(v, bool)} - - if flag_kwargs: - split_prompt = [] - for line in prompt.strip().split("\n"): - hit = False - hit_flag = True - for key, flag in flag_kwargs.items(): - if not line.startswith(f"[{key}]"): - continue - - hit = True - hit_flag = flag - # Remove the flag prefix from the line - line = line.strip(f"[{key}]") - break - - # Include line if no flag is present or if the flag evaluates to True - if not hit: - split_prompt.append(line) - elif hit_flag: - split_prompt.append(line) - - prompt = "\n".join(split_prompt) - - if other_kwargs: - # Apply standard Python string formatting - prompt = prompt.format(**other_kwargs) - - return prompt diff --git a/reme_ai/core_old/enumeration/json_schema_enum.py b/reme_ai/core_old/enumeration/json_schema_enum.py deleted file mode 100644 index 507645f4..00000000 --- a/reme_ai/core_old/enumeration/json_schema_enum.py +++ /dev/null @@ -1,18 +0,0 @@ -"""Defines the standard data types supported by JSON Schema.""" - -from enum import Enum - - -class JsonSchemaEnum(Enum): - """Enumeration of valid JSON Schema data types.""" - - STRING = str - NUMBER = float - INTEGER = int - OBJECT = dict - ARRAY = list - BOOLEAN = bool - - def __str__(self) -> str: - """Returns the string representation of the enum value.""" - return self.name.lower() diff --git a/reme_ai/core_old/enumeration/memory_type.py b/reme_ai/core_old/enumeration/memory_type.py deleted file mode 100644 index 22d35481..00000000 --- a/reme_ai/core_old/enumeration/memory_type.py +++ /dev/null @@ -1,25 +0,0 @@ -"""Memory type enumeration for the three-layer memory architecture.""" - -from enum import Enum - - -class MemoryType(str, Enum): - """ - Three-layer memory architecture for agent memory management. - - Layer 1 - High-level Abstraction Memory: - - IDENTITY: Self-cognition (identity, personality, current state) - - PERSONAL: Person-specific memory (preferences and context about specific individuals) - - PROCEDURAL: Procedural memory (how-to knowledge, e.g., 4 steps to write financial reports) - - TOOL: Tool memory (tool usage patterns, success rates, token consumption, latency) - - Layer 2 - Summary Memory (Compressed): Summarized digest of raw message history - Layer 3 - History Memory (Raw): Raw message history - """ - - IDENTITY = "identity" - PERSONAL = "personal" - PROCEDURAL = "procedural" - TOOL = "tool" - SUMMARY = "summary" - HISTORY = "history" diff --git a/reme_ai/core_old/utils/__init__.py b/reme_ai/core_old/utils/__init__.py deleted file mode 100644 index 23396f97..00000000 --- a/reme_ai/core_old/utils/__init__.py +++ /dev/null @@ -1,47 +0,0 @@ -"""utils""" - -from .cache_handler import CacheHandler -from .case_converter import snake_to_camel, camel_to_snake -from .common_utils import run_coro_safely, execute_stream_task -from .env_utils import load_env -from .execute_tuils import exec_code, run_shell_command -from .http_client import HttpClient -from .llm_utils import extract_content, format_messages, deduplicate_memories -from .logger_utils import init_logger -from .logo_utils import print_logo - -# Make MCPClient import optional to avoid breaking if MCP dependencies are not available -try: - from .mcp_client import MCPClient - _HAS_MCP = True -except ImportError: - MCPClient = None - _HAS_MCP = False - -from .pydantic_config_parser import PydanticConfigParser -from .pydantic_utils import create_pydantic_model -from .singleton import singleton -from .time import timer, get_now_time - -__all__ = [ - "CacheHandler", - "snake_to_camel", - "camel_to_snake", - "run_coro_safely", - "execute_stream_task", - "load_env", - "exec_code", - "run_shell_command", - "HttpClient", - "extract_content", - "format_messages", - "deduplicate_memories", - "init_logger", - "print_logo", - "MCPClient", - "PydanticConfigParser", - "create_pydantic_model", - "singleton", - "timer", - "get_now_time", -] diff --git a/reme_ai/mem_agent/base_memory_agent.py b/reme_ai/mem_agent/base_memory_agent.py index 5ba0cad3..7c21bb19 100644 --- a/reme_ai/mem_agent/base_memory_agent.py +++ b/reme_ai/mem_agent/base_memory_agent.py @@ -6,9 +6,9 @@ from abc import ABCMeta from loguru import logger -from ..core_old.enumeration import Role, MemoryType -from ..core_old.op import BaseOp -from ..core_old.schema import Message, ToolCall, MemoryNode +from ..core.enumeration import Role, MemoryType +from ..core.op import BaseOp +from ..core.schema import Message, ToolCall, MemoryNode from ..mem_tool import BaseMemoryTool, ThinkTool diff --git a/reme_ai/mem_agent/chat/remy_agent.py b/reme_ai/mem_agent/chat/remy_agent.py index c7806617..1eaa9ac7 100644 --- a/reme_ai/mem_agent/chat/remy_agent.py +++ b/reme_ai/mem_agent/chat/remy_agent.py @@ -3,10 +3,10 @@ from typing import List from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role -from ...core_old.schema import Message -from ...core_old.utils import get_now_time +from ...core.context import C +from ...core.enumeration import Role +from ...core.schema import Message +from ...core.utils import get_now_time @C.register_op() diff --git a/reme_ai/mem_agent/chat/simple_chat.py b/reme_ai/mem_agent/chat/simple_chat.py index 9e09ffec..8a71c7a8 100644 --- a/reme_ai/mem_agent/chat/simple_chat.py +++ b/reme_ai/mem_agent/chat/simple_chat.py @@ -2,10 +2,10 @@ from loguru import logger -from ...core_old.context import C -from ...core_old.enumeration import Role -from ...core_old.op import BaseOp -from ...core_old.schema import Message, ToolCall +from ...core.context import C +from ...core.enumeration import Role +from ...core.op import BaseOp +from ...core.schema import Message, ToolCall @C.register_op() diff --git a/reme_ai/mem_agent/chat/stream_chat.py b/reme_ai/mem_agent/chat/stream_chat.py index 2b121446..470e4647 100644 --- a/reme_ai/mem_agent/chat/stream_chat.py +++ b/reme_ai/mem_agent/chat/stream_chat.py @@ -2,10 +2,10 @@ from loguru import logger -from ...core_old.context import C -from ...core_old.enumeration import Role, ChunkEnum -from ...core_old.op import BaseOp -from ...core_old.schema import Message, ToolCall +from ...core.context import C +from ...core.enumeration import Role, ChunkEnum +from ...core.op import BaseOp +from ...core.schema import Message, ToolCall @C.register_op() diff --git a/reme_ai/mem_agent/retriever/reme_retriever.py b/reme_ai/mem_agent/retriever/reme_retriever.py index 400e0d01..f3700b1e 100644 --- a/reme_ai/mem_agent/retriever/reme_retriever.py +++ b/reme_ai/mem_agent/retriever/reme_retriever.py @@ -3,10 +3,10 @@ from typing import List from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role -from ...core_old.schema import Message -from ...core_old.utils import get_now_time, format_messages +from ...core.context import C +from ...core.enumeration import Role +from ...core.schema import Message +from ...core.utils import get_now_time, format_messages @C.register_op() diff --git a/reme_ai/mem_agent/retriever_v2/reme_retriever_v2.py b/reme_ai/mem_agent/retriever_v2/reme_retriever_v2.py index fedfe188..3b934172 100644 --- a/reme_ai/mem_agent/retriever_v2/reme_retriever_v2.py +++ b/reme_ai/mem_agent/retriever_v2/reme_retriever_v2.py @@ -3,10 +3,10 @@ from typing import List from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role -from ...core_old.schema import Message -from ...core_old.utils import format_messages +from ...core.context import C +from ...core.enumeration import Role +from ...core.schema import Message +from ...core.utils import format_messages @C.register_op() diff --git a/reme_ai/mem_agent/summarizer/identity_summarizer.py b/reme_ai/mem_agent/summarizer/identity_summarizer.py index 0a9e1410..be571cdc 100644 --- a/reme_ai/mem_agent/summarizer/identity_summarizer.py +++ b/reme_ai/mem_agent/summarizer/identity_summarizer.py @@ -1,10 +1,10 @@ """Specialized agent for extracting and updating agent self-cognition memories.""" from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message -from ...core_old.utils import get_now_time, format_messages +from ...core.context import C +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message +from ...core.utils import get_now_time, format_messages @C.register_op() diff --git a/reme_ai/mem_agent/summarizer/personal_summarizer.py b/reme_ai/mem_agent/summarizer/personal_summarizer.py index 1c32f499..352fe1ee 100644 --- a/reme_ai/mem_agent/summarizer/personal_summarizer.py +++ b/reme_ai/mem_agent/summarizer/personal_summarizer.py @@ -1,10 +1,10 @@ """Specialized agent for extracting and managing personal memories about specific individuals.""" from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, ToolCall -from ...core_old.utils import get_now_time, format_messages +from ...core.context import C +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, ToolCall +from ...core.utils import get_now_time, format_messages @C.register_op() diff --git a/reme_ai/mem_agent/summarizer/procedural_summarizer.py b/reme_ai/mem_agent/summarizer/procedural_summarizer.py index 24a75339..e31422e4 100644 --- a/reme_ai/mem_agent/summarizer/procedural_summarizer.py +++ b/reme_ai/mem_agent/summarizer/procedural_summarizer.py @@ -1,10 +1,10 @@ """Specialized agent for extracting and managing procedural knowledge and workflows.""" from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message -from ...core_old.utils import get_now_time, format_messages +from ...core.context import C +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message +from ...core.utils import get_now_time, format_messages @C.register_op() diff --git a/reme_ai/mem_agent/summarizer/reme_summarizer.py b/reme_ai/mem_agent/summarizer/reme_summarizer.py index 5521762c..b2418db5 100644 --- a/reme_ai/mem_agent/summarizer/reme_summarizer.py +++ b/reme_ai/mem_agent/summarizer/reme_summarizer.py @@ -3,10 +3,10 @@ from loguru import logger from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, MemoryNode, ToolCall -from ...core_old.utils import get_now_time, format_messages +from ...core.context import C +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, MemoryNode, ToolCall +from ...core.utils import get_now_time, format_messages @C.register_op() diff --git a/reme_ai/mem_agent/summarizer/tool_summarizer.py b/reme_ai/mem_agent/summarizer/tool_summarizer.py index 1e9e33c0..50399bba 100644 --- a/reme_ai/mem_agent/summarizer/tool_summarizer.py +++ b/reme_ai/mem_agent/summarizer/tool_summarizer.py @@ -1,10 +1,10 @@ """Specialized agent for extracting and managing tool usage guidelines and best practices.""" from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message -from ...core_old.utils import get_now_time, format_messages +from ...core.context import C +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message +from ...core.utils import get_now_time, format_messages @C.register_op() diff --git a/reme_ai/mem_agent/summarizer_v2/personal_summarizer_v2.py b/reme_ai/mem_agent/summarizer_v2/personal_summarizer_v2.py index cc2794b3..17bf4c66 100644 --- a/reme_ai/mem_agent/summarizer_v2/personal_summarizer_v2.py +++ b/reme_ai/mem_agent/summarizer_v2/personal_summarizer_v2.py @@ -1,10 +1,10 @@ """Simplified personal memory summarizer using v2 memory tools.""" from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, ToolCall -from ...core_old.utils import format_messages +from ...core.context import C +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, ToolCall +from ...core.utils import format_messages @C.register_op() diff --git a/reme_ai/mem_agent/summarizer_v2/reme_summarizer_v2.py b/reme_ai/mem_agent/summarizer_v2/reme_summarizer_v2.py index aa680da9..1aae4ad4 100644 --- a/reme_ai/mem_agent/summarizer_v2/reme_summarizer_v2.py +++ b/reme_ai/mem_agent/summarizer_v2/reme_summarizer_v2.py @@ -3,10 +3,10 @@ from loguru import logger from ..base_memory_agent import BaseMemoryAgent -from ...core_old.context import C -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, MemoryNode, ToolCall -from ...core_old.utils import format_messages +from ...core.context import C +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, MemoryNode, ToolCall +from ...core.utils import format_messages @C.register_op() diff --git a/reme_ai/mem_agent/v3/personal_summarizer_v3.py b/reme_ai/mem_agent/v3/personal_summarizer_v3.py index 3f2c9ca9..0093884d 100644 --- a/reme_ai/mem_agent/v3/personal_summarizer_v3.py +++ b/reme_ai/mem_agent/v3/personal_summarizer_v3.py @@ -1,7 +1,7 @@ from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, ToolCall -from ...core_old.utils import format_messages +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, ToolCall +from ...core.utils import format_messages class PersonalSummarizerV3(BaseMemoryAgent): diff --git a/reme_ai/mem_agent/v3/reme_retriever_v3.py b/reme_ai/mem_agent/v3/reme_retriever_v3.py index 020b5ad2..8f5c62dc 100644 --- a/reme_ai/mem_agent/v3/reme_retriever_v3.py +++ b/reme_ai/mem_agent/v3/reme_retriever_v3.py @@ -3,9 +3,9 @@ from typing import List from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role -from ...core_old.schema import Message -from ...core_old.utils import format_messages +from ...core.enumeration import Role +from ...core.schema import Message +from ...core.utils import format_messages class ReMeRetrieverV3(BaseMemoryAgent): diff --git a/reme_ai/mem_agent/v3/reme_summarizer_v3.py b/reme_ai/mem_agent/v3/reme_summarizer_v3.py index 3e1f17f7..a0f466b9 100644 --- a/reme_ai/mem_agent/v3/reme_summarizer_v3.py +++ b/reme_ai/mem_agent/v3/reme_summarizer_v3.py @@ -1,9 +1,9 @@ from loguru import logger from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, MemoryNode, ToolCall -from ...core_old.utils import format_messages +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, MemoryNode, ToolCall +from ...core.utils import format_messages class ReMeSummarizerV3(BaseMemoryAgent): diff --git a/reme_ai/mem_agent/v4/personal_retriever_v4.py b/reme_ai/mem_agent/v4/personal_retriever_v4.py index 2ba0dba5..dedcf99a 100644 --- a/reme_ai/mem_agent/v4/personal_retriever_v4.py +++ b/reme_ai/mem_agent/v4/personal_retriever_v4.py @@ -1,7 +1,7 @@ from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message -from ...core_old.utils import format_messages +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message +from ...core.utils import format_messages from ...mem_tool.v4 import ReadUserProfile diff --git a/reme_ai/mem_agent/v4/personal_summarizer_v4.py b/reme_ai/mem_agent/v4/personal_summarizer_v4.py index 8cda9b24..c0e1d4f1 100644 --- a/reme_ai/mem_agent/v4/personal_summarizer_v4.py +++ b/reme_ai/mem_agent/v4/personal_summarizer_v4.py @@ -1,8 +1,8 @@ from loguru import logger from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, MemoryNode +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, MemoryNode class PersonalSummarizerV4(BaseMemoryAgent): diff --git a/reme_ai/mem_agent/v4/reme_retriever_v4.py b/reme_ai/mem_agent/v4/reme_retriever_v4.py index db5f92ae..48ab9f38 100644 --- a/reme_ai/mem_agent/v4/reme_retriever_v4.py +++ b/reme_ai/mem_agent/v4/reme_retriever_v4.py @@ -1,9 +1,9 @@ from loguru import logger from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role -from ...core_old.schema import Message -from ...core_old.utils import format_messages +from ...core.enumeration import Role +from ...core.schema import Message +from ...core.utils import format_messages class ReMeRetrieverV4(BaseMemoryAgent): diff --git a/reme_ai/mem_agent/v4/reme_summarizer_v4.py b/reme_ai/mem_agent/v4/reme_summarizer_v4.py index 7787d035..a4069c85 100644 --- a/reme_ai/mem_agent/v4/reme_summarizer_v4.py +++ b/reme_ai/mem_agent/v4/reme_summarizer_v4.py @@ -1,9 +1,9 @@ from loguru import logger from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, MemoryNode -from ...core_old.utils import format_messages +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, MemoryNode +from ...core.utils import format_messages class ReMeSummarizerV4(BaseMemoryAgent): diff --git a/reme_ai/mem_agent/wk/personal_summarizer_wk.py b/reme_ai/mem_agent/wk/personal_summarizer_wk.py index c95ac36b..e974f99a 100644 --- a/reme_ai/mem_agent/wk/personal_summarizer_wk.py +++ b/reme_ai/mem_agent/wk/personal_summarizer_wk.py @@ -1,7 +1,7 @@ from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, ToolCall -from ...core_old.utils import format_messages +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, ToolCall +from ...core.utils import format_messages class PersonalSummarizerWk(BaseMemoryAgent): diff --git a/reme_ai/mem_agent/wk/reme_retriever_wk.py b/reme_ai/mem_agent/wk/reme_retriever_wk.py index 21a5403a..c98de937 100644 --- a/reme_ai/mem_agent/wk/reme_retriever_wk.py +++ b/reme_ai/mem_agent/wk/reme_retriever_wk.py @@ -3,9 +3,9 @@ from typing import List from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role -from ...core_old.schema import Message -from ...core_old.utils import format_messages +from ...core.enumeration import Role +from ...core.schema import Message +from ...core.utils import format_messages class ReMeRetrieverV2(BaseMemoryAgent): diff --git a/reme_ai/mem_agent/wk/reme_summarizer_wk.py b/reme_ai/mem_agent/wk/reme_summarizer_wk.py index a04d230d..02a7dbf3 100644 --- a/reme_ai/mem_agent/wk/reme_summarizer_wk.py +++ b/reme_ai/mem_agent/wk/reme_summarizer_wk.py @@ -1,9 +1,9 @@ from loguru import logger from ..base_memory_agent import BaseMemoryAgent -from ...core_old.enumeration import Role, MemoryType -from ...core_old.schema import Message, MemoryNode, ToolCall -from ...core_old.utils import format_messages +from ...core.enumeration import Role, MemoryType +from ...core.schema import Message, MemoryNode, ToolCall +from ...core.utils import format_messages class ReMeSummarizerWk(BaseMemoryAgent): diff --git a/reme_ai/mem_tool/base_memory_tool.py b/reme_ai/mem_tool/base_memory_tool.py index 827066b9..8b124496 100644 --- a/reme_ai/mem_tool/base_memory_tool.py +++ b/reme_ai/mem_tool/base_memory_tool.py @@ -3,10 +3,10 @@ from abc import ABCMeta from pathlib import Path -from ..core_old.enumeration import MemoryType -from ..core_old.op import BaseOp -from ..core_old.schema import ToolCall, MemoryNode -from ..core_old.utils import CacheHandler +from ..core.enumeration import MemoryType +from ..core.op import BaseOp +from ..core.schema import ToolCall, MemoryNode +from ..core.utils import CacheHandler class BaseMemoryTool(BaseOp, metaclass=ABCMeta): diff --git a/reme_ai/mem_tool/hands_off_tool.py b/reme_ai/mem_tool/hands_off_tool.py index 7ab65cd7..2cb28d60 100644 --- a/reme_ai/mem_tool/hands_off_tool.py +++ b/reme_ai/mem_tool/hands_off_tool.py @@ -6,8 +6,8 @@ from typing import TYPE_CHECKING from loguru import logger from .base_memory_tool import BaseMemoryTool -from ..core_old.context import C -from ..core_old.enumeration import MemoryType +from ..core.context import C +from ..core.enumeration import MemoryType if TYPE_CHECKING: from ..mem_agent import BaseMemoryAgent diff --git a/reme_ai/mem_tool/history/add_history_memory.py b/reme_ai/mem_tool/history/add_history_memory.py index 85e0181a..a92deca5 100644 --- a/reme_ai/mem_tool/history/add_history_memory.py +++ b/reme_ai/mem_tool/history/add_history_memory.py @@ -3,10 +3,10 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.enumeration import MemoryType -from ...core_old.schema import ToolCall, Message -from ...core_old.utils import format_messages +from ...core.context import C +from ...core.enumeration import MemoryType +from ...core.schema import ToolCall, Message +from ...core.utils import format_messages @C.register_op() diff --git a/reme_ai/mem_tool/history/read_history_memory.py b/reme_ai/mem_tool/history/read_history_memory.py index 24cc0366..def2ff24 100644 --- a/reme_ai/mem_tool/history/read_history_memory.py +++ b/reme_ai/mem_tool/history/read_history_memory.py @@ -3,8 +3,8 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.schema import MemoryNode +from ...core.context import C +from ...core.schema import MemoryNode @C.register_op() diff --git a/reme_ai/mem_tool/identity/read_identity_memory.py b/reme_ai/mem_tool/identity/read_identity_memory.py index dfede68f..bd9f8031 100644 --- a/reme_ai/mem_tool/identity/read_identity_memory.py +++ b/reme_ai/mem_tool/identity/read_identity_memory.py @@ -3,7 +3,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C +from ...core.context import C @C.register_op() diff --git a/reme_ai/mem_tool/identity/update_identity_memory.py b/reme_ai/mem_tool/identity/update_identity_memory.py index 0883b1a9..b0211242 100644 --- a/reme_ai/mem_tool/identity/update_identity_memory.py +++ b/reme_ai/mem_tool/identity/update_identity_memory.py @@ -3,7 +3,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C +from ...core.context import C @C.register_op() diff --git a/reme_ai/mem_tool/meta/add_meta_memory.py b/reme_ai/mem_tool/meta/add_meta_memory.py index 99635698..d7b41254 100644 --- a/reme_ai/mem_tool/meta/add_meta_memory.py +++ b/reme_ai/mem_tool/meta/add_meta_memory.py @@ -5,8 +5,8 @@ import json from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.enumeration import MemoryType +from ...core.context import C +from ...core.enumeration import MemoryType @C.register_op() diff --git a/reme_ai/mem_tool/meta/read_meta_memory.py b/reme_ai/mem_tool/meta/read_meta_memory.py index 5ee59d54..07ad1ecf 100644 --- a/reme_ai/mem_tool/meta/read_meta_memory.py +++ b/reme_ai/mem_tool/meta/read_meta_memory.py @@ -3,8 +3,8 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.enumeration import MemoryType +from ...core.context import C +from ...core.enumeration import MemoryType @C.register_op() diff --git a/reme_ai/mem_tool/think_tool.py b/reme_ai/mem_tool/think_tool.py index c54c7676..1d26446a 100644 --- a/reme_ai/mem_tool/think_tool.py +++ b/reme_ai/mem_tool/think_tool.py @@ -5,8 +5,8 @@ before taking actions, helping agents reason about their next steps. """ from .base_memory_tool import BaseMemoryTool -from ..core_old.context import C -from ..core_old.schema import ToolCall +from ..core.context import C +from ..core.schema import ToolCall @C.register_op() diff --git a/reme_ai/mem_tool/v2/add_memory_drafts.py b/reme_ai/mem_tool/v2/add_memory_drafts.py index b815be6e..93caad0c 100644 --- a/reme_ai/mem_tool/v2/add_memory_drafts.py +++ b/reme_ai/mem_tool/v2/add_memory_drafts.py @@ -3,7 +3,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C +from ...core.context import C @C.register_op() diff --git a/reme_ai/mem_tool/v2/read_history.py b/reme_ai/mem_tool/v2/read_history.py index 141989c0..7bb3b830 100644 --- a/reme_ai/mem_tool/v2/read_history.py +++ b/reme_ai/mem_tool/v2/read_history.py @@ -3,8 +3,8 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.schema import MemoryNode +from ...core.context import C +from ...core.schema import MemoryNode @C.register_op() diff --git a/reme_ai/mem_tool/v2/retrieve_memories.py b/reme_ai/mem_tool/v2/retrieve_memories.py index 96d4ca99..abdfc377 100644 --- a/reme_ai/mem_tool/v2/retrieve_memories.py +++ b/reme_ai/mem_tool/v2/retrieve_memories.py @@ -3,9 +3,9 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.schema import MemoryNode, VectorNode -from ...core_old.utils import deduplicate_memories +from ...core.context import C +from ...core.schema import MemoryNode, VectorNode +from ...core.utils import deduplicate_memories @C.register_op() diff --git a/reme_ai/mem_tool/v2/retrieve_recent_and_similar_memories.py b/reme_ai/mem_tool/v2/retrieve_recent_and_similar_memories.py index cfed10c8..38107ab0 100644 --- a/reme_ai/mem_tool/v2/retrieve_recent_and_similar_memories.py +++ b/reme_ai/mem_tool/v2/retrieve_recent_and_similar_memories.py @@ -3,9 +3,9 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.schema import MemoryNode, VectorNode -from ...core_old.utils import deduplicate_memories +from ...core.context import C +from ...core.schema import MemoryNode, VectorNode +from ...core.utils import deduplicate_memories @C.register_op() diff --git a/reme_ai/mem_tool/v2/summary_and_hands_off.py b/reme_ai/mem_tool/v2/summary_and_hands_off.py index 631c7d6b..131b1101 100644 --- a/reme_ai/mem_tool/v2/summary_and_hands_off.py +++ b/reme_ai/mem_tool/v2/summary_and_hands_off.py @@ -6,9 +6,9 @@ from typing import TYPE_CHECKING from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.enumeration import MemoryType -from ...core_old.schema import MemoryNode, Message +from ...core.context import C +from ...core.enumeration import MemoryType +from ...core.schema import MemoryNode, Message if TYPE_CHECKING: from ...mem_agent import BaseMemoryAgent diff --git a/reme_ai/mem_tool/v2/update_memories.py b/reme_ai/mem_tool/v2/update_memories.py index cffe74ac..03a9f494 100644 --- a/reme_ai/mem_tool/v2/update_memories.py +++ b/reme_ai/mem_tool/v2/update_memories.py @@ -3,8 +3,8 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.schema import MemoryNode +from ...core.context import C +from ...core.schema import MemoryNode @C.register_op() diff --git a/reme_ai/mem_tool/v3/add_memory.py b/reme_ai/mem_tool/v3/add_memory.py index 4893c6a2..ee488639 100644 --- a/reme_ai/mem_tool/v3/add_memory.py +++ b/reme_ai/mem_tool/v3/add_memory.py @@ -1,7 +1,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema import MemoryNode +from ...core.schema import MemoryNode class AddMemory(BaseMemoryTool): diff --git a/reme_ai/mem_tool/v3/read_history.py b/reme_ai/mem_tool/v3/read_history.py index 9506d88a..e9ab2a15 100644 --- a/reme_ai/mem_tool/v3/read_history.py +++ b/reme_ai/mem_tool/v3/read_history.py @@ -1,7 +1,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema import MemoryNode +from ...core.schema import MemoryNode class ReadHistory(BaseMemoryTool): diff --git a/reme_ai/mem_tool/v3/read_user_profile.py b/reme_ai/mem_tool/v3/read_user_profile.py index bab1d413..3dba2bcf 100644 --- a/reme_ai/mem_tool/v3/read_user_profile.py +++ b/reme_ai/mem_tool/v3/read_user_profile.py @@ -1,7 +1,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema.memory_node import MemoryNode +from ...core.schema.memory_node import MemoryNode class ReadUserProfile(BaseMemoryTool): diff --git a/reme_ai/mem_tool/v3/retrieve_memory.py b/reme_ai/mem_tool/v3/retrieve_memory.py index d5b9a7bc..32e526d7 100644 --- a/reme_ai/mem_tool/v3/retrieve_memory.py +++ b/reme_ai/mem_tool/v3/retrieve_memory.py @@ -3,8 +3,8 @@ import json from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema import MemoryNode -from ...core_old.utils import deduplicate_memories +from ...core.schema import MemoryNode +from ...core.utils import deduplicate_memories class RetrieveMemory(BaseMemoryTool): diff --git a/reme_ai/mem_tool/v3/summary_and_hands_off.py b/reme_ai/mem_tool/v3/summary_and_hands_off.py index e0b2756c..19d88744 100644 --- a/reme_ai/mem_tool/v3/summary_and_hands_off.py +++ b/reme_ai/mem_tool/v3/summary_and_hands_off.py @@ -4,8 +4,8 @@ from typing import TYPE_CHECKING from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.enumeration import MemoryType -from ...core_old.schema import MemoryNode, Message +from ...core.enumeration import MemoryType +from ...core.schema import MemoryNode, Message if TYPE_CHECKING: from ...mem_agent import BaseMemoryAgent diff --git a/reme_ai/mem_tool/v3/update_user_profile.py b/reme_ai/mem_tool/v3/update_user_profile.py index ef47f46b..46879e2b 100644 --- a/reme_ai/mem_tool/v3/update_user_profile.py +++ b/reme_ai/mem_tool/v3/update_user_profile.py @@ -1,7 +1,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema.memory_node import MemoryNode +from ...core.schema.memory_node import MemoryNode class UpdateUserProfile(BaseMemoryTool): diff --git a/reme_ai/mem_tool/v4/add_summary_memory.py b/reme_ai/mem_tool/v4/add_summary_memory.py index 6fe30cda..cc4be602 100644 --- a/reme_ai/mem_tool/v4/add_summary_memory.py +++ b/reme_ai/mem_tool/v4/add_summary_memory.py @@ -1,7 +1,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema import MemoryNode +from ...core.schema import MemoryNode class AddSummaryMemory(BaseMemoryTool): diff --git a/reme_ai/mem_tool/v4/hands_off.py b/reme_ai/mem_tool/v4/hands_off.py index 2dab4531..fd818b4f 100644 --- a/reme_ai/mem_tool/v4/hands_off.py +++ b/reme_ai/mem_tool/v4/hands_off.py @@ -3,8 +3,8 @@ from typing import TYPE_CHECKING from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.enumeration import MemoryType -from ...core_old.schema import Message +from ...core.enumeration import MemoryType +from ...core.schema import Message if TYPE_CHECKING: from ...mem_agent import BaseMemoryAgent diff --git a/reme_ai/mem_tool/v4/read_history.py b/reme_ai/mem_tool/v4/read_history.py index 00097234..78a90eb4 100644 --- a/reme_ai/mem_tool/v4/read_history.py +++ b/reme_ai/mem_tool/v4/read_history.py @@ -1,7 +1,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema import MemoryNode +from ...core.schema import MemoryNode class ReadHistory(BaseMemoryTool): diff --git a/reme_ai/mem_tool/v4/read_user_profile.py b/reme_ai/mem_tool/v4/read_user_profile.py index f45c0c34..ff963ea2 100644 --- a/reme_ai/mem_tool/v4/read_user_profile.py +++ b/reme_ai/mem_tool/v4/read_user_profile.py @@ -2,7 +2,7 @@ from typing import Literal from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema.memory_node import MemoryNode +from ...core.schema.memory_node import MemoryNode class ReadUserProfile(BaseMemoryTool): diff --git a/reme_ai/mem_tool/v4/retrieve_memory.py b/reme_ai/mem_tool/v4/retrieve_memory.py index a6717bfa..7a902c71 100644 --- a/reme_ai/mem_tool/v4/retrieve_memory.py +++ b/reme_ai/mem_tool/v4/retrieve_memory.py @@ -3,8 +3,8 @@ import json from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema import MemoryNode -from ...core_old.utils import deduplicate_memories +from ...core.schema import MemoryNode +from ...core.utils import deduplicate_memories class RetrieveMemory(BaseMemoryTool): diff --git a/reme_ai/mem_tool/v4/update_user_profile.py b/reme_ai/mem_tool/v4/update_user_profile.py index 1ab3276c..a8fa04f5 100644 --- a/reme_ai/mem_tool/v4/update_user_profile.py +++ b/reme_ai/mem_tool/v4/update_user_profile.py @@ -1,8 +1,8 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema.memory_node import MemoryNode -from ...core_old.utils import deduplicate_memories +from ...core.schema.memory_node import MemoryNode +from ...core.utils import deduplicate_memories class UpdateUserProfile(BaseMemoryTool): diff --git a/reme_ai/mem_tool/vector_store/add_memory.py b/reme_ai/mem_tool/vector_store/add_memory.py index 0937fe2a..1f87df4b 100644 --- a/reme_ai/mem_tool/vector_store/add_memory.py +++ b/reme_ai/mem_tool/vector_store/add_memory.py @@ -3,8 +3,8 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.schema import MemoryNode +from ...core.context import C +from ...core.schema import MemoryNode @C.register_op() diff --git a/reme_ai/mem_tool/vector_store/add_summary_memory.py b/reme_ai/mem_tool/vector_store/add_summary_memory.py index 54abbd57..ce1127ed 100644 --- a/reme_ai/mem_tool/vector_store/add_summary_memory.py +++ b/reme_ai/mem_tool/vector_store/add_summary_memory.py @@ -3,9 +3,9 @@ from loguru import logger from .add_memory import AddMemory -from ...core_old.context import C -from ...core_old.enumeration import MemoryType -from ...core_old.schema import MemoryNode +from ...core.context import C +from ...core.enumeration import MemoryType +from ...core.schema import MemoryNode @C.register_op() diff --git a/reme_ai/mem_tool/vector_store/delete_memory.py b/reme_ai/mem_tool/vector_store/delete_memory.py index 95f4f210..45b28632 100644 --- a/reme_ai/mem_tool/vector_store/delete_memory.py +++ b/reme_ai/mem_tool/vector_store/delete_memory.py @@ -3,7 +3,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C +from ...core.context import C @C.register_op() diff --git a/reme_ai/mem_tool/vector_store/retrieve_recent_memory.py b/reme_ai/mem_tool/vector_store/retrieve_recent_memory.py index dfaa9240..0896d75a 100644 --- a/reme_ai/mem_tool/vector_store/retrieve_recent_memory.py +++ b/reme_ai/mem_tool/vector_store/retrieve_recent_memory.py @@ -3,9 +3,9 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.schema import MemoryNode, VectorNode -from ...core_old.utils import deduplicate_memories +from ...core.context import C +from ...core.schema import MemoryNode, VectorNode +from ...core.utils import deduplicate_memories @C.register_op() diff --git a/reme_ai/mem_tool/vector_store/update_memory.py b/reme_ai/mem_tool/vector_store/update_memory.py index fe08fb90..4873ce24 100644 --- a/reme_ai/mem_tool/vector_store/update_memory.py +++ b/reme_ai/mem_tool/vector_store/update_memory.py @@ -3,8 +3,8 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.schema import MemoryNode +from ...core.context import C +from ...core.schema import MemoryNode @C.register_op() diff --git a/reme_ai/mem_tool/vector_store/vector_retrieve_memory.py b/reme_ai/mem_tool/vector_store/vector_retrieve_memory.py index 24b05e8b..655de36e 100644 --- a/reme_ai/mem_tool/vector_store/vector_retrieve_memory.py +++ b/reme_ai/mem_tool/vector_store/vector_retrieve_memory.py @@ -3,10 +3,10 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.context import C -from ...core_old.enumeration import MemoryType -from ...core_old.schema import MemoryNode, VectorNode -from ...core_old.utils import deduplicate_memories +from ...core.context import C +from ...core.enumeration import MemoryType +from ...core.schema import MemoryNode, VectorNode +from ...core.utils import deduplicate_memories @C.register_op() diff --git a/reme_ai/mem_tool/wk/add_memory.py b/reme_ai/mem_tool/wk/add_memory.py index 2af7ba71..61cb154c 100644 --- a/reme_ai/mem_tool/wk/add_memory.py +++ b/reme_ai/mem_tool/wk/add_memory.py @@ -1,7 +1,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema import MemoryNode +from ...core.schema import MemoryNode class AddMemory(BaseMemoryTool): diff --git a/reme_ai/mem_tool/wk/read_history.py b/reme_ai/mem_tool/wk/read_history.py index 65e8a0cf..945c02e2 100644 --- a/reme_ai/mem_tool/wk/read_history.py +++ b/reme_ai/mem_tool/wk/read_history.py @@ -1,7 +1,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema import MemoryNode +from ...core.schema import MemoryNode class ReadHistory(BaseMemoryTool): diff --git a/reme_ai/mem_tool/wk/summary_and_hands_off.py b/reme_ai/mem_tool/wk/summary_and_hands_off.py index d384f16a..9a6a76cd 100644 --- a/reme_ai/mem_tool/wk/summary_and_hands_off.py +++ b/reme_ai/mem_tool/wk/summary_and_hands_off.py @@ -4,8 +4,8 @@ from typing import TYPE_CHECKING from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.enumeration import MemoryType -from ...core_old.schema import MemoryNode, Message +from ...core.enumeration import MemoryType +from ...core.schema import MemoryNode, Message if TYPE_CHECKING: from ...mem_agent import BaseMemoryAgent diff --git a/reme_ai/mem_tool/wk/update_memory.py b/reme_ai/mem_tool/wk/update_memory.py index 151eba53..c419261f 100644 --- a/reme_ai/mem_tool/wk/update_memory.py +++ b/reme_ai/mem_tool/wk/update_memory.py @@ -1,7 +1,7 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.schema import MemoryNode +from ...core.schema import MemoryNode class UpdateMemory(BaseMemoryTool): diff --git a/reme_ai/mem_tool/wk/vector_retrieve_memory.py b/reme_ai/mem_tool/wk/vector_retrieve_memory.py index 2698cd6f..de7498b4 100644 --- a/reme_ai/mem_tool/wk/vector_retrieve_memory.py +++ b/reme_ai/mem_tool/wk/vector_retrieve_memory.py @@ -1,9 +1,9 @@ from loguru import logger from ..base_memory_tool import BaseMemoryTool -from ...core_old.enumeration import MemoryType -from ...core_old.schema import MemoryNode, VectorNode -from ...core_old.utils import deduplicate_memories +from ...core.enumeration import MemoryType +from ...core.schema import MemoryNode, VectorNode +from ...core.utils import deduplicate_memories class VectorRetrieveMemory(BaseMemoryTool): diff --git a/reme_ai/tool/execute/execute_code.py b/reme_ai/tool/execute/execute_code.py index f13aab3d..ea259487 100644 --- a/reme_ai/tool/execute/execute_code.py +++ b/reme_ai/tool/execute/execute_code.py @@ -4,11 +4,11 @@ This module provides an operation that can execute Python code strings and return the output or error messages. """ -from ...core_old.context import C -from ...core_old.op import BaseOp -from ...core_old.schema import ToolCall +from ...core.context import C +from ...core.op import BaseOp +from ...core.schema import ToolCall -from ...core_old.utils import exec_code +from ...core.utils import exec_code @C.register_op() diff --git a/reme_ai/tool/execute/execute_shell.py b/reme_ai/tool/execute/execute_shell.py index 1b235921..6e244ddb 100644 --- a/reme_ai/tool/execute/execute_shell.py +++ b/reme_ai/tool/execute/execute_shell.py @@ -4,11 +4,11 @@ This module provides an operation that can execute shell commands asynchronously and return the output, error, and exit code. """ -from ...core_old.context import C -from ...core_old.op import BaseOp -from ...core_old.schema import ToolCall +from ...core.context import C +from ...core.op import BaseOp +from ...core.schema import ToolCall -from ...core_old.utils import run_shell_command +from ...core.utils import run_shell_command @C.register_op() diff --git a/reme_ai/tool/search/dashscope_search.py b/reme_ai/tool/search/dashscope_search.py index 47c399ef..19bd8104 100644 --- a/reme_ai/tool/search/dashscope_search.py +++ b/reme_ai/tool/search/dashscope_search.py @@ -9,9 +9,9 @@ from typing import Literal from loguru import logger -from ...core_old.context import C -from ...core_old.op import BaseOp -from ...core_old.schema import ToolCall +from ...core.context import C +from ...core.op import BaseOp +from ...core.schema import ToolCall @C.register_op() diff --git a/reme_ai/tool/search/mock_search.py b/reme_ai/tool/search/mock_search.py index 69ef3995..187463dc 100644 --- a/reme_ai/tool/search/mock_search.py +++ b/reme_ai/tool/search/mock_search.py @@ -9,11 +9,11 @@ import random from loguru import logger -from ...core_old.context import C -from ...core_old.enumeration import Role -from ...core_old.op import BaseOp -from ...core_old.schema import ToolCall, Message -from ...core_old.utils import extract_content +from ...core.context import C +from ...core.enumeration import Role +from ...core.op import BaseOp +from ...core.schema import ToolCall, Message +from ...core.utils import extract_content @C.register_op() diff --git a/reme_ai/tool/search/tavily_search.py b/reme_ai/tool/search/tavily_search.py index bb000f16..5c194bdc 100644 --- a/reme_ai/tool/search/tavily_search.py +++ b/reme_ai/tool/search/tavily_search.py @@ -9,9 +9,9 @@ import os from loguru import logger -from ...core_old.context import C -from ...core_old.op import BaseOp -from ...core_old.schema import ToolCall +from ...core.context import C +from ...core.op import BaseOp +from ...core.schema import ToolCall @C.register_op() diff --git a/test/test_base_context.py b/test/test_base_context.py index 2b3ebc99..316a6796 100644 --- a/test/test_base_context.py +++ b/test/test_base_context.py @@ -4,7 +4,7 @@ Ensures attribute-style and dict-style access work interchangeably. """ import pickle -from reme_ai.core_old.context import BaseContext +from reme_ai.core.context import BaseContext def test_attribute_access(): diff --git a/test/test_cache_handler.py b/test/test_cache_handler.py index b741769a..ddcac86f 100644 --- a/test/test_cache_handler.py +++ b/test/test_cache_handler.py @@ -9,7 +9,7 @@ from pathlib import Path import pandas as pd from loguru import logger -from reme_ai.core_old.utils.cache_handler import CacheHandler +from reme_ai.core.utils.cache_handler import CacheHandler def run_tests(): diff --git a/test/test_embedding.py b/test/test_embedding.py index b769d05f..d1c404f5 100644 --- a/test/test_embedding.py +++ b/test/test_embedding.py @@ -18,12 +18,12 @@ import asyncio import argparse from typing import Type, List -from reme_ai.core_old.utils import load_env +from reme_ai.core.utils import load_env load_env() -from reme_ai.core_old.embedding import OpenAIEmbeddingModel, BaseEmbeddingModel -from reme_ai.core_old.schema import VectorNode +from reme_ai.core.embedding import OpenAIEmbeddingModel, BaseEmbeddingModel +from reme_ai.core.schema import VectorNode def get_embedding_model(model_class: Type[BaseEmbeddingModel]) -> BaseEmbeddingModel: diff --git a/test/test_embedding_sync.py b/test/test_embedding_sync.py index f97e28ec..361a42b3 100644 --- a/test/test_embedding_sync.py +++ b/test/test_embedding_sync.py @@ -17,12 +17,12 @@ Usage: import argparse from typing import Type, List -from reme_ai.core_old.utils import load_env +from reme_ai.core.utils import load_env load_env() -from reme_ai.core_old.embedding import OpenAIEmbeddingModelSync, BaseEmbeddingModel -from reme_ai.core_old.schema import VectorNode +from reme_ai.core.embedding import OpenAIEmbeddingModelSync, BaseEmbeddingModel +from reme_ai.core.schema import VectorNode def get_embedding_model(model_class: Type[BaseEmbeddingModel]) -> BaseEmbeddingModel: diff --git a/test/test_llm.py b/test/test_llm.py index 819c2b2b..12c6eca3 100644 --- a/test/test_llm.py +++ b/test/test_llm.py @@ -18,13 +18,13 @@ import asyncio import argparse from typing import Type -from reme_ai.core_old.utils import load_env +from reme_ai.core.utils import load_env load_env() -from reme_ai.core_old.llm import OpenAILLM, LiteLLM, BaseLLM -from reme_ai.core_old.schema import Message, ToolCall -from reme_ai.core_old.enumeration import Role, ChunkEnum +from reme_ai.core.llm import OpenAILLM, LiteLLM, BaseLLM +from reme_ai.core.schema import Message, ToolCall +from reme_ai.core.enumeration import Role, ChunkEnum def get_llm(llm_class: Type[BaseLLM]) -> BaseLLM: diff --git a/test/test_llm_sync.py b/test/test_llm_sync.py index 07d80ed1..98751f87 100644 --- a/test/test_llm_sync.py +++ b/test/test_llm_sync.py @@ -17,13 +17,13 @@ Usage: import argparse from typing import Type -from reme_ai.core_old.utils import load_env +from reme_ai.core.utils import load_env load_env() -from reme_ai.core_old.llm import OpenAILLMSync, LiteLLMSync, BaseLLM -from reme_ai.core_old.schema import Message, ToolCall -from reme_ai.core_old.enumeration import Role, ChunkEnum +from reme_ai.core.llm import OpenAILLMSync, LiteLLMSync, BaseLLM +from reme_ai.core.schema import Message, ToolCall +from reme_ai.core.enumeration import Role, ChunkEnum def get_llm(llm_class: Type[BaseLLM]) -> BaseLLM: diff --git a/test/test_logo.py b/test/test_logo.py index 9b4cf089..eeede81e 100644 --- a/test/test_logo.py +++ b/test/test_logo.py @@ -1,9 +1,9 @@ """test logo""" -from reme_ai.core_old.schema import ServiceConfig, MCPConfig +from reme_ai.core.schema import ServiceConfig, MCPConfig if __name__ == "__main__": - from reme_ai.core_old.utils import print_logo + from reme_ai.core.utils import print_logo c = ServiceConfig(app_name="reme", backend="mcp", mcp=MCPConfig(transport="sse")) print_logo(service_config=c) diff --git a/test/test_mcp_client.py b/test/test_mcp_client.py index 0ae6fc54..d2fef40e 100644 --- a/test/test_mcp_client.py +++ b/test/test_mcp_client.py @@ -5,7 +5,7 @@ import asyncio import json -from reme_ai.core_old.utils import MCPClient +from reme_ai.core.utils import MCPClient async def main(): diff --git a/test/test_mcp_server.py b/test/test_mcp_server.py index 4257b977..67f9c542 100644 --- a/test/test_mcp_server.py +++ b/test/test_mcp_server.py @@ -5,8 +5,8 @@ from typing import Any from fastmcp import FastMCP from fastmcp.tools import FunctionTool -from reme_ai.core_old.schema import ToolCall -from reme_ai.core_old.utils import create_pydantic_model +from reme_ai.core.schema import ToolCall +from reme_ai.core.utils import create_pydantic_model mcp = FastMCP("DynamicSchemaServer", port=8010) diff --git a/test/test_message.py b/test/test_message.py index e77e673b..141174c5 100644 --- a/test/test_message.py +++ b/test/test_message.py @@ -4,8 +4,8 @@ import unittest from mcp.types import Tool -from reme_ai.core_old.enumeration import Role -from reme_ai.core_old.schema import ToolAttr, ToolCall, ContentBlock, Message +from reme_ai.core.enumeration import Role +from reme_ai.core.schema import ToolAttr, ToolCall, ContentBlock, Message class TestModelDefinitions(unittest.TestCase): diff --git a/test/test_op_composition.py b/test/test_op_composition.py index 319981a3..8d32b51a 100644 --- a/test/test_op_composition.py +++ b/test/test_op_composition.py @@ -5,8 +5,8 @@ Tests asynchronous execution mode. import asyncio -from reme_ai.core_old.op import BaseOp -from reme_ai.core_old.schema import ToolCall, ToolAttr +from reme_ai.core.op import BaseOp +from reme_ai.core.schema import ToolCall, ToolAttr class AddOp(BaseOp): diff --git a/test/test_reme.py b/test/test_reme.py index b23aa63e..c9e6843e 100644 --- a/test/test_reme.py +++ b/test/test_reme.py @@ -2,7 +2,7 @@ import asyncio -from reme_ai.core_old.schema import VectorNode, MemoryNode +from reme_ai.core.schema import VectorNode, MemoryNode from reme_ai.reme import ReMe reme = ReMe( diff --git a/test/test_timer.py b/test/test_timer.py index 1c9de938..c9714e38 100644 --- a/test/test_timer.py +++ b/test/test_timer.py @@ -7,7 +7,7 @@ import time from loguru import logger -from reme_ai.core_old.utils import timer +from reme_ai.core.utils import timer @timer diff --git a/test/test_token_counter.py b/test/test_token_counter.py index e67fb5c2..3c44a298 100644 --- a/test/test_token_counter.py +++ b/test/test_token_counter.py @@ -14,9 +14,9 @@ Usage: import argparse from typing import Type, List -from reme_ai.core_old.enumeration import Role -from reme_ai.core_old.schema import Message, ToolCall -from reme_ai.core_old.token_counter import BaseTokenCounter, OpenAITokenCounter, HFTokenCounter +from reme_ai.core.enumeration import Role +from reme_ai.core.schema import Message, ToolCall +from reme_ai.core.token_counter import BaseTokenCounter, OpenAITokenCounter, HFTokenCounter def get_token_counter(counter_class: Type[BaseTokenCounter], **kwargs) -> BaseTokenCounter: diff --git a/test/test_tool.py b/test/test_tool.py index 765051b3..9db5a3ed 100644 --- a/test/test_tool.py +++ b/test/test_tool.py @@ -169,8 +169,8 @@ async def test_stream_chat(): process and stream responses in real-time using async operations. """ from reme_ai.mem_agent.chat import StreamChat - from reme_ai.core_old.utils import execute_stream_task - from reme_ai.core_old.context import RuntimeContext + from reme_ai.core.utils import execute_stream_task + from reme_ai.core.context import RuntimeContext from asyncio import Queue op = StreamChat() diff --git a/test/test_tool_call.py b/test/test_tool_call.py index 2ae7a619..30c0a37e 100644 --- a/test/test_tool_call.py +++ b/test/test_tool_call.py @@ -2,7 +2,7 @@ import json -from reme_ai.core_old.schema.tool_call import ToolCall +from reme_ai.core.schema.tool_call import ToolCall def test_simple_schema(): diff --git a/test/test_vector_store.py b/test/test_vector_store.py index 51edbd55..00927d0c 100644 --- a/test/test_vector_store.py +++ b/test/test_vector_store.py @@ -23,9 +23,9 @@ from typing import List from loguru import logger -from reme_ai.core_old.embedding import OpenAIEmbeddingModel -from reme_ai.core_old.schema import VectorNode -from reme_ai.core_old.vector_store import ( +from reme_ai.core.embedding import OpenAIEmbeddingModel +from reme_ai.core.schema import VectorNode +from reme_ai.core.vector_store import ( BaseVectorStore, ChromaVectorStore, LocalVectorStore, @@ -1453,8 +1453,8 @@ async def test_sql_injection_protection(store: BaseVectorStore, store_name: str) # Test 1: Invalid collection name (SQL injection attempt) try: - from reme_ai.core_old.vector_store import PGVectorStore - from reme_ai.core_old.embedding import OpenAIEmbeddingModel + from reme_ai.core.vector_store import PGVectorStore + from reme_ai.core.embedding import OpenAIEmbeddingModel embedding_model = OpenAIEmbeddingModel()