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

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 mime: string;
+        readonly source: {
+            readonly type: "inline";
+        } | {
+            readonly type: "uri";
+            readonly uri: string;
+        };
+        readonly name?: string | undefined;
+        readonly description?: 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 mime: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly name?: string | undefined;
+            readonly description?: 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 mime: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly name?: string | undefined;
+            readonly description?: 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 files?: readonly {
+            readonly data: string;
+            readonly mime: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly name?: string | undefined;
+            readonly description?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+        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;
+    }>;
+    fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents" | "skills">) => {
+        readonly text: string;
+        readonly files?: readonly {
+            readonly data: string;
+            readonly mime: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly name?: string | undefined;
+            readonly description?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+        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;
+    };
+};

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}=)?$/u)).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,275 @@
+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 Event: {
+    Updated: 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<"provider.updated">;
+        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<{}>;
+    }> & {
+        type: "provider.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    };
+    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<"provider.updated">;
+        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<{}>;
+    }> & {
+        type: "provider.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    }];
+};
+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 declare const Compaction: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"summary">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"native">;
+}>]>;
+export type Compaction = typeof Compaction.Type;
+/** "websocket" on a route without a WebSocket channel warns and falls back to HTTP. */
+export declare const Transport: Schema.Literals<readonly ["http", "websocket"]>;
+export type Transport = typeof Transport.Type;
+/** HTTP request body compression; only endpoints known to decode it should enable it. */
+export declare const Encoding: Schema.Literals<readonly ["zstd", "gzip", "none"]>;
+export type Encoding = typeof Encoding.Type;
+export declare const Settings: Schema.StructWithRest<Schema.Struct<{
+    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+    readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+    readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+    readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"summary">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"native">;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"summary">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"native">;
+    }>]>>, never, never>;
+    readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+    readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Any>]>;
+export type Settings = typeof Settings.Type;
+export declare const Overlays: {
+    settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
+        readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [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 interface Request extends Schema.Schema.Type<typeof Request> {
+}
+export declare const Request: Schema.Struct<{
+    readonly settings: Schema.withConstructorDefault<Schema.StructWithRest<Schema.Struct<{
+        readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [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.StructWithRest<Schema.Struct<{
+        readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+    }>, readonly [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;
+    /** Inherited by every model of this provider; model compatibility overrides individual fields. */
+    readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("./model-compatibility.js").ReasoningField, import("./model-compatibility.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("./model-compatibility.js").ReasoningField, import("./model-compatibility.js").ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("./model-compatibility.js").ReasoningField, import("./model-compatibility.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("./model-compatibility.js").ReasoningField, import("./model-compatibility.js").ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    }>>, never, never>;
+}> & {
+    empty: (id: ID) => Info;
+};