@opencode-ai/protocol 0.0.0-next-14661

package/dist/groups/event.js

@@ -0,0 +1,42 @@
+import { Event } from "@opencode-ai/schema/event";
+import { EventManifest } from "@opencode-ai/schema/event-manifest";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+const fields = {
+    id: Event.ID,
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    durable: Schema.optional(Schema.Struct({ aggregateID: Schema.String, seq: Schema.Int, version: Schema.Int })),
+    location: Schema.optional(Location.Ref),
+};
+const schema = (definitions) => Schema.Union([
+    ...definitions,
+    ...(definitions.some((definition) => definition.type === "server.connected")
+        ? []
+        : [
+            Schema.Struct({
+                ...fields,
+                type: Schema.Literal("server.connected"),
+                data: Schema.Struct({}),
+            }).annotate({ identifier: "V2Event.server.connected" }),
+        ]),
+]).annotate({ identifier: "V2Event" });
+const make = (definitions) => {
+    const EventSchema = schema(definitions);
+    return {
+        schema: EventSchema,
+        group: HttpApiGroup.make("server.event")
+            .add(HttpApiEndpoint.get("event.subscribe", "/api/event", {
+            success: HttpApiSchema.StreamSse({ data: EventSchema }),
+        }).annotateMerge(OpenApi.annotations({
+            identifier: "v2.event.subscribe",
+            summary: "Subscribe to events",
+            description: "Subscribe to native event payloads for the server.",
+        })))
+            .annotateMerge(OpenApi.annotations({ title: "events", description: "Experimental event stream route." })),
+    };
+};
+export const makeEventGroup = (definitions) => make(definitions).group;
+const event = make(EventManifest.ServerDefinitions);
+export const EventGroup = event.group;
+export const OpenCodeEvent = event.schema;

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/*", 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.Uint8Array>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.list", "GET", "/api/fs/list", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<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>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<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"]>;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.find", "GET", "/api/fs/find", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<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>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<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"]>;
+    }>>;
+}>>, HttpApiEndpoint.Json<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,32 @@
+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", 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 prompt: Schema.String;
+    readonly model: Schema.optional<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly text: Schema.String;
+    }>;
+}>>, HttpApiEndpoint.Json<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,5 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const HealthGroup: HttpApiGroup.HttpApiGroup<"server.health", HttpApiEndpoint.HttpApiEndpoint<"health.get", "GET", "/api/health", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly healthy: Schema.Literal<true>;
+}>>, HttpApiEndpoint.Json<never>, never, never>, false>;

package/dist/groups/health.js

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+export const HealthGroup = HttpApiGroup.make("server.health").add(HttpApiEndpoint.get("health.get", "/api/health", {
+    success: Schema.Struct({ healthy: Schema.Literal(true) }),
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.health.get",
+    summary: "Check server health",
+    description: "Check whether the API server is ready to accept requests.",
+})));

package/dist/groups/integration.d.ts

@@ -0,0 +1,105 @@
+import { Integration } from "@opencode-ai/schema/integration";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { InvalidRequestError } from "../errors.js";
+export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integration", HttpApiEndpoint.HttpApiEndpoint<"integration.list", "GET", "/api/integration", 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 Integration.Info>;
+}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.get", "GET", "/api/integration/:integrationID", HttpApiEndpoint.StringTree<Schema.Struct<{
+    integrationID: Schema.brand<Schema.String, "Integration.ID">;
+}>>, 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.UndefinedOr<typeof Integration.Info>;
+}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.connect.key", "POST", "/api/integration/:integrationID/connect/key", HttpApiEndpoint.StringTree<Schema.Struct<{
+    integrationID: Schema.brand<Schema.String, "Integration.ID">;
+}>>, 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 key: Schema.String;
+    readonly label: Schema.optional<Schema.String>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.connect.oauth", "POST", "/api/integration/:integrationID/connect/oauth", HttpApiEndpoint.StringTree<Schema.Struct<{
+    integrationID: Schema.brand<Schema.String, "Integration.ID">;
+}>>, 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 methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly inputs: Schema.$Record<Schema.String, Schema.String>;
+    readonly label: Schema.optional<Schema.String>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: typeof Integration.Attempt;
+}>>, HttpApiEndpoint.Json<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.attempt.status", "GET", "/api/integration/attempt/:attemptID", HttpApiEndpoint.StringTree<Schema.Struct<{
+    attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
+        create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
+    };
+}>>, 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.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"pending">;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.Number;
+            readonly expires: Schema.Number;
+        }>;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"complete">;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.Number;
+            readonly expires: Schema.Number;
+        }>;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"failed">;
+        readonly message: Schema.String;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.Number;
+            readonly expires: Schema.Number;
+        }>;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"expired">;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.Number;
+            readonly expires: Schema.Number;
+        }>;
+    }>]>;
+}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.attempt.complete", "POST", "/api/integration/attempt/:attemptID/complete", HttpApiEndpoint.StringTree<Schema.Struct<{
+    attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
+        create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
+    };
+}>>, 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 code: Schema.optional<Schema.String>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.attempt.cancel", "DELETE", "/api/integration/attempt/:attemptID", HttpApiEndpoint.StringTree<Schema.Struct<{
+    attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
+        create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
+    };
+}>>, 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<never>, never, never>, false>;

package/dist/groups/integration.js

@@ -0,0 +1,98 @@
+import { Integration } from "@opencode-ai/schema/integration";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { InvalidRequestError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+const Inputs = Schema.Record(Schema.String, Schema.String);
+export const IntegrationGroup = HttpApiGroup.make("server.integration")
+    .add(HttpApiEndpoint.get("integration.list", "/api/integration", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Integration.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.list",
+    summary: "List integrations",
+    description: "Retrieve available integrations and their authentication methods.",
+})))
+    .add(HttpApiEndpoint.get("integration.get", "/api/integration/:integrationID", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    success: Location.response(Schema.UndefinedOr(Integration.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.get",
+    summary: "Get integration",
+    description: "Retrieve one integration and its authentication methods.",
+})))
+    .add(HttpApiEndpoint.post("integration.connect.key", "/api/integration/:integrationID/connect/key", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    payload: Schema.Struct({
+        key: Schema.String,
+        label: Schema.optional(Schema.String),
+    }),
+    success: HttpApiSchema.NoContent,
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.connect.key",
+    summary: "Connect with key",
+    description: "Run a key authentication method and store the resulting credential.",
+})))
+    .add(HttpApiEndpoint.post("integration.connect.oauth", "/api/integration/:integrationID/connect/oauth", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    payload: Schema.Struct({
+        methodID: Integration.MethodID,
+        inputs: Inputs,
+        label: Schema.optional(Schema.String),
+    }),
+    success: Location.response(Integration.Attempt),
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.connect.oauth",
+    summary: "Begin OAuth connection",
+    description: "Start an OAuth attempt and return the authorization details.",
+})))
+    .add(HttpApiEndpoint.get("integration.attempt.status", "/api/integration/attempt/:attemptID", {
+    params: { attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: Location.response(Integration.AttemptStatus),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.attempt.status",
+    summary: "Get OAuth attempt status",
+    description: "Poll the current status of an OAuth attempt.",
+})))
+    .add(HttpApiEndpoint.post("integration.attempt.complete", "/api/integration/attempt/:attemptID/complete", {
+    params: { attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    payload: Schema.Struct({ code: Schema.optional(Schema.String) }),
+    success: HttpApiSchema.NoContent,
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.attempt.complete",
+    summary: "Complete OAuth connection",
+    description: "Complete a code-based OAuth attempt and store the resulting credential.",
+})))
+    .add(HttpApiEndpoint.delete("integration.attempt.cancel", "/api/integration/attempt/:attemptID", {
+    params: { attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.attempt.cancel",
+    summary: "Cancel OAuth connection",
+    description: "Cancel an OAuth attempt and release its resources.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "integrations", description: "Integration discovery and authentication routes." }));

package/dist/groups/location.d.ts

@@ -0,0 +1,16 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const LocationQuery: Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>;
+export declare const locationQueryOpenApi: import("effect/Context").Context<never>;
+export declare const LocationGroup: HttpApiGroup.HttpApiGroup<"server.location", HttpApiEndpoint.HttpApiEndpoint<"location.get", "GET", "/api/location", 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<typeof Location.Info>, HttpApiEndpoint.Json<never>, never, never>, false>;

package/dist/groups/location.js

@@ -0,0 +1,32 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+export const LocationQuery = Schema.Struct({
+    location: Schema.optional(Schema.Struct({
+        directory: Schema.optional(Schema.String),
+        workspace: Schema.optional(Schema.String),
+    })),
+}).annotate({ identifier: "LocationQuery" });
+export const locationQueryOpenApi = OpenApi.annotations({
+    transform: (operation) => {
+        const parameters = operation.parameters;
+        if (!Array.isArray(parameters))
+            return operation;
+        return {
+            ...operation,
+            parameters: parameters.map((parameter) => parameter?.name === "location" && parameter?.in === "query"
+                ? { ...parameter, style: "deepObject", explode: true }
+                : parameter),
+        };
+    },
+});
+export const LocationGroup = HttpApiGroup.make("server.location").add(HttpApiEndpoint.get("location.get", "/api/location", {
+    query: LocationQuery,
+    success: Location.Info,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.location.get",
+    summary: "Get location",
+    description: "Resolve the requested location or the server default location.",
+})));

package/dist/groups/mcp.d.ts

@@ -0,0 +1,30 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const McpGroup: HttpApiGroup.HttpApiGroup<"server.mcp", HttpApiEndpoint.HttpApiEndpoint<"mcp.list", "GET", "/api/mcp", 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 name: Schema.String;
+        readonly status: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
+            readonly status: Schema.Literal<"connected">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"disconnected">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"disabled">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"failed">;
+            readonly error: Schema.String;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"needs_auth">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"needs_client_registration">;
+            readonly error: Schema.String;
+        }>]>;
+        readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, never, never>, false>;

package/dist/groups/mcp.js

@@ -0,0 +1,17 @@
+import { Mcp } from "@opencode-ai/schema/mcp";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const McpGroup = HttpApiGroup.make("server.mcp")
+    .add(HttpApiEndpoint.get("mcp.list", "/api/mcp", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Mcp.Server)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.mcp.list",
+    summary: "List MCP servers",
+    description: "Retrieve configured MCP servers and their connection status.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "mcp", description: "MCP server status routes." }));