@opencode/protocol 0.0.0-dev-21085 → 0.0.0-dev-21090

package/dist/api.d.ts

@@ -2,6 +2,7 @@ import { Context } from "effect";
 import { HttpApi, HttpApiGroup, HttpApiMiddleware } from "effect/http-api";
 import { SchemaErrorMiddleware } from "./middleware/schema-error.js";
 import { GenerateGroup } from "./groups/generate.js";
+import { VoiceGroup } from "./groups/voice.js";
 import { MessageGroup } from "./groups/message.js";
 import { ModelGroup } from "./groups/model.js";
 import { ProviderGroup } from "./groups/provider.js";
@@ -39,7 +40,7 @@ type SessionGroups<SessionLocationId extends HttpApiMiddleware.AnyId, SessionLoc
 type FormGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService> = ReturnType<typeof makeFormGroup<LocationId, LocationService>>;
 type LocationGroup<LocationId extends HttpApiMiddleware.AnyId, LocationService> = ReturnType<typeof makeLocationGroup<LocationId, LocationService>>;
 type MixedMiddlewareGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService> = ReturnType<typeof makePermissionGroup<LocationId, LocationService, SessionLocationId, SessionLocationService>>;
-type ApiGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Constraint> = typeof ServerGroup | typeof DebugGroup | typeof MigrationGroup | typeof WorktreeGroup | typeof GenerateGroup | typeof PersistentPtyGroup | typeof CredentialGroup | LocationGroups<LocationId> | LocationGroup<LocationId, LocationService> | PtyGroups<LocationId, LocationService> | FormGroups<LocationId, LocationService> | SessionGroups<SessionLocationId, SessionLocationService, FormLocationId, FormLocationService> | MixedMiddlewareGroups<LocationId, LocationService, SessionLocationId, SessionLocationService> | Event;
+type ApiGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Constraint> = typeof ServerGroup | typeof DebugGroup | typeof MigrationGroup | typeof WorktreeGroup | typeof GenerateGroup | typeof VoiceGroup | typeof PersistentPtyGroup | typeof CredentialGroup | LocationGroups<LocationId> | LocationGroup<LocationId, LocationService> | PtyGroups<LocationId, LocationService> | FormGroups<LocationId, LocationService> | SessionGroups<SessionLocationId, SessionLocationService, FormLocationId, FormLocationService> | MixedMiddlewareGroups<LocationId, LocationService, SessionLocationId, SessionLocationService> | Event;
 type EventGroupFor<Definitions extends ReadonlyArray<Definition>> = ReturnType<typeof makeEventGroup<Definitions>>;
 export type Api<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Constraint> = HttpApi.HttpApi<"server", HttpApiGroup.AddMiddleware<HttpApiGroup.AddMiddleware<ApiGroups<LocationId, LocationService, FormLocationId, FormLocationService, SessionLocationId, SessionLocationService, Event>, Authorization>, SchemaErrorMiddleware>>;
 export declare const makeApi: <const Definitions extends ReadonlyArray<Definition>, LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(options: {

package/dist/api.js

@@ -2,6 +2,7 @@ import { Context } from "effect";
 import { HttpApi, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/http-api";
 import { SchemaErrorMiddleware } from "./middleware/schema-error.js";
 import { GenerateGroup } from "./groups/generate.js";
+import { VoiceGroup } from "./groups/voice.js";
 import { MessageGroup } from "./groups/message.js";
 import { ModelGroup } from "./groups/model.js";
 import { ProviderGroup } from "./groups/provider.js";
@@ -42,6 +43,7 @@ const makeApiFromGroup = (eventGroup, locationMiddleware, formLocationMiddleware
     .add(MessageGroup)
     .add(ModelGroup.middleware(locationMiddleware))
     .add(GenerateGroup)
+    .add(VoiceGroup)
     .add(ProviderGroup.middleware(locationMiddleware))
     .add(IntegrationGroup.middleware(locationMiddleware))
     .add(McpGroup.middleware(locationMiddleware))

package/dist/client.d.ts

@@ -36,6 +36,7 @@ export declare const groupNames: {
     readonly "server.message": "message";
     readonly "server.model": "model";
     readonly "server.generate": "generate";
+    readonly "server.voice": "voice";
     readonly "server.provider": "provider";
     readonly "server.integration": "integration";
     readonly "server.websearch": "websearch";

package/dist/client.js

@@ -23,6 +23,7 @@ export const groupNames = {
     "server.message": "message",
     "server.model": "model",
     "server.generate": "generate",
+    "server.voice": "voice",
     "server.provider": "provider",
     "server.integration": "integration",
     "server.websearch": "websearch",

package/dist/groups/session.d.ts

@@ -1,63 +1,43 @@
 import { PromptInput } from "@opencode/schema/prompt-input";
+import { Session } from "@opencode/schema/session";
 import { InstructionEntry } from "@opencode/schema/instruction-entry";
 import { Event } from "@opencode/schema/event";
-import { Context, Effect, Schema } from "effect";
+import { Context, Schema } from "effect";
 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">;
-    readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
-    readonly search: Schema.optional<Schema.String>;
-    readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
-    readonly anchor: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+export declare const SessionsCursor: Schema.brand<Schema.String, "SessionsCursor"> & {
+    make: (input: {
+        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 time: Schema.Finite;
-        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
-    }>;
-}>, Schema.Struct<{
-    readonly project: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
-    readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
-    readonly search: Schema.optional<Schema.String>;
-    readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
-    readonly anchor: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        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 time: Schema.Finite;
-        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
-    }>;
-}>, Schema.Struct<{
-    readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
-    readonly search: Schema.optional<Schema.String>;
-    readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
-    readonly anchor: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        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 time: Schema.Finite;
-        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
-    }>;
-}>]>;
-export declare const SessionsCursor: Schema.brand<Schema.String, "SessionsCursor"> & {
-    make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
-    parse: (input: string) => Effect.Effect<{
+        readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+        readonly search?: string | undefined;
+        readonly order?: "asc" | "desc" | undefined;
+    }) => string & import("effect/Brand").Brand<"SessionsCursor">;
+    parse: (input: string) => import("effect/Effect").Effect<{
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly anchor: {
             readonly id: string & import("effect/Brand").Brand<"SessionID">;
@@ -89,16 +69,41 @@ export declare const SessionsCursor: Schema.brand<Schema.String, "SessionsCursor
         readonly order?: "asc" | "desc" | undefined;
     }, "Invalid cursor", never>;
 };
-export type SessionsCursor = typeof SessionsCursor.Type;
+export type SessionsCursor = Session.ListCursor;
 export declare const SessionsQuery: Schema.Struct<{
-    readonly directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
-    readonly project: Schema.optional<Schema.brand<Schema.String, "Project.ID"> & {
-        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"> & {
-        make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
-        parse: (input: string) => Effect.Effect<{
+        make: (input: {
+            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;
+        }) => string & import("effect/Brand").Brand<"SessionsCursor">;
+        parse: (input: string) => import("effect/Effect").Effect<{
             readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
             readonly anchor: {
                 readonly id: string & import("effect/Brand").Brand<"SessionID">;
@@ -130,23 +135,53 @@ export declare const SessionsQuery: Schema.Struct<{
             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 directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
+    readonly project: Schema.optional<Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    }>;
+    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
+    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
     readonly search: Schema.optional<Schema.String>;
     readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
+    readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
 }>;
 export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, FormI extends HttpApiMiddleware.AnyId, FormS>(sessionLocationMiddleware: Context.Key<I, S>, formLocationMiddleware: Context.Key<FormI, FormS>) => HttpApiGroup.HttpApiGroup<"server.session", HttpApiEndpoint.HttpApiEndpoint<"session.list", "GET", "/api/session", never, Schema.toCodecStringTree<Schema.Struct<{
-    readonly directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
-    readonly project: Schema.optional<Schema.brand<Schema.String, "Project.ID"> & {
-        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"> & {
-        make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
-        parse: (input: string) => Effect.Effect<{
+        make: (input: {
+            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;
+        }) => string & import("effect/Brand").Brand<"SessionsCursor">;
+        parse: (input: string) => import("effect/Effect").Effect<{
             readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
             readonly anchor: {
                 readonly id: string & import("effect/Brand").Brand<"SessionID">;
@@ -178,13 +213,18 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
             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 directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
+    readonly project: Schema.optional<Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    }>;
+    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
+    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
     readonly search: Schema.optional<Schema.String>;
     readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
+    readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly data: Schema.$Array<Schema.Struct<{
         readonly location: Schema.Struct<{
@@ -363,8 +403,38 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
     }>>;
     readonly cursor: Schema.Struct<{
         readonly previous: Schema.optional<Schema.brand<Schema.String, "SessionsCursor"> & {
-            make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
-            parse: (input: string) => Effect.Effect<{
+            make: (input: {
+                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;
+            }) => string & import("effect/Brand").Brand<"SessionsCursor">;
+            parse: (input: string) => import("effect/Effect").Effect<{
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly anchor: {
                     readonly id: string & import("effect/Brand").Brand<"SessionID">;
@@ -397,8 +467,38 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
             }, "Invalid cursor", never>;
         }>;
         readonly next: Schema.optional<Schema.brand<Schema.String, "SessionsCursor"> & {
-            make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
-            parse: (input: string) => Effect.Effect<{
+            make: (input: {
+                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;
+            }) => string & import("effect/Brand").Brand<"SessionsCursor">;
+            parse: (input: string) => import("effect/Effect").Effect<{
                 readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
                 readonly anchor: {
                     readonly id: string & import("effect/Brand").Brand<"SessionID">;
@@ -11600,4 +11700,3 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S, Fo
 }>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly idle: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
 }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, never, never>, false>;
-export {};

package/dist/groups/session.js

@@ -5,10 +5,9 @@ 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 { 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 +20,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" });
@@ -114,12 +55,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 +70,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],

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/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/protocol",
-  "version": "0.0.0-dev-21085",
+  "version": "0.0.0-dev-21090",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -33,7 +33,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode/schema": "0.0.0-dev-21085",
+    "@opencode/schema": "0.0.0-dev-21090",
     "effect": "4.0.1"
   },
   "devDependencies": {