feat(core): add embedded v2 session runtime and tool foundation (#30632)

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

@@ -5,6 +5,7 @@ import { ProviderGroup } from "./v2/provider"
 import { SessionGroup } from "./v2/session"
 import { PermissionGroup, PermissionSavedGroup, SessionPermissionGroup } from "./v2/permission"
 import { FileSystemGroup } from "./v2/fs"
+import { QuestionGroup, SessionQuestionGroup } from "./v2/question"
 
 export const V2Api = HttpApi.make("v2")
   .add(SessionGroup)
@@ -15,6 +16,8 @@ export const V2Api = HttpApi.make("v2")
   .add(SessionPermissionGroup)
   .add(PermissionSavedGroup)
   .add(FileSystemGroup)
+  .add(QuestionGroup)
+  .add(SessionQuestionGroup)
   .annotateMerge(
     OpenApi.annotations({
       title: "opencode experimental HttpApi",

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

@@ -6,6 +6,8 @@ import { PermissionV2 } from "@opencode-ai/core/permission"
 import { ProjectReference } from "@opencode-ai/core/project-reference"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { PluginBoot } from "@opencode-ai/core/plugin/boot"
+import { WorkspaceV2 } from "@opencode-ai/core/workspace"
+import { QuestionV2 } from "@opencode-ai/core/question"
 import { Effect, Layer, Schema } from "effect"
 import { HttpServerRequest } from "effect/unstable/http"
 import { HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi"
@@ -43,16 +45,18 @@ export class V2LocationMiddleware extends HttpApiMiddleware.Service<
       | PermissionV2.Service
       | ProjectReference.Service
       | FileSystem.Service
+      | QuestionV2.Service
   }
 >()("@opencode/ExperimentalHttpApiV2Location") {}
 
 function ref(request: HttpServerRequest.HttpServerRequest): Location.Ref {
   const query = new URL(request.url, "http://localhost").searchParams
+  const workspaceID = query.get("location[workspace]") || request.headers["x-opencode-workspace"]
   return {
     directory: AbsolutePath.make(
       query.get("location[directory]") || request.headers["x-opencode-directory"] || process.cwd(),
     ),
-    workspaceID: query.get("location[workspace]") || request.headers["x-opencode-workspace"],
+    workspaceID: workspaceID ? WorkspaceV2.ID.make(workspaceID) : undefined,
   }
 }
 

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

@@ -9,7 +9,7 @@ export const ModelGroup = HttpApiGroup.make("v2.model")
   .add(
     HttpApiEndpoint.get("models", "/api/model", {
       query: LocationQuery,
-      success: Schema.Array(ModelV2.Info),
+      success: Schema.Array(ModelV2.PublicInfo),
       error: ServiceUnavailableError,
     })
       .annotateMerge(locationQueryOpenApi)

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

@@ -9,7 +9,7 @@ export const ProviderGroup = HttpApiGroup.make("v2.provider")
   .add(
     HttpApiEndpoint.get("providers", "/api/provider", {
       query: LocationQuery,
-      success: Schema.Array(ProviderV2.Info),
+      success: Schema.Array(ProviderV2.PublicInfo),
       error: ServiceUnavailableError,
     })
       .annotateMerge(locationQueryOpenApi)
@@ -25,7 +25,7 @@ export const ProviderGroup = HttpApiGroup.make("v2.provider")
     HttpApiEndpoint.get("provider", "/api/provider/:providerID", {
       params: { providerID: ProviderV2.ID },
       query: LocationQuery,
-      success: ProviderV2.Info,
+      success: ProviderV2.PublicInfo,
       error: [ProviderNotFoundError, ServiceUnavailableError],
     })
       .annotateMerge(locationQueryOpenApi)

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

@@ -0,0 +1,59 @@
+import { QuestionV2 } from "@opencode-ai/core/question"
+import { SessionV2 } from "@opencode-ai/core/session"
+import { Schema } from "effect"
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import { QuestionNotFoundError, SessionNotFoundError } from "../../errors"
+import { V2Authorization } from "../../middleware/authorization"
+import { LocationQuery, locationQueryOpenApi, V2LocationMiddleware } from "./location"
+
+export const QuestionGroup = HttpApiGroup.make("v2.question")
+  .add(
+    HttpApiEndpoint.get("questionRequests", "/api/question/request", {
+      query: LocationQuery,
+      success: Schema.Array(QuestionV2.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: "v2 questions", description: "Experimental v2 question routes." }))
+  .middleware(V2LocationMiddleware)
+  .middleware(V2Authorization)
+
+export const SessionQuestionGroup = HttpApiGroup.make("v2.session.question")
+  .add(
+    HttpApiEndpoint.post("questionRequestReply", "/api/session/:sessionID/question/request/:requestID/reply", {
+      params: { sessionID: SessionV2.ID, requestID: QuestionV2.ID },
+      payload: QuestionV2.Reply,
+      success: HttpApiSchema.NoContent,
+      error: [SessionNotFoundError, QuestionNotFoundError],
+    }).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("questionRequestReject", "/api/session/:sessionID/question/request/:requestID/reject", {
+      params: { sessionID: SessionV2.ID, requestID: QuestionV2.ID },
+      success: HttpApiSchema.NoContent,
+      error: [SessionNotFoundError, QuestionNotFoundError],
+    }).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: "v2 session questions", description: "Experimental v2 session question routes." }),
+  )
+  .middleware(V2Authorization)

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

@@ -1,5 +1,6 @@
 import { SessionID } from "@/session/schema"
 import { SessionMessage } from "@opencode-ai/core/session/message"
+import { SessionInput } from "@opencode-ai/core/session/input"
 import { Prompt } from "@opencode-ai/core/session/prompt"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { ProjectV2 } from "@opencode-ai/core/project"
@@ -8,6 +9,7 @@ import { WorkspaceV2 } from "@opencode-ai/core/workspace"
 import { Schema, Struct } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
 import {
+  ConflictError,
   InvalidCursorError,
   InvalidRequestError,
   ServiceUnavailableError,
@@ -110,16 +112,18 @@ export const SessionGroup = HttpApiGroup.make("v2.session")
       params: { sessionID: SessionID },
       query: WorkspaceRoutingQuery,
       payload: Schema.Struct({
+        id: SessionMessage.ID.pipe(Schema.optional),
         prompt: Prompt,
-        delivery: SessionV2.Delivery.pipe(Schema.optional),
+        delivery: SessionInput.Delivery.pipe(Schema.optional),
+        resume: Schema.Boolean.pipe(Schema.optional),
       }),
-      success: SessionMessage.Message,
-      error: [SessionNotFoundError, ServiceUnavailableError],
+      success: SessionMessage.User,
+      error: [ConflictError, SessionNotFoundError],
     }).annotateMerge(
       OpenApi.annotations({
         identifier: "v2.session.prompt",
         summary: "Send v2 message",
-        description: "Create a v2 session message and queue it for the agent loop.",
+        description: "Durably admit one v2 session input and schedule agent-loop execution unless resume is false.",
       }),
     ),
   )

packages/opencode/src/server/routes/instance/httpapi/handlers/sync.ts

@@ -50,7 +50,8 @@ export const syncHandlers = HttpApiBuilder.group(InstanceHttpApi, "sync", (handl
         last: payload.at(-1)?.seq,
         directory: ctx.payload.directory,
       })
-      yield* events.replayAll(payload)
+      const ownerID = yield* InstanceState.workspaceID
+      yield* events.replayAll(payload, { ownerID, strictOwner: true })
       log.info("sync replay complete", {
         sessionID: source,
         events: payload.length,

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

@@ -1,6 +1,12 @@
 import { SessionV2 } from "@opencode-ai/core/session"
+import { Database } from "@opencode-ai/core/database/database"
+import { EventV2 } from "@opencode-ai/core/event"
 import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { PermissionSaved } from "@opencode-ai/core/permission/saved"
+import { ProjectV2 } from "@opencode-ai/core/project"
+import * as SessionExecutionLocal from "@opencode-ai/core/session/execution/local"
+import { SessionProjector } from "@opencode-ai/core/session/projector"
+import { SessionStore } from "@opencode-ai/core/session/store"
 import { Layer } from "effect"
 import { layer as v2LocationLayer } from "../groups/v2/location"
 import { messageHandlers } from "./v2/message"
@@ -9,6 +15,18 @@ import { providerHandlers } from "./v2/provider"
 import { sessionHandlers } from "./v2/session"
 import { permissionHandlers, savedPermissionHandlers, sessionPermissionHandlers } from "./v2/permission"
 import { fileSystemHandlers } from "./v2/fs"
+import { questionHandlers, sessionQuestionHandlers } from "./v2/question"
+
+const routedSessions = SessionV2.layer.pipe(
+  Layer.provide(SessionProjector.layer),
+  Layer.provide(SessionExecutionLocal.layer),
+  Layer.provide(LocationServiceMap.layer),
+  Layer.provide(SessionStore.layer),
+  Layer.provide(EventV2.layer),
+  Layer.provide(Database.defaultLayer),
+  Layer.provide(ProjectV2.defaultLayer),
+  Layer.orDie,
+)
 
 export const v2Handlers = Layer.mergeAll(
   sessionHandlers,
@@ -19,9 +37,11 @@ export const v2Handlers = Layer.mergeAll(
   sessionPermissionHandlers,
   savedPermissionHandlers,
   fileSystemHandlers,
+  questionHandlers,
+  sessionQuestionHandlers,
 ).pipe(
   Layer.provide(v2LocationLayer),
   Layer.provide(LocationServiceMap.layer),
   Layer.provide(PermissionSaved.layer),
-  Layer.provide(SessionV2.defaultLayer),
+  Layer.provide(routedSessions),
 )

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

@@ -1,7 +1,6 @@
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { Effect, Schema } from "effect"
-import * as DateTime from "effect/DateTime"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { InstanceHttpApi } from "../../api"
 import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../../errors"
@@ -10,7 +9,6 @@ const DefaultMessagesLimit = 50
 
 const Cursor = Schema.Struct({
   id: SessionMessage.ID,
-  time: Schema.Finite,
   order: Schema.Union([Schema.Literal("asc"), Schema.Literal("desc")]),
   direction: Schema.Union([Schema.Literal("previous"), Schema.Literal("next")]),
 })
@@ -19,9 +17,7 @@ const decodeCursor = Schema.decodeUnknownSync(Cursor)
 
 const cursor = {
   encode(message: SessionMessage.Message, order: "asc" | "desc", direction: "previous" | "next") {
-    return Buffer.from(
-      JSON.stringify({ id: message.id, time: DateTime.toEpochMillis(message.time.created), order, direction }),
-    ).toString("base64url")
+    return Buffer.from(JSON.stringify({ id: message.id, order, direction })).toString("base64url")
   },
   decode(input: string) {
     return decodeCursor(JSON.parse(Buffer.from(input, "base64url").toString("utf8")))
@@ -47,7 +43,7 @@ export const messageHandlers = HttpApiBuilder.group(InstanceHttpApi, "v2.message
             sessionID: ctx.params.sessionID,
             limit: ctx.query.limit ?? DefaultMessagesLimit,
             order,
-            cursor: decoded ? { id: decoded.id, time: decoded.time, direction: decoded.direction } : undefined,
+            cursor: decoded ? { id: decoded.id, direction: decoded.direction } : undefined,
           })
           .pipe(
             Effect.catchTag("Session.NotFoundError", (error) =>

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

@@ -1,5 +1,6 @@
 import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginBoot } from "@opencode-ai/core/plugin/boot"
+import { ModelV2 } from "@opencode-ai/core/model"
 import { Effect } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { InstanceHttpApi } from "../../api"
@@ -18,7 +19,7 @@ export const modelHandlers = HttpApiBuilder.group(InstanceHttpApi, "v2.model", (
         const catalog = yield* Catalog.Service
         const pluginBoot = yield* PluginBoot.Service
         yield* pluginBoot.wait().pipe(Effect.catchDefect(() => Effect.fail(catalogUnavailable)))
-        return yield* catalog.model.available()
+        return (yield* catalog.model.available()).map(ModelV2.toPublic)
       }),
     )
   }),

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

@@ -1,5 +1,6 @@
 import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginBoot } from "@opencode-ai/core/plugin/boot"
+import { ProviderV2 } from "@opencode-ai/core/provider"
 import { Effect } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { InstanceHttpApi } from "../../api"
@@ -19,7 +20,7 @@ export const providerHandlers = HttpApiBuilder.group(InstanceHttpApi, "v2.provid
           const catalog = yield* Catalog.Service
           const pluginBoot = yield* PluginBoot.Service
           yield* pluginBoot.wait().pipe(Effect.catchDefect(() => Effect.fail(catalogUnavailable)))
-          return yield* catalog.provider.available()
+          return (yield* catalog.provider.available()).map(ProviderV2.toPublic)
         }),
       )
       .handle(
@@ -29,6 +30,7 @@ export const providerHandlers = HttpApiBuilder.group(InstanceHttpApi, "v2.provid
           const pluginBoot = yield* PluginBoot.Service
           yield* pluginBoot.wait().pipe(Effect.catchDefect(() => Effect.fail(catalogUnavailable)))
           return yield* catalog.provider.get(ctx.params.providerID).pipe(
+            Effect.map(ProviderV2.toPublic),
             Effect.catchTag("CatalogV2.ProviderNotFound", (error) =>
               Effect.fail(
                 new ProviderNotFoundError({

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

@@ -0,0 +1,96 @@
+import { Database } from "@opencode-ai/core/database/database"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { QuestionV2 } from "@opencode-ai/core/question"
+import { AbsolutePath } from "@opencode-ai/core/schema"
+import { SessionTable } from "@opencode-ai/core/session/sql"
+import { eq } from "drizzle-orm"
+import { Effect } from "effect"
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
+import { InstanceHttpApi } from "../../api"
+import { QuestionNotFoundError, SessionNotFoundError } from "../../errors"
+
+function missingRequest(id: QuestionV2.ID) {
+  return new QuestionNotFoundError({ requestID: id, message: `Question request not found: ${id}` })
+}
+
+export const questionHandlers = HttpApiBuilder.group(InstanceHttpApi, "v2.question", (handlers) =>
+  Effect.gen(function* () {
+    return handlers.handle(
+      "questionRequests",
+      Effect.fn(function* () {
+        return yield* (yield* QuestionV2.Service).list()
+      }),
+    )
+  }),
+)
+
+export const sessionQuestionHandlers = HttpApiBuilder.group(InstanceHttpApi, "v2.session.question", (handlers) =>
+  Effect.gen(function* () {
+    const { db } = yield* Database.Service
+    const locations = yield* LocationServiceMap
+
+    const withSessionQuestion = Effect.fnUntraced(function* <A, E>(
+      sessionID: QuestionV2.Request["sessionID"],
+      use: (question: QuestionV2.Interface) => Effect.Effect<A, E>,
+    ) {
+      const row = yield* db
+        .select({ directory: SessionTable.directory, workspaceID: SessionTable.workspace_id })
+        .from(SessionTable)
+        .where(eq(SessionTable.id, sessionID))
+        .get()
+        .pipe(Effect.orDie)
+      if (!row)
+        return yield* new SessionNotFoundError({
+          sessionID,
+          message: `Session not found: ${sessionID}`,
+        })
+
+      return yield* Effect.gen(function* () {
+        return yield* use(yield* QuestionV2.Service)
+      }).pipe(
+        Effect.scoped,
+        Effect.provide(
+          locations.get({ directory: AbsolutePath.make(row.directory), workspaceID: row.workspaceID ?? undefined }),
+        ),
+      )
+    })
+
+    const withOwnedQuestion = Effect.fnUntraced(function* <A, E>(
+      sessionID: QuestionV2.Request["sessionID"],
+      requestID: QuestionV2.ID,
+      use: (question: QuestionV2.Interface) => Effect.Effect<A, E>,
+    ) {
+      return yield* withSessionQuestion(sessionID, (question) =>
+        Effect.gen(function* () {
+          const request = (yield* question.list()).find((request) => request.id === requestID)
+          if (!request || request.sessionID !== sessionID) return yield* missingRequest(requestID)
+          return yield* use(question)
+        }),
+      )
+    })
+
+    return handlers
+      .handle(
+        "questionRequestReply",
+        Effect.fn(function* (ctx) {
+          yield* withOwnedQuestion(ctx.params.sessionID, ctx.params.requestID, (question) =>
+            question
+              .reply({ requestID: ctx.params.requestID, answers: ctx.payload.answers })
+              .pipe(Effect.catchTag("QuestionV2.NotFoundError", () => missingRequest(ctx.params.requestID))),
+          )
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
+      .handle(
+        "questionRequestReject",
+        Effect.fn(function* (ctx) {
+          yield* withOwnedQuestion(ctx.params.sessionID, ctx.params.requestID, (question) =>
+            question
+              .reject(ctx.params.requestID)
+              .pipe(Effect.catchTag("QuestionV2.NotFoundError", () => missingRequest(ctx.params.requestID))),
+          )
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
+  }),
+)

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

@@ -3,7 +3,13 @@ import { DateTime, Effect } from "effect"
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
 import { InstanceHttpApi } from "../../api"
 import { SessionsCursor } from "../../groups/v2/session"
-import { InvalidCursorError, ServiceUnavailableError, SessionNotFoundError, UnknownError } from "../../errors"
+import {
+  ConflictError,
+  InvalidCursorError,
+  ServiceUnavailableError,
+  SessionNotFoundError,
+  UnknownError,
+} from "../../errors"
 
 const DefaultSessionsLimit = 50
 
@@ -61,8 +67,10 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "v2.session
           return yield* session
             .prompt({
               sessionID: ctx.params.sessionID,
+              id: ctx.payload.id,
               prompt: ctx.payload.prompt,
-              delivery: ctx.payload.delivery ?? SessionV2.DefaultDelivery,
+              delivery: ctx.payload.delivery,
+              resume: ctx.payload.resume,
             })
             .pipe(
               Effect.catchTag("Session.NotFoundError", (error) =>
@@ -73,11 +81,11 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "v2.session
                   }),
                 ),
               ),
-              Effect.catchTag("Session.OperationUnavailableError", (error) =>
+              Effect.catchTag("Session.PromptConflictError", (error) =>
                 Effect.fail(
-                  new ServiceUnavailableError({
-                    message: `V2 session ${error.operation} is not available yet`,
-                    service: `v2.session.${error.operation}`,
+                  new ConflictError({
+                    message: `Prompt message ID conflicts with an existing durable record: ${error.messageID}`,
+                    resource: error.messageID,
                   }),
                 ),
               ),

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

@@ -110,7 +110,7 @@ function matchLegacyOpenApi(input: Record<string, unknown>) {
       if (operation.requestBody) {
         // The legacy OpenAPI surface never marked request bodies as required.
         // Keep that SDK surface stable while the HttpApi spec is tightened.
-        delete operation.requestBody.required
+        if (!isV2Api) delete operation.requestBody.required
         const body = operation.requestBody.content?.["application/json"]
         if (body?.schema) body.schema = stripOptionalNull(structuredClone(body.schema))
         if (path === "/experimental/workspace" && method === "post") {