@opencode-ai/schema 0.0.0-next-14659

package/dist/legacy-event.js

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

package/dist/llm.d.ts

@@ -0,0 +1,28 @@
+export * as LLM from "./llm.js";
+import { Schema } from "effect";
+export declare const ProviderMetadata: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
+export type ProviderMetadata = Schema.Schema.Type<typeof ProviderMetadata>;
+export interface ToolTextContent extends Schema.Schema.Type<typeof ToolTextContent> {
+}
+export declare const ToolTextContent: Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+}>;
+export interface ToolFileContent extends Schema.Schema.Type<typeof ToolFileContent> {
+}
+export declare const ToolFileContent: Schema.Struct<{
+    readonly type: Schema.Literal<"file">;
+    readonly uri: Schema.String;
+    readonly mime: Schema.String;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export declare const ToolContent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"file">;
+    readonly uri: Schema.String;
+    readonly mime: Schema.String;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>]>;
+export type ToolContent = Schema.Schema.Type<typeof ToolContent>;

package/dist/llm.js

@@ -0,0 +1,19 @@
+export * as LLM from "./llm.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown)).annotate({
+    identifier: "LLM.ProviderMetadata",
+});
+export const ToolTextContent = Schema.Struct({
+    type: Schema.Literal("text"),
+    text: Schema.String,
+}).annotate({ identifier: "Tool.TextContent" });
+export const ToolFileContent = Schema.Struct({
+    type: Schema.Literal("file"),
+    uri: Schema.String,
+    mime: Schema.String,
+    name: optional(Schema.String),
+}).annotate({ identifier: "Tool.FileContent" });
+export const ToolContent = Schema.Union([ToolTextContent, ToolFileContent])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "LLM.ToolContent" });

package/dist/location.d.ts

@@ -0,0 +1,36 @@
+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, "WorkspaceV2.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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, "WorkspaceV2.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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">;
+    }>;
+}>, {}>;
+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,21 @@
+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,
+    }),
+}) {
+}
+export function response(data) {
+    return Schema.Struct({ location: Info, data });
+}

package/dist/lsp-event.d.ts

@@ -0,0 +1,87 @@
+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 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 durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    data: import("effect/Schema").Struct<{}>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "lsp.updated";
+};
+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 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 durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    data: import("effect/Schema").Struct<{}>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "lsp.updated";
+}];

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.define({ type: "lsp.updated", schema: {} });
+export const Definitions = Event.inventory(Updated);

package/dist/mcp-event.d.ts

@@ -0,0 +1,286 @@
+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 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 durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "mcp.tools.changed";
+};
+export declare const BrowserOpenFailed: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    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.browser.open.failed">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly mcpName: Schema.String;
+        readonly url: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly mcpName: Schema.String;
+        readonly url: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "mcp.browser.open.failed";
+};
+export declare const StatusChanged: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    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 durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "mcp.status.changed";
+};
+export declare const Definitions: readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    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 durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "mcp.tools.changed";
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    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.browser.open.failed">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly mcpName: Schema.String;
+        readonly url: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly mcpName: Schema.String;
+        readonly url: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "mcp.browser.open.failed";
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    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 durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.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, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly server: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "mcp.status.changed";
+}];

package/dist/mcp-event.js

@@ -0,0 +1,25 @@
+export * as McpEvent from "./mcp-event.js";
+import { Schema } from "effect";
+import { Event } from "./event.js";
+export const ToolsChanged = Event.define({
+    type: "mcp.tools.changed",
+    schema: {
+        server: Schema.String,
+    },
+});
+export const BrowserOpenFailed = Event.define({
+    type: "mcp.browser.open.failed",
+    schema: {
+        mcpName: Schema.String,
+        url: 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.define({
+    type: "mcp.status.changed",
+    schema: {
+        server: Schema.String,
+    },
+});
+export const Definitions = Event.inventory(ToolsChanged, BrowserOpenFailed, StatusChanged);

package/dist/mcp.d.ts

@@ -0,0 +1,39 @@
+export * as Mcp from "./mcp.js";
+import { Schema } from "effect";
+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<"disconnected">;
+}>, 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">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"needs_client_registration">;
+    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<"disconnected">;
+    }>, 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">;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"needs_client_registration">;
+        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>;
+}>;

package/dist/mcp.js

@@ -0,0 +1,38 @@
+export * as Mcp from "./mcp.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { IntegrationID } from "./integration-id.js";
+const Connected = Schema.Struct({ status: Schema.Literal("connected") }).annotate({
+    identifier: "Mcp.Status.Connected",
+});
+const Disconnected = Schema.Struct({ status: Schema.Literal("disconnected") }).annotate({
+    identifier: "Mcp.Status.Disconnected",
+});
+const Disabled = Schema.Struct({ status: Schema.Literal("disabled") }).annotate({
+    identifier: "Mcp.Status.Disabled",
+});
+const Failed = Schema.Struct({ status: Schema.Literal("failed"), error: Schema.String }).annotate({
+    identifier: "Mcp.Status.Failed",
+});
+const NeedsAuth = Schema.Struct({ status: Schema.Literal("needs_auth") }).annotate({
+    identifier: "Mcp.Status.NeedsAuth",
+});
+const NeedsClientRegistration = Schema.Struct({
+    status: Schema.Literal("needs_client_registration"),
+    error: Schema.String,
+}).annotate({ identifier: "Mcp.Status.NeedsClientRegistration" });
+export const Status = Schema.Union([
+    Connected,
+    Disconnected,
+    Disabled,
+    Failed,
+    NeedsAuth,
+    NeedsClientRegistration,
+]).pipe(Schema.toTaggedUnion("status"));
+export const Server = Schema.Struct({
+    name: Schema.String,
+    status: Status,
+    // Set for remote servers registered as OAuth integrations; lets clients act on the right integration
+    // without matching by name, which could collide with provider or plugin integrations.
+    integrationID: optional(IntegrationID),
+}).annotate({ identifier: "Mcp.Server" });