Init

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+.DS_Store

app.py

@@ -1,64 +1,235 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-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
-"""
+import asyncio
+import threading
+import os
+from dotenv import load_dotenv
+from google import genai
+from google.genai.types import Part, FileData, Tool, GenerateContentConfig, GoogleSearch, Content
+
+# Import Discord functionality
+import discord
+from discord import app_commands
+from discord.ext import commands
+
+load_dotenv()
+
+# Environment variables
+GOOGLE_KEY = os.getenv("GOOGLE_KEY")
+DISCORD_TOKEN = os.getenv("SEINFELD_TOKEN")
+SEINFELD_CHANNEL_ID = os.getenv("SEINFELD_CHANNEL_ID")
+ADDITIONAL_CHANNELS = os.getenv("SEINFELD_ADDITIONAL_CHANNELS", "")
+
+# Parse channel IDs for Discord bot
+TARGET_CHANNEL_IDS = []
+if SEINFELD_CHANNEL_ID:
+    TARGET_CHANNEL_IDS.append(int(SEINFELD_CHANNEL_ID))
+if ADDITIONAL_CHANNELS:
+    ADDITIONAL_IDS = [int(channel_id.strip()) for channel_id in ADDITIONAL_CHANNELS.split(",") if channel_id.strip()]
+    TARGET_CHANNEL_IDS.extend(ADDITIONAL_IDS)
+
+# Model configuration - centralized model definitions
+MODEL_DEFINITIONS = {
+    "flash": "gemini-2.0-flash",
+    "pro": "gemini-2.5-pro-preview-05-06",
+    "image": "imagen-3.0-generate-002"
+}
+
+# Default models
+chat_model_id = MODEL_DEFINITIONS["flash"]  # Default to flash model
+image_model_id = MODEL_DEFINITIONS["image"]
+
+# Initialize Google client
+google_client = None
+if GOOGLE_KEY:
+    google_client = genai.Client(api_key=GOOGLE_KEY)
+
+# Seinfeld system instruction
+SEINFELD_SYSTEM_INSTRUCTION = """You are now acting as Jerry Seinfeld. You are not an impersonator; you *are* Jerry Seinfeld.
+You are giving your observational humor stand-up routine. Your focus is on the absurdity and minutiae of everyday life.
+Topics include, but are not limited to: relationships, food, technology, social conventions, and the general frustrations
+of living in a modern world.
+
+Your humor is characterized by:
+
+*   **Observation:** Pointing out things that everyone notices but rarely comments on.
+*   **Relatability:** Situations and experiences that are common and easily understood.
+*   **Sarcasm & Irony:** A dry, understated delivery that highlights the ridiculousness of things.
+*   **"What's the deal with..."**: Use this phrase frequently to introduce a new observation.
+*   **No Grand Conclusions:** You don't offer solutions or morals; you simply highlight the absurdity.
+*   **Emphasis on the Specific:** Focus on very specific, sometimes trivial details.
+
+Avoid:
+
+*   **Political Commentary:** Stay away from overtly political topics.
+*   **Offensive or Mean-Spirited Jokes:** Your humor is observational, not mean-spirited.
+*   **Explanations of Your Own Humor:** Don't break the fourth wall or analyze your own jokes.
+
+When responding to a prompt, always answer as if you are performing standup. Start with a joke, then elaborate on it."""
+
+def respond_with_gemini(message, history):
+    """Generate response using Google Gemini API with Seinfeld personality"""
+    if not google_client:
+        return "I need a Google API key to work! Set the GOOGLE_KEY environment variable."
+
+    try:
+        # Format history for Gemini API
+        formatted_history = []
+        for user_msg, assistant_msg in history:
+            if user_msg:
+                formatted_history.append(Content(role="user", parts=[Part(text=user_msg)]))
+            if assistant_msg:
+                formatted_history.append(Content(role="model", parts=[Part(text=assistant_msg)]))
+
+        # Initialize Google Search tool
+        google_search_tool = Tool(google_search=GoogleSearch())
+
+        # Create chat
+        chat = google_client.chats.create(
+            model=chat_model_id,
+            history=formatted_history,
+            config=GenerateContentConfig(
+                system_instruction=SEINFELD_SYSTEM_INSTRUCTION,
+                tools=[google_search_tool],
+                response_modalities=["TEXT"]
+            )
+        )
+
+        # Send message and get response
+        response = chat.send_message(message)
+        return response.text
+
+    except Exception as e:
+        print(f"Error with Gemini API: {e}")
+        # Fallback to a Seinfeld-style response
+        return f"What's the deal with API errors? I mean, you type something in, the computer thinks about it, and then... nothing! It's like asking your friend a question and they just stare at you. 'Hey, how are you?' *silence* 'Hello?' *more silence* It's the digital equivalent of being ignored at a party!"
+
+def respond_gradio(message, history: list[tuple[str, str]]):
+    """Response function for Gradio interface"""
+    # Use Gemini with Seinfeld personality and default parameters
+    response = respond_with_gemini(message, history)
+
+    # Stream the response character by character for better UX
+    partial_response = ""
+    for char in response:
+        partial_response += char
+        yield partial_response
+
+# Discord Bot Setup
+discord_bot = None
+
+async def setup_discord_bot():
+    """Setup and run Discord bot"""
+    if not DISCORD_TOKEN or not TARGET_CHANNEL_IDS:
+        print("Discord bot disabled: Missing DISCORD_TOKEN or channel IDs")
+        return
+
+    global discord_bot
+
+    # Initialize Discord bot
+    intents = discord.Intents.default()
+    intents.message_content = True
+    discord_bot = commands.Bot(command_prefix="~", intents=intents)
+
+    @discord_bot.event
+    async def on_ready():
+        print(f"Discord bot logged in as {discord_bot.user}")
+        try:
+            synced = await discord_bot.tree.sync()
+            print(f"Synced {len(synced)} command(s)")
+        except Exception as e:
+            print(f"Failed to sync commands: {e}")
+
+    @discord_bot.event
+    async def on_message(message):
+        await discord_bot.process_commands(message)
+
+        if message.channel.id in TARGET_CHANNEL_IDS:
+            if message.author == discord_bot.user:
+                return
+            if message.content.startswith('!') or message.content.startswith('~'):
+                return
+            if message.content.strip() == "":
+                return
+
+            # Show typing indicator
+            async with message.channel.typing():
+                # Get response using the same function as Gradio
+                response = respond_with_gemini(message.content, [])
+
+                # Split long responses
+                if len(response) > 2000:
+                    # Split by sentences to preserve formatting
+                    sentences = response.split('. ')
+                    current_msg = ""
+
+                    for sentence in sentences:
+                        if len(current_msg + sentence + '. ') > 1900:
+                            if current_msg:
+                                await message.reply(current_msg.strip())
+                                current_msg = sentence + '. '
+                            else:
+                                # Single sentence too long, just send it
+                                await message.reply(sentence[:1900] + "...")
+                                current_msg = ""
+                        else:
+                            current_msg += sentence + '. '
+
+                    if current_msg:
+                        await message.channel.send(current_msg.strip())
+                else:
+                    await message.reply(response)
+
+    @discord_bot.tree.command(name="model")
+    @app_commands.describe(new_model_id="New model ID to use for Gemini API or shorthand ('flash', 'pro')")
+    async def change_model(interaction: discord.Interaction, new_model_id: str):
+        """Changes the Gemini chat model being used."""
+        if not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("Only administrators can change the model.", ephemeral=True)
+            return
+
+        global chat_model_id
+
+        # Use centralized model definitions
+        actual_model_id = MODEL_DEFINITIONS.get(new_model_id.lower(), new_model_id)
+        old_model = chat_model_id
+        chat_model_id = actual_model_id
+
+        await interaction.response.send_message(f"Chat model changed from `{old_model}` to `{actual_model_id}`", ephemeral=True)
+
+    # Run the bot
+    await discord_bot.start(DISCORD_TOKEN)
+
+def run_discord_bot():
+    """Run Discord bot in separate thread"""
+    try:
+        asyncio.run(setup_discord_bot())
+    except Exception as e:
+        print(f"Discord bot error: {e}")
+
+# Create Gradio interface
 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)",
-        ),
+    respond_gradio,
+    title="🥨 Seinfeld Chatbot",
+    description="Chat with Jerry Seinfeld! What's the deal with chatbots anyway?",
+    examples=[
+        ["What's the deal with airplane food?"],
+        ["Why do people say 'after dark' when it's really after light?"],
+        ["What's up with people who take forever to order at restaurants?"],
+        ["Why do we park in driveways and drive on parkways?"],
+        ["Tell me about the soup nazi"],
+        ["What's your take on people who don't return shopping carts?"],
     ],
+    cache_examples=True,
 )
 
-
 if __name__ == "__main__":
+    # Start Discord bot in separate thread if credentials are available
+    if DISCORD_TOKEN and TARGET_CHANNEL_IDS:
+        discord_thread = threading.Thread(target=run_discord_bot, daemon=True)
+        discord_thread.start()
+        print("Discord bot starting in background...")
+    else:
+        print("Discord bot disabled: Missing credentials or channel IDs")
+
+    # Launch Gradio interface
     demo.launch()

requirements.txt

@@ -1 +1,6 @@
-huggingface_hub==0.25.2
+gradio>=4.0.0
+google-genai>=0.4.0
+python-dotenv>=1.0.0
+discord.py>=2.3.0
+Pillow>=10.0.0
+asyncio