epsimo-agent 0.1.0

package/scripts/find_thread.py

@@ -0,0 +1,55 @@
+
+import requests
+import json
+from auth import get_token, API_BASE_URL
+
+target_thread_id = "2b4c6325-c400-4e78-81c8-ef7781bf8b49"
+
+def check_thread():
+    token = get_token()
+    headers = {"Authorization": f"Bearer {token}"}
+    
+    print(f"Checking thread {target_thread_id} with User Token...")
+    try:
+        resp = requests.get(f"{API_BASE_URL}/threads/{target_thread_id}", headers=headers)
+        if resp.ok:
+            t = resp.json()
+            print(f"FOUND with User Token!")
+            print(json.dumps(t, indent=2))
+            return
+        else:
+            print(f"User Token check failed: {resp.status_code}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+    # Fallback: check projects
+    resp = requests.get(f"{API_BASE_URL}/projects/", headers=headers)
+    projects = resp.json()
+    
+    for p in projects:
+        pid = p['project_id']
+        pname = p['name']
+        
+        # Get project token
+        pr = requests.get(f"{API_BASE_URL}/projects/{pid}", headers=headers)
+        if not pr.ok:
+            continue
+        ptoken = pr.json().get('access_token')
+        pheaders = {"Authorization": f"Bearer {ptoken}"}
+        
+        try:
+            resp = requests.get(f"{API_BASE_URL}/threads/{target_thread_id}", headers=pheaders)
+            if resp.ok:
+                t = resp.json()
+                print(f"FOUND in Project: {pname} ({pid})")
+                print(json.dumps(t, indent=2))
+                return
+            else:
+                 pass # Not in this project
+        except:
+            pass
+            
+    print("Thread not found by ID.")
+
+if __name__ == "__main__":
+    check_thread()

package/scripts/project.py

@@ -0,0 +1,60 @@
+
+import os
+import sys
+import argparse
+import requests
+import json
+from auth import get_token, API_BASE_URL
+
+def list_projects():
+    token = get_token()
+    headers = {"Authorization": f"Bearer {token}"}
+    response = requests.get(f"{API_BASE_URL}/projects/", headers=headers)
+    response.raise_for_status()
+    projects = response.json()
+    print(json.dumps(projects, indent=2))
+
+def create_project(name, description):
+    token = get_token()
+    headers = {"Authorization": f"Bearer {token}"}
+    payload = {"name": name, "description": description}
+    response = requests.post(f"{API_BASE_URL}/projects/", headers=headers, json=payload)
+    if not response.ok:
+        print(f"Error {response.status_code}: {response.text}")
+    response.raise_for_status()
+    print(json.dumps(response.json(), indent=2))
+
+def get_project(project_id):
+    token = get_token()
+    headers = {"Authorization": f"Bearer {token}"}
+    response = requests.get(f"{API_BASE_URL}/projects/{project_id}", headers=headers)
+    response.raise_for_status()
+    print(json.dumps(response.json(), indent=2))
+
+def main():
+    parser = argparse.ArgumentParser(description="Manage EpsimoAI Projects")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # List
+    subparsers.add_parser("list", help="List all projects")
+
+    # Get
+    get_parser = subparsers.add_parser("get", help="Get project details")
+    get_parser.add_argument("--id", required=True, help="Project ID")
+
+    # Create
+    create_parser = subparsers.add_parser("create", help="Create a new project")
+    create_parser.add_argument("--name", required=True, help="Project name")
+    create_parser.add_argument("--description", help="Project description", default="My AI Project")
+
+    args = parser.parse_args()
+
+    if args.command == "list":
+        list_projects()
+    elif args.command == "get":
+        get_project(args.id)
+    elif args.command == "create":
+        create_project(args.name, args.description)
+
+if __name__ == "__main__":
+    main()

package/scripts/run.py

@@ -0,0 +1,75 @@
+
+import os
+import sys
+import argparse
+import requests
+import json
+from auth import get_token, get_project_token, API_BASE_URL
+
+def stream_run(project_id, thread_id, message, assistant_id=None):
+    token = get_token()
+    
+    # Get project specific token
+    project_token = get_project_token(project_id)
+
+    headers = {
+        "Authorization": f"Bearer {project_token}",
+        "Accept": "text/event-stream"
+    }
+    
+    # Matches frontend structure in ThreadsPage.handleSendMessage
+    payload = {
+        "thread_id": thread_id,
+        "input": [{
+            "content": message,
+            "type": "human",
+            "role": "user"
+        }],
+        "stream_mode": ["messages", "events", "values"]
+    }
+    
+    # Frontend doesn't pass assistant_id here, but we can if API supports override.
+    # Frontend relies on thread <-> assistant link.
+    if assistant_id:
+        payload["assistant_id"] = assistant_id
+    
+    response = requests.post(f"{API_BASE_URL}/runs/stream", headers=headers, json=payload, stream=True)
+    
+    if not response.ok:
+        print(f"Status: {response.status_code}")
+        print(f"Body: {response.text}")
+    
+    response.raise_for_status()
+    
+    print("Streaming response...")
+    for line in response.iter_lines():
+        if line:
+            decoded_line = line.decode('utf-8')
+            if decoded_line.startswith("data:"):
+                data_str = decoded_line[5:].strip()
+                if data_str == "[DONE]":
+                    break
+                try:
+                    data = json.loads(data_str)
+                    print(json.dumps(data, indent=None))
+                except json.JSONDecodeError:
+                    print(f"Raw: {data_str}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Manage EpsimoAI Runs")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Stream
+    stream_parser = subparsers.add_parser("stream", help="Stream a run")
+    stream_parser.add_argument("--project-id", required=True, help="Project ID")
+    stream_parser.add_argument("--thread-id", required=True, help="Thread ID")
+    stream_parser.add_argument("--message", required=True, help="User message")
+    stream_parser.add_argument("--assistant-id", help="Optional Assistant ID override (default: uses thread's assistant)")
+
+    args = parser.parse_args()
+
+    if args.command == "stream":
+        stream_run(args.project_id, args.thread_id, args.message, args.assistant_id)
+
+if __name__ == "__main__":
+    main()

package/scripts/test_all_skills.py

@@ -0,0 +1,387 @@
+
+import os
+import sys
+import json
+import time
+import requests
+import uuid
+from auth import get_token, get_project_token, API_BASE_URL
+
+# --- Colors for Output ---
+class Colors:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKCYAN = '\033[96m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+def print_pass(msg):
+    print(f"{Colors.OKGREEN}✅ {msg}{Colors.ENDC}")
+
+def print_fail(msg):
+    print(f"{Colors.FAIL}❌ {msg}{Colors.ENDC}")
+
+def print_info(msg):
+    print(f"{Colors.OKCYAN}ℹ️  {msg}{Colors.ENDC}")
+
+def print_header(msg):
+    print(f"\n{Colors.HEADER}{Colors.BOLD}=== {msg} ==={Colors.ENDC}")
+
+class SkillTester:
+    def __init__(self):
+        self.access_token = None
+        self.project_id = None
+        self.project_token = None
+        self.assistant_id = None
+        self.thread_id = None
+        self.file_path = "test_secret.txt"
+        self.secret_code = f"TEST-SECRET-{uuid.uuid4().hex[:8]}"
+
+    def step_1_auth(self):
+        print_header("Step 1: Authentication")
+        try:
+            self.access_token = get_token()
+            if not self.access_token:
+                raise ValueError("No token returned")
+            print_pass("Authentication successful")
+            
+            # Check Balance (Credits)
+            headers = {"Authorization": f"Bearer {self.access_token}"}
+            resp = requests.get(f"{API_BASE_URL}/auth/thread-info", headers=headers)
+            if resp.ok:
+                data = resp.json()
+                print_info(f"Threads Used: {data.get('thread_counter')}/{data.get('thread_max')}")
+            else:
+                print_fail("Could not fetch balance")
+
+        except Exception as e:
+            print_fail(f"Auth failed: {e}")
+            sys.exit(1)
+
+    def step_2_projects(self):
+        print_header("Step 2: Project Management")
+        
+        # Create
+        unique_name = f"AutoTest Project {int(time.time())}"
+        print_info(f"Creating project: {unique_name}")
+        
+        headers = {"Authorization": f"Bearer {self.access_token}"}
+        payload = {
+            "name": unique_name,
+            "description": "Automated test project"
+        }
+        
+        try:
+            resp = requests.post(f"{API_BASE_URL}/projects/", headers=headers, json=payload)
+            if not resp.ok:
+                raise ValueError(f"Project creation failed: {resp.text}")
+            
+            data = resp.json()
+            self.project_id = data["project_id"]
+            print_pass(f"Created project {self.project_id}")
+            
+            # Get Project Token
+            self.project_token = get_project_token(self.project_id)
+            print_pass("Retrieved project-specific token")
+
+        except Exception as e:
+            print_fail(f"Project step failed: {e}")
+            sys.exit(1)
+
+    def step_3_assistants(self):
+        print_header("Step 3: Assistant Management")
+        
+        headers = {"Authorization": f"Bearer {self.project_token}"}
+        
+        # Create
+        name = f"AutoTest Assistant {uuid.uuid4().hex[:4]}"
+        
+        # Configuration matches updated assistant.py logic
+        instructions = "You are a test assistant. You HAVE access to uploaded files. Use the Retrieval tool to find the secret code."
+        
+        configurable = {
+            "type": "agent",
+            "type==agent/agent_type": "GPT-4O", 
+            "type==agent/llm_type": "gpt-4o",
+            "type==agent/model": "gpt-4o",
+            "type==agent/system_message": instructions,
+            "type==agent/tools": [
+                {
+                    "id": f"retrieval-{uuid.uuid4().hex[:4]}", 
+                    "name": "Retrieval", 
+                    "type": "retrieval",
+                     "description": "Look up information in uploaded files.",
+                    "config": {}
+                },
+                {
+                     "id": f"ddg-{uuid.uuid4().hex[:4]}",
+                     "name": "DuckDuckGo Search",
+                     "type": "ddg_search",
+                     "description": "Search web",
+                     "config": {}
+                }
+            ]
+        }
+        
+        payload = {
+            "name": name,
+            "config": {
+                "configurable": configurable
+            },
+            "public": True
+        }
+        
+        try:
+            print_info(f"Creating assistant: {name}")
+            resp = requests.post(f"{API_BASE_URL}/assistants/", headers=headers, json=payload)
+            if not resp.ok:
+                raise ValueError(f"Create assistant failed: {resp.text}")
+            
+            data = resp.json()
+            self.assistant_id = data["assistant_id"]
+            print_pass(f"Created assistant {self.assistant_id}")
+            
+            # List to verify
+            resp_list = requests.get(f"{API_BASE_URL}/assistants/", headers=headers)
+            if not resp_list.ok:
+                raise ValueError("List assistants failed")
+            
+            assistants = resp_list.json()
+            found = any(a["assistant_id"] == self.assistant_id for a in assistants)
+            if found:
+                print_pass("Verification: Assistant found in list")
+            else:
+                print_fail("Verification: Assistant NOT found in list")
+
+        except Exception as e:
+            print_fail(f"Assistant step failed: {e}")
+            # Don't exit, might be able to cleanup other things
+
+    def step_4_files(self):
+        print_header("Step 4: File Management")
+        if not self.assistant_id:
+            print_fail("Skipping files (no assistant)")
+            return
+
+        # Create dummy file
+        with open(self.file_path, "w") as f:
+            f.write(f"CONFIDENTIAL DATA\nThe secret code is: {self.secret_code}")
+        
+        headers = {"Authorization": f"Bearer {self.project_token}"}
+        
+        try:
+            print_info(f"Uploading file with secret: {self.secret_code}")
+            with open(self.file_path, 'rb') as f:
+                files = {'files': (os.path.basename(self.file_path), f)}
+                resp = requests.post(f"{API_BASE_URL}/assistants/{self.assistant_id}/files", headers=headers, files=files)
+            
+            if not resp.ok:
+                raise ValueError(f"Upload failed: {resp.text}")
+            
+            print_pass("File uploaded successfully")
+            
+            # List files
+            resp_list = requests.get(f"{API_BASE_URL}/assistants/{self.assistant_id}/files", headers=headers)
+            if resp_list.ok:
+                files_list = resp_list.json()
+                if len(files_list) > 0:
+                    print_pass(f"Verified {len(files_list)} file(s) attached")
+                else:
+                    print_fail("File list empty")
+
+        except Exception as e:
+            print_fail(f"File step failed: {e}")
+        finally:
+            if os.path.exists(self.file_path):
+                os.remove(self.file_path)
+
+    def step_5_threads(self):
+        print_header("Step 5: Thread Management")
+        if not self.project_token:
+             print_fail("Skipping threads (no project token)")
+             return
+
+        headers = {"Authorization": f"Bearer {self.project_token}"}
+        name = f"Test Thread {uuid.uuid4().hex[:4]}"
+        
+        payload = {
+            "name": name,
+            "metadata": {"type": "thread"},
+            "assistant_id": self.assistant_id
+        }
+        
+        try:
+            print_info(f"Creating thread: {name}")
+            resp = requests.post(f"{API_BASE_URL}/threads/", headers=headers, json=payload)
+            if not resp.ok:
+                 raise ValueError(f"Create thread failed: {resp.text}")
+            
+            data = resp.json()
+            self.thread_id = data["thread_id"]
+            print_pass(f"Created thread {self.thread_id}")
+
+        except Exception as e:
+            print_fail(f"Thread step failed: {e}")
+            sys.exit(1)
+
+    def step_6_execution(self):
+        print_header("Step 6: Execution (Runs & RAG)")
+        if not self.thread_id or not self.assistant_id:
+            print_fail("Skipping execution (missing resources)")
+            return
+
+        headers = {
+            "Authorization": f"Bearer {self.project_token}",
+            "Accept": "text/event-stream"
+        }
+        
+        payload = {
+            "thread_id": self.thread_id,
+            "assistant_id": self.assistant_id,
+            "input": [{
+                "content": "What is the secret code in the file?",
+                "type": "human",
+                "role": "user"
+            }],
+            "stream_mode": ["messages", "values"]
+        }
+        
+        print_info("Streaming run request...")
+        found_secret = False
+        full_response = ""
+        
+        try:
+            resp = requests.post(f"{API_BASE_URL}/runs/stream", headers=headers, json=payload, stream=True)
+            if not resp.ok:
+                 raise ValueError(f"Stream failed: {resp.status_code} {resp.text}")
+
+            for line in resp.iter_lines():
+                if line:
+                    decoded = line.decode('utf-8')
+                    if decoded.startswith("data:"):
+                        data_str = decoded[5:].strip()
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            # Try to extract content delta or message
+                            # This is a simplified check, actual structure varies
+                            if self.secret_code in data_str:
+                                found_secret = True
+                            full_response += data_str
+                        except:
+                            pass
+                            
+            if found_secret:
+                print_pass(f"RAG Successful! Secret '{self.secret_code}' found in stream.")
+            else:
+                # Polling retry logic for latency
+                max_retries = 6
+                for i in range(max_retries):
+                    wait_time = 10
+                    print_info(f"Secret not found. Retrying in {wait_time}s ({i+1}/{max_retries})...")
+                    time.sleep(wait_time)
+                    
+                    full_response = ""
+                    current_run_found = False
+                    
+                    try:
+                        resp = requests.post(f"{API_BASE_URL}/runs/stream", headers=headers, json=payload, stream=True)
+                        for line in resp.iter_lines():
+                            if line:
+                                decoded = line.decode('utf-8')
+                                if decoded.startswith("data:"):
+                                    data_str = decoded[5:].strip()
+                                    if data_str == "[DONE]":
+                                        break
+                                    try:
+                                        if self.secret_code in data_str:
+                                            current_run_found = True
+                                        full_response += data_str
+                                    except:
+                                        pass
+                    except Exception as e:
+                        print_fail(f"Retry {i+1} failed with error: {e}")
+                        continue
+                        
+                    if current_run_found:
+                        found_secret = True
+                        print_pass(f"RAG Successful (on retry {i+1})! Secret '{self.secret_code}' found.")
+                        break
+                
+                if not found_secret:
+                    print_fail("Secret not found after retries.")
+                    print_info(f"Last response dump (truncated): {full_response[:200]}...")
+
+        except Exception as e:
+            print_fail(f"Execution step failed: {e}")
+
+    def step_7_credits_check(self):
+        print_header("Step 7: Credits Purchase (Dry Run)")
+        # Just verify we can generate a checkout link
+        if not self.access_token: 
+            return
+
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/json"
+        }
+        payload = {"quantity": 100, "total_amount": 10.0}
+        
+        try:
+            resp = requests.post(f"{API_BASE_URL}/checkout/create-checkout-session", json=payload, headers=headers)
+            if resp.ok:
+                url = resp.json().get("url")
+                if url:
+                    print_pass("Checkout session URL generated successfully")
+                else:
+                    print_fail("No URL in checkout response")
+            else:
+                print_fail(f"Checkout creation failed: {resp.text}")
+        except Exception as e:
+             print_fail(f"Credits step failed: {e}")
+
+    def step_8_cleanup(self):
+        print_header("Step 8: Cleanup")
+        # cleanup is important
+        
+        headers = {"Authorization": f"Bearer {self.access_token}"} # Use main token for project deletion context switching
+        
+        if self.project_id:
+            # We need to delete the project. 
+            # Note: Deleting project *should* delete assistants/threads/files inside it.
+            try:
+                # Switch context explicitly just in case or use main token? api.d.ts says delete project uses /projects/{id}
+                # And usually requires just access to it.
+                
+                # Check api.d.ts: delete_project_projects__project_id__delete
+                # If confirm=true is needed
+                print_info(f"Deleting project {self.project_id}...")
+                resp = requests.delete(f"{API_BASE_URL}/projects/{self.project_id}?confirm=true", headers=headers)
+                
+                if resp.ok:
+                    print_pass("Project deleted successfully")
+                else:
+                    print_fail(f"Project deletion failed: {resp.status_code} {resp.text}")
+                    
+            except Exception as e:
+                print_fail(f"Cleanup failed: {e}")
+
+    def run(self):
+        print_header("🚀 STARTING COMPREHENSIVE EPSIMO SKILL TEST 🚀")
+        self.step_1_auth()
+        self.step_2_projects()
+        self.step_3_assistants()
+        self.step_4_files()
+        self.step_5_threads()
+        self.step_6_execution()
+        self.step_7_credits_check()
+        self.step_8_cleanup()
+        print_header("🏁 TEST SUITE COMPLETE 🏁")
+
+if __name__ == "__main__":
+    tester = SkillTester()
+    tester.run()

package/scripts/test_sdk.py

@@ -0,0 +1,83 @@
+
+import sys
+import os
+import time
+# Add the current directory to sys.path so we can import 'epsimo' and 'scripts'
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from epsimo import EpsimoClient
+# Reuse auth helper to get a token for testing
+from scripts.auth import get_token
+
+def test_sdk():
+    print("🚀 Testing Epsimo Python SDK...")
+    
+    # Authenticate
+    token = get_token()
+    client = EpsimoClient(api_key=token)
+    print("✅ Client initialized")
+
+    # 1. Create Project
+    p_name = f"SDK Test {int(time.time())}"
+    print(f"Creating project '{p_name}'...")
+    project = client.projects.create(name=p_name, description="SDK Test Project")
+    p_id = project["project_id"]
+    print(f"✅ Project Created: {p_id}")
+
+    # 2. Create Assistant
+    print("Creating assistant...")
+    asst = client.assistants.create(
+        project_id=p_id, 
+        name="SDK Bot", 
+        instructions="You are a bot created via the SDK.",
+        model="gpt-4o"
+    )
+    a_id = asst["assistant_id"]
+    print(f"✅ Assistant Created: {a_id}")
+
+    # 3. Create Thread
+    print("Creating thread...")
+    thread = client.threads.create(project_id=p_id, name="SDK Thread", assistant_id=a_id)
+    t_id = thread["thread_id"]
+    print(f"✅ Thread Created: {t_id}")
+
+    # 4. Stream Run
+    print("Streaming run...")
+    print("--- Output ---")
+    stream = client.threads.run_stream(
+        project_id=p_id,
+        thread_id=t_id,
+        assistant_id=a_id,
+        message="Say 'Hello from SDK'"
+    )
+    
+    full_text = ""
+    for chunk in stream:
+        # print(f"DEBUG CHUNK: {chunk}")
+        content_found = None
+        
+        if isinstance(chunk, list):
+            for item in chunk:
+                if isinstance(item, dict) and "content" in item:
+                    content_found = item["content"]
+                    break # Usually one message per chunk update in this mode
+        elif isinstance(chunk, dict) and "content" in chunk:
+            content_found = chunk["content"]
+            
+        if content_found:
+            sys.stdout.write(content_found)
+            full_text += content_found
+            
+    print("\n--- End Output ---")
+    if "Hello from SDK" in full_text:
+        print("✅ Streaming Success")
+    else:
+        print("⚠️ Streaming finished but expected text not found.")
+
+    # 5. Cleanup
+    print("Cleaning up...")
+    client.projects.delete(p_id, confirm=True)
+    print("✅ Project Deleted")
+
+if __name__ == "__main__":
+    test_sdk()