@opencode/protocol 2.0.3 → 2.0.5

package/dist/groups/message.js

@@ -1,6 +1,7 @@
 import { Session } from "@opencode/schema/session";
 import { SessionMessage } from "@opencode/schema/session-message";
-import { Schema } from "effect";
+import { Location } from "@opencode/schema/location";
+import { Schema, Struct } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
 import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
 export const SessionMessagesQuery = Schema.Struct({
@@ -28,12 +29,34 @@ export const SessionMessagesQuery = Schema.Struct({
         description: "Filter by message type before pagination. When omitted, all message types are returned. Pass the same type when following cursors.",
     }),
 }).annotate({ identifier: "SessionMessagesQuery" });
+const PublicLocationSwitched = Schema.Struct({
+    ...Struct.omit(SessionMessage.LocationSwitched.fields, ["location", "previous"]),
+    location: Location.PublicRef,
+    previous: Schema.Struct({
+        location: Location.PublicRef,
+        projectID: SessionMessage.LocationSwitched.fields.projectID,
+        subpath: SessionMessage.LocationSwitched.fields.subpath,
+    }).pipe(Schema.optional),
+}).annotate({ identifier: "Session.Message.LocationSwitched" });
+export const PublicSessionMessage = Schema.Union([
+    SessionMessage.AgentSelected,
+    SessionMessage.ModelSelected,
+    PublicLocationSwitched,
+    SessionMessage.User,
+    SessionMessage.Synthetic,
+    SessionMessage.System,
+    SessionMessage.Skill,
+    SessionMessage.Shell,
+    SessionMessage.Assistant,
+    SessionMessage.Compaction,
+    SessionMessage.Idle,
+]).annotate({ identifier: "Session.Message.Info" });
 export const MessageGroup = HttpApiGroup.make("server.message")
     .add(HttpApiEndpoint.get("session.messages", "/api/session/:sessionID/message", {
     params: { sessionID: Session.ID },
     query: SessionMessagesQuery,
     success: Schema.Struct({
-        data: Schema.Array(SessionMessage.Info),
+        data: Schema.Array(PublicSessionMessage),
         cursor: Schema.Struct({
             previous: Schema.String.pipe(Schema.optional),
             next: Schema.String.pipe(Schema.optional),
@@ -41,7 +64,7 @@ export const MessageGroup = HttpApiGroup.make("server.message")
     }).annotate({ identifier: "SessionMessagesResponse" }),
     error: [InvalidCursorError, SessionNotFoundError, UnknownError],
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.message.list",
+    identifier: "session.message.list",
     summary: "Get session messages",
     description: "Retrieve projected messages for a session, optionally filtered by type. Items keep the requested order across pages; use cursor.next or cursor.previous to move through the ordered timeline, passing the same type filter on each page.",
 })))

package/dist/groups/migration.js

@@ -14,7 +14,7 @@ export const MigrationGroup = HttpApiGroup.make("server.migration")
     .add(HttpApiEndpoint.get("migration.v1.status", "/api/experimental/migration/v1", {
     success: V1MigrationStatus,
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.experimental.migration.v1.status",
+    identifier: "experimental.migration.v1.status",
     summary: "Get V1 migration status",
     description: "Return the progress of the V1 to V2 session history migration.",
 })))

package/dist/groups/model.d.ts

@@ -1,21 +1,20 @@
 import { Model } from "@opencode/schema/model";
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 import { ServiceUnavailableError } from "../errors.js";
 export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpApiEndpoint.HttpApiEndpoint<"model.list", "GET", "/api/model", 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 capabilities: Schema.Struct<{
             readonly tools: Schema.Boolean;
             readonly input: Schema.$Array<Schema.String>;
             readonly output: Schema.$Array<Schema.String>;
-            readonly responsesWebsockets: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }> & {
             default: () => {
                 tools: true;
@@ -113,12 +112,14 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
             readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
             readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
             readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>, never, never>;
         readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
@@ -132,7 +133,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             readonly mode: Schema.Literal<"provider">;
             readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>]>>, never, never>;
-        readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
     }> & {
         default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
             id: string & import("effect/Brand").Brand<"Model.ID">;
@@ -160,16 +161,16 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
 }>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"model.default", "GET", "/api/model/default", 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.UndefinedOr<Schema.Struct<{
         readonly capabilities: Schema.Struct<{
             readonly tools: Schema.Boolean;
             readonly input: Schema.$Array<Schema.String>;
             readonly output: Schema.$Array<Schema.String>;
-            readonly responsesWebsockets: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }> & {
             default: () => {
                 tools: true;
@@ -267,12 +268,14 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
             readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
             readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
             readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>, never, never>;
         readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
@@ -286,7 +289,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             readonly mode: Schema.Literal<"provider">;
             readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>]>>, never, never>;
-        readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
     }> & {
         default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
             id: string & import("effect/Brand").Brand<"Model.ID">;

package/dist/groups/model.js

@@ -12,7 +12,7 @@ export const ModelGroup = HttpApiGroup.make("server.model")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.model.list",
+    identifier: "model.list",
     summary: "List models",
     description: "Retrieve the current snapshot of available models ordered by release date. The snapshot may precede initial plugin settlement.",
 })))
@@ -23,7 +23,7 @@ export const ModelGroup = HttpApiGroup.make("server.model")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.model.default",
+    identifier: "model.default",
     summary: "Get default model",
     description: "Retrieve the model used when a session has no explicit model selection.",
 })))

package/dist/groups/permission.d.ts

@@ -1,14 +1,14 @@
-import { Location } from "@opencode/schema/location";
 import { Context, Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
 import { PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
 export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(locationMiddleware: Context.Key<LocationId, LocationService>, sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>) => HttpApiGroup.HttpApiGroup<"server.permission", HttpApiEndpoint.HttpApiEndpoint<"permission.request.list", "GET", "/api/permission/request", 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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -46,6 +46,10 @@ export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.
         };
         readonly action: Schema.String;
         readonly resource: Schema.String;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+            readonly updated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
     }>>;
 }>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"permission.saved.remove", "DELETE", "/api/permission/saved/:id", Schema.toCodecStringTree<Schema.Struct<{
     id: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
@@ -151,17 +155,6 @@ export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.
         create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
     };
 }>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+    readonly decision: Schema.Literals<readonly ["once", "always", "reject"]>;
     readonly message: Schema.optional<Schema.String>;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError | typeof PermissionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.rules", "PUT", "/api/session/:sessionID/permission/rules", Schema.toCodecStringTree<Schema.Struct<{
-    sessionID: Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    };
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly permissions: Schema.$Array<Schema.Struct<{
-        readonly action: Schema.String;
-        readonly resource: Schema.String;
-        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-    }>>;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>>, false>;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError | typeof PermissionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>>, false>;

package/dist/groups/permission.js

@@ -15,7 +15,7 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.permission.request.list",
+    identifier: "permission.request.list",
     summary: "List pending permission requests",
     description: "Retrieve pending permission requests for a location.",
 })))
@@ -23,7 +23,7 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
     query: Schema.Struct({ projectID: Project.ID.pipe(Schema.optional) }),
     success: Schema.Struct({ data: Schema.Array(PermissionSaved.Info) }),
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.permission.saved.list",
+    identifier: "permission.saved.list",
     summary: "List saved permissions",
     description: "Retrieve saved permissions, optionally filtered by project.",
 })))
@@ -31,7 +31,7 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
     params: { id: PermissionSaved.ID },
     success: HttpApiSchema.NoContent,
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.permission.saved.remove",
+    identifier: "permission.saved.remove",
     summary: "Remove saved permission",
     description: "Remove a saved permission by ID.",
 })))
@@ -55,7 +55,7 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
 })
     .middleware(sessionLocationMiddleware)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.permission.create",
+    identifier: "session.permission.create",
     summary: "Create permission request",
     description: "Evaluate and, when approval is required, create a permission request for a session.",
 })))
@@ -64,7 +64,7 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
     success: Schema.Struct({ data: Schema.Array(Permission.Request) }),
     error: SessionNotFoundError,
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.permission.list",
+    identifier: "session.permission.list",
     summary: "List session permission requests",
     description: "Retrieve pending permission requests owned by a session.",
 })))
@@ -75,14 +75,14 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
 })
     .middleware(sessionLocationMiddleware)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.permission.get",
+    identifier: "session.permission.get",
     summary: "Get permission request",
     description: "Retrieve a pending permission request owned by a session.",
 })))
     .add(HttpApiEndpoint.post("session.permission.reply", "/api/session/:sessionID/permission/:requestID/reply", {
     params: { sessionID: Session.ID, requestID: Permission.ID },
     payload: Schema.Struct({
-        reply: Permission.Reply,
+        decision: Permission.Reply,
         message: Schema.String.pipe(Schema.optional),
     }),
     success: HttpApiSchema.NoContent,
@@ -90,20 +90,8 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
 })
     .middleware(sessionLocationMiddleware)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.permission.reply",
+    identifier: "session.permission.reply",
     summary: "Reply to pending permission request",
     description: "Respond to a pending permission request owned by a session.",
-})))
-    .add(HttpApiEndpoint.put("session.permission.rules", "/api/session/:sessionID/permission/rules", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({ permissions: Permission.Ruleset }),
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.permission.rules",
-    summary: "Replace session permission rules",
-    description: "Replace the session-scoped permission rules. Rules are evaluated after the agent's rules, and the last matching rule wins.",
 })))
     .annotateMerge(OpenApi.annotations({ title: "permission", description: "Experimental permission routes." }));

package/dist/groups/persistent-pty.js

@@ -76,7 +76,7 @@ export const PersistentPtyGroup = HttpApiGroup.make("server.experimental")
     success: Schema.Boolean,
     error: [ForbiddenError, PtyNotFoundError, ServiceUnavailableError],
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.persistentPty.connect",
+    identifier: "persistentPty.connect",
     summary: "Connect to a persistent PTY",
     description: "Stream persistent PTY output through the OpenCode server.",
     transform: (operation) => ({

package/dist/groups/plugin.d.ts

@@ -1,14 +1,14 @@
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
 import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export declare const PluginGroup: HttpApiGroup.HttpApiGroup<"server.plugin", HttpApiEndpoint.HttpApiEndpoint<"plugin.list", "GET", "/api/plugin", 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.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Plugin.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Plugin.ID">>, never, never>;
         readonly source: Schema.Union<readonly [Schema.Struct<{
@@ -38,20 +38,16 @@ export declare const PluginGroup: HttpApiGroup.HttpApiGroup<"server.plugin", Htt
             readonly ref: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         }>]>;
     }>>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"plugin.awaitActivation", "POST", "/api/plugin/await-activation", never, Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"plugin.check", "POST", "/api/plugin/check", 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> | HttpApiEndpoint.HttpApiEndpoint<"plugin.check", "POST", "/api/plugin/check", 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 target: 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.$Array<Schema.Struct<{
         readonly id: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Plugin.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Plugin.ID">>, never, never>;
         readonly source: Schema.Union<readonly [Schema.Struct<{
@@ -84,7 +80,6 @@ export declare const PluginGroup: HttpApiGroup.HttpApiGroup<"server.plugin", Htt
 }>>, Schema.toCodecJson<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"plugin.update", "POST", "/api/plugin/update", 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 targets: Schema.$Array<Schema.String>;

package/dist/groups/plugin.js

@@ -11,19 +11,9 @@ export const PluginGroup = HttpApiGroup.make("server.plugin")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.plugin.list",
+    identifier: "plugin.list",
     summary: "List plugins",
     description: "Retrieve enabled server plugins and their current status.",
-})))
-    .add(HttpApiEndpoint.post("plugin.awaitActivation", "/api/plugin/await-activation", {
-    query: LocationQuery,
-    success: HttpApiSchema.NoContent,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.plugin.awaitActivation",
-    summary: "Wait for plugin activation",
-    description: "Wait for configured plugin activation at a Location to settle, including missing-package installs. Completion does not imply every plugin succeeded or background resource discovery finished. Cancelling this wait does not cancel activation.",
 })))
     .add(HttpApiEndpoint.post("plugin.check", "/api/plugin/check", {
     query: LocationQuery,
@@ -33,7 +23,7 @@ export const PluginGroup = HttpApiGroup.make("server.plugin")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.plugin.check",
+    identifier: "plugin.check",
     summary: "Check plugin updates",
     description: "Check one or all package plugins for available updates.",
 })))
@@ -45,7 +35,7 @@ export const PluginGroup = HttpApiGroup.make("server.plugin")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.plugin.update",
+    identifier: "plugin.update",
     summary: "Update plugins",
     description: "Update package plugins concurrently and notify active locations to reload them. Responds once every update has finished; fails when any update fails.",
 })))

package/dist/groups/project.d.ts

@@ -25,7 +25,6 @@ export declare const ProjectGroup: HttpApiGroup.HttpApiGroup<"server.project", H
     readonly time: Schema.Struct<{
         readonly created: Schema.Int;
         readonly updated: Schema.Int;
-        readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>;
     readonly sandboxes: Schema.$Array<Schema.String>;
 }>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"project.update", "PATCH", "/api/project/:projectID", Schema.toCodecStringTree<Schema.Struct<{
@@ -73,18 +72,6 @@ export declare const ProjectGroup: HttpApiGroup.HttpApiGroup<"server.project", H
     readonly time: Schema.Struct<{
         readonly created: Schema.Int;
         readonly updated: Schema.Int;
-        readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>;
     readonly sandboxes: Schema.$Array<Schema.String>;
-}>>, Schema.toCodecJson<typeof ProjectNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"project.current", "GET", "/api/project/current", 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 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>;
+}>>, Schema.toCodecJson<typeof ProjectNotFoundError>, never, never>, false>;

package/dist/groups/project.js

@@ -1,7 +1,6 @@
 import { Project } from "@opencode/schema/project";
 import { Schema, Struct } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
-import { LocationQuery, locationQueryOpenApi } from "./location.js";
 import { ProjectNotFoundError } from "../errors.js";
 const root = "/api/project";
 const UpdatePayload = Schema.Struct(Struct.omit(Project.UpdateInput.fields, ["projectID"]));
@@ -9,7 +8,7 @@ export const ProjectGroup = HttpApiGroup.make("server.project")
     .add(HttpApiEndpoint.get("project.list", root, {
     success: Schema.Array(Project.Info),
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.project.list",
+    identifier: "project.list",
     summary: "List projects",
     description: "List known projects.",
 })))
@@ -19,19 +18,9 @@ export const ProjectGroup = HttpApiGroup.make("server.project")
     success: Project.Info,
     error: ProjectNotFoundError,
 }).annotateMerge(OpenApi.annotations({
-    identifier: "v2.project.update",
+    identifier: "project.update",
     summary: "Update project",
     description: "Update the project canonical directory, display metadata, and workspace commands.",
-})))
-    .add(HttpApiEndpoint.get("project.current", `${root}/current`, {
-    query: LocationQuery,
-    success: Project.Current,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.project.current",
-    summary: "Get current project",
-    description: "Resolve the project for the requested location.",
 })))
     .annotateMerge(OpenApi.annotations({
     title: "project",

package/dist/groups/provider.d.ts

@@ -1,15 +1,15 @@
 import { Provider } from "@opencode/schema/provider";
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 import { ProviderNotFoundError, ServiceUnavailableError } from "../errors.js";
 export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider", HttpApiEndpoint.HttpApiEndpoint<"provider.list", "GET", "/api/provider", 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 settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
         readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
@@ -67,7 +67,7 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
             readonly mode: Schema.Literal<"provider">;
             readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>]>>, never, never>;
-        readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
     }> & {
         empty: (id: Provider.ID) => Provider.Info;
     }>;
@@ -88,10 +88,11 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
 }>>, 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 settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
         readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
@@ -149,7 +150,7 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
             readonly mode: Schema.Literal<"provider">;
             readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>]>>, never, never>;
-        readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
     }> & {
         empty: (id: Provider.ID) => Provider.Info;
     };

package/dist/groups/provider.js

@@ -12,7 +12,7 @@ export const ProviderGroup = HttpApiGroup.make("server.provider")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.provider.list",
+    identifier: "provider.list",
     summary: "List providers",
     description: "Retrieve active AI providers so clients can show provider availability and configuration.",
 })))
@@ -24,7 +24,7 @@ export const ProviderGroup = HttpApiGroup.make("server.provider")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.provider.get",
+    identifier: "provider.get",
     summary: "Get provider",
     description: "Retrieve a single AI provider so clients can inspect its availability and endpoint settings.",
 })))