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

package/dist/groups/event.js

@@ -0,0 +1,51 @@
+import { Event } from "@opencode/schema/event";
+import { EventManifest } from "@opencode/schema/event-manifest";
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+const fields = {
+    id: Event.ID,
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    location: Schema.optional(Location.PublicRef),
+};
+const rpcEvent = Schema.Struct({
+    id: Event.ID,
+    created: Schema.Finite,
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    type: Schema.TemplateLiteral(["rpc.", Schema.String]),
+    location: Location.PublicRef,
+    data: Schema.Record(Schema.String, Schema.Unknown),
+}).annotate({ identifier: "V2Event.rpc" });
+const schema = (definitions) => Schema.Union([
+    ...definitions,
+    rpcEvent,
+    ...(definitions.some((definition) => definition.type === "server.connected")
+        ? []
+        : [
+            Schema.Struct({
+                ...fields,
+                type: Schema.Literal("server.connected"),
+                data: Schema.Struct({}),
+            }).annotate({ identifier: "V2Event.server.connected" }),
+        ]),
+]).annotate({ identifier: "V2Event" });
+const make = (definitions) => {
+    const EventSchema = schema(definitions);
+    return {
+        schema: EventSchema,
+        group: HttpApiGroup.make("server.event")
+            .add(HttpApiEndpoint.get("event.subscribe", "/api/event", {
+            success: HttpApiSchema.StreamSse({ data: EventSchema }),
+        }).annotateMerge(OpenApi.annotations({
+            identifier: "event.subscribe",
+            summary: "Subscribe to events",
+            description: "Subscribe to native events and plugin RPC events across all server locations. Volatile by contract: a slow consumer overflows and fails the stream, and events during disconnection are missed.",
+        })))
+            .annotateMerge(OpenApi.annotations({ title: "event", description: "Experimental event stream routes." })),
+    };
+};
+export const makeEventGroup = (definitions) => make(definitions).group;
+const event = make(EventManifest.ServerDefinitions);
+export const EventGroup = event.group;
+export const OpenCodeEvent = event.schema;
+export const isOpenCodeEvent = (event) => event.type === "server.connected" || EventManifest.isServer(event) || event.type.startsWith("rpc.");

package/dist/groups/form.d.ts

@@ -0,0 +1,138 @@
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware } from "effect/http-api";
+export declare const makeFormGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService>(locationMiddleware: Context.Key<LocationId, LocationService>) => HttpApiGroup.HttpApiGroup<"server.form", HttpApiEndpoint.HttpApiEndpoint<"form.list", "GET", "/api/form", 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, "Form.ID"> & {
+            create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+        };
+        readonly sessionID: Schema.String;
+        readonly title: Schema.String;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+            readonly key: Schema.String;
+            readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>, never, never>;
+            readonly type: Schema.Literal<"string">;
+            readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
+            readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly maxLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly pattern: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly placeholder: 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>;
+            readonly options: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+                readonly value: Schema.String;
+                readonly label: Schema.String;
+                readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly value: Schema.String;
+                readonly label: Schema.String;
+                readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, never, never>;
+            readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }>, Schema.Struct<{
+            readonly key: Schema.String;
+            readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>, never, never>;
+            readonly type: Schema.Literal<"number">;
+            readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+            readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+            readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        }>, Schema.Struct<{
+            readonly key: Schema.String;
+            readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>, never, never>;
+            readonly type: Schema.Literal<"integer">;
+            readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+            readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+            readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        }>, Schema.Struct<{
+            readonly key: Schema.String;
+            readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>, never, never>;
+            readonly type: Schema.Literal<"boolean">;
+            readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }>, Schema.Struct<{
+            readonly key: Schema.String;
+            readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+            }>>>, never, never>;
+            readonly type: Schema.Literal<"multiselect">;
+            readonly options: Schema.$Array<Schema.Struct<{
+                readonly value: Schema.String;
+                readonly label: Schema.String;
+                readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>;
+            readonly minItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        }>, Schema.Struct<{
+            readonly key: Schema.String;
+            readonly type: Schema.Literal<"external">;
+            readonly url: Schema.String;
+            readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>]>>;
+    }>>;
+}>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>>, false>;

package/dist/groups/form.js

@@ -0,0 +1,18 @@
+import { Form } from "@opencode/schema/form";
+import { Location } from "@opencode/schema/location";
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/http-api";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const makeFormGroup = (locationMiddleware) => HttpApiGroup.make("server.form")
+    .add(HttpApiEndpoint.get("form.list", "/api/form", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Form.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "form.list",
+    summary: "List pending forms",
+    description: "Retrieve pending forms for a location.",
+})))
+    .middleware(locationMiddleware)
+    .annotateMerge(OpenApi.annotations({ title: "form", description: "Location form routes." }));

package/dist/groups/fs.d.ts

@@ -0,0 +1,48 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import { FileNotFoundError } from "../errors.js";
+export declare const FileSystemGroup: HttpApiGroup.HttpApiGroup<"server.fs", HttpApiEndpoint.HttpApiEndpoint<"fs.find", "GET", "/api/fs/find", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+    readonly query: Schema.String;
+    readonly type: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["file", "directory"]>>>, Schema.optionalKey<Schema.Literals<readonly ["file", "directory"]>>, never, never>;
+    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.Struct<{
+        readonly path: Schema.brand<Schema.String, "RelativePath">;
+        readonly type: Schema.Literals<readonly ["file", "directory"]>;
+    }>>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.list", "GET", "/api/fs/list", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+    readonly path: 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 path: Schema.brand<Schema.String, "RelativePath">;
+        readonly type: Schema.Literals<readonly ["file", "directory"]>;
+    }>>;
+}>>, Schema.toCodecJson<typeof FileNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.read", "GET", "/api/fs/read/*", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Uint8Array>, Schema.toCodecJson<typeof FileNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"fs.write", "POST", "/api/experimental/fs/write", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+    readonly path: Schema.String;
+}>>, Schema.toCodecJson<Schema.Uint8Array>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.Struct<{
+        readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+}>>, never, never, never>, false>;

package/dist/groups/fs.js

@@ -0,0 +1,73 @@
+import { FileSystem } from "@opencode/schema/filesystem";
+import { Location } from "@opencode/schema/location";
+import { PositiveInt } from "@opencode/schema/schema";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import { FileNotFoundError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+const ListQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    path: Schema.String.pipe(Schema.optional).annotate({
+        description: "An absolute path or a path relative to the requested location. Defaults to the location directory.",
+    }),
+});
+const WriteQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    path: Schema.String.annotate({
+        description: "An absolute path or a path relative to the requested location. Missing parent directories are created.",
+    }),
+});
+const FindQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    query: FileSystem.FindInput.fields.query,
+    type: FileSystem.FindInput.fields.type,
+    limit: Schema.NumberFromString.pipe(Schema.decodeTo(PositiveInt), Schema.optional),
+});
+export const FileSystemGroup = HttpApiGroup.make("server.fs")
+    .add(HttpApiEndpoint.get("fs.read", "/api/fs/read/*", {
+    query: LocationQuery,
+    success: Schema.Uint8Array.pipe(HttpApiSchema.asUint8Array()),
+    error: FileNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "fs.read",
+    summary: "Read file",
+    description: "Stream one file relative to the requested location with ETag, Last-Modified, and single-range HTTP Range support (206 Partial Content, 416 Range Not Satisfiable, and 304 Not Modified; multi-range and malformed Range headers fall back to 200).",
+})))
+    .add(HttpApiEndpoint.get("fs.list", "/api/fs/list", {
+    query: ListQuery,
+    success: Location.response(Schema.Array(FileSystem.Entry)),
+    error: FileNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "fs.list",
+    summary: "List directory",
+    description: "List direct children using an absolute path or a path relative to the requested location, including parents and siblings outside its directory. Entry paths remain relative to the requested location; listing does not switch locations.",
+})))
+    .add(HttpApiEndpoint.get("fs.find", "/api/fs/find", {
+    query: FindQuery,
+    success: Location.response(Schema.Array(FileSystem.Entry)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "fs.find",
+    summary: "Find files",
+    description: "Find recursively ranked filesystem entries relative to the requested location.",
+})))
+    .add(HttpApiEndpoint.post("fs.write", "/api/experimental/fs/write", {
+    query: WriteQuery,
+    payload: Schema.Uint8Array.pipe(HttpApiSchema.asUint8Array()),
+    success: Location.response(FileSystem.Write),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "experimental.fs.write",
+    summary: "Write file",
+    description: "Write the raw request body to an absolute path or a path relative to the requested location, creating parent directories, and return the resolved absolute path. Unlike read, the target is not confined to the location. Experimental: may change without compatibility guarantees.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "filesystem",
+    description: "Experimental location-scoped filesystem routes.",
+}));

package/dist/groups/generate.d.ts

@@ -0,0 +1,33 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import { LocationNotFoundError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+export declare const GenerateGroup: HttpApiGroup.HttpApiGroup<"server.generate", HttpApiEndpoint.HttpApiEndpoint<"generate.text", "POST", "/api/experimental/generate", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly prompt: Schema.String;
+    readonly model: Schema.optional<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Model.ID">;
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+    }> & {
+        parse: (input: string) => {
+            readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+            readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+        };
+    }>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly text: Schema.String;
+    }>;
+}>>, Schema.toCodecJson<typeof LocationNotFoundError | typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/generate.js

@@ -0,0 +1,23 @@
+import { Model } from "@opencode/schema/model";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
+import { LocationNotFoundError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+export const GenerateGroup = HttpApiGroup.make("server.generate")
+    .add(HttpApiEndpoint.post("generate.text", "/api/experimental/generate", {
+    payload: Schema.Struct({
+        prompt: Schema.String,
+        model: Model.Ref.pipe(Schema.optional),
+    }),
+    success: Schema.Struct({
+        data: Schema.Struct({ text: Schema.String }),
+    }).annotate({ identifier: "GenerateTextResponse" }),
+    error: [InvalidRequestError, ServiceUnavailableError, LocationNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "experimental.generate.text",
+    summary: "Generate text",
+    description: "Run one stateless model generation using the server's base configuration and return the assistant text. Uses the base configuration's default model when none is specified.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "generate",
+    description: "Experimental one-shot generation routes.",
+}));