@effect-uai/discord 0.17.0 → 0.18.0

package/dist/{rolldown-runtime-D7D4PA-g.mjs → rolldown-runtime-EAsCxrDo.mjs}

@@ -1,5 +1,6 @@
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -10,4 +11,4 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-export { __exportAll as t };
+export { __exportAll as n, __commonJSMin as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/discord",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Discord provider for @effect-uai/core (Messenger capability over the gateway and REST API).",
   "keywords": [
     "agents",
@@ -44,13 +44,13 @@
     "access": "public"
   },
   "devDependencies": {
-    "effect": "4.0.0-rc.111",
+    "effect": "4.0.1",
     "typescript": "^7.0.2",
-    "@effect-uai/core": "0.17.0"
+    "@effect-uai/core": "0.18.0"
   },
   "peerDependencies": {
     "@effect-uai/core": ">=0.15.0 <1",
-    "effect": ">=4.0.0-rc.111 <5.0.0"
+    "effect": ">=4.0.1 <5.0.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/Discord.ts

@@ -3,7 +3,6 @@ import {
   type Cause,
   Context,
   Effect,
-  Encoding,
   Layer,
   Match,
   Option,
@@ -13,7 +12,9 @@ import {
   type Scope,
   Stream,
 } from "effect"
-import { HttpClient } from "effect/unstable/http"
+import { Base64 } from "effect/encoding"
+import { HttpClient } from "effect/http"
+import * as Socket from "effect/socket/Socket"
 import type { MediaSource } from "@effect-uai/core/Media"
 import {
   CurrentConversation,
@@ -208,11 +209,13 @@ export const make = (
 
     // -- inbound -----------------------------------------------------------
 
+    // The gateway takes its token in the identify payload, not a header, so
+    // every runtime's global `WebSocket` is enough.
     const session = yield* Gateway.connect({
       token: cfg.token,
       intents: cfg.intents ?? defaultIntents,
       url,
-    })
+    }).pipe(Effect.provide(Socket.layerWebSocketConstructorGlobal))
     const toEvents = Events.toEvents(session.bot)
     const inbox = yield* Queue.unbounded<InboundEvent, MessengerError.MessengerError | Cause.Done>()
 
@@ -280,7 +283,7 @@ export const make = (
         Match.tag("url", ({ url }) => sendUrl(at, fields, body, url)),
         Match.tag("bytes", ({ bytes, mimeType }) => send(bytes, mimeType)),
         Match.tag("base64", ({ base64, mimeType }) =>
-          Effect.fromResult(Encoding.decodeBase64(base64)).pipe(
+          Effect.fromResult(Base64.decode(base64)).pipe(
             Effect.mapError(invalidMedia),
             Effect.flatMap((bytes) => send(bytes, mimeType)),
           ),

package/src/internal/gateway.test.ts

@@ -1,5 +1,9 @@
+import { it as effect } from "@effect/vitest"
+import { Effect, Layer, Queue, Redacted } from "effect"
+import * as Socket from "effect/socket/Socket"
+import * as FakeWebSocket from "@effect-uai/core/testing/FakeWebSocket"
 import { describe, expect, it } from "vitest"
-import { classifyClose, closeReason } from "./gateway.js"
+import { classifyClose, closeReason, connect } from "./gateway.js"
 
 describe("classifyClose", () => {
   it("never retries a close reconnecting cannot fix", () => {
@@ -25,3 +29,85 @@ describe("closeReason", () => {
     expect(closeReason(1006, "connection reset")).toBe("connection reset")
   })
 })
+
+const cfg = { token: Redacted.make("token"), intents: 0, url: "wss://gateway.test" }
+
+// Long enough that no heartbeat lands mid-test.
+const HELLO = { op: 10, d: { heartbeat_interval: 3_600_000 } }
+
+const READY = {
+  op: 0,
+  t: "READY",
+  s: 1,
+  d: {
+    user: { id: "1", username: "bot" },
+    session_id: "session",
+    resume_gateway_url: "wss://resume.test",
+  },
+}
+
+// Identify gets READY, resume gets RESUMED.
+const answers: Record<number, ReadonlyArray<unknown>> = {
+  2: [READY],
+  6: [{ op: 0, t: "RESUMED", s: 2 }],
+}
+
+const gateway = FakeWebSocket.make({
+  greeting: [HELLO],
+  reply: (frame) => Effect.succeed(answers[(frame as { op: number }).op] ?? []),
+})
+
+/** One fake per connection, in dial order; the last one takes any extra dials. */
+const dialing = (servers: ReadonlyArray<FakeWebSocket.FakeWebSocketServer>) => {
+  const urls: Array<string> = []
+  const layer = Layer.succeed(Socket.WebSocketConstructor)((url, protocols) => {
+    const server = servers[Math.min(urls.length, servers.length - 1)]!
+    urls.push(url)
+    return server.connect(url, protocols)
+  })
+  return { urls, layer }
+}
+
+describe("gateway close handling", () => {
+  effect.live.each([1000, 4000])("resumes on the resume host after a %i close", (code) =>
+    Effect.gen(function* () {
+      const first = yield* gateway
+      const second = yield* gateway
+      const { urls, layer } = dialing([first, second])
+      const session = yield* connect(cfg).pipe(Effect.provide(layer))
+      expect(session.bot.username).toBe("bot")
+
+      yield* first.close(code)
+      yield* second.awaitSent(1)
+
+      expect(urls[1]).toMatch(/^wss:\/\/resume\.test\//)
+      expect(yield* second.sent).toEqual([
+        { op: 6, d: { token: "token", session_id: "session", seq: 1 } },
+      ])
+    }),
+  )
+
+  effect.live("fails the dispatches on a fatal close after READY", () =>
+    Effect.gen(function* () {
+      const server = yield* gateway
+      const session = yield* connect(cfg).pipe(Effect.provide(dialing([server]).layer))
+
+      yield* server.close(4014)
+      const error = yield* Queue.take(session.dispatches).pipe(Effect.flip)
+
+      expect(error).toMatchObject({ _tag: "MessengerTransportClosed", raw: { code: 4014 } })
+    }),
+  )
+
+  effect.live("fails the connect on a fatal close before READY", () =>
+    Effect.gen(function* () {
+      const server = yield* FakeWebSocket.make({ greeting: [HELLO] })
+      yield* server.awaitSent(1).pipe(Effect.andThen(server.close(4004)), Effect.forkScoped)
+
+      const error = yield* connect(cfg).pipe(Effect.provide(dialing([server]).layer), Effect.flip)
+
+      expect(error._tag).toBe("MessengerConnectFailed")
+      expect(error.reason).toContain("authentication failed")
+    }),
+  )
+})

package/src/internal/gateway.ts

@@ -11,9 +11,11 @@ import {
   Schedule,
   Schema,
   type Scope,
+  Stream,
 } from "effect"
-import * as Socket from "effect/unstable/socket/Socket"
+import * as Socket from "effect/socket/Socket"
 import * as MessengerError from "@effect-uai/core/MessengerError"
+import { isCleanClose } from "@effect-uai/core/WebSocketSession"
 import * as Events from "./events.js"
 import { provider } from "./rest.js"
 
@@ -140,6 +142,14 @@ const socketReason = (error: Socket.SocketError): string =>
     ? (error.reason.closeReason ?? error.reason.message)
     : error.reason.message
 
+// Effect's `Socket` fails on every close. A clean one is only ever our own
+// teardown; anything else carries the close code the classifier reads.
+const endedBy = (error: Socket.SocketError): Ended => {
+  if (isCleanClose(error)) return { action: "resume", code: 1000, reason: "closed" }
+  const code = socketCode(error)
+  return { action: classifyClose(code), code, reason: closeReason(code, socketReason(error)) }
+}
+
 // Discord asks for a random 1-5 s pause before identifying on a fresh session.
 const freshSessionDelay = Effect.sync(() => Duration.millis(1000 + Math.random() * 4000))
 
@@ -159,7 +169,11 @@ const identity = { os: "effect-uai", browser: "effect-uai", device: "effect-uai"
  */
 export const connect = (
   cfg: Config,
-): Effect.Effect<Session, MessengerError.MessengerConnectFailed, Scope.Scope> =>
+): Effect.Effect<
+  Session,
+  MessengerError.MessengerConnectFailed,
+  Scope.Scope | Socket.WebSocketConstructor
+> =>
   Effect.gen(function* () {
     const dispatches = yield* Queue.unbounded<
       Incoming,
@@ -168,6 +182,8 @@ export const connect = (
     const ready = yield* Deferred.make<Events.BotIdentity, MessengerError.MessengerConnectFailed>()
     const resume = yield* Ref.make(Option.none<Resume>())
     const attempts = yield* Ref.make(0)
+    // Outlives a connection: a resume replays from the last sequence seen.
+    const seq = yield* Ref.make(Option.none<number>())
 
     // -- one connection ----------------------------------------------------
 
@@ -176,16 +192,16 @@ export const connect = (
       // A resumable session has its own host; a fresh one starts at the URL
       // `GET /gateway/bot` gave us.
       const host = Option.match(from, { onNone: () => cfg.url, onSome: (r: Resume) => r.url })
-      const socket = yield* Socket.makeWebSocket(`${host}/?v=10&encoding=json`, {
-        // Effect treats every close as an error by default; the standard clean
-        // codes are not, and Discord's 4xxx ones are what drives `classifyClose`.
-        closeCodeIsError: (code: number) => code !== 1000 && code !== 1001 && code !== 1005,
-        // The gateway takes its token in the identify payload, not a header,
-        // so every runtime's global `WebSocket` is enough.
-      }).pipe(Effect.provide(Socket.layerWebSocketConstructorGlobal))
-      const write = yield* socket.writer
+      const socket = yield* Socket.makeWebSocket(`${host}/?v=10&encoding=json`)
+      const writer = yield* socket.writer
+      // The writer waits for the next connection rather than failing, so a
+      // beat or handshake after this one's reader ended is dropped here.
+      const closed = yield* Ref.make(false)
+      const write = (chunk: string | Socket.CloseEvent) =>
+        Effect.flatMap(Ref.get(closed), (isClosed) =>
+          isClosed ? Effect.void : writer.write(chunk),
+        )
       const send = (payload: unknown) => write(JSON.stringify(payload))
-      const seq = yield* Ref.make(Option.none<number>())
       const acked = yield* Ref.make(true)
       // Set by op 9 with `d: false`, the one case the close code cannot express.
       const requested = yield* Ref.make(Option.none<CloseAction>())
@@ -301,18 +317,12 @@ export const connect = (
           )
         }).pipe(Effect.ignore)
 
-      // A clean 1000 is only ever our own teardown; anything else carries the
-      // close code the classifier reads.
-      const ended = yield* socket.runString(handle).pipe(
+      const ended = yield* Stream.fromPull(Socket.readerString(socket)).pipe(
+        Stream.scoped,
+        Stream.runForEach(handle),
+        Effect.ensuring(Ref.set(closed, true)),
         Effect.as<Ended>({ action: "resume", code: 1000, reason: "closed" }),
-        Effect.catch((error: Socket.SocketError) => {
-          const code = socketCode(error)
-          return Effect.succeed<Ended>({
-            action: classifyClose(code),
-            code,
-            reason: closeReason(code, socketReason(error)),
-          })
-        }),
+        Effect.catch((error: Socket.SocketError) => Effect.succeed(endedBy(error))),
       )
       const override = yield* Ref.get(requested)
       return Option.match(override, {

package/src/internal/rest.ts

@@ -1,5 +1,5 @@
 import { Data, Duration, Effect, Redacted, Schema } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { HttpClient, HttpClientRequest } from "effect/http"
 import * as MessengerError from "@effect-uai/core/MessengerError"
 import * as Multipart from "@effect-uai/core/Multipart"
 

package/dist/gateway-C_Ae1HYB.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gateway-C_Ae1HYB.d.mts","names":[],"sources":["../src/internal/gateway.ts"],"mappings":";;;;cAmCa,OAAK,OAAA;;;;;;;;KAKN,eAAe,MAAM;;cAGpB,aAAW,OAAA;gBAAX,OAAA;;;KAoBD;;;;;cAmBC,gBAAa,iBAAmB;;cAchC,cAAW,cAAgB;KAY5B;WACD,OAAO,SAAS;WAChB;;WAEA;;;KAIC;WACD,UAAU;WACV;;KAGC;WACD,KAAK;;;;;WAKL,YAAY,MAAM,MAAM,UAAU,eAAe,iBAAiB,MAAM;;;;;;;;;;cAgCtE,UAAO,KACb,WACJ,OAAO,OAAO,SAAS,eAAe,wBAAwB,MAAM"}