agentx-dev 2.0__tar.gz

agentx_dev-2.0/MANIFEST.in

@@ -0,0 +1,2 @@
+graft agentx_dev
+prune tests

agentx_dev-2.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: agentx-dev
+Version: 2.0
+Summary: A lightweight LLM agent framework with standard and structured tool support use, prompt management, and support for OpenAI.
+Author-email: Bruce-Arhin Shadrach <brucearhin098@gmail.com>
+Project-URL: Homepage, https://github.com/shadrach098/Bruce_framework
+Project-URL: Bug Tracker, https://github.com/shadrach098/Bruce_framework/issues
+Project-URL: Source, https://github.com/shadrach098/Bruce_framework
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: google-generativeai
+Requires-Dist: httpx
+Requires-Dist: PyYAML>=5.3.1
+
+
+# 🧠 Bruce Agent
+
+**AgentX** is a lightweight, extensible agentic framework for building custom LLM agents with structured tool use, prompt templates, and integration with OpenAI and Gemini models.
+
+## 🚀 Features
+
+- 🔁 Custom reasoning loop (`AgentRunner`)
+- 🧩 Structured tool execution (Pydantic-based)
+- 💬 Prompt templating and management
+- 🔌 LLM-agnostic: supports **OpenAI function calling** and **Google Gemini**
+- 🪄 Easy-to-use API for building agents
+
+## 📦 Installation
+
+published to PyPI:
+
+```sh
+pip install AgentX-Dev
+```
+
+## Example use
+
+```python
+from AgentXL import AgentRunner, AgentType,ChatModel
+from pydantic import BaseModel
+from AgentXL.Tools import StructuredTool,StandardTool
+# Define a sample Stuctured tool
+class MultiplyTool(BaseModel):
+    a: int
+    b: int
+
+def multiply(a: int, b: int) -> int:
+    return a * b
+
+# Define a sample Standard tool
+def Weather(weather:str):
+    return f"{weather} is currently at 28 degree with a high of 32 and a low of 18 "
+
+# Create chat model and agent
+ReAct=AgentType.ReAct
+chat_model = ChatModel.GPT(model="gpt-4", temperature=0.7)
+tools = [StructuredTool(name="MultiplyTool",
+                        description="useful when you need to add two numbers",
+                        func=multiply,
+                        args_schema=MultiplyTool
+                        ),
+         StandardTool(name="Weather",
+                      description="when you need to check the weather of a location, input should be the str of the location",
+                      func=Weather)]
+# Create an AgentRunner instance
+agent = AgentRunner(model=chat_model,Agent=ReAct, tools=tools)
+
+# Initialize the agent with user input
+response = agent.Initialize("What is 5 times 8?")
+
+# Print the result
+print(response.content)
+
+
+# output the Agent completion
+agent.Initialize("i need the weather in Barrie")
+
+
+```
+
+``` bruce_framework/
+├── src/
+│   └── bruce_framework/
+│       ├── __init__.py
+│       ├── agent/
+│       │   ├── __init__.py
+│       │   └── agent.py
+│       ├── runner/
+│       │   ├── __init__.py
+│       │   └── agent_run.py
+│       └── chatmodel.py
+├── README.md
+├── LICENSE
+└── pyproject.toml
+
+```
+
+## 📚 Documentation (Coming Soon)
+### More tutorials, tool examples, and structured prompting guides coming soon.
+
+## 🧑‍💻 Author
+#### Bruce-Arhin Shadrach
+#### 📧 brucearhin098@gmail.com
+#### 🌐 GitHub
+
+📝 License
+MIT License
+
+
+

agentx_dev-2.0/README.md

@@ -0,0 +1,96 @@
+
+# 🧠 Bruce Agent
+
+**AgentX** is a lightweight, extensible agentic framework for building custom LLM agents with structured tool use, prompt templates, and integration with OpenAI and Gemini models.
+
+## 🚀 Features
+
+- 🔁 Custom reasoning loop (`AgentRunner`)
+- 🧩 Structured tool execution (Pydantic-based)
+- 💬 Prompt templating and management
+- 🔌 LLM-agnostic: supports **OpenAI function calling** and **Google Gemini**
+- 🪄 Easy-to-use API for building agents
+
+## 📦 Installation
+
+published to PyPI:
+
+```sh
+pip install AgentX-Dev
+```
+
+## Example use
+
+```python
+from AgentXL import AgentRunner, AgentType,ChatModel
+from pydantic import BaseModel
+from AgentXL.Tools import StructuredTool,StandardTool
+# Define a sample Stuctured tool
+class MultiplyTool(BaseModel):
+    a: int
+    b: int
+
+def multiply(a: int, b: int) -> int:
+    return a * b
+
+# Define a sample Standard tool
+def Weather(weather:str):
+    return f"{weather} is currently at 28 degree with a high of 32 and a low of 18 "
+
+# Create chat model and agent
+ReAct=AgentType.ReAct
+chat_model = ChatModel.GPT(model="gpt-4", temperature=0.7)
+tools = [StructuredTool(name="MultiplyTool",
+                        description="useful when you need to add two numbers",
+                        func=multiply,
+                        args_schema=MultiplyTool
+                        ),
+         StandardTool(name="Weather",
+                      description="when you need to check the weather of a location, input should be the str of the location",
+                      func=Weather)]
+# Create an AgentRunner instance
+agent = AgentRunner(model=chat_model,Agent=ReAct, tools=tools)
+
+# Initialize the agent with user input
+response = agent.Initialize("What is 5 times 8?")
+
+# Print the result
+print(response.content)
+
+
+# output the Agent completion
+agent.Initialize("i need the weather in Barrie")
+
+
+```
+
+``` bruce_framework/
+├── src/
+│   └── bruce_framework/
+│       ├── __init__.py
+│       ├── agent/
+│       │   ├── __init__.py
+│       │   └── agent.py
+│       ├── runner/
+│       │   ├── __init__.py
+│       │   └── agent_run.py
+│       └── chatmodel.py
+├── README.md
+├── LICENSE
+└── pyproject.toml
+
+```
+
+## 📚 Documentation (Coming Soon)
+### More tutorials, tool examples, and structured prompting guides coming soon.
+
+## 🧑‍💻 Author
+#### Bruce-Arhin Shadrach
+#### 📧 brucearhin098@gmail.com
+#### 🌐 GitHub
+
+📝 License
+MIT License
+
+
+

agentx_dev-2.0/agentx_dev/Agents/Agent.py

@@ -0,0 +1,349 @@
+"""
+This module contains classes and functions for working with agent prompts and JSON data.
+
+It includes classes for different agent prompt templates, a function to convert strings to JSON,
+and a container class for standard pre-defined agent prompt templates.
+"""
+
+import yaml,logging,json,uuid,time,os
+from pydantic import BaseModel, Field, ValidationError
+from typing import Dict, Any,Type,Optional,List,Union
+from rich.console import Console
+console=Console()
+# Set up logging
+logging.basicConfig(level=logging.ERROR)
+logger = logging.getLogger(__name__)
+
+class StandardParser(BaseModel):
+    """
+    A Pydantic model representing the standard parser.
+
+    Attributes:
+    - action: str, the action to take.
+    - action_input: str or Dict, the input to the action.
+
+    Methods:
+    - from_json: Creates an instance from a JSON string.
+    """
+    action: str = Field("The action to take", alias='action')
+    action_input: str | Dict = Field("The input to the action", alias='action_input')
+
+    class Config:
+        populate_by_name = True
+
+    @classmethod
+    def from_json(cls, json_str: str):
+        try:
+            json_object = convert_to_json(json_str)
+            if isinstance(json_object,dict):
+                return cls(**json_object)
+            elif isinstance(json_object,str):
+                return json_object
+        except (ValueError, ValidationError) as e:
+            logger.error(f"Error creating StandardParser instance: {e}")
+            raise
+
+
+
+
+
+
+def load_prompt_templates(file_path: str) -> Dict:
+    """
+    Loads prompt templates from a YAML file.
+
+    Args:
+    - file_path: str, the path to the YAML file containing the prompt templates.
+
+    Returns:
+    - Dict: A dictionary containing the loaded prompt templates.
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Can't find file {file_path}")
+    with open(file_path, 'r') as yaml_:
+        
+        return yaml.safe_load(yaml_)
+
+system = load_prompt_templates( r"..\promptTemplate.yaml")
+
+
+def convert_to_json(json_str: str) -> Dict[str, Any]:
+    """
+    Converts a given string into a JSON object.
+
+    Args:
+    - json_str: str, the string to be converted into JSON.
+
+    Returns:
+    - Dict[str, Any]: A dictionary representing the JSON object.
+
+    Raises:
+    - json.JSONDecodeError: If the input string is not valid JSON.
+    """
+    try:
+        if json_str.startswith("```json") and json_str.endswith("```"):
+            return json.loads(json_str.split("```json")[-1].split("```")[0])
+        elif json_str.startswith('{') and json_str.endswith('}'):
+            return json.loads(json_str)
+        else :
+            return json_str
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to decode JSON: {e}")
+        return f"Failed to decode JSON: {e}"  # or you can re-raise the exception, depending on your error handling strategy
+
+# Consider adding a Config class to these models to allow population by field name
+class Instruction_Tuned_(BaseModel):
+    """
+    A Pydantic model representing the Instruction-Tuned prompt template.
+
+    Attributes:
+    - action: str, the action to take or final answer.
+    - action_input: str or Dict, the input to the action.
+
+    Methods:
+    - from_json: Creates an instance from a JSON string.
+    """
+    action: str = Field("The action to take OR Final Answer", alias="action")
+    action_input: str | Dict = Field("The input to the action OR You should put what you want to return to use here and return to user immediately", alias="action_input")
+    
+
+    @classmethod
+    def from_json(cls, json_str: str):
+        try:
+            json_object = convert_to_json(json_str)
+            if isinstance(json_object,dict):
+                return cls(**json_object)
+            elif isinstance(json_object,str):
+                return json_object
+        except (ValueError, ValidationError) as e:
+            # Handle the error, e.g., log it, raise a custom exception, or return a default value
+            error = f"Error creating Instruction_Tuned_ instance: {e}"
+            logger.error(error)
+            raise 
+        
+
+class React_(BaseModel):
+    """
+    A Pydantic model representing the ReAct prompt template.
+
+    Attributes:
+    - Thought: str, the agent's thoughts.
+    - action: str, the action to take or final answer.
+    - action_input: str or Dict, the input to the action.
+
+    Methods:
+    - from_json: Creates an instance from a JSON string.
+    """
+    Thought: str = Field('The Agent Thoughts', alias='Thought')
+    action: str = Field("The action to take OR Final Answer", alias="action")
+    action_input: str | Dict = Field("The input to the action OR You should put what you want to return to use here and return to user immediately", alias="action_input")
+
+    @classmethod
+    def from_json(cls, json_str: str):
+        try:
+            json_object = convert_to_json(json_str)
+            if isinstance(json_object,dict):
+                console.print("[bold cyan]Thinking...[/bold cyan]")
+                print(f"\n{json_object['Thought']}")
+                return cls(**json_object)
+            elif isinstance(json_object,str):
+                return json_object
+        except (ValueError, ValidationError) as e:
+            # Handle the error, e.g., log it, raise a custom exception, or return a default value
+            error = f"Error creating React_ instance: {e}"
+            logger.error(error)
+            raise
+
+class ChainOfThought(BaseModel):
+    """
+    A Pydantic model representing the Chain-of-Thought prompt template.
+
+    Attributes:
+    - Thought: str, the step-by-step reasoning.
+    - Action: str, the action to take or final answer.
+    - Action_Input: str or Dict, the input to the action.
+
+    Methods:
+    - from_json: Creates an instance from a JSON string.
+    """
+    Thought: str = Field('The step-by-step reasoning', alias='Thought')
+    Action: str = Field("The action to take or Final Answer", alias='Action')
+    Action_Input: str | Dict = Field("The input to the action", alias='Action Input')
+
+    @classmethod
+    def from_json(cls, json_str: str):
+        try:
+            json_object = convert_to_json(json_str)
+            if isinstance(json_object,dict):
+                console.print("[bold cyan]Thinking...[/bold cyan]")
+                print(f"\n{json_object['Thought']}")
+                return cls(**json_object)
+            elif isinstance(json_object,str):
+                return json_object
+        except (ValueError, ValidationError) as e:
+            logger.error(f"Error creating ChainOfThought instance: {e}")
+            raise
+
+class ZeroShot(BaseModel):
+    """
+    A Pydantic model representing the Zero-Shot prompt template.
+
+    Attributes:
+    - action: str, the action to take.
+    - action_input: str or Dict, the input to the action.
+
+    Methods:
+    - from_json: Creates an instance from a JSON string.
+    """
+    action: str = Field("The action to take", alias='action')
+    action_input: str | Dict = Field("The input to the action", alias='action_input')
+
+    @classmethod
+    def from_json(cls, json_str: str):
+        try:
+            json_object = convert_to_json(json_str)
+            if isinstance(json_object,dict):
+                return cls(**json_object)
+            elif isinstance(json_object,str):
+                return json_object
+        except (ValueError, ValidationError) as e:
+            logger.error(f"Error creating ZeroShot instance: {e}")
+            raise
+
+class FewShot(BaseModel):
+    """
+    A Pydantic model representing the Few-Shot prompt template.
+
+    Attributes:
+    - action: str, the action to take.
+    - action_input: str or Dict, the input to the action.
+
+    Methods:
+    - from_json: Creates an instance from a JSON string.
+    """
+    action: str = Field("The action to take", alias='action')
+    action_input: str | Dict = Field("The input to the action", alias='action_input')
+
+    @classmethod
+    def from_json(cls, json_str: str):
+        try:
+            json_object = convert_to_json(json_str)
+            if isinstance(json_object,dict):
+                return cls(**json_object)
+            elif isinstance(json_object,str):
+                return json_object
+        except (ValueError, ValidationError) as e:
+            logger.error(f"Error creating FewShot instance: {e}")
+            raise
+
+
+class AgentFormattor(BaseModel):
+    prompt: str
+    Agent: Type[BaseModel]=Field(description="The agent that will under the prompt and extract what's needed")
+    
+    @classmethod
+    def Formattor(cls,prompt:str,Agent:Type[BaseModel]):
+        return cls(prompt=prompt,Agent=Agent)
+
+
+class AgentPrompt:
+    """
+    Manages and formats the prompt template for the agent, allowing for
+    flexible placeholder values.
+    """
+    def __init__(self, prompt: str):
+        """
+        Initializes the prompt with a template string.
+        """
+        self.prompt = prompt
+
+    def format(self, tools: List,user_hold, **kwargs: Any) -> str:
+        """
+        Formats the prompt template with dynamic values.
+
+        Args:
+            tools (List): A list of tool objects to populate {tools} and {tool_names}.
+            **kwargs (Any): Optional. Any other key-value pairs corresponding to
+                            placeholders in the template (e.g., user_input="...").
+        Returns:
+            str: The fully formatted prompt.
+        """
+        # Build the dictionary of values that are always available.
+        format_values = {
+            'tools': "\n".join([f"- {t.name}: {t.description}" for t in tools]),
+            'tool_names': ", ".join([t.name for t in tools]),
+            'user_input' : user_hold
+
+        }
+
+        # The update() method merges the optional kwargs.
+        # If kwargs is empty, this does nothing.
+        format_values.update(kwargs)
+
+        # format_map uses the combined dictionary to fill in the template.
+        return self.prompt.format_map(format_values)
+    
+    
+
+
+class AgentType:
+    """
+    A container for standard, pre-defined agent prompt templates.
+
+    This class holds various prompt styles as class attributes, making them
+    easy to access and use to initialize an AgentPrompt.
+
+    Example:
+        react_prompt_template = AgentType.ReAct
+        agent_prompt = AgentPrompt(template=react_prompt_template)
+    """
+
+    ReAct = AgentFormattor.Formattor(prompt=system['ReAct'],Agent=React_)
+    Instruction_Tuned = AgentFormattor.Formattor(prompt=system['Instruction-Tuned'],Agent=Instruction_Tuned_)
+    Chain_of_Thought = AgentFormattor.Formattor(prompt=system['Chain-of-Thought'],Agent=ChainOfThought)
+    Zero_Shot = AgentFormattor.Formattor(prompt=system['Zero-Shot'],Agent=ZeroShot)
+    Few_Shot = AgentFormattor.Formattor(prompt=system['Few-Shot'],Agent=FewShot)
+    
+
+
+
+class ToolCall(BaseModel):
+    name: str
+    args: Dict[str, Any]
+    result: str
+
+
+class ToolCall(BaseModel):
+    name: str
+    args: Dict[str, Any]
+    result: str
+
+class AgentCompletion(BaseModel):
+    id: str
+    object: str = "agent.completion"
+    created: int
+    model: str
+    query: str
+    content: str
+    tool_calls: List[ToolCall] = Field(default_factory=list)
+    steps: List[str] = Field(default_factory=list)
+    history: Optional[List[Dict[str, str]]] = None
+
+
+    @classmethod
+    def from_agent(cls, *, model_name: str, query: str, content: Union[str, Dict[str, Any], List[Dict[str, Any]]], tool_calls: Optional[List[ToolCall]] = None, steps: Optional[List[str]] = None, history: List[Dict[str, str]]):
+        if isinstance(content, (dict, list)):
+            content_str = json.dumps(content, ensure_ascii=False)
+        else:
+            content_str = content
+        return cls(
+            id=str(uuid.uuid4()),
+            created=int(time.time()),
+            model=model_name,
+            query=query,
+            content=content_str,
+            tool_calls=tool_calls,
+            steps=steps,
+            history=history
+        )
+    

agentx_dev-2.0/agentx_dev/Agents/__init__.py

@@ -0,0 +1,11 @@
+from .Agent import AgentFormattor,AgentPrompt,AgentType,AgentCompletion,StandardParser,ToolCall
+
+
+__all__ =[
+    'AgentFormattor',
+    'AgentCompletion',
+    'AgentPrompt',
+    'AgentType',
+    'StandardParser',
+    'ToolCall'  
+]