@opencode-ai/protocol 0.0.0-dev-17471

package/dist/groups/form.js

@@ -0,0 +1,97 @@
+import { Form } from "@opencode-ai/schema/form";
+import { Location } from "@opencode-ai/schema/location";
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { ConflictError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError, InvalidRequestError, SessionNotFoundError, } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+const CreatePayload = Schema.Struct({
+    id: Form.ID.pipe(Schema.optional),
+    title: Form.Info.fields.title,
+    metadata: Form.Info.fields.metadata,
+    fields: Form.Info.fields.fields,
+}).annotate({ identifier: "Form.CreatePayload" });
+// Form routes intentionally look session-scoped, but use a form-specific middleware instead of
+// SessionLocationMiddleware. The middleware treats real session IDs normally and has an
+// undocumented `global` sentinel branch for MCP elicitation forms that are still Location-scoped
+// but not session-owned. This is temporary and should disappear once elicitations are attributable.
+export const makeFormGroup = (locationMiddleware, formLocationMiddleware) => HttpApiGroup.make("server.form")
+    .add(HttpApiEndpoint.get("form.request.list", "/api/form/request", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Form.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.form.request.list",
+    summary: "List pending form requests",
+    description: "Retrieve pending forms for a location.",
+})))
+    .middleware(locationMiddleware)
+    .add(HttpApiEndpoint.get("session.form.list", "/api/session/:sessionID/form", {
+    params: { sessionID: Schema.String },
+    success: Schema.Struct({ data: Schema.Array(Form.Info) }),
+    error: SessionNotFoundError,
+})
+    .middleware(formLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.form.list",
+    summary: "List session forms",
+    description: "Retrieve pending forms for a session.",
+})))
+    .add(HttpApiEndpoint.post("session.form.create", "/api/session/:sessionID/form", {
+    params: { sessionID: Schema.String },
+    payload: CreatePayload,
+    success: Schema.Struct({ data: Form.Info }),
+    error: [SessionNotFoundError, ConflictError, InvalidRequestError],
+})
+    .middleware(formLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.form.create",
+    summary: "Create session form",
+    description: "Create a form for a session.",
+})))
+    .add(HttpApiEndpoint.get("session.form.get", "/api/session/:sessionID/form/:formID", {
+    params: { sessionID: Schema.String, formID: Form.ID },
+    success: Schema.Struct({ data: Form.Info }),
+    error: [SessionNotFoundError, FormNotFoundError],
+})
+    .middleware(formLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.form.get",
+    summary: "Get session form",
+    description: "Retrieve a form for a session.",
+})))
+    .add(HttpApiEndpoint.get("session.form.state", "/api/session/:sessionID/form/:formID/state", {
+    params: { sessionID: Schema.String, formID: Form.ID },
+    success: Schema.Struct({ data: Form.State }),
+    error: [SessionNotFoundError, FormNotFoundError],
+})
+    .middleware(formLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.form.state",
+    summary: "Get form state",
+    description: "Retrieve the current state for a form.",
+})))
+    .add(HttpApiEndpoint.post("session.form.reply", "/api/session/:sessionID/form/:formID/reply", {
+    params: { sessionID: Schema.String, formID: Form.ID },
+    payload: Form.Reply,
+    success: HttpApiSchema.NoContent,
+    error: [SessionNotFoundError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError],
+})
+    .middleware(formLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.form.reply",
+    summary: "Reply to form",
+    description: "Submit an answer to a pending form.",
+})))
+    .add(HttpApiEndpoint.post("session.form.cancel", "/api/session/:sessionID/form/:formID/cancel", {
+    params: { sessionID: Schema.String, formID: Form.ID },
+    success: HttpApiSchema.NoContent,
+    error: [SessionNotFoundError, FormAlreadySettledError, FormNotFoundError],
+})
+    .middleware(formLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.form.cancel",
+    summary: "Cancel form",
+    description: "Cancel a pending form.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "form", description: "Session form routes." }));

package/dist/groups/fs.d.ts

@@ -0,0 +1,35 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const FileSystemGroup: HttpApiGroup.HttpApiGroup<"server.fs", HttpApiEndpoint.HttpApiEndpoint<"fs.read", "GET", "/api/fs/read/*", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Uint8Array>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.list", "GET", "/api/fs/list", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly path: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.brand<Schema.String, "RelativePath">;
+        readonly type: Schema.Literals<readonly ["file", "directory"]>;
+    }>>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.find", "GET", "/api/fs/find", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly query: Schema.String;
+    readonly type: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["file", "directory"]>>>, Schema.optionalKey<Schema.Literals<readonly ["file", "directory"]>>, never, never>;
+    readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.brand<Schema.String, "RelativePath">;
+        readonly type: Schema.Literals<readonly ["file", "directory"]>;
+    }>>;
+}>>, never, never, never>, false>;

package/dist/groups/fs.js

@@ -0,0 +1,51 @@
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+import { Location } from "@opencode-ai/schema/location";
+import { PositiveInt, RelativePath } from "@opencode-ai/schema/schema";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+const ListQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    path: RelativePath.pipe(Schema.optional),
+});
+const FindQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    query: FileSystem.FindInput.fields.query,
+    type: FileSystem.FindInput.fields.type,
+    limit: Schema.NumberFromString.pipe(Schema.decodeTo(PositiveInt), Schema.optional),
+});
+export const FileSystemGroup = HttpApiGroup.make("server.fs")
+    .add(HttpApiEndpoint.get("fs.read", "/api/fs/read/*", {
+    query: LocationQuery,
+    success: Schema.Uint8Array.pipe(HttpApiSchema.asUint8Array()),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.fs.read",
+    summary: "Read file",
+    description: "Serve one file relative to the requested location.",
+})))
+    .add(HttpApiEndpoint.get("fs.list", "/api/fs/list", {
+    query: ListQuery,
+    success: Location.response(Schema.Array(FileSystem.Entry)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.fs.list",
+    summary: "List directory",
+    description: "List direct children of one directory relative to the requested location.",
+})))
+    .add(HttpApiEndpoint.get("fs.find", "/api/fs/find", {
+    query: FindQuery,
+    success: Location.response(Schema.Array(FileSystem.Entry)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.fs.find",
+    summary: "Find files",
+    description: "Find recursively ranked filesystem entries relative to the requested location.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "filesystem",
+    description: "Experimental location-scoped filesystem routes.",
+}));

package/dist/groups/generate.d.ts

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+export declare const GenerateGroup: HttpApiGroup.HttpApiGroup<"server.generate", HttpApiEndpoint.HttpApiEndpoint<"generate.text", "POST", "/api/generate", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly prompt: Schema.String;
+    readonly model: Schema.optional<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Model.ID">;
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+    }> & {
+        parse: (input: string) => {
+            readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+            readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+        };
+    }>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly text: Schema.String;
+    }>;
+}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/generate.js

@@ -0,0 +1,27 @@
+import { Model } from "@opencode-ai/schema/model";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const GenerateGroup = HttpApiGroup.make("server.generate")
+    .add(HttpApiEndpoint.post("generate.text", "/api/generate", {
+    query: LocationQuery,
+    payload: Schema.Struct({
+        prompt: Schema.String,
+        model: Model.Ref.pipe(Schema.optional),
+    }),
+    success: Schema.Struct({
+        data: Schema.Struct({ text: Schema.String }),
+    }).annotate({ identifier: "GenerateTextResponse" }),
+    error: [InvalidRequestError, ServiceUnavailableError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.generate.text",
+    summary: "Generate text",
+    description: "Run one stateless model generation at the requested location and return the assistant text. Uses the location's default model when none is specified.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "generate",
+    description: "Experimental one-shot generation routes.",
+}));

package/dist/groups/health.d.ts

@@ -0,0 +1,27 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare namespace ServiceStatus {
+    const Health: Schema.Struct<{
+        readonly healthy: Schema.Literal<true>;
+        readonly version: Schema.String;
+        readonly pid: Schema.Int;
+    }>;
+    type Health = typeof Health.Type;
+    const StopRequest: Schema.Struct<{
+        readonly instanceID: Schema.String;
+    }>;
+    type StopRequest = typeof StopRequest.Type;
+    const StopResponse: Schema.Struct<{
+        readonly accepted: Schema.Boolean;
+    }>;
+    type StopResponse = typeof StopResponse.Type;
+}
+export declare const HealthGroup: HttpApiGroup.HttpApiGroup<"server.health", HttpApiEndpoint.HttpApiEndpoint<"health.get", "GET", "/api/health", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly healthy: Schema.Literal<true>;
+    readonly version: Schema.String;
+    readonly pid: Schema.Int;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"health.stop", "POST", "/api/service/stop", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly instanceID: Schema.String;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly accepted: Schema.Boolean;
+}>>, never, never, never>, false>;

package/dist/groups/health.js

@@ -0,0 +1,34 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+export var ServiceStatus;
+(function (ServiceStatus) {
+    ServiceStatus.Health = Schema.Struct({
+        healthy: Schema.Literal(true),
+        version: Schema.String,
+        // 0 means the runtime has no OS process identity (e.g. workerd).
+        pid: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    }).annotate({ identifier: "ServiceHealth" });
+    ServiceStatus.StopRequest = Schema.Struct({
+        instanceID: Schema.String,
+    }).annotate({ identifier: "ServiceStopRequest" });
+    ServiceStatus.StopResponse = Schema.Struct({
+        accepted: Schema.Boolean,
+    }).annotate({ identifier: "ServiceStopResponse" });
+})(ServiceStatus || (ServiceStatus = {}));
+export const HealthGroup = HttpApiGroup.make("server.health")
+    .add(HttpApiEndpoint.get("health.get", "/api/health", {
+    success: ServiceStatus.Health,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.health.get",
+    summary: "Check server health",
+    description: "Report the owning server process and its application status.",
+})))
+    .add(HttpApiEndpoint.post("health.stop", "/api/service/stop", {
+    payload: ServiceStatus.StopRequest,
+    success: ServiceStatus.StopResponse,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.health.stop",
+    summary: "Stop the managed server",
+    description: "Request graceful shutdown of one exact managed server instance.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "health" }));