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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentify-core
-Version: 0.1.2
+Version: 0.1.3
 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,6 +134,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.2 → agentify_core-0.1.3}/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.2 → agentify_core-0.1.3}/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.3}/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.3}/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.3/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.3/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.3/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.3/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}'"

agentify_core-0.1.3/agentify/extensions/tools/time.py

@@ -0,0 +1,22 @@
+from agentify.core.tool import Tool
+import datetime
+
+
+class TimeTool(Tool):
+    """Tool for getting current date and time."""
+
+    def __init__(self):
+        schema = {
+            "name": "get_current_time",
+            "description": "Devuelve la hora y fecha actual en formato ISO 8601.",
+            "parameters": {
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
+        }
+        super().__init__(schema, self._get_current_time)
+
+    def _get_current_time(self):
+        now = datetime.datetime.now().astimezone().isoformat()
+        return {"current_time": now}

agentify_core-0.1.3/agentify/extensions/tools/weather.py

@@ -0,0 +1,52 @@
+from agentify.core.tool import Tool
+import os
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class WeatherTool(Tool):
+    """Tool for getting current weather information."""
+
+    def __init__(self):
+        schema = {
+            "name": "get_weather",
+            "description": "Obtiene el estado del tiempo o clima actual para una ciudad o zona especificada.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": "Nombre de la ciudad o zona para consultar el clima.",
+                    }
+                },
+                "required": ["location"],
+            },
+        }
+        super().__init__(schema, self._get_weather)
+
+    def _get_weather(self, location: str):
+        api_key = os.getenv("OPENWEATHER_API_KEY")
+        if not api_key:
+            return {"error": "Variable de entorno OPENWEATHER_API_KEY no configurada."}
+        try:
+            response = requests.get(
+                "https://api.openweathermap.org/data/2.5/weather",
+                params={"q": location, "appid": api_key, "units": "metric"},
+            )
+            data = response.json()
+            if response.status_code != 200:
+                return {
+                    "error": data.get("message", "Error desconocido al obtener el clima.")
+                }
+            weather = {
+                "location": data["name"],
+                "description": data["weather"][0]["description"],
+                "temperature": data["main"]["temp"],
+                "humidity": data["main"]["humidity"],
+                "wind_speed": data["wind"]["speed"],
+            }
+            return {"weather": weather}
+        except Exception as e:
+            return {"error": f"Error al conectar con el servicio de clima: {e}"}

{agentify_core-0.1.2 → agentify_core-0.1.3}/agentify/memory/interfaces.py

@@ -99,3 +99,13 @@ class ConversationStore(Protocol):
 class TokenCounter(Protocol):
     """Callable that returns token count for OpenAI-formatted messages."""
     def __call__(self, openai_messages: List[Dict[str, Any]]) -> int: ...
+
+
+class KeyValueStore(Protocol):
+    """
+    Interface for long-term semantic memory or global state.
+    """
+    def get(self, key: str) -> Optional[Any]: ...
+    def set(self, key: str, value: Any) -> None: ...
+    def delete(self, key: str) -> None: ...
+    def search(self, query: str, limit: int = 5) -> List[Any]: ...

agentify_core-0.1.3/agentify/memory/stores/__init__.py

@@ -0,0 +1,5 @@
+"""Memory storage backends."""
+from .in_memory_store import InMemoryStore
+from .redis_store import RedisStore
+
+__all__ = ["InMemoryStore", "RedisStore"]

{agentify_core-0.1.2 → agentify_core-0.1.3}/agentify/multi_agent/hierarchical.py

@@ -44,7 +44,7 @@ class HierarchicalTeam:
         self._register_hierarchy_tools(session_id, user_id)
 
         # 3. Run Root
-        return self.root.respond(user_input=user_input, addr=root_addr)
+        return self.root.run(user_input=user_input, addr=root_addr)
 
     def _register_hierarchy_tools(self, session_id: str, user_id: str) -> None:
         """Registers children as tools for their parents based on the current session."""

{agentify_core-0.1.2 → agentify_core-0.1.3}/agentify/multi_agent/pipeline.py

@@ -1,4 +1,5 @@
 from typing import List, Union, Generator, Any
+
 from agentify.core.agent import BaseAgent
 from agentify.memory.interfaces import MemoryAddress
 from agentify.multi_agent.team import Team
@@ -43,7 +44,7 @@ class SequentialPipeline:
                 step_addr = MemoryAddress(
                     user_id=user_id, conversation_id=session_id, agent_id=step_name
                 )
-                response = step.respond(user_input=current_input, addr=step_addr)
+                response = step.run(user_input=current_input, addr=step_addr)
 
             elif hasattr(step, "run"):
                 # Team, SequentialPipeline, HierarchicalTeam

{agentify_core-0.1.2 → agentify_core-0.1.3}/agentify/multi_agent/team.py

@@ -59,4 +59,4 @@ class Team:
             self.supervisor.register_tool(tool_wrapper)
 
         # 3. Run Supervisor
-        return self.supervisor.respond(user_input=user_input, addr=supervisor_addr)
+        return self.supervisor.run(user_input=user_input, addr=supervisor_addr)

{agentify_core-0.1.2 → agentify_core-0.1.3}/agentify/multi_agent/tool_wrapper.py

@@ -57,7 +57,7 @@ class AgentTool(Tool):
         )
 
         # Run the agent
-        response = self.agent.respond(user_input=instructions, addr=child_addr)
+        response = self.agent.run(user_input=instructions, addr=child_addr)
 
         # Consume generator if needed
         if hasattr(response, "__iter__") and not isinstance(response, str):
@@ -122,3 +122,88 @@ class FlowTool(Tool):
             response = "".join(list(response))
 
         return {"response": response}
+
+
+class SpawnAgentTool(Tool):
+    """Tool to dynamically spawn a transient sub-agent for a specific task."""
+
+    def __init__(
+        self,
+        base_config: Any,  # AgentConfig type ideally, but Any to avoid circular imports context
+        memory_service: Any, # MemoryService
+        parent_addr: MemoryAddress,
+        client_factory: Optional[Any] = None,
+    ):
+        self.base_config = base_config
+        self.memory_service = memory_service
+        self.parent_addr = parent_addr
+        self.client_factory = client_factory
+
+        schema = {
+            "name": "spawn_subagent",
+            "description": "Spawn a temporary specialized sub-agent to handle a complex sub-task.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "role_name": {
+                        "type": "string",
+                        "description": "Name of the sub-agent (e.g., 'ResearchAssistant').",
+                    },
+                    "instructions": {
+                        "type": "string",
+                        "description": "Specific task instructions for the sub-agent.",
+                    },
+                    "system_prompt": {
+                        "type": "string",
+                        "description": "System prompt defining the sub-agent's persona and constraints.",
+                    }
+                },
+                "required": ["role_name", "instructions"],
+            },
+        }
+        super().__init__(schema, self._spawn_and_run)
+
+    def _spawn_and_run(
+        self, 
+        role_name: str, 
+        instructions: str, 
+        system_prompt: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Creates and runs a new agent instance."""
+        from agentify.core.agent import BaseAgent
+        from agentify.core.config import AgentConfig
+        import copy
+
+        # Clone config but override name and system prompt
+        # Assuming base_config is an AgentConfig object or similar dataclass
+        new_config = copy.deepcopy(self.base_config)
+        new_config.name = f"{self.base_config.name}.{role_name}"
+        if system_prompt:
+            new_config.system_prompt = system_prompt
+        
+        # Create a unique address for this interaction
+        child_addr = MemoryAddress(
+            user_id=self.parent_addr.user_id,
+            conversation_id=f"{self.parent_addr.conversation_id}_{role_name}_{instructions[:10]}", # Unique-ish
+            agent_id=new_config.name,
+        )
+
+        # Create the agent
+        sub_agent = BaseAgent(
+            config=new_config,
+            memory=self.memory_service,
+            memory_address=child_addr,
+            client_factory=self.client_factory
+        )
+
+        response = sub_agent.run(user_input=instructions)
+        
+        # Consume generator if needed
+        if hasattr(response, "__iter__") and not isinstance(response, str):
+            response = "".join(list(response))
+
+        return {
+            "subagent": role_name,
+            "status": "finished",
+            "response": response
+        }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentify-core
-Version: 0.1.2
+Version: 0.1.3
 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,6 +134,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.2 → agentify_core-0.1.3}/agentify_core.egg-info/SOURCES.txt

@@ -14,6 +14,8 @@ agentify/extensions/prompts/__init__.py
 agentify/extensions/prompts/assistant.py
 agentify/extensions/tools/__init__.py
 agentify/extensions/tools/calculator.py
+agentify/extensions/tools/filesystem.py
+agentify/extensions/tools/planning.py
 agentify/extensions/tools/time.py
 agentify/extensions/tools/weather.py
 agentify/llm/__init__.py
@@ -36,4 +38,6 @@ agentify_core.egg-info/PKG-INFO
 agentify_core.egg-info/SOURCES.txt
 agentify_core.egg-info/dependency_links.txt
 agentify_core.egg-info/requires.txt
-agentify_core.egg-info/top_level.txt
+agentify_core.egg-info/top_level.txt
+tests/test_filesystem_tools.py
+tests/test_planning_tool.py

{agentify_core-0.1.2 → agentify_core-0.1.3}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentify-core"
-version = "0.1.2"
+version = "0.1.3"
 description = "Framework-agnostic AI agent library for building single and multi-agent systems"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = {text = "MIT"}
 authors = [
     {name = "Fabian M", email = "fabian@example.com"}
@@ -83,10 +83,10 @@ agentify = ["py.typed"]
 
 [tool.black]
 line-length = 100
-target-version = ['py39', 'py310', 'py311']
+target-version = ['py310', 'py311']
 
 [tool.mypy]
-python_version = "3.9"
+python_version = "3.10"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = false

agentify_core-0.1.3/tests/test_filesystem_tools.py

@@ -0,0 +1,62 @@
+import os
+import tempfile
+import pytest
+from agentify.tools.filesystem import ListDirTool, ReadFileTool, WriteFileTool
+
+
+class TestFilesystemTools:
+    """Test suite for filesystem tools."""
+
+    def test_list_dir_tool(self):
+        """Test ListDirTool enumerates directory contents."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create test files
+            open(os.path.join(tmpdir, "file1.txt"), "w").close()
+            open(os.path.join(tmpdir, "file2.txt"), "w").close()
+            os.makedirs(os.path.join(tmpdir, "subdir"))
+
+            tool = ListDirTool(sandbox_dir=tmpdir)
+            result = tool._list_dir(".")
+            
+            assert "file1.txt" in result
+            assert "file2.txt" in result
+            assert "subdir/" in result
+
+    def test_read_file_tool(self):
+        """Test ReadFileTool reads file contents."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = os.path.join(tmpdir, "test.txt")
+            test_content = "Hello, Deep Agent!"
+            
+            with open(test_file, "w") as f:
+                f.write(test_content)
+            
+            tool = ReadFileTool(sandbox_dir=tmpdir)
+            result = tool._read_file("test.txt")
+            
+            assert result == test_content
+
+    def test_write_file_tool(self):
+        """Test WriteFileTool creates and writes files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tool = WriteFileTool(sandbox_dir=tmpdir)
+            result = tool._write_file("output.txt", "Test content")
+            
+            assert "Successfully wrote" in result
+            
+            # Verify file exists and has correct content
+            with open(os.path.join(tmpdir, "output.txt"), "r") as f:
+                assert f.read() == "Test content"
+
+    def test_sandbox_security(self):
+        """Test that sandbox prevents access outside its boundaries."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tool = ReadFileTool(sandbox_dir=tmpdir)
+            
+            # Try to read outside sandbox
+            result = tool._read_file("../../etc/passwd")
+            assert "Access denied" in result or "Error" in result
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

agentify_core-0.1.3/tests/test_planning_tool.py

@@ -0,0 +1,55 @@
+import pytest
+from agentify.tools.planning import TodoTool
+
+
+class TestPlanningTool:
+    """Test suite for planning tool."""
+
+    def test_add_task(self):
+        """Test adding tasks to the plan."""
+        tool = TodoTool()
+        result = tool._manage_todos(action="add", task="Complete the demo")
+        
+        assert "Task added" in result
+        assert "[0]" in result
+        assert "Complete the demo" in result
+
+    def test_list_tasks(self):
+        """Test listing all tasks."""
+        tool = TodoTool()
+        tool._manage_todos(action="add", task="Task 1")
+        tool._manage_todos(action="add", task="Task 2")
+        
+        result = tool._manage_todos(action="list")
+        
+        assert "Task 1" in result
+        assert "Task 2" in result
+        assert "[ ]" in result  # Pending status
+
+    def test_complete_task(self):
+        """Test marking a task as complete."""
+        tool = TodoTool()
+        tool._manage_todos(action="add", task="Do something")
+        
+        result = tool._manage_todos(action="complete", task_id=0)
+        assert "marked as completed" in result
+        
+        list_result = tool._manage_todos(action="list")
+        assert "[x]" in list_result  # Completed status
+
+    def test_remove_task(self):
+        """Test removing a task."""
+        tool = TodoTool()
+        tool._manage_todos(action="add", task="Task to remove")
+        tool._manage_todos(action="add", task="Task to keep")
+        
+        result = tool._manage_todos(action="remove", task_id=0)
+        assert "removed" in result
+        
+        list_result = tool._manage_todos(action="list")
+        assert "Task to remove" not in list_result
+        assert "Task to keep" in list_result
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

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

@@ -1,9 +0,0 @@
-from agentify.extensions.tools.time import get_current_time_tool
-from agentify.extensions.tools.calculator import calculate_expression_tool
-from agentify.extensions.tools.weather import get_weather_tool
-
-__all__ = [
-    "get_current_time_tool",
-    "calculate_expression_tool",
-    "get_weather_tool",
-]

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

@@ -1,56 +0,0 @@
-from agentify.core.tool import Tool
-import ast
-import operator as op
-
-
-calculate_expression_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"],
-    },
-}
-
-
-_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,
-}
-
-
-def _eval_node(node):
-    if isinstance(node, ast.Num):
-        return node.n
-    if isinstance(node, ast.BinOp):
-        left = _eval_node(node.left)
-        right = _eval_node(node.right)
-        return _allowed_ops[type(node.op)](left, right)
-    if isinstance(node, ast.UnaryOp):
-        operand = _eval_node(node.operand)
-        return _allowed_ops[type(node.op)](operand)
-    raise ValueError(f"Operador no permitido: {node}")
-
-
-def calculate_expression(expression: str):
-    try:
-        tree = ast.parse(expression, mode="eval").body
-        result = _eval_node(tree)
-        return {"result": result}
-    except Exception as e:
-        return {"error": f"Expresión inválida: {e}"}
-
-
-calculate_expression_tool = Tool(calculate_expression_schema, calculate_expression)

agentify_core-0.1.2/agentify/extensions/tools/time.py

@@ -1,21 +0,0 @@
-from agentify.core.tool import Tool
-import datetime
-
-
-get_current_time_schema = {
-    "name": "get_current_time",
-    "description": "Devuelve la hora y fecha actual en formato ISO 8601.",
-    "parameters": {
-        "type": "object",
-        "properties": {},
-        "required": [],
-    },
-}
-
-
-def get_current_time():
-    now = datetime.datetime.now().astimezone().isoformat()
-    return {"current_time": now}
-
-
-get_current_time_tool = Tool(get_current_time_schema, get_current_time)

agentify_core-0.1.2/agentify/extensions/tools/weather.py

@@ -1,51 +0,0 @@
-from agentify.core.tool import Tool
-import os
-import requests
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-get_weather_schema = {
-    "name": "get_weather",
-    "description": "Obtiene el estado del tiempo o clima actual para una ciudad o zona especificada.",
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "location": {
-                "type": "string",
-                "description": "Nombre de la ciudad o zona para consultar el clima.",
-            }
-        },
-        "required": ["location"],
-    },
-}
-
-
-def get_weather(location: str):
-    api_key = os.getenv("OPENWEATHER_API_KEY")
-    if not api_key:
-        return {"error": "Variable de entorno OPENWEATHER_API_KEY no configurada."}
-    try:
-        response = requests.get(
-            "https://api.openweathermap.org/data/2.5/weather",
-            params={"q": location, "appid": api_key, "units": "metric"},
-        )
-        data = response.json()
-        if response.status_code != 200:
-            return {
-                "error": data.get("message", "Error desconocido al obtener el clima.")
-            }
-        weather = {
-            "location": data["name"],
-            "description": data["weather"][0]["description"],
-            "temperature": data["main"]["temp"],
-            "humidity": data["main"]["humidity"],
-            "wind_speed": data["wind"]["speed"],
-        }
-        return {"weather": weather}
-    except Exception as e:
-        return {"error": f"Error al conectar con el servicio de clima: {e}"}
-
-
-get_weather_tool = Tool(get_weather_schema, get_weather)

agentify_core-0.1.2/agentify/memory/stores/__init__.py

@@ -1,6 +0,0 @@
-"""Memory storage backends."""
-
-from agentify.memory.stores.in_memory_store import InMemoryStore
-from agentify.memory.stores.redis_store import RedisStore
-
-__all__ = ["InMemoryStore", "RedisStore"]