@opencode-ai/schema 0.0.0-dev-17471

package/dist/integration.js

@@ -0,0 +1,87 @@
+export * as Integration from "./integration.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { ephemeral, inventory } from "./event.js";
+import { Connection } from "./connection.js";
+import { ascending } from "./identifier.js";
+import { statics } from "./schema.js";
+import { IntegrationID, IntegrationMethodID } from "./integration-id.js";
+import { Form } from "./form.js";
+export const ID = IntegrationID;
+export const MethodID = IntegrationMethodID;
+export const OAuthMethod = Schema.Struct({
+    id: MethodID,
+    type: Schema.Literal("oauth"),
+    label: Schema.String,
+    form: optional(Form.Fields),
+}).annotate({ identifier: "Integration.OAuthMethod" });
+export const CommandMethod = Schema.Struct({
+    id: MethodID,
+    type: Schema.Literal("command"),
+    label: Schema.String,
+    command: Schema.Array(Schema.String),
+}).annotate({ identifier: "Integration.CommandMethod" });
+export const KeyMethod = Schema.Struct({
+    type: Schema.Literal("key"),
+    label: optional(Schema.String),
+    form: optional(Form.Fields),
+}).annotate({ identifier: "Integration.KeyMethod" });
+export const EnvMethod = Schema.Struct({
+    type: Schema.Literal("env"),
+    names: Schema.Array(Schema.String),
+}).annotate({ identifier: "Integration.EnvMethod" });
+export const Method = Schema.Union([OAuthMethod, CommandMethod, KeyMethod, EnvMethod])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Integration.Method" });
+const Updated = ephemeral({
+    type: "integration.updated",
+    schema: {},
+});
+const ConnectionUpdated = ephemeral({
+    type: "integration.connection.updated",
+    schema: { integrationID: ID },
+});
+export const Event = { Updated, ConnectionUpdated, Definitions: inventory(Updated, ConnectionUpdated) };
+export const Ref = Schema.Struct({
+    id: ID,
+    name: Schema.String,
+}).annotate({ identifier: "Integration.Ref" });
+export const Info = Schema.Struct({
+    id: ID,
+    name: Schema.String,
+    methods: Schema.Array(Method),
+    connections: Schema.Array(Connection.Info),
+}).annotate({ identifier: "Integration.Info" });
+export const AttemptID = Schema.String.pipe(Schema.brand("Integration.AttemptID"), statics((schema) => ({ create: () => schema.make("con_" + ascending()) })));
+const AttemptTime = Schema.Struct({
+    created: Schema.Number,
+    expires: Schema.Number,
+});
+export class Attempt extends Schema.Class("Integration.Attempt")({
+    attemptID: AttemptID,
+    url: Schema.String,
+    instructions: Schema.String,
+    mode: Schema.Literals(["auto", "code"]),
+    time: AttemptTime,
+}) {
+}
+export const AttemptStatus = Schema.Union([
+    Schema.Struct({ status: Schema.Literal("pending"), time: AttemptTime }),
+    Schema.Struct({ status: Schema.Literal("complete"), time: AttemptTime }),
+    Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String, time: AttemptTime }),
+    Schema.Struct({ status: Schema.Literal("expired"), time: AttemptTime }),
+])
+    .pipe(Schema.toTaggedUnion("status"))
+    .annotate({ identifier: "Integration.AttemptStatus" });
+export const CommandAttempt = Schema.Struct({
+    attemptID: AttemptID,
+    time: AttemptTime,
+}).annotate({ identifier: "Integration.CommandAttempt" });
+export const CommandAttemptStatus = Schema.Union([
+    Schema.Struct({ status: Schema.Literal("pending"), message: optional(Schema.String), time: AttemptTime }),
+    Schema.Struct({ status: Schema.Literal("complete"), time: AttemptTime }),
+    Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String, time: AttemptTime }),
+    Schema.Struct({ status: Schema.Literal("expired"), time: AttemptTime }),
+])
+    .pipe(Schema.toTaggedUnion("status"))
+    .annotate({ identifier: "Integration.CommandAttemptStatus" });

package/dist/legacy-event.d.ts

@@ -0,0 +1 @@
+export * from "./v1/legacy-event.js";

package/dist/legacy-event.js

@@ -0,0 +1 @@
+export * from "./v1/legacy-event.js";

package/dist/llm.d.ts

@@ -0,0 +1,4 @@
+export * as LLM from "./llm.js";
+import { Schema } from "effect";
+export declare const FinishReason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+export type FinishReason = typeof FinishReason.Type;

package/dist/llm.js

@@ -0,0 +1,3 @@
+export * as LLM from "./llm.js";
+import { Schema } from "effect";
+export const FinishReason = Schema.Literals(["stop", "length", "tool-calls", "content-filter", "error", "unknown"]);

package/dist/location.d.ts

@@ -0,0 +1,37 @@
+export * as Location from "./location.js";
+import { Schema } from "effect";
+export interface Ref extends Schema.Schema.Type<typeof Ref> {
+}
+export declare const Ref: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>, never, never>;
+}>;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>, never, never>;
+    readonly project: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+            global: string & import("effect/Brand").Brand<"Project.ID">;
+        };
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+export declare function response<S extends Schema.Top>(data: S): Schema.Struct<{
+    readonly location: typeof Info;
+    readonly data: S;
+}>;

package/dist/location.js

@@ -0,0 +1,22 @@
+export * as Location from "./location.js";
+import { Schema } from "effect";
+import { AbsolutePath, optional } from "./schema.js";
+import { ProjectID } from "./project-id.js";
+import { WorkspaceID } from "./workspace-id.js";
+export const Ref = Schema.Struct({
+    directory: AbsolutePath,
+    workspaceID: optional(WorkspaceID),
+}).annotate({ identifier: "Location.Ref" });
+export class Info extends Schema.Class("Location.Info")({
+    directory: AbsolutePath,
+    workspaceID: optional(WorkspaceID),
+    project: Schema.Struct({
+        id: ProjectID,
+        directory: AbsolutePath,
+        canonical: AbsolutePath,
+    }),
+}) {
+}
+export function response(data) {
+    return Schema.Struct({ location: Info, data });
+}

package/dist/lsp-event.d.ts

@@ -0,0 +1,67 @@
+export * as LspEvent from "./lsp-event.js";
+export declare const Updated: import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: import("effect/Schema").Finite;
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"lsp.updated">;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "lsp.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+};
+export declare const Definitions: readonly [import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: import("effect/Schema").Finite;
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"lsp.updated">;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "lsp.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+}];

package/dist/lsp-event.js

@@ -0,0 +1,4 @@
+export * as LspEvent from "./lsp-event.js";
+import { Event } from "./event.js";
+export const Updated = Event.ephemeral({ type: "lsp.updated", schema: {} });
+export const Definitions = Event.inventory(Updated);

package/dist/mcp-event.d.ts

@@ -0,0 +1,222 @@
+export * as McpEvent from "./mcp-event.js";
+import { Schema } from "effect";
+export declare const ToolsChanged: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"mcp.tools.changed">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    type: "mcp.tools.changed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+};
+export declare const ResourcesChanged: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"mcp.resources.changed">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    type: "mcp.resources.changed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+};
+export declare const StatusChanged: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"mcp.status.changed">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    type: "mcp.status.changed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+};
+export declare const Definitions: readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"mcp.tools.changed">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    type: "mcp.tools.changed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"mcp.resources.changed">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    type: "mcp.resources.changed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"mcp.status.changed">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    type: "mcp.status.changed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}];

package/dist/mcp-event.js

@@ -0,0 +1,24 @@
+export * as McpEvent from "./mcp-event.js";
+import { Schema } from "effect";
+import { Event } from "./event.js";
+export const ToolsChanged = Event.ephemeral({
+    type: "mcp.tools.changed",
+    schema: {
+        server: Schema.String,
+    },
+});
+export const ResourcesChanged = Event.ephemeral({
+    type: "mcp.resources.changed",
+    schema: {
+        server: Schema.String,
+    },
+});
+// Emitted whenever a server's connection status settles (connected, failed, needs_auth, closed) so
+// observers can refresh status without polling.
+export const StatusChanged = Event.ephemeral({
+    type: "mcp.status.changed",
+    schema: {
+        server: Schema.String,
+    },
+});
+export const Definitions = Event.inventory(ToolsChanged, ResourcesChanged, StatusChanged);

package/dist/mcp.d.ts

@@ -0,0 +1,138 @@
+export * as Mcp from "./mcp.js";
+import { Schema } from "effect";
+declare const TimeoutConfig_base: Schema.Class<TimeoutConfig, Schema.Struct<{
+    readonly startup: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly catalog: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly execution: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>, {}>;
+export declare class TimeoutConfig extends TimeoutConfig_base {
+}
+declare const LocalConfig_base: Schema.Class<LocalConfig, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly command: Schema.$Array<Schema.String>;
+    readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly environment: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly codemode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<typeof TimeoutConfig>>, Schema.optionalKey<typeof TimeoutConfig>, never, never>;
+}>, {}>;
+export declare class LocalConfig extends LocalConfig_base {
+}
+declare const OAuthConfig_base: Schema.Class<OAuthConfig, Schema.Struct<{
+    readonly client_id: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly client_secret: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly scope: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly callback_port: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly redirect_uri: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>, {}>;
+export declare class OAuthConfig extends OAuthConfig_base {
+}
+declare const RemoteConfig_base: Schema.Class<RemoteConfig, Schema.Struct<{
+    readonly type: Schema.Literal<"remote">;
+    readonly url: Schema.String;
+    readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly oauth: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [typeof OAuthConfig, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [typeof OAuthConfig, Schema.Literal<false>]>>, never, never>;
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly codemode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<typeof TimeoutConfig>>, Schema.optionalKey<typeof TimeoutConfig>, never, never>;
+}>, {}>;
+export declare class RemoteConfig extends RemoteConfig_base {
+}
+export declare const ServerConfig: Schema.toTaggedUnion<"type", readonly [typeof LocalConfig, typeof RemoteConfig]>;
+export type ServerConfig = typeof ServerConfig.Type;
+export type Status = typeof Status.Type;
+export declare const Status: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"connected">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"pending">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"disabled">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.String;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"needs_auth">;
+}>]>;
+export interface Server extends Schema.Schema.Type<typeof Server> {
+}
+export declare const Server: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly status: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"connected">;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"pending">;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"disabled">;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"failed">;
+        readonly error: Schema.String;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"needs_auth">;
+    }>]>;
+    readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
+}>;
+export interface Resource extends Schema.Schema.Type<typeof Resource> {
+}
+export declare const Resource: Schema.Struct<{
+    readonly server: Schema.String;
+    readonly name: Schema.String;
+    readonly uri: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export interface ResourceTemplate extends Schema.Schema.Type<typeof ResourceTemplate> {
+}
+export declare const ResourceTemplate: Schema.Struct<{
+    readonly server: Schema.String;
+    readonly name: Schema.String;
+    readonly uriTemplate: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export interface ResourceCatalog extends Schema.Schema.Type<typeof ResourceCatalog> {
+}
+export declare const ResourceCatalog: Schema.Struct<{
+    readonly resources: Schema.$Array<Schema.Struct<{
+        readonly server: Schema.String;
+        readonly name: Schema.String;
+        readonly uri: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>;
+    readonly templates: Schema.$Array<Schema.Struct<{
+        readonly server: Schema.String;
+        readonly name: Schema.String;
+        readonly uriTemplate: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>;
+}>;
+export declare const ResourceContentPart: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly uri: Schema.String;
+    readonly text: Schema.String;
+    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"blob">;
+    readonly uri: Schema.String;
+    readonly blob: Schema.String;
+    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>]>;
+export type ResourceContentPart = typeof ResourceContentPart.Type;
+export interface ResourceContent extends Schema.Schema.Type<typeof ResourceContent> {
+}
+export declare const ResourceContent: Schema.Struct<{
+    readonly server: Schema.String;
+    readonly uri: Schema.String;
+    readonly contents: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly uri: Schema.String;
+        readonly text: Schema.String;
+        readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob">;
+        readonly uri: Schema.String;
+        readonly blob: Schema.String;
+        readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>]>>;
+}>;