@opencode/schema 0.0.0-reserved → 2.0.1

package/dist/prompt-input.js

@@ -0,0 +1,25 @@
+export * as PromptInput from "./prompt-input.js";
+import { Schema } from "effect";
+import { AgentAttachment, PromptMention } from "./prompt.js";
+import { optional, statics } from "./schema.js";
+import { Skill } from "./skill.js";
+export const FileAttachment = Schema.Struct({
+    uri: Schema.String,
+    name: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    mention: PromptMention.pipe(optional),
+})
+    .annotate({ identifier: "PromptInput.FileAttachment" })
+    .pipe(statics((schema) => ({
+    create: (input) => schema.make(input),
+})));
+export const SkillAttachment = Schema.Struct({
+    id: Skill.ID,
+    mention: PromptMention.pipe(optional),
+}).annotate({ identifier: "PromptInput.SkillAttachment" });
+export const Prompt = Schema.Struct({
+    text: Schema.String,
+    files: Schema.Array(FileAttachment).pipe(optional),
+    agents: Schema.Array(AgentAttachment).pipe(optional),
+    skills: Schema.Array(SkillAttachment).pipe(optional),
+}).annotate({ identifier: "PromptInput" });

package/dist/prompt.d.ts

@@ -0,0 +1,297 @@
+import { Schema } from "effect";
+export interface PromptMention extends Schema.Schema.Type<typeof PromptMention> {
+}
+export declare const PromptMention: Schema.Struct<{
+    readonly start: Schema.Finite;
+    readonly end: Schema.Finite;
+    readonly text: Schema.String;
+}>;
+export declare const FileSource: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"inline">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"uri">;
+    readonly uri: Schema.String;
+}>]>;
+export type FileSource = typeof FileSource.Type;
+export declare const Base64: Schema.String;
+export type Base64 = typeof Base64.Type;
+export interface FileAttachment extends Schema.Schema.Type<typeof FileAttachment> {
+}
+export declare const FileAttachment: Schema.Struct<{
+    readonly data: Schema.String;
+    readonly mime: Schema.String;
+    readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"inline">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"uri">;
+        readonly uri: Schema.String;
+    }>]>;
+    readonly name: 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 mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly start: Schema.Finite;
+        readonly end: Schema.Finite;
+        readonly text: Schema.String;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly start: Schema.Finite;
+        readonly end: Schema.Finite;
+        readonly text: Schema.String;
+    }>>, never, never>;
+}> & {
+    create: (input: FileAttachment) => {
+        readonly data: string;
+        readonly source: {
+            readonly type: "inline";
+        } | {
+            readonly type: "uri";
+            readonly uri: string;
+        };
+        readonly mime: string;
+        readonly description?: string | undefined;
+        readonly name?: string | undefined;
+        readonly mention?: {
+            readonly start: number;
+            readonly end: number;
+            readonly text: string;
+        } | undefined;
+    };
+};
+export interface AgentAttachment extends Schema.Schema.Type<typeof AgentAttachment> {
+}
+export declare const AgentAttachment: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly start: Schema.Finite;
+        readonly end: Schema.Finite;
+        readonly text: Schema.String;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly start: Schema.Finite;
+        readonly end: Schema.Finite;
+        readonly text: Schema.String;
+    }>>, never, never>;
+}>;
+export interface SkillAttachment extends Schema.Schema.Type<typeof SkillAttachment> {
+}
+export declare const SkillAttachment: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Skill.ID">;
+    readonly name: Schema.brand<Schema.String, "Skill.Name">;
+    readonly text: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly start: Schema.Finite;
+        readonly end: Schema.Finite;
+        readonly text: Schema.String;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly start: Schema.Finite;
+        readonly end: Schema.Finite;
+        readonly text: Schema.String;
+    }>>, never, never>;
+}>;
+export interface Prompt extends Schema.Schema.Type<typeof Prompt> {
+}
+export declare const Prompt: Schema.Struct<{
+    readonly text: Schema.String;
+    readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly data: Schema.String;
+        readonly mime: Schema.String;
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"inline">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"uri">;
+            readonly uri: Schema.String;
+        }>]>;
+        readonly name: 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 mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }> & {
+        create: (input: FileAttachment) => {
+            readonly data: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly mime: string;
+            readonly description?: string | undefined;
+            readonly name?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        };
+    }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly data: Schema.String;
+        readonly mime: Schema.String;
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"inline">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"uri">;
+            readonly uri: Schema.String;
+        }>]>;
+        readonly name: 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 mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }> & {
+        create: (input: FileAttachment) => {
+            readonly data: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly mime: string;
+            readonly description?: string | undefined;
+            readonly name?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        };
+    }>>, never, never>;
+    readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }>>>, never, never>;
+    readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Skill.ID">;
+        readonly name: Schema.brand<Schema.String, "Skill.Name">;
+        readonly text: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Skill.ID">;
+        readonly name: Schema.brand<Schema.String, "Skill.Name">;
+        readonly text: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }>>>, never, never>;
+}> & {
+    equivalence: import("effect/Equivalence").Equivalence<{
+        readonly text: string;
+        readonly agents?: readonly {
+            readonly name: string;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+        readonly skills?: readonly {
+            readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+            readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
+            readonly text?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+        readonly files?: readonly {
+            readonly data: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly mime: string;
+            readonly description?: string | undefined;
+            readonly name?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+    }>;
+    fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents" | "skills">) => {
+        readonly text: string;
+        readonly agents?: readonly {
+            readonly name: string;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+        readonly skills?: readonly {
+            readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+            readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
+            readonly text?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+        readonly files?: readonly {
+            readonly data: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly mime: string;
+            readonly description?: string | undefined;
+            readonly name?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+    };
+};

package/dist/prompt.js

@@ -0,0 +1,61 @@
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { statics } from "./schema.js";
+import { Skill } from "./skill.js";
+export const PromptMention = Schema.Struct({
+    start: Schema.Finite,
+    end: Schema.Finite,
+    text: Schema.String,
+}).annotate({ identifier: "Prompt.Mention" });
+export const FileSource = Schema.Union([
+    Schema.Struct({ type: Schema.Literal("inline") }),
+    Schema.Struct({ type: Schema.Literal("uri"), uri: Schema.String }),
+])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Prompt.FileSource" });
+export const Base64 = Schema.String.check(Schema.isPattern(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/)).annotate({ identifier: "Prompt.Base64" });
+export const FileAttachment = Schema.Struct({
+    data: Base64,
+    mime: Schema.String,
+    source: FileSource,
+    name: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    mention: PromptMention.pipe(optional),
+})
+    .annotate({ identifier: "Prompt.FileAttachment" })
+    .pipe(statics((schema) => ({
+    create: (input) => schema.make({
+        data: input.data,
+        mime: input.mime,
+        source: input.source,
+        name: input.name,
+        description: input.description,
+        mention: input.mention,
+    }),
+})));
+export const AgentAttachment = Schema.Struct({
+    name: Schema.String,
+    mention: PromptMention.pipe(optional),
+}).annotate({ identifier: "Prompt.AgentAttachment" });
+export const SkillAttachment = Schema.Struct({
+    id: Skill.ID,
+    name: Skill.Name,
+    text: Schema.String.pipe(optional),
+    mention: PromptMention.pipe(optional),
+}).annotate({ identifier: "Prompt.SkillAttachment" });
+export const Prompt = Schema.Struct({
+    text: Schema.String,
+    files: Schema.Array(FileAttachment).pipe(optional),
+    agents: Schema.Array(AgentAttachment).pipe(optional),
+    skills: Schema.Array(SkillAttachment).pipe(optional),
+})
+    .annotate({ identifier: "Prompt" })
+    .pipe(statics((schema) => ({
+    equivalence: Schema.toEquivalence(schema),
+    fromUserMessage: (input) => schema.make({
+        text: input.text,
+        ...(input.files === undefined ? {} : { files: input.files }),
+        ...(input.agents === undefined ? {} : { agents: input.agents }),
+        ...(input.skills === undefined ? {} : { skills: input.skills }),
+    }),
+})));

package/dist/provider.d.ts

@@ -0,0 +1,105 @@
+export * as Provider from "./provider.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "Provider.ID"> & {
+    opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+    anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+    openai: string & import("effect/Brand").Brand<"Provider.ID">;
+    google: string & import("effect/Brand").Brand<"Provider.ID">;
+    googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+    githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+    amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+    azure: string & import("effect/Brand").Brand<"Provider.ID">;
+    openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+    mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+    gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Package: Schema.String;
+export type Package = typeof Package.Type;
+export declare const Activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
+export type Activation = typeof Activation.Type;
+export type Compaction = typeof Compaction.Type;
+export declare const Compaction: Schema.Union<readonly [Schema.Struct<{
+    readonly mode: Schema.Literal<"local">;
+}>, Schema.Struct<{
+    readonly mode: Schema.Literal<"provider">;
+    readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>]>;
+export declare const Overlays: {
+    settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+};
+export declare const Settings: Schema.$Record<Schema.String, Schema.Any>;
+export type Settings = typeof Settings.Type;
+export interface Request extends Schema.Schema.Type<typeof Request> {
+}
+export declare const Request: Schema.Struct<{
+    readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Any>>;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly body: Schema.$Record<Schema.String, Schema.Any>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly id: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly canonical: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    }>, never, never>;
+    readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
+    readonly name: Schema.String;
+    readonly activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
+    readonly package: Schema.String;
+    readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly mode: Schema.Literal<"local">;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"provider">;
+        readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly mode: Schema.Literal<"local">;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"provider">;
+        readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>]>>, never, never>;
+    /** Session WebSocket policy for routes that support it; omitted means disabled. */
+    readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}> & {
+    empty: (id: ID) => Info;
+};

package/dist/provider.js

@@ -0,0 +1,50 @@
+export * as Provider from "./provider.js";
+import { Effect, Schema } from "effect";
+import { Integration } from "./integration.js";
+import { optional, PositiveInt, statics } from "./schema.js";
+export const ID = Schema.String.pipe(Schema.brand("Provider.ID"), statics((schema) => ({
+    opencode: schema.make("opencode"),
+    anthropic: schema.make("anthropic"),
+    openai: schema.make("openai"),
+    google: schema.make("google"),
+    googleVertex: schema.make("google-vertex"),
+    githubCopilot: schema.make("github-copilot"),
+    amazonBedrock: schema.make("amazon-bedrock"),
+    azure: schema.make("azure"),
+    openrouter: schema.make("openrouter"),
+    mistral: schema.make("mistral"),
+    gitlab: schema.make("gitlab"),
+})));
+export const Package = Schema.String;
+export const Activation = Schema.Literals(["auto", "enabled", "disabled"]);
+export const Compaction = Schema.Union([
+    Schema.Struct({ mode: Schema.Literal("local") }),
+    Schema.Struct({ mode: Schema.Literal("provider"), threshold: PositiveInt.pipe(optional) }),
+]).annotate({ identifier: "Provider.Compaction" });
+export const Overlays = {
+    settings: Schema.Record(Schema.String, Schema.Any).pipe(optional),
+    headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    body: Schema.Record(Schema.String, Schema.Any).pipe(optional),
+};
+export const Settings = Schema.Record(Schema.String, Schema.Any).annotate({ identifier: "Provider.Settings" });
+export const Request = Schema.Struct({
+    settings: Settings.pipe(Schema.withConstructorDefault(Effect.succeed({}))),
+    headers: Schema.Record(Schema.String, Schema.String),
+    body: Schema.Record(Schema.String, Schema.Any),
+}).annotate({ identifier: "Provider.Request" });
+export const Info = Schema.Struct({
+    id: ID,
+    canonical: ID.pipe(optional),
+    integrationID: Integration.ID.pipe(optional),
+    name: Schema.String,
+    activation: Activation,
+    package: Package,
+    compaction: Compaction.pipe(optional),
+    /** Session WebSocket policy for routes that support it; omitted means disabled. */
+    websocket: Schema.Boolean.pipe(optional),
+    ...Overlays,
+})
+    .annotate({ identifier: "Provider.Info" })
+    .pipe(statics(() => ({
+    empty: (id) => ({ id, name: id, activation: "auto", package: "" }),
+})));

package/dist/pty-ticket.d.ts

@@ -0,0 +1,8 @@
+export * as PtyTicket from "./pty-ticket.js";
+import { Schema } from "effect";
+export declare const ConnectToken: Schema.Struct<{
+    readonly ticket: Schema.String;
+    readonly expires_in: Schema.Int;
+}>;
+export interface ConnectToken extends Schema.Schema.Type<typeof ConnectToken> {
+}

package/dist/pty-ticket.js

@@ -0,0 +1,7 @@
+export * as PtyTicket from "./pty-ticket.js";
+import { Schema } from "effect";
+import { PositiveInt } from "./schema.js";
+export const ConnectToken = Schema.Struct({
+    ticket: Schema.String,
+    expires_in: PositiveInt,
+}).annotate({ identifier: "PtyTicket.ConnectToken" });