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

package/dist/model.js

@@ -0,0 +1,115 @@
+export * as Model from "./model.js";
+import { Schema } from "effect";
+import { optional, statics } from "./schema.js";
+import { Provider } from "./provider.js";
+import { Compatibility, MaxTokensField, ReasoningField } from "./model-compatibility.js";
+import { Money } from "./money.js";
+import { ephemeral, inventory } from "./event.js";
+export const ID = Schema.String.pipe(Schema.brand("Model.ID"));
+const Updated = ephemeral({ type: "model.updated", schema: {} });
+export const Event = { Updated, Definitions: inventory(Updated) };
+export const VariantID = Schema.String.pipe(Schema.brand("Model.VariantID"));
+export const Ref = Schema.Struct({
+    id: ID,
+    providerID: Provider.ID,
+    variant: VariantID.pipe(optional),
+})
+    .annotate({ identifier: "Model.Ref" })
+    .pipe(statics((schema) => ({
+    parse: (input) => {
+        const providerEnd = input.indexOf("/");
+        if (providerEnd <= 0)
+            throw new Error(`Invalid model reference: ${input}`);
+        const providerID = input.slice(0, providerEnd);
+        const variantStart = input.indexOf("#", providerEnd + 1);
+        const id = input.slice(providerEnd + 1, variantStart === -1 ? undefined : variantStart);
+        const variant = variantStart === -1 ? undefined : input.slice(variantStart + 1);
+        if (!id || providerID.includes("#") || (variant !== undefined && (!variant || variant.includes("#"))))
+            throw new Error(`Invalid model reference: ${input}`);
+        return schema.make({
+            providerID: Provider.ID.make(providerID),
+            id: ID.make(id),
+            ...(variant ? { variant: VariantID.make(variant) } : {}),
+        });
+    },
+})));
+export { Compatibility, MaxTokensField, ReasoningField };
+export const Family = Schema.String.pipe(Schema.brand("Model.Family"));
+export const Settings = Schema.StructWithRest(Schema.Struct({
+    compaction: Provider.Compaction.pipe(optional),
+    encoding: Provider.Encoding.pipe(optional),
+}), 
+// Provider packages may define arbitrary model-level options beyond OpenCode's shared compaction policy.
+[Schema.Record(Schema.String, Schema.Any)]).annotate({ identifier: "Model.Settings" });
+export const Overlays = {
+    settings: Settings.pipe(optional),
+    headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    body: Schema.Record(Schema.String, Schema.Any).pipe(optional),
+};
+export const Capabilities = Schema.Struct({
+    tools: Schema.Boolean,
+    input: Schema.Array(Schema.String),
+    output: Schema.Array(Schema.String),
+    /** Whether the model accepts a sampling temperature. Unknown when unset. */
+    temperature: Schema.Boolean.pipe(optional),
+})
+    .annotate({ identifier: "Model.Capabilities" })
+    .pipe(statics(() => ({
+    default: () => ({ tools: true, input: ["text", "image"], output: ["text"] }),
+})));
+export const Cost = Schema.Struct({
+    tier: Schema.Struct({
+        type: Schema.tag("context"),
+        size: Schema.Int,
+    }).pipe(optional),
+    input: Money.USDPerMillionTokens,
+    output: Money.USDPerMillionTokens,
+    cache: Schema.Struct({
+        read: Money.USDPerMillionTokens,
+        write: Money.USDPerMillionTokens,
+    }),
+}).annotate({ identifier: "Model.Cost" });
+export const Variant = Schema.Struct({
+    id: VariantID,
+    ...Overlays,
+}).annotate({ identifier: "Model.Variant" });
+export const Info = Schema.Struct({
+    id: ID,
+    modelID: ID,
+    providerID: Provider.ID,
+    canonical: Provider.ID.pipe(optional),
+    family: Family.pipe(optional),
+    name: Schema.String,
+    compatibility: Compatibility.pipe(optional),
+    package: Provider.Package.pipe(optional),
+    ...Overlays,
+    capabilities: Capabilities,
+    variants: Schema.Array(Variant),
+    time: Schema.Struct({
+        released: Schema.Finite,
+    }),
+    cost: Schema.Array(Cost),
+    status: Schema.Literals(["alpha", "beta", "deprecated", "active"]),
+    enabled: Schema.Boolean,
+    limit: Schema.Struct({
+        context: Schema.Int,
+        input: Schema.Int.pipe(optional),
+        output: Schema.Int,
+    }),
+})
+    .annotate({ identifier: "Model.Info" })
+    .pipe(statics(() => ({
+    default: (providerID, id) => ({
+        id,
+        modelID: id,
+        providerID,
+        name: id,
+        capabilities: Capabilities.default(),
+        variants: [],
+        time: { released: 0 },
+        cost: [],
+        status: "active",
+        enabled: true,
+        limit: { context: 200_000, output: 32_000 },
+    }),
+})));

package/dist/models-dev.d.ts

@@ -0,0 +1,69 @@
+export * as ModelsDev from "./models-dev.js";
+export declare const Event: {
+    Refreshed: 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<"models-dev.refreshed">;
+        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: "models-dev.refreshed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: import("effect/Schema").Struct<{}>;
+    };
+    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<"models-dev.refreshed">;
+        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: "models-dev.refreshed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: import("effect/Schema").Struct<{}>;
+    }];
+};

package/dist/models-dev.js

@@ -0,0 +1,7 @@
+export * as ModelsDev from "./models-dev.js";
+import { ephemeral, inventory } from "./event.js";
+const Refreshed = ephemeral({
+    type: "models-dev.refreshed",
+    schema: {},
+});
+export const Event = { Refreshed, Definitions: inventory(Refreshed) };

package/dist/money.d.ts

@@ -0,0 +1,10 @@
+export * as Money from "./money.js";
+import { Schema } from "effect";
+export declare const USD: Schema.brand<Schema.Finite, "Money.USD"> & {
+    zero: number & import("effect/Brand").Brand<"Money.USD">;
+};
+export type USD = typeof USD.Type;
+export declare const USDPerMillionTokens: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+};
+export type USDPerMillionTokens = typeof USDPerMillionTokens.Type;

package/dist/money.js

@@ -0,0 +1,5 @@
+export * as Money from "./money.js";
+import { Schema } from "effect";
+import { statics } from "./schema.js";
+export const USD = Schema.Finite.pipe(Schema.brand("Money.USD"), Schema.annotate({ identifier: "Money.USD" }), statics((schema) => ({ zero: schema.make(0) })));
+export const USDPerMillionTokens = Schema.Finite.pipe(Schema.brand("Money.USDPerMillionTokens"), Schema.annotate({ identifier: "Money.USDPerMillionTokens" }), statics((schema) => ({ zero: schema.make(0) })));

package/dist/permission-saved.d.ts

@@ -0,0 +1,22 @@
+export * as PermissionSaved from "./permission-saved.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+    };
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly action: Schema.String;
+    readonly resource: Schema.String;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly updated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}

package/dist/permission-saved.js

@@ -0,0 +1,16 @@
+export * as PermissionSaved from "./permission-saved.js";
+import { Schema } from "effect";
+import { ascending } from "./identifier.js";
+import { ProjectID } from "./project-id.js";
+import { DateTimeUtcFromMillis, statics } from "./schema.js";
+export const ID = Schema.String.pipe(Schema.brand("PermissionSaved.ID"), Schema.annotate({ identifier: "PermissionSaved.ID" }), statics((schema) => ({ create: () => schema.make("psv_" + ascending()) })));
+export const Info = Schema.Struct({
+    id: ID,
+    projectID: ProjectID,
+    action: Schema.String,
+    resource: Schema.String,
+    time: Schema.Struct({
+        created: DateTimeUtcFromMillis,
+        updated: DateTimeUtcFromMillis,
+    }),
+}).annotate({ identifier: "PermissionSaved.Info" });

package/dist/permission-v1.d.ts

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

package/dist/permission-v1.js

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

package/dist/permission.d.ts

@@ -0,0 +1,302 @@
+export * as Permission from "./permission.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "Permission.ID"> & {
+    create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Source: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"tool">;
+    readonly messageID: Schema.String;
+    readonly id: Schema.String;
+}>]>;
+export type Source = typeof Source.Type;
+export declare const Request: Schema.Struct<{
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly action: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+    readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>, never, never>;
+    readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    };
+}>;
+export interface Request extends Schema.Schema.Type<typeof Request> {
+}
+export declare const Reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+export type Reply = typeof Reply.Type;
+export declare const Event: {
+    Asked: 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<"permission.asked">;
+        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly id: Schema.String;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly id: Schema.String;
+            }>]>>, never, never>;
+            readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+            };
+        }>;
+    }> & {
+        type: "permission.asked";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly id: Schema.String;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly id: Schema.String;
+            }>]>>, never, never>;
+            readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+            };
+        }>;
+    };
+    Replied: 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<"permission.replied">;
+        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "Permission.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    }> & {
+        type: "permission.replied";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "Permission.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    };
+    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<"permission.asked">;
+        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly id: Schema.String;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly id: Schema.String;
+            }>]>>, never, never>;
+            readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+            };
+        }>;
+    }> & {
+        type: "permission.asked";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly id: Schema.String;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly id: Schema.String;
+            }>]>>, never, never>;
+            readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+            };
+        }>;
+    }, 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<"permission.replied">;
+        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "Permission.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    }> & {
+        type: "permission.replied";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "Permission.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    }];
+};
+export declare const Effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+export type Effect = typeof Effect.Type;
+export interface Rule extends Schema.Schema.Type<typeof Rule> {
+}
+export declare const Rule: Schema.Struct<{
+    readonly action: Schema.String;
+    readonly resource: Schema.String;
+    readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+}>;
+export declare const Ruleset: Schema.$Array<Schema.Struct<{
+    readonly action: Schema.String;
+    readonly resource: Schema.String;
+    readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+}>>;
+export type Ruleset = typeof Ruleset.Type;

package/dist/permission.js

@@ -0,0 +1,46 @@
+export * as Permission from "./permission.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { ephemeral, inventory } from "./event.js";
+import { ascending } from "./identifier.js";
+import { SessionID } from "./session-id.js";
+import { statics } from "./schema.js";
+export const ID = Schema.String.check(Schema.isStartingWith("per")).pipe(Schema.brand("Permission.ID"), Schema.annotate({ identifier: "Permission.ID" }), statics((schema) => ({ create: (id) => schema.make(id ?? "per_" + ascending()) })));
+export const Source = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("tool"),
+        messageID: Schema.String,
+        id: Schema.String,
+    }),
+]).annotate({ identifier: "Permission.Source" });
+const RequestFields = {
+    sessionID: SessionID,
+    action: Schema.String,
+    resources: Schema.Array(Schema.String),
+    save: Schema.Array(Schema.String).pipe(optional),
+    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+    source: Source.pipe(optional),
+    message: Schema.String.pipe(optional),
+};
+export const Request = Schema.Struct({
+    id: ID,
+    ...RequestFields,
+}).annotate({ identifier: "Permission.Request" });
+export const Reply = Schema.Literals(["once", "always", "reject"]).annotate({ identifier: "Permission.Reply" });
+const Asked = ephemeral({ type: "permission.asked", schema: Request.fields });
+const Replied = ephemeral({
+    type: "permission.replied",
+    schema: {
+        sessionID: SessionID,
+        requestID: ID,
+        reply: Reply,
+    },
+});
+export const Event = { Asked, Replied, Definitions: inventory(Asked, Replied) };
+export const Effect = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "Permission.Effect" });
+export const Rule = Schema.Struct({
+    action: Schema.String,
+    resource: Schema.String,
+    effect: Effect,
+}).annotate({ identifier: "Permission.Rule" });
+export const Ruleset = Schema.Array(Rule).annotate({ identifier: "Permission.Ruleset" });