@opencode/protocol 2.0.25 → 2.0.27

package/dist/api.d.ts

@@ -1,5 +1,5 @@
 import { Context } from "effect";
-import { HttpApi, HttpApiGroup, HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApi, HttpApiGroup, HttpApiMiddleware } from "effect/http-api";
 import { SchemaErrorMiddleware } from "./middleware/schema-error.js";
 import { GenerateGroup } from "./groups/generate.js";
 import { MessageGroup } from "./groups/message.js";

package/dist/api.js

@@ -1,5 +1,5 @@
 import { Context } from "effect";
-import { HttpApi, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
+import { HttpApi, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/http-api";
 import { SchemaErrorMiddleware } from "./middleware/schema-error.js";
 import { GenerateGroup } from "./groups/generate.js";
 import { MessageGroup } from "./groups/message.js";

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import { LocationNotFoundError, InvalidRequestError, SessionNotFoundError } from "./errors.js";
 import type { Api } from "./api.js";
 import type { Context } from "effect";
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import type { EventGroup } from "./groups/event.js";
 declare const LocationMiddleware_base: HttpApiMiddleware.ServiceClass<LocationMiddleware, "@opencode/client/LocationMiddleware", {
     requires: never;

package/dist/client.js

@@ -1,6 +1,6 @@
 import { LocationNotFoundError, InvalidRequestError, SessionNotFoundError } from "./errors.js";
 import { makeDefaultApi } from "./api.js";
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 class LocationMiddleware extends HttpApiMiddleware.Service()("@opencode/client/LocationMiddleware", { error: [LocationNotFoundError] }) {
 }
 class SessionLocationMiddleware extends HttpApiMiddleware.Service()("@opencode/client/SessionLocationMiddleware", { error: [InvalidRequestError, SessionNotFoundError, LocationNotFoundError] }) {

package/dist/groups/agent.d.ts

@@ -1,6 +1,6 @@
 import { Agent } from "@opencode/schema/agent";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 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<{

package/dist/groups/agent.js

@@ -1,7 +1,7 @@
 import { Agent } from "@opencode/schema/agent";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 import { AgentNotFoundError } from "../errors.js";
 export const AgentGroup = HttpApiGroup.make("server.agent")

package/dist/groups/command.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 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>;

package/dist/groups/command.js

@@ -1,7 +1,7 @@
 import { Command } from "@opencode/schema/command";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const CommandGroup = HttpApiGroup.make("server.command")
     .add(HttpApiEndpoint.get("command.list", "/api/command", {

package/dist/groups/config.d.ts

@@ -1,6 +1,6 @@
 import { Config } from "@opencode/schema/config";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 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>;

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, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const ConfigGroup = HttpApiGroup.make("server.config")
     .add(HttpApiEndpoint.get("config.get", "/api/config", {

package/dist/groups/credential.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ConflictError } from "../errors.js";
 export declare const CredentialGroup: HttpApiGroup.HttpApiGroup<"server.credential", HttpApiEndpoint.HttpApiEndpoint<"credential.list", "GET", "/api/credential", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly data: Schema.$Array<Schema.Struct<{

package/dist/groups/credential.js

@@ -1,6 +1,6 @@
 import { Credential } from "@opencode/schema/credential";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ConflictError } from "../errors.js";
 export const CredentialGroup = HttpApiGroup.make("server.credential")
     .add(HttpApiEndpoint.get("credential.list", "/api/credential", {

package/dist/groups/debug.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 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">;
 }>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"debug.location.evict", "DELETE", "/api/debug/location", never, Schema.toCodecStringTree<Schema.Struct<{

package/dist/groups/debug.js

@@ -1,6 +1,6 @@
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const DebugGroup = HttpApiGroup.make("server.debug")
     .add(HttpApiEndpoint.get("debug.location", "/api/debug/location", {

package/dist/groups/event.d.ts

@@ -1,7 +1,7 @@
 import { Event } from "@opencode/schema/event";
 import type { Definition } from "@opencode/schema/event";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 export declare const makeEventGroup: <const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions) => HttpApiGroup.HttpApiGroup<"server.event", HttpApiEndpoint.HttpApiEndpoint<"event.subscribe", "GET", "/api/event", never, never, never, never, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [...Definitions, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -4760,6 +4760,7 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
             readonly active: Schema.Int;
+            readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;
@@ -4792,6 +4793,7 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
             readonly active: Schema.Int;
+            readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;
@@ -6419,6 +6421,11 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 readonly type: "string";
                 readonly key: string;
                 readonly required?: boolean | undefined;
+                readonly options?: readonly {
+                    readonly value: string;
+                    readonly label: string;
+                    readonly description?: string | undefined;
+                }[] | undefined;
                 readonly description?: string | undefined;
                 readonly format?: "email" | "uri" | "date" | "date-time" | undefined;
                 readonly minLength?: number | undefined;
@@ -6426,11 +6433,6 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 readonly pattern?: string | undefined;
                 readonly placeholder?: string | undefined;
                 readonly default?: string | undefined;
-                readonly options?: readonly {
-                    readonly value: string;
-                    readonly label: string;
-                    readonly description?: string | undefined;
-                }[] | undefined;
                 readonly custom?: boolean | undefined;
                 readonly title?: string | undefined;
                 readonly hidden?: boolean | undefined;
@@ -6484,12 +6486,12 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 }[] | undefined;
             } | {
                 readonly type: "multiselect";
-                readonly key: string;
                 readonly options: readonly {
                     readonly value: string;
                     readonly label: string;
                     readonly description?: string | undefined;
                 }[];
+                readonly key: string;
                 readonly required?: boolean | undefined;
                 readonly description?: string | undefined;
                 readonly default?: readonly string[] | undefined;
@@ -6513,6 +6515,11 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 readonly type: "string";
                 readonly key: string;
                 readonly required?: boolean | undefined;
+                readonly options?: readonly {
+                    readonly value: string;
+                    readonly label: string;
+                    readonly description?: string | undefined;
+                }[] | undefined;
                 readonly description?: string | undefined;
                 readonly format?: "email" | "uri" | "date" | "date-time" | undefined;
                 readonly minLength?: number | undefined;
@@ -6520,11 +6527,6 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 readonly pattern?: string | undefined;
                 readonly placeholder?: string | undefined;
                 readonly default?: string | undefined;
-                readonly options?: readonly {
-                    readonly value: string;
-                    readonly label: string;
-                    readonly description?: string | undefined;
-                }[] | undefined;
                 readonly custom?: boolean | undefined;
                 readonly title?: string | undefined;
                 readonly hidden?: boolean | undefined;
@@ -6578,12 +6580,12 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 }[] | undefined;
             } | {
                 readonly type: "multiselect";
-                readonly key: string;
                 readonly options: readonly {
                     readonly value: string;
                     readonly label: string;
                     readonly description?: string | undefined;
                 }[];
+                readonly key: string;
                 readonly required?: boolean | undefined;
                 readonly description?: string | undefined;
                 readonly default?: readonly string[] | undefined;
@@ -6778,8 +6780,9 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
         readonly canonical: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly time: {
             readonly created: number;
-            readonly updated: number;
             readonly active: number;
+            readonly updated: number;
+            readonly archived?: number | undefined;
         };
         readonly sandboxes: readonly string[];
         readonly name?: string | undefined;
@@ -13394,6 +13397,7 @@ export declare const OpenCodeEvent: Schema.Union<readonly [Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
             readonly active: Schema.Int;
+            readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;
@@ -13426,6 +13430,7 @@ export declare const OpenCodeEvent: Schema.Union<readonly [Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
             readonly active: Schema.Int;
+            readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;

package/dist/groups/event.js

@@ -2,7 +2,7 @@ import { Event } from "@opencode/schema/event";
 import { EventManifest } from "@opencode/schema/event-manifest";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 const fields = {
     id: Event.ID,
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),

package/dist/groups/form.d.ts

@@ -1,5 +1,5 @@
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware } from "effect/http-api";
 export declare const makeFormGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService>(locationMiddleware: Context.Key<LocationId, LocationService>) => HttpApiGroup.HttpApiGroup<"server.form", HttpApiEndpoint.HttpApiEndpoint<"form.list", "GET", "/api/form", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;

package/dist/groups/form.js

@@ -1,7 +1,7 @@
 import { Form } from "@opencode/schema/form";
 import { Location } from "@opencode/schema/location";
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const makeFormGroup = (locationMiddleware) => HttpApiGroup.make("server.form")
     .add(HttpApiEndpoint.get("form.list", "/api/form", {

package/dist/groups/fs.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 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<{
@@ -18,7 +18,7 @@ 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.find", "GET", "/api/fs/find", never, Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof FileNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.find", "GET", "/api/fs/find", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly query: Schema.String;
     readonly type: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["file", "directory"]>>>, Schema.optionalKey<Schema.Literals<readonly ["file", "directory"]>>, never, never>;
     readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;

package/dist/groups/fs.js

@@ -2,7 +2,7 @@ import { FileSystem } from "@opencode/schema/filesystem";
 import { Location } from "@opencode/schema/location";
 import { PositiveInt } from "@opencode/schema/schema";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { FileNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 const ListQuery = Schema.Struct({
@@ -38,6 +38,7 @@ export const FileSystemGroup = HttpApiGroup.make("server.fs")
     .add(HttpApiEndpoint.get("fs.list", "/api/fs/list", {
     query: ListQuery,
     success: Location.response(Schema.Array(FileSystem.Entry)),
+    error: FileNotFoundError,
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({

package/dist/groups/generate.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { LocationNotFoundError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 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;

package/dist/groups/generate.js

@@ -1,6 +1,6 @@
 import { Model } from "@opencode/schema/model";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationNotFoundError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export const GenerateGroup = HttpApiGroup.make("server.generate")
     .add(HttpApiEndpoint.post("generate.text", "/api/experimental/generate", {

package/dist/groups/integration.d.ts

@@ -1,6 +1,6 @@
 import { Integration } from "@opencode/schema/integration";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 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<{

package/dist/groups/integration.js

@@ -2,7 +2,7 @@ import { Integration } from "@opencode/schema/integration";
 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 { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { IntegrationAttemptNotFoundError, IntegrationMethodNotFoundError, IntegrationNotFoundError, InvalidRequestError, } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const IntegrationGroup = HttpApiGroup.make("server.integration")

package/dist/groups/location.d.ts

@@ -1,5 +1,5 @@
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
 import { ServiceUnavailableError } from "../errors.js";
 export declare const LocationQuery: Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/location.js

@@ -1,6 +1,6 @@
 import { Location } from "@opencode/schema/location";
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ServiceUnavailableError } from "../errors.js";
 export const LocationQuery = Schema.Struct({
     location: Schema.optional(Schema.Struct({

package/dist/groups/mcp.d.ts

@@ -1,6 +1,6 @@
 import { Mcp } from "@opencode/schema/mcp";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 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<{

package/dist/groups/mcp.js

@@ -1,7 +1,7 @@
 import { Mcp } from "@opencode/schema/mcp";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { McpServerNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const McpGroup = HttpApiGroup.make("server.mcp")

package/dist/groups/message.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
 export declare const SessionMessagesQuery: Schema.Struct<{
     readonly limit: Schema.optional<Schema.NumberFromString>;
@@ -717,6 +717,25 @@ export declare const PublicSessionMessage: Schema.Union<readonly [Schema.Struct<
 }>]>, Schema.Struct<{
     readonly type: Schema.tag<"idle">;
     readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+    readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly type: Schema.String;
+        readonly message: Schema.String;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly type: Schema.String;
+        readonly message: Schema.String;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>, never, never>;
+    }>>, never, never>;
     readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -1447,6 +1466,25 @@ export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", H
     }>]>, Schema.Struct<{
         readonly type: Schema.tag<"idle">;
         readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>, never, never>;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
             fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/groups/message.js

@@ -2,7 +2,7 @@ import { Session } from "@opencode/schema/session";
 import { SessionMessage } from "@opencode/schema/session-message";
 import { Location } from "@opencode/schema/location";
 import { Schema, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
 export const SessionMessagesQuery = Schema.Struct({
     limit: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(200))).annotate({

package/dist/groups/migration.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const V1MigrationStatus: Schema.Union<readonly [Schema.Struct<{
     readonly status: Schema.Literals<readonly ["required", "completed"]>;
 }>, Schema.Struct<{

package/dist/groups/migration.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 const V1MigrationProgress = Schema.Struct({
     label: Schema.String,
     numerator: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),

package/dist/groups/model.d.ts

@@ -1,6 +1,6 @@
 import { Model } from "@opencode/schema/model";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 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<{

package/dist/groups/model.js

@@ -1,7 +1,7 @@
 import { Model } from "@opencode/schema/model";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { ServiceUnavailableError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const ModelGroup = HttpApiGroup.make("server.model")

package/dist/groups/permission.d.ts

@@ -1,5 +1,5 @@
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
 import { LocationNotFoundError, 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<{

package/dist/groups/permission.js

@@ -5,7 +5,7 @@ import { PermissionSaved } from "@opencode/schema/permission-saved";
 import { Project } from "@opencode/schema/project";
 import { Session } from "@opencode/schema/session";
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
 import { LocationNotFoundError, PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const makePermissionGroup = (locationMiddleware, sessionLocationMiddleware) => HttpApiGroup.make("server.permission")

package/dist/groups/persistent-pty.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ForbiddenError, InvalidRequestError, PtyNotFoundError, ServiceUnavailableError } from "../errors.js";
 import { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER, PTY_CONNECT_TOKEN_HEADER_VALUE } from "./pty.js";
 export { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER, PTY_CONNECT_TOKEN_HEADER_VALUE };

package/dist/groups/persistent-pty.js

@@ -3,7 +3,7 @@ import { Pty } from "@opencode/schema/pty";
 import { PtyTicket } from "@opencode/schema/pty-ticket";
 import { Session } from "@opencode/schema/session";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ForbiddenError, InvalidRequestError, PtyNotFoundError, ServiceUnavailableError } from "../errors.js";
 import { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER, PTY_CONNECT_TOKEN_HEADER_VALUE } from "./pty.js";
 export { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER, PTY_CONNECT_TOKEN_HEADER_VALUE };

package/dist/groups/plugin.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 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<{

package/dist/groups/plugin.js

@@ -1,7 +1,7 @@
 import { Location } from "@opencode/schema/location";
 import { Plugin } from "@opencode/schema/plugin";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const PluginGroup = HttpApiGroup.make("server.plugin")

package/dist/groups/project.d.ts

@@ -1,7 +1,9 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { ProjectNotFoundError } from "../errors.js";
-export declare const ProjectGroup: HttpApiGroup.HttpApiGroup<"server.project", HttpApiEndpoint.HttpApiEndpoint<"project.list", "GET", "/api/project", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+export declare const ProjectGroup: HttpApiGroup.HttpApiGroup<"server.project", HttpApiEndpoint.HttpApiEndpoint<"project.list", "GET", "/api/project", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly archived: Schema.optional<Schema.decodeTo<Schema.Boolean, Schema.Literals<readonly ["true", "false"]>, never, never>>;
+}>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Project.ID"> & {
         global: string & import("effect/Brand").Brand<"Project.ID">;
     };
@@ -26,6 +28,7 @@ export declare const ProjectGroup: HttpApiGroup.HttpApiGroup<"server.project", H
         readonly created: Schema.Int;
         readonly updated: Schema.Int;
         readonly active: Schema.Int;
+        readonly archived: 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<{
@@ -74,6 +77,7 @@ export declare const ProjectGroup: HttpApiGroup.HttpApiGroup<"server.project", H
         readonly created: Schema.Int;
         readonly updated: Schema.Int;
         readonly active: Schema.Int;
+        readonly archived: 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>, false>;

package/dist/groups/project.js

@@ -1,16 +1,21 @@
 import { Project } from "@opencode/schema/project";
-import { Schema, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { Schema, SchemaGetter, Struct } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { ProjectNotFoundError } from "../errors.js";
 const root = "/api/project";
 const UpdatePayload = Schema.Struct(Struct.omit(Project.UpdateInput.fields, ["projectID"]));
+const BooleanFromString = Schema.Literals(["true", "false"]).pipe(Schema.decodeTo(Schema.Boolean, {
+    decode: SchemaGetter.transform((value) => value === "true"),
+    encode: SchemaGetter.transform((value) => (value ? "true" : "false")),
+}));
 export const ProjectGroup = HttpApiGroup.make("server.project")
     .add(HttpApiEndpoint.get("project.list", root, {
+    query: Schema.Struct({ archived: BooleanFromString.pipe(Schema.optional) }),
     success: Schema.Array(Project.Info),
 }).annotateMerge(OpenApi.annotations({
     identifier: "project.list",
     summary: "List projects",
-    description: "List known projects.",
+    description: "List known projects. Archived projects are excluded unless archived=true.",
 })))
     .add(HttpApiEndpoint.patch("project.update", `${root}/:projectID`, {
     params: { projectID: Project.ID },

package/dist/groups/provider.d.ts

@@ -1,6 +1,6 @@
 import { Provider } from "@opencode/schema/provider";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 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<{

package/dist/groups/provider.js

@@ -1,7 +1,7 @@
 import { Provider } from "@opencode/schema/provider";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { ProviderNotFoundError, ServiceUnavailableError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const ProviderGroup = HttpApiGroup.make("server.provider")

package/dist/groups/pty.d.ts

@@ -1,5 +1,5 @@
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
 import { ForbiddenError, LocationNotFoundError, PtyNotFoundError } from "../errors.js";
 export declare const PTY_CONNECT_TICKET_QUERY = "ticket";
 export declare const PTY_CONNECT_TOKEN_HEADER = "x-opencode-ticket";

package/dist/groups/pty.js

@@ -2,7 +2,7 @@ import { Pty } from "@opencode/schema/pty";
 import { PtyTicket } from "@opencode/schema/pty-ticket";
 import { Location } from "@opencode/schema/location";
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ForbiddenError, LocationNotFoundError, PtyNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const PTY_CONNECT_TICKET_QUERY = "ticket";

package/dist/groups/reference.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const ReferenceGroup: HttpApiGroup.HttpApiGroup<"server.reference", HttpApiEndpoint.HttpApiEndpoint<"reference.list", "GET", "/api/reference", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;

package/dist/groups/reference.js

@@ -1,7 +1,7 @@
 import { Location } from "@opencode/schema/location";
 import { Reference } from "@opencode/schema/reference";
 import { Schema, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 const PublicLocalSource = Schema.Struct(Struct.omit(Reference.LocalSource.fields, ["description", "hidden"])).annotate({
     identifier: "Reference.LocalSource",

package/dist/groups/rpc.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { RpcError, RpcInternalError } from "../errors.js";
 export declare const RpcInput: Schema.Struct<{
     readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;

package/dist/groups/rpc.js

@@ -1,6 +1,6 @@
 import { optional } from "@opencode/schema/schema";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { RpcError, RpcInternalError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const RpcInput = Schema.Struct({ input: optional(Schema.Unknown) }).annotate({ identifier: "Rpc.Input" });

package/dist/groups/server.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { UnauthorizedError } from "../errors.js";
 export declare const ServerInfo: Schema.Struct<{
     readonly version: Schema.String;

package/dist/groups/server.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { UnauthorizedError } from "../errors.js";
 export const ServerInfo = Schema.Struct({
     version: Schema.String,

package/dist/groups/session.d.ts

@@ -2,7 +2,7 @@ import { PromptInput } from "@opencode/schema/prompt-input";
 import { InstructionEntry } from "@opencode/schema/instruction-entry";
 import { Event } from "@opencode/schema/event";
 import { Context, Effect, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
 import { ConflictError, LocationNotFoundError, CommandExecutionError, CommandNotFoundError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError, InvalidCursorError, InvalidRequestError, MessageNotFoundError, ServiceUnavailableError, SessionBusyError, SessionNotFoundError, SkillNotFoundError, UnknownError } from "../errors.js";
 declare const SessionsCursorInput: Schema.Union<readonly [Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -96,7 +96,40 @@ export declare const SessionsQuery: Schema.Struct<{
         global: string & import("effect/Brand").Brand<"Project.ID">;
     }>;
     readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
-    readonly cursor: Schema.optional<Schema.brand<Schema.String, "SessionsCursor">>;
+    readonly cursor: Schema.optional<Schema.brand<Schema.String, "SessionsCursor"> & {
+        make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
+        parse: (input: string) => Effect.Effect<{
+            readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+            readonly anchor: {
+                readonly id: string & import("effect/Brand").Brand<"SessionID">;
+                readonly time: number;
+                readonly direction: "previous" | "next";
+            };
+            readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+            readonly search?: string | undefined;
+            readonly order?: "asc" | "desc" | undefined;
+        } | {
+            readonly project: string & import("effect/Brand").Brand<"Project.ID">;
+            readonly anchor: {
+                readonly id: string & import("effect/Brand").Brand<"SessionID">;
+                readonly time: number;
+                readonly direction: "previous" | "next";
+            };
+            readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
+            readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+            readonly search?: string | undefined;
+            readonly order?: "asc" | "desc" | undefined;
+        } | {
+            readonly anchor: {
+                readonly id: string & import("effect/Brand").Brand<"SessionID">;
+                readonly time: number;
+                readonly direction: "previous" | "next";
+            };
+            readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+            readonly search?: string | undefined;
+            readonly order?: "asc" | "desc" | undefined;
+        }, "Invalid cursor", never>;
+    }>;
     readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
     readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
     readonly search: Schema.optional<Schema.String>;
@@ -111,7 +144,40 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
         global: string & import("effect/Brand").Brand<"Project.ID">;
     }>;
     readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
-    readonly cursor: Schema.optional<Schema.brand<Schema.String, "SessionsCursor">>;
+    readonly cursor: Schema.optional<Schema.brand<Schema.String, "SessionsCursor"> & {
+        make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
+        parse: (input: string) => Effect.Effect<{
+            readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+            readonly anchor: {
+                readonly id: string & import("effect/Brand").Brand<"SessionID">;
+                readonly time: number;
+                readonly direction: "previous" | "next";
+            };
+            readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+            readonly search?: string | undefined;
+            readonly order?: "asc" | "desc" | undefined;
+        } | {
+            readonly project: string & import("effect/Brand").Brand<"Project.ID">;
+            readonly anchor: {
+                readonly id: string & import("effect/Brand").Brand<"SessionID">;
+                readonly time: number;
+                readonly direction: "previous" | "next";
+            };
+            readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
+            readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+            readonly search?: string | undefined;
+            readonly order?: "asc" | "desc" | undefined;
+        } | {
+            readonly anchor: {
+                readonly id: string & import("effect/Brand").Brand<"SessionID">;
+                readonly time: number;
+                readonly direction: "previous" | "next";
+            };
+            readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+            readonly search?: string | undefined;
+            readonly order?: "asc" | "desc" | undefined;
+        }, "Invalid cursor", never>;
+    }>;
     readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
     readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
     readonly search: Schema.optional<Schema.String>;
@@ -1575,6 +1641,25 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
     }>]>, Schema.Struct<{
         readonly type: Schema.tag<"idle">;
         readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>, never, never>;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
             fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -2654,6 +2739,25 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
         }>]>, Schema.Struct<{
             readonly type: Schema.tag<"idle">;
             readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+            readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly type: Schema.String;
+                readonly message: Schema.String;
+                readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+                readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                    readonly body: Schema.String;
+                }>>>, Schema.optionalKey<Schema.Struct<{
+                    readonly body: Schema.String;
+                }>>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly type: Schema.String;
+                readonly message: Schema.String;
+                readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+                readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                    readonly body: Schema.String;
+                }>>>, Schema.optionalKey<Schema.Struct<{
+                    readonly body: Schema.String;
+                }>>, never, never>;
+            }>>, never, never>;
             readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
                 fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -4307,6 +4411,25 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
     }>]>, Schema.Struct<{
         readonly type: Schema.tag<"idle">;
         readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>, never, never>;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
             fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -10893,6 +11016,25 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
     }>]>, Schema.Struct<{
         readonly type: Schema.tag<"idle">;
         readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>, never, never>;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
             fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/groups/session.js

@@ -7,8 +7,9 @@ import { InstructionEntry } from "@opencode/schema/instruction-entry";
 import { Project } from "@opencode/schema/project";
 import { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, PositiveInt, RelativePath, statics, } from "@opencode/schema/schema";
 import { Event } from "@opencode/schema/event";
-import { Context, Effect, Encoding, Result, Schema, SchemaGetter, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { Context, Effect, Result, Schema, SchemaGetter, SchemaParser, Struct } from "effect";
+import { Base64Url } from "effect/encoding";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ConflictError, LocationNotFoundError, CommandExecutionError, CommandNotFoundError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError, InvalidCursorError, InvalidRequestError, MessageNotFoundError, ServiceUnavailableError, SessionBusyError, SessionNotFoundError, SkillNotFoundError, UnknownError, } from "../errors.js";
 import { Agent } from "@opencode/schema/agent";
 import { Skill } from "@opencode/schema/skill";
@@ -62,12 +63,16 @@ const SessionsCursorJson = Schema.fromJsonString(SessionsCursorInput);
 const encodeSessionsCursor = Schema.encodeSync(SessionsCursorJson);
 const decodeSessionsCursor = Schema.decodeUnknownEffect(SessionsCursorJson);
 const invalidCursor = "Invalid cursor";
-export const SessionsCursor = Schema.String.pipe(Schema.brand("SessionsCursor"), statics((schema) => {
-    const make = schema.make.bind(schema);
+export const SessionsCursor = Schema.String.pipe(Schema.brand("SessionsCursor"), Schema.annotate({
+    identifier: "SessionsCursor",
+    description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
+}), statics((schema) => {
+    // Read the default constructor without caching it on the schema, so `make` can be replaced.
+    const make = SchemaParser.make(schema);
     return {
-        make: (input) => make(Encoding.encodeBase64Url(encodeSessionsCursor(input))),
+        make: (input) => make(Base64Url.encode(encodeSessionsCursor(input))),
         parse: (input) => Effect.suspend(() => {
-            const result = Encoding.decodeBase64UrlString(input);
+            const result = Base64Url.decodeString(input);
             return Result.isFailure(result)
                 ? Effect.fail(invalidCursor)
                 : decodeSessionsCursor(result.success).pipe(Effect.mapError(() => invalidCursor));
@@ -109,15 +114,12 @@ const BooleanFromString = Schema.Literals(["true", "false"]).pipe(Schema.decodeT
     decode: SchemaGetter.transform((value) => value === "true"),
     encode: SchemaGetter.transform((value) => (value ? "true" : "false")),
 }));
-const SessionsQueryCursor = SessionsCursor.annotate({
-    description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
-});
 export const SessionsQuery = Schema.Struct({
     ...SessionsQueryFields,
     directory: AbsolutePath.pipe(Schema.optional),
     project: Project.ID.pipe(Schema.optional),
     subpath: RelativePath.pipe(Schema.optional),
-    cursor: SessionsQueryCursor.pipe(Schema.optional),
+    cursor: SessionsCursor.pipe(Schema.optional),
 }).annotate({ identifier: "SessionsQuery" });
 export const makeSessionGroup = (sessionLocationMiddleware, formLocationMiddleware) => HttpApiGroup.make("server.session")
     .add(HttpApiEndpoint.get("session.list", "/api/session", {

package/dist/groups/shell.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ShellNotFoundError } from "../errors.js";
 export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpApiEndpoint.HttpApiEndpoint<"shell.list", "GET", "/api/shell", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/shell.js

@@ -1,7 +1,7 @@
 import { Shell } from "@opencode/schema/shell";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ShellNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const ShellGroup = HttpApiGroup.make("server.shell")

package/dist/groups/skill.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const SkillGroup: HttpApiGroup.HttpApiGroup<"server.skill", HttpApiEndpoint.HttpApiEndpoint<"skill.list", "GET", "/api/skill", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;

package/dist/groups/skill.js

@@ -1,7 +1,7 @@
 import { Skill } from "@opencode/schema/skill";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const SkillGroup = HttpApiGroup.make("server.skill")
     .add(HttpApiEndpoint.get("skill.list", "/api/skill", {

package/dist/groups/vcs.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ConflictError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 declare const VcsInitNotSupportedError_base: Schema.Class<VcsInitNotSupportedError, Schema.TaggedStruct<"VcsInitNotSupportedError", {
     readonly providerID: Schema.String;

package/dist/groups/vcs.js

@@ -3,7 +3,7 @@ import { Location } from "@opencode/schema/location";
 import { NonNegativeInt, PositiveInt, optional } from "@opencode/schema/schema";
 import { Vcs } from "@opencode/schema/vcs";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 import { ConflictError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 const InitQuery = Schema.Struct({

package/dist/groups/websearch.d.ts

@@ -1,6 +1,6 @@
 import { WebSearch } from "@opencode/schema/websearch";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export declare const WebSearchGroup: HttpApiGroup.HttpApiGroup<"server.websearch", HttpApiEndpoint.HttpApiEndpoint<"websearch.providers", "GET", "/api/websearch/provider", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/websearch.js

@@ -1,7 +1,7 @@
 import { Location } from "@opencode/schema/location";
 import { WebSearch } from "@opencode/schema/websearch";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const WebSearchGroup = HttpApiGroup.make("server.websearch")

package/dist/groups/worktree.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ProjectNotFoundError } from "../errors.js";
 declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.TaggedStruct<"WorktreeError", {
     readonly name: Schema.Literal<"WorktreeError">;

package/dist/groups/worktree.js

@@ -1,6 +1,6 @@
 import { Worktree } from "@opencode/schema/worktree";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { Project } from "@opencode/schema/project";
 import { ProjectNotFoundError } from "../errors.js";
 const root = "/api/worktree";

package/dist/middleware/authorization.d.ts

@@ -1,4 +1,4 @@
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import { UnauthorizedError } from "../errors.js";
 declare const Authorization_base: HttpApiMiddleware.ServiceClass<Authorization, "@opencode/HttpApiAuthorization", {
     requires: never;

package/dist/middleware/authorization.js

@@ -1,4 +1,4 @@
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import { UnauthorizedError } from "../errors.js";
 export class Authorization extends HttpApiMiddleware.Service()("@opencode/HttpApiAuthorization", {
     error: UnauthorizedError,

package/dist/middleware/schema-error.d.ts

@@ -1,4 +1,4 @@
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import { InvalidRequestError } from "../errors.js";
 declare const SchemaErrorMiddleware_base: HttpApiMiddleware.ServiceClass<SchemaErrorMiddleware, "@opencode/HttpApiSchemaError", {
     requires: never;

package/dist/middleware/schema-error.js

@@ -1,4 +1,4 @@
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import { InvalidRequestError } from "../errors.js";
 export class SchemaErrorMiddleware extends HttpApiMiddleware.Service()("@opencode/HttpApiSchemaError", { error: InvalidRequestError }) {
 }

package/dist/simulation.d.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { Rpc, RpcGroup } from "effect/unstable/rpc";
+import { Rpc, RpcGroup } from "effect/rpc";
 export declare namespace JsonRpc {
     const RequestFields: {
         jsonrpc: Schema.Literal<"2.0">;

package/dist/simulation.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { Rpc, RpcGroup } from "effect/unstable/rpc";
+import { Rpc, RpcGroup } from "effect/rpc";
 const JsonRpcID = Schema.Union([Schema.String, Schema.Number, Schema.Null]);
 const decodeJson = Schema.decodeUnknownSync(Schema.Json);
 export var JsonRpc;

package/package.json

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