Allow tool selection during assistant setup or subsequent assistant update

Author: chriscarrollsmith

routers/chat.py

@@ -1,8 +1,7 @@
 import logging
 import time
 from datetime import datetime
-from typing import Any, AsyncGenerator, Dict, List, Optional, Union, cast
-from dataclasses import dataclass
+from typing import AsyncGenerator, Optional, Union
 from fastapi.templating import Jinja2Templates
 from fastapi import APIRouter, Form, Depends, Request
 from fastapi.responses import StreamingResponse, HTMLResponse
@@ -13,50 +12,18 @@
     ThreadRunRequiresAction, ThreadRunStepCreated, ThreadRunStepDelta
 )
 from openai.types.beta import AssistantStreamEvent
-from openai.types.beta.threads.run_submit_tool_outputs_params import ToolOutput
 from openai.types.beta.threads.run import RequiredAction
 from openai.types.beta.threads.message_content_delta import MessageContentDelta
 from openai.types.beta.threads.text_delta_block import TextDeltaBlock
 from fastapi.responses import StreamingResponse
-from fastapi import APIRouter, Depends, Form, HTTPException
-from pydantic import BaseModel
+from fastapi import APIRouter, Depends, Form
 
 import json
 
-from utils.custom_functions import get_weather
+from utils.custom_functions import get_weather, post_tool_outputs
 from utils.sse import sse_format
+from utils.streaming import AssistantStreamMetadata
 
-@dataclass
-class AssistantStreamMetadata:
-    """Metadata for assistant stream events that require further processing."""
-    type: str  # Always "metadata"
-    required_action: Optional[RequiredAction]
-    step_id: str
-    run_requires_action_event: Optional[ThreadRunRequiresAction]
-
-    @classmethod
-    def create(cls, 
-               required_action: Optional[RequiredAction],
-               step_id: str,
-               run_requires_action_event: Optional[ThreadRunRequiresAction]
-    ) -> "AssistantStreamMetadata":
-        """Factory method to create a metadata instance with validation."""
-        return cls(
-            type="metadata",
-            required_action=required_action,
-            step_id=step_id,
-            run_requires_action_event=run_requires_action_event
-        )
-
-    def requires_tool_call(self) -> bool:
-        """Check if this metadata indicates a required tool call."""
-        return (self.required_action is not None 
-                and self.required_action.submit_tool_outputs is not None 
-                and bool(self.required_action.submit_tool_outputs.tool_calls))
-
-    def get_run_id(self) -> str:
-        """Get the run ID from the requires action event, or empty string if none."""
-        return self.run_requires_action_event.data.id if self.run_requires_action_event else ""
 
 logger: logging.Logger = logging.getLogger("uvicorn.error")
 logger.setLevel(logging.DEBUG)
@@ -70,43 +37,6 @@ def get_run_id(self) -> str:
 # Jinja2 templates
 templates = Jinja2Templates(directory="templates")
 
-# Utility function for submitting tool outputs to the assistant
-class ToolCallOutputs(BaseModel):
-    tool_outputs: Dict[str, Any]
-    runId: str
-
-async def post_tool_outputs(client: AsyncOpenAI, data: Dict[str, Any], thread_id: str) -> AsyncAssistantStreamManager:
-    """
-    data is expected to be something like
-    {
-      "tool_outputs": {
-        "output": [{"location": "City", "temperature": 70, "conditions": "Sunny"}],
-        "tool_call_id": "call_123"
-      },
-      "runId": "some-run-id",
-    }
-    """
-    try:
-        outputs_list = [
-            ToolOutput(
-                output=str(data["tool_outputs"]["output"]),
-                tool_call_id=data["tool_outputs"]["tool_call_id"]
-            )
-        ]
-
-
-        stream_manager = client.beta.threads.runs.submit_tool_outputs_stream(
-            thread_id=thread_id,
-            run_id=data["runId"],
-            tool_outputs=outputs_list,
-        )
-
-        return stream_manager
-
-    except Exception as e:
-        logger.error(f"Error submitting tool outputs: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
 
 # Route to submit a new user message to a thread and mount a component that
 # will start an assistant run stream

routers/files.py

@@ -1,15 +1,18 @@
 import os
 import logging
-from typing import List, Dict, Any, AsyncIterable
+from typing import List, Dict
 from dotenv import load_dotenv
 from fastapi import APIRouter, Request, UploadFile, File, HTTPException, Depends, Form, Path
 from fastapi.responses import StreamingResponse
 from openai import AsyncOpenAI
+from openai.types.file_purpose import FilePurpose
+from utils.files import get_or_create_vector_store
+from utils.streaming import stream_file_content
 
 logger = logging.getLogger("uvicorn.error")
 
 # Get assistant ID from environment variables
-load_dotenv()
+load_dotenv(override=True)
 assistant_id_env = os.getenv("ASSISTANT_ID")
 if not assistant_id_env:
     raise ValueError("ASSISTANT_ID environment variable not set")
@@ -20,21 +23,8 @@
     tags=["assistants_files"]
 )
 
-# Helper function to get or create a vector store
-async def get_or_create_vector_store(assistantId: str, client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())) -> str:
-    assistant = await client.beta.assistants.retrieve(assistantId)
-    if assistant.tool_resources and assistant.tool_resources.file_search and assistant.tool_resources.file_search.vector_store_ids:
-        return assistant.tool_resources.file_search.vector_store_ids[0]
-    vector_store = await client.vector_stores.create(name="sample-assistant-vector-store")
-    await client.beta.assistants.update(
-        assistantId,
-        tool_resources={
-            "file_search": {
-                "vector_store_ids": [vector_store.id],
-            },
-        }
-    )
-    return vector_store.id
+
+#TODO: Correctly return HTML, not JSON, from the routes below
 
 @router.get("/")
 async def list_files(client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())) -> List[Dict[str, str]]:
@@ -57,14 +47,16 @@ async def list_files(client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())) -> Li
             })
     return files_array
 
+
+# Take a purpose parameter, defaulting to "assistants"
 @router.post("/")
-async def upload_file(file: UploadFile = File(...)) -> Dict[str, str]:
+async def upload_file(file: UploadFile = File(...), purpose: FilePurpose = Form(default="assistants")) -> Dict[str, str]:
     try:
         client = AsyncOpenAI()
         vector_store_id = await get_or_create_vector_store(assistant_id)
         openai_file = await client.files.create(
             file=file.file,
-            purpose="assistants"
+            purpose=purpose
         )
         await client.vector_stores.files.create(
             vector_store_id=vector_store_id,
@@ -74,11 +66,25 @@ async def upload_file(file: UploadFile = File(...)) -> Dict[str, str]:
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-async def stream_file_content(content: bytes) -> AsyncIterable[bytes]:
-    yield content
+
+@router.delete("/delete")
+async def delete_file(
+    request: Request, 
+    fileId: str = Form(...), 
+    client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())
+) -> Dict[str, str]:
+    vector_store_id = await get_or_create_vector_store(assistant_id, client)
+    await client.vector_stores.files.delete(vector_store_id=vector_store_id, file_id=fileId)
+    return {"message": "File deleted successfully"}
+
+
+# --- Streaming file content ---
+
+
+
 
 @router.get("/{file_id}")
-async def get_file(
+async def download_assistant_file(
     file_id: str = Path(..., description="The ID of the file to retrieve"),
     client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())
 ) -> StreamingResponse:
@@ -96,18 +102,9 @@ async def get_file(
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@router.delete("/delete")
-async def delete_file(
-    request: Request, 
-    fileId: str = Form(...), 
-    client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())
-) -> Dict[str, str]:
-    vector_store_id = await get_or_create_vector_store(assistant_id, client)
-    await client.vector_stores.files.delete(vector_store_id=vector_store_id, file_id=fileId)
-    return {"message": "File deleted successfully"}
 
 @router.get("/{file_id}/content")
-async def get_file_content(
+async def get_assistant_image_content(
     file_id: str,
     client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())
 ) -> StreamingResponse:
@@ -119,7 +116,7 @@ async def get_file_content(
         # Get the file content from OpenAI
         file_content = await client.files.content(file_id)
         file_bytes = file_content.read()  # Remove await since read() returns bytes directly
-        
+
         # Return the file content as a streaming response
         # Note: In a production environment, you might want to add caching
         return StreamingResponse(

routers/setup.py

@@ -1,13 +1,14 @@
 import logging
 import os
-from typing import Optional
+from typing import Optional, List
 from dotenv import load_dotenv
 from fastapi import APIRouter, Depends, HTTPException, Form, Request
 from fastapi.responses import RedirectResponse, Response
 from fastapi.templating import Jinja2Templates
 from openai import AsyncOpenAI
+from openai.types.beta import Assistant
 
-from utils.create_assistant import create_or_update_assistant, request as assistant_create_request
+from utils.create_assistant import create_or_update_assistant, ToolTypes
 from utils.create_assistant import update_env_file
 
 # Configure logger
@@ -45,27 +46,44 @@ async def set_openai_api_key(api_key: str = Form(...)) -> RedirectResponse:
 
 # Add new setup route
 @router.get("/")
-async def read_setup(request: Request, message: Optional[str] = "") -> Response:
+async def read_setup(
+    request: Request,
+    client: AsyncOpenAI = Depends(lambda: AsyncOpenAI()),
+    message: Optional[str] = ""
+) -> Response:
     # Check if assistant ID is missing
+    current_tools = []
     load_dotenv(override=True)
     openai_api_key = os.getenv("OPENAI_API_KEY")
     assistant_id = os.getenv("ASSISTANT_ID")
 
     if not openai_api_key:
         message = "OpenAI API key is missing."
-    elif not assistant_id:
-        message = "Assistant ID is missing."
     else:
-        message = "All set up!"
+        if assistant_id:
+            try:
+                assistant = await client.beta.assistants.retrieve(assistant_id)
+                current_tools = [tool.type for tool in assistant.tools]
+            except Exception as e:
+                logger.error(f"Failed to retrieve assistant {assistant_id}: {e}")
+                # If we can't retrieve the assistant, proceed as if it doesn't exist
+                assistant_id = None
+                message = "Error retrieving existing assistant. Please create a new one."
 
     return templates.TemplateResponse(
         "setup.html",
-        {"request": request, "message": message}
+        {
+            "request": request,
+            "message": message,
+            "assistant_id": assistant_id,
+            "current_tools": current_tools
+        }
     )
 
 
 @router.post("/assistant")
 async def create_update_assistant(
+    tool_types: List[ToolTypes] = Form(...),
     client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())
 ) -> RedirectResponse:
     """
@@ -76,7 +94,7 @@ async def create_update_assistant(
     new_assistant_id = await create_or_update_assistant(
         client=client,
         assistant_id=current_assistant_id,
-        request=assistant_create_request,
+        tool_types=tool_types,
         logger=logger
     )
 

static/styles.css

@@ -19,6 +19,7 @@ body {
 }
 
 body {
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
   color: rgb(var(--foreground-rgb));
 }
 
@@ -57,16 +58,8 @@ pre {
 .logo {
   width: 32px;
   height: 32px;
-  position: absolute;
-  margin: 16px;
-  top: 0;
-  right: 0;
-}
-
-@media (max-width: 1100px) {
-  .logo {
-    display: none;
-  }
+  filter: invert(100%) sepia(0%) saturate(0%) hue-rotate(0deg) brightness(100%) contrast(100%);
+  /* Removed absolute positioning, handled by nav flexbox */
 }
 
 .main {
@@ -576,3 +569,52 @@ pre {
     border-radius: 0.5rem;
     box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
 }
+
+.checkboxGroup {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  margin-bottom: 1rem;
+}
+
+.checkboxGroup label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.errorMessage {
+  color: #e53e3e;
+  font-size: 0.875rem;
+}
+
+/* --- Nav --- */
+.nav {
+  position: relative; /* Context for absolute logo if needed later */
+  display: flex;
+  align-items: center; /* Vertically center items */
+  justify-content: flex-end; /* Pushes items to the right */
+  gap: 16px; /* Space between nav-links div and logo */
+  padding: 16px; /* Match logo margin */
+  height: 64px; /* Logo height (32) + top/bottom padding (16*2) */
+  box-sizing: border-box;
+  width: 100%;
+  background-color: #000; /* Black background */
+  border-bottom: 1px solid #eee; /* Optional: separator */
+}
+
+.nav-links {
+    display: flex;
+    gap: 16px; /* Space between links */
+}
+
+.nav a {
+  color: white;
+  font-weight: bold;
+  text-decoration: none;
+}
+
+.nav a:hover {
+  text-decoration: underline;
+}
+/* --- End Nav --- */