@batonfx/foldkit 0.3.7 → 0.4.1

package/dist/connection.js

@@ -0,0 +1,70 @@
+import { Cause, Context, Effect, Layer, Option, Ref, Result, Schema, Stream } from "effect";
+import { Socket } from "effect/unstable/socket";
+import { m } from "foldkit/message";
+import { Client, Wire } from "@batonfx/transport";
+/** @experimental */
+export const ConnectionOpened = m("ConnectionOpened");
+/** @experimental */
+export const ConnectionLost = m("ConnectionLost");
+/** @experimental */
+export const ConnectionFailed = m("ConnectionFailed", { reason: Schema.String });
+/** @experimental */
+export const Incoming = Schema.Union([
+    Wire.LooseServerFrame,
+    ConnectionOpened,
+    ConnectionLost,
+    ConnectionFailed,
+]);
+/** @experimental */
+export class SendFailed extends Schema.TaggedErrorClass()("@batonfx/foldkit/SendFailed", {
+    reason: Schema.String,
+}) {
+}
+/** @experimental */
+export class AgentConnection extends Context.Service()("@batonfx/foldkit/AgentConnection") {
+}
+const reasonFrom = (error) => {
+    if (error instanceof SendFailed)
+        return error.reason;
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+};
+const statusIncoming = (status) => {
+    switch (status._tag) {
+        case "Open":
+            return Option.some(ConnectionOpened());
+        case "Reconnecting":
+        case "Closed":
+            return Option.some(ConnectionLost());
+        case "Connecting":
+            return Option.none();
+    }
+};
+/** @experimental */
+export const testLayer = (implementation) => Layer.succeed(AgentConnection, AgentConnection.of(implementation));
+/** @experimental */
+export const layerWebSocket = (options) => Layer.effect(AgentConnection, Effect.gen(function* () {
+    const client = yield* Client.AgentClient;
+    const active = yield* Ref.make(Option.none());
+    const clearActive = (connection) => Ref.update(active, (current) => Option.isSome(current) && current.value.connection === connection ? Option.none() : current);
+    return AgentConnection.of({
+        frames: ({ sessionId }) => Stream.unwrap(Effect.gen(function* () {
+            const connection = yield* client.connect({ url: options.url, sessionId });
+            yield* Ref.set(active, Option.some({ sessionId, connection }));
+            yield* Effect.addFinalizer(() => clearActive(connection));
+            const statuses = connection.status.pipe(Stream.filterMap((status) => Option.match(statusIncoming(status), {
+                onNone: () => Result.fail(undefined),
+                onSome: Result.succeed,
+            })));
+            const frames = connection.frames.pipe(Stream.map((frame) => frame), Stream.catchCause((cause) => Stream.succeed(ConnectionFailed({ reason: reasonFrom(Cause.squash(cause)) }))));
+            return statuses.pipe(Stream.merge(frames));
+        })),
+        send: (frame) => Ref.get(active).pipe(Effect.flatMap(Option.match({
+            onNone: () => Effect.fail(new SendFailed({ reason: "No active agent connection" })),
+            onSome: ({ connection }) => connection
+                .send(frame)
+                .pipe(Effect.mapError((error) => new SendFailed({ reason: reasonFrom(error) }))),
+        }))),
+    });
+})).pipe(Layer.provide(Client.layerWebSocket));

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * as Chat from "./chat.js";
+export * as Connection from "./connection.js";