@opencode-ai/protocol 0.0.0-next-14661

package/dist/groups/pty.d.ts

@@ -0,0 +1,145 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { ForbiddenError, PtyNotFoundError } from "../errors.js";
+export declare const PTY_CONNECT_TICKET_QUERY = "ticket";
+export declare const PTY_CONNECT_TOKEN_HEADER = "x-opencode-ticket";
+export declare const PTY_CONNECT_TOKEN_HEADER_VALUE = "1";
+export declare function hasPtyConnectTicketURL(url: URL): boolean;
+export declare const PtyGroup: HttpApiGroup.HttpApiGroup<"server.pty", HttpApiEndpoint.HttpApiEndpoint<"pty.list", "GET", "/api/pty", 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, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.create", "POST", "/api/pty", 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.Json<Schema.Struct<{
+    readonly command: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly args: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly env: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.get", "GET", "/api/pty/:ptyID", HttpApiEndpoint.StringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, 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.Struct<{
+        readonly id: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+}>>, HttpApiEndpoint.Json<typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.update", "PUT", "/api/pty/:ptyID", HttpApiEndpoint.StringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly size: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly rows: Schema.Int;
+        readonly cols: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly rows: Schema.Int;
+        readonly cols: Schema.Int;
+    }>>, never, never>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+}>>, HttpApiEndpoint.Json<typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.remove", "DELETE", "/api/pty/:ptyID", HttpApiEndpoint.StringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.connectToken", "POST", "/api/pty/:ptyID/connect-token", HttpApiEndpoint.StringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly ticket: Schema.String;
+        readonly expires_in: Schema.Int;
+    }>;
+}>>, HttpApiEndpoint.Json<typeof ForbiddenError | typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.connect", "GET", "/api/pty/:ptyID/connect", HttpApiEndpoint.StringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Boolean>, HttpApiEndpoint.Json<typeof ForbiddenError | typeof PtyNotFoundError>, never, never>, false>;

package/dist/groups/pty.js

@@ -0,0 +1,111 @@
+import { Pty } from "@opencode-ai/schema/pty";
+import { PtyTicket } from "@opencode-ai/schema/pty-ticket";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { ForbiddenError, PtyNotFoundError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const PTY_CONNECT_TICKET_QUERY = "ticket";
+export const PTY_CONNECT_TOKEN_HEADER = "x-opencode-ticket";
+export const PTY_CONNECT_TOKEN_HEADER_VALUE = "1";
+const PTY_CONNECT_PATH = /^\/api\/pty\/[^/]+\/connect$/;
+// Authorization middleware skips credential checks when this matches; the PTY connect handler
+// is then responsible for consuming and validating the ticket.
+export function hasPtyConnectTicketURL(url) {
+    return PTY_CONNECT_PATH.test(url.pathname) && !!url.searchParams.get(PTY_CONNECT_TICKET_QUERY);
+}
+export const PtyGroup = HttpApiGroup.make("server.pty")
+    .add(HttpApiEndpoint.get("pty.list", "/api/pty", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Pty.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.list",
+    summary: "List PTY sessions",
+    description: "List PTY sessions for a location, including exited sessions retained until removal.",
+})))
+    .add(HttpApiEndpoint.post("pty.create", "/api/pty", {
+    query: LocationQuery,
+    payload: Pty.CreateInput,
+    success: Location.response(Pty.Info),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.create",
+    summary: "Create PTY session",
+    description: "Create a pseudo-terminal session for a location.",
+})))
+    .add(HttpApiEndpoint.get("pty.get", "/api/pty/:ptyID", {
+    params: { ptyID: Pty.ID },
+    query: LocationQuery,
+    success: Location.response(Pty.Info),
+    error: PtyNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.get",
+    summary: "Get PTY session",
+    description: "Get one PTY session, including its exit code once exited.",
+})))
+    .add(HttpApiEndpoint.put("pty.update", "/api/pty/:ptyID", {
+    params: { ptyID: Pty.ID },
+    query: LocationQuery,
+    payload: Pty.UpdateInput,
+    success: Location.response(Pty.Info),
+    error: PtyNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.update",
+    summary: "Update PTY session",
+    description: "Update the title or viewport size of one PTY session.",
+})))
+    .add(HttpApiEndpoint.delete("pty.remove", "/api/pty/:ptyID", {
+    params: { ptyID: Pty.ID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: PtyNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.remove",
+    summary: "Remove PTY session",
+    description: "Terminate and remove one PTY session.",
+})))
+    .add(HttpApiEndpoint.post("pty.connectToken", "/api/pty/:ptyID/connect-token", {
+    params: { ptyID: Pty.ID },
+    query: LocationQuery,
+    success: Location.response(PtyTicket.ConnectToken),
+    error: [ForbiddenError, PtyNotFoundError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.connectToken",
+    summary: "Create PTY WebSocket token",
+    description: "Create a short-lived single-use ticket for opening a PTY WebSocket connection.",
+})))
+    .add(
+// Query fields are decoded in the raw handler after the existence check so a missing
+// session responds with an empty 404 before any upgrade work.
+HttpApiEndpoint.get("pty.connect", "/api/pty/:ptyID/connect", {
+    params: { ptyID: Pty.ID },
+    success: Schema.Boolean,
+    error: [ForbiddenError, PtyNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.connect",
+    summary: "Connect to PTY session",
+    description: "Establish a WebSocket connection streaming PTY output and accepting terminal input.",
+    transform: (operation) => ({
+        ...operation,
+        parameters: [
+            ...(operation.parameters ?? []),
+            ...["location[directory]", "location[workspace]", "cursor", PTY_CONNECT_TICKET_QUERY].map((name) => ({
+                in: "query",
+                name,
+                schema: { type: "string" },
+            })),
+        ],
+    }),
+})))
+    .annotateMerge(OpenApi.annotations({ title: "pty", description: "Experimental location-scoped PTY routes." }));

package/dist/groups/question.d.ts

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,56 @@
+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." }));

package/dist/groups/reference.d.ts

@@ -0,0 +1,13 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Reference } from "@opencode-ai/schema/reference";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const ReferenceGroup: HttpApiGroup.HttpApiGroup<"server.reference", HttpApiEndpoint.HttpApiEndpoint<"reference.list", "GET", "/api/reference", 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<typeof Reference.Info>;
+}>>, HttpApiEndpoint.Json<never>, never, never>, false>;

package/dist/groups/reference.js

@@ -0,0 +1,20 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Reference } from "@opencode-ai/schema/reference";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const ReferenceGroup = HttpApiGroup.make("server.reference")
+    .add(HttpApiEndpoint.get("reference.list", "/api/reference", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Reference.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.reference.list",
+    summary: "List references",
+    description: "List references available in the requested location.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "reference",
+    description: "Location-scoped project references.",
+}));