@opencode/protocol 2.0.26 → 2.0.28

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<{
@@ -73,6 +73,7 @@ export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", HttpA
                     readonly type: Schema.Literal<"native">;
                 }>]>>, never, never>;
                 readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
             }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>;
             readonly headers: Schema.$Record<Schema.String, Schema.String>;
             readonly body: Schema.$Record<Schema.String, Schema.Any>;
@@ -183,6 +184,7 @@ export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", HttpA
                     readonly type: Schema.Literal<"native">;
                 }>]>>, never, never>;
                 readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
             }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>;
             readonly headers: Schema.$Record<Schema.String, Schema.String>;
             readonly body: Schema.$Record<Schema.String, Schema.Any>;

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<{
@@ -33,6 +33,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
                 }>, Schema.Struct<{
                     readonly type: Schema.Literal<"native">;
                 }>]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
             }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
                 readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                     readonly type: Schema.Literal<"summary">;
@@ -43,6 +44,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
                 }>, Schema.Struct<{
                     readonly type: Schema.Literal<"native">;
                 }>]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
             }>, readonly [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>;
             readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
@@ -91,6 +93,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
         }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
             readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
@@ -101,6 +104,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
         }>, readonly [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>;
         readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
@@ -153,6 +157,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             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>;
+            readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
             readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>>, Schema.optionalKey<Schema.Struct<{
@@ -162,6 +167,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             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>;
+            readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
             readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>, never, never>;
@@ -221,6 +227,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
                 }>, Schema.Struct<{
                     readonly type: Schema.Literal<"native">;
                 }>]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
             }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
                 readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                     readonly type: Schema.Literal<"summary">;
@@ -231,6 +238,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
                 }>, Schema.Struct<{
                     readonly type: Schema.Literal<"native">;
                 }>]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
             }>, readonly [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>;
             readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
@@ -279,6 +287,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
         }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
             readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
@@ -289,6 +298,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
         }>, readonly [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>;
         readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
@@ -341,6 +351,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             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>;
+            readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
             readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>>, Schema.optionalKey<Schema.Struct<{
@@ -350,6 +361,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             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>;
+            readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
             readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>, never, never>;