decodingtrust-agent-sdk 0.1.0__py3-none-any.whl

dt_arena/mcp_server/snowflake/probe.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""
+Probe client for the local Snowflake MCP server (HTTP JSON-RPC over SSE).
+FastMCP HTTP transport requires Accept: application/json, text/event-stream and
+maintains a session via cookies. Responses are Server-Sent Events with lines:
+  event: message
+  data: {...json...}
+We parse those 'data' lines and print the JSON.
+"""
+import os
+import json
+import httpx
+
+HOST = os.getenv("HOST", "127.0.0.1")
+PORT = int(os.getenv("PORT", "8842"))
+BASE = f"http://{HOST}:{PORT}/mcp"
+
+
+def _ingest_set_cookie(client: httpx.Client, r: httpx.Response) -> None:
+    sc = r.headers.get("set-cookie", "")
+    if not sc:
+        return
+    parts = sc.split(",")
+    for part in parts:
+        kv = part.split(";", 1)[0].strip()
+        if "=" in kv:
+            name, value = kv.split("=", 1)
+            if name and value:
+                client.cookies.set(name.strip(), value.strip())
+
+
+def sse_rpc(client: httpx.Client, method: str, params: dict, extra_headers: dict | None = None) -> dict:
+    payload = {"jsonrpc": "2.0", "id": method, "method": method, "params": params}
+    headers = extra_headers or {}
+    # Try SSE first
+    with client.stream("POST", BASE, json=payload, headers=headers) as r:
+        _ingest_set_cookie(client, r)
+        for line in r.iter_lines():
+            if not line:
+                continue
+            s = line.decode("utf-8") if isinstance(line, (bytes, bytearray)) else line
+            if s.startswith("data:"):
+                data_str = s[len("data:"):].strip()
+                try:
+                    return json.loads(data_str)
+                except Exception:
+                    return {"raw": data_str}
+    # Fallback to non-stream JSON POST
+    try:
+        resp = client.post(BASE, json=payload, headers=headers)
+        if resp.headers.get("set-cookie"):
+            _ingest_set_cookie(client, resp)
+        resp.raise_for_status()
+        return resp.json()
+    except Exception:
+        return {"error": "no data"}
+
+
+def main():
+    headers = {
+        "Accept": "application/json, text/event-stream",
+        "Content-Type": "application/json",
+    }
+    with httpx.Client(timeout=20.0, headers=headers) as client:
+        # Initialize non-stream to capture session/cookies reliably
+        init_payload = {
+            "jsonrpc": "2.0",
+            "id": "initialize",
+            "method": "initialize",
+            "params": {
+                "protocolVersion": "2025-06-18",
+                "capabilities": {"experimental": {}, "tools": {}, "resources": {}, "prompts": {}},
+                "clientInfo": {"name": "probe", "version": "1.0"},
+            },
+        }
+        init_resp = client.post(BASE, json=init_payload)
+        _ingest_set_cookie(client, init_resp)
+        session_id = init_resp.headers.get("mcp-session-id")
+        extra = {"mcp-session-id": session_id} if session_id else None
+        try:
+            init_json = init_resp.json()
+        except Exception:
+            init_json = {"status": init_resp.status_code, "text": init_resp.text}
+        print("== initialize", json.dumps(init_json, indent=2))
+
+        # tools/list
+        tl_res = sse_rpc(client, "tools/list", {}, extra_headers=extra)
+        print("== tools/list", json.dumps(tl_res, indent=2))
+        # sql_exec_tool
+        sql_res = sse_rpc(client, "tools/call",
+                          {"name": "sql_exec_tool", "arguments": {"sql": "SELECT 1"}},
+                          extra_headers=extra)
+        print("== tools/call sql_exec_tool", json.dumps(sql_res, indent=2))
+        # product-search
+        ps_res = sse_rpc(client, "tools/call",
+                         {"name": "product-search", "arguments": {"query": "laptop", "limit": 3}},
+                         extra_headers=extra)
+        print("== tools/call product-search", json.dumps(ps_res, indent=2))
+        # revenue-semantic-view
+        an_res = sse_rpc(client, "tools/call",
+                         {"name": "revenue-semantic-view", "arguments": {"message": "top revenue"}},
+                         extra_headers=extra)
+        print("== tools/call revenue-semantic-view", json.dumps(an_res, indent=2))
+        # agent_1
+        ag_res = sse_rpc(client, "tools/call",
+                         {"name": "agent_1", "arguments": {"message": "draft a summary"}},
+                         extra_headers=extra)
+        print("== tools/call agent_1", json.dumps(ag_res, indent=2))
+
+
+if __name__ == "__main__":
+    main()
+
+if False and __name__ == "__main__":
+    main()
+import json
+import http.client
+from typing import Any, Dict
+
+HOST = "127.0.0.1"
+PORT = 8842
+PATH = "/mcp"
+HEADERS = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+}
+
+def rpc(method: str, params: Dict[str, Any], extra_headers: Dict[str, str] | None = None) -> tuple[int, str, dict[str, str]]:
+    conn = http.client.HTTPConnection(HOST, PORT, timeout=20)
+    req = {"jsonrpc": "2.0", "id": method, "method": method, "params": params}
+    headers = dict(HEADERS)
+    if extra_headers:
+        headers.update(extra_headers)
+    conn.request("POST", PATH, body=json.dumps(req).encode("utf-8"), headers=headers)
+    resp = conn.getresponse()
+    data = resp.read().decode("utf-8", errors="replace")
+    headers_out = {k.lower(): v for k, v in resp.getheaders()}
+    conn.close()
+    return resp.status, data, headers_out
+
+def try_initialize() -> None:
+    payloads = [
+        {"protocolVersion": "2025-06-18"},
+        {"protocolVersion": "2025-06-18", "capabilities": {"tools": {}}},
+        {"protocolVersion": "2025-06-18", "capabilities": {"tools": {"listChanged": False}}},
+    ]
+    for p in payloads:
+        code, data, headers = rpc("initialize", p)
+        print(f"\n== initialize ({p}) -> {code}\n{data}")
+        if "mcp-session-id" in headers:
+            print(f"session: {headers['mcp-session-id']}")
+
+def main() -> None:
+    # Initialize and capture session id
+    init_params = {
+        "protocolVersion": "2025-06-18",
+        "capabilities": {},
+        "clientInfo": {"name": "probe-client", "version": "0.0.1"},
+    }
+    code, data, headers = rpc("initialize", init_params)
+    print(f"\n== initialize -> {code}\n{data}")
+    session = headers.get("mcp-session-id")
+    extra = {"mcp-session-id": session} if session else {}
+    # tools/list
+    code, data, _ = rpc("tools/list", {}, extra_headers=extra)
+    print(f"\n== tools/list -> {code}\n{data}")
+    # tools/call sql_exec_tool
+    code, data, _ = rpc("tools/call", {"name": "sql_exec_tool", "arguments": {"sql": "SELECT 1"}}, extra_headers=extra)
+    print(f"\n== tools/call sql_exec_tool -> {code}\n{data}")
+    # tools/call product-search
+    code, data, _ = rpc("tools/call", {"name": "product-search", "arguments": {"query": "revenue", "limit": 2}}, extra_headers=extra)
+    print(f"\n== tools/call product-search -> {code}\n{data}")
+    # tools/call revenue-semantic-view
+    code, data, _ = rpc("tools/call", {"name": "revenue-semantic-view", "arguments": {"message": "Revenue by region last quarter?"}}, extra_headers=extra)
+    print(f"\n== tools/call revenue-semantic-view -> {code}\n{data}")
+    # tools/call agent_1
+    code, data, _ = rpc("tools/call", {"name": "agent_1", "arguments": {"message": "Draft a summary for the drill"}}, extra_headers=extra)
+    print(f"\n== tools/call agent_1 -> {code}\n{data}")
+
+if __name__ == "__main__":
+    main()
+
+

dt_arena/mcp_server/telecom/mcp_client.py

@@ -0,0 +1,423 @@
+#!/usr/bin/env python3
+"""
+Test client for Telecom MCP Server
+Tests various telecom server endpoints using direct HTTP requests.
+"""
+import os
+import sys
+import json
+import requests
+
+# Telecom server configuration
+TELECOM_HOST = os.getenv("TELECOM_HOST", "localhost")
+TELECOM_PORT = os.getenv("TELECOM_PORT", "10301")
+TIMEOUT = 30
+
+BASE_URL = f"http://{TELECOM_HOST}:{TELECOM_PORT}"
+
+
+def send_get(endpoint: str, params: dict = None) -> dict:
+    """Send GET request to telecom server."""
+    url = f"{BASE_URL}/{endpoint}"
+    try:
+        resp = requests.get(url, params=params, timeout=TIMEOUT)
+        resp.raise_for_status()
+        return resp.json()
+    except requests.exceptions.RequestException as e:
+        return {"status": "error", "result": f"Request failed: {str(e)}"}
+
+
+def send_post(endpoint: str, data: dict) -> dict:
+    """Send POST request to telecom server."""
+    url = f"{BASE_URL}/{endpoint}"
+    try:
+        resp = requests.post(url, json=data, timeout=TIMEOUT)
+        resp.raise_for_status()
+        return resp.json()
+    except requests.exceptions.RequestException as e:
+        return {"status": "error", "result": f"Request failed: {str(e)}"}
+
+
+def print_result(title: str, result: dict):
+    """Print test result in a formatted way."""
+    print(f"\n{title}")
+    print("-" * 60)
+    if isinstance(result, dict):
+        status = result.get("status", "unknown")
+        result_data = result.get("result", result)
+        print(f"Status: {status}")
+        if isinstance(result_data, (dict, list)):
+            print(f"Result: {json.dumps(result_data, indent=2)}")
+        else:
+            print(f"Result: {result_data}")
+    else:
+        print(f"Result: {result}")
+    print("-" * 60)
+
+
+def test_customer_operations():
+    """Test customer CRUD operations."""
+    print("\n" + "="*60)
+    print("Test: Customer Operations")
+    print("="*60)
+    
+    customer_id = "TEST_CUST_001"
+    
+    # Test 1: Add customer
+    # Required fields: id, name, area, address, email, phone, plan
+    print("\n1. Adding customer...")
+    result = send_post("add_customer", {
+        "id": customer_id,
+        "name": "Test Customer",
+        "area": "Downtown",
+        "address": "123 Test St, Test City",
+        "email": "test@example.com",
+        "phone": "555-0100",
+        "plan": "Premium"
+    })
+    print_result("Add Customer", result)
+    
+    # Test 2: Query customer
+    print("\n2. Querying customer...")
+    result = send_get("query_customer", {"id": customer_id})
+    print_result("Query Customer", result)
+    
+    # Test 3: Update customer
+    # Valid fields: id, name, area, address, email, phone, plan
+    print("\n3. Updating customer...")
+    result = send_post("update_customer", {
+        "id": customer_id,
+        "field": "plan",
+        "value": "Fiber 1 Gbps"
+    })
+    print_result("Update Customer", result)
+    
+    # Test 4: Remove customer
+    print("\n4. Removing customer...")
+    result = send_post("remove_customer", {"id": customer_id})
+    print_result("Remove Customer", result)
+    
+    return True
+
+
+def test_account_operations():
+    """Test account CRUD operations."""
+    print("\n" + "="*60)
+    print("Test: Account Operations")
+    print("="*60)
+    
+    customer_id = "TEST_CUST_002"
+    
+    # First create a customer
+    # Required fields: id, name, area, address, email, phone, plan
+    print("\n0. Creating customer for account test...")
+    send_post("add_customer", {
+        "id": customer_id,
+        "name": "Account Test Customer",
+        "area": "Downtown",
+        "address": "456 Account St, Test City",
+        "email": "account@example.com",
+        "phone": "555-0200",
+        "plan": "Premium"
+    })
+    
+    # Test: Add account - ONLY valid fields: customer_id, account_name, password
+    print("\n1. Adding account...")
+    result = send_post("add_account", {
+        "customer_id": customer_id,
+        "account_name": "ACC_TEST_001",
+        "password": "testpass123"
+    })
+    print_result("Add Account", result)
+    
+    # Test: Query account
+    print("\n2. Querying account...")
+    result = send_get("query_account", {"customer_id": customer_id})
+    print_result("Query Account", result)
+    
+    return True
+
+
+def test_bill_operations():
+    """Test bill operations."""
+    print("\n" + "="*60)
+    print("Test: Bill Operations")
+    print("="*60)
+    
+    customer_id = "TEST_CUST_003"
+    
+    # Test: Add bill - ONLY valid fields: customer_id, amount, credits
+    print("\n1. Adding bill...")
+    result = send_post("add_bill", {
+        "customer_id": customer_id,
+        "amount": "99.99",
+        "credits": "0.00"
+    })
+    print_result("Add Bill", result)
+    
+    # Test: Query bill
+    print("\n2. Querying bill...")
+    result = send_get("query_bill", {"customer_id": customer_id})
+    print_result("Query Bill", result)
+    
+    return True
+
+
+def test_ticket_operations():
+    """Test ticket operations."""
+    print("\n" + "="*60)
+    print("Test: Ticket Operations")
+    print("="*60)
+    
+    customer_id = "TEST_CUST_004"
+    ticket_id = "TKT_TEST_001"
+    
+    # Test: Add ticket - ONLY valid fields: id, customer_id, issue, created_at_iso, status
+    print("\n1. Adding ticket...")
+    result = send_post("add_ticket", {
+        "id": ticket_id,
+        "customer_id": customer_id,
+        "issue": "Testing ticket creation",
+        "created_at_iso": "2024-01-15T10:00:00",
+        "status": "open"
+    })
+    print_result("Add Ticket", result)
+    
+    # Test: Query ticket
+    print("\n2. Querying ticket...")
+    result = send_get("query_ticket", {"id": ticket_id})
+    print_result("Query Ticket", result)
+    
+    # Test: Update ticket
+    print("\n3. Updating ticket...")
+    result = send_post("update_ticket", {
+        "id": ticket_id,
+        "field": "status",
+        "value": "in_progress"
+    })
+    print_result("Update Ticket", result)
+    
+    return True
+
+
+def test_sms_operations():
+    """Test SMS operations."""
+    print("\n" + "="*60)
+    print("Test: SMS Operations")
+    print("="*60)
+    
+    sms_id = "SMS_TEST_001"
+    
+    # Test: Add SMS - ONLY valid fields: id, customer_id, body, sent_at_iso
+    print("\n1. Adding SMS...")
+    result = send_post("add_sms", {
+        "id": sms_id,
+        "customer_id": "TEST_CUST_001",
+        "body": "Test SMS message",
+        "sent_at_iso": "2024-01-15T14:30:00"
+    })
+    print_result("Add SMS", result)
+    
+    # Test: Query SMS
+    print("\n2. Querying SMS...")
+    result = send_get("query_sms", {"id": sms_id})
+    print_result("Query SMS", result)
+    
+    return True
+
+
+def test_email_operations():
+    """Test email operations."""
+    print("\n" + "="*60)
+    print("Test: Email Operations")
+    print("="*60)
+    
+    email_id = "EMAIL_TEST_001"
+    
+    # Test: Add email - ONLY valid fields: id, customer_id, subject, body, sent_at_iso
+    print("\n1. Adding email...")
+    result = send_post("add_email", {
+        "id": email_id,
+        "customer_id": "TEST_CUST_001",
+        "subject": "Test Email",
+        "body": "This is a test email message.",
+        "sent_at_iso": "2024-01-15T14:30:00"
+    })
+    print_result("Add Email", result)
+    
+    # Test: Query email
+    print("\n2. Querying email...")
+    result = send_get("query_email", {"id": email_id})
+    print_result("Query Email", result)
+    
+    return True
+
+
+def test_order_operations():
+    """Test order operations."""
+    print("\n" + "="*60)
+    print("Test: Order Operations")
+    print("="*60)
+    
+    order_id = "ORD_TEST_001"
+    customer_id = "TEST_CUST_005"
+    
+    # Test: Add order
+    print("\n1. Adding order...")
+    result = send_post("add_order", {
+        "order_id": order_id,
+        "customer_id": customer_id,
+        "item": "Premium Plan",
+        "price": "99.99",
+        "purchase_date_iso": "2024-01-15T00:00:00",
+        "channel": "online",
+        "requires_ra": "false",
+        "is_prepaid_or_gift": "false",
+        "accessories_present": "false",
+        "original_packaging": "true",
+        "damaged_or_altered": "false",
+        "shipping_and_handling": "5.00"
+    })
+    print_result("Add Order", result)
+    
+    # Test: Query order
+    print("\n2. Querying order...")
+    result = send_get("query_order", {"order_id": order_id})
+    print_result("Query Order", result)
+    
+    return True
+
+
+def test_calendar_event_operations():
+    """Test calendar event operations."""
+    print("\n" + "="*60)
+    print("Test: Calendar Event Operations")
+    print("="*60)
+    
+    event_id = "EVT_TEST_001"
+    customer_id = "TEST_CUST_006"
+    
+    # Test: Add calendar event
+    print("\n1. Adding calendar event...")
+    result = send_post("add_calendar_event", {
+        "id": event_id,
+        "customer_id": customer_id,
+        "title": "Test Meeting",
+        "description": "Test calendar event",
+        "start_time_iso": "2024-02-01T10:00:00",
+        "end_time_iso": "2024-02-01T11:00:00"
+    })
+    print_result("Add Calendar Event", result)
+    
+    # Test: Query calendar event
+    print("\n2. Querying calendar event...")
+    result = send_get("query_calendar_event", {"id": event_id})
+    print_result("Query Calendar Event", result)
+    
+    return True
+
+
+def test_outage_operations():
+    """Test outage operations."""
+    print("\n" + "="*60)
+    print("Test: Outage Operations")
+    print("="*60)
+    
+    area = "TEST_AREA_001"
+    
+    # Test: Add outage
+    print("\n1. Adding outage...")
+    result = send_post("add_outage", {
+        "area": area,
+        "description": "Test outage",
+        "eta_in_hours": "2",
+        "eta_iso": "2024-01-15T12:00:00"
+    })
+    print_result("Add Outage", result)
+    
+    # Test: Query outage
+    print("\n2. Querying outage...")
+    result = send_get("query_outage", {"area": area})
+    print_result("Query Outage", result)
+    
+    return True
+
+
+def test_utility_operations():
+    """Test utility operations."""
+    print("\n" + "="*60)
+    print("Test: Utility Operations")
+    print("="*60)
+    
+    # Test: Reload all tables
+    print("\n1. Reloading all tables...")
+    result = send_post("reload_all", {})
+    print_result("Reload All Tables", result)
+    
+    return True
+
+
+def test_server_health():
+    """Test if server is accessible."""
+    print("\n" + "="*60)
+    print("Test: Server Health Check")
+    print("="*60)
+    
+    try:
+        result = send_get("")
+        print_result("Server Health", result)
+        return True
+    except Exception as e:
+        print(f"✗ Server not accessible: {e}")
+        return False
+
+
+def run_all_tests():
+    """Run all test cases."""
+    print("\n" + "="*60)
+    print("Telecom Server Test Suite")
+    print("="*60)
+    print(f"Server URL: {BASE_URL}")
+    print("="*60)
+    
+    # Test server health first
+    if not test_server_health():
+        print("\n✗ Server is not accessible. Please make sure the telecom server is running.")
+        print(f"Expected server at: {BASE_URL}")
+        return
+    
+    # Run all tests
+    tests = [
+        ("Customer Operations", test_customer_operations),
+        # ("Account Operations", test_account_operations),
+        # ("Bill Operations", test_bill_operations),
+        # ("Ticket Operations", test_ticket_operations),
+        # ("SMS Operations", test_sms_operations),
+        # ("Email Operations", test_email_operations),
+        # ("Order Operations", test_order_operations),
+        # ("Calendar Event Operations", test_calendar_event_operations),
+        # ("Outage Operations", test_outage_operations),
+        # ("Utility Operations", test_utility_operations),
+    ]
+    
+    results = []
+    for test_name, test_func in tests:
+        try:
+            result = test_func()
+            results.append((test_name, result))
+        except Exception as e:
+            print(f"\n✗ {test_name} failed with error: {e}")
+            results.append((test_name, False))
+    
+    # Print summary
+    print("\n" + "="*60)
+    print("Test Summary")
+    print("="*60)
+    for test_name, result in results:
+        status = "✓ PASSED" if result else "✗ FAILED"
+        print(f"{status}: {test_name}")
+    print("="*60)
+
+
+if __name__ == "__main__":
+    run_all_tests()