@opencode/protocol 2.0.31 → 2.1.0

package/dist/groups/session.js

@@ -5,10 +5,10 @@ import { Session } from "@opencode/schema/session";
 import { SessionStats } from "@opencode/schema/session-stats";
 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 { DateTimeUtcFromMillis, NonNegativeInt, PositiveInt } from "@opencode/schema/schema";
 import { Event } from "@opencode/schema/event";
-import { Context, Effect, Result, Schema, SchemaGetter, SchemaParser, Struct } from "effect";
-import { Base64Url } from "effect/encoding";
+import { SessionLegacy } from "@opencode/schema/session-legacy";
+import { Context, Schema, SchemaGetter, Struct } from "effect";
 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";
@@ -21,64 +21,6 @@ import { EventLog } from "@opencode/schema/event-log";
 import { FileDiff } from "@opencode/schema/file-diff";
 import { Form } from "@opencode/schema/form";
 import { PublicSessionMessage } from "./message.js";
-const ParentIDFilter = Schema.Union([
-    Session.ID,
-    Schema.Null.pipe(Schema.encodeTo(Schema.Literal("null"), {
-        decode: SchemaGetter.transform(() => null),
-        encode: SchemaGetter.transform(() => "null"),
-    })),
-]).annotate({
-    description: "Filter by parent session. Use null to return only root sessions.",
-});
-const SessionsQueryFields = {
-    limit: Schema.NumberFromString.pipe(Schema.decodeTo(PositiveInt), Schema.optional).annotate({
-        description: "Maximum number of sessions to return. Defaults to the newest 50 sessions.",
-    }),
-    order: Schema.optional(Schema.Union([Schema.Literal("asc"), Schema.Literal("desc")])).annotate({
-        description: "Session order for the first page. Use desc for newest first or asc for oldest first.",
-    }),
-    search: Schema.optional(Schema.String),
-    parentID: ParentIDFilter.pipe(Schema.optional),
-};
-const SessionsDirectoryQuery = Schema.Struct({
-    ...SessionsQueryFields,
-    directory: AbsolutePath,
-});
-const SessionsProjectQuery = Schema.Struct({
-    ...SessionsQueryFields,
-    project: Project.ID,
-    subpath: RelativePath.pipe(Schema.optional),
-});
-const SessionsAllQuery = Schema.Struct(SessionsQueryFields);
-const withCursor = (schema) => schema.mapFields((fields) => ({
-    ...Struct.omit(fields, ["limit"]),
-    anchor: Session.ListAnchor,
-}));
-const SessionsCursorInput = Schema.Union([
-    withCursor(SessionsDirectoryQuery),
-    withCursor(SessionsProjectQuery),
-    withCursor(SessionsAllQuery),
-]);
-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"), 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(Base64Url.encode(encodeSessionsCursor(input))),
-        parse: (input) => Effect.suspend(() => {
-            const result = Base64Url.decodeString(input);
-            return Result.isFailure(result)
-                ? Effect.fail(invalidCursor)
-                : decodeSessionsCursor(result.success).pipe(Effect.mapError(() => invalidCursor));
-        }),
-    };
-}));
 const SessionActive = Schema.Struct({
     type: Schema.Literal("running"),
 }).annotate({ identifier: "SessionActive" });
@@ -104,6 +46,15 @@ const PublicInboxInfo = Schema.Union([
     SessionInbox.Compaction,
     PublicMove,
 ]).annotate({ identifier: "Session.Inbox.Info" });
+// Transcripts exported before v2.1 carry older names for native data. The wire stays plain JSON so any export file
+// is accepted; decoding upgrades those names and then validates the current message shape.
+const ImportedMessages = Schema.Array(Schema.Json).pipe(Schema.decodeTo(Schema.Array(Schema.Unknown), {
+    decode: SchemaGetter.transform(SessionLegacy.messages),
+    encode: SchemaGetter.passthrough({ strict: false }),
+}), Schema.decodeTo(Schema.Array(PublicSessionMessage), {
+    decode: SchemaGetter.passthrough({ strict: false }),
+    encode: SchemaGetter.passthrough({ strict: false }),
+}));
 const FormCreatePayload = Schema.Struct({
     id: Form.ID.pipe(Schema.optional),
     title: Form.Info.fields.title,
@@ -114,12 +65,14 @@ const BooleanFromString = Schema.Literals(["true", "false"]).pipe(Schema.decodeT
     decode: SchemaGetter.transform((value) => value === "true"),
     encode: SchemaGetter.transform((value) => (value ? "true" : "false")),
 }));
+// Kept so existing imports of SessionsCursor from Protocol keep working.
+export const SessionsCursor = Session.ListCursor;
 export const SessionsQuery = Schema.Struct({
-    ...SessionsQueryFields,
-    directory: AbsolutePath.pipe(Schema.optional),
-    project: Project.ID.pipe(Schema.optional),
-    subpath: RelativePath.pipe(Schema.optional),
-    cursor: SessionsCursor.pipe(Schema.optional),
+    limit: Schema.NumberFromString.pipe(Schema.decodeTo(PositiveInt), Schema.optional).annotate({
+        description: "Maximum number of sessions to return. Defaults to the newest 50 sessions.",
+    }),
+    ...Session.ListFilter.fields,
+    cursor: Session.ListCursor.pipe(Schema.optional),
 }).annotate({ identifier: "SessionsQuery" });
 export const makeSessionGroup = (sessionLocationMiddleware, formLocationMiddleware) => HttpApiGroup.make("server.session")
     .add(HttpApiEndpoint.get("session.list", "/api/session", {
@@ -127,8 +80,8 @@ export const makeSessionGroup = (sessionLocationMiddleware, formLocationMiddlewa
     success: Schema.Struct({
         data: Schema.Array(PublicSessionInfo),
         cursor: Schema.Struct({
-            previous: SessionsCursor.pipe(Schema.optional),
-            next: SessionsCursor.pipe(Schema.optional),
+            previous: Session.ListCursor.pipe(Schema.optional),
+            next: Session.ListCursor.pipe(Schema.optional),
         }),
     }).annotate({ identifier: "SessionsResponse" }),
     error: [InvalidCursorError, InvalidRequestError],
@@ -172,7 +125,8 @@ export const makeSessionGroup = (sessionLocationMiddleware, formLocationMiddlewa
 })))
     .add(HttpApiEndpoint.post("session.import", "/api/experimental/session/import", {
     payload: Schema.Struct({
-        ...PublicSessionTransfer.fields,
+        info: PublicSessionTransfer.fields.info,
+        messages: ImportedMessages,
         location: Location.PublicRef.pipe(Schema.optional),
     }),
     success: Schema.Struct({ data: PublicSessionInfo }),
@@ -180,7 +134,7 @@ export const makeSessionGroup = (sessionLocationMiddleware, formLocationMiddlewa
 }).annotateMerge(OpenApi.annotations({
     identifier: "experimental.session.import",
     summary: "Import session",
-    description: "Import a projected session transcript at the requested location. If parentID is supplied, the parent session must already exist; import parents before children.",
+    description: "Import a projected session transcript at the requested location. Accepts transcripts exported by earlier releases. If parentID is supplied, the parent session must already exist; import parents before children.",
 })))
     .add(HttpApiEndpoint.get("session.export", "/api/experimental/session/:sessionID/export", {
     params: { sessionID: Session.ID },
@@ -259,6 +213,9 @@ export const makeSessionGroup = (sessionLocationMiddleware, formLocationMiddlewa
         title: Schema.String.pipe(Schema.optional),
         metadata: Session.Metadata.pipe(Schema.optional),
         permissions: Permission.Ruleset.pipe(Schema.optional),
+        archived: Schema.Boolean.pipe(Schema.optional).annotate({
+            description: "Archive the session with true or restore it with false. Repeating the current state is a no-op.",
+        }),
     }),
     success: HttpApiSchema.NoContent,
     error: SessionNotFoundError,

package/dist/groups/shell.d.ts

@@ -1,15 +1,20 @@
 import { Schema } from "effect";
 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<{
+export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpApiEndpoint.HttpApiEndpoint<"shell.create", "POST", "/api/shell", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly command: Schema.String;
+    readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly location: Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
-    readonly data: Schema.$Array<Schema.Struct<{
+    readonly data: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Shell.ID">;
             ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
@@ -27,17 +32,17 @@ export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpA
             readonly started: Schema.Finite;
             readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
         }>;
-    }>>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.create", "POST", "/api/shell", never, Schema.toCodecStringTree<Schema.Struct<{
+    }>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.get", "GET", "/api/shell/:id", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "Shell.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+    };
+}>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
-}>>, Schema.toCodecJson<Schema.Struct<{
-    readonly command: Schema.String;
-    readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
-    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly location: Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
@@ -60,12 +65,7 @@ export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpA
             readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
         }>;
     }>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.get", "GET", "/api/shell/:id", Schema.toCodecStringTree<Schema.Struct<{
-    id: Schema.brand<Schema.String, "Shell.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Shell.ID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
-    };
-}>>, Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ShellNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.list", "GET", "/api/shell", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
@@ -73,7 +73,7 @@ export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpA
     readonly location: Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
-    readonly data: Schema.Struct<{
+    readonly data: Schema.$Array<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Shell.ID">;
             ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
@@ -91,8 +91,8 @@ export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpA
             readonly started: Schema.Finite;
             readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
         }>;
-    }>;
-}>>, Schema.toCodecJson<typeof ShellNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.output", "GET", "/api/shell/:id/output", Schema.toCodecStringTree<Schema.Struct<{
+    }>>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.output", "GET", "/api/shell/:id/output", Schema.toCodecStringTree<Schema.Struct<{
     id: Schema.brand<Schema.String, "Shell.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Shell.ID">;
         ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;

package/dist/groups/vcs.d.ts

@@ -7,12 +7,7 @@ declare const VcsInitNotSupportedError_base: Schema.Class<VcsInitNotSupportedErr
 }>, 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<{
+export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEndpoint.HttpApiEndpoint<"vcs.base", "GET", "/api/vcs/base", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
@@ -20,43 +15,41 @@ export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEn
     readonly location: Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
-    readonly data: Schema.Struct<{
-        readonly provider: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly branch: Schema.Struct<{
-            readonly current: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        }>;
-    }>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.base", "GET", "/api/vcs/base", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly data: Schema.NullOr<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly ref: Schema.String;
+        readonly source: Schema.Literals<readonly ["reflog", "default"]>;
+    }>>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.branch.list", "GET", "/api/vcs/branch", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
+    readonly search: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly location: Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
-    readonly data: Schema.NullOr<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly ref: Schema.String;
-        readonly source: Schema.Literals<readonly ["reflog", "default"]>;
-    }>>;
-}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.status", "GET", "/api/vcs/status", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly data: Schema.$Array<Schema.String>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.diff", "GET", "/api/vcs/diff", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
+    readonly mode: Schema.Literals<readonly ["working", "branch", "committed"]>;
+    readonly base: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly context: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly location: Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly file: Schema.String;
+        readonly patch: Schema.String;
         readonly additions: Schema.Int;
         readonly deletions: Schema.Int;
         readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
     }>>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.branch.list", "GET", "/api/vcs/branch", never, Schema.toCodecStringTree<Schema.Struct<{
-    readonly search: Schema.optional<Schema.String>;
-    readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, 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>;
     }>>;
@@ -64,11 +57,19 @@ export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEn
     readonly location: Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
-    readonly data: Schema.$Array<Schema.String>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.diff", "GET", "/api/vcs/diff", never, Schema.toCodecStringTree<Schema.Struct<{
-    readonly mode: Schema.Literals<readonly ["working", "branch", "committed"]>;
-    readonly base: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly context: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
+    readonly data: Schema.Struct<{
+        readonly provider: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly branch: Schema.Struct<{
+            readonly current: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>;
+    }>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.init", "POST", "/api/vcs/init", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+    readonly provider: 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.status", "GET", "/api/vcs/status", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
@@ -78,10 +79,9 @@ export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEn
     }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly file: Schema.String;
-        readonly patch: Schema.String;
         readonly additions: Schema.Int;
         readonly deletions: Schema.Int;
         readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
     }>>;
-}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never>, false>;
+}>>, never, never, never>, false>;
 export {};

package/dist/groups/voice.d.ts

@@ -0,0 +1,60 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import { InvalidRequestError, LocationNotFoundError, ServiceUnavailableError } from "../errors.js";
+export declare const VoiceWebRTCTransportInput: Schema.Struct<{
+    readonly type: Schema.Literal<"webrtc">;
+    readonly sdp: Schema.String;
+    readonly dcid: Schema.optional<Schema.Number>;
+}>;
+export declare const VoiceWebSocketTransportInput: Schema.Struct<{
+    readonly type: Schema.Literal<"websocket">;
+}>;
+export declare const VoiceTransportInput: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"webrtc">;
+    readonly sdp: Schema.String;
+    readonly dcid: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"websocket">;
+}>]>;
+export declare const VoiceWebRTCTransport: Schema.Struct<{
+    readonly type: Schema.Literal<"webrtc">;
+    readonly sdp: Schema.String;
+}>;
+export declare const VoiceWebSocketTransport: Schema.Struct<{
+    readonly type: Schema.Literal<"websocket">;
+    readonly url: Schema.String;
+    readonly token: Schema.String;
+    readonly expiresAt: Schema.Number;
+}>;
+export declare const VoiceTransport: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"webrtc">;
+    readonly sdp: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"websocket">;
+    readonly url: Schema.String;
+    readonly token: Schema.String;
+    readonly expiresAt: Schema.Number;
+}>]>;
+export declare const VoiceGroup: HttpApiGroup.HttpApiGroup<"server.voice", HttpApiEndpoint.HttpApiEndpoint<"voice.session", "POST", "/api/experimental/voice/session", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly model: Schema.String;
+    readonly session: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly transport: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"webrtc">;
+        readonly sdp: Schema.String;
+        readonly dcid: Schema.optional<Schema.Number>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"websocket">;
+    }>]>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly transport: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"webrtc">;
+            readonly sdp: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"websocket">;
+            readonly url: Schema.String;
+            readonly token: Schema.String;
+            readonly expiresAt: Schema.Number;
+        }>]>;
+    }>;
+}>>, Schema.toCodecJson<typeof LocationNotFoundError | typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/voice.js

@@ -0,0 +1,51 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
+import { InvalidRequestError, LocationNotFoundError, ServiceUnavailableError } from "../errors.js";
+export const VoiceWebRTCTransportInput = Schema.Struct({
+    type: Schema.Literal("webrtc"),
+    sdp: Schema.String,
+    dcid: Schema.optional(Schema.Number),
+}).annotate({ identifier: "VoiceWebRTCTransportInput" });
+export const VoiceWebSocketTransportInput = Schema.Struct({
+    type: Schema.Literal("websocket"),
+}).annotate({ identifier: "VoiceWebSocketTransportInput" });
+export const VoiceTransportInput = Schema.Union([
+    VoiceWebRTCTransportInput,
+    VoiceWebSocketTransportInput,
+]).annotate({ identifier: "VoiceTransportInput" });
+export const VoiceWebRTCTransport = Schema.Struct({
+    type: Schema.Literal("webrtc"),
+    sdp: Schema.String,
+}).annotate({ identifier: "VoiceWebRTCTransport" });
+export const VoiceWebSocketTransport = Schema.Struct({
+    type: Schema.Literal("websocket"),
+    url: Schema.String,
+    token: Schema.String,
+    expiresAt: Schema.Number,
+}).annotate({ identifier: "VoiceWebSocketTransport" });
+export const VoiceTransport = Schema.Union([
+    VoiceWebRTCTransport,
+    VoiceWebSocketTransport,
+]).annotate({ identifier: "VoiceTransport" });
+export const VoiceGroup = HttpApiGroup.make("server.voice")
+    .add(HttpApiEndpoint.post("voice.session", "/api/experimental/voice/session", {
+    payload: Schema.Struct({
+        model: Schema.String,
+        session: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+        transport: VoiceTransportInput,
+    }),
+    success: Schema.Struct({
+        data: Schema.Struct({
+            transport: VoiceTransport,
+        }),
+    }).annotate({ identifier: "VoiceSessionResponse" }),
+    error: [InvalidRequestError, ServiceUnavailableError, LocationNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "experimental.voice.session",
+    summary: "Create voice session",
+    description: "Create a server-brokered voice session using the server's configured provider credentials and return the WebRTC SDP answer or WebSocket ephemeral token.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "voice",
+    description: "Experimental server-brokered voice session routes.",
+}));

package/dist/groups/worktree.d.ts

@@ -10,14 +10,7 @@ declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.TaggedStruc
 }>, import("effect/Cause").YieldableError>;
 export declare class WorktreeError extends WorktreeError_base {
 }
-export declare const WorktreeGroup: HttpApiGroup.HttpApiGroup<"server.worktree", HttpApiEndpoint.HttpApiEndpoint<"worktree.list", "GET", "/api/worktree", never, Schema.toCodecStringTree<Schema.Struct<{
-    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-}>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>>>, Schema.toCodecJson<typeof ProjectNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.create", "POST", "/api/worktree", never, never, Schema.toCodecJson<Schema.Struct<{
+export declare const WorktreeGroup: HttpApiGroup.HttpApiGroup<"server.worktree", HttpApiEndpoint.HttpApiEndpoint<"worktree.create", "POST", "/api/worktree", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
         global: string & import("effect/Brand").Brand<"Project.ID">;
     };
@@ -27,15 +20,22 @@ export declare const WorktreeGroup: HttpApiGroup.HttpApiGroup<"server.worktree",
     readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-}>>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.remove", "DELETE", "/api/worktree", never, never, Schema.toCodecJson<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.list", "GET", "/api/worktree", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
         global: string & import("effect/Brand").Brand<"Project.ID">;
     };
+}>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-    readonly force: Schema.Boolean;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.refresh", "POST", "/api/worktree/refresh", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>>>, Schema.toCodecJson<typeof ProjectNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.refresh", "POST", "/api/worktree/refresh", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
         global: string & import("effect/Brand").Brand<"Project.ID">;
     };
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.remove", "DELETE", "/api/worktree", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly force: Schema.Boolean;
 }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never>, false>;
 export {};