sceneprogagent 0.1.0__tar.gz

sceneprogagent-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: sceneprogagent
+Version: 0.1.0
+Summary: A Scene Prog Agent
+Home-page: https://github.com/KunalMGupta/sceneprogagent.git
+Author: Kunal Gupta
+Author-email: k5upta@ucsd.edu
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# **SceneProgAgent**
+
+**SceneProgAgent** is a powerful agent framework customized for the SceneProg Project.

sceneprogagent-0.1.0/README.md

@@ -0,0 +1,3 @@
+# **SceneProgAgent**
+
+**SceneProgAgent** is a powerful agent framework customized for the SceneProg Project.

sceneprogagent-0.1.0/sceneprogagent/__init__.py

@@ -0,0 +1,3 @@
+from .sceneprogagent import SceneProgAgent
+from .utils import print_colored
+from .tool import SceneProgTool

sceneprogagent-0.1.0/sceneprogagent/planner.py

@@ -0,0 +1,126 @@
+from sceneprogllm import LLM
+
+class Planner:
+    def __init__(self, name, planning_examples=None, tool_description=None):
+        self.name = name
+
+        if not planning_examples:
+            planning_examples = """
+Input: Cook pasta
+Output:
+    {{
+    '1': 'Invoke the BoilWater tool to boil water',
+    '2': 'Invoke the AddPasta tool to add pasta to boiling water',
+    '3': 'Invoke the Timer tool to set a timer for 8-12 minutes',
+    '4': 'Invoke the DrainPasta tool to drain the pasta once cooked',
+    'start': 1,
+    }}
+
+Input: Book a flight ticket from New York to Los Angeles for December 25th
+Output:
+    {{
+    '1': 'Invoke the SearchFlights tool to search for flights from New York to Los Angeles on December 25th',
+    '2': 'Invoke the ComparePrices tool to compare flight prices',
+    '3': 'Invoke the BookFlight tool to book the selected flight',
+    'start': 1,
+    }}
+
+Input: Write a blog post about sustainable living
+Output:
+    {{
+    '1': 'Invoke the ResearchTopic tool to gather information about sustainable living',
+    '2': 'Invoke the GenerateOutline tool to create an outline for the blog post',
+    '3': 'Invoke the WriteDraft tool to write a draft of the blog post',
+    '4': 'Invoke the Proofread tool to proofread and edit the blog post',
+    'start': 1,
+    }}
+
+Input: Organize a meeting with the team next Monday at 10 AM
+Output:
+    {{
+    '1': 'Invoke the CheckAvailability tool to check the team’s availability for next Monday at 10 AM',
+    '2': 'Invoke the BookMeetingRoom tool to reserve a meeting room',
+    '3': 'Invoke the SendInvites tool to send calendar invitations to the team',
+    'start': 1,
+    }}
+
+Input: Plan a weekend trip to the mountains
+Output:
+    {{
+    '1': 'Invoke the SearchDestinations tool to find mountain destinations',
+    '2': 'Invoke the CheckWeather tool to check the weekend weather forecast',
+    '3': 'Invoke the BookAccommodation tool to book a cabin or hotel',
+    '4': 'Invoke the CreatePackingList tool to generate a packing list for the trip',
+    'start': 1,
+    }}
+
+Input: Create a presentation about artificial intelligence
+Output:
+    {{
+    '1': 'Invoke the ResearchTopic tool to gather information about artificial intelligence',
+    '2': 'Invoke the CreateSlideOutline tool to draft the structure of the presentation',
+    '3': 'Invoke the DesignSlides tool to design slides for the presentation',
+    '4': 'Invoke the ReviewPresentation tool to review and refine the slides',
+    'start': 1,
+    }}
+
+Input: Make a smoothie
+Output:
+    {{
+    '1': 'Invoke the GatherIngredients tool to list required ingredients (e.g., fruits, milk, yogurt)',
+    '2': 'Invoke the BlendIngredients tool to blend the ingredients',
+    '3': 'Invoke the Serve tool to pour the smoothie into a glass',
+    'start': 1,
+    }}
+
+Input: Schedule a doctor’s appointment
+Output:
+    {{
+    '1': 'Invoke the FindDoctors tool to search for available doctors',
+    '2': 'Invoke the CheckAvailability tool to check appointment slots',
+    '3': 'Invoke the BookAppointment tool to confirm the appointment',
+    'start': 1,
+    }}
+"""
+
+        self.description = f"""
+Given the user query, your task is to generate a plan, primarily in plane english, whose successful execution will lead to the resolution of the query. 
+You must generate the plan as a list of steps (a python dictionary with numbers '1', '2', '3' being keys and steps being respective values). At each step, you may use a maximum of one tool from the tools available to you.
+Each step should be a simple instruction that can be executed, a call to action. In addition to the steps, you must also include a key 'start' which indicates the starting step of the plan. Example, if we want to start the plan from step 2, the 'start' key should have the value 2.
+The tools available to you are:
+{tool_description}
+Here are a few examples of how your response should look like:
+{planning_examples}
+"""
+        self.llm = LLM(name=name, system_desc=self.description, response_format="json")
+
+    def run(self, query):
+        response = self.llm.run(query)
+        plan = []
+        for key, value in response.items():
+            if key == "start":
+                plan_idx = int(value)
+                continue
+            plan.append(value)
+        return plan, plan_idx
+    
+    def __call__(self, query):
+        plan, plan_idx = self.run(query)
+        prompt = f"""
+The plan you generated for the query: {query} is as follows:
+{plan}
+with the starting step being: {plan_idx}
+Check if the plan is correct, complete and only uses the tools available to you. If you need to make any changes, do so now. If you cannot generate a plan, simply return a single item 'CANNOT PLAN'.
+"""
+        plan, plan_idx = self.run(prompt)
+        return plan, plan_idx
+    
+    def refine_plan(self, query, plan, plan_idx, result):
+        prompt = f"""
+For the query: {query}, you had generated the following plan:
+{plan}
+However, while executing step {plan[plan_idx-1]}, we encountered an error: {result}.
+Modify the plan accordingly to address the error. Also, update the starting step of the plan so that the steps before the error are not repeated.
+"""
+        plan, plan_idx = self(prompt)
+        return plan, plan_idx

sceneprogagent-0.1.0/sceneprogagent/sceneprogagent.py

@@ -0,0 +1,110 @@
+'''
+Features of the simple agent
+1. Tool usage (done)
+2. Handle tool failure (done)
+3. code execution
+4. Should be able to plan (done)
+5. Ability to refine response
+6. able to collaborate with other agents
+7. Implements RAG
+8. 
+'''
+from sceneprogllm import LLM
+from .planner import Planner
+from .tool_manager import ToolManager
+from .utils import print_colored
+
+class SceneProgAgent:
+    def __init__(self, name, role, description, planning_examples=None, silent=False):
+        self.name = name
+        self.role = role
+        self.description = description
+        self.silent = silent
+        self.planning_examples = planning_examples
+        self.tool_manager = ToolManager(name=self.name)
+
+        description = f"""
+Your name: {name}
+Your Role: {role}
+Task Description: {description}
+"""
+        self.llm = LLM(
+            name=name,
+            system_desc=description,
+            response_format="text",
+        )
+
+        self.clear_memory()
+
+    def clear_memory(self):
+        self.memory = ""
+
+    def clear_scratchpad(self):
+        self.scratchpad = ""
+
+    def register_tool(self, tool):
+        self.tool_manager.register_tool(tool)
+
+    def add_to_memory(self, speaker, message):
+        self.memory += f"{speaker}: {message}\n"
+    
+    def add_to_scratchpad(self, speaker, message):
+        self.scratchpad += f"{speaker}: {message}\n"
+
+    def try_executing_plan_step(self, plan, plan_idx, query):
+        step = plan[plan_idx-1]
+        self.add_to_scratchpad("You", "Executing step: "+step)
+        prompt = f"""
+The activity has been so far:
+{self.scratchpad}
+You are required to generate a brief reponse which contains sufficient information to execute the following step:
+{step}
+"""
+        context = self.llm.run(prompt)
+        status, result = self.tool_manager(step, context)
+        if status == -1:
+            self.add_to_scratchpad("You", "Error found: "+result)
+            return -1, result
+        self.add_to_scratchpad("You", "Step executed successfully.")
+        self.add_to_scratchpad("You", "Result: "+str(result))
+        print_colored(f"Result: {result}", color="magenta", silent=self.silent)
+        return status, result
+        
+    def init_planner(self):
+        self.planner = Planner(name=f"{self.name}_planner", planning_examples=self.planning_examples, tool_description=self.tool_manager.tool_description)
+
+    def __call__(self, query):
+        print_colored(f"Query: {query}", color="blue", silent=self.silent)
+        self.clear_scratchpad()
+
+        self.add_to_memory("User", query)
+        self.add_to_scratchpad("User", query)
+
+        plan, plan_idx = self.planner(query)
+        print_colored(f"Plan: {plan}, Plan Index: {plan_idx}", color="green", silent=self.silent)
+        if plan == ["CANNOT PLAN"]:
+            msg = "I'm sorry, I don't have sufficient information or tools to answer this query."
+            self.add_to_memory("You", msg)
+            return -1, msg
+        
+        self.add_to_scratchpad("Planner", "Following is the plan to achieve the task:"+"\n".join(plan))
+        
+        while True:
+            status, result = self.try_executing_plan_step(plan, plan_idx, query)
+            if status == -1:
+                plan, plan_idx = self.planner.refine_plan(query, plan, plan_idx, result)
+                print_colored(f"Refined Plan: {plan}, Plan Index: {plan_idx}", color="green", silent=self.silent)
+                if plan == ["CANNOT PLAN"]:
+                    msg = "I'm sorry, I don't have sufficient information or tools to answer this query."
+                    self.add_to_memory("You", msg)
+                    return -1, msg
+                
+                self.add_to_scratchpad("Planner", "Following is the refined plan to achieve the task:"+"\n".join(plan))
+            else:
+                plan_idx += 1
+            
+            if plan_idx > len(plan):
+                break
+
+        self.add_to_memory("You", "Task completed successfully.")
+        return result

sceneprogagent-0.1.0/sceneprogagent/tool.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel, Field
+from typing import List
+
+class SceneProgTool:
+    def __init__(self):
+        
+        self.name = None
+        self.usage = None
+        self.io = None
+        self.examples = None
+
+    def build_io(self, Inputs, Outputs):
+        self.Inputs = Inputs
+        self.Outputs = Outputs
+        # Generate the text block
+        inputs ="\n".join([f"- {name}: {info}" for name, info in dict(Inputs.model_fields.items()).items()])
+        outputs = "\n".join([f"- {name}: {info}" for name, info in dict(Outputs.model_fields.items()).items()])
+        self.io = f"""
+Input:
+{inputs}
+Output:
+{outputs}
+"""
+    def __str__(self):
+        return f"{self.name}: {self.usage}\n{self.io}\n{self.examples}"
+    
+    def validate_arguments(self, Inputs):
+        pass
+
+    def build_response(self, status, message, solution, result):
+        class Response:
+            def __init__(self, status, message, solution, result):
+                self.status = status
+                self.message = message
+                self.solution = solution
+                self.result = result
+        return Response(status, message, solution, result)

sceneprogagent-0.1.0/sceneprogagent/tool_manager.py

@@ -0,0 +1,106 @@
+from sceneprogllm import LLM
+from .utils import print_colored
+
+class ToolManager:
+    def __init__(self, name, silent=False):
+        self.name = name
+        self.silent = silent
+        self.tool_description = ""
+        self.tool_registry = {}
+        self.tool_identifier = LLM(
+            name=f"{self.name}_tool_identifier",
+            system_desc="Identify the tool needed to execute the query. Your answer should be a dict like 'tool': 'tool_name'. Note that only a single tool should be identified.",
+            response_format="json",
+            json_keys=['tool']
+        )
+
+        self.tool_argument_extractor = LLM(
+            name=f"{self.name}_tool_argument_extractor",
+            system_desc="Extract the arguments needed to execute the identified tool. Carefully go through the query and identify the necessary arguments for the tool. ",
+            response_format="pydantic",
+        )
+
+    def register_tool(self, tool):
+        self.tool_registry[tool.name] = tool
+        self.tool_description += f"""
+Tool: {tool.name}
+Usage: {tool.usage}
+Input/Output: 
+{tool.io}
+Example of tool usage: 
+{tool.examples}
+""" 
+
+    def get_tool_name(self, query):
+        tool_name = self.tool_identifier.run(query)
+        print_colored(f"Tool identified: {tool_name['tool']}", color="green", silent=self.silent)
+
+        count=0
+        while True:
+            if tool_name['tool'] == "unknown" or count>3:
+                return -1, f"Cannot identify appropriate tool for the query: {query}."
+            elif tool_name['tool'] in self.tool_registry:
+                return 0, tool_name['tool']
+            else:
+                prompt = f"""
+The tool that you identified: {tool_name['tool']} for the query: {query} cannot be found in the tool registry.
+Make sure you are identifying the correct tool with the correct name. If the exact tool is not available, try to identify a similar tool.
+If you are unable to identify the tool, please return the tool name as 'unknown'.
+"""
+                tool_name = self.tool_identifier.run(prompt)
+                count+=1
+            
+    def get_tool_arguments(self, tool, context):
+        prompt = f"""
+You are required to extract arguments for the tool: {tool.name}
+Tool Usage Info: {tool.usage}
+Following are the I/O for the tool:
+{tool.io}
+Use the following context to extract the arguments:
+{context}
+"""
+        arguments = self.tool_argument_extractor.run(prompt, pydantic_object=tool.Inputs)
+        count=0
+        while True:
+            try:
+                tool.validate_arguments(arguments)   
+                break
+            except Exception as e:
+                prompt = f"""
+Your retrieved arguments: {arguments} for the tool: {tool.name} are incorrect. 
+Error: {e}
+Please try again.
+"""
+                print_colored(f"Error: {e} occurred while executing the tool: {tool.name} with arguments: {arguments}.", color="red", silent=self.silent)           
+                arguments = self.tool_argument_extractor.run(prompt, pydantic_object=tool.Inputs) 
+                count+=1
+
+            if count>3:
+                print_colored(f"Tool: {tool.name} failed to execute after 3 attempts. Please think of something else.", color="red", silent=self.silent)
+                return -1, f"Tool: {tool.name} failed to execute after 3 attempts. Please think of something else."
+            
+        print_colored(f"Arguments extracted: {arguments}", color="green", silent=self.silent)
+        return 0, arguments
+    
+    def __call__(self, query, context):
+        
+        status, tool_name = self.get_tool_name(query)
+        if status == -1:
+            return -1, tool_name
+        
+        tool = self.tool_registry[tool_name]
+        status, arguments = self.get_tool_arguments(tool, context)
+        if status == -1:
+            return -1, arguments
+
+        response = tool(arguments)
+        if response.status == -1:
+            msg = f"""
+Tried running the tool: {tool.name} with arguments: {arguments} but it failed to execute.
+Error: {response.message}
+Potential solution: {response.solution}
+"""
+            print_colored(msg, color="red", silent=self.silent)
+            return -1, msg
+
+        return 0, response.result

sceneprogagent-0.1.0/sceneprogagent/utils.py

@@ -0,0 +1,28 @@
+def print_colored(text: str, color: str = "default", silent: bool = False):
+        if silent:
+            return
+        """
+        Prints text in various colors.
+        
+        Args:
+            text (str): The text to print.
+            color (str): The color of the text. Options are:
+                        "black", "red", "green", "yellow", "blue", "magenta",
+                        "cyan", "white", or "default".
+        """
+        colors = {
+            "black": "\033[30m",
+            "red": "\033[31m",
+            "green": "\033[32m",
+            "yellow": "\033[33m",
+            "blue": "\033[34m",
+            "magenta": "\033[35m",
+            "cyan": "\033[36m",
+            "white": "\033[37m",
+            "default": "\033[39m"
+        }
+        
+        reset = "\033[0m"
+        color_code = colors.get(color.lower(), colors["default"])
+        
+        print(f"{color_code}{text}{reset}")

sceneprogagent-0.1.0/sceneprogagent.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: sceneprogagent
+Version: 0.1.0
+Summary: A Scene Prog Agent
+Home-page: https://github.com/KunalMGupta/sceneprogagent.git
+Author: Kunal Gupta
+Author-email: k5upta@ucsd.edu
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# **SceneProgAgent**
+
+**SceneProgAgent** is a powerful agent framework customized for the SceneProg Project.

sceneprogagent-0.1.0/sceneprogagent.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+sceneprogagent/__init__.py
+sceneprogagent/planner.py
+sceneprogagent/sceneprogagent.py
+sceneprogagent/tool.py
+sceneprogagent/tool_manager.py
+sceneprogagent/utils.py
+sceneprogagent.egg-info/PKG-INFO
+sceneprogagent.egg-info/SOURCES.txt
+sceneprogagent.egg-info/dependency_links.txt
+sceneprogagent.egg-info/top_level.txt

sceneprogagent-0.1.0/sceneprogagent.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sceneprogagent-0.1.0/sceneprogagent.egg-info/top_level.txt

@@ -0,0 +1 @@
+sceneprogagent

sceneprogagent-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sceneprogagent-0.1.0/setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup, find_packages
+setup(
+    name='sceneprogagent',  # Replace with your package's name
+    version='0.1.0',    # Replace with your package's version
+    description='A Scene Prog Agent',  # Replace with a short description of your package
+    long_description=open('README.md').read(),  # Optional: Use your README for a detailed description
+    long_description_content_type='text/markdown',
+    author='Kunal Gupta',
+    author_email='k5upta@ucsd.edu',
+    url='https://github.com/KunalMGupta/sceneprogagent.git',  # Optional: Replace with your repo URL
+    packages=find_packages(),  # Automatically find all packages in your project
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.9',  # Replace with the minimum Python version your package supports
+)