@opencode-ai/protocol 0.0.0-next-14984 → 0.0.0-next-14986

package/dist/groups/event.d.ts

@@ -2,19 +2,7 @@ import { Event } from "@opencode-ai/schema/event";
 import type { Definition } from "@opencode-ai/schema/event";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
-export declare const makeEventGroup: <const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions) => HttpApiGroup.HttpApiGroup<"server.event", HttpApiEndpoint.HttpApiEndpoint<"event.changes", "GET", "/api/event/changes", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"log.hint">;
-    readonly aggregateID: Schema.String;
-    readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"log.sweep_required">;
-}>]>>, Schema.Never, {
-    readonly type: "log.hint";
-    readonly aggregateID: string;
-    readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-} | {
-    readonly type: "log.sweep_required";
-}>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"event.subscribe", "GET", "/api/event", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [...Definitions, ...Schema.Struct<{
+export declare const makeEventGroup: <const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions) => HttpApiGroup.HttpApiGroup<"server.event", HttpApiEndpoint.HttpApiEndpoint<"event.subscribe", "GET", "/api/event", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [...Definitions, ...Schema.Struct<{
     readonly type: Schema.Literal<"server.connected">;
     readonly data: Schema.Struct<{}>;
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -43,19 +31,7 @@ export declare const makeEventGroup: <const Definitions extends ReadonlyArray<De
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
     } | undefined;
 }[]])[number]>, HttpApiEndpoint.Json<never>, never, never>, false>;
-export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpApiEndpoint.HttpApiEndpoint<"event.changes", "GET", "/api/event/changes", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"log.hint">;
-    readonly aggregateID: Schema.String;
-    readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"log.sweep_required">;
-}>]>>, Schema.Never, {
-    readonly type: "log.hint";
-    readonly aggregateID: string;
-    readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-} | {
-    readonly type: "log.sweep_required";
-}>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"event.subscribe", "GET", "/api/event", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Struct<{
+export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpApiEndpoint.HttpApiEndpoint<"event.subscribe", "GET", "/api/event", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
     };

package/dist/groups/event.js

@@ -1,5 +1,4 @@
 import { Event } from "@opencode-ai/schema/event";
-import { EventLog } from "@opencode-ai/schema/event-log";
 import { EventManifest } from "@opencode-ai/schema/event-manifest";
 import { Location } from "@opencode-ai/schema/location";
 import { Schema } from "effect";
@@ -31,14 +30,7 @@ const make = (definitions) => {
         }).annotateMerge(OpenApi.annotations({
             identifier: "v2.event.subscribe",
             summary: "Subscribe to events",
-            description: "Subscribe to native event payloads for the server. Volatile by contract: a slow consumer overflows and fails the stream, and events during disconnection are missed. Consumers that need reliability should combine the changes feed with durable session log reads.",
-        })))
-            .add(HttpApiEndpoint.get("event.changes", "/api/event/changes", {
-            success: HttpApiSchema.StreamSse({ data: EventLog.Change }),
-        }).annotateMerge(OpenApi.annotations({
-            identifier: "v2.event.changes",
-            summary: "Subscribe to change hints",
-            description: "Payload-free hint channel: after an event commits, a subscriber eventually receives a hint for that aggregate with seq at or beyond the event, or a sweep-required marker. Hints coalesce to the latest seq per aggregate under backpressure and the stream never fails from overflow. No consumer may derive correctness from receiving a hint; correctness always comes from durable log reads plus the consumer's own checkpoint. A sweep-required marker is emitted first on every (re)subscribe and whenever hint retention is exceeded: treat every aggregate as potentially dirty and recover via bounded sweep plus log reads.",
+            description: "Subscribe to native event payloads for the server. Volatile by contract: a slow consumer overflows and fails the stream, and events during disconnection are missed.",
         })))
             .annotateMerge(OpenApi.annotations({ title: "event", description: "Experimental event stream routes." })),
     };

package/dist/groups/message.d.ts

@@ -1,4 +1,3 @@
-import { Event } from "@opencode-ai/schema/event";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
@@ -22,7 +21,7 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
         readonly agent: Schema.String;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly time: Schema.Struct<{
@@ -82,7 +81,7 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
         }>>, never, never>;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly time: Schema.Struct<{
@@ -169,7 +168,7 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
         readonly type: Schema.Literal<"user">;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly time: Schema.Struct<{
@@ -185,7 +184,7 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
         readonly type: Schema.Literal<"synthetic">;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly time: Schema.Struct<{
@@ -196,7 +195,7 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
         readonly text: Schema.String;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly time: Schema.Struct<{
@@ -208,7 +207,7 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
         readonly text: Schema.String;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly time: Schema.Struct<{
@@ -251,7 +250,7 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
         }>;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
     }>, Schema.Struct<{
@@ -454,13 +453,13 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
         }>;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly time: Schema.Struct<{
@@ -471,7 +470,6 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
         readonly summary: Schema.String;
         readonly recent: Schema.String;
     }>]>>;
-    readonly watermark: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Int, "Event.Seq">>>, Schema.optionalKey<Schema.brand<Schema.Int, "Event.Seq">>, never, never>;
     readonly cursor: Schema.Struct<{
         readonly previous: Schema.optional<Schema.String>;
         readonly next: Schema.optional<Schema.String>;

package/dist/groups/message.js

@@ -1,7 +1,5 @@
 import { Session } from "@opencode-ai/schema/session";
 import { SessionMessage } from "@opencode-ai/schema/session-message";
-import { optional } from "@opencode-ai/schema/schema";
-import { Event } from "@opencode-ai/schema/event";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
 import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
@@ -22,9 +20,6 @@ export const MessageGroup = HttpApiGroup.make("server.message")
     query: SessionMessagesQuery,
     success: Schema.Struct({
         data: Schema.Array(SessionMessage.Message),
-        watermark: optional(Event.Seq).annotate({
-            description: "Durable log seq this snapshot was computed at, read before the snapshot. Attach a live log read after the watermark to compose fetch and stream gap-free; events between the watermark and the snapshot read may be redelivered by the tail and are safe to re-apply. Absent when the session has no durable events.",
-        }),
         cursor: Schema.Struct({
             previous: Schema.String.pipe(Schema.optional),
             next: Schema.String.pipe(Schema.optional),

package/dist/groups/session.d.ts

@@ -263,10 +263,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             }>>>, never, never>;
         }>>, never, never>;
     }>>;
-    readonly watermarks: Schema.$Record<Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    }, Schema.brand<Schema.Int, "Event.Seq">>;
     readonly cursor: Schema.Struct<{
         readonly previous: Schema.optional<Schema.brand<Schema.String, "SessionsCursor"> & {
             make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
@@ -504,10 +500,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     }, Schema.Struct<{
         readonly type: Schema.Literal<"running">;
     }>>;
-    readonly watermarks: Schema.$Record<Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    }, Schema.brand<Schema.Int, "Event.Seq">>;
 }>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.get", "GET", "/api/session/:sessionID", HttpApiEndpoint.StringTree<Schema.Struct<{
     sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -1840,7 +1832,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
     key: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.log", "GET", "/api/session/:sessionID/log", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.log", "GET", "/api/experimental/session/:sessionID/log", HttpApiEndpoint.StringTree<Schema.Struct<{
     sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;

package/dist/groups/session.js

@@ -74,10 +74,6 @@ export const SessionsCursor = Schema.String.pipe(Schema.brand("SessionsCursor"),
 const SessionActive = Schema.Struct({
     type: Schema.Literal("running"),
 }).annotate({ identifier: "SessionActive" });
-const SessionWatermarks = Schema.Record(Session.ID, Event.Seq).annotate({
-    identifier: "SessionWatermarks",
-    description: "Durable log seq each session's snapshot was computed at. Attach a live log read after the watermark to compose fetch and stream gap-free; apply a snapshot only where its watermark is at or beyond already-applied events. Sessions without durable events are absent.",
-});
 const BooleanFromString = Schema.Literals(["true", "false"]).pipe(Schema.decodeTo(Schema.Boolean, {
     decode: SchemaGetter.transform((value) => value === "true"),
     encode: SchemaGetter.transform((value) => (value ? "true" : "false")),
@@ -97,7 +93,6 @@ export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make
     query: SessionsQuery,
     success: Schema.Struct({
         data: Schema.Array(Session.Info),
-        watermarks: SessionWatermarks,
         cursor: Schema.Struct({
             previous: SessionsCursor.pipe(Schema.optional),
             next: SessionsCursor.pipe(Schema.optional),
@@ -123,11 +118,11 @@ export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make
     description: "Create a session at the requested location.",
 })))
     .add(HttpApiEndpoint.get("session.active", "/api/session/active", {
-    success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive), watermarks: SessionWatermarks }),
+    success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive) }),
 }).annotateMerge(OpenApi.annotations({
     identifier: "v2.session.active",
     summary: "List active sessions",
-    description: "Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive. Watermarks are the durable log positions read alongside the activity snapshot; activity itself is process state, so the pairing is advisory rather than transactional.",
+    description: "Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive.",
 })))
     .add(HttpApiEndpoint.get("session.get", "/api/session/:sessionID", {
     params: { sessionID: Session.ID },
@@ -367,7 +362,7 @@ export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make
     summary: "Remove context entry",
     description: "Remove one context entry; the removal is announced to the model at the next turn boundary.",
 })))
-    .add(HttpApiEndpoint.get("session.log", "/api/session/:sessionID/log", {
+    .add(HttpApiEndpoint.get("session.log", "/api/experimental/session/:sessionID/log", {
     params: { sessionID: Session.ID },
     query: {
         after: Schema.NumberFromString.pipe(Schema.decodeTo(Event.Seq), Schema.optional),
@@ -382,7 +377,7 @@ export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make
     .annotateMerge(OpenApi.annotations({
     identifier: "v2.session.log",
     summary: "Read the session log",
-    description: "Durable, ordered, gap-free read of public session events after an exclusive aggregate sequence. Emits a synced marker once replay reaches the captured watermark, then completes; with follow=true it continues with live events instead. The only event API that promises reliability: attach after a snapshot watermark to compose fetch and stream without a race window.",
+    description: "Experimental durable session event log. Reads events after an exclusive aggregate sequence and continues with live events when follow=true.",
 })))
     .add(HttpApiEndpoint.post("session.interrupt", "/api/session/:sessionID/interrupt", {
     params: { sessionID: Session.ID },

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/protocol",
-  "version": "0.0.0-next-14984",
+  "version": "0.0.0-next-14986",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,7 +26,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/schema": "0.0.0-next-14984",
+    "@opencode-ai/schema": "0.0.0-next-14986",
     "effect": "4.0.0-beta.83"
   },
   "devDependencies": {