Open History to see the last commit
1#!/usr/bin/env python3
2
3import json
4import os
5import sys
6import urllib.error
7import urllib.request
8from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
9from typing import Any, Callable, Iterable
10
11HOST = "127.0.0.1"
12PORT = int(os.environ.get("PORT", "8006"))
13DEFAULT_OPENAI_MODEL = "gpt-4o"
14DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-6"
15
16
17def text_from_message(message: dict[str, Any]) -> str:
18 parts = message.get("parts")
19 if isinstance(parts, list):
20 text_parts = [
21 part["content"]
22 for part in parts
23 if isinstance(part, dict)
24 and part.get("type") == "text"
25 and isinstance(part.get("content"), str)
26 ]
27 if text_parts:
28 return "".join(text_parts)
29
30 content = message.get("content")
31 if isinstance(content, str):
32 return content
33 if isinstance(content, list):
34 return "".join(
35 item["text"]
36 for item in content
37 if isinstance(item, dict)
38 and item.get("type") == "text"
39 and isinstance(item.get("text"), str)
40 )
41 return ""
42
43
44def to_chat_messages(
45 messages: Any,
46) -> tuple[str, list[dict[str, str]]]:
47 system_parts: list[str] = []
48 chat: list[dict[str, str]] = []
49
50 if not isinstance(messages, list):
51 return "", chat
52
53 for message in messages:
54 if not isinstance(message, dict):
55 continue
56
57 role = message.get("role")
58 if role == "developer":
59 role = "system"
60 if role not in ("system", "user", "assistant"):
61 continue
62
63 text = text_from_message(message)
64 if not text:
65 continue
66
67 if role == "system":
68 system_parts.append(text)
69 else:
70 chat.append({"role": role, "content": text})
71
72 return "\n\n".join(system_parts), chat
73
74
75def props_from_input(input_data: dict[str, Any]) -> dict[str, Any]:
76 forwarded = input_data.get("forwardedProps")
77 if isinstance(forwarded, dict) and forwarded:
78 return forwarded
79
80 data = input_data.get("data")
81 if isinstance(data, dict):
82 return data
83
84 return {}
85
86
87def provider_from_input(input_data: dict[str, Any]) -> tuple[str, str]:
88 props = props_from_input(input_data)
89 provider = props.get("provider", "openai")
90 model = props.get("model", "")
91
92 if not isinstance(provider, str) or not provider:
93 provider = "openai"
94 if not isinstance(model, str):
95 model = ""
96
97 if provider == "openai":
98 return provider, model or DEFAULT_OPENAI_MODEL
99 if provider == "anthropic":
100 return provider, model or DEFAULT_ANTHROPIC_MODEL
101 raise RuntimeError(
102 f'unsupported provider "{provider}" (expected openai or anthropic)'
103 )
104
105
106def stream_provider_sse(
107 url: str,
108 headers: dict[str, str],
109 payload: dict[str, Any],
110) -> Iterable[dict[str, Any]]:
111 request = urllib.request.Request(
112 url,
113 data=json.dumps(payload).encode("utf-8"),
114 headers=headers,
115 method="POST",
116 )
117
118 try:
119 with urllib.request.urlopen(request, timeout=120) as response:
120 for raw_line in response:
121 line = raw_line.decode("utf-8").rstrip("\r\n")
122 if not line.startswith("data: "):
123 continue
124 data = line[6:]
125 if data == "[DONE]":
126 return
127 try:
128 parsed = json.loads(data)
129 except json.JSONDecodeError:
130 continue
131 if isinstance(parsed, dict):
132 yield parsed
133 except urllib.error.HTTPError as error:
134 raise RuntimeError(
135 f"provider request failed ({error.code})"
136 ) from error
137 except urllib.error.URLError as error:
138 raise RuntimeError(f"provider request failed: {error.reason}") from error
139
140
141def stream_openai(
142 model: str,
143 system: str,
144 messages: list[dict[str, str]],
145 emit: Callable[[str], None],
146) -> None:
147 api_key = os.environ.get("OPENAI_API_KEY", "")
148 if not api_key:
149 raise RuntimeError("OPENAI_API_KEY is not set")
150
151 openai_messages = list(messages)
152 if system:
153 openai_messages.insert(0, {"role": "system", "content": system})
154
155 for event in stream_provider_sse(
156 "https://api.openai.com/v1/chat/completions",
157 {
158 "Authorization": f"Bearer {api_key}",
159 "Content-Type": "application/json",
160 },
161 {
162 "model": model,
163 "messages": openai_messages,
164 "stream": True,
165 },
166 ):
167 choices = event.get("choices")
168 if not isinstance(choices, list) or not choices:
169 continue
170 choice = choices[0]
171 if not isinstance(choice, dict):
172 continue
173 delta = choice.get("delta")
174 if not isinstance(delta, dict):
175 continue
176 content = delta.get("content")
177 if isinstance(content, str) and content:
178 emit(content)
179
180
181def stream_anthropic(
182 model: str,
183 system: str,
184 messages: list[dict[str, str]],
185 emit: Callable[[str], None],
186) -> None:
187 api_key = os.environ.get("ANTHROPIC_API_KEY", "")
188 if not api_key:
189 raise RuntimeError("ANTHROPIC_API_KEY is not set")
190
191 payload: dict[str, Any] = {
192 "model": model,
193 "max_tokens": 4096,
194 "messages": messages,
195 "stream": True,
196 }
197 if system:
198 payload["system"] = system
199
200 for event in stream_provider_sse(
201 "https://api.anthropic.com/v1/messages",
202 {
203 "x-api-key": api_key,
204 "anthropic-version": "2023-06-01",
205 "Content-Type": "application/json",
206 },
207 payload,
208 ):
209 if event.get("type") != "content_block_delta":
210 continue
211 delta = event.get("delta")
212 if not isinstance(delta, dict) or delta.get("type") != "text_delta":
213 continue
214 text = delta.get("text")
215 if isinstance(text, str) and text:
216 emit(text)
217
218
219def stream_completion(
220 provider: str,
221 model: str,
222 system: str,
223 messages: list[dict[str, str]],
224 emit: Callable[[str], None],
225) -> None:
226 if provider == "openai":
227 stream_openai(model, system, messages, emit)
228 return
229 if provider == "anthropic":
230 stream_anthropic(model, system, messages, emit)
231 return
232 raise RuntimeError(
233 f'unsupported provider "{provider}" (expected openai or anthropic)'
234 )
235
236
237class AguiHandler(BaseHTTPRequestHandler):
238 protocol_version = "HTTP/1.1"
239
240 def log_message(self, format: str, *args: Any) -> None:
241 sys.stderr.write(f"[python] {format % args}\n")
242
243 def send_text(self, status: int, message: str) -> None:
244 body = message.encode("utf-8")
245 self.send_response(status)
246 self.send_header("Content-Type", "text/plain; charset=utf-8")
247 self.send_header("Content-Length", str(len(body)))
248 self.send_header("Access-Control-Allow-Origin", "*")
249 self.end_headers()
250 self.wfile.write(body)
251
252 def do_OPTIONS(self) -> None:
253 self.send_response(204)
254 self.send_header("Access-Control-Allow-Origin", "*")
255 self.send_header("Access-Control-Allow-Methods", "POST, OPTIONS")
256 self.send_header("Access-Control-Allow-Headers", "Content-Type")
257 self.send_header("Content-Length", "0")
258 self.end_headers()
259
260 def do_GET(self) -> None:
261 if self.path.split("?", 1)[0] == "/health":
262 self.send_text(200, "ok")
263 return
264 self.send_text(405, "method not allowed")
265
266 def do_POST(self) -> None:
267 if self.path.split("?", 1)[0] != "/":
268 self.send_text(404, "not found")
269 return
270
271 try:
272 content_length = int(self.headers.get("Content-Length", "0"))
273 input_data = json.loads(self.rfile.read(content_length))
274 except (ValueError, json.JSONDecodeError, UnicodeDecodeError):
275 self.send_text(400, "invalid JSON body")
276 return
277
278 if not isinstance(input_data, dict):
279 self.send_text(400, "invalid JSON body")
280 return
281
282 thread_id = input_data.get("threadId")
283 run_id = input_data.get("runId")
284 if not isinstance(thread_id, str) or not thread_id or not isinstance(
285 run_id, str
286 ) or not run_id:
287 self.send_text(400, "threadId and runId are required")
288 return
289
290 system, messages = to_chat_messages(input_data.get("messages"))
291 self.begin_sse()
292 self.write_event(
293 {"type": "RUN_STARTED", "threadId": thread_id, "runId": run_id}
294 )
295
296 if not messages:
297 self.write_run_error(
298 thread_id, run_id, "no user or assistant messages to send"
299 )
300 self.write_done()
301 return
302
303 message_id = f"msg-{run_id}"
304 self.write_event(
305 {
306 "type": "TEXT_MESSAGE_START",
307 "messageId": message_id,
308 "role": "assistant",
309 }
310 )
311
312 try:
313 provider, model = provider_from_input(input_data)
314 stream_completion(
315 provider,
316 model,
317 system,
318 messages,
319 lambda delta: self.write_event(
320 {
321 "type": "TEXT_MESSAGE_CONTENT",
322 "messageId": message_id,
323 "delta": delta,
324 }
325 ),
326 )
327 self.write_event(
328 {"type": "TEXT_MESSAGE_END", "messageId": message_id}
329 )
330 self.write_event(
331 {
332 "type": "RUN_FINISHED",
333 "threadId": thread_id,
334 "runId": run_id,
335 "finishReason": "stop",
336 }
337 )
338 self.write_done()
339 except Exception as error:
340 self.log_message("chat error: %s", error)
341 self.write_run_error(thread_id, run_id, str(error))
342 self.write_done()
343
344 def begin_sse(self) -> None:
345 self.send_response(200)
346 self.send_header("Content-Type", "text/event-stream")
347 self.send_header("Cache-Control", "no-cache")
348 self.send_header("Access-Control-Allow-Origin", "*")
349 self.send_header("Connection", "close")
350 self.end_headers()
351
352 def write_event(self, event: dict[str, Any]) -> None:
353 frame = f"data: {json.dumps(event, ensure_ascii=False)}\n\n"
354 self.wfile.write(frame.encode("utf-8"))
355 self.wfile.flush()
356
357 def write_run_error(
358 self, thread_id: str, run_id: str, message: str
359 ) -> None:
360 self.write_event(
361 {
362 "type": "RUN_ERROR",
363 "threadId": thread_id,
364 "runId": run_id,
365 "error": {"message": message},
366 }
367 )
368
369 def write_done(self) -> None:
370 self.wfile.write(b"data: [DONE]\n\n")
371 self.wfile.flush()
372
373
374def main() -> None:
375 server = ThreadingHTTPServer((HOST, PORT), AguiHandler)
376 print(
377 f"[python] listening on http://{HOST}:{PORT}",
378 flush=True,
379 )
380 try:
381 server.serve_forever()
382 except KeyboardInterrupt:
383 pass
384 finally:
385 server.server_close()
386
387
388if __name__ == "__main__":
389 main()