amrita_core 0.10.0.dev2__tar.gz → 0.10.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amrita_core
-Version: 0.10.0.dev2
+Version: 0.10.2
 Summary: High performance, flexible, lightweight agent framework.
 Project-URL: Homepage, https://github.com/AmritaBot/AmritaCore
 Project-URL: Source, https://github.com/AmritaBot/AmritaCore

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

@@ -1,6 +1,6 @@
 [project]
 name = "amrita_core"
-version = "0.10.0.dev2"
+version = "0.10.2"
 description = "High performance, flexible, lightweight agent framework."
 readme = "README.md"
 requires-python = ">=3.10,<3.15"

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

@@ -113,7 +113,9 @@ __all__ = [
     "get_config",
     "get_last_response",
     "get_tokens",
+    "load_amrita",
     "mcp",
+    "minimal_init",
     "on_completion",
     "on_event",
     "on_precompletion",

{amrita_core-0.10.0.dev2 → amrita_core-0.10.2}/src/amrita_core/base/backend.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
@@ -12,7 +12,7 @@ if TYPE_CHECKING:
     from amrita_core.types import MemoryModel
 
 
-class AbilityBackend:
+class AbilityBackend(ABC):
     @abstractmethod
     async def load_ability_all(self, session_id: str) -> AbilityContext:
         """Load ability"""
@@ -28,7 +28,7 @@ class AbilityBackend:
     async def load_presets(self, session_id: str) -> MultiPresetManager: ...
 
 
-class MemoryBackend:
+class MemoryBackend(ABC):
     @abstractmethod
     async def load_memory(self, session_id: str) -> MemoryModel:
         """Load memory"""

{amrita_core-0.10.0.dev2 → amrita_core-0.10.2}/src/amrita_core/builtins/agent.py

@@ -21,6 +21,7 @@ from amrita_core.libchat import (
 )
 from amrita_core.types import (
     CONTENT_LIST_TYPE_ITEM,
+    Function,
     Message,
     SendMessageWrap,
     TextContent,
@@ -578,158 +579,230 @@ class BaseReActAgentStrategy(AgentStrategy, ABC):
         """
         pass
 
+    async def _run_tool_calls_concurrently(
+        self,
+        tool_calls: list[ToolCall],
+    ) -> list[tuple[ToolCall, str, BaseException | None]]:
+        """Execute multiple tool calls concurrently via asyncio.gather.
+
+        Built-in flow-control tools (REASONING, STOP) are dispatched to their
+        specialised handlers inside each coroutine.  Regular tools use
+        :meth:`call_tool`.  One failure does not cancel the others.
+        Results are returned in the same order as the input list.
+
+        Subclasses may override this to change the execution strategy (e.g. add
+        throttling, retries, or switch to sequential fallback).
+
+        Args:
+            tool_calls: ToolCall objects to execute concurrently.  Callers should
+                order them so that built-in tools appear **after** regular tools
+                so that the side-effects of built-in handlers do not race with
+                the context modifications produced by regular-tool result
+                processing.
+
+        Returns:
+            List of ``(tool_call, result_string, original_exception)`` tuples.
+            ``original_exception`` is the exception instance when an error
+            occurred, ``None`` otherwise.  On error ``result_string`` is
+            formatted as ``"ERR: Tool {name} execution failed\\n{error}"``.
+        """
+
+        async def _exec_one(tc: ToolCall) -> tuple[ToolCall, str, BaseException | None]:
+            fn = tc.function.name
+            try:
+                if fn == REASONING_TOOL.function.name:
+                    content: UniResponse[
+                        str, None
+                    ] = await self._generate_reasoning_content(
+                        tc, self.ctx.original_context.unwrap()
+                    )
+                    await self._append_reasoning(tc, content)
+                    return (tc, content.content, None)
+                if fn == STOP_TOOL.function.name:
+                    args: dict[str, Any] = json.loads(tc.function.arguments)
+                    self.agent_last_step = "Stopped"
+                    self.reasoning_pc = 0
+                    self._suggested_stop = True
+                    logger.info("Agent work has been terminated.")
+
+                    if self._should_enable_reflection():
+                        logger.debug("Running post-reasoning reflection...")
+                        reason_ctx = self.ctx.original_context.unwrap()
+                        reflection_results = await self._run_reflection(reason_ctx)
+                        failures = [
+                            r for r in reflection_results if r["result"] == "fail"
+                        ]
+                        if failures:
+                            correction_msg = (
+                                "<BEGIN_OF_REFLECTION_CORRECTION>\n"
+                                + "Your reasoning was checked and the following issues were found:\n"
+                                + "\n".join(
+                                    f"- [{r['check_type']}] {r['detail']}"
+                                    for r in failures
+                                )
+                                + "\nPlease re-examine your reasoning and correct these issues "
+                                + "before providing the final answer.\n"
+                                + "<END_OF_REFLECTION_CORRECTION>"
+                            )
+                            self.ctx.message.append(
+                                Message(role="user", content=correction_msg)
+                            )
+                            # Empty result → caller skips stop response.
+                            return (tc, "", None)
+
+                    result = self._build_stop_response(args)
+                    return (tc, result, None)
+
+                # Regular tool
+                result = await self.call_tool(tc)
+                return (tc, result, None)
+            except Exception as e:
+                error_content = await self._handle_tool_error_common(fn, e, tc.id)
+                return (tc, error_content, e)
+
+        return await asyncio.gather(*[_exec_one(tc) for tc in tool_calls])
+
     async def _execute_tool_loop(
         self,
         response_msg: UniResponse[None, list[ToolCall] | None],
     ) -> bool:
-        """Execute the main tool calling loop with strategy-specific behaviors.
+        """Execute the main tool calling loop.
 
-        This is a template method that defines the common execution flow while
-        delegating strategy-specific behaviors to abstract methods.
+        All tool calls are executed concurrently via
+        :meth:`_run_tool_calls_concurrently`.  Built-in tools are ordered last
+        so that their message-list side-effects (reasoning append, stop
+        response) are applied after regular-tool results.
 
         Args:
-            response_msg: The response from tools_caller containing tool calls
+            response_msg: The response from tools_caller containing tool calls.
 
         Returns:
-            True if execution should continue, False if it should stop
+            True if execution should continue, False if it should stop.
         """
         if not (tool_calls := response_msg.tool_calls):
             return False
 
-        result_msg_list: list[ToolResult] = []
-        ret: bool = True
-        for tool_call in tool_calls:
-            function_name = tool_call.function.name
-            function_args: dict[str, Any] = json.loads(tool_call.function.arguments)
-            debug_log(f"Function arguments are {tool_call.function.arguments}")
-            logger.info(f"Calling function {function_name}")
+        # Built-in tools last so their side-effects don't race with regular tools.
+        tool_calls.sort(
+            key=lambda tc: (
+                tc.function.name
+                in (REASONING_TOOL.function.name, STOP_TOOL.function.name)
+            )
+        )
+
+        #  Notify "calling" for every tool
+        for tc in tool_calls:
             await self.chat_object.io_stream.yield_response(
                 MessageWithMetadata(
-                    content=f"Calling function {function_name}\n",
+                    content=f"Calling function {tc.function.name}\n",
                     metadata=AgentToolCallMetadata(
                         type="function_call",
                         extra_type=None,
-                        function_name=function_name,
+                        function_name=tc.function.name,
                         is_done=False,
-                        tool_id=tool_call.id,
+                        tool_id=tc.id,
                         err=None,
                     ),
                 )
             )
 
-            func_response: str = ""
-            try:
-                match function_name:
-                    case REASONING_TOOL.function.name:
-                        logger.debug("Generating task summary and reason.")
-                        content: UniResponse[
-                            str, None
-                        ] = await self._generate_reasoning_content(
-                            tool_call, self.ctx.original_context.unwrap()
-                        )
-                        await self._append_reasoning(tool_call, content)
-                        return True
-                    case STOP_TOOL.function.name:
-                        self.agent_last_step = "Stopped"
-                        self.reasoning_pc = 0
-                        self._suggested_stop = True
-                        logger.info("Agent work has been terminated.")
-
-                        if self._should_enable_reflection():
-                            logger.debug("Running post-reasoning reflection...")
-                            reason_ctx = self.ctx.original_context.unwrap()
-                            reflection_results = await self._run_reflection(reason_ctx)
-                            # Check for failures and inject correction
-                            failures = [
-                                r for r in reflection_results if r["result"] == "fail"
-                            ]
-                            if failures:
-                                correction_msg = (
-                                    "<BEGIN_OF_REFLECTION_CORRECTION>\n"
-                                    + "Your reasoning was checked and the following issues were found:\n"
-                                    + "\n".join(
-                                        f"- [{r['check_type']}] {r['detail']}"
-                                        for r in failures
-                                    )
-                                    + "\nPlease re-examine your reasoning and correct these issues "
-                                    + "before providing the final answer.\n"
-                                    + "<END_OF_REFLECTION_CORRECTION>"
-                                )
-                                self.ctx.message.append(
-                                    Message(
-                                        role="user",
-                                        content=correction_msg,
-                                    )
-                                )
-                                # Don't build stop response yet — let the agent re-reason
-                                continue
-
-                        func_response = self._build_stop_response(function_args)
-                        await self._build_stop_response_and_append(
-                            function_args,
-                            response_msg,
-                            function_name,
-                            tool_call.id,
-                            func_response,
-                        )
-                    case _:
-                        self.reasoning_pc = 0
-                        func_response = await self.call_tool(tool_call)
-                        await self._append_tool_result_to_context(
-                            tool_call, func_response, response_msg
-                        )
-            except Exception as err:
-                error_content = await self._handle_tool_error_common(
-                    function_name, err, tool_call.id
+        concurrent_results: list[
+            tuple[ToolCall, str, BaseException | None]
+        ] = await self._run_tool_calls_concurrently(tool_calls)
+
+        #  Append results sequentially
+        result_msg_list: list[ToolResult] = []
+        should_continue = True  # default: keep looping (old `ret` semantics)
+        for tc, func_response, exc in concurrent_results:
+            function_name = tc.function.name
+            is_reasoning = function_name == REASONING_TOOL.function.name
+            is_stop = function_name == STOP_TOOL.function.name
+
+            if is_reasoning:
+                # _run_tool_calls_concurrently already called _append_reasoning.
+                should_continue = True
+                continue
+
+            if is_stop:
+                if not func_response:
+                    # Reflection failed — correction already injected, continue.
+                    continue
+                await self._build_stop_response_and_append(
+                    json.loads(tc.function.arguments),
+                    response_msg,
+                    function_name,
+                    tc.id,
+                    func_response,
                 )
-                # Strategy-specific error handling with original exception
+            elif func_response.startswith("ERR:"):
+                self.reasoning_pc = 0
                 await self._handle_error_append(
                     function_name,
-                    error_content,
-                    tool_call.id,
-                    original_exception=err,
+                    func_response,
+                    tc.id,
+                    original_exception=exc,
                 )
             else:
-                logger.debug(f"Function {function_name} returned: {func_response}")
-                msg: ToolResult = ToolResult(
+                self.reasoning_pc = 0
+                await self._append_tool_result_to_context(
+                    tc, func_response, response_msg
+                )
+
+            logger.debug(f"Function {function_name} returned: {func_response}")
+            result_msg_list.append(
+                ToolResult(
                     role="tool",
                     content=func_response,
                     name=function_name,
-                    tool_call_id=tool_call.id,
+                    tool_call_id=tc.id,
                 )
-                result_msg_list.append(msg)
+            )
+            self.call_count += 1
 
-            finally:
-                self.call_count += 1
-                prompt = self._check_and_handle_loop_reasoning()
-                if prompt is not None:
-                    await self._handle_loop_reasoning_cleanup(prompt)
-                    await self.chat_object.io_stream.yield_response(
-                        MessageWithMetadata(
-                            content=prompt,
-                            metadata=AgentLoopErrorMetadata(
-                                type="error",
-                                extra_type="loop_reasoning",
-                                chat_object_id=self.chat_object.stream_id,
-                                error=prompt,
-                            ),
-                        )
+            prompt = self._check_and_handle_loop_reasoning()
+            if prompt is not None:
+                await self._handle_loop_reasoning_cleanup(prompt)
+                await self.chat_object.io_stream.yield_response(
+                    MessageWithMetadata(
+                        content=prompt,
+                        metadata=AgentLoopErrorMetadata(
+                            type="error",
+                            extra_type="loop_reasoning",
+                            chat_object_id=self.chat_object.stream_id,
+                            error=prompt,
+                        ),
                     )
-                    ret = False
+                )
+                # Stop early — don't process remaining results.
+                should_continue = False
+                break
 
-            # Send tool call info to user
-            await self._notify_tool_calls(result_msg_list, function_name, tool_call.id)
+        #  Notify once with the complete result list.
+        if result_msg_list:
+            await self._notify_tool_calls(
+                result_msg_list,
+                result_msg_list[-1].name,
+                result_msg_list[-1].tool_call_id,
+            )
 
-        return ret
+        return should_continue
 
     async def _handle_error_append(
         self,
         function_name: str,
         error_content: str,
         tool_call_id: str,
-        original_exception: BaseException,
+        original_exception: BaseException | None = None,
     ):
-        """Handle appending error messages to context (strategy-specific)."""
+        """Handle appending error messages to context (strategy-specific).
+
+        Args:
+            function_name: Name of the failed function.
+            error_content: Formatted error message to append.
+            tool_call_id: ID of the failed tool call.
+            original_exception: The original exception, or ``None`` when the error
+                was captured as a string during concurrent execution.
+        """
         ...
 
     @abstractmethod
@@ -1127,9 +1200,25 @@ class ReActAgentStrategy(BaseReActAgentStrategy):
         function_call_id: str,
         function_response: str,
     ):
-        """ReAct strategy: append assistant message before stop."""
+        """ReAct strategy: append assistant message with only this STOP tool_call before its ToolResult.
+
+        Only a single ToolCall is included in the assistant message to avoid the
+        "insufficient tool messages following tool_calls message" API error.
+        """
         self.ctx.message.append(
-            Message.model_validate(response_msg, from_attributes=True)
+            Message(
+                role="assistant",
+                content=None,
+                tool_calls=[
+                    ToolCall(
+                        id=function_call_id,
+                        function=Function(
+                            name=function_name,
+                            arguments=json.dumps(function_args),
+                        ),
+                    )
+                ],
+            )
         )
         self.ctx.message.append(
             ToolResult(
@@ -1147,14 +1236,16 @@ class ReActAgentStrategy(BaseReActAgentStrategy):
         func_response: str,
         response_msg: UniResponse[None, list[ToolCall] | None],
     ):
-        """ReAct strategy: append both assistant message and tool result as a pair.
+        """ReAct strategy: append assistant message with only this tool_call paired with its ToolResult.
 
         This follows OpenAI's ToolCall-ToolResult pairing requirement where every
         assistant message with tool_calls must be followed by corresponding tool messages.
+        Only a single ToolCall is included per assistant message to prevent the
+        "insufficient tool messages following tool_calls message" API error when the
+        model returns multiple tool_calls in one response.
         """
-        # First, append the assistant message containing the tool_calls
         msg_list = self.ctx.message
-        msg_list.append(Message.model_validate(response_msg, from_attributes=True))
+        msg_list.append(Message(role="assistant", content=None, tool_calls=[tool_call]))
         msg_list.append(
             ToolResult(
                 role="tool",
@@ -1170,20 +1261,36 @@ class ReActAgentStrategy(BaseReActAgentStrategy):
         function_name: str,
         error_content: str,
         tool_call_id: str,
-        original_exception: BaseException,
+        original_exception: BaseException | None = None,
     ):
-        """ReAct strategy: append error as ToolResult with optional exception context.
+        """ReAct strategy: append error as an assistant+tool message pair.
 
-        The original_exception parameter allows for advanced error handling strategies,
-        such as different recovery behaviors based on exception type (e.g., retry on
-        timeout, abort on authentication errors).
+        An assistant message with a single ToolCall is prepended to satisfy the
+        OpenAI API requirement that every ToolResult must follow an assistant
+        message containing the corresponding tool_call.
 
         Args:
             function_name: Name of the failed function
             error_content: Formatted error message to append
             tool_call_id: ID of the tool call
-            original_exception: The original exception object for type-based handling
+            original_exception: The original exception, or ``None`` when the
+                error was captured as a string during concurrent execution.
         """
+        self.ctx.message.append(
+            Message(
+                role="assistant",
+                content=None,
+                tool_calls=[
+                    ToolCall(
+                        id=tool_call_id,
+                        function=Function(
+                            name=function_name,
+                            arguments="{}",
+                        ),
+                    )
+                ],
+            )
+        )
         self.ctx.message.append(
             ToolResult(
                 role="tool",
@@ -1193,6 +1300,7 @@ class ReActAgentStrategy(BaseReActAgentStrategy):
             )
         )
 
+    @override
     async def single_execute(
         self,
     ) -> bool:

{amrita_core-0.10.0.dev2 → amrita_core-0.10.2}/src/amrita_core/builtins/tools.py

@@ -15,7 +15,8 @@ from .types import AgentMiddleMessageMetadata
 
 PROCESS_MESSAGE_TOOL = FunctionDefinitionSchema(
     name="processing_message",
-    description="Describe what the agent is currently doing and express the agent's internal thoughts to the user. Use this when you need to communicate your current actions or internal reasoning to the user, not for general completion.",
+    description="Describe what the agent is currently doing and express the agent's **internal ideas** to the user."
+    + " Use this when you need to communicate your current actions or internal ideas to the user, **not** for general completion.",
     parameters=FunctionParametersSchema(
         type="object",
         properties={

{amrita_core-0.10.0.dev2 → amrita_core-0.10.2}/src/amrita_core/chatmanager/chat_object.py

@@ -115,9 +115,9 @@ class ChatObject:
     # Timing
     timestamp: str  # Timestamp (for LLM)
     time: datetime  # Time
-    end_at: datetime | None = None
+    end_at: datetime | None
     last_call: datetime  # Last internal function call time
-    now_calling: str | None = None  # currently calling function name
+    now_calling: str | None  # currently calling function name
 
     # Config & Preset
     config: AmritaConfig  # config used in this call
@@ -143,10 +143,10 @@ class ChatObject:
     extra_usage: UniResponseUsage[int]
 
     # Runtime State
-    _is_running: bool = False  # Whether it is running
-    _is_done: bool = False  # Whether it has completed
+    _is_running: bool  # Whether it is running
+    _is_done: bool  # Whether it has completed
     _task: Task[None]  # (lateinit) set on runtime
-    _err: BaseException | None = None  # Exception in runtime
+    _err: BaseException | None  # Exception in runtime
 
     # Options
     _bke_opt: DatabackendOptions
@@ -156,21 +156,53 @@ class ChatObject:
     _raised_exc: tuple[type[BaseException], ...]
 
     # Workflow / Interpreter
-    _workflow: (
-        NodeComposeRendered  # (lateinit) ChatObject's runtime, will be set in __init__.
-    )
-    _interpreter: (
-        WorkflowInterpreter  # (lateinit) When _entry is called, this will be set.
-    )
+    _workflow: NodeComposeRendered
+    _interpreter: WorkflowInterpreter
     _middleware: (
         Callable[[Self], Awaitable[Any]] | None
     )  # Middleware for the whole workflow, will be set in __init__.
 
     # Agent loop state
-    _agent_loop: AgentLoopState | None = None
+    _agent_loop: AgentLoopState | None
 
     # ChatObject temp storage
     _chatman: ChatManager
+    __slots__ = (
+        "_agent_loop",
+        "_bke_opt",
+        "_chatman",
+        "_err",
+        "_hook_args",
+        "_hook_kwargs",
+        "_interpreter",
+        "_is_done",
+        "_is_running",
+        "_middleware",
+        "_raised_exc",
+        "_s_id",
+        "_task",
+        "_workflow",
+        "config",
+        "context_wrap",
+        "end_at",
+        "extra_usage",
+        "io_stream",
+        "jinja2_vars",
+        "last_call",
+        "now_calling",
+        "preset",
+        "response",
+        "slot",
+        "state",
+        "strategy",
+        "stream_id",
+        "template",
+        "time",
+        "timestamp",
+        "train",
+        "user_input",
+        "user_message",
+    )
 
     def __init__(
         self,
@@ -226,6 +258,13 @@ class ChatObject:
             backend_options: Fine-grained control over which backend
                 fetch/commit operations are performed.
         """
+        # Init as None in slots
+        self._agent_loop = None
+        self._err = None
+        self._is_done = False
+        self._is_running = False
+        self.now_calling = None
+        self.end_at = None
         # Special flags
         self._raised_exc = (
             exception_ignored if not __flags__.DISABLE_EXC_IGNORED else ()
@@ -530,6 +569,8 @@ async def _load_state(chat_obj: ChatObject):
             )
     if not (opt.skip_memory_fetch):
         chat_obj.state.memory = await slot.memory.load_memory(chat_obj.state.session_id)
+    if not hasattr(chat_obj, "preset"):
+        chat_obj.preset = chat_obj.state.ability.presets.get_default_preset()
 
 
 @Node(SuspendEnum.TRAIN_RENDER)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amrita_core
-Version: 0.10.0.dev2
+Version: 0.10.2
 Summary: High performance, flexible, lightweight agent framework.
 Project-URL: Homepage, https://github.com/AmritaBot/AmritaCore
 Project-URL: Source, https://github.com/AmritaBot/AmritaCore