@kilocode/protocol 0.0.0-stage → 0.0.0-v2-9

package/dist/groups/shell.d.ts

@@ -0,0 +1,125 @@
+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.create", "POST", "/api/shell", never, 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<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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">;
+        };
+        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.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly signal: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            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.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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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">;
+        };
+        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.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly signal: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            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.list", "GET", "/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<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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">;
+        };
+        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.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly signal: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            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.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">;
+    };
+}>>, Schema.toCodecStringTree<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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.Struct<{
+        readonly output: Schema.String;
+        readonly cursor: Schema.Int;
+        readonly size: Schema.Int;
+        readonly truncated: Schema.Boolean;
+    }>;
+}>>, Schema.toCodecJson<typeof ShellNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.remove", "DELETE", "/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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/shell.js

@@ -0,0 +1,64 @@
+import { Shell } from "@opencode/schema/shell";
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import { ShellNotFoundError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const ShellGroup = HttpApiGroup.make("server.shell")
+    .add(HttpApiEndpoint.get("shell.list", "/api/shell", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Shell.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "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: "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: "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: "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,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "shell.remove",
+    summary: "Remove shell command",
+    description: "Terminate and remove one shell command and its retained output.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "shell", description: "Location-scoped shell command routes." }));

package/dist/groups/skill.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+export declare const SkillGroup: HttpApiGroup.HttpApiGroup<"server.skill", HttpApiEndpoint.HttpApiEndpoint<"skill.list", "GET", "/api/skill", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Skill.ID">;
+        readonly name: Schema.brand<Schema.String, "Skill.Name">;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly content: Schema.String;
+    }>>;
+}>>, never, never, never>, false>;

package/dist/groups/skill.js

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

package/dist/groups/vcs.d.ts

@@ -0,0 +1,87 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
+import { ConflictError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+declare const VcsInitNotSupportedError_base: Schema.Class<VcsInitNotSupportedError, Schema.TaggedStruct<"VcsInitNotSupportedError", {
+    readonly providerID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class VcsInitNotSupportedError extends VcsInitNotSupportedError_base {
+}
+export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEndpoint.HttpApiEndpoint<"vcs.base", "GET", "/api/vcs/base", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, 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.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.$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"]>;
+    }>>;
+}>>, 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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    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.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>;
+    }>>;
+}>>, 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 additions: Schema.Int;
+        readonly deletions: Schema.Int;
+        readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
+    }>>;
+}>>, never, never, never>, false>;
+export {};

package/dist/groups/vcs.js

@@ -0,0 +1,93 @@
+import { FileDiff } from "@opencode/schema/file-diff";
+import { Location } from "@opencode/schema/location";
+import { NonNegativeInt, PositiveInt, optional } from "@opencode/schema/schema";
+import { Vcs } from "@opencode/schema/vcs";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+import { ConflictError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+const InitQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    provider: Schema.optional(Schema.String),
+});
+export class VcsInitNotSupportedError extends Schema.TaggedError()("VcsInitNotSupportedError", { providerID: Schema.String, message: Schema.String }, { httpApiStatus: 501 }) {
+}
+const BranchesQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    search: Schema.optional(Schema.String),
+    limit: Schema.NumberFromString.pipe(Schema.decodeTo(PositiveInt), Schema.optional),
+});
+const DiffQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    mode: Vcs.Mode,
+    base: optional(Schema.String),
+    context: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional),
+});
+export const VcsGroup = HttpApiGroup.make("server.vcs")
+    .add(HttpApiEndpoint.post("vcs.init", "/api/vcs/init", {
+    query: InitQuery,
+    success: HttpApiSchema.NoContent,
+    error: [ConflictError, InvalidRequestError, VcsInitNotSupportedError, ServiceUnavailableError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "vcs.init",
+    summary: "Initialize VCS repository",
+    description: "Initialize a repository using the selected VCS provider in a markerless project's directory and refresh its location services. Omitting provider defaults to git; built-in git and hg providers support initialization. An unknown provider returns 400; a registered provider without init returns 501.",
+})))
+    .add(HttpApiEndpoint.get("vcs.get", "/api/vcs", {
+    query: LocationQuery,
+    success: Location.response(Vcs.Info),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "vcs.get",
+    summary: "VCS info",
+    description: "Get current and default branch information for the requested location.",
+})))
+    .add(HttpApiEndpoint.get("vcs.base", "/api/vcs/base", {
+    query: LocationQuery,
+    success: Location.response(Schema.NullOr(Vcs.Base)),
+    error: ServiceUnavailableError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "vcs.base",
+    summary: "VCS review base",
+    description: "Infer a local review base from named branch creation history, or the repository default only when currently on that branch. Returns null before the first commit or when the provider lacks base metadata; ambiguous Git history requires an explicit base on diff requests.",
+})))
+    .add(HttpApiEndpoint.get("vcs.status", "/api/vcs/status", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Vcs.FileStatus)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "vcs.status",
+    summary: "VCS status",
+    description: "List uncommitted working-copy changes relative to the requested location.",
+})))
+    .add(HttpApiEndpoint.get("vcs.branch.list", "/api/vcs/branch", {
+    query: BranchesQuery,
+    success: Location.response(Vcs.BranchList),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "vcs.branch.list",
+    summary: "VCS branches",
+    description: "List local and remote branches available at the requested location.",
+})))
+    .add(HttpApiEndpoint.get("vcs.diff", "/api/vcs/diff", {
+    query: DiffQuery,
+    success: Location.response(Schema.Array(FileDiff.Info)),
+    error: ServiceUnavailableError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "vcs.diff",
+    summary: "VCS diff",
+    description: "Diff HEAD to the working copy (working), the base merge-base to the working copy (branch), or the base merge-base to HEAD (committed). Omitting base preserves repository-default comparison; supplying it overrides the comparison without saving it.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "vcs",
+    description: "Location-scoped version control routes.",
+}));

package/dist/groups/voice.d.ts

@@ -0,0 +1,93 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
+import { InvalidRequestError, LocationNotFoundError, ServiceUnavailableError } from "../errors.js";
+export declare const VoiceTransportType: Schema.Literals<readonly ["webrtc", "websocket"]>;
+export declare const VoiceModel: Schema.Struct<{
+    readonly model: Schema.String;
+    readonly provider: Schema.String;
+    readonly transports: Schema.$Array<Schema.Literals<readonly ["webrtc", "websocket"]>>;
+    readonly available: Schema.Boolean;
+    /** The integration whose connection starts its sessions: the provider's stored key, or `opencode` when the connected OpenCode Console hosts it. */
+    readonly integration: Schema.optional<Schema.String>;
+    /** The OpenCode Console workspace a hosted model's sessions bill to. */
+    readonly workspace: Schema.optional<Schema.String>;
+}>;
+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.instructions", "POST", "/api/experimental/voice/session/:sessionID/instructions", Schema.toCodecStringTree<Schema.Struct<{
+    sessionID: Schema.String;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly instructions: Schema.String;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof LocationNotFoundError | typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"voice.models", "GET", "/api/experimental/voice/models", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly models: Schema.$Array<Schema.Struct<{
+            readonly model: Schema.String;
+            readonly provider: Schema.String;
+            readonly transports: Schema.$Array<Schema.Literals<readonly ["webrtc", "websocket"]>>;
+            readonly available: Schema.Boolean;
+            /** The integration whose connection starts its sessions: the provider's stored key, or `opencode` when the connected OpenCode Console hosts it. */
+            readonly integration: Schema.optional<Schema.String>;
+            /** The OpenCode Console workspace a hosted model's sessions bill to. */
+            readonly workspace: Schema.optional<Schema.String>;
+        }>>;
+        readonly default: Schema.optional<Schema.String>;
+    }>;
+}>>, Schema.toCodecJson<typeof LocationNotFoundError | typeof ServiceUnavailableError>, never, never> | 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;
+        }>]>;
+        /** A hosted session's ID, for `voice.instructions`. */
+        readonly session: Schema.optional<Schema.Struct<{
+            readonly id: Schema.String;
+        }>>;
+    }>;
+}>>, Schema.toCodecJson<typeof LocationNotFoundError | typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/voice.js

@@ -0,0 +1,89 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import { InvalidRequestError, LocationNotFoundError, ServiceUnavailableError } from "../errors.js";
+export const VoiceTransportType = Schema.Literals(["webrtc", "websocket"]).annotate({
+    identifier: "VoiceTransportType",
+});
+export const VoiceModel = Schema.Struct({
+    model: Schema.String,
+    provider: Schema.String,
+    transports: Schema.Array(VoiceTransportType),
+    available: Schema.Boolean,
+    /** The integration whose connection starts its sessions: the provider's stored key, or `opencode` when the connected OpenCode Console hosts it. */
+    integration: Schema.optional(Schema.String),
+    /** The OpenCode Console workspace a hosted model's sessions bill to. */
+    workspace: Schema.optional(Schema.String),
+}).annotate({ identifier: "VoiceModel" });
+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.get("voice.models", "/api/experimental/voice/models", {
+    success: Schema.Struct({
+        data: Schema.Struct({
+            models: Schema.Array(VoiceModel),
+            default: Schema.optional(Schema.String),
+        }),
+    }).annotate({ identifier: "VoiceModelsResponse" }),
+    error: [ServiceUnavailableError, LocationNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "experimental.voice.models",
+    summary: "List voice models",
+    description: "List supported voice models, their transports, whether the server has a usable API key for each provider or the connected OpenCode Console hosts the model, and the Console workspace a hosted model bills to.",
+})))
+    .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,
+            /** A hosted session's ID, for `voice.instructions`. */
+            session: Schema.optional(Schema.Struct({ id: Schema.String })),
+        }),
+    }).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, or the connected OpenCode Console when it hosts the model, and return the WebRTC SDP answer or WebSocket ephemeral token.",
+})))
+    .add(HttpApiEndpoint.post("voice.instructions", "/api/experimental/voice/session/:sessionID/instructions", {
+    params: { sessionID: Schema.String },
+    payload: Schema.Struct({ instructions: Schema.String }),
+    success: HttpApiSchema.NoContent,
+    error: [InvalidRequestError, ServiceUnavailableError, LocationNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "experimental.voice.instructions",
+    summary: "Replace voice session instructions",
+    description: "Replace the backend instructions of a running session the connected OpenCode Console hosts, whose data channel can't change them.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "voice",
+    description: "Experimental server-brokered voice session routes.",
+}));

package/dist/groups/websearch.d.ts

@@ -0,0 +1,29 @@
+import { WebSearch } from "@opencode/schema/websearch";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+export declare const WebSearchGroup: HttpApiGroup.HttpApiGroup<"server.websearch", HttpApiEndpoint.HttpApiEndpoint<"websearch.providers", "GET", "/api/websearch/provider", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "WebSearch.ID">;
+        readonly name: Schema.String;
+    }>>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"websearch.query", "POST", "/api/websearch", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly query: Schema.String;
+    readonly providerID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WebSearch.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "WebSearch.ID">>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: typeof WebSearch.Response;
+}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never>, false>;