amrita_core 0.1.0__py3-none-any.whl

amrita_core/types.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import json
+import time
+import typing
+from collections.abc import Iterable
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Generic, Literal
+
+from pydantic import BaseModel as B_Model
+from pydantic import Field
+
+# Pydantic models
+
+T = typing.TypeVar("T", None, str, None | typing.Literal[""])
+T_INT = typing.TypeVar("T_INT", int, None)
+
+
+class BaseModel(B_Model):
+    """BaseModel+dict duck typing"""
+
+    def __str__(self) -> str:
+        return json.dumps(self.model_dump(), ensure_ascii=True)
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def __getitem__(self, key: str) -> Any:
+        return self.model_dump()[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.__setattr__(key, value)
+
+
+class ModelConfig(BaseModel):
+    """Model configuration"""
+
+    top_k: int = Field(default=50, description="TopK")
+    top_p: float = Field(default=0.95, description="TopP")
+    temperature: float = Field(default=0.7, description="Temperature")
+    stream: bool = Field(
+        default=False,
+        description="Whether to enable streaming response (output by character)",
+    )
+    thought_chain_model: bool = Field(
+        default=False,
+        description="Whether to enable thought chain model optimization (enhance complex problem solving)",
+    )
+    multimodal: bool = Field(
+        default=False,
+        description="Whether to support multimodal input (e.g. image recognition)",
+    )
+
+
+class ModelPreset(BaseModel):
+    model: str = Field(
+        default="", description="Name of the AI model to use (e.g. gpt-3.5-turbo)"
+    )
+    name: str = Field(
+        default="default", description="Identifier name for current preset"
+    )
+    base_url: str = Field(
+        default="",
+        description="Base address of API service (use OpenAI default if empty)",
+    )
+    api_key: str = Field(default="", description="Key required to access API")
+    protocol: str = Field(default="__main__", description="Protocol adapter type")
+    config: ModelConfig = Field(default_factory=ModelConfig)
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+    @classmethod
+    def load(cls, path: Path):
+        if path.exists():
+            with path.open(
+                "r",
+                encoding="utf-8",
+            ) as f:
+                data = json.load(f)
+            return cls.model_validate(data)
+        return cls()  # Return default values
+
+    def save(self, path: Path):
+        with path.open("w", encoding="u8") as f:
+            json.dump(self.model_dump(), f, indent=4, ensure_ascii=False)
+
+
+class Function(BaseModel):
+    arguments: str
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: str
+    """The name of the function to call."""
+
+
+class ToolCall(BaseModel):
+    id: str
+    """The ID of the tool call."""
+
+    function: Function
+    """The function that the model called."""
+
+    type: typing.Literal["function"] = "function"
+    """The type of the tool. Currently, only `function` is supported."""
+
+
+T_TOOL = typing.TypeVar("T_TOOL", list[ToolCall], None, list[ToolCall] | None)
+
+
+class UniResponseUsage(BaseModel, Generic[T_INT]):
+    prompt_tokens: T_INT
+    completion_tokens: T_INT
+    total_tokens: T_INT
+
+
+class UniResponse(
+    BaseModel,
+    Generic[T, T_TOOL],
+):
+    """Unified response format"""
+
+    role: Literal["assistant"] = Field(
+        default="assistant",  # Regardless of whether there's content/tool_call, role is assistant
+        description="Role",
+    )
+
+    usage: UniResponseUsage | None = None
+    content: T = Field(
+        ...,
+        description="Content",
+        exclude_if=lambda x: x is None,
+    )
+    tool_calls: T_TOOL = Field(
+        ...,
+        description="Tool call results",
+        exclude_if=lambda x: x is None,
+    )
+
+
+class ImageUrl(BaseModel):
+    url: str = Field(..., description="Image URL")
+
+
+class Content(BaseModel): ...
+
+
+class ImageContent(Content):
+    type: Literal["image_url"] = "image_url"
+    image_url: ImageUrl = Field(..., description="Image URL")
+
+
+class TextContent(Content):
+    type: Literal["text"] = "text"
+    text: str = Field(..., description="Text content")
+
+
+CT_MAP: dict[str, type[Content]] = {
+    "image_url": ImageContent,
+    "text": TextContent,
+}
+
+USER_INPUT = list[TextContent | ImageContent] | str
+
+_T = typing.TypeVar(
+    "_T",
+    str,
+    None,
+    list[TextContent],
+    list[TextContent | ImageContent],
+    USER_INPUT,
+)
+
+
+class Message(BaseModel, Generic[_T]):
+    role: Literal["user", "assistant", "system"] = Field(..., description="Role")
+    content: _T = Field(..., description="Content")
+    tool_calls: list[ToolCall] | None = Field(
+        default=None, description="Tool calls", exclude_if=lambda x: x is None
+    )
+
+
+class ToolResult(BaseModel):
+    role: Literal["tool"] = Field(..., description="Role")
+    name: str = Field(..., description="Tool name")
+    content: str = Field(..., description="Tool return content")
+    tool_call_id: str = Field(..., description="Tool call ID")
+
+
+class MemoryModel(BaseModel):
+    messages: list[CONTENT_LIST_TYPE_ITEM] = Field(default_factory=list)
+    time: float = Field(default_factory=time.time, description="Timestamp")
+    abstract: str = Field(default="", description="Summary")
+
+
+CONTENT_LIST_TYPE_ITEM = Message | ToolResult
+CONTENT_LIST_TYPE = list[CONTENT_LIST_TYPE_ITEM]
+
+
+class SendMessageWrap(Iterable[CONTENT_LIST_TYPE_ITEM]):
+    """Wrapper class for CONTENT_LIST_TYPE"""
+
+    train: Message[str]  # system message
+    memory: CONTENT_LIST_TYPE  # Messages without system message
+    user_query: Message
+    end_messages: CONTENT_LIST_TYPE  # End messages
+
+    def __init__(
+        self,
+        train: dict[str, str] | Message[str],
+        memory: CONTENT_LIST_TYPE | MemoryModel,
+        user_query: Message | None = None,
+    ):
+        self.train = (
+            train if isinstance(train, Message) else Message.model_validate(train)
+        )
+        self.end_messages = []
+        self.memory = memory if isinstance(memory, list) else memory.messages
+        query = user_query or self.memory[-1]
+        if isinstance(query, ToolResult) or query.role != "user":
+            raise ValueError("Invalid query message, expecting user message!")
+        self.user_query = query
+        self.memory.pop()
+
+    @classmethod
+    def validate_messages(cls, messages: CONTENT_LIST_TYPE) -> SendMessageWrap:
+        train = messages[0]
+        if train.role != "system":  # Fall back to match the first system message
+            for idx, msg in enumerate(messages):
+                if msg.role == "system":
+                    train = msg
+                    messages.pop(idx)
+                    memory = messages
+                    break
+            else:
+                raise ValueError("Invalid messages, expecting system message!")
+        else:
+            memory = messages[1:]
+        return cls(train, memory)
+
+    def __len__(self) -> int:
+        return len(self.memory) + 2 + len(self.end_messages)
+
+    def __iter__(self) -> typing.Iterator[CONTENT_LIST_TYPE_ITEM]:
+        yield self.train
+        yield from self.memory
+        yield self.user_query
+        yield from self.end_messages
+
+    def copy(self) -> SendMessageWrap:
+        return deepcopy(self)
+
+    def unwrap(self, exclude_system: bool = False) -> CONTENT_LIST_TYPE:
+        system_msg: CONTENT_LIST_TYPE = [self.train] if not exclude_system else []
+        return [*system_msg, *self.memory, self.user_query, *self.end_messages]
+
+    def get_train(self) -> Message[str]:
+        return self.train
+
+    def get_memory(self) -> CONTENT_LIST_TYPE:
+        return self.memory
+
+    def get_user_query(self) -> Message:
+        return self.user_query
+
+    def append(self, message: CONTENT_LIST_TYPE_ITEM) -> None:
+        self.end_messages.append(message)
+
+    def extend(self, messages: CONTENT_LIST_TYPE) -> None:
+        self.end_messages.extend(messages)

amrita_core/utils.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import pytz
+
+
+def remove_think_tag(text: str) -> str:
+    """Remove the first occurrence of think tag
+
+    Args:
+        text (str): Parameter to process
+
+    Returns:
+        str: Processed text
+    """
+
+    start_tag = "<think>"
+    end_tag = "</think>"
+
+    # Find the position of the first start tag
+    start_idx = text.find(start_tag)
+    if start_idx == -1:
+        return text  # No start tag found, return original text
+
+    # Find the position of the end tag after the start tag
+    end_idx = text.find(end_tag, start_idx + len(start_tag))
+    if end_idx == -1:
+        return text  # No corresponding end tag found, return original text
+
+    # Calculate the end position of the end tag
+    end_of_end_tag = end_idx + len(end_tag)
+
+    # Concatenate text after removing the tag
+    text_new = text[:start_idx] + text[end_of_end_tag:]
+    while text_new.startswith("\n"):
+        text_new = text_new[1:]
+    return text_new
+
+
+def format_datetime_timestamp(time: float) -> str:
+    """Format timestamp to date, weekday and time string"""
+    now = datetime.fromtimestamp(time)
+    formatted_date = now.strftime("%Y-%m-%d")
+    formatted_weekday = now.strftime("%A")
+    formatted_time = now.strftime("%I:%M:%S %p")
+    return f"[{formatted_date} {formatted_weekday} {formatted_time}]"
+
+
+def split_list(lst: list, threshold: int) -> list[Any]:
+    """Split list into multiple sublists, each sublist length does not exceed threshold"""
+    if len(lst) <= threshold:
+        return [lst]
+    return [lst[i : i + threshold] for i in range(0, len(lst), threshold)]
+
+
+def get_current_datetime_timestamp(utc_time: None | datetime = None):
+    """Get current time and format as date, weekday and time string"""
+    utc_time = utc_time or datetime.now(pytz.utc)
+    asia_shanghai = pytz.timezone("Asia/Shanghai")
+    now = utc_time.astimezone(asia_shanghai)
+    formatted_date = now.strftime("%Y-%m-%d")
+    formatted_weekday = now.strftime("%A")
+    formatted_time = now.strftime("%H:%M:%S")
+    return f"[{formatted_date} {formatted_weekday} {formatted_time}]"

amrita_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: amrita_core
+Version: 0.1.0
+Summary: Agent core of Project Amrita
+Project-URL: Homepage, https://github.com/AmritaBot/AmritaCore
+Project-URL: Source, https://github.com/AmritaBot/AmritaCore
+Project-URL: Issue Tracker, https://github.com/AmritaBot/AmritaCore/issues
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastmcp>=2.14.4
+Requires-Dist: jieba>=0.42.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: openai>=2.16.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pytz>=2025.2
+Dynamic: license-file
+
+# AmritaCore
+
+AmritaCore is the intelligent agent core module of Proj.Amrita, serving as the primary logical or control component of the project. It provides a flexible and extensible framework for implementing AI agents with advanced capabilities.
+
+## 🚀 What is AmritaCore?
+
+AmritaCore is a next-generation agent framework designed to simplify the creation and deployment of intelligent agents. Built with modern Python technologies, it provides a comprehensive solution for implementing AI-powered applications with features like event-driven architecture, tool integration, and multi-modal support.
+
+## 🎯 Mission and Value Proposition
+
+The mission of AmritaCore is to democratize the development of intelligent agents by providing a powerful yet accessible framework. Our core value propositions include:
+
+- **Stream-based Design**: All message outputs are designed as asynchronous streams for real-time responses
+- **Security**: Built-in cookie security detection to ensure session safety
+- **Vendor Agnostic**: Data types and conversation management are independent of specific providers, offering high portability
+- **Extensibility**: Integrated MCP client in extension mechanisms for enhanced system scalability
+
+## 🔑 Key Features
+
+1. **Every is a Stream**: All message outputs are asynchronous stream-based designs supporting real-time responses
+2. **Cookie Security Detection**: Built-in cookie security detection functionality to protect session security
+3. **Provider Independent Mechanism**: Data types and conversation management are independent of specific vendors, with high portability
+4. **MCP Client Support**: Extension mechanisms integrate MCP clients, enhancing system expansion capabilities
+5. **Event-Driven Architecture**: Comprehensive event system for flexible and reactive agent behavior
+6. **Tool Integration Framework**: Robust system for integrating external tools and services
+7. **Advanced Memory Management**: Sophisticated context handling with automatic summarization and token optimization
+
+## 📖 Documentation Structure
+
+This repository contains documentation organized as follows:
+
+- **Level 1: Project Introduction** - Overview of AmritaCore, its purpose, and key characteristics
+- **Level 2: Quick Start** - Getting started guides, installation, and minimal examples
+- **Level 3: Core Concepts** - Configuration systems, data types, event systems, and tool systems
+- **Level 4: Implementation Guide** - Detailed functional implementations and usage patterns
+- **Level 5: Extensions & Integration** - How to extend and integrate with other systems
+- **Level 6: Security Mechanisms** - Security features and best practices
+- **Level 7: Application Scenarios** - Use cases and practical examples
+- **Level 8: Best Practices & FAQs** - Troubleshooting and optimization tips
+- **Level 9: API Reference** - Complete API documentation
+- **Level 10: Appendices** - Glossary, resources, and changelogs
+
+Documentation is currently under construction. For quick start, please refer to the examples in the `demo/` folder.
+
+## 🛠️ Quick Start
+
+To quickly start using AmritaCore, check out the examples in the [demo](./demo/) directory. The basic example demonstrates how to initialize the core, configure settings, and run a simple chat session with the AI assistant.
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our contribution guidelines for more information.
+
+## 📄 License
+
+This project is licensed under the AGPL-3.0 License - see the [LICENSE](./LICENSE) file for details.

amrita_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+amrita_core/__init__.py,sha256=uNev8VnIbKg6CcdsaB_H7DgTLTNXLyTRoOqlAOYaBu8,2329
+amrita_core/chatmanager.py,sha256=PV_IfEBiWfjIjKykaJ4XtcEHFYKCvMrwDy2eHVVy5kQ,32436
+amrita_core/config.py,sha256=T8SAH5-ND496nMEQ-b-VGnmDdaGixlDVCSLZ985f860,5377
+amrita_core/libchat.py,sha256=bM-WhD6BGvn_aFHAkywYGaU6vF67QAfudsHfB2Ia-M4,5614
+amrita_core/logging.py,sha256=aUPGGMntZq-r5i60DAvTXfMaeD5ac93Nxus8rcIWw_8,1724
+amrita_core/preset.py,sha256=q9Xf6n247lGndedlNVm2eIHtnMivs8lHJIXdZQZK4CM,5599
+amrita_core/protocol.py,sha256=ehvnVwy6yxWFesAANDh4QOofgU6yDj3TXkBc_sMKhFs,3585
+amrita_core/tokenizer.py,sha256=RkFJLQCT2VHhBAawFYX1rvSZ_7IEe51COwO9PKx5My8,3545
+amrita_core/types.py,sha256=c7XVI1xyDGAQDJRcNcTGyTv45m6spPmXfm7QS26WPG8,8214
+amrita_core/utils.py,sha256=f3aKsy_NEnQS5PR47HBmora9__WSH_-wJ4Jlz0SR6OE,2152
+amrita_core/builtins/__init__.py,sha256=rY4dUdNlLmxFteAyelHVCGKms9RLNQTD6orMPcd5fJM,92
+amrita_core/builtins/adapter.py,sha256=MSfi_orfALrMFVrkrwI0EBgKcqNgMN_Ii9JSuGo7AHs,5329
+amrita_core/builtins/agent.py,sha256=A9KNkLWuXzyDl0eu8Wob_YNv7VhhCx03jDPGUmVkK4g,16801
+amrita_core/builtins/tools.py,sha256=h6xoAYA6cflWvwZQ7jWXwc7g5tMBKVzxdL1lsf_K2p8,2304
+amrita_core/hook/event.py,sha256=GoyV4M93BE8MwGcp_nJwduyib3DW1NTNe31RfWSGUQw,2243
+amrita_core/hook/exception.py,sha256=Q4U8Vd8fZursEnuCwDyFjJizJGW75coj_0Gik4jERoM,226
+amrita_core/hook/matcher.py,sha256=NGU6ClyIaNMWMdFduZkLTXm1st2YpgVFJIyn45Qu31M,7666
+amrita_core/hook/on.py,sha256=C9Z66Nliy6Rq4xyn4CZt3V8NXWPEHPuavp8tDBXcP0w,451
+amrita_core/tools/manager.py,sha256=SwFjopuTa2OqV6bEXRtRaP81d9T3nLiQI5sHvge5NO4,5229
+amrita_core/tools/mcp.py,sha256=K-6SjsD-KUfRgII7HuX2AADClD79qwy2DyxXbSpjyYk,12739
+amrita_core/tools/models.py,sha256=lUpdYSOh-rzOM1jIJURBYgqaZGHWOznnGGyGJExGFeI,12246
+amrita_core-0.1.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+amrita_core-0.1.0.dist-info/METADATA,sha256=AFHnyDC6XTdxH4LJf3toCJQzfkTsP2Brs5oFXAwZuSA,4125
+amrita_core-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+amrita_core-0.1.0.dist-info/top_level.txt,sha256=7mB9cYXC_VZ73UXo6DXplcfSvMGeP1sTNHza46x2FTk,12
+amrita_core-0.1.0.dist-info/RECORD,,

amrita_core-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+