splitwise-mcp 0.1.0__py3-none-any.whl

splitwise_mcp/agent/audio.py

@@ -0,0 +1,105 @@
+import sounddevice as sd
+import numpy as np
+import scipy.io.wavfile as wav
+import tempfile
+import os
+from deepgram import DeepgramClient
+
+class AudioTranscriber:
+    def __init__(self):
+        # Initialize Deepgram client
+        api_key = os.getenv("DEEPGRAM_API_KEY")
+        if not api_key:
+             raise ValueError("Missing DEEPGRAM_API_KEY in .env")
+        self.client = DeepgramClient(api_key=api_key)
+
+    def record_audio(self, duration=10, sample_rate=44100):
+        """
+        Record audio from the microphone for a fixed duration.
+        Returns the path to the temporary WAV file.
+        """
+        print(f"🎤 Recording for {duration} seconds... (Speak now!)")
+        
+        recording = sd.rec(int(duration * sample_rate), samplerate=sample_rate, channels=1)
+        sd.wait()  # Wait until recording is finished
+        
+        print("✅ Recording finished.")
+        
+        # Save to temp file
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_audio:
+            wav.write(temp_audio.name, sample_rate, recording)
+            return temp_audio.name
+
+    def transcribe_bytes(self, buffer_data):
+        """
+        Transcribes audio bytes directly.
+        """
+        print("📝 Transcribing bytes with Deepgram...")
+        
+        # v5.x: Pass bytes as 'request' kwarg, and options as kwargs
+        response = self.client.listen.v1.media.transcribe_file(
+            request=buffer_data, 
+            model="nova-2", 
+            smart_format=True, 
+            language="en"
+        )
+        
+        transcript = response.results.channels[0].alternatives[0].transcript
+        return transcript
+
+    def generate_speech(self, text):
+        """
+        Generates speech from text using Deepgram Aura (TTS).
+        Returns raw audio bytes (mp3).
+        """
+        print(f"🗣️ Generating speech for: {text[:50]}...")
+        # Deepgram TTS (Aura)
+        SPEAK_OPTIONS = {"text": text}
+        # Model: aura-asteria-en (Female) or aura-orion-en (Male)
+        # Using Asteria for a friendly assistant voice
+        options = {
+            "model": "aura-asteria-en",
+            "encoding": "mp3",
+        }
+        
+        # Save to a temporary file is standard, but keeping in memory is better for Streamlit
+        # Deepgram SDK .save method saves to file. 
+        # We can use .stream? Or just save to temp and read back.
+        
+        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_tts:
+             filename = temp_tts.name
+        
+        # self.client.speak.v("1").save... failed (attribute error).
+        # We found self.client.speak.v1.audio.generate exists.
+        
+        response = self.client.speak.v1.audio.generate(SPEAK_OPTIONS, options)
+        
+        # Check if response handles saving (SDK wrapper) or if we need to write bytes
+        if hasattr(response, "save"):
+            response.save(filename)
+        elif hasattr(response, "content"):
+            with open(filename, "wb") as f:
+                f.write(response.content)
+        else:
+            # Assume it is bytes directly
+            with open(filename, "wb") as f:
+                f.write(response)
+        
+        with open(filename, "rb") as f:
+            audio_bytes = f.read()
+            
+        os.remove(filename) # Clean up
+        return audio_bytes
+
+    def transcribe(self, audio_path):
+        """
+        Transcribes the audio file using Deepgram.
+        """
+        print("📝 Transcribing with Deepgram...")
+        with open(audio_path, "rb") as audio:
+             buffer_data = audio.read()
+        return self.transcribe_bytes(buffer_data)
+
+    def cleanup(self, audio_path):
+        if os.path.exists(audio_path):
+            os.remove(audio_path)

splitwise_mcp/agent/client.py

@@ -0,0 +1,281 @@
+import os
+import json
+from google import genai
+from google.genai import types
+from splitwise_mcp.client import SplitwiseClient
+from colorama import Fore, Style
+
+class GeminiSplitwiseAgent:
+    def __init__(self):
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+             raise ValueError("Missing GEMINI_API_KEY in .env")
+        
+        self.client = genai.Client(api_key=api_key)
+        self.splitwise = SplitwiseClient()
+        self.model_name = "gemini-3-flash-preview"
+        
+        # Tools definitions
+        self.tool_functions = {
+            "add_expense": self._add_expense_impl,
+            "list_friends": self._list_friends_impl,
+            "delete_expense": self._delete_expense_impl,
+            "_add_expense_impl": self._add_expense_impl,
+            "_list_friends_impl": self._list_friends_impl,
+            "_delete_expense_impl": self._delete_expense_impl
+        }
+        
+        # Pre-load friends and groups for context
+        print(f"{Fore.CYAN}👥 Pre-loading friends and groups...{Style.RESET_ALL}")
+        try:
+            friends = self.splitwise.get_friends()
+            self.friend_list_str = ", ".join([f"{f.getFirstName()} {f.getLastName()} (ID: {f.getId()})" for f in friends])
+            
+            groups = self.splitwise.get_groups()
+            self.group_list_str = ", ".join([f"{g.getName()} (ID: {g.getId()})" for g in groups])
+        except Exception as e:
+            print(f"{Fore.RED}⚠️ Failed to pre-load data: {e}{Style.RESET_ALL}")
+            self.friend_list_str = "Could not load friends."
+            self.group_list_str = "Could not load groups."
+
+        system_prompt = (
+            "You are a helpful assistant that manages Splitwise expenses.\n"
+            f"Here is the user's current friend list: [{self.friend_list_str}].\n"
+            f"Here is the user's current group list: [{self.group_list_str}].\n"
+            "Rules:\n"
+            "1. If the transcribed name does NOT exactly match a friend's name in the list, "
+            "you MUST ask for clarification. For example, if user says 'Humeet' but you have 'Sumeet' in the list, "
+            "ask 'Did you mean Sumeet?' Do NOT assume phonetic matches.\n"
+            "2. If the name is completely not found, ask the user to spell it again.\n"
+            "3. Do NOT guess friend IDs. Only use IDs from the list above.\n"
+            "4. If the user wants to add an expense, call 'add_expense' with the matched friend names.\n"
+            "5. If the user specifies unequal splits (e.g. 'I owe 10, Sumeet owes 20', or 'Split 50/50%'), use 'split_map'. "
+            "Map 'me' or 'I' to the user's share, and friend names to their share (amounts or percentages).\n"
+            "6. If the user mentions a group (e.g. 'add to Apartment group'), use 'group_name'. Match against the group list above.\n"
+            "7. If the user specifies who paid (e.g. 'Alice paid'), use 'payer_name'. Default is YOU paid.\n"
+            "8. If excluding someone from a group expense, use 'exclude_names'.\n"
+            "9. To delete an expense, use 'delete_expense' with the ID (if known) or ask user for it.\n"
+            "10. Be concise and conversational."
+        )
+
+        # Create chat session
+        self.chat = self.client.chats.create(
+            model=self.model_name,
+            config=types.GenerateContentConfig(
+                tools=[self._add_expense_impl, self._list_friends_impl, self._delete_expense_impl],
+                system_instruction=system_prompt,
+                automatic_function_calling={"disable": True} 
+            )
+        )
+
+    # --- Tool Implementations ---
+    # --- Tool Implementations ---
+    def _add_expense_impl(self, amount: str, description: str, friend_names: list[str], split_map: dict = None, group_name: str = None, payer_name: str = None, exclude_names: list[str] = None):
+        """Add a new expense to Splitwise. Use this when the user wants to split a cost.
+        
+        Args:
+            amount: The numeric amount of the expense (e.g. '50.00').
+            description: Short description of the expense (e.g. 'Dinner', 'Cab').
+            friend_names: List of names of friends to split with. Can be empty if matching a group.
+            split_map: Optional dictionary for unequal splits. 
+                       Keys are names (use 'me' for yourself), Values are amounts (e.g. '10.50') OR percentages (e.g. '50%').
+                       Example: {'me': '40%', 'Sumeet Singh': '60%'}
+            group_name: Optional name of the group to add this expense to.
+            payer_name: Optional name of who paid the full amount. Defaults to current user if not specified.
+            exclude_names: Optional list of names to exclude from a group split.
+        """
+        # This function won't be called automatically by Gemini anymore.
+        # We will call it manually in 'execute_tool'.
+        print(f"{Fore.YELLOW}🛠️  Executing: add_expense({amount}, {description}, {friend_names}, split_map={split_map}, group_name={group_name}, payer={payer_name}, exclude={exclude_names}){Style.RESET_ALL}")
+        try:
+            res = self.splitwise.add_expense(amount, description, friend_names, split_map=split_map, group_name=group_name, payer_name=payer_name, exclude_names=exclude_names)
+            if res:
+                return f"Success! Added expense (ID: {res.getId()})"
+            return "Failed to add expense."
+        except Exception as e:
+            return f"Error: {e}"
+
+    def _delete_expense_impl(self, expense_id: str):
+        """Delete an expense by ID."""
+        print(f"{Fore.YELLOW}🛠️  Executing: delete_expense({expense_id}){Style.RESET_ALL}")
+        try:
+            self.splitwise.delete_expense(expense_id)
+            return f"Success! Deleted expense {expense_id}."
+        except Exception as e:
+            return f"Error: {e}"
+
+    def _list_friends_impl(self):
+        """List the user's friends on Splitwise."""
+        print(f"{Fore.YELLOW}🛠️  Executing: list_friends(){Style.RESET_ALL}")
+        try:
+            friends = self.splitwise.get_friends()
+            names = [f"{f.getFirstName()} {f.getLastName()}" for f in friends]
+            return f"Friends: {', '.join(names)}"
+        except Exception as e:
+            return f"Error: {e}"
+
+    # --- Agent Logic ---
+
+    def process_input(self, user_text: str):
+        """
+        Sends text to Gemini. 
+        Returns structure:
+         { "type": "text", "content": "..." }
+         OR
+         { "type": "confirmation_required", "tool_name": "...", "tool_args": {...}, "call_id": ... }
+        """
+        print(f"{Fore.CYAN}🧠 Thinking...{Style.RESET_ALL}")
+        response = self.chat.send_message(user_text)
+        
+        # Check if the model wants to call a function
+        # response.parts is a list. Look for function_call.
+        if response.candidates and response.candidates[0].content.parts:
+            for part in response.candidates[0].content.parts:
+                if part.function_call:
+                    fc = part.function_call
+                    tool_name = fc.name
+                    tool_args = fc.args
+                    
+                    # Optimization: Auto-execute read-only tools
+                    if tool_name == "_list_friends_impl":
+                        print(f"{Fore.MAGENTA}🔄 Auto-executing read-only tool: {tool_name}{Style.RESET_ALL}")
+                        # Execute and feed back to model
+                        # 1. Execute tool locally.
+                        func = self.tool_functions.get(tool_name)
+                        if not func:
+                             res_str = f"Error: Tool {tool_name} not found."
+                        else:
+                             res_str = func(**tool_args)
+                        
+                        # 2. Send ToolResponse to Gemini
+                        tool_response_part = types.Part(
+                            function_response=types.FunctionResponse(
+                                name=tool_name,
+                                response={'result': res_str}
+                            )
+                        )
+                        print(f"{Fore.MAGENTA}📤 Sending auto-result back to model...{Style.RESET_ALL}")
+                        
+                        # Recurse: Ask model again
+                        next_response = self.chat.send_message([tool_response_part])
+                        
+                        # Check THIS response for function calls (e.g. add_expense)
+                        if next_response.candidates and next_response.candidates[0].content.parts:
+                             for next_part in next_response.candidates[0].content.parts:
+                                 if next_part.function_call:
+                                     return {
+                                        "type": "confirmation_required",
+                                        "tool_name": next_part.function_call.name,
+                                        "tool_args": next_part.function_call.args, 
+                                        "call_id": "auto_recursive"
+                                     }
+                        
+                        # Else it's text
+                        return {
+                            "type": "text",
+                            "content": next_response.text
+                        }
+
+
+
+                    return {
+                        "type": "confirmation_required",
+                        "tool_name": tool_name,
+                        "tool_args": tool_args, # Dictionary
+                        "call_id": "manual_execution" 
+                    }
+        
+        # Otherwise just text
+        return {
+            "type": "text",
+            "content": response.text
+        }
+
+    def execute_tool_and_reply(self, tool_name, tool_args):
+        """
+        Executes the tool (after user said YES) and sends the output back to Gemini.
+        Returns the final text response from Gemini.
+        """
+        # 1. Execute
+        func = self.tool_functions.get(tool_name)
+        if not func:
+            result = f"Error: Tool {tool_name} not found."
+        else:
+            try:
+                # Unpack args
+                result = func(**tool_args)
+            except Exception as e:
+                result = f"Error calling function: {e}"
+
+        print(f"{Fore.GREEN}✅ Output: {result}{Style.RESET_ALL}")
+
+        # 2. Send result back to Gemini
+        # We need to construct a ToolResponse part.
+        
+        # In the new SDK, we send the message with the function response.
+        # We need to construct the 'parts' with 'function_response'.
+        
+        # NOTE: With automatic_function_calling disabled, we need to send the response manually.
+        # The SDK expects us to send a message containing the function response.
+        
+        # part = types.Part.from_function_response(name=tool_name, response={'result': result}) 
+        # API expects specific structure. 
+        
+        # Let's try sending it as a properly formatted tool response.
+        tool_response_part = types.Part(
+            function_response=types.FunctionResponse(
+                name=tool_name,
+                response={'result': result}
+            )
+        )
+
+        try:
+            response = self.chat.send_message([tool_response_part])
+            return response.text
+        except Exception as e:
+            print(f"{Fore.RED}⚠️ Gemini failed to acknowledge tool execution: {e}{Style.RESET_ALL}")
+            return f"✅ Action Executed Successfully: {result}\n\n(Note: Gemini could not generate a follow-up reply due to network/server issues)."
+
+    def reject_tool(self, reason: str):
+        """
+        User said NO or provided correction.
+        We send this feedback to Gemini so it can try again.
+        """
+        # We just send the user's correction text.
+        # Gemini sees: 
+        # User: "Split 50..."
+        # Model: Call add_expense(50)
+        # User (Feedback): "No, change amount to 15"
+        # Model: Call add_expense(15)
+        
+        # BUT, if we just send "No..." does Gemini know we REJECTED the previous call?
+        # Since we didn't send the ToolResponse, the previous turn is technically incomplete?
+        # Actually in Google GenAI, if we don't send the function response, 
+        # we might need to "rewind" or just send the text.
+        # Sending text "No, do X" usually works as a follow up.
+        
+        # Let's treat it as a new user message.
+        return self.process_input(reason)
+
+    def process_and_execute(self, user_text: str) -> str:
+        """
+        Process user text and auto-execute any tool calls.
+        Used by MCP server where tools should be executed without human confirmation.
+        
+        Returns the final response text (either from Gemini or tool execution result).
+        """
+        result = self.process_input(user_text)
+        
+        if result["type"] == "text":
+            return result["content"]
+        
+        elif result["type"] == "confirmation_required":
+            # Auto-execute the tool
+            tool_name = result["tool_name"]
+            tool_args = result["tool_args"]
+            return self.execute_tool_and_reply(tool_name, tool_args)
+        
+        return "Unexpected response type."
+
+# Export
+SplitwiseAgent = GeminiSplitwiseAgent

splitwise_mcp/client.py

@@ -0,0 +1,285 @@
+import os
+from dotenv import load_dotenv
+from splitwise import Splitwise
+from splitwise.expense import Expense
+from splitwise.user import ExpenseUser
+from typing import List, Optional
+
+load_dotenv()
+
+class SplitwiseClient:
+    def __init__(self):
+        self.consumer_key = os.getenv("SPLITWISE_CONSUMER_KEY")
+        self.consumer_secret = os.getenv("SPLITWISE_CONSUMER_SECRET")
+        self.api_key = os.getenv("SPLITWISE_API_KEY")
+        self.access_token = None
+        
+        self.client = None
+        self._current_user = None
+        
+        # Try to initialize if env vars are present
+        if (self.consumer_key and self.consumer_secret) or self.api_key:
+            self._init_client()
+
+    def _init_client(self):
+        self.client = Splitwise(
+            consumer_key=self.consumer_key,
+            consumer_secret=self.consumer_secret,
+            api_key=self.api_key
+        )
+        # If we have an access token, set it.
+        # Note: The library might expect a dict for OAuth1, or handle OAuth2 differently.
+        # Assuming we can just populate the internal state or user uses 'api_key' as bearer.
+        if self.access_token:
+            # We assume dict format for stability with common library versions
+            # But for purely OAuth2, it might differ. 
+            # We'll set it as a dictionary which is a common pattern for this lib.
+            self.client.setAccessToken({'oauth_token': self.access_token, 'oauth_token_secret': ''})
+
+    def configure(self, consumer_key: str = None, consumer_secret: str = None, api_key: str = None, access_token: str = None):
+        """
+        Configure the client with credentials at runtime.
+        """
+        if consumer_key: self.consumer_key = consumer_key
+        if consumer_secret: self.consumer_secret = consumer_secret
+        if api_key: self.api_key = api_key
+        if access_token: self.access_token = access_token
+        
+        self._init_client()
+
+        self._current_user = None
+
+    def get_current_user(self):
+        if not self.client:
+            raise ValueError("Splitwise client not configured. Please use 'configure_splitwise' tool.")
+            
+        if not self._current_user:
+            self._current_user = self.client.getCurrentUser()
+        return self._current_user
+
+    def get_friends(self):
+        if not self.client:
+            raise ValueError("Splitwise client not configured. Please use 'configure_splitwise' tool.")
+        return self.client.getFriends()
+
+    def find_friend_by_name(self, name: str):
+        friends = self.get_friends()
+        name_lower = name.lower()
+        for friend in friends:
+            # Check first, last, and full name
+            first = (friend.getFirstName() or "").lower()
+            last = (friend.getLastName() or "").lower()
+            full = f"{first} {last}".strip()
+            
+            if name_lower in full or name_lower == first or name_lower == last:
+                return friend
+        return None
+
+    def get_groups(self):
+        if not self.client:
+            raise ValueError("Splitwise client not configured. Please use 'configure_splitwise' tool.")
+        return self.client.getGroups()
+
+    def find_group_by_name(self, name: str):
+        groups = self.get_groups()
+        name_lower = name.lower()
+        for group in groups:
+            if group.getName().lower() == name_lower:
+                return group
+        return None
+
+    def add_expense(self, amount: str, description: str, friend_names: List[str], split_map: dict = None, group_name: str = None, payer_name: str = None, exclude_names: List[str] = None):
+        """
+        Splits an expense. 
+        If split_map is None, splits equally.
+        If split_map is provided:
+            - Keys are names (use "me" or "I" for current user).
+            - Values are amounts (e.g. "10.00") OR percentages (e.g. "50%").
+        If group_name is provided:
+            - If friend_names is empty, fetches all group members.
+            - Adds expense to that group.
+        If payer_name is provided:
+            - Specifies who paid the full amount. Defaults to current user.
+        If exclude_names is provided:
+            - Remixes group members to exclude these names.
+        """
+        current_user = self.get_current_user()
+        users_in_split = []
+        
+        # 1. Resolve Group & Members
+        group_id = None
+        if group_name:
+            group = self.find_group_by_name(group_name)
+            if not group:
+                raise ValueError(f"Group not found: {group_name}")
+            group_id = group.getId()
+            
+            # Auto-fetch members if friend_names is empty
+            if not friend_names:
+                members = group.getMembers()
+                # Filter out excluded members
+                if exclude_names:
+                    # Normalize exclude names
+                    excludes_lower = [n.lower() for n in exclude_names]
+                    members = [
+                        m for m in members 
+                        if f"{m.getFirstName()} {m.getLastName()}".strip().lower() not in excludes_lower
+                        and m.getFirstName().lower() not in excludes_lower
+                    ]
+                users_in_split = members
+
+        # 2. Resolve Friends (if not using group auto-fetch)
+        if not users_in_split:
+            users_in_split = [current_user]
+            friend_objects = {} 
+            for name in friend_names:
+                friend = self.find_friend_by_name(name)
+                if not friend:
+                    raise ValueError(f"Friend not found: {name}")
+                users_in_split.append(friend)
+            
+            # Key by full name for split_map matching
+            full_name = f"{friend.getFirstName()} {friend.getLastName()}".strip()
+            friend_objects[full_name] = friend
+            # Also key by first name? Ideally agent canonicalizes names.
+
+        # Deduplicate based on ID just in case
+        unique_users = {}
+        for u in users_in_split:
+             unique_users[u.getId()] = u
+        users_in_split = list(unique_users.values())
+
+        total_amount = float(amount)
+        
+        # 3. Create expense users
+        expense_users = []
+        
+        # Resolve Payer
+        payer_id = current_user.getId()
+        if payer_name and payer_name.lower() not in ["me", "i", "myself"]:
+             # Find payer in our list or friend list
+             payer_found = False
+             # Search in split users first
+             for u in users_in_split:
+                 f_name = f"{u.getFirstName()} {u.getLastName()}".strip()
+                 if payer_name.lower() in f_name.lower() or payer_name.lower() == u.getFirstName().lower():
+                     payer_id = u.getId()
+                     payer_found = True
+                     break
+             
+             if not payer_found:
+                 # Try finding explicitly if not in split (e.g. payer paid but is not part of split?)
+                 p = self.find_friend_by_name(payer_name)
+                 if p:
+                     payer_id = p.getId()
+                     # If payer is not in split, add them to users (paid share set later)
+                     if p.getId() not in unique_users:
+                         users_in_split.append(p)
+                         unique_users[p.getId()] = p
+                 else:
+                     raise ValueError(f"Payer not found: {payer_name}")
+        
+        if split_map:
+            # Unequal split logic
+            total_split = 0.0
+            
+            for user in users_in_split:
+                eu = ExpenseUser()
+                eu.setId(user.getId())
+                
+                # Paid Share
+                if user.getId() == payer_id:
+                    eu.setPaidShare(f"{total_amount:.2f}")
+                else:
+                    eu.setPaidShare("0.00")
+                
+                # Owed Share
+                owed = 0.0
+                
+                # Match user in split_map
+                key_to_use = None
+                
+                # Check "me"
+                if user.getId() == current_user.getId():
+                    if "me" in split_map: key_to_use = "me"
+                    elif "Me" in split_map: key_to_use = "Me"
+                    elif "I" in split_map: key_to_use = "I"
+                
+                # Check Name
+                if not key_to_use:
+                    f_name = f"{user.getFirstName()} {user.getLastName()}".strip()
+                    if f_name in split_map: key_to_use = f_name
+                    else:
+                        for k in split_map:
+                             if k.lower() in f_name.lower():
+                                 key_to_use = k
+                                 break
+                
+                if key_to_use:
+                    val = split_map[key_to_use]
+                    # Percentage Check
+                    if isinstance(val, str) and val.strip().endswith("%"):
+                        pct = float(val.strip().replace("%", ""))
+                        owed = (pct / 100.0) * total_amount
+                    else:
+                        owed = float(val)
+
+                eu.setOwedShare(f"{owed:.2f}")
+                total_split += owed
+                expense_users.append(eu)
+
+            # Validation (loose due to float math)
+            if abs(total_split - total_amount) > 0.05:
+                 pass 
+                
+        else:
+            # Equal split logic
+            num_users = len(users_in_split)
+            share = total_amount / num_users
+            for user in users_in_split:
+                eu = ExpenseUser()
+                eu.setId(user.getId())
+                
+                if user.getId() == payer_id:
+                    eu.setPaidShare(f"{total_amount:.2f}")
+                else:
+                    eu.setPaidShare("0.00")
+                    
+                eu.setOwedShare(f"{share:.2f}")
+                expense_users.append(eu)
+
+        expense = Expense()
+        expense.setCost(f"{total_amount:.2f}")
+        expense.setDescription(description)
+        expense.setUsers(expense_users)
+        
+        if group_id:
+            expense.setGroupId(group_id)
+        
+        # Handling potential 0.01 rounding errors? 
+        # API might reject if sums don't match exactly.
+        # Simple fix: the payload requires string.
+        # splitwise library handles some of this? 
+        # Let's hope basic division works for now. 
+        # Advanced: distrubute remainder.
+        
+        expense, errors = self.client.createExpense(expense)
+        
+        if errors:
+             raise Exception(f"Splitwise Error: {errors.getErrors()}")
+             
+        return expense
+
+    def delete_expense(self, expense_id: str):
+        """
+        Delete an expense by ID.
+        """
+        if not self.client:
+             raise ValueError("Splitwise client not configured.")
+        
+        success, errors = self.client.deleteExpense(expense_id)
+        if success:
+            return True
+        else:
+            raise Exception(f"Failed to delete expense: {errors.getErrors()}")
+

splitwise_mcp/server.py

@@ -0,0 +1,217 @@
+from mcp.server.fastmcp import FastMCP
+from splitwise_mcp.client import SplitwiseClient
+import logging
+import base64
+
+# Initialize FastMCP
+mcp = FastMCP("splitwise")
+
+# Global client (for direct Splitwise tools)
+client = SplitwiseClient()
+
+# Lazy-initialized agent (for voice/text command tools)
+_agent = None
+_transcriber = None
+
+def _get_agent():
+    """Lazy-initialize the Gemini agent."""
+    global _agent
+    if _agent is None:
+        from splitwise_mcp.agent.client import GeminiSplitwiseAgent
+        _agent = GeminiSplitwiseAgent()
+    return _agent
+
+def _get_transcriber():
+    """Lazy-initialize the Deepgram transcriber."""
+    global _transcriber
+    if _transcriber is None:
+        from splitwise_mcp.agent.audio import AudioTranscriber
+        _transcriber = AudioTranscriber()
+    return _transcriber
+
+# =============================================================================
+# Voice Agent Tools (Full Pipeline)
+# =============================================================================
+
+@mcp.tool()
+def voice_command(audio_base64: str) -> str:
+    """
+    Process a voice command for Splitwise.
+    
+    Accepts base64-encoded audio (WAV or MP3 format), transcribes it using Deepgram,
+    processes the intent using Gemini, and executes Splitwise actions.
+    
+    Args:
+        audio_base64: Base64-encoded audio data (WAV or MP3).
+        
+    Returns:
+        The result of the voice command (e.g., confirmation, clarification request, or error).
+    """
+    try:
+        # Decode audio
+        audio_bytes = base64.b64decode(audio_base64)
+        
+        # Transcribe with Deepgram
+        transcriber = _get_transcriber()
+        transcript = transcriber.transcribe_bytes(audio_bytes)
+        
+        if not transcript or not transcript.strip():
+            return "Could not transcribe audio. Please try again with clearer audio."
+        
+        # Process with Gemini agent
+        agent = _get_agent()
+        result = agent.process_and_execute(transcript)
+        
+        return f"Transcribed: \"{transcript}\"\n\nResult: {result}"
+        
+    except Exception as e:
+        return f"Voice command error: {e}"
+
+@mcp.tool()
+def text_command(text: str) -> str:
+    """
+    Process a text command for Splitwise.
+    
+    Interprets natural language text using Gemini and executes Splitwise actions.
+    Use this when you already have text (e.g., from a chat message) instead of audio.
+    
+    Args:
+        text: Natural language command (e.g., "Split 50 with Sumeet for dinner").
+        
+    Returns:
+        The result of the command (e.g., confirmation, clarification request, or error).
+    """
+    try:
+        agent = _get_agent()
+        result = agent.process_and_execute(text)
+        return result
+    except Exception as e:
+        return f"Text command error: {e}"
+
+# =============================================================================
+# Direct Splitwise Tools (For Manual Control)
+# =============================================================================
+
+@mcp.tool()
+def configure_splitwise(consumer_key: str = None, consumer_secret: str = None, api_key: str = None) -> str:
+    """
+    Configure the Splitwise client with API credentials.
+    You must provide either (consumer_key AND consumer_secret) OR api_key.
+    """
+    try:
+        client.configure(consumer_key, consumer_secret, api_key)
+        # Verify it works by getting current user
+        user = client.get_current_user()
+        name = f"{user.getFirstName()} {user.getLastName()}".strip()
+        return f"Successfully configured Splitwise for user: {name}"
+    except Exception as e:
+        return f"Configuration failed: {e}. Please check your keys."
+
+@mcp.tool()
+def login_with_token(access_token: str) -> str:
+    """
+    Log in using an existing OAuth2 Access Token.
+    Useful for integrations where authentication is handled externally (e.g. ChatGPT).
+    """
+    try:
+        client.configure(access_token=access_token)
+        # Verify
+        user = client.get_current_user()
+        name = f"{user.getFirstName()} {user.getLastName()}".strip()
+        return f"Successfully logged in as: {name}"
+    except Exception as e:
+        return f"Login failed: {e}. Token might be invalid."
+
+
+@mcp.tool()
+def list_friends() -> str:
+    """
+    List all friends of the current user on Splitwise.
+    Returns a formatted string list of friends.
+    """
+    try:
+        # Client check is handled inside client.get_friends()
+        friends = client.get_friends()
+        
+        if not friends:
+            return "No friends found."
+        
+        output = ["Current Friends:"]
+        for f in friends:
+            name = f"{f.getFirstName() or ''} {f.getLastName() or ''}".strip()
+            output.append(f"- {name} (ID: {f.getId()})")
+        
+        return "\n".join(output)
+        
+    except ValueError as e:
+         return f"Configuration Error: {e}"
+    except Exception as e:
+        return f"Error listing friends: {e}"
+
+@mcp.tool()
+def add_expense(
+    amount: str, 
+    description: str, 
+    friend_names: list[str], 
+    split_map: dict = None, 
+    group_name: str = None, 
+    payer_name: str = None, 
+    exclude_names: list[str] = None
+) -> str:
+    """
+    Add an expense to Splitwise, supporting unequal splits, groups, and precise control.
+    
+    Args:
+        amount: The total cost (e.g., "70", "10.50").
+        description: A brief description.
+        friend_names: Friends to split with. Can be empty if using `group_name`.
+        split_map: Optional dict for unequal splits. Keys=Names (or 'me'), Values=Amount/Percentage.
+                   Example: {'me': '40%', 'Alice': '60%'} or {'me': '10', 'Bob': '20'}
+        group_name: Optional group to add expense to.
+        payer_name: Optional name of who paid. Defaults to 'me'.
+        exclude_names: Optional list of names to exclude from a group split.
+    """
+    if not client.client:
+        return "Error: Splitwise client not configured. Use 'configure_splitwise' first."
+
+    try:
+        expense = client.add_expense(
+            amount, 
+            description, 
+            friend_names, 
+            split_map=split_map, 
+            group_name=group_name, 
+            payer_name=payer_name, 
+            exclude_names=exclude_names
+        )
+        if expense:
+            return f"Successfully added expense '{description}' for {amount}. (ID: {expense.getId()})"
+        else:
+            errors = client.client.getErrors() 
+            return f"Failed to add expense. Errors: {errors}"
+            
+    except ValueError as e:
+        return f"Error validation: {e}"
+    except Exception as e:
+        return f"Error adding expense: {e}"
+
+@mcp.tool()
+def delete_expense(expense_id: str) -> str:
+    """
+    Delete an expense by its ID.
+    """
+    if not client.client:
+        return "Error: Splitwise client not configured."
+    
+    try:
+        client.delete_expense(expense_id)
+        return f"Successfully deleted expense {expense_id}."
+    except Exception as e:
+        return f"Error deleting expense: {e}"
+
+def main():
+    mcp.run()
+
+if __name__ == "__main__":
+    main()
+

splitwise_mcp/sse.py

@@ -0,0 +1,4 @@
+from splitwise_mcp.server import mcp
+
+# Expose the ASGI app for uvicorn
+app = mcp.sse_app

splitwise_mcp/web_api.py

@@ -0,0 +1,74 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List, Optional
+from splitwise_mcp.client import SplitwiseClient
+import os
+
+app = FastAPI(title="Splitwise ChatGPT Connector", description="API to manage Splitwise expenses via ChatGPT")
+
+# Global client
+client = SplitwiseClient()
+
+class ConfigureRequest(BaseModel):
+    consumer_key: Optional[str] = None
+    consumer_secret: Optional[str] = None
+    api_key: Optional[str] = None
+
+class LoginTokenRequest(BaseModel):
+    access_token: str
+
+class AddExpenseRequest(BaseModel):
+    amount: str
+    description: str
+    friend_names: List[str]
+
+@app.get("/list_friends")
+def list_friends():
+    """List all friends."""
+    if not client.client:
+        raise HTTPException(status_code=401, detail="Not configured. Please call /configure or /login_with_token first.")
+    
+    try:
+        friends = client.get_friends()
+        output = []
+        for f in friends:
+             output.append({
+                 "id": f.getId(),
+                 "name": f"{f.getFirstName() or ''} {f.getLastName() or ''}".strip()
+             })
+        return {"friends": output}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/add_expense")
+def add_expense(req: AddExpenseRequest):
+    """Add an expense."""
+    if not client.client:
+        raise HTTPException(status_code=401, detail="Not configured.")
+        
+    try:
+        expense = client.add_expense(req.amount, req.description, req.friend_names)
+        if expense:
+            return {"status": "success", "id": expense.getId(), "message": f"Added {req.amount} for {req.description}"}
+        else:
+             raise HTTPException(status_code=400, detail="Failed to add expense")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/configure")
+def configure(req: ConfigureRequest):
+    """Set API Keys manually."""
+    try:
+        client.configure(req.consumer_key, req.consumer_secret, req.api_key)
+        return {"status": "success", "message": "Configured successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.post("/login_with_token")
+def login_with_token(req: LoginTokenRequest):
+    """Log in with OAuth2 token."""
+    try:
+        client.configure(access_token=req.access_token)
+        return {"status": "success", "message": "Logged in successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

splitwise_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: splitwise-mcp
+Version: 0.1.0
+Summary: MCP server for Splitwise integration
+Author-email: User <user@example.com>
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: deepgram-sdk>=3.0.0
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: google-genai>=0.1.0
+Requires-Dist: mcp[cli]>=0.1.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: scipy>=1.11.0
+Requires-Dist: sounddevice>=0.4.6
+Requires-Dist: splitwise>=3.0.0
+Requires-Dist: streamlit>=1.30.0
+Requires-Dist: uvicorn>=0.20.0

splitwise_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+splitwise_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+splitwise_mcp/client.py,sha256=YI-qlHmj1PnHNkF3f6Mi_HqrGBkJAAmejqEZG6HGtVU,11199
+splitwise_mcp/server.py,sha256=n6C84WtlKrDvpCMGYL04H1mS98gblnbRcPE8rd8NN4M,7137
+splitwise_mcp/sse.py,sha256=NUInFdjQlncZayOuSsG0G1B5A6Ql_CtDcSKZoLoQd78,90
+splitwise_mcp/web_api.py,sha256=ZPkn2QXxtzAs7_h-schLoIg8c3AAra3eEnMexSquAMo,2543
+splitwise_mcp/agent/audio.py,sha256=B6N2PnyPVRjZa3I4fnDuQG6xrEv1RMxO7klrHkyLs9w,3771
+splitwise_mcp/agent/client.py,sha256=7uOBgwl6UkxTpzuSGffg9Bw7LRmLcEQk08vZYSaJG4w,13432
+splitwise_mcp-0.1.0.dist-info/METADATA,sha256=3TxgVJ1rROCxs51rlBphTjMpGQBUmGXu2VJke6e4oWM,575
+splitwise_mcp-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+splitwise_mcp-0.1.0.dist-info/entry_points.txt,sha256=GP-yZpuk1iE8D6Ajn2E7sLN1Vgy1bG4_jccZwNryRzc,60
+splitwise_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=SdEGDxmjXDxJeajJNuPh-JqOvJFxRPni9qTy2RczBkQ,1061
+splitwise_mcp-0.1.0.dist-info/RECORD,,

splitwise_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

splitwise_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+splitwise-mcp = splitwise_mcp.server:main

splitwise_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 User
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.