epsimo-agent 0.1.0

package/references/virtual_db_guide.md

@@ -0,0 +1,57 @@
+# Virtual Database via Epsimo Threads
+
+This guide explains how to use Epsimo threads as a persistent, structured storage layer for your application using the **Virtual Database** pattern.
+
+## The Concept
+
+Instead of managing a separate database, your assistant can maintain its own structured state directly within an Epsimo thread. This data is persistent, indexed by thread, and can be queried both by the assistant and your frontend.
+
+## 1. Defining the Storage Tool (Skill)
+
+To allow an assistant to write to its database, provide it with a tool that handles data recording.
+
+### Tool Definition (JSON)
+```json
+{
+  "name": "update_database",
+  "description": "Persist structured data to the thread state.",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "key": { "type": "string", "description": "The field name (e.g., 'user_preferences')" },
+      "value": { "type": "object", "description": "The data to store (JSON object)" }
+    },
+    "required": ["key", "value"]
+  }
+}
+```
+
+## 2. Reading Data via SDK
+
+Use the newly implemented `c.db` resource in the `epsimo` Python SDK to retrieve the structured state.
+
+```python
+from epsimo import EpsimoClient
+
+client = EpsimoClient(api_key="your-token")
+
+# Get everything
+db = client.db.get_all(project_id, thread_id)
+
+# Get specific key
+preferences = client.db.get(project_id, thread_id, "user_preferences")
+print(f"Theme: {preferences.get('theme')}")
+```
+
+## 3. Writing Data via CLI (Admin/Testing)
+
+You can also manually seed coordinates into the "database" using the CLI:
+
+```bash
+epsimo db set --project-id PROJ_ID --thread-id THREAD_ID --key "status" --value '"active"'
+```
+
+## Benefits
+- **Zero Configuration**: No database server required.
+- **Contextual Storage**: Data is naturally partitioned by conversation.
+- **Agent Awareness**: The assistant always "knows" what's in its DB because it is part of the thread state.

package/requirements.txt

@@ -0,0 +1,2 @@
+requests>=2.0.0
+PyYAML>=6.0.0

package/scripts/assistant.py

@@ -0,0 +1,165 @@
+
+import os
+import sys
+import argparse
+import requests
+import json
+from auth import get_token, get_project_token, API_BASE_URL
+
+def create_assistant(project_id, name, instructions, model, tools=None):
+    token = get_token()
+    
+    # Get project specific token
+    project_token = get_project_token(project_id)
+    
+    headers = {"Authorization": f"Bearer {project_token}"}
+    
+    # Construct tools list similar to frontend
+    final_tools = []
+    if tools:
+        for t_name in tools:
+            t_lower = t_name.lower()
+            if t_lower == "retrieval" or t_lower == "retriever":
+                final_tools.append({
+                    "id": f"retrieval-{os.urandom(4).hex()}",
+                    "name": "Retrieval",
+                    "type": "retrieval",
+                    "description": "Look up information in uploaded files.",
+                    "config": {}
+                })
+            elif "duckduckgo" in t_lower or "ddg" in t_lower:
+                final_tools.append({
+                    "id": f"ddg_search-{os.urandom(4).hex()}",
+                    "name": "DuckDuckGo Search",
+                    "type": "ddg_search",
+                    "description": "Uses the DuckDuckGo search engine to find information on the web.",
+                    "config": {}
+                })
+            elif "tavily" in t_lower:
+                final_tools.append({
+                    "id": f"search_tavily-{os.urandom(4).hex()}",
+                    "name": "Search (Tavily)",
+                    "type": "search_tavily",
+                    "description": "Uses the Tavily search engine. Includes sources in the response.",
+                    "config": {}
+                })
+            else:
+                 # Generic fallback
+                 final_tools.append({
+                    "id": f"{t_name}-{os.urandom(4).hex()}",
+                    "name": t_name,
+                    "type": t_name,
+                    "description": "",
+                    "config": {}
+                })
+
+    # New config structure based on AssistantModal.tsx
+    configurable = {
+        "type": "agent",
+        "type==agent/agent_type": model.upper(), 
+        "type==agent/llm_type": model,
+        "type==agent/model": model,
+        "type==agent/system_message": instructions,
+        "type==agent/tools": final_tools
+    }
+    
+    payload = {
+        "name": name,
+        "config": {
+            "configurable": configurable
+        },
+        "public": True 
+    }
+    
+    response = requests.post(f"{API_BASE_URL}/assistants/", headers=headers, json=payload)
+    if not response.ok:
+        print(f"Error: {response.text}")
+    response.raise_for_status()
+    print(json.dumps(response.json(), indent=2))
+
+def list_assistants(project_id):
+    token = get_token()
+    
+    # Get project specific token
+    auth_headers = {"Authorization": f"Bearer {token}"}
+    proj_resp = requests.get(f"{API_BASE_URL}/projects/{project_id}", headers=auth_headers)
+    proj_resp.raise_for_status()
+    data = proj_resp.json()
+    project_token = data.get('access_token') or data.get('token') or data.get('jwt_token')
+
+    headers = {"Authorization": f"Bearer {project_token}"}
+    response = requests.get(f"{API_BASE_URL}/assistants/", headers=headers)
+    response.raise_for_status()
+    print(json.dumps(response.json(), indent=2))
+
+def update_assistant(project_id, assistant_id, name=None, instructions=None, model=None, tools=None):
+    token = get_token()
+    
+    # Get project specific token
+    auth_headers = {"Authorization": f"Bearer {token}"}
+    proj_resp = requests.get(f"{API_BASE_URL}/projects/{project_id}", headers=auth_headers)
+    proj_resp.raise_for_status()
+    data = proj_resp.json()
+    project_token = data.get('access_token') or data.get('token') or data.get('jwt_token')
+    
+    headers = {"Authorization": f"Bearer {project_token}"}
+    
+    # Fetch existing assistant data first to merge
+    existing_resp = requests.get(f"{API_BASE_URL}/assistants/{assistant_id}", headers=headers)
+    existing_resp.raise_for_status()
+    existing_data = existing_resp.json()
+    
+    config = existing_data.get("config", {})
+    if instructions:
+        config["system_prompt"] = instructions
+    if model:
+        config["model"] = model
+    if tools is not None:
+        config["tools"] = tools
+
+    payload = {
+        "name": name if name else existing_data.get("name"),
+        "config": config,
+        "public": existing_data.get("public", True)
+    }
+    
+    response = requests.put(f"{API_BASE_URL}/assistants/{assistant_id}", headers=headers, json=payload)
+    response.raise_for_status()
+    print(json.dumps(response.json(), indent=2))
+
+def main():
+    parser = argparse.ArgumentParser(description="Manage EpsimoAI Assistants")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # List
+    list_parser = subparsers.add_parser("list", help="List assistants in a project")
+    list_parser.add_argument("--project-id", required=True, help="Project ID")
+
+    # Create
+    create_parser = subparsers.add_parser("create", help="Create a new assistant")
+    create_parser.add_argument("--project-id", required=True, help="Project ID")
+    create_parser.add_argument("--name", required=True, help="Assistant name")
+    create_parser.add_argument("--instructions", required=True, help="System instructions")
+    create_parser.add_argument("--model", default="gpt-4o", help="Model name (default: gpt-4o)")
+    create_parser.add_argument("--tools", nargs="*", help="List of tools to enable (e.g. Retrieval DuckDuckGo)")
+
+    # Update
+    update_parser = subparsers.add_parser("update", help="Update an existing assistant")
+    update_parser.add_argument("--project-id", required=True, help="Project ID")
+    update_parser.add_argument("--assistant-id", required=True, help="Assistant ID")
+    update_parser.add_argument("--name", help="New assistant name")
+    update_parser.add_argument("--instructions", help="New system instructions")
+    update_parser.add_argument("--model", help="New model name")
+    update_parser.add_argument("--tools", nargs="*", help="New list of tools")
+
+    args = parser.parse_args()
+
+    if args.command == "list":
+        list_assistants(args.project_id)
+    elif args.command == "create":
+        create_assistant(args.project_id, args.name, args.instructions, args.model, tools=args.tools)
+    elif args.command == "update":
+        update_assistant(args.project_id, args.assistant_id, args.name, args.instructions, args.model, tools=args.tools)
+
+if __name__ == "__main__":
+    main()

package/scripts/auth.py

@@ -0,0 +1,195 @@
+
+import os
+import json
+import time
+import requests
+import argparse
+import getpass
+import sys
+import subprocess
+from pathlib import Path
+
+# Configuration
+API_BASE_URL = os.environ.get("EPSIMO_API_URL", "https://api.epsimoagents.com")
+TOKEN_FILE = Path("/Users/thierry/code/epsimo-frontend/.epsimo_token")
+
+def get_token():
+    """Retrieve a valid JWT token, refreshing if necessary."""
+    
+    # Check if token file exists
+    if TOKEN_FILE.exists():
+        try:
+            with open(TOKEN_FILE, 'r') as f:
+                data = json.load(f)
+                return data.get('access_token') or data.get('token') or data.get('jwt_token')
+        except json.JSONDecodeError:
+            pass
+            
+    # Try logging in with env vars if file doesn't exist/is invalid
+    if os.environ.get("EPSIMO_EMAIL") and os.environ.get("EPSIMO_PASSWORD"):
+        return perform_login(os.environ.get("EPSIMO_EMAIL"), os.environ.get("EPSIMO_PASSWORD"))
+
+    raise RuntimeError("Authentication required. Please run `python3 .agent/skills/epsimo-agent/scripts/auth.py login` or set EPSIMO_EMAIL and EPSIMO_PASSWORD environment variables.")
+
+def get_project_token(project_id):
+    """Get a project-specific token."""
+    token = get_token()
+    headers = {"Authorization": f"Bearer {token}"}
+    response = requests.get(f"{API_BASE_URL}/projects/{project_id}", headers=headers)
+    response.raise_for_status()
+    data = response.json()
+    project_token = data.get('access_token') or data.get('token') or data.get('jwt_token')
+    if not project_token:
+        raise ValueError(f"Failed to obtain project token for project {project_id}")
+    return project_token
+
+def perform_signup(email, password):
+    """Register a new user."""
+    print(f"Attempting to register new user: {email}")
+    url = f"{API_BASE_URL}/auth/signup"
+    payload = {
+        "email": email,
+        "password": password
+    }
+    
+    try:
+        response = requests.post(url, json=payload)
+        response.raise_for_status()
+        print("✅ Signup successful! Logging in...")
+        return perform_login(email, password)
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 400: # Usually "User already exists" or validation error
+             print(f"⚠️ Signup failed: {e.response.text}")
+        else:
+             print(f"❌ Signup failed: {e}")
+        raise
+
+def get_input_via_applescript(prompt, hidden=False):
+    """Get input using macOS native dialog."""
+    try:
+        script = f'display dialog "{prompt}" default answer ""'
+        if hidden:
+            script += ' with hidden answer'
+        script += ' buttons {"Cancel", "OK"} default button "OK"'
+        
+        cmd = ['osascript', '-e', script]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        # Parse result: button returned:OK, text returned:foobar
+        output = result.stdout.strip()
+        if "text returned:" in output:
+            return output.split("text returned:")[-1]
+        return ""
+    except subprocess.CalledProcessError:
+        return None
+
+def perform_login(email, password, attempt_signup_on_fail=False):
+    """Login logic."""
+    if not email or not password:
+        raise ValueError("Email and password are required.")
+
+    url = f"{API_BASE_URL}/auth/login"
+    payload = {
+        "email": email,
+        "password": password
+    }
+    
+    try:
+        response = requests.post(url, json=payload)
+        response.raise_for_status()
+        
+        data = response.json()
+        
+        # DEBUG: Print keys if structure is unexpected
+        token = data.get('access_token')
+        
+        if not token:
+             token = data.get('token')
+             
+        if not token:
+             token = data.get('jwt_token')
+             
+        if not token:
+            print(f"⚠️ Debug: Full response data keys: {list(data.keys())}")
+            print(f"⚠️ Debug: Full response data: {data}")
+            raise ValueError("Failed to obtain access token from login response.")
+
+        # Save token
+        with open(TOKEN_FILE, 'w') as f:
+            json.dump(data, f)
+            
+        print(f"✅ Successfully logged in as {email}")
+        return token
+
+    except requests.exceptions.HTTPError as e:
+        print(f"❌ Login failed: {e}")
+        # If UNAUTHORIZED, it might mean user doesn't exist OR bad password.
+        if attempt_signup_on_fail:
+             print("\nUser might not exist or password is wrong.")
+             
+             # Check if we should use GUI for prompt
+             if sys.platform == 'darwin' and os.environ.get("USE_GUI_PROMPT"):
+                 # Simple popup confirming desire to signup? Hard to do strictly y/n
+                 # Just use CLI for choices for simplicity, or assume yes if they explicitly ran setup
+                 pass
+                 
+             choice = input("Do you want to create a new account with these credentials? (y/n): ")
+             if choice.lower() == 'y':
+                 return perform_signup(email, password)
+        raise
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="EpsimoAI Authentication")
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # Login command
+    login_parser = subparsers.add_parser("login", help="Authenticate with EpsimoAI")
+    login_parser.add_argument("--email", help="Your email address")
+    login_parser.add_argument("--password", help="Your password (optional, will prompt if missing)")
+    login_parser.add_argument("--modal", action="store_true", help="Use macOS modal dialogs for input")
+
+    args = parser.parse_args()
+
+    if args.command == "login":
+        email = args.email
+        password = args.password
+        use_modal = args.modal or os.environ.get("USE_GUI_PROMPT") == "1"
+
+        if not email:
+            if use_modal and sys.platform == 'darwin':
+                email = get_input_via_applescript("Enter your Epsimo Email:")
+            else:
+                email = input("Email: ")
+        
+        if not email:
+            print("Email is required.")
+            sys.exit(1)
+
+        if not password:
+            if 'EPSIMO_PASSWORD' in os.environ:
+                password = os.environ['EPSIMO_PASSWORD']
+            elif use_modal and sys.platform == 'darwin':
+                password = get_input_via_applescript("Enter your Epsimo Password:", hidden=True)
+            else:
+                password = getpass.getpass("Password: ")
+        
+        if not password:
+             print("Password is required.")
+             sys.exit(1)
+
+        try:
+            # We enable auto-signup prompt for interactive login
+            # Pass choice to use GUI prompts if needed
+            if use_modal:
+                os.environ["USE_GUI_PROMPT"] = "1"
+            perform_login(email, password, attempt_signup_on_fail=True)
+        except Exception:
+            sys.exit(1)
+            
+    else:
+        # Default behavior: test token retrieval
+        try:
+            token = get_token()
+            print(f"Token: {token[:10]}...") 
+        except Exception as e:
+            print(f"Error: {e}")
+            sys.exit(1)

package/scripts/credits.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+import sys
+import os
+import argparse
+import json
+import requests
+from auth import get_token, login
+
+BASE_URL = os.environ.get("EPSIMO_API_URL", "https://api.epsimoagents.com")
+
+def check_balance():
+    """Check the current thread and credit balance."""
+    token = get_token()
+    if not token:
+        print("Not authenticated. Please login first.")
+        return
+
+    try:
+        # Try retrieving full thread info
+        headers = {"Authorization": f"Bearer {token}"}
+        response = requests.get(f"{BASE_URL}/auth/thread-info", headers=headers)
+        
+        if response.status_code == 200:
+            data = response.json()
+            thread_count = data.get("thread_counter", 0)
+            thread_max = data.get("thread_max", 0)
+            remaining = thread_max - thread_count
+            
+            print("\n=== Thread Balance ===")
+            print(f"Threads Used:      {thread_count}")
+            print(f"Total Allowance:   {thread_max}")
+            print(f"Threads Remaining: {remaining}")
+            print("======================\n")
+        else:
+            print(f"Error checking balance: {response.text}")
+            
+    except Exception as e:
+        print(f"Error: {e}")
+
+def buy_credits(quantity, total_amount=None):
+    """Create a checkout session to buy credits."""
+    token = get_token()
+    if not token:
+        print("Not authenticated. Please login first.")
+        return
+
+    # Simple logic for price estimation if not provided
+    # Assuming roughly €0.10 per thread for small amounts, cheaper for bulk
+    if total_amount is None:
+        if quantity >= 1000:
+            price_per_unit = 0.08
+        elif quantity >= 500:
+            price_per_unit = 0.09
+        else:
+            price_per_unit = 0.10
+        
+        total_amount = round(quantity * price_per_unit, 2)
+        print(f"Estimated cost: {total_amount} EUR")
+
+    try:
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "quantity": quantity,
+            "total_amount": float(total_amount)
+        }
+        
+        print("Creating checkout session...")
+        response = requests.post(f"{BASE_URL}/checkout/create-checkout-session", json=payload, headers=headers)
+        
+        if response.status_code == 200:
+            data = response.json()
+            checkout_url = data.get("url")
+            print("\nCheckout session created successfully!")
+            print(f"Please visit this URL to complete your purchase:\n\n{checkout_url}\n")
+        else:
+            print(f"Error creating checkout session: {response.text}")
+            
+    except Exception as e:
+        print(f"Error: {e}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Manage credits and thread usage")
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+    
+    # Balance command
+    subparsers.add_parser("balance", help="Check current credit balance")
+    
+    # Buy command
+    buy_parser = subparsers.add_parser("buy", help="Buy more credits")
+    buy_parser.add_argument("--quantity", type=int, required=True, help="Number of threads to purchase")
+    buy_parser.add_argument("--amount", type=float, help="Total amount to pay in EUR (optional, calculated if omitted)")
+
+    args = parser.parse_args()
+    
+    if args.command == "balance":
+        check_balance()
+    elif args.command == "buy":
+        buy_credits(args.quantity, args.amount)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

package/scripts/debug_run.py

@@ -0,0 +1,41 @@
+
+import requests
+import os
+import json
+from auth import get_token, API_BASE_URL
+
+projectId = "5d4025a5-5db7-4b6c-99b0-5b65e97d88c0"
+assistantId = "a4178aa5-63d3-468b-8672-c6d916153d0a"
+threadId = "2b4c6325-c400-4e78-81c8-ef7781bf8b49"
+message = "Research Google"
+
+def debug_run():
+    token = get_token()
+    auth_headers = {"Authorization": f"Bearer {token}"}
+    proj_resp = requests.get(f"{API_BASE_URL}/projects/{projectId}", headers=auth_headers)
+    data = proj_resp.json()
+    project_token = data.get('access_token')
+
+    headers = {
+        "Authorization": f"Bearer {project_token}",
+        "Accept": "text/event-stream"
+    }
+
+    payload = {
+        "assistant_id": assistantId,
+        "thread_id": threadId,
+        "input": [{"type": "human", "content": message}]
+    }
+
+    print(f"Testing url: {API_BASE_URL}/runs/stream")
+    r1 = requests.post(f"{API_BASE_URL}/runs/stream", headers=headers, json=payload, allow_redirects=False)
+    print(f"No Slash: {r1.status_code}")
+    print(r1.headers)
+
+    print(f"Testing url: {API_BASE_URL}/runs/stream/")
+    r2 = requests.post(f"{API_BASE_URL}/runs/stream/", headers=headers, json=payload, allow_redirects=False)
+    print(f"With Slash: {r2.status_code}")
+    print(r2.headers)
+
+if __name__ == "__main__":
+    debug_run()

package/scripts/example.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""
+Example helper script for epsimo-agent
+
+This is a placeholder script that can be executed directly.
+Replace with actual implementation or delete if not needed.
+
+Example real scripts from other skills:
+- pdf/scripts/fill_fillable_fields.py - Fills PDF form fields
+- pdf/scripts/convert_pdf_to_images.py - Converts PDF pages to images
+"""
+
+def main():
+    print("This is an example script for epsimo-agent")
+    # TODO: Add actual script logic here
+    # This could be data processing, file conversion, API calls, etc.
+
+if __name__ == "__main__":
+    main()

package/scripts/files.py

@@ -0,0 +1,73 @@
+
+import os
+import sys
+import argparse
+import requests
+import json
+from auth import get_token, get_project_token, API_BASE_URL
+
+def list_files(project_id, assistant_id):
+    token = get_token()
+    
+    # Get project specific token
+    project_token = get_project_token(project_id)
+
+    headers = {"Authorization": f"Bearer {project_token}"}
+    response = requests.get(f"{API_BASE_URL}/assistants/{assistant_id}/files", headers=headers)
+    response.raise_for_status()
+    print(json.dumps(response.json(), indent=2))
+
+def upload_file(project_id, assistant_id, file_path):
+    token = get_token()
+    
+    # Get project specific token
+    auth_headers = {"Authorization": f"Bearer {token}"}
+    proj_resp = requests.get(f"{API_BASE_URL}/projects/{project_id}", headers=auth_headers)
+    proj_resp.raise_for_status()
+    data = proj_resp.json()
+    project_token = data.get('access_token') or data.get('token') or data.get('jwt_token')
+    
+    headers = {"Authorization": f"Bearer {project_token}"}
+    
+    if not os.path.exists(file_path):
+        print(f"Error: File not found at {file_path}")
+        return
+
+    with open(file_path, 'rb') as f:
+        files = {'files': (os.path.basename(file_path), f)}
+        response = requests.post(
+            f"{API_BASE_URL}/assistants/{assistant_id}/files",
+            headers=headers,
+            files=files
+        )
+    
+    if not response.ok:
+        print(f"Error: {response.text}")
+    
+    response.raise_for_status()
+    print(json.dumps(response.json(), indent=2))
+
+def main():
+    parser = argparse.ArgumentParser(description="Manage EpsimoAI Assistant Files")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # List
+    list_parser = subparsers.add_parser("list", help="List files for an assistant")
+    list_parser.add_argument("--project-id", required=True, help="Project ID")
+    list_parser.add_argument("--assistant-id", required=True, help="Assistant ID")
+
+    # Upload
+    upload_parser = subparsers.add_parser("upload", help="Upload a file to an assistant")
+    upload_parser.add_argument("--project-id", required=True, help="Project ID")
+    upload_parser.add_argument("--assistant-id", required=True, help="Assistant ID")
+    upload_parser.add_argument("--file", required=True, help="Path to file to upload")
+
+    args = parser.parse_args()
+
+    if args.command == "list":
+        list_files(args.project_id, args.assistant_id)
+    elif args.command == "upload":
+        upload_file(args.project_id, args.assistant_id, args.file)
+
+if __name__ == "__main__":
+    main()