@opencode-ai/protocol 0.0.0-next-14722 → 0.0.0-next-14730

package/dist/groups/session.js

@@ -4,9 +4,10 @@ import { PromptInput } from "@opencode-ai/schema/prompt-input";
 import { Session } from "@opencode-ai/schema/session";
 import { SessionContextEntry } from "@opencode-ai/schema/session-context-entry";
 import { Project } from "@opencode-ai/schema/project";
-import { AbsolutePath, NonNegativeInt, PositiveInt, RelativePath, statics } from "@opencode-ai/schema/schema";
+import { AbsolutePath, PositiveInt, RelativePath, statics } from "@opencode-ai/schema/schema";
+import { Event } from "@opencode-ai/schema/event";
 import { Workspace } from "@opencode-ai/schema/workspace";
-import { Context, Effect, Encoding, Result, Schema, Struct } from "effect";
+import { Context, Effect, Encoding, Result, Schema, SchemaGetter, Struct } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
 import { ConflictError, CommandEvaluationError, CommandNotFoundError, InvalidCursorError, InvalidRequestError, MessageNotFoundError, ServiceUnavailableError, SessionBusyError, SessionNotFoundError, SkillNotFoundError, UnknownError, } from "../errors.js";
 import { Agent } from "@opencode-ai/schema/agent";
@@ -14,6 +15,7 @@ import { Model } from "@opencode-ai/schema/model";
 import { Location } from "@opencode-ai/schema/location";
 import { Revert } from "@opencode-ai/schema/revert";
 import { SessionEvent } from "@opencode-ai/schema/session-event";
+import { EventLog } from "@opencode-ai/schema/event-log";
 const SessionsQueryFields = {
     workspace: Workspace.ID.pipe(Schema.optional),
     limit: Schema.NumberFromString.pipe(Schema.decodeTo(PositiveInt), Schema.optional).annotate({
@@ -62,11 +64,14 @@ export const SessionsCursor = Schema.String.pipe(Schema.brand("SessionsCursor"),
 const SessionActive = Schema.Struct({
     type: Schema.Literal("running"),
 }).annotate({ identifier: "SessionActive" });
-const SessionHistoryLimit = PositiveInt.check(Schema.isLessThanOrEqualTo(100));
-export const SessionHistoryQuery = Schema.Struct({
-    limit: Schema.NumberFromString.pipe(Schema.decodeTo(SessionHistoryLimit), Schema.optional),
-    after: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional),
+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")),
+}));
 const SessionsQueryCursor = SessionsCursor.annotate({
     description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
 });
@@ -82,6 +87,7 @@ 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),
@@ -107,11 +113,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) }),
+    success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive), watermarks: SessionWatermarks }),
 }).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.",
+    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.",
 })))
     .add(HttpApiEndpoint.get("session.get", "/api/session/:sessionID", {
     params: { sessionID: Session.ID },
@@ -336,34 +342,22 @@ 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.history", "/api/session/:sessionID/history", {
-    params: { sessionID: Session.ID },
-    query: SessionHistoryQuery,
-    success: Schema.Struct({
-        data: Schema.Array(SessionEvent.Durable),
-        hasMore: Schema.Boolean,
-    }).annotate({ identifier: "SessionHistory" }),
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.history",
-    summary: "Get session history",
-    description: "Read one finite page of public durable Session events after an exclusive aggregate sequence. Newly committed events may appear on later pages.",
-})))
-    .add(HttpApiEndpoint.get("session.events", "/api/session/:sessionID/event", {
+    .add(HttpApiEndpoint.get("session.log", "/api/session/:sessionID/log", {
     params: { sessionID: Session.ID },
     query: {
-        after: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional),
+        after: Schema.NumberFromString.pipe(Schema.decodeTo(Event.Seq), Schema.optional),
+        follow: BooleanFromString.pipe(Schema.optional),
     },
-    success: HttpApiSchema.StreamSse({ data: SessionEvent.Durable }),
+    success: HttpApiSchema.StreamSse({
+        data: Schema.Union([SessionEvent.Durable, EventLog.CaughtUp]).annotate({ identifier: "SessionLogItem" }),
+    }),
     error: SessionNotFoundError,
 })
     .middleware(sessionLocationMiddleware)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.events",
-    summary: "Subscribe to session events",
-    description: "Replay durable events after an aggregate sequence, then continue with new durable events.",
+    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 caught-up marker once the replay reaches the end of the log, 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.",
 })))
     .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-14722",
+  "version": "0.0.0-next-14730",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,7 +26,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/schema": "0.0.0-next-14722",
+    "@opencode-ai/schema": "0.0.0-next-14730",
     "effect": "4.0.0-beta.83"
   },
   "devDependencies": {

package/dist/groups/question.d.ts

@@ -1,92 +0,0 @@
-import { Location } from "@opencode-ai/schema/location";
-import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
-import { QuestionNotFoundError, SessionNotFoundError } from "../errors.js";
-export declare const makeQuestionGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(locationMiddleware: Context.Key<LocationId, LocationService>, sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>) => HttpApiGroup.HttpApiGroup<"server.question", HttpApiEndpoint.HttpApiEndpoint<"question.request.list", "GET", "/api/question/request", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
-    readonly location: typeof Location.Info;
-    readonly data: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "QuestionV2.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
-        };
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-        readonly questions: Schema.$Array<Schema.Struct<{
-            readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-            readonly question: Schema.String;
-            readonly header: Schema.String;
-            readonly options: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.String;
-                readonly description: Schema.String;
-            }>>;
-            readonly multiple: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        }>>;
-        readonly tool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly messageID: Schema.String;
-            readonly callID: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly messageID: Schema.String;
-            readonly callID: Schema.String;
-        }>>, never, never>;
-    }>>;
-}>>, HttpApiEndpoint.Json<never>, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.question.list", "GET", "/api/session/:sessionID/question", 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">;
-    };
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
-    readonly data: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "QuestionV2.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
-        };
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-        readonly questions: Schema.$Array<Schema.Struct<{
-            readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-            readonly question: Schema.String;
-            readonly header: Schema.String;
-            readonly options: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.String;
-                readonly description: Schema.String;
-            }>>;
-            readonly multiple: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        }>>;
-        readonly tool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly messageID: Schema.String;
-            readonly callID: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly messageID: Schema.String;
-            readonly callID: Schema.String;
-        }>>, never, never>;
-    }>>;
-}>>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.question.reply", "POST", "/api/session/:sessionID/question/:requestID/reply", 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">;
-    };
-    requestID: Schema.brand<Schema.String, "QuestionV2.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
-    };
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
-    readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError | typeof QuestionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.question.reject", "POST", "/api/session/:sessionID/question/:requestID/reject", 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">;
-    };
-    requestID: Schema.brand<Schema.String, "QuestionV2.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
-    };
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError | typeof QuestionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>>, false>;

package/dist/groups/question.js

@@ -1,56 +0,0 @@
-import { Question } from "@opencode-ai/schema/question";
-import { Location } from "@opencode-ai/schema/location";
-import { Session } from "@opencode-ai/schema/session";
-import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { QuestionNotFoundError, SessionNotFoundError } from "../errors.js";
-import { LocationQuery, locationQueryOpenApi } from "./location.js";
-export const makeQuestionGroup = (locationMiddleware, sessionLocationMiddleware) => HttpApiGroup.make("server.question")
-    .add(HttpApiEndpoint.get("question.request.list", "/api/question/request", {
-    query: LocationQuery,
-    success: Location.response(Schema.Array(Question.Request)),
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.question.request.list",
-    summary: "List pending question requests",
-    description: "Retrieve pending question requests for a location.",
-})))
-    .annotateMerge(OpenApi.annotations({ title: "questions", description: "Experimental question routes." }))
-    // Effect applies group middleware only to endpoints already added; session endpoints use session placement below.
-    .middleware(locationMiddleware)
-    .add(HttpApiEndpoint.get("session.question.list", "/api/session/:sessionID/question", {
-    params: { sessionID: Session.ID },
-    success: Schema.Struct({ data: Schema.Array(Question.Request) }),
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.question.list",
-    summary: "List session question requests",
-    description: "Retrieve pending question requests owned by a session.",
-})))
-    .add(HttpApiEndpoint.post("session.question.reply", "/api/session/:sessionID/question/:requestID/reply", {
-    params: { sessionID: Session.ID, requestID: Question.ID },
-    payload: Question.Reply,
-    success: HttpApiSchema.NoContent,
-    error: [SessionNotFoundError, QuestionNotFoundError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.question.reply",
-    summary: "Reply to pending question request",
-    description: "Answer a pending question request owned by a session.",
-})))
-    .add(HttpApiEndpoint.post("session.question.reject", "/api/session/:sessionID/question/:requestID/reject", {
-    params: { sessionID: Session.ID, requestID: Question.ID },
-    success: HttpApiSchema.NoContent,
-    error: [SessionNotFoundError, QuestionNotFoundError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.question.reject",
-    summary: "Reject pending question request",
-    description: "Reject a pending question request owned by a session.",
-})))
-    .annotateMerge(OpenApi.annotations({ title: "session questions", description: "Experimental session question routes." }));