@opencode/protocol 2.0.2 → 2.0.4

package/dist/api.d.ts

@@ -16,7 +16,6 @@ import { EventGroup, makeEventGroup } from "./groups/event.js";
 import type { Definition } from "@opencode/schema/event";
 import { AgentGroup } from "./groups/agent.js";
 import { PluginGroup } from "./groups/plugin.js";
-import { HealthGroup } from "./groups/health.js";
 import { ServerGroup } from "./groups/server.js";
 import { DebugGroup } from "./groups/debug.js";
 import { PtyGroup } from "./groups/pty.js";
@@ -34,12 +33,11 @@ import { WorktreeGroup } from "./groups/worktree.js";
 import { VcsGroup } from "./groups/vcs.js";
 import { MigrationGroup } from "./groups/migration.js";
 import { ConfigGroup } from "./groups/config.js";
-import { WorkspaceGroup } from "./groups/workspace.js";
-type LocationGroups<LocationId extends HttpApiMiddleware.AnyId> = HttpApiGroup.AddMiddleware<typeof LocationGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof AgentGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof PluginGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ModelGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ProviderGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof IntegrationGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof WebSearchGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof McpGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof CredentialGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ProjectGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof FileSystemGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof CommandGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof SkillGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof RpcGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof PtyGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ShellGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ReferenceGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof WorktreeGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof VcsGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ConfigGroup, LocationId>;
-type SessionGroups<SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService> = ReturnType<typeof makeSessionGroup<SessionLocationId, SessionLocationService>> | typeof MessageGroup;
-type FormGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService> = ReturnType<typeof makeFormGroup<LocationId, LocationService, FormLocationId, FormLocationService>>;
+type LocationGroups<LocationId extends HttpApiMiddleware.AnyId> = HttpApiGroup.AddMiddleware<typeof LocationGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof AgentGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof PluginGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ModelGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ProviderGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof IntegrationGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof WebSearchGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof McpGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ProjectGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof FileSystemGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof CommandGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof SkillGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof RpcGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof PtyGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ShellGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ReferenceGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof VcsGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ConfigGroup, LocationId>;
+type SessionGroups<SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService> = ReturnType<typeof makeSessionGroup<SessionLocationId, SessionLocationService, FormLocationId, FormLocationService>> | typeof MessageGroup;
+type FormGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService> = ReturnType<typeof makeFormGroup<LocationId, LocationService>>;
 type MixedMiddlewareGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService> = ReturnType<typeof makePermissionGroup<LocationId, LocationService, SessionLocationId, SessionLocationService>>;
-type ApiGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Constraint> = typeof HealthGroup | typeof ServerGroup | typeof DebugGroup | typeof MigrationGroup | typeof WorkspaceGroup | typeof GenerateGroup | typeof PersistentPtyGroup | LocationGroups<LocationId> | FormGroups<LocationId, LocationService, FormLocationId, FormLocationService> | SessionGroups<SessionLocationId, SessionLocationService> | MixedMiddlewareGroups<LocationId, LocationService, SessionLocationId, SessionLocationService> | Event;
+type ApiGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Constraint> = typeof ServerGroup | typeof DebugGroup | typeof MigrationGroup | typeof WorktreeGroup | typeof GenerateGroup | typeof PersistentPtyGroup | typeof CredentialGroup | LocationGroups<LocationId> | FormGroups<LocationId, LocationService> | SessionGroups<SessionLocationId, SessionLocationService, FormLocationId, FormLocationService> | MixedMiddlewareGroups<LocationId, LocationService, SessionLocationId, SessionLocationService> | Event;
 type EventGroupFor<Definitions extends ReadonlyArray<Definition>> = ReturnType<typeof makeEventGroup<Definitions>>;
 export type Api<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Constraint> = HttpApi.HttpApi<"server", HttpApiGroup.AddMiddleware<HttpApiGroup.AddMiddleware<ApiGroups<LocationId, LocationService, FormLocationId, FormLocationService, SessionLocationId, SessionLocationService, Event>, Authorization>, SchemaErrorMiddleware>>;
 export declare const makeApi: <const Definitions extends ReadonlyArray<Definition>, LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(options: {

package/dist/api.js

@@ -15,7 +15,6 @@ import { RpcGroup } from "./groups/rpc.js";
 import { EventGroup, makeEventGroup } from "./groups/event.js";
 import { AgentGroup } from "./groups/agent.js";
 import { PluginGroup } from "./groups/plugin.js";
-import { HealthGroup } from "./groups/health.js";
 import { ServerGroup } from "./groups/server.js";
 import { DebugGroup } from "./groups/debug.js";
 import { PtyGroup } from "./groups/pty.js";
@@ -33,24 +32,22 @@ import { WorktreeGroup } from "./groups/worktree.js";
 import { VcsGroup } from "./groups/vcs.js";
 import { MigrationGroup } from "./groups/migration.js";
 import { ConfigGroup } from "./groups/config.js";
-import { WorkspaceGroup } from "./groups/workspace.js";
 // Protocol owns middleware placement, while Server injects concrete keys so Core service identities stay downstream.
 const makeApiFromGroup = (eventGroup, locationMiddleware, formLocationMiddleware, sessionLocationMiddleware) => HttpApi.make("server")
-    .add(HealthGroup)
     .add(ServerGroup)
     .add(LocationGroup.middleware(locationMiddleware))
     .add(AgentGroup.middleware(locationMiddleware))
     .add(PluginGroup.middleware(locationMiddleware))
-    .add(makeSessionGroup(sessionLocationMiddleware))
+    .add(makeSessionGroup(sessionLocationMiddleware, formLocationMiddleware))
     .add(MessageGroup)
     .add(ModelGroup.middleware(locationMiddleware))
     .add(GenerateGroup)
     .add(ProviderGroup.middleware(locationMiddleware))
     .add(IntegrationGroup.middleware(locationMiddleware))
     .add(McpGroup.middleware(locationMiddleware))
-    .add(CredentialGroup.middleware(locationMiddleware))
+    .add(CredentialGroup)
     .add(ProjectGroup.middleware(locationMiddleware))
-    .add(makeFormGroup(locationMiddleware, formLocationMiddleware))
+    .add(makeFormGroup(locationMiddleware))
     .add(makePermissionGroup(locationMiddleware, sessionLocationMiddleware))
     .add(FileSystemGroup.middleware(locationMiddleware))
     .add(CommandGroup.middleware(locationMiddleware))
@@ -61,8 +58,7 @@ const makeApiFromGroup = (eventGroup, locationMiddleware, formLocationMiddleware
     .add(PersistentPtyGroup)
     .add(ShellGroup.middleware(locationMiddleware))
     .add(ReferenceGroup.middleware(locationMiddleware))
-    .add(WorktreeGroup.middleware(locationMiddleware))
-    .add(WorkspaceGroup)
+    .add(WorktreeGroup)
     .add(VcsGroup.middleware(locationMiddleware))
     .add(DebugGroup)
     .add(MigrationGroup)

package/dist/client.d.ts

@@ -26,7 +26,6 @@ declare class SessionLocationMiddleware extends SessionLocationMiddleware_base {
 type ClientApiShape = Api<Context.Service.Identifier<typeof LocationMiddleware>, Context.Service.Shape<typeof LocationMiddleware>, Context.Service.Identifier<typeof SessionLocationMiddleware>, Context.Service.Shape<typeof SessionLocationMiddleware>, Context.Service.Identifier<typeof SessionLocationMiddleware>, Context.Service.Shape<typeof SessionLocationMiddleware>, typeof EventGroup>;
 export declare const ClientApi: ClientApiShape;
 export declare const groupNames: {
-    readonly "server.health": "health";
     readonly "server.server": "server";
     readonly "server.debug": "debug";
     readonly "server.migration": "migration";
@@ -55,7 +54,6 @@ export declare const groupNames: {
     readonly "server.reference": "reference";
     readonly "server.project": "project";
     readonly "server.worktree": "worktree";
-    readonly "server.workspace": "workspace";
     readonly "server.vcs": "vcs";
     readonly "server.config": "config";
 };

package/dist/client.js

@@ -13,7 +13,6 @@ export const ClientApi = makeDefaultApi({
     sessionLocationMiddleware: SessionLocationMiddleware,
 });
 export const groupNames = {
-    "server.health": "health",
     "server.server": "server",
     "server.debug": "debug",
     "server.migration": "migration",
@@ -42,7 +41,6 @@ export const groupNames = {
     "server.reference": "reference",
     "server.project": "project",
     "server.worktree": "worktree",
-    "server.workspace": "workspace",
     "server.vcs": "vcs",
     "server.config": "config",
 };

package/dist/errors.d.ts

@@ -55,6 +55,26 @@ declare const ProviderNotFoundError_base: Schema.Class<ProviderNotFoundError, Sc
 }>, import("effect/Cause").YieldableError>;
 export declare class ProviderNotFoundError extends ProviderNotFoundError_base {
 }
+declare const IntegrationNotFoundError_base: Schema.Class<IntegrationNotFoundError, Schema.TaggedStruct<"IntegrationNotFoundError", {
+    readonly integrationID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class IntegrationNotFoundError extends IntegrationNotFoundError_base {
+}
+declare const IntegrationAttemptNotFoundError_base: Schema.Class<IntegrationAttemptNotFoundError, Schema.TaggedStruct<"IntegrationAttemptNotFoundError", {
+    readonly integrationID: Schema.String;
+    readonly attemptID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class IntegrationAttemptNotFoundError extends IntegrationAttemptNotFoundError_base {
+}
+declare const IntegrationMethodNotFoundError_base: Schema.Class<IntegrationMethodNotFoundError, Schema.TaggedStruct<"IntegrationMethodNotFoundError", {
+    readonly integrationID: Schema.String;
+    readonly methodID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class IntegrationMethodNotFoundError extends IntegrationMethodNotFoundError_base {
+}
 declare const ProjectNotFoundError_base: Schema.Class<ProjectNotFoundError, Schema.TaggedStruct<"ProjectNotFoundError", {
     readonly projectID: Schema.String;
     readonly message: Schema.String;

package/dist/errors.js

@@ -45,6 +45,23 @@ export class ProviderNotFoundError extends Schema.TaggedError()("ProviderNotFoun
     message: Schema.String,
 }, { httpApiStatus: 404 }) {
 }
+export class IntegrationNotFoundError extends Schema.TaggedError()("IntegrationNotFoundError", {
+    integrationID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class IntegrationAttemptNotFoundError extends Schema.TaggedError()("IntegrationAttemptNotFoundError", {
+    integrationID: Schema.String,
+    attemptID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class IntegrationMethodNotFoundError extends Schema.TaggedError()("IntegrationMethodNotFoundError", {
+    integrationID: Schema.String,
+    methodID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
 export class ProjectNotFoundError extends Schema.TaggedError()("ProjectNotFoundError", {
     projectID: Schema.String,
     message: Schema.String,

package/dist/groups/agent.d.ts

@@ -1,15 +1,15 @@
 import { Agent } from "@opencode/schema/agent";
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 import { AgentNotFoundError } from "../errors.js";
 export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", HttpApiEndpoint.HttpApiEndpoint<"agent.list", "GET", "/api/agent", 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, "Agent.ID">;
         readonly name: Schema.brand<Schema.String, "Agent.Name">;
@@ -101,10 +101,11 @@ export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", HttpA
 }>>, 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 id: Schema.brand<Schema.String, "Agent.ID">;
         readonly name: Schema.brand<Schema.String, "Agent.Name">;

package/dist/groups/agent.js

@@ -11,7 +11,7 @@ export const AgentGroup = HttpApiGroup.make("server.agent")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.agent.list",
+    identifier: "agent.list",
     summary: "List agents",
     description: "Retrieve currently registered agents.",
 })))
@@ -23,7 +23,7 @@ export const AgentGroup = HttpApiGroup.make("server.agent")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.agent.get",
+    identifier: "agent.get",
     summary: "Get agent",
     description: "Retrieve a single currently registered agent.",
 })))

package/dist/groups/command.d.ts

@@ -1,13 +1,13 @@
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 export declare const CommandGroup: HttpApiGroup.HttpApiGroup<"server.command", HttpApiEndpoint.HttpApiEndpoint<"command.list", "GET", "/api/command", 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 description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;

package/dist/groups/command.js

@@ -10,7 +10,7 @@ export const CommandGroup = HttpApiGroup.make("server.command")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.command.list",
+    identifier: "command.list",
     summary: "List commands",
     description: "Retrieve currently registered commands.",
 })))

package/dist/groups/config.d.ts

@@ -1,22 +1,14 @@
 import { Config } from "@opencode/schema/config";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
 export declare const ConfigGroup: HttpApiGroup.HttpApiGroup<"server.config", HttpApiEndpoint.HttpApiEndpoint<"config.get", "GET", "/api/config", 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.$Array<Schema.Union<readonly [typeof Config.Document, typeof Config.Directory, typeof Config.AgentsDirectory, typeof Config.ClaudeDirectory]>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"config.preferences", "GET", "/api/config/preferences", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly shell: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly websearch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Literal<false>, typeof import("@opencode/schema/config/websearch").Info]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Literal<false>, typeof import("@opencode/schema/config/websearch").Info]>>, never, never>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"config.updatePreferences", "PATCH", "/api/config/preferences", never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly shell: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NullOr<Schema.String>>>, Schema.optionalKey<Schema.NullOr<Schema.String>>, never, never>;
-    readonly websearch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NullOr<Schema.Union<readonly [Schema.Literal<false>, typeof import("@opencode/schema/config/websearch").Info]>>>>, Schema.optionalKey<Schema.NullOr<Schema.Union<readonly [Schema.Literal<false>, typeof import("@opencode/schema/config/websearch").Info]>>>, never, never>;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly shell: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly websearch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Literal<false>, typeof import("@opencode/schema/config/websearch").Info]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Literal<false>, typeof import("@opencode/schema/config/websearch").Info]>>, never, never>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"config.shells", "GET", "/api/config/shell", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Union<readonly [typeof Config.Document, typeof Config.Directory]>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"config.shells", "GET", "/api/config/shell", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
     readonly path: Schema.String;
     readonly name: Schema.String;
     readonly acceptable: Schema.Boolean;
-}>>>, never, never, never>, false>;
+}>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"config.update", "PATCH", "/api/experimental/config", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly shell: Schema.NullOr<Schema.String>;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/config.js

@@ -1,7 +1,7 @@
 import { Config } from "@opencode/schema/config";
 import { ConfigShell } from "@opencode/schema/config/shell";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const ConfigGroup = HttpApiGroup.make("server.config")
     .add(HttpApiEndpoint.get("config.get", "/api/config", {
@@ -10,30 +10,23 @@ export const ConfigGroup = HttpApiGroup.make("server.config")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.config.get",
+    identifier: "config.get",
     summary: "Get configuration",
     description: "Return configuration documents and discovery sources for the requested location, from lowest to highest priority.",
-})))
-    .add(HttpApiEndpoint.get("config.preferences", "/api/config/preferences", {
-    success: Config.Preferences,
-}).annotateMerge(OpenApi.annotations({
-    identifier: "v2.config.preferences",
-    summary: "Get global preferences",
-    description: "Return preferences from the highest-precedence global configuration document.",
-})))
-    .add(HttpApiEndpoint.patch("config.updatePreferences", "/api/config/preferences", {
-    payload: Config.PreferencesPatch,
-    success: Config.Preferences,
-}).annotateMerge(OpenApi.annotations({
-    identifier: "v2.config.updatePreferences",
-    summary: "Update global preferences",
-    description: "Patch preferences in the highest-precedence global configuration document.",
 })))
     .add(HttpApiEndpoint.get("config.shells", "/api/config/shell", {
     success: Schema.Array(ConfigShell.Option),
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.config.shells",
+    identifier: "config.shells",
     summary: "List available shells",
     description: "Return shells available to terminal and agent execution.",
+})))
+    .add(HttpApiEndpoint.patch("config.update", "/api/experimental/config", {
+    payload: Config.Patch,
+    success: HttpApiSchema.NoContent,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "experimental.config.update",
+    summary: "Update global configuration",
+    description: "Patch supported fields in the highest-precedence global configuration document.",
 })))
     .annotateMerge(OpenApi.annotations({ title: "config", description: "Location-scoped configuration routes." }));

package/dist/groups/credential.d.ts

@@ -4,29 +4,14 @@ export declare const CredentialGroup: HttpApiGroup.HttpApiGroup<"server.credenti
     credentialID: Schema.brand<Schema.String, "Credential.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Credential.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<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly label: Schema.String;
 }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"credential.activate", "POST", "/api/credential/:credentialID/activate", Schema.toCodecStringTree<Schema.Struct<{
     credentialID: Schema.brand<Schema.String, "Credential.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Credential.ID">;
     };
-}>>, 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<"credential.remove", "DELETE", "/api/credential/:credentialID", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"credential.remove", "DELETE", "/api/credential/:credentialID", Schema.toCodecStringTree<Schema.Struct<{
     credentialID: Schema.brand<Schema.String, "Credential.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Credential.ID">;
     };
-}>>, 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>;
+}>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/credential.js

@@ -1,40 +1,33 @@
 import { Credential } from "@opencode/schema/credential";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const CredentialGroup = HttpApiGroup.make("server.credential")
     .add(HttpApiEndpoint.patch("credential.update", "/api/credential/:credentialID", {
     params: { credentialID: Credential.ID },
-    query: LocationQuery,
     payload: Schema.Struct({ label: Schema.String }),
     success: HttpApiSchema.NoContent,
 })
-    .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.credential.update",
+    identifier: "credential.update",
     summary: "Update credential",
     description: "Update a stored credential label.",
 })))
     .annotateMerge(OpenApi.annotations({ title: "credential" }))
     .add(HttpApiEndpoint.post("credential.activate", "/api/credential/:credentialID/activate", {
     params: { credentialID: Credential.ID },
-    query: LocationQuery,
     success: HttpApiSchema.NoContent,
 })
-    .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.credential.activate",
+    identifier: "credential.activate",
     summary: "Activate credential",
     description: "Activate a stored integration credential.",
 })))
     .add(HttpApiEndpoint.delete("credential.remove", "/api/credential/:credentialID", {
     params: { credentialID: Credential.ID },
-    query: LocationQuery,
     success: HttpApiSchema.NoContent,
 })
-    .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.credential.remove",
+    identifier: "credential.remove",
     summary: "Remove credential",
     description: "Remove a stored integration credential.",
 })));

package/dist/groups/debug.d.ts

@@ -2,16 +2,8 @@ import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
 export declare const DebugGroup: HttpApiGroup.HttpApiGroup<"server.debug", HttpApiEndpoint.HttpApiEndpoint<"debug.location", "GET", "/api/debug/location", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-    readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-    }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-    }>, never, never>;
 }>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"debug.location.evict", "DELETE", "/api/debug/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<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/debug.js

@@ -4,9 +4,9 @@ import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/un
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const DebugGroup = HttpApiGroup.make("server.debug")
     .add(HttpApiEndpoint.get("debug.location", "/api/debug/location", {
-    success: Schema.Array(Location.Ref),
+    success: Schema.Array(Location.PublicRef),
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.debug.location.list",
+    identifier: "debug.location.list",
     summary: "List loaded locations",
     description: "List locations currently loaded by the server.",
 })))
@@ -16,7 +16,7 @@ export const DebugGroup = HttpApiGroup.make("server.debug")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.debug.location.evict",
+    identifier: "debug.location.evict",
     summary: "Evict a loaded location",
     description: "Dispose the requested location's cached services so its next use boots them fresh.",
 })))