@opencode-ai/schema 0.0.0-dev-18706 → 0.0.0-dev-18708

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export { Project } from "./project.js";
 export { Worktree } from "./worktree.js";
 export { Provider } from "./provider.js";
 export { Reference } from "./reference.js";
+export { Rpc } from "./rpc.js";
 export { WebSearch } from "./websearch.js";
 export { Session } from "./session.js";
 export { Vcs } from "./vcs.js";

package/dist/index.js

@@ -18,6 +18,7 @@ export { Project } from "./project.js";
 export { Worktree } from "./worktree.js";
 export { Provider } from "./provider.js";
 export { Reference } from "./reference.js";
+export { Rpc } from "./rpc.js";
 export { WebSearch } from "./websearch.js";
 export { Session } from "./session.js";
 export { Vcs } from "./vcs.js";

package/dist/plugin.d.ts

@@ -14,22 +14,22 @@ export declare const Source: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"sdk">;
 }>]>;
 export type Source = typeof Source.Type;
-export declare const Info: Schema.Union<readonly [Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Plugin.ID">;
-    readonly source: Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"builtin">;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"package">;
-        readonly package: Schema.String;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"local">;
-        readonly path: Schema.String;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"sdk">;
-    }>]>;
+export declare const Features: Schema.Struct<{
+    readonly server: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literal<true>>>, Schema.optionalKey<Schema.Literal<true>>, never, never>;
+    readonly tui: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literal<true>>>, Schema.optionalKey<Schema.Literal<true>>, never, never>;
+    readonly rpc: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literal<true>>>, Schema.optionalKey<Schema.Literal<true>>, never, never>;
+}>;
+export type Features = typeof Features.Type;
+export declare const State: Schema.Union<readonly [Schema.Struct<{
     readonly status: Schema.Literal<"active">;
-    readonly tui: Schema.Boolean;
 }>, Schema.Struct<{
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.String;
+}>]>;
+export type State = typeof State.Type;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
     readonly id: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Plugin.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Plugin.ID">>, never, never>;
     readonly source: Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"builtin">;
@@ -42,11 +42,18 @@ export declare const Info: Schema.Union<readonly [Schema.Struct<{
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"sdk">;
     }>]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.String;
-    readonly tui: Schema.Boolean;
-}>]>;
-export type Info = typeof Info.Type;
+    readonly features: Schema.Struct<{
+        readonly server: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literal<true>>>, Schema.optionalKey<Schema.Literal<true>>, never, never>;
+        readonly tui: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literal<true>>>, Schema.optionalKey<Schema.Literal<true>>, never, never>;
+        readonly rpc: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literal<true>>>, Schema.optionalKey<Schema.Literal<true>>, never, never>;
+    }>;
+    readonly state: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"active">;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"failed">;
+        readonly error: Schema.String;
+    }>]>;
+}>;
 export declare const Event: {
     Added: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {

package/dist/plugin.js

@@ -9,21 +9,21 @@ export const Source = Schema.Union([
     Schema.Struct({ type: Schema.Literal("local"), path: Schema.String }),
     Schema.Struct({ type: Schema.Literal("sdk") }),
 ]).annotate({ identifier: "Plugin.Source" });
-export const Info = Schema.Union([
-    Schema.Struct({
-        id: ID,
-        source: Source,
-        status: Schema.Literal("active"),
-        tui: Schema.Boolean,
-    }),
-    Schema.Struct({
-        id: ID.pipe(optional),
-        source: Source,
-        status: Schema.Literal("failed"),
-        error: Schema.String,
-        tui: Schema.Boolean,
-    }),
-]).annotate({ identifier: "Plugin.Info" });
+export const Features = Schema.Struct({
+    server: Schema.Literal(true).pipe(optional),
+    tui: Schema.Literal(true).pipe(optional),
+    rpc: Schema.Literal(true).pipe(optional),
+}).annotate({ identifier: "Plugin.Features" });
+export const State = Schema.Union([
+    Schema.Struct({ status: Schema.Literal("active") }),
+    Schema.Struct({ status: Schema.Literal("failed"), error: Schema.String }),
+]).annotate({ identifier: "Plugin.State" });
+export const Info = Schema.Struct({
+    id: ID.pipe(optional),
+    source: Source,
+    features: Features,
+    state: State,
+}).annotate({ identifier: "Plugin.Info" });
 const Added = ephemeral({
     type: "plugin.added",
     schema: { id: ID },

package/dist/rpc.d.ts

@@ -0,0 +1,111 @@
+export * as Rpc from "./rpc.js";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { JsonSchema, Schema } from "effect";
+import type { Event } from "./event.js";
+import type { Location } from "./location.js";
+import type { Tool } from "./tool.js";
+export type ErrorMap = Readonly<Record<string, Tool.ValueSchema>> & {
+    readonly [Name in `rpc.${string}`]?: never;
+};
+export interface Method {
+    readonly input: Tool.ValueSchema;
+    readonly output: Tool.ValueSchema;
+    readonly errors?: ErrorMap;
+}
+export type PortableValueSchema = StandardSchemaV1<unknown, unknown> | JsonSchema.JsonSchema;
+export interface PortableMethod extends Method {
+    readonly input: PortableValueSchema;
+    readonly output: PortableValueSchema;
+    readonly errors?: Readonly<Record<string, PortableValueSchema>> & {
+        readonly [Name in `rpc.${string}`]?: never;
+    };
+}
+type EventDataObject = Readonly<Record<string, unknown>>;
+type EventValueSchema = Schema.Codec<EventDataObject, EventDataObject> | StandardSchemaV1<unknown, EventDataObject> | (JsonSchema.JsonSchema & {
+    readonly type: "object";
+});
+type PortableEventValueSchema = StandardSchemaV1<unknown, EventDataObject> | (JsonSchema.JsonSchema & {
+    readonly type: "object";
+});
+export interface EventDefinition {
+    readonly schema: EventValueSchema;
+}
+export type PortableEventDefinition = EventDefinition & {
+    readonly schema: PortableEventValueSchema;
+};
+export interface Definition {
+    readonly id: string;
+    readonly methods: Readonly<Record<string, Method>> & {
+        readonly events?: never;
+    };
+    readonly events: Readonly<Record<string, EventDefinition>>;
+}
+export interface PortableDefinition extends Definition {
+    readonly methods: Readonly<Record<string, PortableMethod>> & {
+        readonly events?: never;
+    };
+    readonly events: Readonly<Record<string, PortableEventDefinition>>;
+}
+export declare function define<const D extends Definition>(definition: D): D;
+export type Input<S extends Tool.ValueSchema> = S extends Schema.Top ? S["Encoded"] : S extends StandardSchemaV1 ? StandardSchemaV1.InferInput<S> : unknown;
+export type Output<S extends Tool.ValueSchema> = S extends Schema.Top ? S["Type"] : S extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<S> : unknown;
+export type HandlerOutput<S extends Tool.ValueSchema> = S extends Schema.Top ? Output<S> : Input<S>;
+type MethodErrors<M extends Method> = M extends {
+    readonly errors: infer Errors extends ErrorMap;
+} ? Errors : never;
+type ErrorSchema<M extends Method, Name extends ErrorName<M>> = MethodErrors<M>[Name];
+type ErrorData<Data> = unknown extends Data ? {
+    readonly data: Data;
+} : undefined extends Data ? {
+    readonly data?: Data;
+} : {
+    readonly data: Data;
+};
+type ErrorDataArguments<Data> = unknown extends Data ? [data: Data] : undefined extends Data ? [data?: Data] : [data: Data];
+type Simplify<A> = {
+    readonly [K in keyof A]: A[K];
+};
+declare const HandlerErrorTypeId: unique symbol;
+export interface Failure<Type extends string = string, Data = unknown> {
+    readonly type: Type;
+    readonly message: string;
+    readonly data?: Data;
+}
+export type SystemError = Failure<"rpc.unavailable" | "rpc.method_not_found" | "rpc.invalid_input" | "rpc.invalid_output" | "rpc.internal", never>;
+export type ErrorName<M extends Method> = M extends {
+    readonly errors: infer Errors extends ErrorMap;
+} ? Exclude<keyof Errors & string, `rpc.${string}`> : never;
+export type HandlerErrorFor<M extends Method, Name extends ErrorName<M>> = Simplify<{
+    readonly type: Name;
+    readonly message: string;
+    readonly [HandlerErrorTypeId]: true;
+} & ErrorData<HandlerOutput<ErrorSchema<M, Name>>>>;
+export type HandlerError<M extends Method> = {
+    readonly [Name in ErrorName<M>]: HandlerErrorFor<M, Name>;
+}[ErrorName<M>];
+export type MethodErrorFor<M extends Method, Name extends ErrorName<M>> = Simplify<{
+    readonly type: Name;
+    readonly message: string;
+} & ErrorData<Output<ErrorSchema<M, Name>>>>;
+export type MethodError<M extends Method> = {
+    readonly [Name in ErrorName<M>]: MethodErrorFor<M, Name>;
+}[ErrorName<M>];
+export type ErrorArguments<M extends Method, Name extends ErrorName<M>> = [
+    type: Name,
+    message: string,
+    ...data: ErrorDataArguments<HandlerOutput<ErrorSchema<M, Name>>>
+];
+export type ErrorFactory<M extends Method> = <Name extends ErrorName<M>>(...args: ErrorArguments<M, Name>) => HandlerErrorFor<M, Name>;
+export type EventInputData<S extends EventValueSchema> = S extends JsonSchema.JsonSchema ? EventDataObject : HandlerOutput<S>;
+export type EventData<S extends EventValueSchema> = S extends JsonSchema.JsonSchema ? EventDataObject : Output<S>;
+export type EventInput<D extends Definition> = {
+    [Name in keyof D["events"] & string]: [name: Name, data: EventInputData<D["events"][Name]["schema"]>];
+}[keyof D["events"] & string];
+type EventPayloadFor<D extends Definition, Name extends keyof D["events"] & string> = Omit<Event.Payload<Event.EphemeralDefinition>, "type" | "data" | "durable" | "location"> & {
+    readonly type: `rpc.${D["id"]}.${Name}`;
+    readonly data: EventData<D["events"][Name]["schema"]>;
+    readonly location: Location.Ref;
+};
+export type EventPayload<D extends Definition, Name extends keyof D["events"] & string = keyof D["events"] & string> = {
+    readonly [K in Name]: EventPayloadFor<D, K>;
+}[Name];

package/dist/rpc.js

@@ -0,0 +1,9 @@
+export * as Rpc from "./rpc.js";
+export function define(definition) {
+    const reserved = Object.values(definition.methods)
+        .flatMap((method) => Object.keys(method.errors ?? {}))
+        .find((name) => name.startsWith("rpc."));
+    if (reserved)
+        throw new Error(`RPC error names starting with "rpc." are reserved: ${reserved}`);
+    return definition;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/schema",
-  "version": "0.0.0-dev-18706",
+  "version": "0.0.0-dev-18708",
   "type": "module",
   "license": "MIT",
   "repository": {