@opencode/protocol 2.0.5 → 2.0.6

package/dist/api.d.ts

@@ -23,7 +23,7 @@ import { PersistentPtyGroup } from "./groups/persistent-pty.js";
 import { ShellGroup } from "./groups/shell.js";
 import { ReferenceGroup } from "./groups/reference.js";
 import { Authorization } from "./middleware/authorization.js";
-import { LocationGroup } from "./groups/location.js";
+import { makeLocationGroup } from "./groups/location.js";
 import { IntegrationGroup } from "./groups/integration.js";
 import { WebSearchGroup } from "./groups/websearch.js";
 import { McpGroup } from "./groups/mcp.js";
@@ -33,11 +33,12 @@ import { WorktreeGroup } from "./groups/worktree.js";
 import { VcsGroup } from "./groups/vcs.js";
 import { MigrationGroup } from "./groups/migration.js";
 import { ConfigGroup } from "./groups/config.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 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 LocationGroups<LocationId extends HttpApiMiddleware.AnyId> = 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 LocationGroup<LocationId extends HttpApiMiddleware.AnyId, LocationService> = ReturnType<typeof makeLocationGroup<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 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 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> | LocationGroup<LocationId, LocationService> | 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

@@ -22,7 +22,7 @@ import { PersistentPtyGroup } from "./groups/persistent-pty.js";
 import { ShellGroup } from "./groups/shell.js";
 import { ReferenceGroup } from "./groups/reference.js";
 import { Authorization } from "./middleware/authorization.js";
-import { LocationGroup } from "./groups/location.js";
+import { makeLocationGroup } from "./groups/location.js";
 import { IntegrationGroup } from "./groups/integration.js";
 import { WebSearchGroup } from "./groups/websearch.js";
 import { McpGroup } from "./groups/mcp.js";
@@ -35,7 +35,7 @@ import { ConfigGroup } from "./groups/config.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(ServerGroup)
-    .add(LocationGroup.middleware(locationMiddleware))
+    .add(makeLocationGroup(locationMiddleware))
     .add(AgentGroup.middleware(locationMiddleware))
     .add(PluginGroup.middleware(locationMiddleware))
     .add(makeSessionGroup(sessionLocationMiddleware, formLocationMiddleware))

package/dist/client.js

@@ -45,4 +45,4 @@ export const groupNames = {
     "server.config": "config",
 };
 export const promiseOmitEndpoints = new Set(["pty.connect", "persistentPty.connect"]);
-export const effectOmitEndpoints = new Set(["fs.read", "pty.connect", "persistentPty.connect"]);
+export const effectOmitEndpoints = new Set(["fs.read", "fs.write", "pty.connect", "persistentPty.connect"]);

package/dist/groups/event.d.ts

@@ -48,6 +48,38 @@ export declare const makeEventGroup: <const Definitions extends ReadonlyArray<De
     } | undefined;
 }[]])[number]>, never, never, never>, false>;
 export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpApiEndpoint.HttpApiEndpoint<"event.subscribe", "GET", "/api/event", never, never, never, never, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"location.shutdown">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<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>;
+    }>>>, Schema.optionalKey<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>;
+    readonly data: Schema.Struct<{}>;
+}> & {
+    type: "location.shutdown";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{}>;
+}, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
     };
@@ -8132,6 +8164,18 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
+} | {
+    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+    readonly data: {};
+    readonly type: "location.shutdown";
+    readonly created: number;
+    readonly location?: {
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+    } | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly data: {
@@ -8464,6 +8508,38 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
     } | undefined;
 }>, never, never, never>, false>;
 export declare const OpenCodeEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"location.shutdown">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<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>;
+    }>>>, Schema.optionalKey<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>;
+    readonly data: Schema.Struct<{}>;
+}> & {
+    type: "location.shutdown";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{}>;
+}, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
     };

package/dist/groups/fs.d.ts

@@ -33,4 +33,16 @@ export declare const FileSystemGroup: HttpApiGroup.HttpApiGroup<"server.fs", Htt
         readonly path: Schema.brand<Schema.String, "RelativePath">;
         readonly type: Schema.Literals<readonly ["file", "directory"]>;
     }>>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.write", "POST", "/api/experimental/fs/write", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly path: Schema.String;
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, Schema.toCodecJson<Schema.Uint8Array>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.Struct<{
+        readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
 }>>, never, never, never>, false>;

package/dist/groups/fs.js

@@ -11,6 +11,12 @@ const ListQuery = Schema.Struct({
         description: "An absolute path or a path relative to the requested location. Defaults to the location directory.",
     }),
 });
+const WriteQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    path: Schema.String.annotate({
+        description: "An absolute path or a path relative to the requested location. Missing parent directories are created.",
+    }),
+});
 const FindQuery = Schema.Struct({
     ...LocationQuery.fields,
     query: FileSystem.FindInput.fields.query,
@@ -48,6 +54,17 @@ export const FileSystemGroup = HttpApiGroup.make("server.fs")
     identifier: "fs.find",
     summary: "Find files",
     description: "Find recursively ranked filesystem entries relative to the requested location.",
+})))
+    .add(HttpApiEndpoint.post("fs.write", "/api/experimental/fs/write", {
+    query: WriteQuery,
+    payload: Schema.Uint8Array.pipe(HttpApiSchema.asUint8Array()),
+    success: Location.response(FileSystem.Write),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "experimental.fs.write",
+    summary: "Write file",
+    description: "Write the raw request body to an absolute path or a path relative to the requested location, creating parent directories, and return the resolved absolute path. Unlike read, the target is not confined to the location. Experimental: may change without compatibility guarantees.",
 })))
     .annotateMerge(OpenApi.annotations({
     title: "filesystem",

package/dist/groups/location.d.ts

@@ -1,12 +1,13 @@
-import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { ServiceUnavailableError } from "../errors.js";
 export declare const LocationQuery: Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: 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<{
+export declare const locationQueryOpenApi: Context.Context<never>;
+export declare const makeLocationGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService>(locationMiddleware: Context.Key<LocationId, LocationService>) => 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>;
     }>>;
@@ -19,4 +20,4 @@ export declare const LocationGroup: HttpApiGroup.HttpApiGroup<"server.location",
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
-}>>, never, never, never>, false>;
+}>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"location.reload", "POST", "/api/location/reload", never, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/location.js

@@ -1,6 +1,7 @@
 import { Location } from "@opencode/schema/location";
-import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { ServiceUnavailableError } from "../errors.js";
 export const LocationQuery = Schema.Struct({
     location: Schema.optional(Schema.Struct({
         directory: Schema.optional(Schema.String),
@@ -19,15 +20,26 @@ export const locationQueryOpenApi = OpenApi.annotations({
         };
     },
 });
-export const LocationGroup = HttpApiGroup.make("server.location")
+// Middleware is applied per endpoint: reload acts on every loaded location and
+// must not boot the caller's location first.
+export const makeLocationGroup = (locationMiddleware) => HttpApiGroup.make("server.location")
     .add(HttpApiEndpoint.get("location.get", "/api/location", {
     query: LocationQuery,
     success: Location.PublicInfo,
 })
+    .middleware(locationMiddleware)
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
     identifier: "location.get",
     summary: "Get location",
     description: "Resolve the requested location or the server default location.",
+})))
+    .add(HttpApiEndpoint.post("location.reload", "/api/location/reload", {
+    success: HttpApiSchema.NoContent,
+    error: ServiceUnavailableError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "location.reload",
+    summary: "Reload locations",
+    description: "Shut down and rebuild every loaded location. Pending permissions and forms are cancelled; running sessions continue with fresh services at the next step boundary. Emits location.shutdown for client recovery and responds once all replacement builds settle.",
 })))
     .annotateMerge(OpenApi.annotations({ title: "location" }));

package/dist/groups/server.d.ts

@@ -1,13 +1,19 @@
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
-export declare const ServerStatus: Schema.Struct<{
+export declare const ServerInfo: Schema.Struct<{
     readonly version: Schema.String;
     readonly pid: Schema.Int;
     readonly urls: Schema.$Array<Schema.String>;
+    readonly paths: Schema.Struct<{
+        readonly tmp: Schema.String;
+    }>;
 }>;
-export type ServerStatus = typeof ServerStatus.Type;
-export declare const ServerGroup: HttpApiGroup.HttpApiGroup<"server.server", HttpApiEndpoint.HttpApiEndpoint<"server.status", "GET", "/api/status", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+export type ServerInfo = typeof ServerInfo.Type;
+export declare const ServerGroup: HttpApiGroup.HttpApiGroup<"server.server", HttpApiEndpoint.HttpApiEndpoint<"server.info", "GET", "/api/info", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly version: Schema.String;
     readonly pid: Schema.Int;
     readonly urls: Schema.$Array<Schema.String>;
+    readonly paths: Schema.Struct<{
+        readonly tmp: Schema.String;
+    }>;
 }>>, never, never, never>, false>;

package/dist/groups/server.js

@@ -1,17 +1,20 @@
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
-export const ServerStatus = Schema.Struct({
+export const ServerInfo = Schema.Struct({
     version: Schema.String,
     // 0 means the runtime has no OS process identity (e.g. workerd).
     pid: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
     urls: Schema.Array(Schema.String),
-}).annotate({ identifier: "ServerStatus" });
+    paths: Schema.Struct({
+        tmp: Schema.String,
+    }),
+}).annotate({ identifier: "ServerInfo" });
 export const ServerGroup = HttpApiGroup.make("server.server")
-    .add(HttpApiEndpoint.get("server.status", "/api/status", {
-    success: ServerStatus,
+    .add(HttpApiEndpoint.get("server.info", "/api/info", {
+    success: ServerInfo,
 }).annotateMerge(OpenApi.annotations({
-    identifier: "server.status",
-    summary: "Get server status",
-    description: "Return the server identity, connection URLs, and readiness status.",
+    identifier: "server.info",
+    summary: "Get server info",
+    description: "Return the server identity, connection URLs, paths, and readiness status.",
 })))
     .annotateMerge(OpenApi.annotations({ title: "server" }));

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/protocol",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode/schema": "2.0.5",
+    "@opencode/schema": "2.0.6",
     "effect": "4.0.0-rc.112"
   },
   "devDependencies": {