@opencode/protocol 2.0.21 → 2.0.23

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { InvalidRequestError, SessionNotFoundError } from "./errors.js";
+import { LocationNotFoundError, InvalidRequestError, SessionNotFoundError } from "./errors.js";
 import type { Api } from "./api.js";
 import type { Context } from "effect";
 import { HttpApiMiddleware } from "effect/unstable/httpapi";
@@ -6,21 +6,21 @@ import type { EventGroup } from "./groups/event.js";
 declare const LocationMiddleware_base: HttpApiMiddleware.ServiceClass<LocationMiddleware, "@opencode/client/LocationMiddleware", {
     requires: never;
     provides: never;
-    error: never;
+    error: readonly [typeof LocationNotFoundError];
     clientError: never;
     requiredForClient: false;
     security: never;
-}, HttpApiMiddleware.HttpApiMiddleware<never, never, never>>;
+}, HttpApiMiddleware.HttpApiMiddleware<never, readonly [typeof LocationNotFoundError], never>>;
 declare class LocationMiddleware extends LocationMiddleware_base {
 }
 declare const SessionLocationMiddleware_base: HttpApiMiddleware.ServiceClass<SessionLocationMiddleware, "@opencode/client/SessionLocationMiddleware", {
     requires: never;
     provides: never;
-    error: readonly [typeof InvalidRequestError, typeof SessionNotFoundError];
+    error: readonly [typeof InvalidRequestError, typeof SessionNotFoundError, typeof LocationNotFoundError];
     clientError: never;
     requiredForClient: false;
     security: never;
-}, HttpApiMiddleware.HttpApiMiddleware<never, readonly [typeof InvalidRequestError, typeof SessionNotFoundError], never>>;
+}, HttpApiMiddleware.HttpApiMiddleware<never, readonly [typeof InvalidRequestError, typeof SessionNotFoundError, typeof LocationNotFoundError], never>>;
 declare class SessionLocationMiddleware extends SessionLocationMiddleware_base {
 }
 type ClientApiShape = Api<Context.Service.Identifier<typeof LocationMiddleware>, Context.Service.Shape<typeof LocationMiddleware>, Context.Service.Identifier<typeof SessionLocationMiddleware>, Context.Service.Shape<typeof SessionLocationMiddleware>, Context.Service.Identifier<typeof SessionLocationMiddleware>, Context.Service.Shape<typeof SessionLocationMiddleware>, typeof EventGroup>;

package/dist/client.js

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

package/dist/errors.d.ts

@@ -1,4 +1,12 @@
 import { Schema } from "effect";
+declare const LocationNotFoundError_base: Schema.Class<LocationNotFoundError, Schema.TaggedStruct<"LocationNotFoundError", {
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class LocationNotFoundError extends LocationNotFoundError_base {
+}
 declare const InvalidRequestError_base: Schema.Class<InvalidRequestError, Schema.TaggedStruct<"InvalidRequestError", {
     readonly message: Schema.String;
     readonly kind: Schema.optional<Schema.String>;

package/dist/errors.js

@@ -1,5 +1,8 @@
 import { Schema } from "effect";
 import { Skill } from "@opencode/schema/skill";
+import { Location } from "@opencode/schema/location";
+export class LocationNotFoundError extends Schema.TaggedError()("LocationNotFoundError", { location: Location.PublicRef, message: Schema.String }, { httpApiStatus: 404 }) {
+}
 export class InvalidRequestError extends Schema.TaggedError()("InvalidRequestError", {
     message: Schema.String,
     kind: Schema.optional(Schema.String),

package/dist/groups/agent.d.ts

@@ -61,7 +61,8 @@ export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", HttpA
         readonly request: Schema.Struct<{
             readonly settings: Schema.withConstructorDefault<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 chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, 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>;
+                readonly chunkTimeout: 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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                     readonly type: Schema.Literal<"summary">;
                 }>, Schema.Struct<{
@@ -170,7 +171,8 @@ export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", HttpA
         readonly request: Schema.Struct<{
             readonly settings: Schema.withConstructorDefault<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 chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, 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>;
+                readonly chunkTimeout: 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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                     readonly type: Schema.Literal<"summary">;
                 }>, Schema.Struct<{

package/dist/groups/generate.d.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
-import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+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;
     readonly model: Schema.optional<Schema.Struct<{
@@ -30,4 +30,4 @@ export declare const GenerateGroup: HttpApiGroup.HttpApiGroup<"server.generate",
     readonly data: Schema.Struct<{
         readonly text: Schema.String;
     }>;
-}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never>, false>;
+}>>, Schema.toCodecJson<typeof LocationNotFoundError | typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/generate.js

@@ -1,7 +1,7 @@
 import { Model } from "@opencode/schema/model";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
-import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+import { LocationNotFoundError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export const GenerateGroup = HttpApiGroup.make("server.generate")
     .add(HttpApiEndpoint.post("generate.text", "/api/experimental/generate", {
     payload: Schema.Struct({
@@ -11,7 +11,7 @@ export const GenerateGroup = HttpApiGroup.make("server.generate")
     success: Schema.Struct({
         data: Schema.Struct({ text: Schema.String }),
     }).annotate({ identifier: "GenerateTextResponse" }),
-    error: [InvalidRequestError, ServiceUnavailableError],
+    error: [InvalidRequestError, ServiceUnavailableError, LocationNotFoundError],
 }).annotateMerge(OpenApi.annotations({
     identifier: "experimental.generate.text",
     summary: "Generate text",

package/dist/groups/permission.d.ts

@@ -1,6 +1,6 @@
 import { Context, Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
-import { PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
+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<{
         readonly directory: Schema.optional<Schema.String>;
@@ -114,7 +114,7 @@ export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.
             create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
         };
     }>>;
-}>>, Schema.toCodecJson<typeof SessionNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.get", "GET", "/api/session/:sessionID/permission/:requestID", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof LocationNotFoundError | typeof SessionNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.get", "GET", "/api/session/:sessionID/permission/:requestID", Schema.toCodecStringTree<Schema.Struct<{
     sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;

package/dist/groups/permission.js

@@ -6,7 +6,7 @@ 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 { PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
+import { LocationNotFoundError, PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const makePermissionGroup = (locationMiddleware, sessionLocationMiddleware) => HttpApiGroup.make("server.permission")
     .add(HttpApiEndpoint.get("permission.request.list", "/api/permission/request", {
@@ -62,7 +62,7 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
     .add(HttpApiEndpoint.get("session.permission.list", "/api/session/:sessionID/permission", {
     params: { sessionID: Session.ID },
     success: Schema.Struct({ data: Schema.Array(Permission.Request) }),
-    error: SessionNotFoundError,
+    error: [SessionNotFoundError, LocationNotFoundError],
 }).annotateMerge(OpenApi.annotations({
     identifier: "session.permission.list",
     summary: "List session permission requests",

package/dist/groups/provider.d.ts

@@ -13,7 +13,8 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
     readonly data: Schema.$Array<Schema.Struct<{
         readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<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 chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, 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>;
+            readonly chunkTimeout: 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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
             }>, Schema.Struct<{
@@ -26,7 +27,8 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
             readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, 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 chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, 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>;
+            readonly chunkTimeout: 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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
             }>, Schema.Struct<{
@@ -110,7 +112,8 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
     readonly data: Schema.Struct<{
         readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<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 chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, 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>;
+            readonly chunkTimeout: 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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
             }>, Schema.Struct<{
@@ -123,7 +126,8 @@ export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider",
             readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, 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 chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, 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>;
+            readonly chunkTimeout: 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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
             }>, Schema.Struct<{

package/dist/groups/server.d.ts

@@ -8,6 +8,9 @@ export declare const ServerInfo: Schema.Struct<{
     readonly paths: Schema.Struct<{
         readonly tmp: Schema.String;
     }>;
+    readonly capabilities: Schema.optional<Schema.Struct<{
+        readonly persistentPty: Schema.optional<Schema.Boolean>;
+    }>>;
 }>;
 export type ServerInfo = typeof ServerInfo.Type;
 export declare const PairingCode: Schema.Struct<{
@@ -27,6 +30,9 @@ export declare const ServerGroup: HttpApiGroup.HttpApiGroup<"server.server", Htt
     readonly paths: Schema.Struct<{
         readonly tmp: Schema.String;
     }>;
+    readonly capabilities: Schema.optional<Schema.Struct<{
+        readonly persistentPty: Schema.optional<Schema.Boolean>;
+    }>>;
 }>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"server.pair", "POST", "/api/pair", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly code: Schema.String;
     readonly expires_in: Schema.Int;

package/dist/groups/server.js

@@ -9,6 +9,10 @@ export const ServerInfo = Schema.Struct({
     paths: Schema.Struct({
         tmp: Schema.String,
     }),
+    // Optional at every level so clients still decode servers that predate a capability.
+    capabilities: Schema.optional(Schema.Struct({
+        persistentPty: Schema.optional(Schema.Boolean),
+    })),
 }).annotate({ identifier: "ServerInfo" });
 export const PairingCode = Schema.Struct({
     code: Schema.String,

package/dist/groups/session.d.ts

@@ -3,8 +3,7 @@ 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 { ConflictError, CommandExecutionError, CommandNotFoundError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError, InvalidCursorError, InvalidRequestError, MessageNotFoundError, ServiceUnavailableError, SessionBusyError, SessionNotFoundError, SkillNotFoundError, UnknownError } from "../errors.js";
-import { SessionEvent } from "@opencode/schema/session-event";
+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">;
     readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
@@ -473,6 +472,10 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>;
+    readonly parentID: Schema.optional<Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }>;
     readonly title: Schema.optional<Schema.String>;
     readonly agent: Schema.optional<Schema.brand<Schema.String, "Agent.ID">>;
     readonly model: Schema.optional<Schema.Struct<{
@@ -683,7 +686,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
             }>]>;
         }>>, never, never>;
     }>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.import", "POST", "/api/experimental/session/import", never, never, Schema.toCodecJson<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof SessionNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.import", "POST", "/api/experimental/session/import", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>>;
@@ -1005,7 +1008,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                 readonly text: Schema.String;
             }>>, never, never>;
         }> & {
-            create: (input: SessionEvent.FileAttachment) => {
+            create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
                 readonly source: {
                     readonly type: "inline";
@@ -1043,7 +1046,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                 readonly text: Schema.String;
             }>>, never, never>;
         }> & {
-            create: (input: SessionEvent.FileAttachment) => {
+            create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
                 readonly source: {
                     readonly type: "inline";
@@ -2084,7 +2087,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                     readonly text: Schema.String;
                 }>>, never, never>;
             }> & {
-                create: (input: SessionEvent.FileAttachment) => {
+                create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                     readonly data: string;
                     readonly source: {
                         readonly type: "inline";
@@ -2122,7 +2125,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                     readonly text: Schema.String;
                 }>>, never, never>;
             }> & {
-                create: (input: SessionEvent.FileAttachment) => {
+                create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                     readonly data: string;
                     readonly source: {
                         readonly type: "inline";
@@ -3233,7 +3236,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                     readonly text: Schema.String;
                 }>>, never, never>;
             }> & {
-                create: (input: SessionEvent.FileAttachment) => {
+                create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                     readonly data: string;
                     readonly source: {
                         readonly type: "inline";
@@ -3271,7 +3274,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                     readonly text: Schema.String;
                 }>>, never, never>;
             }> & {
-                create: (input: SessionEvent.FileAttachment) => {
+                create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                     readonly data: string;
                     readonly source: {
                         readonly type: "inline";
@@ -3737,7 +3740,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                 readonly text: Schema.String;
             }>>, never, never>;
         }> & {
-            create: (input: SessionEvent.FileAttachment) => {
+            create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
                 readonly source: {
                     readonly type: "inline";
@@ -3775,7 +3778,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                 readonly text: Schema.String;
             }>>, never, never>;
         }> & {
-            create: (input: SessionEvent.FileAttachment) => {
+            create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
                 readonly source: {
                     readonly type: "inline";
@@ -4336,7 +4339,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
         readonly deletions: Schema.Int;
         readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
     }>>;
-}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof UnknownError | typeof SessionNotFoundError | typeof MessageNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.inbox.list", "GET", "/api/session/:sessionID/inbox", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof LocationNotFoundError | typeof InvalidRequestError | typeof UnknownError | typeof SessionNotFoundError | typeof MessageNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.inbox.list", "GET", "/api/session/:sessionID/inbox", Schema.toCodecStringTree<Schema.Struct<{
     sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -4368,7 +4371,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                     readonly text: Schema.String;
                 }>>, never, never>;
             }> & {
-                create: (input: SessionEvent.FileAttachment) => {
+                create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                     readonly data: string;
                     readonly source: {
                         readonly type: "inline";
@@ -4406,7 +4409,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                     readonly text: Schema.String;
                 }>>, never, never>;
             }> & {
-                create: (input: SessionEvent.FileAttachment) => {
+                create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                     readonly data: string;
                     readonly source: {
                         readonly type: "inline";
@@ -5622,7 +5625,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                         readonly text: Schema.String;
                     }>>, never, never>;
                 }> & {
-                    create: (input: SessionEvent.FileAttachment) => {
+                    create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                         readonly data: string;
                         readonly source: {
                             readonly type: "inline";
@@ -5660,7 +5663,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                         readonly text: Schema.String;
                     }>>, never, never>;
                 }> & {
-                    create: (input: SessionEvent.FileAttachment) => {
+                    create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                         readonly data: string;
                         readonly source: {
                             readonly type: "inline";
@@ -5805,7 +5808,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                         readonly text: Schema.String;
                     }>>, never, never>;
                 }> & {
-                    create: (input: SessionEvent.FileAttachment) => {
+                    create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                         readonly data: string;
                         readonly source: {
                             readonly type: "inline";
@@ -5843,7 +5846,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                         readonly text: Schema.String;
                     }>>, never, never>;
                 }> & {
-                    create: (input: SessionEvent.FileAttachment) => {
+                    create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                         readonly data: string;
                         readonly source: {
                             readonly type: "inline";
@@ -10323,7 +10326,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                 readonly text: Schema.String;
             }>>, never, never>;
         }> & {
-            create: (input: SessionEvent.FileAttachment) => {
+            create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
                 readonly source: {
                     readonly type: "inline";
@@ -10361,7 +10364,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
                 readonly text: Schema.String;
             }>>, never, never>;
         }> & {
-            create: (input: SessionEvent.FileAttachment) => {
+            create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
                 readonly source: {
                     readonly type: "inline";

package/dist/groups/session.js

@@ -9,7 +9,7 @@ import { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, PositiveInt, Relat
 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 { ConflictError, CommandExecutionError, CommandNotFoundError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError, InvalidCursorError, InvalidRequestError, MessageNotFoundError, ServiceUnavailableError, SessionBusyError, SessionNotFoundError, SkillNotFoundError, UnknownError, } from "../errors.js";
+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";
 import { Model } from "@opencode/schema/model";
@@ -153,6 +153,7 @@ export const makeSessionGroup = (sessionLocationMiddleware, formLocationMiddlewa
     .add(HttpApiEndpoint.post("session.create", "/api/session", {
     payload: Schema.Struct({
         id: Session.ID.pipe(Schema.optional),
+        parentID: Session.ID.pipe(Schema.optional),
         title: Schema.String.pipe(Schema.optional),
         agent: Agent.ID.pipe(Schema.optional),
         model: Model.Ref.pipe(Schema.optional),
@@ -161,10 +162,11 @@ export const makeSessionGroup = (sessionLocationMiddleware, formLocationMiddlewa
         permissions: Permission.Ruleset.pipe(Schema.optional),
     }),
     success: Schema.Struct({ data: PublicSessionInfo }),
+    error: SessionNotFoundError,
 }).annotateMerge(OpenApi.annotations({
     identifier: "session.create",
     summary: "Create session",
-    description: "Create a session at the requested location.",
+    description: "Create a session at the requested location. A parentID creates a linked child session at its parent's location.",
 })))
     .add(HttpApiEndpoint.post("session.import", "/api/experimental/session/import", {
     payload: Schema.Struct({
@@ -433,7 +435,7 @@ export const makeSessionGroup = (sessionLocationMiddleware, formLocationMiddlewa
         }),
     }),
     success: Schema.Struct({ data: Schema.Array(FileDiff.Info) }),
-    error: [InvalidRequestError, MessageNotFoundError, SessionNotFoundError, UnknownError],
+    error: [InvalidRequestError, MessageNotFoundError, SessionNotFoundError, UnknownError, LocationNotFoundError],
 }).annotateMerge(OpenApi.annotations({
     identifier: "session.diff",
     summary: "Diff session turns",

package/dist/groups/vcs.d.ts

@@ -1,7 +1,18 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
-import { ServiceUnavailableError } from "../errors.js";
-export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEndpoint.HttpApiEndpoint<"vcs.get", "GET", "/api/vcs", never, Schema.toCodecStringTree<Schema.Struct<{
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { ConflictError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+declare const VcsInitNotSupportedError_base: Schema.Class<VcsInitNotSupportedError, Schema.TaggedStruct<"VcsInitNotSupportedError", {
+    readonly providerID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class VcsInitNotSupportedError extends VcsInitNotSupportedError_base {
+}
+export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEndpoint.HttpApiEndpoint<"vcs.init", "POST", "/api/vcs/init", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly provider: Schema.optional<Schema.String>;
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError | typeof ConflictError | typeof ServiceUnavailableError | typeof VcsInitNotSupportedError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.get", "GET", "/api/vcs", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
@@ -73,3 +84,4 @@ export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEn
         readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
     }>>;
 }>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never>, false>;
+export {};

package/dist/groups/vcs.js

@@ -3,9 +3,15 @@ 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, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
-import { ServiceUnavailableError } from "../errors.js";
+import { ConflictError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+const InitQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    provider: Schema.optional(Schema.String),
+});
+export class VcsInitNotSupportedError extends Schema.TaggedError()("VcsInitNotSupportedError", { providerID: Schema.String, message: Schema.String }, { httpApiStatus: 501 }) {
+}
 const BranchesQuery = Schema.Struct({
     ...LocationQuery.fields,
     search: Schema.optional(Schema.String),
@@ -18,6 +24,17 @@ const DiffQuery = Schema.Struct({
     context: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional),
 });
 export const VcsGroup = HttpApiGroup.make("server.vcs")
+    .add(HttpApiEndpoint.post("vcs.init", "/api/vcs/init", {
+    query: InitQuery,
+    success: HttpApiSchema.NoContent,
+    error: [ConflictError, InvalidRequestError, VcsInitNotSupportedError, ServiceUnavailableError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "vcs.init",
+    summary: "Initialize VCS repository",
+    description: "Initialize a repository using the selected VCS provider in a markerless project's directory and refresh its location services. Omitting provider defaults to git; built-in git and hg providers support initialization. An unknown provider returns 400; a registered provider without init returns 501.",
+})))
     .add(HttpApiEndpoint.get("vcs.get", "/api/vcs", {
     query: LocationQuery,
     success: Location.response(Vcs.Info),

package/dist/groups/worktree.d.ts

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

package/dist/groups/worktree.js

@@ -4,7 +4,7 @@ import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/un
 import { Project } from "@opencode/schema/project";
 import { ProjectNotFoundError } from "../errors.js";
 const root = "/api/worktree";
-export class WorktreeError extends Schema.Error("WorktreeError")({
+export class WorktreeError extends Schema.TaggedError()("WorktreeError", {
     name: Schema.Literal("WorktreeError"),
     data: Schema.Struct({
         message: Schema.String,

package/package.json

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