@opencode-ai/schema 0.0.0-next-14659

package/dist/agent.d.ts

@@ -0,0 +1,175 @@
+export * as Agent from "./agent.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "AgentV2.ID">;
+export type ID = typeof ID.Type;
+export declare const Color: Schema.Union<readonly [Schema.String, Schema.Literals<readonly ["primary", "secondary", "accent", "success", "warning", "error", "info"]>]>;
+export type Color = typeof Color.Type;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "AgentV2.ID">;
+    readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+    }>>, never, never>;
+    readonly request: Schema.Struct<{
+        readonly headers: Schema.$Record<Schema.String, Schema.String>;
+        readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>;
+    readonly system: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly mode: Schema.Literals<readonly ["subagent", "primary", "all"]>;
+    readonly hidden: Schema.Boolean;
+    readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.String, Schema.Literals<readonly ["primary", "secondary", "accent", "success", "warning", "error", "info"]>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Literals<readonly ["primary", "secondary", "accent", "success", "warning", "error", "info"]>]>>, never, never>;
+    readonly steps: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly permissions: Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>;
+}> & {
+    empty: (id: ID) => {
+        readonly id: string & import("effect/Brand").Brand<"AgentV2.ID">;
+        readonly request: {
+            readonly headers: {
+                readonly [x: string]: string;
+            };
+            readonly body: {
+                readonly [x: string]: Schema.Json;
+            };
+        };
+        readonly mode: "primary" | "subagent" | "all";
+        readonly hidden: boolean;
+        readonly permissions: readonly {
+            readonly action: string;
+            readonly resource: string;
+            readonly effect: "allow" | "deny" | "ask";
+        }[];
+        readonly model?: {
+            readonly id: string & import("effect/Brand").Brand<"ModelV2.ID">;
+            readonly providerID: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            readonly variant?: (string & import("effect/Brand").Brand<"VariantID">) | undefined;
+        } | undefined;
+        readonly system?: string | undefined;
+        readonly description?: string | undefined;
+        readonly color?: string | undefined;
+        readonly steps?: number | undefined;
+    };
+};
+export declare const Event: {
+    Updated: 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<"agent.updated">;
+        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<{}>;
+    }> & {
+        data: Schema.Struct<{}>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "agent.updated";
+    };
+    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<"agent.updated">;
+        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<{}>;
+    }> & {
+        data: Schema.Struct<{}>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "agent.updated";
+    }];
+};

package/dist/agent.js

@@ -0,0 +1,43 @@
+export * as Agent from "./agent.js";
+import { Schema } from "effect";
+import { define, inventory } from "./event.js";
+import { optional } from "./schema.js";
+import { Model } from "./model.js";
+import { Permission } from "./permission.js";
+import { Provider } from "./provider.js";
+import { PositiveInt, statics } from "./schema.js";
+const Updated = define({ type: "agent.updated", schema: {} });
+export const ID = Schema.String.pipe(Schema.brand("AgentV2.ID"));
+export const Color = Schema.Union([
+    Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/)),
+    Schema.Literals(["primary", "secondary", "accent", "success", "warning", "error", "info"]),
+]).annotate({ identifier: "Agent.Color" });
+export const Info = Schema.Struct({
+    id: ID,
+    model: Model.Ref.pipe(optional),
+    request: Provider.Request,
+    system: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    mode: Schema.Literals(["subagent", "primary", "all"]),
+    hidden: Schema.Boolean,
+    color: Color.pipe(optional),
+    steps: PositiveInt.pipe(optional),
+    permissions: Permission.Ruleset,
+})
+    .annotate({ identifier: "AgentV2.Info" })
+    .pipe(statics((schema) => ({
+    empty: (id) => schema.make({
+        id,
+        request: { headers: {}, body: {} },
+        mode: "all",
+        hidden: false,
+        permissions: [
+            { action: "*", resource: "*", effect: "allow" },
+            { action: "external_directory", resource: "*", effect: "ask" },
+        ],
+    }),
+})));
+export const Event = {
+    Updated,
+    Definitions: inventory(Updated),
+};

package/dist/catalog.d.ts

@@ -0,0 +1,89 @@
+export * as Catalog from "./catalog.js";
+export declare const Event: {
+    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<"catalog.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: "catalog.updated";
+    };
+    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<"catalog.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: "catalog.updated";
+    }];
+};

package/dist/catalog.js

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

package/dist/command.d.ts

@@ -0,0 +1,44 @@
+export * as Command from "./command.js";
+import { Schema } from "effect";
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly template: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly agent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+    }>>, never, never>;
+    readonly subtask: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;

package/dist/command.js

@@ -0,0 +1,12 @@
+export * as Command from "./command.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { Model } from "./model.js";
+export const Info = Schema.Struct({
+    name: Schema.String,
+    template: Schema.String,
+    description: Schema.String.pipe(optional),
+    agent: Schema.String.pipe(optional),
+    model: Model.Ref.pipe(optional),
+    subtask: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "CommandV2.Info" });

package/dist/connection.d.ts

@@ -0,0 +1,28 @@
+export * as Connection from "./connection.js";
+import { Schema } from "effect";
+export interface CredentialInfo extends Schema.Schema.Type<typeof CredentialInfo> {
+}
+export declare const CredentialInfo: Schema.Struct<{
+    readonly type: Schema.Literal<"credential">;
+    readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+    readonly label: Schema.String;
+}>;
+export interface EnvInfo extends Schema.Schema.Type<typeof EnvInfo> {
+}
+export declare const EnvInfo: Schema.Struct<{
+    readonly type: Schema.Literal<"env">;
+    readonly name: Schema.String;
+}>;
+export declare const Info: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"credential">;
+    readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+    readonly label: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"env">;
+    readonly name: Schema.String;
+}>]>;
+export type Info = typeof Info.Type;

package/dist/connection.js

@@ -0,0 +1,15 @@
+export * as Connection from "./connection.js";
+import { Schema } from "effect";
+import { Credential } from "./credential.js";
+export const CredentialInfo = Schema.Struct({
+    type: Schema.Literal("credential"),
+    id: Credential.ID,
+    label: Schema.String,
+}).annotate({ identifier: "Connection.CredentialInfo" });
+export const EnvInfo = Schema.Struct({
+    type: Schema.Literal("env"),
+    name: Schema.String,
+}).annotate({ identifier: "Connection.EnvInfo" });
+export const Info = Schema.Union([CredentialInfo, EnvInfo])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Connection.Info" });

package/dist/credential.d.ts

@@ -0,0 +1,36 @@
+export * as Credential from "./credential.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "Credential.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+};
+export type ID = typeof ID.Type;
+export interface OAuth extends Schema.Schema.Type<typeof OAuth> {
+}
+export declare const OAuth: Schema.Struct<{
+    readonly type: Schema.Literal<"oauth">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly refresh: Schema.String;
+    readonly access: Schema.String;
+    readonly expires: Schema.Int;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>;
+export interface Key extends Schema.Schema.Type<typeof Key> {
+}
+export declare const Key: Schema.Struct<{
+    readonly type: Schema.Literal<"key">;
+    readonly key: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>;
+export declare const Value: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"oauth">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly refresh: Schema.String;
+    readonly access: Schema.String;
+    readonly expires: Schema.Int;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"key">;
+    readonly key: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>]>;
+export type Value = Schema.Schema.Type<typeof Value>;

package/dist/credential.js

@@ -0,0 +1,23 @@
+export * as Credential from "./credential.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { IntegrationMethodID } from "./integration-id.js";
+import { ascending } from "./identifier.js";
+import { NonNegativeInt, statics } from "./schema.js";
+export const ID = Schema.String.pipe(Schema.brand("Credential.ID"), statics((schema) => ({ create: () => schema.make("cred_" + ascending()) })));
+export const OAuth = Schema.Struct({
+    type: Schema.Literal("oauth"),
+    methodID: IntegrationMethodID,
+    refresh: Schema.String,
+    access: Schema.String,
+    expires: NonNegativeInt,
+    metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
+}).annotate({ identifier: "Credential.OAuth" });
+export const Key = Schema.Struct({
+    type: Schema.Literal("key"),
+    key: Schema.String,
+    metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
+}).annotate({ identifier: "Credential.Key" });
+export const Value = Schema.Union([OAuth, Key])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Credential.Value" });