@fluxy-chat/protocol 0.1.0

package/README.md

@@ -0,0 +1,30 @@
+# @fluxy-chat/protocol
+
+Shared wire protocol for FluxyChat clients and the worker.
+
+## What it covers
+
+- Canonical **inbound** WebSocket event types (server → client)
+- Canonical **outbound** client event types (client → room)
+- Lightweight runtime guards (`isFluxyInboundEvent`, `isFluxyOutboundEvent`)
+
+## Usage
+
+```ts
+import { isFluxyInboundEvent, FLUXY_INBOUND_EVENT_TYPES } from "@fluxy-chat/protocol";
+
+socket.onmessage = (raw) => {
+  const data = JSON.parse(raw.data);
+  if (!isFluxyInboundEvent(data)) return;
+  // dispatch by data.type
+};
+```
+
+## P21 contract tests
+
+SDK packages should keep their event unions aligned with `FLUXY_INBOUND_EVENT_TYPES`. When adding a new WS event in the worker:
+
+1. Add to `@fluxy-chat/protocol` inbound/outbound lists
+2. Update Room DO handler
+3. Extend SDK `FluxyChatEvent` union
+4. Run `pnpm --filter @fluxy-chat/protocol test`

package/dist/dispatch-inbound-frame.d.ts

@@ -0,0 +1,10 @@
+export interface InboundDispatchHandlers {
+    onPong: () => void;
+    onReplay: (messages: unknown[]) => void;
+    onHistoryMarker: () => void;
+    onWorkerError: (message?: string) => void;
+    onEvent: (event: Record<string, unknown>) => void;
+}
+/** Shared WS frame dispatch for all FluxyChat client SDKs. */
+export declare function dispatchInboundWsFrame(raw: string, handlers: InboundDispatchHandlers): void;
+//# sourceMappingURL=dispatch-inbound-frame.d.ts.map

package/dist/dispatch-inbound-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-inbound-frame.d.ts","sourceRoot":"","sources":["../src/dispatch-inbound-frame.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACxC,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,aAAa,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CACnD;AAED,8DAA8D;AAC9D,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,uBAAuB,GAAG,IAAI,CA4B3F"}

package/dist/dispatch-inbound-frame.js

@@ -0,0 +1,27 @@
+import { parseInboundWsFrame } from "./parse-inbound-frame.js";
+/** Shared WS frame dispatch for all FluxyChat client SDKs. */
+export function dispatchInboundWsFrame(raw, handlers) {
+    const frame = parseInboundWsFrame(raw);
+    if (!frame)
+        return;
+    if (frame.kind === "pong") {
+        handlers.onPong();
+        return;
+    }
+    if (frame.kind === "replay") {
+        handlers.onReplay(frame.messages ?? []);
+        return;
+    }
+    if (frame.kind === "ignored")
+        return;
+    const event = frame.event;
+    if (!event || typeof event.type !== "string")
+        return;
+    if (event.type === "history") {
+        handlers.onHistoryMarker();
+    }
+    if (event.type === "error") {
+        handlers.onWorkerError(typeof event.message === "string" ? event.message : undefined);
+    }
+    handlers.onEvent(event);
+}

package/dist/event-types.d.ts

@@ -0,0 +1,12 @@
+/** Inbound WebSocket events broadcast by the worker / Room DO. */
+export declare const FLUXY_INBOUND_EVENT_TYPES: readonly ["message", "message_edit", "message_delete", "message_expired", "typing", "subscription_succeeded", "subscription_count", "member_joined", "member_left", "client_event", "agentTyping", "tool_call", "tool_result", "tool_error", "agentRun", "presence", "cache_snapshot", "server_event", "user_event", "user_subscription_succeeded", "state_change", "stream", "pong", "error"];
+/** Outbound client → room events (Room DO handlers). */
+export declare const FLUXY_OUTBOUND_EVENT_TYPES: readonly ["ping", "message", "stream", "edit", "reaction", "read", "delete", "typing", "client_event", "agentTyping"];
+/** Worker → client transport frames handled before dispatch. */
+export declare const FLUXY_TRANSPORT_INBOUND_TYPES: readonly ["pong", "replay"];
+/** Client-side synthetic events (REST replay / local merge). */
+export declare const FLUXY_SDK_SYNTHETIC_INBOUND_TYPES: readonly ["history"];
+export type FluxyInboundEventType = (typeof FLUXY_INBOUND_EVENT_TYPES)[number];
+export type FluxyOutboundEventType = (typeof FLUXY_OUTBOUND_EVENT_TYPES)[number];
+export declare const FLUXY_PROTOCOL_VERSION = "1.0.0";
+//# sourceMappingURL=event-types.d.ts.map

package/dist/event-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-types.d.ts","sourceRoot":"","sources":["../src/event-types.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,eAAO,MAAM,yBAAyB,gYAyB5B,CAAC;AAEX,wDAAwD;AACxD,eAAO,MAAM,0BAA0B,uHAW7B,CAAC;AAEX,gEAAgE;AAChE,eAAO,MAAM,6BAA6B,6BAA8B,CAAC;AAEzE,gEAAgE;AAChE,eAAO,MAAM,iCAAiC,sBAAuB,CAAC;AAEtE,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAC/E,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjF,eAAO,MAAM,sBAAsB,UAAU,CAAC"}

package/dist/event-types.js

@@ -0,0 +1,45 @@
+/** Inbound WebSocket events broadcast by the worker / Room DO. */
+export const FLUXY_INBOUND_EVENT_TYPES = [
+    "message",
+    "message_edit",
+    "message_delete",
+    "message_expired",
+    "typing",
+    "subscription_succeeded",
+    "subscription_count",
+    "member_joined",
+    "member_left",
+    "client_event",
+    "agentTyping",
+    "tool_call",
+    "tool_result",
+    "tool_error",
+    "agentRun",
+    "presence",
+    "cache_snapshot",
+    "server_event",
+    "user_event",
+    "user_subscription_succeeded",
+    "state_change",
+    "stream",
+    "pong",
+    "error",
+];
+/** Outbound client → room events (Room DO handlers). */
+export const FLUXY_OUTBOUND_EVENT_TYPES = [
+    "ping",
+    "message",
+    "stream",
+    "edit",
+    "reaction",
+    "read",
+    "delete",
+    "typing",
+    "client_event",
+    "agentTyping",
+];
+/** Worker → client transport frames handled before dispatch. */
+export const FLUXY_TRANSPORT_INBOUND_TYPES = ["pong", "replay"];
+/** Client-side synthetic events (REST replay / local merge). */
+export const FLUXY_SDK_SYNTHETIC_INBOUND_TYPES = ["history"];
+export const FLUXY_PROTOCOL_VERSION = "1.0.0";

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { FLUXY_INBOUND_EVENT_TYPES, FLUXY_OUTBOUND_EVENT_TYPES, FLUXY_PROTOCOL_VERSION, FLUXY_SDK_SYNTHETIC_INBOUND_TYPES, FLUXY_TRANSPORT_INBOUND_TYPES, type FluxyInboundEventType, type FluxyOutboundEventType } from "./event-types.js";
+export { FLUXY_INBOUND_EVENT_TYPES, FLUXY_OUTBOUND_EVENT_TYPES, FLUXY_PROTOCOL_VERSION, FLUXY_SDK_SYNTHETIC_INBOUND_TYPES, FLUXY_TRANSPORT_INBOUND_TYPES, type FluxyInboundEventType, type FluxyOutboundEventType, };
+export interface FluxyProtocolEventBase {
+    type: string;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isFluxyInboundEvent(value: unknown): value is FluxyProtocolEventBase & {
+    type: FluxyInboundEventType;
+};
+export declare function isFluxyOutboundEvent(value: unknown): value is FluxyProtocolEventBase & {
+    type: FluxyOutboundEventType;
+};
+export declare function assertInboundEventType(type: string): FluxyInboundEventType | null;
+export { parseInboundWsFrame, isKnownOutboundClientEvent, type ParsedInboundWsFrame, type InboundFrameKind, } from "./parse-inbound-frame.js";
+export { dispatchInboundWsFrame, type InboundDispatchHandlers, } from "./dispatch-inbound-frame.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,0BAA0B,EAC1B,sBAAsB,EACtB,iCAAiC,EACjC,6BAA6B,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,yBAAyB,EACzB,0BAA0B,EAC1B,sBAAsB,EACtB,iCAAiC,EACjC,6BAA6B,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,GAC5B,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,GAAG;IAAE,IAAI,EAAE,qBAAqB,CAAA;CAAE,CAGrH;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,GAAG;IAAE,IAAI,EAAE,sBAAsB,CAAA;CAAE,CAGvH;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAIjF;AAED,OAAO,EACL,mBAAmB,EACnB,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,GACtB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,sBAAsB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -0,0 +1,22 @@
+import { FLUXY_INBOUND_EVENT_TYPES, FLUXY_OUTBOUND_EVENT_TYPES, FLUXY_PROTOCOL_VERSION, FLUXY_SDK_SYNTHETIC_INBOUND_TYPES, FLUXY_TRANSPORT_INBOUND_TYPES, } from "./event-types.js";
+export { FLUXY_INBOUND_EVENT_TYPES, FLUXY_OUTBOUND_EVENT_TYPES, FLUXY_PROTOCOL_VERSION, FLUXY_SDK_SYNTHETIC_INBOUND_TYPES, FLUXY_TRANSPORT_INBOUND_TYPES, };
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isFluxyInboundEvent(value) {
+    if (!isRecord(value) || typeof value.type !== "string")
+        return false;
+    return FLUXY_INBOUND_EVENT_TYPES.includes(value.type);
+}
+export function isFluxyOutboundEvent(value) {
+    if (!isRecord(value) || typeof value.type !== "string")
+        return false;
+    return FLUXY_OUTBOUND_EVENT_TYPES.includes(value.type);
+}
+export function assertInboundEventType(type) {
+    return FLUXY_INBOUND_EVENT_TYPES.includes(type)
+        ? type
+        : null;
+}
+export { parseInboundWsFrame, isKnownOutboundClientEvent, } from "./parse-inbound-frame.js";
+export { dispatchInboundWsFrame, } from "./dispatch-inbound-frame.js";

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/dist/index.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { FLUXY_INBOUND_EVENT_TYPES, FLUXY_OUTBOUND_EVENT_TYPES, FLUXY_PROTOCOL_VERSION, assertInboundEventType, isFluxyInboundEvent, isFluxyOutboundEvent, } from "./index.js";
+describe("@fluxy-chat/protocol", () => {
+    it("exposes a stable protocol version", () => {
+        expect(FLUXY_PROTOCOL_VERSION).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+    it("recognizes core inbound events", () => {
+        expect(isFluxyInboundEvent({ type: "message", id: 1 })).toBe(true);
+        expect(isFluxyInboundEvent({ type: "tool_call", runId: "r1" })).toBe(true);
+        expect(isFluxyInboundEvent({ type: "not_a_real_event" })).toBe(false);
+        expect(isFluxyInboundEvent(null)).toBe(false);
+    });
+    it("recognizes outbound client events", () => {
+        expect(isFluxyOutboundEvent({ type: "ping" })).toBe(true);
+        expect(isFluxyOutboundEvent({ type: "stream", op: "start" })).toBe(true);
+        expect(isFluxyOutboundEvent({ type: "message" })).toBe(true);
+    });
+    it("maps unknown inbound types to null", () => {
+        expect(assertInboundEventType("presence")).toBe("presence");
+        expect(assertInboundEventType("bogus")).toBeNull();
+    });
+    it("keeps inbound/outbound lists disjoint", () => {
+        const overlap = FLUXY_INBOUND_EVENT_TYPES.filter((t) => FLUXY_OUTBOUND_EVENT_TYPES.includes(t));
+        expect(overlap.sort()).toEqual(["agentTyping", "client_event", "message", "stream", "typing"]);
+    });
+});
+describe("outbound client events", () => {
+    it("matches Room DO handlers", () => {
+        const roomDoTypes = [
+            "ping",
+            "message",
+            "stream",
+            "edit",
+            "reaction",
+            "read",
+            "delete",
+            "client_event",
+            "typing",
+            "agentTyping",
+        ];
+        expect([...FLUXY_OUTBOUND_EVENT_TYPES].sort()).toEqual(roomDoTypes.sort());
+    });
+});

package/dist/parse-inbound-frame.d.ts

@@ -0,0 +1,11 @@
+export type InboundFrameKind = "pong" | "replay" | "event" | "ignored";
+export interface ParsedInboundWsFrame {
+    kind: InboundFrameKind;
+    event?: Record<string, unknown>;
+    messages?: unknown[];
+}
+export declare function parseInboundWsFrame(raw: string): ParsedInboundWsFrame | null;
+export declare function isKnownOutboundClientEvent(value: unknown): value is Record<string, unknown> & {
+    type: string;
+};
+//# sourceMappingURL=parse-inbound-frame.d.ts.map

package/dist/parse-inbound-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-inbound-frame.d.ts","sourceRoot":"","sources":["../src/parse-inbound-frame.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvE,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACtB;AAqBD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CAe5E;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAG9G"}

package/dist/parse-inbound-frame.js

@@ -0,0 +1,36 @@
+import { FLUXY_INBOUND_EVENT_TYPES, FLUXY_OUTBOUND_EVENT_TYPES, FLUXY_SDK_SYNTHETIC_INBOUND_TYPES, } from "./event-types.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function isDeliverableInboundType(type) {
+    return (FLUXY_INBOUND_EVENT_TYPES.includes(type) ||
+        FLUXY_SDK_SYNTHETIC_INBOUND_TYPES.includes(type));
+}
+export function parseInboundWsFrame(raw) {
+    const data = parseJson(raw);
+    if (!isRecord(data) || typeof data.type !== "string")
+        return null;
+    if (data.type === "pong")
+        return { kind: "pong" };
+    if (data.type === "replay") {
+        const messages = Array.isArray(data.messages) ? data.messages : [];
+        return { kind: "replay", messages };
+    }
+    if (!isDeliverableInboundType(data.type)) {
+        return { kind: "ignored" };
+    }
+    return { kind: "event", event: data };
+}
+export function isKnownOutboundClientEvent(value) {
+    if (!isRecord(value) || typeof value.type !== "string")
+        return false;
+    return FLUXY_OUTBOUND_EVENT_TYPES.includes(value.type);
+}

package/dist/parse-inbound-frame.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parse-inbound-frame.test.d.ts.map

package/dist/parse-inbound-frame.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-inbound-frame.test.d.ts","sourceRoot":"","sources":["../src/parse-inbound-frame.test.ts"],"names":[],"mappings":""}

package/dist/parse-inbound-frame.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { parseInboundWsFrame, isKnownOutboundClientEvent } from "./parse-inbound-frame.js";
+describe("parseInboundWsFrame", () => {
+    it("parses pong", () => {
+        expect(parseInboundWsFrame(JSON.stringify({ type: "pong", ts: 1 }))).toEqual({ kind: "pong" });
+    });
+    it("parses replay snapshot", () => {
+        expect(parseInboundWsFrame(JSON.stringify({ type: "replay", messages: [{ id: 1 }] }))).toEqual({
+            kind: "replay",
+            messages: [{ id: 1 }],
+        });
+    });
+    it("parses deliverable events", () => {
+        const frame = parseInboundWsFrame(JSON.stringify({ type: "message", id: 2, content: "hi" }));
+        expect(frame?.kind).toBe("event");
+        expect(frame?.event?.type).toBe("message");
+    });
+    it("ignores unknown inbound types", () => {
+        expect(parseInboundWsFrame(JSON.stringify({ type: "totally_unknown" }))).toEqual({ kind: "ignored" });
+    });
+    it("returns null on invalid JSON", () => {
+        expect(parseInboundWsFrame("{")).toBeNull();
+    });
+});
+describe("isKnownOutboundClientEvent", () => {
+    it("accepts room DO client events", () => {
+        expect(isKnownOutboundClientEvent({ type: "message", content: "x" })).toBe(true);
+        expect(isKnownOutboundClientEvent({ type: "edit", id: 1 })).toBe(true);
+    });
+    it("rejects unknown outbound types", () => {
+        expect(isKnownOutboundClientEvent({ type: "subscribe" })).toBe(false);
+        expect(isKnownOutboundClientEvent(null)).toBe(false);
+    });
+});

package/dist/protocol-events-json.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=protocol-events-json.test.d.ts.map

package/dist/protocol-events-json.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-events-json.test.d.ts","sourceRoot":"","sources":["../src/protocol-events-json.test.ts"],"names":[],"mappings":""}

package/dist/protocol-events-json.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import protocolEvents from "../protocol-events.json" with { type: "json" };
+import { FLUXY_INBOUND_EVENT_TYPES, FLUXY_OUTBOUND_EVENT_TYPES, FLUXY_PROTOCOL_VERSION, } from "./event-types.js";
+describe("protocol-events.json cross-SDK manifest", () => {
+    it("matches TypeScript event registries", () => {
+        expect([...protocolEvents.inbound].sort()).toEqual([...FLUXY_INBOUND_EVENT_TYPES].sort());
+        expect([...protocolEvents.outbound].sort()).toEqual([...FLUXY_OUTBOUND_EVENT_TYPES].sort());
+        expect(protocolEvents.version).toBe(FLUXY_PROTOCOL_VERSION);
+    });
+});

package/dist/sdk-contract.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sdk-contract.test.d.ts.map

package/dist/sdk-contract.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-contract.test.d.ts","sourceRoot":"","sources":["../src/sdk-contract.test.ts"],"names":[],"mappings":""}

package/dist/sdk-contract.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { FLUXY_INBOUND_EVENT_TYPES } from "./index.js";
+/**
+ * Subset of @fluxy-chat/sdk FluxyChatEvent types that must stay in sync.
+ * Expand when the TS SDK union grows.
+ */
+const SDK_INBOUND_EVENT_TYPES = [
+    "message",
+    "message_edit",
+    "message_delete",
+    "message_expired",
+    "typing",
+    "subscription_succeeded",
+    "subscription_count",
+    "member_joined",
+    "member_left",
+    "client_event",
+    "agentTyping",
+    "tool_call",
+    "tool_result",
+    "tool_error",
+    "agentRun",
+    "presence",
+    "cache_snapshot",
+    "server_event",
+    "user_event",
+    "user_subscription_succeeded",
+    "state_change",
+    "stream",
+    "error",
+];
+describe("SDK contract", () => {
+    it("includes every SDK inbound event in the protocol registry", () => {
+        const protocol = new Set(FLUXY_INBOUND_EVENT_TYPES);
+        const missing = SDK_INBOUND_EVENT_TYPES.filter((t) => !protocol.has(t));
+        expect(missing).toEqual([]);
+    });
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name":  "@fluxy-chat/protocol",
+    "version":  "0.1.0",
+    "description":  "Shared FluxyChat wire protocol — WebSocket event types and validators for SDKs and the worker",
+    "license":  "MIT",
+    "type":  "module",
+    "main":  "dist/index.js",
+    "types":  "dist/index.d.ts",
+    "exports":  {
+                    ".":  {
+                              "types":  "./dist/index.d.ts",
+                              "import":  "./dist/index.js"
+                          }
+                },
+    "files":  [
+                  "dist",
+                  "protocol-events.json"
+              ],
+    "scripts":  {
+                    "build":  "pnpm exec tsc -p tsconfig.json",
+                    "test":  "vitest run",
+                    "typecheck":  "tsc -p tsconfig.json --noEmit",
+                    "prepublishOnly":  "pnpm run build"
+                },
+    "devDependencies":  {
+                            "typescript":  "^5.8.3",
+                            "vite":  "^8.0.16",
+                            "vitest":  "^4.1.5"
+                        },
+    "publishConfig":  {
+                          "access":  "public"
+                      }
+}

package/protocol-events.json

@@ -0,0 +1,41 @@
+{
+  "version": "1.0.0",
+  "inbound": [
+    "message",
+    "message_edit",
+    "message_delete",
+    "message_expired",
+    "typing",
+    "subscription_succeeded",
+    "subscription_count",
+    "member_joined",
+    "member_left",
+    "client_event",
+    "agentTyping",
+    "tool_call",
+    "tool_result",
+    "tool_error",
+    "agentRun",
+    "presence",
+    "cache_snapshot",
+    "server_event",
+    "user_event",
+    "user_subscription_succeeded",
+    "state_change",
+    "stream",
+    "pong",
+    "error"
+  ],
+  "outbound": [
+    "ping",
+    "message",
+    "stream",
+    "edit",
+    "reaction",
+    "read",
+    "delete",
+    "typing",
+    "client_event",
+    "agentTyping"
+  ]
+}