abstractagent 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

abstractagent/logic/codeact.py

@@ -1,7 +1,11 @@
 """CodeAct logic (pure; no runtime imports).
 
-CodeAct is a ReAct-like loop where the main action is executing Python code
-instead of calling many specialized tools.
+This module implements a conventional CodeAct loop:
+- the model primarily acts by producing Python code (or calling execute_python)
+- tool results are appended to chat history
+- the model iterates until it can answer directly
+
+CodeAct is intentionally *not* a memory-enhanced agent.
 """
 
 from __future__ import annotations
@@ -26,7 +30,6 @@ class CodeActLogic:
     ):
         self._tools = list(tools)
         self._max_history_messages = int(max_history_messages)
-        # -1 means unlimited (send all messages), otherwise must be >= 1
         if self._max_history_messages != -1 and self._max_history_messages < 1:
             self._max_history_messages = 1
         self._max_tokens = max_tokens
@@ -35,6 +38,23 @@ class CodeActLogic:
     def tools(self) -> List[ToolDefinition]:
         return list(self._tools)
 
+    def add_tools(self, tools: List[ToolDefinition]) -> int:
+        if not isinstance(tools, list) or not tools:
+            return 0
+
+        existing = {str(t.name) for t in self._tools if getattr(t, "name", None)}
+        added = 0
+        for t in tools:
+            name = getattr(t, "name", None)
+            if not isinstance(name, str) or not name.strip():
+                continue
+            if name in existing:
+                continue
+            self._tools.append(t)
+            existing.add(name)
+            added += 1
+        return added
+
     def build_request(
         self,
         *,
@@ -45,58 +65,74 @@ class CodeActLogic:
         max_iterations: int = 20,
         vars: Optional[Dict[str, Any]] = None,
     ) -> LLMRequest:
-        """Build an LLM request for the CodeAct agent.
-
-        Args:
-            task: The task to perform
-            messages: Conversation history
-            guidance: Optional guidance text to inject
-            iteration: Current iteration number
-            max_iterations: Maximum allowed iterations
-            vars: Optional run.vars dict. If provided, limits are read from
-                  vars["_limits"] (canonical) with fallback to instance defaults.
-        """
+        _ = messages  # history is carried out-of-band via chat messages
+
         task = str(task or "")
         guidance = str(guidance or "").strip()
 
-        # Get limits from vars if available, else use instance defaults
         limits = (vars or {}).get("_limits", {})
-        max_history = int(limits.get("max_history_messages", self._max_history_messages) or self._max_history_messages)
-        max_tokens = limits.get("max_tokens", self._max_tokens)
-        if max_tokens is not None:
-            max_tokens = int(max_tokens)
-
-        # -1 means unlimited (use all messages)
-        if max_history == -1:
-            history = messages if messages else []
-        else:
-            history = messages[-max_history:] if messages else []
-        history_text = "\n".join(
-            [f"{m.get('role', 'unknown')}: {m.get('content', '')}" for m in history]
-        )
-
-        prompt = (
-            "You are CodeAct: you can solve tasks by writing and executing Python code.\n"
-            "Use the tool `execute_python` to run Python snippets. Prefer small, focused scripts.\n"
-            "Print any intermediate results you need.\n"
-            "When you are confident, provide the final answer without calling tools.\n\n"
+        max_output_tokens = limits.get("max_output_tokens", None)
+        if max_output_tokens is not None:
+            try:
+                max_output_tokens = int(max_output_tokens)
+            except Exception:
+                max_output_tokens = None
+
+        runtime_ns = (vars or {}).get("_runtime", {})
+        scratchpad = (vars or {}).get("scratchpad", {})
+        plan_mode = bool(runtime_ns.get("plan_mode")) if isinstance(runtime_ns, dict) else False
+        plan_text = scratchpad.get("plan") if isinstance(scratchpad, dict) else None
+        plan = str(plan_text).strip() if isinstance(plan_text, str) and plan_text.strip() else ""
+
+        prompt = task.strip()
+
+        output_budget_line = ""
+        if isinstance(max_output_tokens, int) and max_output_tokens > 0:
+            output_budget_line = f"- Output token limit for this response: {max_output_tokens}.\n"
+
+        system_prompt = (
             f"Iteration: {int(iteration)}/{int(max_iterations)}\n\n"
-            f"Task: {task}\n\n"
-        )
-        if history_text:
-            prompt += f"History:\n{history_text}\n\n"
+            "You are CodeAct: you solve tasks by writing and executing Python when needed.\n\n"
+            "Evidence & action (IMPORTANT):\n"
+            "- Be truthful: only claim actions supported by tool outputs.\n"
+            "- If the task requires code execution or file edits, do it now (call a tool or output a fenced ```python``` block).\n"
+            "- Do not “announce” actions without executing them.\n\n"
+            "Rules:\n"
+            "- Be truthful: only claim actions supported by tool outputs.\n"
+            "- Be autonomous: do not ask the user for confirmation to proceed; keep going until the task is done.\n"
+            "- If you need to run code, call `execute_python` (preferred) or output a fenced ```python code block.\n"
+            "- Efficiency: batch independent read-only tool calls into a single turn (multiple tool calls) to reduce iterations.\n"
+            "  Examples: read_file for multiple files/ranges, search_files with different queries, list_files across folders, analyze_code on multiple targets.\n"
+            "  Only split tool calls across turns when later calls depend on earlier outputs; avoid batching side-effectful tools (write/edit/execute).\n"
+            "- When context is getting large, use delegate_agent(task, context, tools) to offload an independent subtask with minimal context.\n"
+            "- Never fabricate tool outputs.\n"
+            "- Only ask the user a question when required information is missing.\n"
+            f"{output_budget_line}"
+        ).strip()
 
         if guidance:
-            prompt += f"[User guidance]: {guidance}\n\n"
-
-        prompt += (
-            "If you need to run code, either:\n"
-            "- Call `execute_python` with the Python code, or\n"
-            "- If tool calling is unavailable, include a fenced ```python code block.\n"
+            system_prompt = (system_prompt + "\n\nGuidance:\n" + guidance).strip()
+
+        if plan_mode and plan:
+            system_prompt = (system_prompt + "\n\nCurrent plan:\n" + plan).strip()
+
+        if plan_mode:
+            system_prompt = (
+                system_prompt
+                + "\n\nPlan mode:\n"
+                "- Maintain and update the plan as you work.\n"
+                "- If the plan changes, include a final section at the END of your message:\n"
+                "  Plan Update:\n"
+                "  <markdown checklist>\n"
+            ).strip()
+
+        return LLMRequest(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            tools=self.tools,
+            max_tokens=max_output_tokens,
         )
 
-        return LLMRequest(prompt=prompt, tools=self.tools, max_tokens=max_tokens)
-
     def parse_response(self, response: Any) -> Tuple[str, List[ToolCall]]:
         if not isinstance(response, dict):
             return "", []
@@ -104,6 +140,11 @@ class CodeActLogic:
         content = response.get("content")
         content = "" if content is None else str(content)
 
+        if not content.strip():
+            reasoning = response.get("reasoning")
+            if isinstance(reasoning, str) and reasoning.strip():
+                content = reasoning.strip()
+
         tool_calls_raw = response.get("tool_calls") or []
         tool_calls: List[ToolCall] = []
         if isinstance(tool_calls_raw, list):
@@ -118,15 +159,6 @@ class CodeActLogic:
                     if isinstance(args, dict):
                         tool_calls.append(ToolCall(name=name, arguments=dict(args), call_id=call_id))
 
-        # FALLBACK: Parse from content if no native tool calls
-        # Handles <|tool_call|>, <function_call>, ```tool_code, etc.
-        if not tool_calls and content:
-            from abstractcore.tools.parser import parse_tool_calls, detect_tool_calls
-            if detect_tool_calls(content):
-                # Pass model name for architecture-specific parsing
-                model_name = response.get("model")
-                tool_calls = parse_tool_calls(content, model_name=model_name)
-
         return content, tool_calls
 
     def extract_code(self, text: str) -> str | None:
@@ -138,29 +170,7 @@ class CodeActLogic:
         return code.strip() or None
 
     def format_observation(self, *, name: str, output: Any, success: bool) -> str:
-        if name != "execute_python":
-            out = "" if output is None else str(output)
-            return f"[{name}]: {out}" if success else f"[{name}]: Error: {out}"
-
-        if not isinstance(output, dict):
-            out = "" if output is None else str(output)
-            return f"[execute_python]: {out}" if success else f"[execute_python]: Error: {out}"
-
-        stdout = str(output.get("stdout") or "")
-        stderr = str(output.get("stderr") or "")
-        exit_code = output.get("exit_code")
-        error = output.get("error")
-
-        parts: List[str] = []
-        if error:
-            parts.append(f"error={error}")
-        if exit_code is not None:
-            parts.append(f"exit_code={exit_code}")
-        if stdout:
-            parts.append("stdout:\n" + stdout)
-        if stderr:
-            parts.append("stderr:\n" + stderr)
-
-        rendered = "\n".join(parts).strip() or "(no output)"
-        return f"[execute_python]: {rendered}"
-
+        out = "" if output is None else str(output)
+        if success:
+            return f"[{name}]: {out}"
+        return f"[{name}]: Error: {out}"

abstractagent/logic/memact.py

@@ -0,0 +1,128 @@
+"""MemAct logic (pure; no runtime imports).
+
+MemAct is a memory-enhanced agent (Letta-like) that relies on a separate, runtime-owned
+Active Memory system. This logic layer stays conventional:
+- tool calling is the only way to have an effect
+- tool results are appended to chat history by the runtime adapter
+
+The memory system is injected by the MemAct runtime adapter via the system prompt and
+updated via a structured JSON envelope at finalization.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Tuple
+
+from abstractcore.tools import ToolCall, ToolDefinition
+
+from .types import LLMRequest
+
+
+class MemActLogic:
+    def __init__(
+        self,
+        *,
+        tools: List[ToolDefinition],
+        max_history_messages: int = -1,
+        max_tokens: Optional[int] = None,
+    ):
+        self._tools = list(tools)
+        self._max_history_messages = int(max_history_messages)
+        if self._max_history_messages != -1 and self._max_history_messages < 1:
+            self._max_history_messages = 1
+        self._max_tokens = max_tokens
+
+    @property
+    def tools(self) -> List[ToolDefinition]:
+        return list(self._tools)
+
+    def build_request(
+        self,
+        *,
+        task: str,
+        messages: List[Dict[str, Any]],
+        guidance: str = "",
+        iteration: int = 1,
+        max_iterations: int = 20,
+        vars: Optional[Dict[str, Any]] = None,
+    ) -> LLMRequest:
+        """Build a base LLM request (adapter injects memory blocks separately)."""
+        _ = messages  # history is carried via chat messages by the adapter
+
+        task = str(task or "").strip()
+        guidance = str(guidance or "").strip()
+
+        limits = (vars or {}).get("_limits", {})
+        max_output_tokens = limits.get("max_output_tokens", None)
+        if max_output_tokens is not None:
+            try:
+                max_output_tokens = int(max_output_tokens)
+            except Exception:
+                max_output_tokens = None
+
+        output_budget_line = ""
+        if isinstance(max_output_tokens, int) and max_output_tokens > 0:
+            output_budget_line = f"- Output token limit for this response: {max_output_tokens}.\n"
+
+        system_prompt = (
+            f"Iteration: {int(iteration)}/{int(max_iterations)}\n\n"
+            "You are an autonomous MemAct agent.\n"
+            "Taking action / having an effect means calling a tool.\n\n"
+            "Rules:\n"
+            "- Be truthful: only claim actions supported by tool outputs.\n"
+            "- Be autonomous: do not ask the user for confirmation to proceed; keep going until the task is done.\n"
+            "- If you need to create/edit files, run commands, fetch URLs, or search, you MUST call an appropriate tool.\n"
+            "- Efficiency: batch independent read-only tool calls into a single turn (multiple tool calls) when possible.\n"
+            "- When context is getting large, use delegate_agent(task, context, tools) to offload an independent subtask with minimal context.\n"
+            "- Never fabricate tool outputs.\n"
+            "- Only ask the user a question when required information is missing.\n"
+            f"{output_budget_line}"
+        ).strip()
+
+        if guidance:
+            system_prompt = (system_prompt + "\n\nGuidance:\n" + guidance).strip()
+
+        return LLMRequest(
+            prompt=task,
+            system_prompt=system_prompt,
+            tools=self.tools,
+            max_tokens=max_output_tokens,
+        )
+
+    def parse_response(self, response: Any) -> Tuple[str, List[ToolCall]]:
+        if not isinstance(response, dict):
+            return "", []
+
+        content = response.get("content")
+        content = "" if content is None else str(content)
+        content = content.lstrip()
+        for prefix in ("assistant:", "assistant："):
+            if content.lower().startswith(prefix):
+                content = content[len(prefix) :].lstrip()
+                break
+
+        if not content.strip():
+            reasoning = response.get("reasoning")
+            if isinstance(reasoning, str) and reasoning.strip():
+                content = reasoning.strip()
+
+        tool_calls_raw = response.get("tool_calls") or []
+        tool_calls: List[ToolCall] = []
+        if isinstance(tool_calls_raw, list):
+            for tc in tool_calls_raw:
+                if isinstance(tc, ToolCall):
+                    tool_calls.append(tc)
+                    continue
+                if isinstance(tc, dict):
+                    name = str(tc.get("name", "") or "")
+                    args = tc.get("arguments", {})
+                    call_id = tc.get("call_id")
+                    if isinstance(args, dict):
+                        tool_calls.append(ToolCall(name=name, arguments=dict(args), call_id=call_id))
+
+        return content, tool_calls
+
+    def format_observation(self, *, name: str, output: str, success: bool) -> str:
+        if success:
+            return f"[{name}]: {output}"
+        return f"[{name}]: Error: {output}"

abstractagent/logic/react.py

@@ -1,4 +1,13 @@
-"""ReAct logic (pure; no runtime imports)."""
+"""ReAct logic (pure; no runtime imports).
+
+This module implements the classic ReAct loop:
+- the model decides whether to call tools
+- tool results are appended to chat history
+- the model iterates until it can answer directly
+
+ReAct is intentionally *not* a memory-enhanced agent. Long-term memory and
+structured memory blocks belong in a separate agent (MemAct).
+"""
 
 from __future__ import annotations
 
@@ -28,6 +37,24 @@ class ReActLogic:
     def tools(self) -> List[ToolDefinition]:
         return list(self._tools)
 
+    def add_tools(self, tools: List[ToolDefinition]) -> int:
+        """Add tool definitions to this logic instance (deduped by name)."""
+        if not isinstance(tools, list) or not tools:
+            return 0
+
+        existing = {str(t.name) for t in self._tools if getattr(t, "name", None)}
+        added = 0
+        for t in tools:
+            name = getattr(t, "name", None)
+            if not isinstance(name, str) or not name.strip():
+                continue
+            if name in existing:
+                continue
+            self._tools.append(t)
+            existing.add(name)
+            added += 1
+        return added
+
     def build_request(
         self,
         *,
@@ -40,52 +67,63 @@ class ReActLogic:
     ) -> LLMRequest:
         """Build an LLM request for the ReAct agent.
 
-        Args:
-            task: The task to perform
-            messages: Conversation history
-            guidance: Optional guidance text to inject
-            iteration: Current iteration number
-            max_iterations: Maximum allowed iterations
-            vars: Optional run.vars dict. If provided, limits are read from
-                  vars["_limits"] (canonical) with fallback to instance defaults.
+        Notes:
+        - The user request belongs in the user-role message (prompt), not in the system prompt.
+        - Conversation + tool history is provided via `messages` by the runtime adapter.
         """
-        task = str(task or "")
+        # History is carried out-of-band via `messages`; keep logic pure.
+        _ = messages
+
+        task = str(task or "").strip()
         guidance = str(guidance or "").strip()
 
-        # Get limits from vars if available, else use instance defaults
+        # Output token cap (provider max_tokens) comes from `_limits.max_output_tokens`.
         limits = (vars or {}).get("_limits", {})
-        max_history = int(limits.get("max_history_messages", self._max_history_messages) or self._max_history_messages)
-        max_tokens = limits.get("max_tokens", self._max_tokens)
-        if max_tokens is not None:
-            max_tokens = int(max_tokens)
-
-        if len(messages) <= 1:
-            prompt = (
-                f"Task: {task}\n\n"
-                "Use the available tools to complete this task. When done, provide your final answer."
-            )
-        else:
-            # -1 means unlimited (use all messages)
-            if max_history == -1:
-                history = messages
-            else:
-                history = messages[-max_history:]
-            history_text = "\n".join(
-                [f"{m.get('role', 'unknown')}: {m.get('content', '')}" for m in history]
-            )
-            prompt = (
-                "You have access to the conversation history below as context.\n"
-                "Do not claim you have no memory of it; it is provided to you here.\n\n"
-                f"Iteration: {int(iteration)}/{int(max_iterations)}\n\n"
-                f"History:\n{history_text}\n\n"
-                "Continue the conversation and work on the user's latest request.\n"
-                "Use tools when needed, or provide a final answer."
-            )
+        max_output_tokens = limits.get("max_output_tokens", None)
+        if max_output_tokens is not None:
+            try:
+                max_output_tokens = int(max_output_tokens)
+            except Exception:
+                max_output_tokens = None
+        if not isinstance(max_output_tokens, int) or max_output_tokens <= 0:
+            max_output_tokens = None
+
+        system_prompt = (
+            f"Iteration: {int(iteration)}/{int(max_iterations)}\n\n"
+            "## MY PERSONA\n"
+            "You are an autonomous ReAct agent (Reason → Act → Observe).\n\n"
+            "Loop contract:\n"
+            "- THINK briefly using the full transcript and prior observations.\n"
+            "- If you need to ACT, CALL one or more tools (function calls).\n"
+            "- If you are DONE, respond with the final answer and NO tool calls.\n\n"
+            "Rules:\n"
+            "- Choose tools yourself; never ask the user which tool to run.\n"
+            "- Do not write a long plan before tool calls.\n"
+            "- Keep non-final responses short; do not draft large deliverables in chat when tools can build them.\n"
+            "- Efficiency (important): the runtime supports MULTIPLE tool calls in one response.\n"
+            "  Batch independent read-only tool calls to reduce iterations.\n"
+            "  Example: read multiple files/ranges or run multiple searches in one response.\n"
+            "  If reading nearby ranges of the same file, prefer ONE call with a wider range.\n"
+            "  Only split tool calls across turns when later calls depend on earlier outputs; do NOT batch side-effectful tools (write_file/edit_file/execute_command/send_email/send_whatsapp_message/send_telegram_message/send_telegram_artifact).\n"
+            "- When context is getting large, use delegate_agent(task, context, tools) to offload an independent subtask with minimal context.\n"
+            "- Keep tool call arguments small and valid; avoid embedding huge blobs (large file contents / giant JSON) directly in arguments.\n"
+            "- Attachments:\n"
+            "  - If you see an 'Active attachments' message or inline 'Content from <file>' blocks, treat those attachments as already available in-context.\n"
+            "    Do NOT call tools just to re-open/read them.\n"
+            "  - If you see 'Stored session attachments', those may not be included in the current call.\n"
+            "    Only if you truly need it, use the attachment-open tool with artifact_id and a bounded line range.\n"
+            "  - Never use filesystem tools on attachment filenames/paths or absolute paths outside the workspace.\n"
+            "- For fetch_url: use include_full_content=False for shorter previews; set keep_links=False to strip links when not needed.\n"
+            "- For large files, create a small skeleton first, then refine via multiple smaller edits/tool calls.\n"
+            "- Use tool outputs as evidence; do not claim actions without tool outputs.\n"
+            "- Continue iterating until the task is complete.\n"
+        ).strip()
 
         if guidance:
-            prompt += "\n\n[User guidance]: " + guidance
+            system_prompt = f"{system_prompt}\n\nGuidance:\n{guidance}".strip()
 
-        return LLMRequest(prompt=prompt, tools=self.tools, max_tokens=max_tokens)
+        # Note: prompt is unused by the runtime adapter (we supply chat `messages`).
+        return LLMRequest(prompt=task, system_prompt=system_prompt, tools=self.tools, max_tokens=max_output_tokens)
 
     def parse_response(self, response: Any) -> Tuple[str, List[ToolCall]]:
         if not isinstance(response, dict):
@@ -93,6 +131,19 @@ class ReActLogic:
 
         content = response.get("content")
         content = "" if content is None else str(content)
+        # Some OSS models echo role labels; strip common prefixes to keep UI/history clean.
+        content = content.lstrip()
+        for prefix in ("assistant:", "assistant："):
+            if content.lower().startswith(prefix):
+                content = content[len(prefix) :].lstrip()
+                break
+
+        # Some providers return a separate `reasoning` field. If content is empty, fall back
+        # to reasoning so iterative loops don't lose context.
+        if not content.strip():
+            reasoning = response.get("reasoning")
+            if isinstance(reasoning, str) and reasoning.strip():
+                content = reasoning.strip()
 
         tool_calls_raw = response.get("tool_calls") or []
         tool_calls: List[ToolCall] = []
@@ -108,19 +159,9 @@ class ReActLogic:
                     if isinstance(args, dict):
                         tool_calls.append(ToolCall(name=name, arguments=dict(args), call_id=call_id))
 
-        # FALLBACK: Parse from content if no native tool calls
-        # Handles <|tool_call|>, <function_call>, ```tool_code, etc.
-        if not tool_calls and content:
-            from abstractcore.tools.parser import parse_tool_calls, detect_tool_calls
-            if detect_tool_calls(content):
-                # Pass model name for architecture-specific parsing
-                model_name = response.get("model")
-                tool_calls = parse_tool_calls(content, model_name=model_name)
-
         return content, tool_calls
 
     def format_observation(self, *, name: str, output: str, success: bool) -> str:
         if success:
             return f"[{name}]: {output}"
         return f"[{name}]: Error: {output}"
-