agentify-core 0.1.2__tar.gz → 0.1.4__tar.gz

{agentify_core-0.1.2/agentify_core.egg-info → agentify_core-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentify-core
-Version: 0.1.2
+Version: 0.1.4
 Summary: Framework-agnostic AI agent library for building single and multi-agent systems
 Author-email: Fabian M <fabian@example.com>
 License: MIT
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: openai>=1.0.0
@@ -47,9 +47,10 @@ Dynamic: license-file
 
 # Agentify
 
-**Framework-agnostic AI agent library for building single and multi-agent systems**
+**Independent AI agent library based on the OpenAI SDK**
+
+Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable `base_url` (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.
 
-Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It focuses on a small set of composable primitives for LLM integration, memory, tools and coordination, so you can focus on product logic instead of framework details.
 
 ## Why Agentify?
 
@@ -116,7 +117,7 @@ agent = BaseAgent(
 )
 
 # 3. Run a conversation
-response = agent.respond(user_input="Hello! How can you help me?")
+response = agent.run(user_input="Hello! How can you help me?")
 ```
 
 ## Composable Flows
@@ -133,22 +134,18 @@ Because all flows share the same `run()` interface, you can build Teams made of
 Agentify supports both **strict workflows** (fixed, pre-defined Pipelines and Hierarchies) and **dynamic agentic flows**, where a supervisor/router agent decides at runtime which agent, Team or Pipeline to call next.
 
 
-### More Examples
-
-Check out the [examples](examples/) directory for detailed implementations:
+## Learn More
 
-*   [Single Agent Chatbot](examples/chatbot/)
-*   [Multi-Agent Teams](examples/multi_agent/team/)
-*   [Sequential Pipelines](examples/multi_agent/pipeline/)
-*   [Hierarchical Structures](examples/multi_agent/hierarchical/)
+For detailed documentation, examples, and API reference, visit the [GitHub repository](https://github.com/fa8i/Agentify).
 
+## Contributing
 
-## Author
+Contributions are welcome! Please visit the [repository](https://github.com/fa8i/Agentify) to report issues or submit pull requests.
 
-- **Fabian Melchor** [fabianmp_98@hotmail.com](mailto:fabianmp_98@hotmail.com)
+## License
 
+MIT License - see the repository for details.
 
-## Links
+## Author
 
-- **Repository**: https://github.com/fa8i/Agentify
-- **Issues**: https://github.com/fa8i/Agentify/issues
+**Fabian Melchor** - [fabianmp_98@hotmail.com](mailto:fabianmp_98@hotmail.com)

{agentify_core-0.1.2 → agentify_core-0.1.4}/README.md

@@ -1,8 +1,9 @@
 # Agentify
 
-**Framework-agnostic AI agent library for building single and multi-agent systems**
+**Independent AI agent library based on the OpenAI SDK**
+
+Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable `base_url` (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.
 
-Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It focuses on a small set of composable primitives for LLM integration, memory, tools and coordination, so you can focus on product logic instead of framework details.
 
 ## Why Agentify?
 
@@ -69,7 +70,7 @@ agent = BaseAgent(
 )
 
 # 3. Run a conversation
-response = agent.respond(user_input="Hello! How can you help me?")
+response = agent.run(user_input="Hello! How can you help me?")
 ```
 
 ## Composable Flows
@@ -86,6 +87,15 @@ Because all flows share the same `run()` interface, you can build Teams made of
 Agentify supports both **strict workflows** (fixed, pre-defined Pipelines and Hierarchies) and **dynamic agentic flows**, where a supervisor/router agent decides at runtime which agent, Team or Pipeline to call next.
 
 
+## Documentation
+
+- [Getting Started](docs/getting_started.md) - Installation and first steps
+- [Core Concepts](docs/core_concepts.md) - Agents, memory, and tools
+- [Multi-Agent Systems](docs/multi_agent.md) - Teams, pipelines, and hierarchies
+- [Advanced Features](docs/advanced.md) - Vision, streaming, hooks, and more
+- [API Reference](docs/api_reference.md) - Complete API documentation
+
+
 ### More Examples
 
 Check out the [examples](examples/) directory for detailed implementations:

agentify_core-0.1.4/README_PYPI.md

@@ -0,0 +1,104 @@
+# Agentify
+
+**Independent AI agent library based on the OpenAI SDK**
+
+Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable `base_url` (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.
+
+
+## Why Agentify?
+
+- **Built for production**: clear abstractions, explicit configuration, error handling and extension points that map well to real deployments.
+- **Orchestration-first design**: a uniform `run()` interface for agents, teams, pipelines and hierarchies makes it straightforward to compose and refactor flows.
+- **Providers**: switch between OpenAI, Gemini, Azure OpenAI, DeepSeek, Claude and others without changing your agent code.
+
+
+## Key Features
+
+- **Agents and multi-agent patterns**  
+  Single Agents with tools and memory, supervisor–worker Multi-Agent Teams, Sequential Pipelines where output flows from step to step, Hierarchical Structures for complex delegation, and Dynamic Flows where a controller decides at runtime which sub-agents or teams to invoke.
+
+- **Memory service and isolation**  
+  Pluggable backends (in-memory, Redis, …) with per-use-case policies (TTL, maximum messages, etc.), plus optional memory isolation so each agent can maintain its own conversation history for scalability and privacy.
+
+- **Reasoning Models**  
+  Configure the model's thinking depth, safely merge `model_kwargs`, automatically store
+  "Chain of Thought" in conversation history, and log reasoning steps in real-time for visibility.
+
+- **Tools and actions**  
+  Type-annotated tool interface, straightforward registration of custom tools.
+
+- **Observability hooks**  
+  Callback system for logging, monitoring and debugging agent behaviour across complex flows.
+
+- **I/O capabilities**  
+  Streaming support for real-time responses and vision/image models for multimodal interactions.
+
+
+## Installation
+
+```bash
+pip install agentify-core
+```
+
+For optional features:
+```bash
+pip install agentify-core[all]  # Installs all optional dependencies
+```
+
+## Quick Start
+
+```python
+from agentify import BaseAgent, AgentConfig, MemoryService, MemoryAddress
+from agentify.memory.stores import InMemoryStore
+
+# 1. Create memory service
+memory = MemoryService(store=InMemoryStore(), log_enabled=True, max_log_length=100)
+addr = MemoryAddress(conversation_id="session_1")
+
+# 2. Create an Agent
+agent = BaseAgent(
+    config=AgentConfig(
+        name="ReasoningAgent",
+        system_prompt="You are a helpful assistant.",
+        provider="openai",
+        model_name="gpt-5",
+        reasoning_effort="high",  # optional param:"low", "medium", "high"
+        model_kwargs={"max_completion_tokens": 5000} # Pass model-specific params
+    ),
+    memory=memory,
+    memory_address=addr
+)
+
+# 3. Run a conversation
+response = agent.run(user_input="Hello! How can you help me?")
+```
+
+## Composable Flows
+
+Agentify provides powerful primitives that can be combined to build arbitrarily complex systems:
+
+* **BaseAgent**: The fundamental unit of work.
+* **Teams**: A group of agents managed by a supervisor.
+* **Pipelines**: A sequence of steps where output passes from one to the next.
+* **Hierarchies**: Tree structures for massive delegation.
+
+Because all flows share the same `run()` interface, you can build Teams made of Pipelines, Pipelines made of Teams, and deeply nested Hierarchies.
+
+Agentify supports both **strict workflows** (fixed, pre-defined Pipelines and Hierarchies) and **dynamic agentic flows**, where a supervisor/router agent decides at runtime which agent, Team or Pipeline to call next.
+
+
+## Learn More
+
+For detailed documentation, examples, and API reference, visit the [GitHub repository](https://github.com/fa8i/Agentify).
+
+## Contributing
+
+Contributions are welcome! Please visit the [repository](https://github.com/fa8i/Agentify) to report issues or submit pull requests.
+
+## License
+
+MIT License - see the repository for details.
+
+## Author
+
+**Fabian Melchor** - [fabianmp_98@hotmail.com](mailto:fabianmp_98@hotmail.com)

{agentify_core-0.1.2 → agentify_core-0.1.4}/agentify/__init__.py

@@ -16,7 +16,7 @@ from agentify.memory.service import MemoryService
 from agentify.memory.interfaces import MemoryAddress
 from agentify.memory.policies import MemoryPolicy
 
-__version__ = "0.1.0"
+__version__ = "0.1.3"
 
 __all__ = [
     "BaseAgent",

{agentify_core-0.1.2 → agentify_core-0.1.4}/agentify/core/agent.py

@@ -5,7 +5,8 @@ import time
 import uuid
 import base64
 from io import BytesIO
-from typing import Any, Dict, Generator, List, Optional, Union, Iterator
+import inspect
+from typing import Any, Dict, Generator, List, Optional, Union, Iterator, Callable
 
 from PIL import Image
 from openai import RateLimitError
@@ -21,7 +22,23 @@ logger = logging.getLogger(__name__)
 
 
 class BaseAgent:
-    """Framework-agnostic AI Agent core class."""
+    """AI Agent core class based on chat completions interface.
+    
+    This class provides a unified interface for interacting with various LLM providers
+    that are compatible with the OpenAI SDK format.
+    
+    Attributes:
+        pre_hooks (List[Callable]): Functions to execute before the agent loop starts.
+            Supported arguments for injection:
+            - `agent`: The BaseAgent instance.
+            - `user_input`: The user's input string.
+            
+        post_hooks (List[Callable]): Functions to execute after the agent loop finishes.
+            Supported arguments for injection:
+            - `agent`: The BaseAgent instance.
+            - `user_input`: The user's input string.
+            - `response`: The final accumulated response string.
+    """
 
     def __init__(
         self,
@@ -32,11 +49,15 @@ class BaseAgent:
         client_factory: Optional[LLMClientFactory] = None,
         tools: Optional[List[Tool]] = None,
         image_config: Optional[ImageConfig] = None,
+        pre_hooks: Optional[List[Callable]] = None,
+        post_hooks: Optional[List[Callable]] = None,
     ) -> None:
         self.config = config
         self.memory = memory
         self.memory_address = memory_address
         self.image_config = image_config or ImageConfig()
+        self.pre_hooks = pre_hooks or []
+        self.post_hooks = post_hooks or []
 
         # Decouple callbacks from config to avoid mutation of shared config
         self.callbacks = list(self.config.callbacks) if self.config.callbacks else []
@@ -196,6 +217,28 @@ class BaseAgent:
         for m in messages[1:]:
             self.memory.append_history(a, m)
 
+    # Hook Execution
+    def _execute_hook(self, hook: Callable, **kwargs: Any) -> None:
+        """Execute a hook injecting only the arguments it declares."""
+        try:
+            sig = inspect.signature(hook)
+            # Filter kwargs to only those present in the hook's signature
+            # If the hook accepts **kwargs, pass everything
+            has_var_keyword = any(
+                p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
+            )
+            
+            if has_var_keyword:
+                hook_kwargs = kwargs
+            else:
+                hook_kwargs = {
+                    k: v for k, v in kwargs.items() if k in sig.parameters
+                }
+            
+            hook(**hook_kwargs)
+        except Exception as e:
+            logger.error(f"Error executing hook '{hook.__name__}': {e}", exc_info=True)
+
     # Core Logic
 
     def _get_llm_response(
@@ -518,6 +561,9 @@ class BaseAgent:
         for cb in self.callbacks:
             cb.on_agent_start(self.config.name, user_input)
 
+        for hook in self.pre_hooks:
+            self._execute_hook(hook, agent=self, user_input=user_input)
+
         user_content = self._build_user_content(
             user_input,
             image_path=image_path,
@@ -526,7 +572,14 @@ class BaseAgent:
         if user_content is not None:
             self.add(role="user", content=user_content, addr=addr)
 
-        for _ in range(self.config.max_tool_iter):
+        accumulated_response: List[str] = []
+
+        iteration_count = 0
+        while True:
+            if self.config.max_tool_iter is not None and iteration_count >= self.config.max_tool_iter:
+                break
+            iteration_count += 1
+
             response_or_stream = self._get_llm_response(addr=addr)
 
             current_turn_content_parts: List[str] = []
@@ -540,6 +593,7 @@ class BaseAgent:
                         content_chunk = next(gen)
                         yield content_chunk
                         current_turn_content_parts.append(content_chunk)
+                        accumulated_response.append(content_chunk)
                 except StopIteration as e:
                     assembled_tool_calls, full_reasoning_content = e.value
             else:
@@ -549,6 +603,7 @@ class BaseAgent:
                 if content:
                     yield content
                     current_turn_content_parts.append(content)
+                    accumulated_response.append(content)
 
             # Expand tool calls (fix for some models)
             assembled_tool_calls = self._expand_tool_calls(assembled_tool_calls)
@@ -602,10 +657,17 @@ class BaseAgent:
             for cb in self.callbacks:
                 cb.on_agent_finish(self.config.name, warn_msg)
             yield warn_msg
+            accumulated_response.append(warn_msg)
+
+        full_response = "".join(accumulated_response)
+        for hook in self.post_hooks:
+            self._execute_hook(
+                hook, agent=self, user_input=user_input, response=full_response
+            )
 
     # Public entrypoint
 
-    def respond(
+    def run(
         self,
         user_input: str,
         *,
@@ -613,7 +675,17 @@ class BaseAgent:
         image_path: Optional[str] = None,
         image_detail_override: Optional[str] = None,
     ) -> Union[str, Generator[str, None, None]]:
-        """Main entrypoint to interact with the agent."""
+        """Main entrypoint to interact with the agent.
+        
+        Args:
+            user_input: The text input from the user.
+            addr: The memory address for the conversation.
+            image_path: Optional path to an image file.
+            image_detail_override: Optional detail level for image processing.
+            
+        Returns:
+            The agent's response as a string or a generator if streaming is enabled.
+        """
         a = self._addr_or_raise(addr)
         response_generator = self._execute_agent_loop(
             user_input,
@@ -628,6 +700,7 @@ class BaseAgent:
         parts: List[str] = list(response_generator)
         return "".join(parts).strip()
 
+
     # Tool registry management
 
     def tool_exists(self, name: str) -> bool:

{agentify_core-0.1.2 → agentify_core-0.1.4}/agentify/core/config.py

@@ -21,7 +21,7 @@ class AgentConfig:
     timeout: int = 60
     stream: bool = False
     max_retries: int = 3
-    max_tool_iter: int = 5
+    max_tool_iter: Optional[int] = 10
     reasoning_effort: Optional[str] = None
     model_kwargs: Optional[Dict[str, Any]] = None
     client_config_override: Optional[Dict[str, Any]] = None

agentify_core-0.1.4/agentify/extensions/tools/__init__.py

@@ -0,0 +1,15 @@
+from agentify.extensions.tools.time import TimeTool
+from agentify.extensions.tools.calculator import CalculatorTool
+from agentify.extensions.tools.weather import WeatherTool
+from agentify.extensions.tools.planning import TodoTool
+from agentify.extensions.tools.filesystem import ListDirTool, ReadFileTool, WriteFileTool
+
+__all__ = [
+    "TimeTool",
+    "CalculatorTool",
+    "WeatherTool",
+    "TodoTool",
+    "ListDirTool",
+    "ReadFileTool",
+    "WriteFileTool",
+]

agentify_core-0.1.4/agentify/extensions/tools/calculator.py

@@ -0,0 +1,55 @@
+from agentify.core.tool import Tool
+import ast
+import operator as op
+
+
+class CalculatorTool(Tool):
+    """Tool for evaluating safe mathematical expressions."""
+
+    def __init__(self):
+        self._allowed_ops = {
+            ast.Add: op.add,
+            ast.Sub: op.sub,
+            ast.Mult: op.mul,
+            ast.Div: op.truediv,
+            ast.Pow: op.pow,
+            ast.Mod: op.mod,
+            ast.UAdd: op.pos,
+            ast.USub: op.neg,
+        }
+
+        schema = {
+            "name": "calculate_expression",
+            "description": "Evalúa una expresión matemática segura y devuelve el resultado.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "expression": {
+                        "type": "string",
+                        "description": "Expresión matemática a calcular, por ejemplo '2 + 2 * (3 - 1)'.",
+                    }
+                },
+                "required": ["expression"],
+            },
+        }
+        super().__init__(schema, self._calculate_expression)
+
+    def _eval_node(self, node):
+        if isinstance(node, ast.Num):
+            return node.n
+        if isinstance(node, ast.BinOp):
+            left = self._eval_node(node.left)
+            right = self._eval_node(node.right)
+            return self._allowed_ops[type(node.op)](left, right)
+        if isinstance(node, ast.UnaryOp):
+            operand = self._eval_node(node.operand)
+            return self._allowed_ops[type(node.op)](operand)
+        raise ValueError(f"Operador no permitido: {node}")
+
+    def _calculate_expression(self, expression: str):
+        try:
+            tree = ast.parse(expression, mode="eval").body
+            result = self._eval_node(tree)
+            return {"result": result}
+        except Exception as e:
+            return {"error": f"Expresión inválida: {e}"}

agentify_core-0.1.4/agentify/extensions/tools/filesystem.py

@@ -0,0 +1,126 @@
+import os
+from typing import Any, Dict, List, Optional
+from agentify.core.tool import Tool
+
+class BaseFilesystemTool(Tool):
+    """Base class for filesystem tools with sandbox security."""
+    
+    def __init__(self, schema: Dict[str, Any], func: Any, sandbox_dir: Optional[str] = None):
+        super().__init__(schema, func)
+        # If no sandbox provided, default to current working directory or a safe temp dir could be better 
+        # but for this agent library, let's default to CWD but allow override.
+        self.sandbox_dir = os.path.abspath(sandbox_dir or os.getcwd())
+
+    def _validate_path(self, file_path: str) -> str:
+        """Ensure path is within sandbox."""
+        # Handle absolute paths by checking if they start with sandbox
+        abs_path = os.path.abspath(os.path.join(self.sandbox_dir, file_path))
+        
+        if not abs_path.startswith(self.sandbox_dir):
+            raise ValueError(f"Access denied: Path '{file_path}' is outside sandbox directory '{self.sandbox_dir}'")
+        
+        return abs_path
+
+
+class ListDirTool(BaseFilesystemTool):
+    def __init__(self, sandbox_dir: Optional[str] = None):
+        schema = {
+            "name": "list_files",
+            "description": "List files and directories in a given path.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "directory_path": {
+                        "type": "string",
+                        "description": "Relative path to list contents of. Defaults to root of sandbox.",
+                    }
+                },
+            },
+        }
+        super().__init__(schema, self._list_dir, sandbox_dir)
+
+    def _list_dir(self, directory_path: str = ".") -> str:
+        try:
+            target_path = self._validate_path(directory_path)
+            if not os.path.exists(target_path):
+                return f"Error: Directory '{directory_path}' does not exist."
+            
+            items = os.listdir(target_path)
+            # Add indicators for directories
+            formatted_items = []
+            for item in items:
+                if os.path.isdir(os.path.join(target_path, item)):
+                    formatted_items.append(f"{item}/")
+                else:
+                    formatted_items.append(item)
+            
+            return "\n".join(formatted_items) if formatted_items else "(empty directory)"
+        except Exception as e:
+            return f"Error listing directory: {str(e)}"
+
+
+class ReadFileTool(BaseFilesystemTool):
+    def __init__(self, sandbox_dir: Optional[str] = None):
+        schema = {
+            "name": "read_file",
+            "description": "Read the contents of a file.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Path to the file to read.",
+                    }
+                },
+                "required": ["file_path"],
+            },
+        }
+        super().__init__(schema, self._read_file, sandbox_dir)
+
+    def _read_file(self, file_path: str) -> str:
+        try:
+            target_path = self._validate_path(file_path)
+            if not os.path.exists(target_path):
+                return f"Error: File '{file_path}' does not exist."
+            
+            with open(target_path, "r", encoding="utf-8") as f:
+                return f.read()
+        except Exception as e:
+            return f"Error reading file: {str(e)}"
+
+
+class WriteFileTool(BaseFilesystemTool):
+    def __init__(self, sandbox_dir: Optional[str] = None):
+        schema = {
+            "name": "write_file",
+            "description": "Write content to a file. Overwrites if exists.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Path to the file to write.",
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "Content to write to the file.",
+                    }
+                },
+                "required": ["file_path", "content"],
+            },
+        }
+        super().__init__(schema, self._write_file, sandbox_dir)
+
+    def _write_file(self, file_path: str, content: str) -> str:
+        try:
+            target_path = self._validate_path(file_path)
+            
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(target_path), exist_ok=True)
+            
+            with open(target_path, "w", encoding="utf-8") as f:
+                f.write(content)
+            
+            return f"Successfully wrote to '{file_path}'."
+        except Exception as e:
+            return f"Error writing file: {str(e)}"

agentify_core-0.1.4/agentify/extensions/tools/planning.py

@@ -0,0 +1,76 @@
+from typing import Any, Dict, List, Optional
+from agentify.core.tool import Tool
+
+class TodoTool(Tool):
+    """A tool for agents to manage their own todo list / plan."""
+    
+    def __init__(self):
+        self._todos: List[Dict[str, Any]] = []
+        schema = {
+            "name": "manage_plan",
+            "description": "Manage a todo list to plan and track progress.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "action": {
+                        "type": "string",
+                        "enum": ["add", "complete", "list", "remove"],
+                        "description": "Action to perform on the plan.",
+                    },
+                    "task": {
+                        "type": "string",
+                        "description": "Description of the task (required for 'add')",
+                    },
+                    "task_id": {
+                        "type": "integer",
+                        "description": "ID of the task (required for 'complete' or 'remove')",
+                    },
+                },
+                "required": ["action"],
+            },
+        }
+        super().__init__(schema, self._manage_todos)
+
+    def _manage_todos(
+        self, 
+        action: str, 
+        task: Optional[str] = None, 
+        task_id: Optional[int] = None
+    ) -> str:
+        if action == "add":
+            if not task:
+                return "Error: 'task' description required for 'add' action."
+            new_id = len(self._todos)
+            self._todos.append({"id": new_id, "task": task, "status": "pending"})
+            return f"Task added: [{new_id}] {task}"
+        
+        elif action == "complete":
+            if task_id is None:
+                return "Error: 'task_id' required for 'complete' action."
+            if 0 <= task_id < len(self._todos):
+                self._todos[task_id]["status"] = "completed"
+                return f"Task [{task_id}] marked as completed."
+            return f"Error: Invalid task_id {task_id}"
+            
+        elif action == "remove":
+            if task_id is None:
+                return "Error: 'task_id' required for 'remove' action."
+            if 0 <= task_id < len(self._todos):
+                # Rebuild list without the specified task_id
+                self._todos = [t for i, t in enumerate(self._todos) if i != task_id]
+                # Re-assign IDs to keep them sequential
+                for i, t in enumerate(self._todos):
+                    t["id"] = i
+                return f"Task removed. Remaining tasks re-indexed."
+            return f"Error: Invalid task_id {task_id}"
+
+        elif action == "list":
+            if not self._todos:
+                return "Plan is empty."
+            lines = []
+            for t in self._todos:
+                status = "[x]" if t["status"] == "completed" else "[ ]"
+                lines.append(f"{status} {t['id']}: {t['task']}")
+            return "\n".join(lines)
+        
+        return f"Error: Unknown action '{action}'"