@opencode/protocol 2.0.26 → 2.0.28

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<{
@@ -25,6 +25,7 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
                 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>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
             readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
             readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
@@ -39,6 +40,7 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
                 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>]>>, 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>;
@@ -84,6 +86,23 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
         readonly name: Schema.String;
         readonly activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
         readonly package: Schema.String;
+        readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("@opencode/schema/model-compatibility").ReasoningField, import("@opencode/schema/model-compatibility").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("@opencode/schema/model-compatibility").ReasoningField, import("@opencode/schema/model-compatibility").ReasoningField, never, never>>, never, never>;
+            readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+            readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("@opencode/schema/model-compatibility").ReasoningField, import("@opencode/schema/model-compatibility").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("@opencode/schema/model-compatibility").ReasoningField, import("@opencode/schema/model-compatibility").ReasoningField, never, never>>, never, never>;
+            readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+            readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+        }>>, never, never>;
     }> & {
         empty: (id: Provider.ID) => Provider.Info;
     }>;
@@ -124,6 +143,7 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
                 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>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
             readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
             readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
@@ -138,6 +158,7 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
                 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>]>>, 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>;
@@ -183,6 +204,23 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
         readonly name: Schema.String;
         readonly activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
         readonly package: Schema.String;
+        readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("@opencode/schema/model-compatibility").ReasoningField, import("@opencode/schema/model-compatibility").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("@opencode/schema/model-compatibility").ReasoningField, import("@opencode/schema/model-compatibility").ReasoningField, never, never>>, never, never>;
+            readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+            readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("@opencode/schema/model-compatibility").ReasoningField, import("@opencode/schema/model-compatibility").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("@opencode/schema/model-compatibility").ReasoningField, import("@opencode/schema/model-compatibility").ReasoningField, never, never>>, never, never>;
+            readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+            readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+        }>>, never, never>;
     }> & {
         empty: (id: Provider.ID) => Provider.Info;
     };

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({