epsimo-agent 0.1.0

package/scripts/test_streaming.py

@@ -0,0 +1,167 @@
+
+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'
+    OKGREEN = '\033[92m'
+    OKCYAN = '\033[96m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+
+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 run_streaming_test():
+    print(f"{Colors.HEADER}=== Starting Assistant Streaming Verification ==={Colors.ENDC}")
+
+    # 1. Auth
+    try:
+        token = get_token()
+        print_pass("Authenticated")
+    except Exception as e:
+        print_fail(f"Auth failed: {e}")
+        return
+
+    # 2. Project
+    project_name = f"StreamTest {int(time.time())}"
+    print_info(f"Creating project '{project_name}'...")
+    headers = {"Authorization": f"Bearer {token}"}
+    
+    try:
+        resp = requests.post(f"{API_BASE_URL}/projects/", headers=headers, json={"name": project_name, "description": "Streaming test"})
+        resp.raise_for_status()
+        project_id = resp.json()["project_id"]
+        project_token = get_project_token(project_id)
+        print_pass(f"Project created: {project_id}")
+    except Exception as e:
+        print_fail(f"Project creation failed: {e}")
+        return
+
+    # 3. Assistant
+    print_info("Creating simple assistant...")
+    p_headers = {"Authorization": f"Bearer {project_token}"}
+    
+    asst_payload = {
+        "name": "Streaming Bot",
+        "config": {
+            "configurable": {
+                "type": "agent",
+                "type==agent/agent_type": "GPT-4O",
+                "type==agent/model": "gpt-4o",
+                "type==agent/system_message": "You are a helpful assistant. If asked to say something, say it exactly."
+            }
+        },
+        "public": False
+    }
+
+    try:
+        resp = requests.post(f"{API_BASE_URL}/assistants/", headers=p_headers, json=asst_payload)
+        resp.raise_for_status()
+        assistant_id = resp.json()["assistant_id"]
+        print_pass(f"Assistant created: {assistant_id}")
+    except Exception as e:
+        print_fail(f"Assistant creation failed: {e}")
+        return
+
+    # 4. Thread
+    print_info("Creating thread...")
+    try:
+        resp = requests.post(f"{API_BASE_URL}/threads/", headers=p_headers, json={"name": "Stream Thread", "assistant_id": assistant_id})
+        resp.raise_for_status()
+        thread_id = resp.json()["thread_id"]
+        print_pass(f"Thread created: {thread_id}")
+    except Exception as e:
+        print_fail(f"Thread creation failed: {e}")
+        return
+
+    # 5. Streaming Run
+    print_info("Ref: sending message 'Say: STREAMING_WORKS'...")
+    
+    stream_headers = {
+        "Authorization": f"Bearer {project_token}",
+        "Accept": "text/event-stream"
+    }
+    
+    run_payload = {
+        "thread_id": thread_id,
+        "assistant_id": assistant_id,
+        "input": [{"role": "user", "content": "Say: STREAMING_WORKS", "type": "human"}],
+        "stream_mode": ["messages", "values"]
+    }
+
+    full_text = ""
+    print(f"{Colors.OKCYAN}--- Stream Output Start ---{Colors.ENDC}")
+    
+    try:
+        with requests.post(f"{API_BASE_URL}/runs/stream", headers=stream_headers, json=run_payload, stream=True) as r:
+            r.raise_for_status()
+            for line in r.iter_lines():
+                if line:
+                    decoded = line.decode('utf-8')
+                    if decoded.startswith("data:"):
+                        data_str = decoded[5:].strip()
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            # Attempt to parse json to find content (structure varies, so we print raw for debug if needed)
+                            # Or just heuristic text accumulation
+                             # Epsimo / LangGraph usually sends complex JSONs
+                            data_json = json.loads(data_str)
+                            
+                            # Heuristic extraction for various formats
+                            content = ""
+                            if isinstance(data_json, list): # Often a list of ops
+                                for item in data_json:
+                                    if "content" in item:
+                                        content = item["content"]
+                            elif isinstance(data_json, dict):
+                                if "messages" in data_json:
+                                     # Extract last message content
+                                     pass 
+                                if "content" in data_json:
+                                    content = data_json["content"]
+                            
+                            # Simple visual echo 
+                            if content:
+                                sys.stdout.write(content)
+                                sys.stdout.flush()
+                                full_text += content
+                            else:
+                                # Fallback if we can't parse structure easily, just check raw for test
+                                pass
+                        except:
+                            pass
+                            
+        print(f"\n{Colors.OKCYAN}--- Stream Output End ---{Colors.ENDC}")
+        
+        if "STREAMING_WORKS" in full_text:
+            print_pass("Verification Successful: Received expected output!")
+        else:
+            print_fail("Did not receive exact expected phrase, but stream finished.")
+            print_info(f"Received total length: {len(full_text)}")
+
+    except Exception as e:
+        print_fail(f"Streaming failed: {e}")
+
+    # 6. Cleanup
+    try:
+        requests.delete(f"{API_BASE_URL}/projects/{project_id}?confirm=true", headers=headers)
+        print_pass("Cleanup: Project deleted")
+    except:
+        pass
+
+if __name__ == "__main__":
+    run_streaming_test()

package/scripts/test_vdb.py

@@ -0,0 +1,65 @@
+import sys
+import os
+import json
+
+# Add parent dir to path to find epsimo package
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from epsimo import EpsimoClient
+from epsimo.auth import get_token
+
+def test_vdb():
+    print("🧪 Testing Virtual Database via Threads...")
+    
+    # Needs a real project and thread from the user's environment
+    PROJECT_ID = "cb323eb1-768e-4702-b7af-c73a1d6ce0e1"
+    
+    try:
+        token = get_token()
+        client = EpsimoClient(api_key=token)
+        
+        # 1. Create a fresh thread for DB testing
+        print("Creating fresh DB thread...")
+        # Get an assistant first
+        assistants = client.assistants.list(PROJECT_ID)
+        if not assistants:
+            print("❌ No assistants found in project.")
+            return
+        
+        asst_id = assistants[0]["assistant_id"]
+        thread = client.threads.create(PROJECT_ID, "Virtual DB Test", asst_id)
+        thread_id = thread["thread_id"]
+        print(f"✅ Thread Created: {thread_id}")
+        
+        # 2. Set some structured data
+        print("Setting data in DB...")
+        db_data = {
+            "user_settings": {
+                "theme": "dark",
+                "notifications": True
+            },
+            "last_login": "2026-02-03",
+            "active_session": True
+        }
+        
+        client.threads.set_state(PROJECT_ID, thread_id, db_data)
+        print("✅ Data persisted.")
+        
+        # 3. Retrieve and verify
+        print("Querying DB...")
+        state = client.threads.get_state(PROJECT_ID, thread_id)
+        values = state.get("values", {})
+        
+        print("\n=== Virtual DB Content ===")
+        print(json.dumps(values, indent=2))
+        
+        if values.get("user_settings", {}).get("theme") == "dark":
+            print("\n🎉 SUCCESS: Virtual Database is working correctly!")
+        else:
+            print("\n❌ FAILURE: Data mismatch or not found.")
+            
+    except Exception as e:
+        print(f"❌ Test Failed: {e}")
+
+if __name__ == "__main__":
+    test_vdb()

package/scripts/thread.py

@@ -0,0 +1,77 @@
+
+import os
+import sys
+import argparse
+import requests
+import json
+from auth import get_token, get_project_token, API_BASE_URL
+
+def create_thread(project_id, name, assistant_id=None):
+    token = get_token()
+    
+    # Get project specific token
+    project_token = get_project_token(project_id)
+
+    headers = {"Authorization": f"Bearer {project_token}"}
+    
+    # Metadata structure from frontend
+    payload = {
+        "name": name,
+        "metadata": {
+            "configurable": {},
+            "type": "thread"
+        },
+        "configurable": {
+             "type": "agent"
+        }
+    }
+    if assistant_id:
+        payload["assistant_id"] = assistant_id
+        
+    response = requests.post(f"{API_BASE_URL}/threads/", headers=headers, json=payload)
+    
+    if not response.ok:
+        print(f"Status: {response.status_code}")
+        print(f"Body: {response.text}")
+        
+    response.raise_for_status()
+    print(json.dumps(response.json(), indent=2))
+
+def list_threads(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}/threads/", headers=headers)
+    response.raise_for_status()
+    print(json.dumps(response.json(), indent=2))
+
+def main():
+    parser = argparse.ArgumentParser(description="Manage EpsimoAI Threads")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # List
+    list_parser = subparsers.add_parser("list", help="List threads 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 thread")
+    create_parser.add_argument("--project-id", required=True, help="Project ID")
+    create_parser.add_argument("--name", default="New Thread", help="Thread name")
+    create_parser.add_argument("--assistant-id", help="Assistant ID to associate with the thread (optional)")
+
+    args = parser.parse_args()
+
+    if args.command == "list":
+        list_threads(args.project_id)
+    elif args.command == "create":
+        create_thread(args.project_id, args.name, args.assistant_id)
+
+if __name__ == "__main__":
+    main()

package/scripts/verify_skill.py

@@ -0,0 +1,87 @@
+
+import subprocess
+import sys
+import json
+import time
+import os
+import shutil
+
+def run_command(cmd, capture_output=True):
+    print(f"Running: {cmd}")
+    # Add PYTHONPATH to find epsimo package
+    env = os.environ.copy()
+    env["PYTHONPATH"] = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    
+    result = subprocess.run(cmd, shell=True, capture_output=capture_output, text=True, env=env)
+    if result.returncode != 0:
+        print(f"Error: {result.stderr}")
+        raise Exception(f"Command failed: {cmd}")
+    return result.stdout.strip()
+
+def main():
+    print("🚀 Starting Epsimo Agent Skill Verification (CLI Version)...")
+    
+    # 1. Auth Check - we do this in the root to ensure we have credentials
+    print("\n1️⃣  Checking Authentication...")
+    try:
+        run_command("python3 -m epsimo.cli whoami") 
+    except:
+        print("🔐 Authentication required. Please run 'epsimo auth login' first.")
+        sys.exit(1)
+        
+    # Setup temp workspace
+    temp_workspace = f"verify-workspace-{int(time.time())}"
+    os.makedirs(temp_workspace)
+    orig_dir = os.getcwd()
+    os.chdir(temp_workspace)
+    print(f"📂 Created temporary workspace: {temp_workspace}")
+
+    try:
+        # 2. Project Scaffolding
+        print("\n2️⃣  Verifying Project Scaffolding...")
+        test_slug = "verify-app"
+        run_command(f"python3 -m epsimo.cli create 'Verify App'")
+        if os.path.exists(test_slug) and os.path.exists(f"{test_slug}/epsimo.yaml"):
+            print("✅ Scaffolding SUCCESS: App structure created.")
+        else:
+            raise Exception("App structure missing files.")
+        
+        # 3. End-to-End lifecycle
+        print("\n3️⃣  Verifying Project/Assistant Lifecycle...")
+        proj_name = f"VerifyProj-{int(time.time())}"
+        run_command(f"python3 -m epsimo.cli init --name '{proj_name}'")
+        
+        with open("epsimo.yaml", "r") as f:
+            import yaml
+            cfg = yaml.safe_load(f)
+            project_id = cfg['project_id']
+        
+        print(f"✅ Created Project: {project_id}")
+        
+        # Deploy (creates assistant)
+        run_command("python3 -m epsimo.cli deploy")
+        print("✅ Deployed Assistant.")
+
+        # Discovery Check
+        asst_json = run_command(f"python3 -m epsimo.cli assistants --project-id {project_id} --json")
+        assistants = json.loads(asst_json)
+        if not assistants:
+            raise Exception("No assistants found after deploy.")
+        
+        print(f"✅ Discovery SUCCESS: Found {len(assistants)} assistants.")
+
+        # 4. Logic responsive check
+        print("\n4️⃣  Checking Credits...")
+        run_command("python3 -m epsimo.cli credits balance")
+        print("✅ Logic Check: Responsive.")
+
+    finally:
+        os.chdir(orig_dir)
+        if os.path.exists(temp_workspace):
+            shutil.rmtree(temp_workspace)
+
+    print("\n🎉 Skill Verification Completed Successfully!")
+
+if __name__ == "__main__":
+    main()
+