@opencode/protocol 2.0.3 → 2.0.5

package/dist/groups/form.js

@@ -1,95 +1,18 @@
 import { Form } from "@opencode/schema/form";
 import { Location } from "@opencode/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 { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
 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", {
+export const makeFormGroup = (locationMiddleware) => HttpApiGroup.make("server.form")
+    .add(HttpApiEndpoint.get("form.list", "/api/form", {
     query: LocationQuery,
     success: Location.response(Schema.Array(Form.Info)),
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.form.request.list",
-    summary: "List pending form requests",
+    identifier: "form.list",
+    summary: "List pending forms",
     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,
-}).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." }));
+    .annotateMerge(OpenApi.annotations({ title: "form", description: "Location form routes." }));

package/dist/groups/fs.d.ts

@@ -1,20 +1,19 @@
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 import { FileNotFoundError } from "../errors.js";
 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>, Schema.toCodecJson<typeof FileNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.list", "GET", "/api/fs/list", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly path: Schema.optional<Schema.String>;
     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 location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly path: Schema.brand<Schema.String, "RelativePath">;
         readonly type: Schema.Literals<readonly ["file", "directory"]>;
@@ -25,10 +24,11 @@ export declare const FileSystemGroup: HttpApiGroup.HttpApiGroup<"server.fs", Htt
     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 location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly path: Schema.brand<Schema.String, "RelativePath">;
         readonly type: Schema.Literals<readonly ["file", "directory"]>;

package/dist/groups/fs.js

@@ -25,7 +25,7 @@ export const FileSystemGroup = HttpApiGroup.make("server.fs")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.fs.read",
+    identifier: "fs.read",
     summary: "Read file",
     description: "Serve one file relative to the requested location.",
 })))
@@ -35,7 +35,7 @@ export const FileSystemGroup = HttpApiGroup.make("server.fs")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.fs.list",
+    identifier: "fs.list",
     summary: "List directory",
     description: "List direct children using an absolute path or a path relative to the requested location, including parents and siblings outside its directory. Entry paths remain relative to the requested location; listing does not switch locations.",
 })))
@@ -45,7 +45,7 @@ export const FileSystemGroup = HttpApiGroup.make("server.fs")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.fs.find",
+    identifier: "fs.find",
     summary: "Find files",
     description: "Find recursively ranked filesystem entries relative to the requested location.",
 })))

package/dist/groups/generate.d.ts

@@ -1,7 +1,7 @@
 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, never, Schema.toCodecJson<Schema.Struct<{
+export declare const GenerateGroup: HttpApiGroup.HttpApiGroup<"server.generate", HttpApiEndpoint.HttpApiEndpoint<"generate.text", "POST", "/api/experimental/generate", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly prompt: Schema.String;
     readonly model: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Model.ID">;

package/dist/groups/generate.js

@@ -3,7 +3,7 @@ import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
 import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export const GenerateGroup = HttpApiGroup.make("server.generate")
-    .add(HttpApiEndpoint.post("generate.text", "/api/generate", {
+    .add(HttpApiEndpoint.post("generate.text", "/api/experimental/generate", {
     payload: Schema.Struct({
         prompt: Schema.String,
         model: Model.Ref.pipe(Schema.optional),
@@ -13,7 +13,7 @@ export const GenerateGroup = HttpApiGroup.make("server.generate")
     }).annotate({ identifier: "GenerateTextResponse" }),
     error: [InvalidRequestError, ServiceUnavailableError],
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.generate.text",
+    identifier: "experimental.generate.text",
     summary: "Generate text",
     description: "Run one stateless model generation using the server's base configuration and return the assistant text. Uses the base configuration's default model when none is specified.",
 })))

package/dist/groups/integration.d.ts

@@ -1,15 +1,15 @@
 import { Integration } from "@opencode/schema/integration";
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
-import { InvalidRequestError } from "../errors.js";
+import { IntegrationAttemptNotFoundError, IntegrationMethodNotFoundError, IntegrationNotFoundError, InvalidRequestError } from "../errors.js";
 export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integration", HttpApiEndpoint.HttpApiEndpoint<"integration.list", "GET", "/api/integration", 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.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Integration.ID">;
         readonly name: Schema.String;
@@ -500,11 +500,12 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
 }>>, 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.Struct<{
-    readonly location: typeof Location.Info;
-    readonly data: Schema.UndefinedOr<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Integration.ID">;
         readonly name: Schema.String;
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
@@ -988,11 +989,10 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
             readonly type: Schema.Literal<"env">;
             readonly name: Schema.String;
         }>]>>;
-    }>>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.wellknown.add", "POST", "/api/experimental/integration/wellknown", never, Schema.toCodecStringTree<Schema.Struct<{
+    }>;
+}>>, Schema.toCodecJson<typeof IntegrationNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.wellknown.add", "POST", "/api/experimental/integration/wellknown", 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 url: Schema.String;
@@ -1001,25 +1001,25 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
 }>>, 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 key: Schema.String;
     readonly answer: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>;
     readonly label: Schema.optional<Schema.String>;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.connect", "POST", "/api/integration/:integrationID/connect/oauth", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError | typeof IntegrationNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.connect", "POST", "/api/integration/:integrationID/connect/oauth", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
 }>>, 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 methodID: Schema.brand<Schema.String, "Integration.MethodID">;
     readonly answer: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>;
     readonly label: Schema.optional<Schema.String>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: typeof Integration.Attempt;
 }>>, Schema.toCodecJson<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.status", "GET", "/api/integration/:integrationID/connect/oauth/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
@@ -1029,10 +1029,11 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
 }>>, 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.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.Union<readonly [Schema.Struct<{
         readonly status: Schema.Literal<"pending">;
         readonly time: Schema.Struct<{
@@ -1059,7 +1060,7 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
             readonly expires: Schema.Number;
         }>;
     }>]>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.complete", "POST", "/api/integration/:integrationID/connect/oauth/:attemptID/complete", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof IntegrationNotFoundError | typeof IntegrationAttemptNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.complete", "POST", "/api/integration/:integrationID/connect/oauth/:attemptID/complete", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
     attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
         create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
@@ -1067,11 +1068,10 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
 }>>, 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 code: Schema.optional<Schema.String>;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.cancel", "DELETE", "/api/integration/:integrationID/connect/oauth/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError | typeof IntegrationNotFoundError | typeof IntegrationAttemptNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.cancel", "DELETE", "/api/integration/:integrationID/connect/oauth/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
     attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
         create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
@@ -1079,20 +1079,20 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
 }>>, 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<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.command.connect", "POST", "/api/integration/:integrationID/connect/command", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
 }>>, 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 methodID: Schema.brand<Schema.String, "Integration.MethodID">;
     readonly label: Schema.optional<Schema.String>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.Struct<{
         readonly attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
             create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
@@ -1102,7 +1102,7 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
             readonly expires: Schema.Number;
         }>;
     }>;
-}>>, Schema.toCodecJson<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.command.status", "GET", "/api/integration/:integrationID/connect/command/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof IntegrationNotFoundError | typeof IntegrationMethodNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.command.status", "GET", "/api/integration/:integrationID/connect/command/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
     attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
         create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
@@ -1110,10 +1110,11 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
 }>>, 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.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.Union<readonly [Schema.Struct<{
         readonly status: Schema.Literal<"pending">;
         readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -1141,7 +1142,7 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
             readonly expires: Schema.Number;
         }>;
     }>]>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.command.cancel", "DELETE", "/api/integration/:integrationID/connect/command/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof IntegrationNotFoundError | typeof IntegrationAttemptNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.command.cancel", "DELETE", "/api/integration/:integrationID/connect/command/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
     attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
         create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
@@ -1149,6 +1150,5 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
 }>>, 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<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/integration.js

@@ -3,7 +3,7 @@ import { Location } from "@opencode/schema/location";
 import { Form } from "@opencode/schema/form";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { InvalidRequestError } from "../errors.js";
+import { IntegrationAttemptNotFoundError, IntegrationMethodNotFoundError, IntegrationNotFoundError, InvalidRequestError, } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const IntegrationGroup = HttpApiGroup.make("server.integration")
     .add(HttpApiEndpoint.get("integration.list", "/api/integration", {
@@ -12,18 +12,19 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.list",
+    identifier: "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)),
+    success: Location.response(Integration.Info),
+    error: IntegrationNotFoundError,
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.get",
+    identifier: "integration.get",
     summary: "Get integration",
     description: "Retrieve one integration and its authentication methods.",
 })))
@@ -35,7 +36,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.experimental.integration.wellknown.add",
+    identifier: "experimental.integration.wellknown.add",
     summary: "Add wellknown integration",
     description: "Discover and persist an experimental wellknown integration source.",
 })))
@@ -48,11 +49,11 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
         label: Schema.optional(Schema.String),
     }),
     success: HttpApiSchema.NoContent,
-    error: InvalidRequestError,
+    error: [IntegrationNotFoundError, InvalidRequestError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.connect.key",
+    identifier: "integration.connect.key",
     summary: "Connect with key",
     description: "Run a key authentication method and store the resulting credential.",
 })))
@@ -69,7 +70,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.oauth.connect",
+    identifier: "integration.oauth.connect",
     summary: "Begin OAuth connection",
     description: "Start an OAuth attempt and return the authorization details.",
 })))
@@ -77,10 +78,11 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
     params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
     query: LocationQuery,
     success: Location.response(Integration.AttemptStatus),
+    error: [IntegrationNotFoundError, IntegrationAttemptNotFoundError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.oauth.status",
+    identifier: "integration.oauth.status",
     summary: "Get OAuth attempt status",
     description: "Poll the current status of an OAuth attempt.",
 })))
@@ -89,11 +91,11 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
     query: LocationQuery,
     payload: Schema.Struct({ code: Schema.optional(Schema.String) }),
     success: HttpApiSchema.NoContent,
-    error: InvalidRequestError,
+    error: [IntegrationNotFoundError, IntegrationAttemptNotFoundError, InvalidRequestError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.oauth.complete",
+    identifier: "integration.oauth.complete",
     summary: "Complete OAuth connection",
     description: "Complete a code-based OAuth attempt and store the resulting credential.",
 })))
@@ -104,7 +106,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.oauth.cancel",
+    identifier: "integration.oauth.cancel",
     summary: "Cancel OAuth connection",
     description: "Cancel an OAuth attempt and release its resources.",
 })))
@@ -116,11 +118,11 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
         label: Schema.optional(Schema.String),
     }),
     success: Location.response(Integration.CommandAttempt),
-    error: InvalidRequestError,
+    error: [IntegrationNotFoundError, IntegrationMethodNotFoundError, InvalidRequestError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.command.connect",
+    identifier: "integration.command.connect",
     summary: "Begin command connection",
     description: "Start a command authentication attempt.",
 })))
@@ -128,10 +130,11 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
     params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
     query: LocationQuery,
     success: Location.response(Integration.CommandAttemptStatus),
+    error: [IntegrationNotFoundError, IntegrationAttemptNotFoundError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.command.status",
+    identifier: "integration.command.status",
     summary: "Get command attempt status",
     description: "Poll the current status and output of a command authentication attempt.",
 })))
@@ -142,7 +145,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.integration.command.cancel",
+    identifier: "integration.command.cancel",
     summary: "Cancel command connection",
     description: "Cancel a command authentication attempt and terminate its process.",
 })))

package/dist/groups/location.d.ts

@@ -1,16 +1,22 @@
-import { Location } from "@opencode/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", 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<typeof Location.Info>, never, never, never>, false>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly project: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+            global: string & import("effect/Brand").Brand<"Project.ID">;
+        };
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+}>>, never, never, never>, false>;

package/dist/groups/location.js

@@ -4,7 +4,6 @@ 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({
@@ -23,11 +22,11 @@ export const locationQueryOpenApi = OpenApi.annotations({
 export const LocationGroup = HttpApiGroup.make("server.location")
     .add(HttpApiEndpoint.get("location.get", "/api/location", {
     query: LocationQuery,
-    success: Location.Info,
+    success: Location.PublicInfo,
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.location.get",
+    identifier: "location.get",
     summary: "Get location",
     description: "Resolve the requested location or the server default location.",
 })))

package/dist/groups/mcp.d.ts

@@ -1,15 +1,15 @@
 import { Mcp } from "@opencode/schema/mcp";
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
 import { McpServerNotFoundError } from "../errors.js";
 export declare const McpGroup: HttpApiGroup.HttpApiGroup<"server.mcp", HttpApiEndpoint.HttpApiEndpoint<"mcp.list", "GET", "/api/mcp", 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.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly name: Schema.String;
         readonly status: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
@@ -23,46 +23,44 @@ export declare const McpGroup: HttpApiGroup.HttpApiGroup<"server.mcp", HttpApiEn
             readonly error: Schema.String;
         }>, Schema.Struct<{
             readonly status: Schema.Literal<"needs_auth">;
+            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>;
     }>>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.add", "PUT", "/api/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.add", "PUT", "/api/experimental/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
     server: Schema.String;
 }>>, 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 config: Schema.toTaggedUnion<"type", readonly [typeof Mcp.LocalConfig, typeof Mcp.RemoteConfig]>;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.remove", "DELETE", "/api/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.remove", "DELETE", "/api/experimental/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
     server: Schema.String;
 }>>, 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<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.connect", "POST", "/api/mcp/:server/connect", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.connect", "POST", "/api/experimental/mcp/:server/connect", Schema.toCodecStringTree<Schema.Struct<{
     server: Schema.String;
 }>>, 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<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.disconnect", "POST", "/api/mcp/:server/disconnect", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.disconnect", "POST", "/api/experimental/mcp/:server/disconnect", Schema.toCodecStringTree<Schema.Struct<{
     server: Schema.String;
 }>>, 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<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.resource.catalog", "GET", "/api/mcp/resource", 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.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.Struct<{
         readonly resources: Schema.$Array<Schema.Struct<{
             readonly server: Schema.String;