openai-ws.test.ts 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700
  1. import { describe, expect, test } from "bun:test"
  2. import { EventEmitter } from "node:events"
  3. import { createServer, type IncomingMessage, type Server as HttpServer } from "node:http"
  4. import net, { type AddressInfo, type Socket } from "node:net"
  5. import WebSocket, { WebSocketServer } from "ws"
  6. import { ProviderError } from "../../src/provider/error"
  7. import { OpenAIWebSocket } from "../../src/plugin/openai/ws"
  8. import { OpenAIWebSocketPool, TITLE_HEADER } from "../../src/plugin/openai/ws-pool"
  9. describe("plugin.openai.ws", () => {
  10. test("derives websocket URLs and sends auth plus protocol headers", async () => {
  11. let headers: IncomingMessage["headers"] | undefined
  12. await using server = await createWebSocketServer((_socket, request) => {
  13. headers = request.headers
  14. })
  15. const socket = await OpenAIWebSocket.connectResponsesWebSocket({
  16. url: server.wsUrl,
  17. headers: { authorization: "Bearer test", "content-length": "123" },
  18. })
  19. expect(OpenAIWebSocket.toWebSocketUrl("http://example.com/v1/responses")).toBe("ws://example.com/v1/responses")
  20. expect(OpenAIWebSocket.toWebSocketUrl("https://example.com/v1/responses")).toBe("wss://example.com/v1/responses")
  21. expect(headers?.authorization).toBe("Bearer test")
  22. expect(headers?.["openai-beta"]).toBe(OpenAIWebSocket.PROTOCOL_HEADER)
  23. expect(headers?.["content-length"]).toBeUndefined()
  24. socket.terminate()
  25. })
  26. test("enforces websocket connect timeout", async () => {
  27. await using server = await createHangingTcpServer()
  28. await expect(
  29. OpenAIWebSocket.connectResponsesWebSocket({
  30. url: server.wsUrl,
  31. headers: {},
  32. timeout: 20,
  33. }),
  34. ).rejects.toThrow("WebSocket connect timed out")
  35. })
  36. test("enforces websocket send idle timeout", async () => {
  37. const socket = new (class extends EventEmitter {
  38. send(_data: string, _callback: (error?: Error) => void) {}
  39. })() as unknown as WebSocket
  40. const invalid: string[] = []
  41. const response = OpenAIWebSocket.streamResponsesWebSocket({
  42. socket,
  43. body: { stream: true, input: "hi" },
  44. idleTimeout: 20,
  45. onConnectionInvalid: (error) => invalid.push(error.message),
  46. })
  47. expect((await readTextError(response.text())).message).toContain("idle timeout sending websocket request")
  48. expect(invalid).toEqual(["idle timeout sending websocket request"])
  49. })
  50. test("streams websocket events as SSE and handles response.done", async () => {
  51. let requestBody: unknown
  52. await using server = await createWebSocketServer((socket) => {
  53. socket.once("message", (data) => {
  54. requestBody = JSON.parse(data.toString())
  55. socket.send(JSON.stringify({ type: "response.output_text.delta", delta: "hello" }))
  56. socket.send(JSON.stringify({ type: "response.done", response: { id: "resp_123" } }))
  57. socket.close(1000, "done")
  58. })
  59. })
  60. const socket = await OpenAIWebSocket.connectResponsesWebSocket({
  61. url: server.wsUrl,
  62. headers: { authorization: "Bearer test", "content-length": "123" },
  63. })
  64. const completed: Record<string, unknown>[] = []
  65. const response = OpenAIWebSocket.streamResponsesWebSocket({
  66. socket,
  67. body: { stream: true, background: true, input: "hi" },
  68. onComplete: (event) => completed.push(event),
  69. })
  70. expect(await response.text()).toBe(
  71. 'data: {"type":"response.output_text.delta","delta":"hello"}\n\ndata: {"type":"response.done","response":{"id":"resp_123"}}\n\ndata: [DONE]\n\n',
  72. )
  73. expect(requestBody).toEqual({ type: "response.create", input: "hi" })
  74. expect(completed).toHaveLength(1)
  75. expect(completed[0]?.type).toBe("response.done")
  76. })
  77. test("errors the SSE stream when the server closes before a terminal event", async () => {
  78. const invalid: Error[] = []
  79. await using server = await createWebSocketServer((socket) => {
  80. socket.once("message", () => {
  81. socket.close(1009, "payload too large")
  82. })
  83. })
  84. const socket = await OpenAIWebSocket.connectResponsesWebSocket({ url: server.wsUrl, headers: {} })
  85. const response = OpenAIWebSocket.streamResponsesWebSocket({
  86. socket,
  87. body: { stream: true, input: "hi" },
  88. onConnectionInvalid: (error) => invalid.push(error),
  89. })
  90. expect((await readTextError(response.text())).message).toContain(
  91. "WebSocket closed before response.completed (code 1009: message too big: payload too large)",
  92. )
  93. expect(invalid[0]).toBeInstanceOf(ProviderError.ResponseStreamError)
  94. expect(invalid.map((error) => error.message)).toEqual([
  95. "WebSocket closed before response.completed (code 1009: message too big: payload too large)",
  96. ])
  97. })
  98. test("rejects unexpected binary websocket frames", async () => {
  99. const invalid: string[] = []
  100. await using server = await createWebSocketServer((socket) => {
  101. socket.once("message", () => {
  102. socket.send(Buffer.from("not json text"))
  103. })
  104. })
  105. const socket = await OpenAIWebSocket.connectResponsesWebSocket({ url: server.wsUrl, headers: {} })
  106. const response = OpenAIWebSocket.streamResponsesWebSocket({
  107. socket,
  108. body: { stream: true, input: "hi" },
  109. onConnectionInvalid: (error) => invalid.push(error.message),
  110. })
  111. expect((await readTextError(response.text())).message).toContain("Unexpected binary WebSocket frame")
  112. expect(invalid).toEqual(["Unexpected binary WebSocket frame"])
  113. })
  114. })
  115. describe("plugin.openai.ws-pool", () => {
  116. test("reuses one healthy websocket for sequential requests", async () => {
  117. let connections = 0
  118. let messages = 0
  119. await using server = await createWebSocketServer((socket) => {
  120. connections += 1
  121. socket.on("message", () => {
  122. messages += 1
  123. socket.send(JSON.stringify({ type: "response.completed", response: { id: `resp_${messages}` } }))
  124. })
  125. })
  126. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  127. url: server.url,
  128. })
  129. const first = await fetch(server.url, streamRequest())
  130. expect(await first.text()).toContain("data: [DONE]")
  131. const second = await fetch(server.url, streamRequest())
  132. expect(await second.text()).toContain("data: [DONE]")
  133. expect(connections).toBe(1)
  134. expect(messages).toBe(2)
  135. fetch.close()
  136. })
  137. test("rotates a socket that exceeds max connection age", async () => {
  138. let connections = 0
  139. await using server = await createWebSocketServer((socket) => {
  140. connections += 1
  141. socket.on("message", () => {
  142. socket.send(JSON.stringify({ type: "response.completed", response: { id: `resp_${connections}` } }))
  143. })
  144. })
  145. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  146. url: server.url,
  147. maxConnectionAge: 0,
  148. })
  149. const first = await fetch(server.url, streamRequest())
  150. expect(await first.text()).toContain("data: [DONE]")
  151. const second = await fetch(server.url, streamRequest())
  152. expect(await second.text()).toContain("data: [DONE]")
  153. expect(connections).toBe(2)
  154. fetch.close()
  155. })
  156. test("falls back to HTTP after websocket setup retries are exhausted", async () => {
  157. const attempts: string[] = []
  158. await using server = await createRejectingWebSocketServer(() => attempts.push("websocket"))
  159. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  160. url: server.url,
  161. connectTimeout: 100,
  162. streamRetries: 1,
  163. })
  164. const first = await fetch(server.url, streamRequest({ [TITLE_HEADER]: "false" }))
  165. expect(await readTextError(first.text())).toBeInstanceOf(ProviderError.ResponseStreamError)
  166. const second = await fetch(server.url, streamRequest({ [TITLE_HEADER]: "false" }))
  167. const third = await fetch(server.url, streamRequest({ [TITLE_HEADER]: "false" }))
  168. expect(await second.text()).toBe("http")
  169. expect(await third.text()).toBe("http")
  170. expect(attempts).toEqual(["websocket", "websocket"])
  171. expect(server.httpRequests).toHaveLength(2)
  172. expect(server.httpRequests[0]?.headers[TITLE_HEADER]).toBeUndefined()
  173. expect(server.httpRequests[1]?.headers[TITLE_HEADER]).toBeUndefined()
  174. fetch.close()
  175. })
  176. test("prunes HTTP fallback after its idle timeout", async () => {
  177. let websocketAttempts = 0
  178. await using server = await createRejectingWebSocketServer(() => websocketAttempts++)
  179. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  180. url: server.url,
  181. connectTimeout: 100,
  182. idleTimeout: 20,
  183. streamRetries: 0,
  184. })
  185. const first = await fetch(server.url, streamRequest())
  186. expect(await first.text()).toBe("http")
  187. await new Promise((resolve) => setTimeout(resolve, 50))
  188. const second = await fetch(server.url, streamRequest())
  189. expect(await second.text()).toBe("http")
  190. expect(websocketAttempts).toBe(2)
  191. expect(server.httpRequests).toHaveLength(2)
  192. fetch.close()
  193. })
  194. test("invalidates but does not reuse a socket after terminal failure frames", async () => {
  195. let connections = 0
  196. await using server = await createWebSocketServer((socket) => {
  197. connections += 1
  198. socket.once("message", () => {
  199. socket.send(JSON.stringify({ type: connections === 1 ? "response.failed" : "response.completed" }))
  200. })
  201. })
  202. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  203. url: server.url,
  204. })
  205. const first = await fetch(server.url, streamRequest())
  206. expect(await first.text()).toContain('data: {"type":"response.failed"}')
  207. const second = await fetch(server.url, streamRequest())
  208. expect(await second.text()).toContain('data: {"type":"response.completed"}')
  209. expect(connections).toBe(2)
  210. expect(server.httpRequests).toHaveLength(0)
  211. fetch.close()
  212. })
  213. test("retries websocket connection limit errors on the next stream attempt", async () => {
  214. let connections = 0
  215. let messages = 0
  216. await using server = await createWebSocketServer((socket) => {
  217. connections += 1
  218. socket.once("message", () => {
  219. messages += 1
  220. if (connections === 1) {
  221. socket.send(
  222. JSON.stringify({
  223. type: "error",
  224. status: 400,
  225. error: {
  226. type: "invalid_request_error",
  227. code: "websocket_connection_limit_reached",
  228. message: "Responses websocket connection limit reached",
  229. },
  230. }),
  231. )
  232. return
  233. }
  234. socket.send(JSON.stringify({ type: "response.completed", response: { id: "resp_retry" } }))
  235. })
  236. })
  237. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  238. url: server.url,
  239. })
  240. const first = await fetch(server.url, streamRequest())
  241. expect((await readTextError(first.text())).message).toContain("Responses websocket connection limit reached")
  242. const second = await fetch(server.url, streamRequest())
  243. const text = await second.text()
  244. expect(text).not.toContain("websocket_connection_limit_reached")
  245. expect(text).toContain('data: {"type":"response.completed","response":{"id":"resp_retry"}}')
  246. expect(text).toContain("data: [DONE]")
  247. expect(connections).toBe(2)
  248. expect(messages).toBe(2)
  249. expect(server.httpRequests).toHaveLength(0)
  250. fetch.close()
  251. })
  252. test("falls back to HTTP after websocket connection limit retries are exhausted", async () => {
  253. let connections = 0
  254. await using server = await createWebSocketServer((socket) => {
  255. connections += 1
  256. socket.once("message", () => {
  257. socket.send(
  258. JSON.stringify({
  259. type: "error",
  260. status: 400,
  261. error: {
  262. type: "invalid_request_error",
  263. code: "websocket_connection_limit_reached",
  264. message: "Responses websocket connection limit reached",
  265. },
  266. }),
  267. )
  268. })
  269. })
  270. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  271. url: server.url,
  272. streamRetries: 2,
  273. })
  274. const first = await fetch(server.url, streamRequest())
  275. expect((await readTextError(first.text())).message).toContain("Responses websocket connection limit reached")
  276. const second = await fetch(server.url, streamRequest())
  277. expect((await readTextError(second.text())).message).toContain("Responses websocket connection limit reached")
  278. const third = await fetch(server.url, streamRequest())
  279. const fourth = await fetch(server.url, streamRequest())
  280. expect(await third.text()).toBe("http")
  281. expect(await fourth.text()).toBe("http")
  282. expect(connections).toBe(3)
  283. expect(server.httpRequests).toHaveLength(2)
  284. fetch.close()
  285. })
  286. test("shares the websocket retry budget across stream and connection limit failures", async () => {
  287. let connections = 0
  288. await using server = await createWebSocketServer((socket) => {
  289. connections += 1
  290. socket.once("message", () => {
  291. if (connections === 1) {
  292. socket.send(JSON.stringify({ type: "response.output_text.delta", delta: "started" }))
  293. socket.terminate()
  294. return
  295. }
  296. socket.send(
  297. JSON.stringify({
  298. type: "error",
  299. error: {
  300. code: "websocket_connection_limit_reached",
  301. message: "Responses websocket connection limit reached",
  302. },
  303. }),
  304. )
  305. })
  306. })
  307. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  308. url: server.url,
  309. streamRetries: 1,
  310. })
  311. const first = await fetch(server.url, streamRequest())
  312. expect((await readTextError(first.text())).message).toContain("WebSocket closed before response.completed")
  313. const second = await fetch(server.url, streamRequest())
  314. expect(await second.text()).toBe("http")
  315. expect(connections).toBe(2)
  316. expect(server.httpRequests).toHaveLength(1)
  317. fetch.close()
  318. })
  319. test("retries websocket idle failures before first event then falls back to HTTP", async () => {
  320. let connections = 0
  321. await using server = await createWebSocketServer((socket) => {
  322. connections += 1
  323. socket.once("message", () => {})
  324. })
  325. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  326. url: server.url,
  327. idleTimeout: 20,
  328. streamRetries: 1,
  329. })
  330. const first = await fetch(server.url, streamRequest())
  331. expect((await readTextError(first.text())).message).toContain("idle timeout waiting for websocket")
  332. const second = await fetch(server.url, streamRequest())
  333. const third = await fetch(server.url, streamRequest())
  334. expect(await second.text()).toBe("http")
  335. expect(await third.text()).toBe("http")
  336. expect(connections).toBe(2)
  337. expect(server.httpRequests).toHaveLength(2)
  338. fetch.close()
  339. })
  340. test("retries failed websocket streams before using HTTP fallback", async () => {
  341. await using server = await createWebSocketServer((socket) => {
  342. socket.once("message", () => {
  343. socket.send(JSON.stringify({ type: "response.output_text.delta", delta: "started" }))
  344. })
  345. })
  346. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  347. url: server.url,
  348. idleTimeout: 20,
  349. streamRetries: 1,
  350. })
  351. const first = await fetch(server.url, streamRequest())
  352. expect((await readTextError(first.text())).message).toContain("idle timeout waiting for websocket")
  353. const second = await fetch(server.url, streamRequest())
  354. expect((await readTextError(second.text())).message).toContain("idle timeout waiting for websocket")
  355. const third = await fetch(server.url, streamRequest())
  356. expect(await third.text()).toBe("http")
  357. expect(server.httpRequests).toHaveLength(1)
  358. fetch.close()
  359. })
  360. test("resets websocket stream failures after a completed response", async () => {
  361. let connections = 0
  362. let requests = 0
  363. await using server = await createWebSocketServer((socket) => {
  364. connections += 1
  365. socket.on("message", () => {
  366. requests += 1
  367. if (requests === 1 || requests === 3) {
  368. socket.send(JSON.stringify({ type: "response.output_text.delta", delta: "started" }))
  369. socket.terminate()
  370. return
  371. }
  372. socket.send(JSON.stringify({ type: "response.completed", response: { id: `resp_${requests}` } }))
  373. })
  374. })
  375. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  376. url: server.url,
  377. streamRetries: 1,
  378. })
  379. const first = await fetch(server.url, streamRequest())
  380. expect((await readTextError(first.text())).message).toContain("WebSocket closed before response.completed")
  381. const second = await fetch(server.url, streamRequest())
  382. expect(await second.text()).toContain("data: [DONE]")
  383. const third = await fetch(server.url, streamRequest())
  384. expect((await readTextError(third.text())).message).toContain("WebSocket closed before response.completed")
  385. const fourth = await fetch(server.url, streamRequest())
  386. expect(await fourth.text()).toContain("data: [DONE]")
  387. expect(connections).toBe(3)
  388. expect(requests).toBe(4)
  389. expect(server.httpRequests).toHaveLength(0)
  390. fetch.close()
  391. })
  392. test("falls back to HTTP for missing session and title requests", async () => {
  393. await using server = await createWebSocketServer(() => {})
  394. const fetch = OpenAIWebSocketPool.createWebSocketFetch()
  395. const missingSession = await fetch(server.url, {
  396. method: "POST",
  397. headers: { [TITLE_HEADER]: "false" },
  398. body: JSON.stringify({ stream: true }),
  399. })
  400. const title = await fetch(server.url, streamRequest({ [TITLE_HEADER]: "true" }))
  401. expect(await missingSession.text()).toBe("http")
  402. expect(await title.text()).toBe("http")
  403. expect(server.httpRequests).toHaveLength(2)
  404. expect(server.httpRequests[0]?.headers[TITLE_HEADER]).toBeUndefined()
  405. expect(server.httpRequests[1]?.headers[TITLE_HEADER]).toBeUndefined()
  406. fetch.close()
  407. })
  408. test("falls back to HTTP while a websocket lane is busy", async () => {
  409. let connections = 0
  410. await using server = await createWebSocketServer((socket) => {
  411. connections += 1
  412. socket.once("message", () => {
  413. socket.send(JSON.stringify({ type: "response.output_text.delta", delta: "started" }))
  414. })
  415. })
  416. const abort = new AbortController()
  417. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  418. url: server.url,
  419. })
  420. const first = await fetch(server.url, streamRequest({}, abort.signal))
  421. const firstText = first.text()
  422. await waitFor(() => connections === 1, "websocket did not connect")
  423. const second = await fetch(server.url, streamRequest())
  424. expect(await second.text()).toBe("http")
  425. expect(server.httpRequests).toHaveLength(1)
  426. expect(connections).toBe(1)
  427. abort.abort(new Error("stop"))
  428. expect((await readTextError(firstText)).message).toContain("stop")
  429. fetch.close()
  430. })
  431. test("reserves a websocket lane while its socket is connecting", async () => {
  432. await using server = await createHangingTcpServer()
  433. await using fallback = await createHttpServer()
  434. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  435. url: server.url,
  436. connectTimeout: 20,
  437. streamRetries: 0,
  438. })
  439. const first = fetch(fallback.url, streamRequest())
  440. await waitFor(() => server.connections() === 1, "first websocket did not begin connecting")
  441. const second = fetch(fallback.url, streamRequest())
  442. expect(await (await second).text()).toBe("http")
  443. expect(await (await first).text()).toBe("http")
  444. expect(server.connections()).toBe(1)
  445. expect(fallback.httpRequests).toHaveLength(2)
  446. fetch.close()
  447. })
  448. test("retries unexpected closes before first event then falls back to HTTP", async () => {
  449. let connections = 0
  450. await using server = await createWebSocketServer((socket) => {
  451. connections += 1
  452. socket.once("message", () => {
  453. socket.close(1001, "server shutdown")
  454. })
  455. })
  456. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  457. url: server.url,
  458. streamRetries: 1,
  459. })
  460. const first = await fetch(server.url, streamRequest())
  461. expect((await readTextError(first.text())).message).toContain("WebSocket closed before response.completed")
  462. const second = await fetch(server.url, streamRequest())
  463. const third = await fetch(server.url, streamRequest())
  464. expect(await second.text()).toBe("http")
  465. expect(await third.text()).toBe("http")
  466. expect(connections).toBe(2)
  467. expect(server.httpRequests).toHaveLength(2)
  468. fetch.close()
  469. })
  470. test("does not keep HTTP fallback active after aborting a websocket response", async () => {
  471. let connections = 0
  472. await using server = await createWebSocketServer((socket) => {
  473. connections += 1
  474. socket.once("message", () => {
  475. if (connections === 1) {
  476. socket.send(JSON.stringify({ type: "response.output_text.delta", delta: "started" }))
  477. return
  478. }
  479. socket.send(JSON.stringify({ type: "response.completed", response: { id: "resp_456" } }))
  480. })
  481. })
  482. const abort = new AbortController()
  483. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  484. url: server.url,
  485. })
  486. const first = await fetch(server.url, streamRequest({}, abort.signal))
  487. const firstText = first.text()
  488. await waitFor(() => connections === 1, "first websocket did not connect")
  489. abort.abort(new Error("stop"))
  490. expect((await readTextError(firstText)).message).toContain("stop")
  491. const second = await fetch(server.url, streamRequest())
  492. expect(await second.text()).toContain("data: [DONE]")
  493. expect(connections).toBe(2)
  494. expect(server.httpRequests).toHaveLength(0)
  495. fetch.close()
  496. })
  497. test("releases the websocket lane when the response body is cancelled", async () => {
  498. let connections = 0
  499. await using server = await createWebSocketServer((socket) => {
  500. connections += 1
  501. socket.once("message", () => {
  502. if (connections === 1) {
  503. socket.send(JSON.stringify({ type: "response.output_text.delta", delta: "started" }))
  504. return
  505. }
  506. socket.send(JSON.stringify({ type: "response.completed", response: { id: "resp_after_cancel" } }))
  507. })
  508. })
  509. const fetch = OpenAIWebSocketPool.createWebSocketFetch({
  510. url: server.url,
  511. })
  512. const first = await fetch(server.url, streamRequest())
  513. await waitFor(() => connections === 1, "first websocket did not connect")
  514. await first.body!.cancel("stop")
  515. const second = await fetch(server.url, streamRequest())
  516. expect(await second.text()).toContain("data: [DONE]")
  517. expect(connections).toBe(2)
  518. expect(server.httpRequests).toHaveLength(0)
  519. fetch.close()
  520. })
  521. })
  522. function streamRequest(headers?: Record<string, string>, signal?: AbortSignal): RequestInit {
  523. return {
  524. method: "POST",
  525. headers: {
  526. "session-id": "session-1",
  527. authorization: "Bearer test",
  528. ...headers,
  529. },
  530. body: JSON.stringify({ stream: true, input: "hi" }),
  531. signal,
  532. }
  533. }
  534. async function readTextError(promise: Promise<string>) {
  535. // Bun 1.3.14 hangs on expect(response.text()).rejects for streams errored from ws callbacks.
  536. return promise.then(
  537. () => {
  538. throw new Error("Expected response text to reject")
  539. },
  540. (error) => {
  541. expect(error).toBeInstanceOf(Error)
  542. return error as Error
  543. },
  544. )
  545. }
  546. async function createWebSocketServer(onConnection: (socket: WebSocket, request: IncomingMessage) => void) {
  547. const http = await createHttpServer()
  548. const server = new WebSocketServer({ server: http.server })
  549. server.on("connection", onConnection)
  550. return websocketServerHandle(server, http)
  551. }
  552. async function createHangingTcpServer() {
  553. const sockets = new Set<Socket>()
  554. let connections = 0
  555. const server = net.createServer((socket) => {
  556. connections += 1
  557. sockets.add(socket)
  558. socket.on("close", () => sockets.delete(socket))
  559. })
  560. await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve))
  561. const address = server.address() as AddressInfo
  562. return {
  563. url: `http://127.0.0.1:${address.port}/v1/responses`,
  564. wsUrl: `ws://127.0.0.1:${address.port}/v1/responses`,
  565. connections: () => connections,
  566. async [Symbol.asyncDispose]() {
  567. for (const socket of sockets) socket.destroy()
  568. server.close()
  569. },
  570. }
  571. }
  572. async function createRejectingWebSocketServer(onAttempt: () => void) {
  573. const http = await createHttpServer()
  574. const server = new WebSocketServer({
  575. server: http.server,
  576. verifyClient(_info, callback) {
  577. onAttempt()
  578. callback(false, 401, "denied")
  579. },
  580. })
  581. return websocketServerHandle(server, http)
  582. }
  583. async function createHttpServer() {
  584. const httpRequests: IncomingMessage[] = []
  585. const server = createServer((request, response) => {
  586. httpRequests.push(request)
  587. response.writeHead(200, { "content-type": "text/plain" })
  588. response.end("http")
  589. })
  590. await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve))
  591. const address = server.address() as AddressInfo
  592. return {
  593. server,
  594. httpRequests,
  595. url: `http://127.0.0.1:${address.port}/v1/responses`,
  596. async [Symbol.asyncDispose]() {
  597. await closeHttpServer(server)
  598. },
  599. }
  600. }
  601. function websocketServerHandle(server: WebSocketServer, http: Awaited<ReturnType<typeof createHttpServer>>) {
  602. return {
  603. url: http.url,
  604. wsUrl: http.url.replace(/^http/, "ws"),
  605. httpRequests: http.httpRequests,
  606. async [Symbol.asyncDispose]() {
  607. for (const socket of server.clients) socket.terminate()
  608. server.close()
  609. http.server.close()
  610. },
  611. }
  612. }
  613. function closeHttpServer(server: HttpServer) {
  614. return new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))
  615. }
  616. async function waitFor(predicate: () => boolean, message: string) {
  617. const started = Date.now()
  618. while (!predicate()) {
  619. if (Date.now() - started > 1_000) throw new Error(message)
  620. await new Promise((resolve) => setTimeout(resolve, 1))
  621. }
  622. }