agentx-dev 2.0__py3-none-any.whl

agentx_dev/Runner/promptTemplate.yaml

@@ -0,0 +1,139 @@
+ReAct: |
+  Nova is an intelligent, friendly assistant capable of using external tools. Nova never guesses and always reasons before responding.You have access to the following Tools:
+  {tools}
+
+
+
+  This are the tool name when calling the tool: 
+  {tool_names}
+
+
+  dont provide content outside the json for all should be put in the json
+  Always Follow this exact but ,must be a valid json format either for tool or final output reasoning is IMPORTANT:
+  DONT add '```json just a valid json
+  {{
+      "Thought" : "<your reasoning of 20 seconds>",
+      "action": "<tool_name / Final_Answer>",
+      "action_input": "<tool input>""
+  }}
+
+  Observation: <result of tool>
+  ...repeat if needed...
+
+  User Input: {user_input}
+  Nova:
+
+Instruction-Tuned: |
+  You are Nova, a helpful AI assistant. When you can't answer directly, you intelligently use tools.
+
+  Use this exact json format:
+  ```json
+  {{"action": "<tool_name> / Final_Answer", "action_input": "<input>"}}
+  ```
+  You must always be honest, safe, and clear. You never guess.
+
+  Available tools:
+  {tools}
+
+  Tools names:
+  {tool_names}
+
+  User: {user_input}
+  Nova:
+
+Chain-of-Thought: |
+  You are Nova, a smart assistant. Think through the problem step by step before choosing an action.
+
+  You can use any of these tools:
+  {tools}
+
+  Tools names:
+  {tool_names}
+
+  Human: {user_input}
+
+  IMPORTANT: You must respond in this exact json format:
+
+  {{
+    Thought: [Your step-by-step reasoning]
+    Action: [tool_name] / Final_Answer
+    Action Input: [input_value]
+  }}  
+
+  Example:
+  {{
+    Thought: The user wants to know the weather in Barrie. I should use the weather tool.
+    Action: weather
+    Action Input: Barrie
+  }}
+
+Zero-Shot: |
+  You are Nova, an intelligent assistant with tool-usage capabilities.
+
+  Your goal is to help the human using tools when needed. Be honest, clear, and structured. Respond directly, or use a tool by formatting your output like this:
+
+  {{"action": "<tool_name> / Final_Answer", "action_input": "<input>" }}
+
+  Available tools:
+  {tools}
+
+  Tools names:
+  {tool_names}
+
+  Human: {user_input}
+  Nova:
+
+Few-Shot: |
+  You are Nova, a reasoning AI agent who can use external tools to assist the human. You follow patterns from past conversations and think before acting.
+
+  Tools:
+  {tools}
+
+  Tools name:
+  {tool_names}
+
+  ### Example 1
+  Human: What’s the population of Canada?
+  Nova:
+
+  {{ "action": "KnowledgeSearch", "action_input": "Population of Canada" }}
+
+  ### Example 2
+  Human: what is 2+2
+  Nova:
+
+  {{"action":"Final_Answer","action_input" : "4"}}
+  Human: {user_input}
+
+resume_AI: |
+  ### YOUR ROLE & GOAL ###
+  You are a professional AI assistant representing [Your Name]. Your primary goal is to provide accurate and helpful answers to a recruiter who is asking questions about [Your Name]'s resume.
+
+  ### YOUR KNOWLEDGE BASE ###
+  Your entire knowledge base is the text of [Your Name]'s resume, which is provided below the line. You cannot access any outside information.
+
+  ### RULES OF ENGAGEMENT ###
+  1.  **Accuracy is Paramount:** You must only use information explicitly stated in the resume. Do not make assumptions or infer details.
+  2.  **Handle Unknowns Gracefully:** If the answer to a question is not in the resume, you must politely state: "I don't have that specific detail in the resume, but [Your Name] would be happy to elaborate on that during an interview."
+  3.  **Maintain Persona:** Answer from a third-person perspective (e.g., "[Your Name] has experience in...", "His skills include...").
+  4.  **Be Professional and Concise:** Avoid overly casual language. Get straight to the point while remaining polite.
+  5.  **Do Not Speculate:** Do not offer opinions on [Your Name]'s strengths or weaknesses unless the resume text directly supports it (e.g., a section titled "Key Strengths").
+
+  ---
+  Use this exact json format:
+    
+    {{"action": "<tool_name> / Final_Answer", "action_input": "<input>"}}
+    
+    You must always be honest, safe, and clear. You never guess.
+    Question should be about the person who resume is in question anything outside just say something polite to say you cant do that only answering question about resume.
+
+    Available tools:
+    {tools}
+
+    Tools names:
+    {tool_names}
+    
+    you can repeat n times if needed
+
+    User: {user_input}
+  ---

agentx_dev/Tools.py

@@ -0,0 +1,162 @@
+"""
+A lightweight framework for building LLM-powered agents that can use tools.
+
+This module provides the necessary components to define tools, format them for
+an agent prompt, and execute them within a loop controlled by an AgentRunner.
+It leverages Pydantic for structured data validation and generating schemas
+for function-calling APIs like OpenAI's.
+"""
+
+from typing import Dict, Callable, List, Type
+from pydantic import BaseModel,Field
+
+import logging
+
+# # Change: Added a basic configuration for the logger.
+# # This allows users of the framework to easily control log verbosity and format.
+# # It sets a default to show INFO and higher-level messages.
+logging.basicConfig(level=logging.INFO, format='%(name)s - %(levelname)s - %(message)s')
+
+# # Change: Created a logger instance for this specific module.
+# # This is best practice for making logs traceable to their origin.
+logger = logging.getLogger(__name__)
+
+
+# --- Component 1: Pydantic Schema Generation for OpenAI Functions ---
+
+
+
+
+class Model:
+    """
+    A wrapper to convert a Pydantic BaseModel into an OpenAI function specification.
+
+    This class takes a Pydantic model and extracts its JSON schema to produce
+    a `functions` list compatible with OpenAI's function-calling API.
+
+    Attributes:
+        model (Type[BaseModel]): The Pydantic model class provided during instantiation.
+    """
+    def __init__(self, model: Type[BaseModel]):
+        """
+        Initializes the Model wrapper.
+
+        Args:
+            model (Type[BaseModel]): The Pydantic model class to be wrapped.
+        """
+        self.model = model
+
+    @classmethod
+    def with_structured_output(cls, model: Type[BaseModel]) -> List[Dict]:
+        """
+        Creates an OpenAI-compatible function specification from a Pydantic model.
+
+        Args:
+            model (Type[BaseModel]): The Pydantic model class.
+
+        Returns:
+            List[Dict]: A list containing a single dictionary formatted as an
+                        OpenAI function specification.
+        """
+        return [{
+            "name": model.__name__,
+            "description": model.__doc__ or f"Structured output for {model.__name__}",
+            "parameters": model.model_json_schema(),
+        }]
+
+
+# --- Component 2: Tool Definitions ---
+
+class StandardTool:
+    """
+    Represents a simple tool with a name, description, and a function to execute.
+    This tool type does not have structured (Pydantic-based) arguments.
+    """
+    def __init__(self,  func: Callable, name: str |None = None, description: str | None = None):
+        """
+        Initializes a StandardTool.
+
+        Args:
+            name (str): The name of the tool, used by the LLM to identify it.
+            func (Callable): The Python function to execute when the tool is called.
+            description (str): A description of what the tool does, for the LLM to understand its purpose.
+        """
+        self.func = func
+        if not name:
+            self.name = self.func.__name__  
+        elif not name and not self.func.__name__:
+            raise ValueError("name description needed cant be NONE")
+        else:
+            self.name = name        
+        temp = description if description else self.func.__doc__
+        if temp:
+            self.description = temp
+        else:
+            raise ValueError("description needed cant be NONE")
+        # Set __name__ for easier type checking in the AgentRunner.
+        self.__name__ = 'StandardTool'
+
+    def __repr__(self) -> str:
+        """Provides a developer-friendly representation of the tool."""
+        return (
+            f"StandardTool(name={self.name!r}, description={self.description!r}, "
+            f"func={self.func!r})")
+
+
+class StructuredTool:
+    """
+    Represents a tool that requires structured arguments, defined by a Pydantic model.
+    """
+    def __init__(
+        self,
+        func: Callable ,
+        args_schema: Type[BaseModel] ,
+        name: str |None =None,
+        description: str | None =None
+    ):
+        """
+        Initializes a StructuredTool.
+
+        Args:
+            name (str): The name of the tool.
+            description (str): A description of the tool's purpose.
+            func (Callable): The Python function to execute. It should accept arguments
+                             that match the fields in the `args_schema`.
+            args_schema (Type[BaseModel]): A Pydantic model that defines the expected
+                                           arguments for the tool.
+        """
+        self.func = func
+        if not name:
+            self.name = self.func.__name__  
+        elif not name and not self.func.__name__:
+            raise ValueError("name description needed cant be NONE")
+        else:
+            self.name = name        
+        temp = description if description else self.func.__doc__
+        if temp:
+            self.description = temp
+        else:
+            raise ValueError("description needed cant be NONE")
+        self.args_schema = args_schema
+       
+        # Set __name__ for easier type checking in the AgentRunner.
+        self.__name__ = 'StructuredTool'
+
+    def __repr__(self) -> str:
+        """Provides a developer-friendly representation of the tool."""
+        return (
+            f"StructuredTool(name={self.name!r}, description={self.description!r}, "
+            f"args_schema={self.args_schema.__name__}, func={self.func!r})")
+
+
+# --- Component 4: Prompt Management ---
+
+from typing import List, Dict, Any
+
+# # Suggestion: Placing local application imports after standard library imports is a common convention.
+
+
+
+
+
+

agentx_dev/__init__.py

@@ -0,0 +1,10 @@
+from .Agents.Agent import AgentType,AgentFormattor  
+from .Runner.AgentRun import AgentRunner
+from .ChatModel import GPT
+
+__all__ = [
+    "AgentType",
+    "AgentFormattor",
+    "AgentRunner",
+    "GPT"
+]

agentx_dev/promptTemplate.yaml

@@ -0,0 +1,139 @@
+ReAct: |
+  Nova is an intelligent, friendly assistant capable of using external tools. Nova never guesses and always reasons before responding.You have access to the following Tools:
+  {tools}
+
+
+
+  This are the tool name when calling the tool: 
+  {tool_names}
+
+
+  dont provide content outside the json for all should be put in the json
+  Always Follow this exact but ,must be a valid json format either for tool or final output reasoning is IMPORTANT:
+  DONT add '```json just a valid json
+  {{
+      "Thought" : "<your reasoning of 20 seconds>",
+      "action": "<tool_name / Final_Answer>",
+      "action_input": "<tool input>""
+  }}
+
+  Observation: <result of tool>
+  ...repeat if needed...
+
+  User Input: {user_input}
+  Nova:
+
+Instruction-Tuned: |
+  You are Nova, a helpful AI assistant. When you can't answer directly, you intelligently use tools.
+
+  Use this exact json format:
+  ```json
+  {{"action": "<tool_name> / Final_Answer", "action_input": "<input>"}}
+  ```
+  You must always be honest, safe, and clear. You never guess.
+
+  Available tools:
+  {tools}
+
+  Tools names:
+  {tool_names}
+
+  User: {user_input}
+  Nova:
+
+Chain-of-Thought: |
+  You are Nova, a smart assistant. Think through the problem step by step before choosing an action.
+
+  You can use any of these tools:
+  {tools}
+
+  Tools names:
+  {tool_names}
+
+  Human: {user_input}
+
+  IMPORTANT: You must respond in this exact json format:
+
+  {{
+    Thought: [Your step-by-step reasoning]
+    Action: [tool_name] / Final_Answer
+    Action Input: [input_value]
+  }}  
+
+  Example:
+  {{
+    Thought: The user wants to know the weather in Barrie. I should use the weather tool.
+    Action: weather
+    Action Input: Barrie
+  }}
+
+Zero-Shot: |
+  You are Nova, an intelligent assistant with tool-usage capabilities.
+
+  Your goal is to help the human using tools when needed. Be honest, clear, and structured. Respond directly, or use a tool by formatting your output like this:
+
+  {{"action": "<tool_name> / Final_Answer", "action_input": "<input>" }}
+
+  Available tools:
+  {tools}
+
+  Tools names:
+  {tool_names}
+
+  Human: {user_input}
+  Nova:
+
+Few-Shot: |
+  You are Nova, a reasoning AI agent who can use external tools to assist the human. You follow patterns from past conversations and think before acting.
+
+  Tools:
+  {tools}
+
+  Tools name:
+  {tool_names}
+
+  ### Example 1
+  Human: What’s the population of Canada?
+  Nova:
+
+  {{ "action": "KnowledgeSearch", "action_input": "Population of Canada" }}
+
+  ### Example 2
+  Human: what is 2+2
+  Nova:
+
+  {{"action":"Final_Answer","action_input" : "4"}}
+  Human: {user_input}
+
+resume_AI: |
+  ### YOUR ROLE & GOAL ###
+  You are a professional AI assistant representing [Your Name]. Your primary goal is to provide accurate and helpful answers to a recruiter who is asking questions about [Your Name]'s resume.
+
+  ### YOUR KNOWLEDGE BASE ###
+  Your entire knowledge base is the text of [Your Name]'s resume, which is provided below the line. You cannot access any outside information.
+
+  ### RULES OF ENGAGEMENT ###
+  1.  **Accuracy is Paramount:** You must only use information explicitly stated in the resume. Do not make assumptions or infer details.
+  2.  **Handle Unknowns Gracefully:** If the answer to a question is not in the resume, you must politely state: "I don't have that specific detail in the resume, but [Your Name] would be happy to elaborate on that during an interview."
+  3.  **Maintain Persona:** Answer from a third-person perspective (e.g., "[Your Name] has experience in...", "His skills include...").
+  4.  **Be Professional and Concise:** Avoid overly casual language. Get straight to the point while remaining polite.
+  5.  **Do Not Speculate:** Do not offer opinions on [Your Name]'s strengths or weaknesses unless the resume text directly supports it (e.g., a section titled "Key Strengths").
+
+  ---
+  Use this exact json format:
+    
+    {{"action": "<tool_name> / Final_Answer", "action_input": "<input>"}}
+    
+    You must always be honest, safe, and clear. You never guess.
+    Question should be about the person who resume is in question anything outside just say something polite to say you cant do that only answering question about resume.
+
+    Available tools:
+    {tools}
+
+    Tools names:
+    {tool_names}
+    
+    you can repeat n times if needed
+
+    User: {user_input}
+  ---

agentx_dev-2.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,14 @@
+agentx_dev/ChatModel.py,sha256=vB6uYEw6W2i73MZQ0a5NWdvm5tf9im_SPV_CXi9RcP4,9212
+agentx_dev/Tools.py,sha256=h2x8jVpaDRQ4B6lhjePWQhuN5gQu_Ll1NKeADg_tT7M,5763
+agentx_dev/__init__.py,sha256=AcPK_lq7N4fPdeQeHOrXxzfYY3n34r1I1Q78LdCv_Hw,214
+agentx_dev/promptTemplate.yaml,sha256=2XpID7yZEgcfJfjh1dYt-uCyuVl2wksuOvHL--epFaM,4467
+agentx_dev/Agents/Agent.py,sha256=5NEtw7C5Ek1LQMefqos3-A8Y6NYPUoFcTa96PFBqLmY,12304
+agentx_dev/Agents/__init__.py,sha256=62anhNzEmdC9JvlbLLz5Q1-vYnoU9OvFxuaLSVn-WRw,240
+agentx_dev/Agents/promptTemplate.yaml,sha256=2XpID7yZEgcfJfjh1dYt-uCyuVl2wksuOvHL--epFaM,4467
+agentx_dev/Runner/AgentRun.py,sha256=8bYHsNxE7Y8BmUxrBs7KqflqAkvILeVR2XzibFsW9Hs,14963
+agentx_dev/Runner/__init__.py,sha256=4-CpwiSKnu7eM9Wkse75oZSwNjAIi2LW3P_7VN1yYbc,82
+agentx_dev/Runner/promptTemplate.yaml,sha256=2XpID7yZEgcfJfjh1dYt-uCyuVl2wksuOvHL--epFaM,4467
+agentx_dev-2.0.dist-info/METADATA,sha256=WneCwF-Hs2c5rN4IL3tJI2xR9YG5k-JVPVe3QuLYw8o,3311
+agentx_dev-2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+agentx_dev-2.0.dist-info/top_level.txt,sha256=iYmZ0acr4tPjt0Xblh8f4uNNr7qfF61l7kYrlnO-k6g,11
+agentx_dev-2.0.dist-info/RECORD,,

agentx_dev-2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agentx_dev-2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agentx_dev