@opencode-ai/protocol 0.0.0-next-14661

package/dist/groups/session.js

@@ -0,0 +1,331 @@
+import { SessionMessage } from "@opencode-ai/schema/session-message";
+import { SessionInput } from "@opencode-ai/schema/session-input";
+import { PromptInput } from "@opencode-ai/schema/prompt-input";
+import { Session } from "@opencode-ai/schema/session";
+import { Project } from "@opencode-ai/schema/project";
+import { AbsolutePath, NonNegativeInt, PositiveInt, RelativePath, statics } from "@opencode-ai/schema/schema";
+import { Workspace } from "@opencode-ai/schema/workspace";
+import { Context, Effect, Encoding, Result, Schema, Struct } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { ConflictError, InvalidCursorError, InvalidRequestError, MessageNotFoundError, ServiceUnavailableError, SessionBusyError, SessionNotFoundError, SkillNotFoundError, UnknownError, } from "../errors.js";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Model } from "@opencode-ai/schema/model";
+import { Location } from "@opencode-ai/schema/location";
+import { Revert } from "@opencode-ai/schema/revert";
+import { SessionEvent } from "@opencode-ai/schema/session-event";
+const SessionsQueryFields = {
+    workspace: Workspace.ID.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.",
+    }),
+    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),
+};
+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"), statics((schema) => {
+    const make = schema.make.bind(schema);
+    return {
+        make: (input) => make(Encoding.encodeBase64Url(encodeSessionsCursor(input))),
+        parse: (input) => Effect.suspend(() => {
+            const result = Encoding.decodeBase64UrlString(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" });
+const SessionHistoryLimit = PositiveInt.check(Schema.isLessThanOrEqualTo(100));
+export const SessionHistoryQuery = Schema.Struct({
+    limit: Schema.NumberFromString.pipe(Schema.decodeTo(SessionHistoryLimit), Schema.optional),
+    after: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional),
+});
+const SessionsQueryCursor = SessionsCursor.annotate({
+    description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
+});
+export const SessionsQuery = Schema.Struct({
+    ...SessionsQueryFields,
+    directory: AbsolutePath.pipe(Schema.optional),
+    project: Project.ID.pipe(Schema.optional),
+    subpath: RelativePath.pipe(Schema.optional),
+    cursor: SessionsQueryCursor.pipe(Schema.optional),
+}).annotate({ identifier: "SessionsQuery" });
+export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make("server.session")
+    .add(HttpApiEndpoint.get("session.list", "/api/session", {
+    query: SessionsQuery,
+    success: Schema.Struct({
+        data: Schema.Array(Session.Info),
+        cursor: Schema.Struct({
+            previous: SessionsCursor.pipe(Schema.optional),
+            next: SessionsCursor.pipe(Schema.optional),
+        }),
+    }).annotate({ identifier: "SessionsResponse" }),
+    error: [InvalidCursorError, InvalidRequestError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.list",
+    summary: "List sessions",
+    description: "Retrieve sessions in the requested order. Items keep that order across pages; use cursor.next or cursor.previous to move through the ordered list.",
+})))
+    .add(HttpApiEndpoint.post("session.create", "/api/session", {
+    payload: Schema.Struct({
+        id: Session.ID.pipe(Schema.optional),
+        agent: Agent.ID.pipe(Schema.optional),
+        model: Model.Ref.pipe(Schema.optional),
+        location: Location.Ref.pipe(Schema.optional),
+    }),
+    success: Schema.Struct({ data: Session.Info }),
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.create",
+    summary: "Create session",
+    description: "Create a session at the requested location.",
+})))
+    .add(HttpApiEndpoint.get("session.active", "/api/session/active", {
+    success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive) }),
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.active",
+    summary: "List active sessions",
+    description: "Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive.",
+})))
+    .add(HttpApiEndpoint.get("session.get", "/api/session/:sessionID", {
+    params: { sessionID: Session.ID },
+    success: Schema.Struct({ data: Session.Info }),
+    error: SessionNotFoundError,
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.get",
+    summary: "Get session",
+    description: "Retrieve a session by ID.",
+})))
+    .add(HttpApiEndpoint.post("session.fork", "/api/session/:sessionID/fork", {
+    params: { sessionID: Session.ID },
+    payload: Schema.Struct({ messageID: SessionMessage.ID.pipe(Schema.optional) }),
+    success: Schema.Struct({ data: Session.Info }),
+    error: [SessionNotFoundError, MessageNotFoundError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.fork",
+    summary: "Fork session",
+    description: "Create a child session by copying projected history from the parent. When messageID is supplied, copy messages before that boundary.",
+})))
+    .add(HttpApiEndpoint.post("session.switchAgent", "/api/session/:sessionID/agent", {
+    params: { sessionID: Session.ID },
+    payload: Schema.Struct({ agent: Agent.ID }),
+    success: HttpApiSchema.NoContent,
+    error: SessionNotFoundError,
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.switchAgent",
+    summary: "Switch session agent",
+    description: "Switch the agent used by subsequent provider turns.",
+})))
+    .add(HttpApiEndpoint.post("session.switchModel", "/api/session/:sessionID/model", {
+    params: { sessionID: Session.ID },
+    payload: Schema.Struct({ model: Model.Ref }),
+    success: HttpApiSchema.NoContent,
+    error: SessionNotFoundError,
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.switchModel",
+    summary: "Switch session model",
+    description: "Switch the model used by subsequent provider turns.",
+})))
+    .add(HttpApiEndpoint.post("session.rename", "/api/session/:sessionID/rename", {
+    params: { sessionID: Session.ID },
+    payload: Schema.Struct({ title: Schema.String }),
+    success: HttpApiSchema.NoContent,
+    error: SessionNotFoundError,
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.rename",
+    summary: "Rename session",
+    description: "Update the session title.",
+})))
+    .add(HttpApiEndpoint.post("session.prompt", "/api/session/:sessionID/prompt", {
+    params: { sessionID: Session.ID },
+    payload: Schema.Struct({
+        id: SessionMessage.ID.pipe(Schema.optional),
+        prompt: PromptInput.Prompt,
+        delivery: SessionInput.Delivery.pipe(Schema.optional),
+        resume: Schema.Boolean.pipe(Schema.optional),
+    }),
+    success: Schema.Struct({ data: SessionInput.Admitted }),
+    error: [ConflictError, SessionNotFoundError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.prompt",
+    summary: "Send message",
+    description: "Durably admit one session input and schedule agent-loop execution unless resume is false.",
+})))
+    .add(HttpApiEndpoint.post("session.skill", "/api/session/:sessionID/skill", {
+    params: { sessionID: Session.ID },
+    payload: Schema.Struct({
+        id: SessionMessage.ID.pipe(Schema.optional),
+        skill: Schema.String,
+        resume: Schema.Boolean.pipe(Schema.optional),
+    }),
+    success: HttpApiSchema.NoContent,
+    error: [SessionNotFoundError, SkillNotFoundError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.skill",
+    summary: "Activate skill",
+    description: "Activate a skill for a session by appending a skill message and resuming execution.",
+})))
+    .add(HttpApiEndpoint.post("session.compact", "/api/session/:sessionID/compact", {
+    params: { sessionID: Session.ID },
+    success: HttpApiSchema.NoContent,
+    error: [SessionNotFoundError, SessionBusyError, ServiceUnavailableError, UnknownError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.compact",
+    summary: "Compact session",
+    description: "Compact a session conversation.",
+})))
+    .add(HttpApiEndpoint.post("session.wait", "/api/session/:sessionID/wait", {
+    params: { sessionID: Session.ID },
+    success: HttpApiSchema.NoContent,
+    error: [SessionNotFoundError, ServiceUnavailableError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.wait",
+    summary: "Wait for session",
+    description: "Wait for a session agent loop to become idle.",
+})))
+    .add(HttpApiEndpoint.post("session.revert.stage", "/api/session/:sessionID/revert/stage", {
+    params: { sessionID: Session.ID },
+    payload: Schema.Struct({ messageID: SessionMessage.ID, files: Schema.Boolean.pipe(Schema.optional) }),
+    success: Schema.Struct({ data: Revert.State }),
+    error: [MessageNotFoundError, SessionNotFoundError, SessionBusyError, UnknownError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.revert.stage",
+    summary: "Stage session revert",
+    description: "Stage or move a reversible session boundary and optionally apply its file changes.",
+})))
+    .add(HttpApiEndpoint.post("session.revert.clear", "/api/session/:sessionID/revert/clear", {
+    params: { sessionID: Session.ID },
+    success: HttpApiSchema.NoContent,
+    error: [SessionNotFoundError, SessionBusyError, UnknownError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({ identifier: "v2.session.revert.clear", summary: "Clear staged revert" })))
+    .add(HttpApiEndpoint.post("session.revert.commit", "/api/session/:sessionID/revert/commit", {
+    params: { sessionID: Session.ID },
+    success: HttpApiSchema.NoContent,
+    error: [SessionNotFoundError, SessionBusyError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({ identifier: "v2.session.revert.commit", summary: "Commit staged revert" })))
+    .add(HttpApiEndpoint.get("session.context", "/api/session/:sessionID/context", {
+    params: { sessionID: Session.ID },
+    success: Schema.Struct({ data: Schema.Array(SessionMessage.Message) }),
+    error: [SessionNotFoundError, UnknownError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.context",
+    summary: "Get session context",
+    description: "Retrieve the active context messages for a session (all messages after the last compaction).",
+})))
+    .add(HttpApiEndpoint.get("session.history", "/api/session/:sessionID/history", {
+    params: { sessionID: Session.ID },
+    query: SessionHistoryQuery,
+    success: Schema.Struct({
+        data: Schema.Array(SessionEvent.Durable),
+        hasMore: Schema.Boolean,
+    }).annotate({ identifier: "SessionHistory" }),
+    error: SessionNotFoundError,
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.history",
+    summary: "Get session history",
+    description: "Read one finite page of public durable Session events after an exclusive aggregate sequence. Newly committed events may appear on later pages.",
+})))
+    .add(HttpApiEndpoint.get("session.events", "/api/session/:sessionID/event", {
+    params: { sessionID: Session.ID },
+    query: {
+        after: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional),
+    },
+    success: HttpApiSchema.StreamSse({ data: SessionEvent.Durable }),
+    error: SessionNotFoundError,
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.events",
+    summary: "Subscribe to session events",
+    description: "Replay durable events after an aggregate sequence, then continue with new durable events.",
+})))
+    .add(HttpApiEndpoint.post("session.interrupt", "/api/session/:sessionID/interrupt", {
+    params: { sessionID: Session.ID },
+    success: HttpApiSchema.NoContent,
+    error: SessionNotFoundError,
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.interrupt",
+    summary: "Interrupt session execution",
+    description: "Interrupt active execution owned by this OpenCode process. Idle interruption is a no-op.",
+})))
+    .add(HttpApiEndpoint.post("session.background", "/api/session/:sessionID/background", {
+    params: { sessionID: Session.ID },
+    success: HttpApiSchema.NoContent,
+    error: SessionNotFoundError,
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.background",
+    summary: "Background blocking session tools",
+    description: "Move active foreground backgroundable tools for this session into background observation. Idle requests are a no-op.",
+})))
+    .add(HttpApiEndpoint.get("session.message", "/api/session/:sessionID/message/:messageID", {
+    params: { sessionID: Session.ID, messageID: SessionMessage.ID },
+    success: Schema.Struct({ data: SessionMessage.Message }),
+    error: [SessionNotFoundError, MessageNotFoundError],
+})
+    .middleware(sessionLocationMiddleware)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.session.message",
+    summary: "Get session message",
+    description: "Retrieve one projected message owned by the Session.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "sessions",
+    description: "Experimental session routes.",
+}));

package/dist/groups/shell.d.ts

@@ -0,0 +1,120 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { ShellNotFoundError } from "../errors.js";
+export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpApiEndpoint.HttpApiEndpoint<"shell.list", "GET", "/api/shell", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ShellID"> & {
+            create: () => string & import("effect/Brand").Brand<"ShellID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+        };
+        readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
+        readonly command: Schema.String;
+        readonly cwd: Schema.String;
+        readonly shell: Schema.String;
+        readonly file: Schema.String;
+        readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            readonly started: Schema.Number;
+            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        }>;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.create", "POST", "/api/shell", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.Json<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>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ShellID"> & {
+            create: () => string & import("effect/Brand").Brand<"ShellID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+        };
+        readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
+        readonly command: Schema.String;
+        readonly cwd: Schema.String;
+        readonly shell: Schema.String;
+        readonly file: Schema.String;
+        readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            readonly started: Schema.Number;
+            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        }>;
+    }>;
+}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.get", "GET", "/api/shell/:id", HttpApiEndpoint.StringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "ShellID"> & {
+        create: () => string & import("effect/Brand").Brand<"ShellID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+    };
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ShellID"> & {
+            create: () => string & import("effect/Brand").Brand<"ShellID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+        };
+        readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
+        readonly command: Schema.String;
+        readonly cwd: Schema.String;
+        readonly shell: Schema.String;
+        readonly file: Schema.String;
+        readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            readonly started: Schema.Number;
+            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        }>;
+    }>;
+}>>, HttpApiEndpoint.Json<typeof ShellNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.output", "GET", "/api/shell/:id/output", HttpApiEndpoint.StringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "ShellID"> & {
+        create: () => string & import("effect/Brand").Brand<"ShellID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+    };
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly cursor: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly output: Schema.String;
+        readonly cursor: Schema.Int;
+        readonly size: Schema.Int;
+        readonly truncated: Schema.Boolean;
+    }>;
+}>>, HttpApiEndpoint.Json<typeof ShellNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.remove", "DELETE", "/api/shell/:id", HttpApiEndpoint.StringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "ShellID"> & {
+        create: () => string & import("effect/Brand").Brand<"ShellID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+    };
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof ShellNotFoundError>, never, never>, false>;

package/dist/groups/shell.js

@@ -0,0 +1,65 @@
+import { Shell } from "@opencode-ai/schema/shell";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { ShellNotFoundError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const ShellGroup = HttpApiGroup.make("server.shell")
+    .add(HttpApiEndpoint.get("shell.list", "/api/shell", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Shell.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.list",
+    summary: "List running shell commands",
+    description: "List currently running shell commands for a location. Exited commands are not included.",
+})))
+    .add(HttpApiEndpoint.post("shell.create", "/api/shell", {
+    query: LocationQuery,
+    payload: Shell.CreateInput,
+    success: Location.response(Shell.Info),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.create",
+    summary: "Run shell command",
+    description: "Spawn one non-interactive shell command for a location. Combined stdout/stderr is captured to a file pageable via output.",
+})))
+    .add(HttpApiEndpoint.get("shell.get", "/api/shell/:id", {
+    params: { id: Shell.ID },
+    query: LocationQuery,
+    success: Location.response(Shell.Info),
+    error: ShellNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.get",
+    summary: "Get shell command",
+    description: "Get one shell command, including its status and exit code once exited.",
+})))
+    .add(HttpApiEndpoint.get("shell.output", "/api/shell/:id/output", {
+    params: { id: Shell.ID },
+    query: Schema.Struct({ ...LocationQuery.fields, ...Shell.OutputInput.fields }),
+    success: Location.response(Shell.Output),
+    error: ShellNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.output",
+    summary: "Read shell output",
+    description: "Page through captured combined output by absolute byte cursor.",
+})))
+    .add(HttpApiEndpoint.delete("shell.remove", "/api/shell/:id", {
+    params: { id: Shell.ID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: ShellNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.remove",
+    summary: "Remove shell command",
+    description: "Terminate and remove one shell command and its retained output.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "shell", description: "Experimental location-scoped shell command routes." }));

package/dist/groups/skill.d.ts

@@ -0,0 +1,19 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const SkillGroup: HttpApiGroup.HttpApiGroup<"server.skill", HttpApiEndpoint.HttpApiEndpoint<"skill.list", "GET", "/api/skill", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly slash: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly location: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly content: Schema.String;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, never, never>, false>;

package/dist/groups/skill.js

@@ -0,0 +1,20 @@
+import { Skill } from "@opencode-ai/schema/skill";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const SkillGroup = HttpApiGroup.make("server.skill")
+    .add(HttpApiEndpoint.get("skill.list", "/api/skill", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Skill.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.skill.list",
+    summary: "List skills",
+    description: "Retrieve currently registered skills.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "skills",
+    description: "Experimental skill routes.",
+}));

package/dist/middleware/authorization.d.ts

@@ -0,0 +1,13 @@
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { UnauthorizedError } from "../errors.js";
+declare const Authorization_base: HttpApiMiddleware.ServiceClass<Authorization, "@opencode/HttpApiAuthorization", {
+    requires: never;
+    provides: never;
+    error: typeof UnauthorizedError;
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<never, typeof UnauthorizedError, never>>;
+export declare class Authorization extends Authorization_base {
+}
+export {};

package/dist/middleware/authorization.js

@@ -0,0 +1,6 @@
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { UnauthorizedError } from "../errors.js";
+export class Authorization extends HttpApiMiddleware.Service()("@opencode/HttpApiAuthorization", {
+    error: UnauthorizedError,
+}) {
+}

package/dist/middleware/schema-error.d.ts

@@ -0,0 +1,13 @@
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { InvalidRequestError } from "../errors.js";
+declare const SchemaErrorMiddleware_base: HttpApiMiddleware.ServiceClass<SchemaErrorMiddleware, "@opencode/HttpApiSchemaError", {
+    requires: never;
+    provides: never;
+    error: typeof InvalidRequestError;
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<never, typeof InvalidRequestError, never>>;
+export declare class SchemaErrorMiddleware extends SchemaErrorMiddleware_base {
+}
+export {};

package/dist/middleware/schema-error.js

@@ -0,0 +1,4 @@
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { InvalidRequestError } from "../errors.js";
+export class SchemaErrorMiddleware extends HttpApiMiddleware.Service()("@opencode/HttpApiSchemaError", { error: InvalidRequestError }) {
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode-ai/protocol",
+  "version": "0.0.0-next-14661",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anomalyco/opencode.git",
+    "directory": "packages/protocol"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run script/build.ts",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@opencode-ai/schema": "0.0.0-next-14661",
+    "effect": "4.0.0-beta.83"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.3.13",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1",
+    "typescript": "5.8.2"
+  }
+}