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

package/dist/location-event.js

@@ -0,0 +1,5 @@
+export * as LocationEvent from "./location-event.js";
+import { ephemeral, inventory } from "./event.js";
+/** The location's cached services were shut down; clients must revalidate its reads. */
+export const Shutdown = ephemeral({ type: "location.shutdown", schema: {} });
+export const Definitions = inventory(Shutdown);

package/dist/location.d.ts

@@ -0,0 +1,56 @@
+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>;
+}>;
+export declare const PublicRef: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export interface PublicRef extends Schema.Schema.Type<typeof PublicRef> {
+}
+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 const PublicInfo: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    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 interface PublicInfo extends Schema.Schema.Type<typeof PublicInfo> {
+}
+export declare function response<S extends Schema.Top>(data: S): Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: S;
+}>;

package/dist/location.js

@@ -0,0 +1,28 @@
+export * as Location from "./location.js";
+import { Schema, Struct } 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 const PublicRef = Schema.Struct(Struct.omit(Ref.fields, ["workspaceID"])).annotate({
+    identifier: "Location.PublicRef",
+});
+export class Info extends Schema.Class("Location.Info")({
+    directory: AbsolutePath,
+    workspaceID: optional(WorkspaceID),
+    project: Schema.Struct({
+        id: ProjectID,
+        directory: AbsolutePath,
+        canonical: AbsolutePath,
+    }),
+}) {
+}
+export const PublicInfo = Schema.Struct(Struct.omit(Info.fields, ["workspaceID"])).annotate({
+    identifier: "Location.PublicInfo",
+});
+export function response(data) {
+    return Schema.Struct({ location: PublicRef, 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,145 @@
+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 {
+}
+export type Protocol = typeof Protocol.Type;
+export declare const Protocol: Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>;
+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>;
+    readonly protocol: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>>>, Schema.optionalKey<Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>>, 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>;
+    readonly auth_server_metadata_url: 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>;
+    readonly protocol: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>>>, Schema.optionalKey<Schema.Literals<readonly ["legacy", "auto", "2026-07-28"]>>, 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">;
+    readonly error: Schema.String;
+}>]>;
+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 error: Schema.String;
+    }>]>;
+    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>;
+    }>]>>;
+}>;