amrita_core 0.9.4__tar.gz → 0.10.0.dev2__tar.gz

{amrita_core-0.9.4/src/amrita_core.egg-info → amrita_core-0.10.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amrita_core
-Version: 0.9.4
+Version: 0.10.0.dev2
 Summary: High performance, flexible, lightweight agent framework.
 Project-URL: Homepage, https://github.com/AmritaBot/AmritaCore
 Project-URL: Source, https://github.com/AmritaBot/AmritaCore
@@ -11,7 +11,7 @@ License-File: LICENSE
 Requires-Dist: aiofiles>=25.1.0
 Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: aiologic>=0.16.0
-Requires-Dist: amrita-sense>=0.3.0
+Requires-Dist: amrita-sense>=0.3.2
 Requires-Dist: fastmcp>=3.2.0
 Requires-Dist: filetype>=1.2.0
 Requires-Dist: importlib>=1.0.4

{amrita_core-0.9.4 → amrita_core-0.10.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "amrita_core"
-version = "0.9.4"
+version = "0.10.0.dev2"
 description = "High performance, flexible, lightweight agent framework."
 readme = "README.md"
 requires-python = ">=3.10,<3.15"
@@ -8,7 +8,7 @@ dependencies = [
     "aiofiles>=25.1.0",
     "aiohttp>=3.13.3",
     "aiologic>=0.16.0",
-    "amrita-sense>=0.3.0",
+    "amrita-sense>=0.3.2",
     "fastmcp>=3.2.0",        # Updated, see https://github.com/advisories/GHSA-rww4-4w9c-7733 for details.
     "filetype>=1.2.0",
     "importlib>=1.0.4",

{amrita_core-0.9.4 → amrita_core-0.10.0.dev2}/src/amrita_core/__init__.py

@@ -1,6 +1,5 @@
 from amrita_sense.logging import debug_log, logger
 from amrita_sense.streaming import SuspendObjectStream
-from typing_extensions import deprecated
 
 from amrita_core.base.adapter import AdapterManager
 from amrita_core.base.tokenizer import TokenizerManager
@@ -8,8 +7,11 @@ from amrita_core.base.tokenizer import TokenizerManager
 from . import adapters, tokenizers
 from .agent.functions import AgentRuntime, create_agent
 from .agent.strategy import AgentStrategy
+from .base.backend import AbilityBackend, BackendSlots, MemoryBackend
+from .builtins.backends import LegacyBackend
 from .chatmanager import ChatManager, ChatObject, ChatObjectMeta, SuspendEnum
 from .config import AmritaConfig, get_config, set_config
+from .contexts import AbilityContext, StateContext
 from .hook.event import CompletionEvent, EventTypeEnum, PreCompletionEvent
 from .hook.on import on_completion, on_event, on_precompletion
 from .libchat import (
@@ -20,7 +22,6 @@ from .libchat import (
     tools_caller,
 )
 from .preset import PresetManager, PresetReport
-from .sessions import SessionsManager
 from .tools import mcp
 from .tools.manager import ToolsManager, on_tools, simple_tool
 from .tools.models import (
@@ -43,20 +44,7 @@ from .types import (
     UniResponse,
     UniResponseUsage,
 )
-from .utils import side_effect_import
-
-
-@deprecated(
-    "Init method is no longer necessary. Please use minimal_init or load_amrita() instead for async initialization. Will be removed in v0.10.0",
-    category=DeprecationWarning,
-)
-def init(): ...
-
-
-def load_session(session_id: str):
-    logger.info("Loading session %s......", session_id)
-    sm = SessionsManager()
-    sm.init_session(session_id)
+from .utils import load_and_notice, side_effect_import
 
 
 async def load_amrita():
@@ -75,17 +63,19 @@ async def minimal_init(config: AmritaConfig = AmritaConfig()) -> None:
 
 logger.info("Loading tokenizers and adapters......")
 
-
-side_effect_import(adapters)
+load_and_notice(adapters, "Adapters")
 logger.debug(f"Loaded adapters: {','.join(AdapterManager().get_adapters().keys())}")
-side_effect_import(tokenizers)
+load_and_notice(tokenizers, "Tokenizers")
 logger.debug(
     f"Loaded tokenizers: {','.join(TokenizerManager().get_tokenizers().keys())}"
 )
 
 __all__ = [
+    "AbilityBackend",
+    "AbilityContext",
     "AgentRuntime",
     "AgentStrategy",
+    "BackendSlots",
     "BaseModel",
     "ChatManager",
     "ChatObject",
@@ -96,13 +86,15 @@ __all__ = [
     "FunctionDefinitionSchema",
     "FunctionParametersSchema",
     "FunctionPropertySchema",
+    "LegacyBackend",
+    "MemoryBackend",
     "MemoryModel",
     "ModelConfig",
     "ModelPreset",
     "PreCompletionEvent",
     "PresetManager",
     "PresetReport",
-    "SessionsManager",
+    "StateContext",
     "SuspendEnum",
     "SuspendObjectStream",
     "TextContent",
@@ -121,7 +113,6 @@ __all__ = [
     "get_config",
     "get_last_response",
     "get_tokens",
-    "logger",
     "mcp",
     "on_completion",
     "on_event",

{amrita_core-0.9.4 → amrita_core-0.10.0.dev2}/src/amrita_core/adapters/anthropic.py

@@ -6,12 +6,12 @@ from amrita_sense.logging import logger
 from pydantic import BaseModel, Field
 from typing_extensions import override
 
-from amrita_core.config import AmritaConfig
-from amrita_core.contents import MessageMetadataPayload, MessageWithMetadata
-from amrita_core.protocol import (
+from amrita_core.base.adapter import (
     COMPLETION_RETURNING,
     ModelAdapter,
 )
+from amrita_core.config import AmritaConfig
+from amrita_core.contents import MessageMetadataPayload, MessageWithMetadata
 from amrita_core.tools.models import (
     FunctionParametersSchema,
     ToolChoice,

{amrita_core-0.9.4 → amrita_core-0.10.0.dev2}/src/amrita_core/adapters/openai.py

@@ -2,6 +2,7 @@ from collections.abc import AsyncGenerator, Iterable, Sequence
 from typing import cast
 
 import openai
+from amrita_sense.logging import debug_log
 from openai._types import SequenceNotStr
 from openai.types.chat.chat_completion import ChatCompletion
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
@@ -17,13 +18,12 @@ from openai.types.chat.chat_completion_tool_choice_option_param import (
 )
 from typing_extensions import override
 
-from amrita_core.config import AmritaConfig
-from amrita_core.contents import MessageMetadataPayload, MessageWithMetadata
-from amrita_core.logging import debug_log
-from amrita_core.protocol import (
+from amrita_core.base.adapter import (
     COMPLETION_RETURNING,
     ModelAdapter,
 )
+from amrita_core.config import AmritaConfig
+from amrita_core.contents import MessageMetadataPayload, MessageWithMetadata
 from amrita_core.tools.models import (
     ToolChoice,
     ToolFunctionSchema,

amrita_core-0.10.0.dev2/src/amrita_core/agent/functions.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from uuid import uuid4
+
+from jinja2 import Template
+
+from amrita_core.base.backend import BackendSlots
+from amrita_core.builtins.agent import ReActAgentStrategy
+from amrita_core.builtins.backends import LegacyBackend
+from amrita_core.chatmanager import ChatObject
+from amrita_core.config import get_config
+from amrita_core.consts import DEFAULT_INSTRUCTIONS, DEFAULT_TEMPLATE
+from amrita_core.types import USER_INPUT, Message, ModelConfig, ModelPreset
+
+if TYPE_CHECKING:
+    from amrita_core.config import AmritaConfig
+
+    from .strategy import AgentStrategy
+
+
+class AgentRuntime:
+    """
+    AgentRuntime is a high-level wrapper around ChatObject that provides a reusable
+    agent operation interface.
+
+    This class encapsulates the complexity of ChatObject and provides a simplified
+    API for agent interactions. It maintains session state, configuration, and
+    strategy settings, making it a reusable object for multiple agent operations
+    within the same context.
+
+    Session and memory management is delegated to the Backend mechanism
+    (:class:`BackendSlots`), which handles memory loading, committing, and
+    ability resolution transparently.  AgentRuntime itself only holds a
+    ``session_id`` string and a ``slot`` reference — the actual state lives
+    inside the Backend and is lazily resolved by :class:`ChatObject` at
+    runtime.
+    """
+
+    strategy: type[AgentStrategy]
+    session_id: str
+    slot: BackendSlots
+    preset: ModelPreset
+    config: AmritaConfig
+    train: Message[str]
+    template: Template
+
+    def __init__(
+        self,
+        config: AmritaConfig,
+        preset: ModelPreset,
+        train: dict[str, str] | Message[str],
+        strategy: type[AgentStrategy] = ReActAgentStrategy,
+        template: Template | str = DEFAULT_TEMPLATE,
+        session_id: str | None = None,
+        backend: BackendSlots | None = None,
+    ):
+        """
+        Initialize an AgentRuntime instance.
+
+        Args:
+            config: Amrita configuration object containing global configuration settings.
+            preset: Model preset configuration defining basic model parameters and settings.
+            train: System prompt for the agent (dict or Message).
+            strategy: Agent strategy class, defaults to ReActAgentStrategy.
+            template: Jinja2 template (or template string) used to render the system prompt.
+            session_id: Session identifier string. If None, a new UUID-based ID is generated.
+                The session_id is passed to every ChatObject created by this runtime,
+                allowing the Backend to isolate memory and abilities per session.
+            backend: Backend slots providing memory and ability backends. If None, a
+                :class:`LegacyBackend` is used for both slots, which stores data in
+                global in-process containers.
+        """
+        self.session_id = session_id or uuid4().hex
+        bkd = LegacyBackend()
+        self.slot = backend or BackendSlots(bkd, bkd)
+        self.template = Template(template) if isinstance(template, str) else template
+        self.strategy = strategy
+        self.preset = preset
+        self.config = config
+        self.train = (
+            train if isinstance(train, Message) else Message[str].model_validate(train)
+        )
+
+    def set_strategy(self, strategy: type[AgentStrategy]) -> None:
+        """
+        Set the agent strategy to be used for execution.
+
+        Args:
+            strategy: The agent strategy class to be used for execution.
+        """
+        self.strategy = strategy
+
+    def get_chatobject(self, user_input: USER_INPUT, **kwargs) -> ChatObject:
+        """Create a :class:`ChatObject` bound to this runtime's configuration.
+
+        The returned ChatObject reuses the runtime's preset, config, strategy,
+        system prompt template, session_id and backend slots.  Memory and
+        ability resolution is handled lazily by ChatObject via the backend.
+
+        Args:
+            user_input: The user's input message.
+            **kwargs: Additional keyword arguments forwarded to :class:`ChatObject`
+                (e.g. ``io_stream``, ``hook_args``, ``middleware``, etc.).
+
+        Returns:
+            A fully configured ChatObject ready for execution.
+        """
+        return ChatObject(
+            train=self.train,
+            user_input=user_input,
+            context=None,
+            session_id=self.session_id,
+            backend=self.slot,
+            config=self.config,
+            preset=self.preset,
+            agent_strategy=self.strategy,
+            train_template=self.template,
+            **kwargs,
+        )
+
+
+def create_agent(
+    base_url: str,
+    api_key: str,
+    model: str = "auto",
+    *,
+    train: str | None = None,
+    model_config: ModelConfig | dict | None = None,
+    config: AmritaConfig | None = None,
+    **kwargs,
+) -> AgentRuntime:
+    """
+    Create an agent with minimal parameters by automatically creating a temporary preset.
+
+    This factory function simplifies agent creation by only requiring essential
+    parameters like URL and API key, automatically creating a temporary preset.
+
+    Args:
+        base_url: The API endpoint URL.
+        api_key: The API key for authentication.
+        model: The model to use. Defaults to "auto".
+        model_config: Optional model configuration (dict or ModelConfig).
+        config: Configuration for the agent. Defaults to global config.
+        **kwargs: Additional keyword arguments forwarded to :class:`AgentRuntime`
+            (e.g. ``strategy``, ``template``, ``session_id``, ``backend``).
+
+    Returns:
+        A configured :class:`AgentRuntime` instance.
+
+    Example:
+        ```python
+        agent = create_agent(
+            "https://api.example.com",
+            "your-api-key",
+            model="gpt-4",
+            model_config={"temperature": 0.7},
+        )
+        ```
+    """
+    if train is None:
+        train = DEFAULT_INSTRUCTIONS
+    final_config = config or get_config()
+    if isinstance(model_config, dict):
+        model_config = ModelConfig(**model_config)
+    elif not model_config:
+        model_config = ModelConfig()
+
+    preset = ModelPreset(
+        name=f"temp_{uuid4().hex[:8]}",
+        base_url=base_url,
+        api_key=api_key,
+        config=model_config,
+        model=model,
+    )
+
+    return AgentRuntime(
+        config=final_config,
+        preset=preset,
+        train=Message(content=train, role="system"),
+        **{k: v for k, v in kwargs.items() if k not in ["config", "model_config"]},
+    )

{amrita_core-0.9.4 → amrita_core-0.10.0.dev2}/src/amrita_core/agent/strategy.py

@@ -9,10 +9,7 @@ from typing import TYPE_CHECKING, Any, Literal
 from typing_extensions import Self
 
 from amrita_core.agent.context import StrategyContext
-from amrita_core.contents import MessageMetadataPayloadSystem
-from amrita_core.protocol import MessageWithMetadata
-from amrita_core.sessions import SessionData, SessionsManager
-from amrita_core.tools.manager import ToolsManager
+from amrita_core.contents import MessageMetadataPayloadSystem, MessageWithMetadata
 from amrita_core.tools.models import ToolContext
 from amrita_core.types import Message, ToolCall
 
@@ -31,7 +28,6 @@ class _StrategyBase(ABC):
     """Shared execution logic for AgentStrategy and StrategyLikedObject, which
     differ only in how the context is injected (``__init__`` vs ``__call__``)."""
 
-    session: SessionData | None = None
     tools_manager: "MultiToolsManager"
     chat_object: "ChatObject"
     ctx: StrategyContext
@@ -39,9 +35,7 @@ class _StrategyBase(ABC):
     def _bind(self, ctx: StrategyContext) -> None:
         self.ctx = ctx
         self.chat_object = ctx.chat_object
-        session_id = ctx.chat_object.session_id
-        self.session = SessionsManager().get_session_data(session_id, None)
-        self.tools_manager = self.session.tools if self.session else ToolsManager()
+        self.tools_manager = ctx.chat_object.state.ability.tools
 
     async def single_execute(
         self,

{amrita_core-0.9.4 → amrita_core-0.10.0.dev2}/src/amrita_core/base/adapter.py

@@ -5,10 +5,10 @@ from collections.abc import AsyncGenerator, Iterable, Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Literal
 
+from amrita_sense.logging import logger
+
 from amrita_core.config import AmritaConfig, get_config
-from amrita_core.threadsafe import ContextThreadsafe
 
-from ..logging import logger
 from ..tools.models import ToolChoice, ToolFunctionSchema
 from ..types import EmbeddingChunk, ModelPreset, ToolCall, UniResponse
 
@@ -93,7 +93,7 @@ class ModelAdapter:
         return self.get_adapter_protocol()
 
 
-class AdapterManager(ContextThreadsafe):
+class AdapterManager:
     __instance = None
     __inited = False
     _adapter_class: dict[str, type[ModelAdapter]]

amrita_core-0.10.0.dev2/src/amrita_core/base/backend.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from amrita_core.contexts import AbilityContext
+    from amrita_core.preset import MultiPresetManager
+    from amrita_core.tools.manager import MultiToolsManager
+    from amrita_core.tools.mcp import MultiClientManager
+    from amrita_core.types import MemoryModel
+
+
+class AbilityBackend:
+    @abstractmethod
+    async def load_ability_all(self, session_id: str) -> AbilityContext:
+        """Load ability"""
+        ...
+
+    @abstractmethod
+    async def load_mcp_clients(self, session_id: str) -> MultiClientManager: ...
+
+    @abstractmethod
+    async def load_tools(self, session_id: str) -> MultiToolsManager: ...
+
+    @abstractmethod
+    async def load_presets(self, session_id: str) -> MultiPresetManager: ...
+
+
+class MemoryBackend:
+    @abstractmethod
+    async def load_memory(self, session_id: str) -> MemoryModel:
+        """Load memory"""
+        ...
+
+    @abstractmethod
+    async def commit_memory(self, session_id: str, memory: MemoryModel) -> None:
+        """Commit memory"""
+        ...
+
+
+@dataclass
+class BackendSlots:
+    ability: AbilityBackend
+    memory: MemoryBackend

{amrita_core-0.9.4 → amrita_core-0.10.0.dev2}/src/amrita_core/base/tokenizer.py

@@ -3,8 +3,6 @@ from typing import Literal
 
 from amrita_sense.logging import logger
 
-from amrita_core.threadsafe import ContextThreadsafe
-
 
 class BaseTokenizer(ABC):
     __override__: bool = False  # Whether to allow overriding existing tokenizers
@@ -64,7 +62,7 @@ class BaseTokenizer(ABC):
         ...
 
 
-class TokenizerManager(ContextThreadsafe):
+class TokenizerManager:
     __instance = None
     __inited = False
     _tokenizer_class: dict[str, type[BaseTokenizer]]