@opencode-ai/protocol 0.0.0-next-14854 → 0.0.0-reserved.0

package/dist/groups/form.js

@@ -1,99 +0,0 @@
-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.FormInfo.fields.title,
-    metadata: Form.FormInfo.fields.metadata,
-    mode: Schema.Literals(["form", "url"]),
-    fields: Form.FormInfo.fields.fields.pipe(Schema.optional),
-    url: Form.UrlInfo.fields.url.pipe(Schema.optional),
-}).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: "forms", description: "Session form routes." }));

package/dist/groups/fs.d.ts

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

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

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

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

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

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

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

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

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

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

@@ -1,30 +0,0 @@
-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<"pending">;
-        }>, 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

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