Threads

1
import os
2
3
BASE_URL = os.getenv("INVESTING_ASSISTANT_BASE_URL", "https://alfa.boosted.ai")
4
API_KEY = os.environ["INVESTING_ASSISTANT_API_KEY"]
5
6
def auth_headers():
7
    return {"x-api-key": API_KEY, "Content-Type": "application/json"}
8
9
def get_history(thread_id: str, *, start_index: int = 0, limit_num: int = 50) -> list[dict]:
10
    params = {"start_index": start_index, "limit_num": limit_num}
11
    resp = requests.get(
12
        f"{BASE_URL}/client/v1/threads/{thread_id}/messages",
13
        headers=auth_headers(),
14
        params=params,
15
        timeout=30,
16
    )
17
    resp.raise_for_status()
18
    return resp.json()["messages"]
19
20
def get_artifact(thread_id: str, artifact_id: str) -> dict:
21
    resp = requests.get(
22
        f"{BASE_URL}/client/v1/threads/{thread_id}/artifacts/{artifact_id}",
23
        headers=auth_headers(),
24
        timeout=30,
25
    )
26
    resp.raise_for_status()
27
    return resp.json()["artifact"]

1
import os
2
3
BASE_URL = os.getenv("INVESTING_ASSISTANT_BASE_URL", "https://alfa.boosted.ai")
4
API_KEY = os.environ["INVESTING_ASSISTANT_API_KEY"]
5
6
def upload_user_file(thread_id: str, file_path: str) -> dict:
7
    with open(file_path, "rb") as fh:
8
        files = {"file": fh}
9
        resp = requests.post(
10
            f"{BASE_URL}/client/v1/threads/{thread_id}/files",
11
            headers={"x-api-key": API_KEY},
12
            files=files,
13
            timeout=60,
14
        )
15
    resp.raise_for_status()
16
    return resp.json()
17
18
response = upload_user_file(thread_id, "documents/q2.pdf")
19
print("Uploaded file:", response["file_id"])

1
def cancel_thread_task(thread_id: str) -> None:
2
    resp = requests.delete(
3
        f"{BASE_URL}/client/v1/threads/{thread_id}/task",
4
        headers=auth_headers(),
5
        timeout=15,
6
    )
7
    resp.raise_for_status()
8
9
cancel_thread_task(thread_id)

1
import json
2
import sys
3
import threading
4
import time
5
import requests
6
7
BASE_URL = "https://alfa.boosted.ai"
8
API_KEY = "your-api-key-here"
9
10
stream_connected = threading.Event()
11
stream_error = threading.Event()
12
13
def create_thread(thread_name):
14
    url = f"{BASE_URL}/client/v1/threads"
15
    headers = {
16
        "x-api-key": API_KEY,
17
        "Content-Type": "application/json"
18
    }
19
    data = {"thread_name": thread_name}
20
    
21
    response = requests.post(url, headers=headers, json=data)
22
    response.raise_for_status()
23
    return response.json()["thread_id"]
24
25
def send_message(thread_id, message):
26
    url = f"{BASE_URL}/client/v1/threads/{thread_id}/messages"
27
    headers = {"x-api-key": API_KEY}
28
    data = {"message": message}
29
    
30
    print(f"\nSending message...")
31
    response = requests.post(url, headers=headers, data=data)
32
    response.raise_for_status()
33
    print("Message sent successfully!")
34
    return response.json()
35
36
def stream_thread_events(thread_id):
37
    url = f"{BASE_URL}/client/v1/threads/stream/{thread_id}"
38
    headers = {
39
        "x-api-key": API_KEY,
40
        "Accept": "text/event-stream",
41
        "Cache-Control": "no-cache"
42
    }
43
    
44
    try:
45
        print("\nConnecting to event stream...")
46
        response = requests.get(url, headers=headers, stream=True, timeout=None)
47
        response.raise_for_status()
48
        
49
        print("Connected to stream, waiting for events...\n")
50
        stream_connected.set()
51
        
52
        for line in response.iter_lines(decode_unicode=True):
53
            if line:
54
                if line.startswith(':'):
55
                    continue
56
                    
57
                if line.startswith('data: '):
58
                    data = line[6:]
59
                    try:
60
                        event_data = json.loads(data)
61
                        event_type = event_data.get('event', {}).get('event_type', 'unknown')
62
                        
63
                        if event_type == 'message_chunk':
64
                            chunk = event_data['event'].get('message_chunk', {})
65
                            sys.stdout.write(chunk.get('message', ''))
66
                            sys.stdout.flush()
67
                            
68
                            if event_data['event'].get('final_chunk'):
69
                                print("\n-- final chunk --")
70
                        elif event_type == 'message':
71
                            print(f"\n\nComplete message received")
72
                        elif event_type == 'task_status' or event_type == 'execution_status':
73
                            status = event_data['event'].get('status', '')
74
                            if status == 'Complete':
75
                                print(f"\n\nTask completed!")
76
                                break
77
                        else:
78
                            print(f"\n[{event_type}]")
79
                    except json.JSONDecodeError:
80
                        print(f"Data: {data}")
81
                elif line.startswith('event: '):
82
                    event_type = line[7:]
83
                    if event_type == 'close':
84
                        print("\n\nStream closed by server")
85
                        break
86
                    
87
    except requests.exceptions.RequestException as e:
88
        print(f"\nStream error: {e}")
89
        stream_error.set()
90
    except Exception as e:
91
        print(f"\nUnexpected error: {e}")
92
        stream_error.set()
93
94
def main():
95
    try:
96
        print("Creating a new thread...")
97
        thread_id = create_thread("Research Thread")
98
        print(f"Thread created with ID: {thread_id}")
99
        
100
        message = input("\nEnter your message: ")
101
        
102
        stream_thread = threading.Thread(
103
            target=stream_thread_events, 
104
            args=(thread_id,), 
105
            daemon=True
106
        )
107
        stream_thread.start()
108
        
109
        if not stream_connected.wait(timeout=10):
110
            print("Failed to connect to stream within 10 seconds")
111
            return
112
        
113
        if stream_error.is_set():
114
            print("Stream connection failed")
115
            return
116
        
117
        time.sleep(0.5)
118
        
119
        send_message(thread_id, message)
120
        
121
        stream_thread.join(timeout=120)
122
        
123
        if stream_thread.is_alive():
124
            print("\n\nStream still active after 120 seconds, exiting...")
125
        
126
    except requests.exceptions.RequestException as e:
127
        print(f"Error: {e}")
128
        sys.exit(1)
129
    except KeyboardInterrupt:
130
        print("\n\nInterrupted by user")
131
        sys.exit(0)
132
133
if __name__ == "__main__":
134
    if API_KEY == "your-api-key-here":
135
        print("Please set your API key in the script before running.")
136
        sys.exit(1)
137
    main()