core: expose v2 session controls

Author: thdxr

packages/opencode/src/server/routes/instance/httpapi/v2.ts

@@ -1,8 +1,9 @@
 import { SessionID } from "@/session/schema"
 import { SessionMessage } from "@/v2/session-message"
+import { Prompt } from "@/v2/session-prompt"
 import { SessionV2 } from "@/v2/session"
 import { Effect, Layer, Schema } from "effect"
-import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
+import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
 import { Authorization } from "./auth"
 
 export const V2Api = HttpApi.make("v2")
@@ -20,6 +21,46 @@ export const V2Api = HttpApi.make("v2")
           }),
         ),
       )
+      .add(
+        HttpApiEndpoint.post("prompt", "/api/session/:sessionID/prompt", {
+          params: { sessionID: SessionID },
+          payload: Schema.Struct({
+            prompt: Prompt,
+            delivery: SessionV2.Delivery.pipe(Schema.optional),
+          }),
+          success: SessionMessage.Message,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "v2.session.prompt",
+            summary: "Send v2 message",
+            description: "Create a v2 session message and queue it for the agent loop.",
+          }),
+        ),
+      )
+      .add(
+        HttpApiEndpoint.post("compact", "/api/session/:sessionID/compact", {
+          params: { sessionID: SessionID },
+          success: HttpApiSchema.NoContent,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "v2.session.compact",
+            summary: "Compact v2 session",
+            description: "Compact a v2 session conversation.",
+          }),
+        ),
+      )
+      .add(
+        HttpApiEndpoint.post("wait", "/api/session/:sessionID/wait", {
+          params: { sessionID: SessionID },
+          success: HttpApiSchema.NoContent,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "v2.session.wait",
+            summary: "Wait for v2 session",
+            description: "Wait for a v2 session agent loop to become idle.",
+          }),
+        ),
+      )
       .annotateMerge(
         OpenApi.annotations({
           title: "v2",
@@ -39,12 +80,37 @@ export const V2Api = HttpApi.make("v2")
 export const v2Handlers = HttpApiBuilder.group(V2Api, "v2", (handlers) =>
   Effect.gen(function* () {
     const session = yield* SessionV2.Service
-    return handlers.handle(
-      "messages",
-      Effect.fn(function* (ctx) {
-        return yield* session.messages(ctx.params.sessionID)
-      }),
-    )
+    return handlers
+      .handle(
+        "messages",
+        Effect.fn(function* (ctx) {
+          return yield* session.messages(ctx.params.sessionID)
+        }),
+      )
+      .handle(
+        "prompt",
+        Effect.fn(function* (ctx) {
+          return yield* session.prompt({
+            sessionID: ctx.params.sessionID,
+            prompt: ctx.payload.prompt,
+            delivery: ctx.payload.delivery ?? SessionV2.DefaultDelivery,
+          })
+        }),
+      )
+      .handle(
+        "compact",
+        Effect.fn(function* (ctx) {
+          yield* session.compact(ctx.params.sessionID)
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
+      .handle(
+        "wait",
+        Effect.fn(function* (ctx) {
+          yield* session.wait(ctx.params.sessionID)
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
   }),
 ).pipe(Layer.provide(SessionV2.defaultLayer))
 

packages/opencode/src/v2/session.ts

@@ -4,36 +4,64 @@ import { asc, eq } from "@/storage/db"
 import * as Database from "@/storage/db"
 import { Context, Effect, Layer, Schema } from "effect"
 import { SessionMessage } from "./session-message"
+import type { Prompt } from "./session-prompt"
+import { Session } from "@/session/session"
+import { SessionPrompt } from "@/session/prompt"
+import type { Event } from "./event"
+
+export const Delivery = Schema.Union([Schema.Literal("immediate"), Schema.Literal("deferred")]).annotate({
+  identifier: "Session.Delivery",
+})
+export type Delivery = Schema.Schema.Type<typeof Delivery>
+
+export const DefaultDelivery = "immediate" satisfies Delivery
 
 export interface Interface {
   readonly messages: (sessionID: SessionID) => Effect.Effect<SessionMessage.Message[], never>
+  readonly prompt: (input: {
+    id?: Event.ID
+    sessionID: SessionID
+    prompt: Prompt
+    delivery?: Delivery
+  }) => Effect.Effect<SessionMessage.User, never>
+  readonly compact: (sessionID: SessionID) => Effect.Effect<void, never>
+  readonly wait: (sessionID: SessionID) => Effect.Effect<void, never>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Session") {}
 
-export const layer: Layer.Layer<Service> = Layer.effect(
+export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const prompt = yield* SessionPrompt.Service
     const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Message)
     const decode = (row: typeof SessionMessageTable.$inferSelect) =>
       decodeMessage({ ...row.data, id: row.id, type: row.type })
 
-    const messages = Effect.fn("V2Session.messages")(function* (sessionID: SessionID) {
-      return Database.use((db) =>
-        db
-          .select()
-          .from(SessionMessageTable)
-          .where(eq(SessionMessageTable.session_id, sessionID))
-          .orderBy(asc(SessionMessageTable.time_created), asc(SessionMessageTable.id))
-          .all()
-          .map((row) => decode(row)),
-      )
-    })
-
-    return Service.of({ messages })
+    const result: Interface = {
+      messages: Effect.fn("V2Session.messages")(function* (sessionID) {
+        return Database.use((db) =>
+          db
+            .select()
+            .from(SessionMessageTable)
+            .where(eq(SessionMessageTable.session_id, sessionID))
+            .orderBy(asc(SessionMessageTable.time_created), asc(SessionMessageTable.id))
+            .all()
+            .map((row) => decode(row)),
+        )
+      }),
+      prompt: Effect.fn("V2Session.prompt")(function* (input) {
+        const delivery = input.delivery ?? DefaultDelivery
+        return {} as any
+      }),
+      compact: Effect.fn("V2Session.compact")(function* (sessionID) {}),
+      wait: Effect.fn("V2Session.wait")(function* (sessionID) {}),
+    }
+
+    return Service.of(result)
   }),
 )
 
-export const defaultLayer = layer
+export const defaultLayer = layer.pipe(Layer.provide(SessionPrompt.defaultLayer))
 
 export * as SessionV2 from "./session"