Update app.py

app.py

@@ -1,121 +1,44 @@
-from dotenv import load_dotenv
-from openai import OpenAI
-import json
-import os
-import requests
-from PyPDF2 import PdfReader
-import gradio as gr
-import gdown
-from datetime import datetime
-from pathlib import Path
-import zipfile
-
-load_dotenv(override=True)
-
-def push(text):
-    try:
-        requests.post(
-            "https://api.pushover.net/1/messages.json",
-            data={
-                "token": os.getenv("PUSHOVER_TOKEN"),
-                "user": os.getenv("PUSHOVER_USER"),
-                "message": text,
-            }
-        )
-    except Exception as e:
-        print(f"Pushover error: {e}")
-
-def record_user_details(email, name="Name not provided", notes="not provided"):
-    push(f"Recording {name} with email {email} and notes {notes}")
-    return {"recorded": "ok"}
-
-def record_unknown_question(question):
-    push(f"Recording {question}")
-    return {"recorded": "ok"}
-
-record_user_details_json = {
-    "name": "record_user_details",
-    "description": "Use this tool to record that a user is interested in being in touch and provided an email address",
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "email": {"type": "string"},
-            "name": {"type": "string"},
-            "notes": {"type": "string"}
-        },
-        "required": ["email"],
-        "additionalProperties": False
-    }
-}
-
-record_unknown_question_json = {
-    "name": "record_unknown_question",
-    "description": "Record a question that couldn't be answered",
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "question": {"type": "string"}
-        },
-        "required": ["question"],
-        "additionalProperties": False
-    }
-}
-
-tools = [
-    {"type": "function", "function": record_user_details_json},
-    {"type": "function", "function": record_unknown_question_json}
-]
-
-class Me:
-    def __init__(self):
-        self.openai = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-        self.name = "Jacob Isaacson"
-        self.session_log = []
-        Path("chat_logs").mkdir(exist_ok=True)
-
-        gdown.download("https://drive.google.com/uc?id=1xz2RowkImpI8odYv8zvKdlRHaKfILn40", "linkedin.pdf", quiet=False)
-        reader = PdfReader("linkedin.pdf")
-        self.linkedin = "".join(page.extract_text() or "" for page in reader.pages)
-
-        gdown.download("https://drive.google.com/uc?id=1hjJz082YFSVjFtpO0pwT6Tyy3eLYYj6-", "summary.txt", quiet=False)
-        with open("summary.txt", "r", encoding="utf-8") as f:
-            self.summary = f.read()
-
-        self.archive_logs()
-
-    def system_prompt(self):
-        return f"""You are acting as {self.name}. You're answering questions on {self.name}'s website about his career, experience, and skills.
-Be professional and conversational, as if talking to a potential employer or client.
-
-If you can't answer something, call `record_unknown_question`. If a user seems interested, ask for their email and use `record_user_details`.
-
-## Summary:
-{self.summary}
-
-## LinkedIn Profile:
-{self.linkedin}
-"""
+def chat_stream(self, message, history):
+    messages = [{"role": "system", "content": self.system_prompt()}]
+    for msg in history:
+        if isinstance(msg, dict) and msg.get("role") in ["user", "assistant"]:
+            messages.append(msg)
+
+    messages.append({"role": "user", "content": message})
+    self.session_log.append({"role": "user", "content": message})
+
+    # First non-streamed call to check for tool calls
+    response = self.openai.chat.completions.create(
+        model="gpt-4o",
+        messages=messages,
+        tools=tools,
+        stream=False  # Check for tool calls
+    )
 
-    def handle_tool_call(self, tool_calls):
-        results = []
-        for tool_call in tool_calls:
-            tool_name = tool_call.function.name
-            arguments = json.loads(tool_call.function.arguments)
-            tool = globals().get(tool_name)
-            result = tool(**arguments) if tool else {}
-            results.append({"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result)})
-        return results
+    reply = response.choices[0].message
 
-    def chat_stream(self, message, history):
-        messages = [{"role": "system", "content": self.system_prompt()}]
+    if reply.tool_calls:
+        tool_results = self.handle_tool_call(reply.tool_calls)
+        messages.append(reply)
+        messages.extend(tool_results)
 
-        for msg in history:
-            if isinstance(msg, dict) and msg.get("role") in ["user", "assistant"]:
-                messages.append(msg)
+        # Retry final response after tool call
+        final_response = self.openai.chat.completions.create(
+            model="gpt-4o",
+            messages=messages,
+            tools=tools,
+            stream=True
+        )
 
-        messages.append({"role": "user", "content": message})
-        self.session_log.append({"role": "user", "content": message})
+        full_response = ""
+        for chunk in final_response:
+            delta = chunk.choices[0].delta
+            if hasattr(delta, "content") and delta.content:
+                full_response += delta.content
+                yield full_response
 
+    else:
+        # Normal streaming response
         stream = self.openai.chat.completions.create(
             model="gpt-4o",
             messages=messages,
@@ -130,36 +53,8 @@ If you can't answer something, call `record_unknown_question`. If a user seems i
                 full_response += delta.content
                 yield full_response
 
-        full_response += "\n\n💬 Let me know if you’d like to follow up or need help connecting with Jacob."
-
-        self.session_log.append({"role": "assistant", "content": full_response})
-        self.save_session_log()
-
-    def save_session_log(self):
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"chat_logs/session_{timestamp}.json"
-        with open(filename, "w", encoding="utf-8") as f:
-            json.dump(self.session_log, f, indent=2)
-
-    def archive_logs(self):
-        zip_path = "chat_logs/weekly_archive.zip"
-        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as archive:
-            for log_file in Path("chat_logs").glob("session_*.json"):
-                archive.write(log_file, arcname=log_file.name)
-
-me = Me()
-
-with gr.Blocks(title="Jacob Isaacson Chatbot") as iface:
-    with gr.Row():
-        gr.Image("jacob.png", width=100, show_label=False)
-        gr.Markdown("### Chat with Jacob Isaacson\nAsk about Jacob's background, skills, or career. \n🛡️ *All chats are logged for improvement purposes.*")
-
-    gr.ChatInterface(
-        fn=me.chat_stream,
-        chatbot=gr.Chatbot(show_copy_button=True),
-        examples=["What is Jacob's experience with AI?", "Tell me about his recent projects."],
-        type="messages"
-    )
+    # Always add follow-up message
+    full_response += "\n\n💬 Let me know if you’d like to follow up or need help connecting with Jacob."
+    self.session_log.append({"role": "assistant", "content": full_response})
+    self.save_session_log()
 
-if __name__ == "__main__":
-    iface.launch()