first HF spaces deploy

HFHub.py

@@ -0,0 +1,111 @@
+#%%writefile HFHub.py
+
+#utility file
+
+from smolagents.default_tools import __all__ as dft_tools
+from huggingface_hub import login, InferenceClient
+import logging
+from smolagents import ToolCollection
+from smolagents import HfApiModel, CodeAgent, Tool, LiteLLMModel
+from smolagents import ToolCollection
+from smolagents import HfApiModel, CodeAgent, Tool
+
+publishtoken = None;
+
+tool_Collections: dict[str, ToolCollection] = {}
+
+
+def all_tools() -> list[Tool]:
+    all_tools = []
+    for collection in tool_Collections.values():
+      if isinstance(collection, ToolCollection):
+        for tool in collection.tools:
+            all_tools.append(tool)
+      else:
+        for tool in collection:
+            all_tools.append(tool)
+
+    return all_tools
+
+def filter_tools(tools):
+    base_tools_names = ['web search']
+# dft_tools
+    # logging.warning(f"Filtering tools, excluding: {exclude_tool}")  # Log the exclusion
+    filtered_tools = [tool for tool in tools if tool.name not in  base_tools_names]
+    logging.warning(f"Number of tools after filtering: {len(filtered_tools)}") # Log the result
+    return filtered_tools
+
+additional_authorized_imports=["smolagents","subprocess","typing","os", "inspect","open", "requests"]
+
+
+litellm_api_keys = {
+    'xai': '',
+    'HF': '',
+    'grok': '',
+    'anthropic': '',
+    'openAI': '',
+    # ...
+}
+
+def get_litellm_api_key(key_name):
+    return litellm_api_keys.get(key_name, '')  
+
+def login_for_publication() :
+    login(publishtoken)
+
+
+def load_collection_from_space(agent : CodeAgent, collection_slug: str = "Mightypeacock/agent-tools-6777c9699c231b7a1e87fa31" ) -> ToolCollection:
+
+    if collection_slug not in tool_Collections:
+        tool_collection = ToolCollection(
+            collection_slug=collection_slug,
+            # token=publishtoken,
+            trust_remote_code=True
+        )
+        tool_Collections[collection_slug] = tool_collection
+
+        for tool in tool_collection.tools:
+            if agent.toolbox.tools.get(tool.name) is None:
+              agent.toolbox.add_tool(tool)
+            else:
+              agent.toolbox.update_tool(tool)
+
+    return all_tools()
+
+
+def createAgent():
+
+    agent = CodeAgent(
+        tools=filter_tools(all_tools()),
+        # all_tools(),#[tool for col in tool_Collections.values() for tool in col.tools],  # need to flatmap those probably
+        # tools=[],
+        # model=HfApiModel("microsoft/phi-4"),
+        # model=HfApiModel("Leonuraht/Phi-4"), #space
+
+        # model = LiteLLMModel(model_id=
+        #             # "gpt-4o"
+        #             "anthropic/claude-3-5-sonnet-20240620"
+        #             # xai/<any-model-on-xai> : grok-beta
+        # ),
+
+        model=HfApiModel(
+        #     # "lmstudio-community/phi-4-GGUF" #working
+            ),
+
+        additional_authorized_imports=additional_authorized_imports,
+        add_base_tools=True,
+        planning_interval=None,
+        # use_e2b_executor=True,
+        verbose=True
+
+        )
+
+    for tool in agent.toolbox.tools.values():
+        if tool not in all_tools():
+            if "base tools" not in tool_Collections:
+                tool_Collections["base tools"] = []
+
+            tool_Collections["base tools"].append(tool)
+
+    return agent
+

app.py

@@ -1,64 +1,234 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
+import random
+import time
+from io import StringIO
+import sys
+import pprint
+import inspect
+from HFHub import login_for_publication, litellm_api_keys, load_collection_from_space
+from HFHub import createAgent
+from typing import Dict
+import os
+import logging
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
 
+def dropdown_update_choices(elt, choices):
+    print(f"updating dropdown: {elt} with {choices}")
+    return gr.update(elt, choices=choices, value=None)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO) # not working (prints warnings tho)
+
+# os.environ['HF_TOKEN'] = "..."
+# hf_token = os.environ.get("HF_TOKEN")
+
+logging.warning('start')
+
+
+def process_logs(agent):
+    logs = ""
+    if hasattr(agent, 'logs'):
+        for entry in agent.logs:
+            if hasattr(entry, 'llm_output'):
+                logs += str(entry.llm_output) + "\n"
+        return logs
+    else:
+        return "The agent object does not have a valid 'logs' attribute or the attribute is not a list."
+
+def get_tools():
+    return [{"name": tool.name, "description": tool.description} for tool in agent.toolbox.tools.values()]
+
+def get_functions():
+    return agent.python_executor.custom_tools
+
+
+
+def get_function_code(selected_function_name):
+    func = get_functions().get(selected_function_name)
+    if func:
+        try:
+            return inspect.getsource(func)
+
+        except OSError:
+            return "Source code not available for this function."
+    return "Function not found."
+
+def get_tool_description(selected_tool_name, tools):
+    for tool in tools:
+        if tool["name"] == selected_tool_name:
+            return tool["description"]
+    return "No description available."
+
+
+def refresh_ui_elements():
+    
+    updated_tools = get_tools()
+    updated_functions = get_functions()
+
+    tool_names = [tool["name"] for tool in updated_tools]
+    function_names = list(updated_functions.keys())
+
+    print(function_names)
+    
+    current_tool = tool_names[0] if tool_names else None
+    current_function = function_names[0] if function_names else None
+
+    tool_description = get_tool_description(current_tool, updated_tools)
+
+    function_code = get_function_code(current_function) if current_function else ""
+
+    dropdown_update_choices(function_dropdown,function_names)
+    dropdown_update_choices(tool_dropdown,tool_names)
+
+    return (
+        tool_dropdown,
+        function_dropdown,
+        tool_description,
+        function_code
+    )
+
+
+def load_collection_andUploadUI(collection_slug: str ):
+    load_collection_from_space(agent,collection_slug)
+    refresh_ui_elements()
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column():
+            with gr.Tab("Chat"):
+                gr.Markdown("<center><h1>smolAgent chat</h1></center>")
+                chatbot = gr.Chatbot(type="messages")
+                msg = gr.Textbox()
+
+                send_button = gr.Button("Send")  # Send button
+
+                # send_button.click(respond, [msg, chatbot], [msg, chatbot])
+
+                clear = gr.ClearButton([msg, chatbot])
+
+            with gr.Tab("Console"):
+                outputbox = gr.Textbox(
+                    lines=25,
+                    scale=1,
+                    interactive=False
+                )
+
+            with gr.Tab("config"):
+
+                local_storage = gr.BrowserState(["", ""])
+                gr.Markdown("## Configure litellm API Keys")
+                api_key_inputs = {}
+                for provider in litellm_api_keys.keys():
+                    with gr.Row():
+                        api_key_inputs[provider] = gr.Textbox(
+                            label=f'{provider} API Key',
+                            placeholder='Enter key',
+                            type='password',
+                            value=litellm_api_keys[provider]
+                        )
+
+#TODO : save keys to localstorage
+
+                        # api_key_inputs[provider]
+                # save_keys_button = gr.Button('Save Configuration')
+
+
+                #         @gr.on(api_key_inputs[provider].change, inputs=[api_key_inputs[provider]], outputs=[local_storage])
+                #         def save_to_local_storage(text):
+                #             return [text]
+
+                # # Load from local storage when page loads
+                # @demo.load(inputs=[local_storage], outputs=[input_text])
+                # def load_from_local_storage(saved_values):
+                #     return saved_values[0]
+
+
+
+        with gr.Column():
+            gr.Markdown("<center><h1>tool collection</h1></center>")
+
+
+            tools = get_tools()
+            tool_dropdown = gr.Dropdown(
+                show_label=False,
+                choices=[tool["name"] for tool in tools],
+                value=tools[0]["name"] if tools else None,
+                type="value",
+                allow_custom_value=False,
+                scale=3
+            )
+
+            description_textbox = gr.Textbox(
+                label="Tool Description",
+                value=get_tool_description(tool_dropdown.value, tools),
+                interactive=False,
+            )
+
+            slug = gr.Textbox(label="collection slug",value="Mightypeacock/agent-tools-6777c9699c231b7a1e87fa31")
+            greet_btn = gr.Button("Load")
+            greet_btn.click(fn=load_collection_from_space, inputs=slug,
+                            # outputs=tool_dropdown,
+                            outputs=None,
+                            api_name="load_HF_Collection")
+
+
+            gr.Markdown("<center><h2>Functions</h2></center>")
+            functions = get_functions()
+            function_dropdown = gr.Dropdown(
+                label="Select Function",
+                choices=list(functions.keys()),
+                value=None if not functions.keys() else list(functions.keys())[0],
+                type="value",
+            )
+
+            code = gr.Code(label="Function Code", language="python")
+
+            tool_dropdown.change(
+                fn=get_tool_description,
+                inputs=[tool_dropdown, gr.State(tools)],
+                outputs=description_textbox,
+            )
+
+            function_dropdown.change(
+                fn=get_function_code,
+                inputs=function_dropdown,
+                outputs=code,
+            )
+
+    def respond(message, console_output, chat_history):
+        try:
+            print(f"Received message: {message}")
+
+            if not isinstance(message, str):
+                message = str(message)
+
+            bot_message = agent.run(message)
+            new_console_output = process_logs(agent)
+
+            print(f"Agent response: {bot_message}")
+            print(f"Console output: {new_console_output}")
+
+            chat_history.extend([
+                {"role": "user", "content": message},
+                {"role": "assistant", "content": bot_message}
+            ])
+
+            updated_console = console_output + f"\nQuery: {message}\nLogs: {new_console_output}"
+
+            tool_dropdown_update, function_dropdown_update, description_update, code_update = refresh_ui_elements()
+            return "", updated_console, chat_history, tool_dropdown_update, function_dropdown_update, description_update, code_update
+
+        except Exception as e:
+            print(f"Error in respond function: {e}")
+            return f"An error occurred: {str(e)}", console_output, chat_history, None, None, None, None
+
+    msg.submit(
+        respond,
+        inputs=[msg, outputbox, chatbot],
+        outputs=[msg, outputbox, chatbot, tool_dropdown, function_dropdown, description_textbox, code]
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    agent = createAgent()
+    demo.launch(show_error=True, debug=True)

requirements.txt

@@ -1 +1,5 @@
-huggingface_hub==0.25.2
+huggingface_hub==0.25.2
+git+https://github.com/Brunwo/smolagents
+huggingface_hub
+
+litellm