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

package/dist/kilocode/marketplace.js

@@ -0,0 +1,122 @@
+export * as KiloMarketplaceRpc from "./marketplace.js";
+import { Schema } from "effect";
+import { Rpc } from "../rpc.js";
+import { optional } from "../schema.js";
+// The plugin owns all file/config writes, including when clients connect to a remote server.
+const portable = Schema.toStandardSchemaV1;
+const Failure = {
+    fetch_failed: portable(Schema.Undefined),
+    not_found: portable(Schema.Undefined),
+    conflict: portable(Schema.Undefined),
+    invalid_params: portable(Schema.Undefined),
+    write_failed: portable(Schema.Undefined),
+    unsupported: portable(Schema.Undefined),
+};
+export const Kind = Schema.Literals(["skill", "mcp"]);
+/** Install into the global config directory or the opened project. */
+export const Scope = Schema.Literals(["global", "project"]);
+export const Parameter = Schema.Struct({
+    key: Schema.String,
+    name: Schema.String,
+    placeholder: optional(Schema.String),
+    optional: Schema.Boolean,
+    /** Mask entry in clients; supplied values can still be stored as plaintext in MCP config. */
+    secret: optional(Schema.Boolean),
+});
+export const InstallOption = Schema.Struct({
+    name: Schema.String,
+    description: optional(Schema.String),
+    prerequisites: Schema.Array(Schema.String),
+    parameters: Schema.Array(Parameter),
+});
+export const Item = Schema.Struct({
+    registry: Schema.String,
+    kind: Kind,
+    id: Schema.String,
+    name: Schema.String,
+    description: Schema.String,
+    category: optional(Schema.String),
+    author: optional(Schema.String),
+    url: optional(Schema.String),
+    tags: Schema.Array(Schema.String),
+    prerequisites: Schema.Array(Schema.String),
+    /** Parameters shared by every install option. */
+    parameters: Schema.Array(Parameter),
+    options: Schema.Array(InstallOption),
+});
+/**
+ * Owned resources are located from the current scope, never from stored paths: a skill tree is
+ * `<skills root>/<id>` and an MCP entry is found by server name in the scope's native config files.
+ * During recovery both previous and planned contents may be owned.
+ */
+export const Resource = Schema.Union([
+    Schema.Struct({ id: Schema.String, fingerprints: optional(Schema.Array(Schema.String)) }),
+    Schema.Struct({ server: Schema.String, fingerprints: optional(Schema.Array(Schema.String)) }),
+]);
+/** A managed installation, authorizing removal of exactly the resources it wrote. */
+export const Installed = Schema.Struct({
+    /** Stored record format; an unknown version is skipped instead of being misread. */
+    version: optional(Schema.Literal(1)),
+    registry: Schema.String,
+    kind: Kind,
+    id: Schema.String,
+    scope: Scope,
+    project: optional(Schema.String),
+    /** MCP config file relative to the scope root, so records survive moving the project. */
+    config: optional(Schema.String),
+    /** Native mcp.servers key, used for status and sign-in handoff. */
+    server: optional(Schema.String),
+    resources: optional(Schema.Array(Resource)),
+    /** Intent persisted before mutations, recoverable by retry or uninstall. */
+    recovering: optional(Schema.Boolean),
+    status: optional(Schema.Literals(["ready", "missing", "modified", "incomplete"])),
+    warnings: optional(Schema.Array(Schema.String)),
+    /** Obsolete resources remain owned until cleanup succeeds. */
+    pending: optional(Schema.Array(Resource)),
+    installedAt: Schema.Number,
+});
+const Ref = { registry: Schema.String, kind: Kind, id: Schema.String };
+const InstallInput = Schema.Struct({
+    ...Ref,
+    scope: Scope,
+    option: optional(Schema.String),
+    params: optional(Schema.Record(Schema.String, Schema.String)),
+});
+export const Definition = Rpc.define({
+    id: "kilocode.marketplace",
+    methods: {
+        list: {
+            input: portable(Schema.Struct({ kind: Kind, refresh: optional(Schema.Boolean), query: optional(Schema.String) })),
+            output: portable(Schema.Struct({
+                items: Schema.Array(Item),
+                /** A failed refresh can return the persisted catalog with a warning. */
+                failures: Schema.Array(Schema.Struct({ registry: Schema.String, message: Schema.String })),
+            })),
+            errors: Failure,
+        },
+        installed: {
+            input: portable(Schema.Struct({})),
+            output: portable(Schema.Array(Installed)),
+            errors: Failure,
+        },
+        /** Read-only preview; redact secrets before interpolating the template. */
+        preview: {
+            input: portable(InstallInput),
+            output: portable(Schema.Struct({
+                config: Schema.String,
+                server: Schema.String,
+                parameters: Schema.Array(Schema.String),
+                /** Names of nonempty secret parameters that will be stored in plaintext. */
+                secrets: Schema.Array(Schema.String),
+            })),
+            errors: Failure,
+        },
+        install: { input: portable(InstallInput), output: portable(Installed), errors: Failure },
+        uninstall: {
+            input: portable(Schema.Struct({ ...Ref, scope: Scope })),
+            output: portable(Schema.Struct({})),
+            errors: Failure,
+        },
+    },
+    events: {},
+});

package/dist/kilocode/provider-usage.d.ts

@@ -0,0 +1,371 @@
+export * as ProviderUsage from "./provider-usage.js";
+import { Schema } from "effect";
+export interface UsageError extends Schema.Schema.Type<typeof UsageError> {
+}
+export declare const UsageError: Schema.Struct<{
+    readonly code: Schema.String;
+    readonly message: Schema.String;
+    readonly retryable: Schema.Boolean;
+}>;
+export interface UsagePeriod extends Schema.Schema.Type<typeof UsagePeriod> {
+}
+export declare const UsagePeriod: Schema.Struct<{
+    readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+    readonly value: Schema.Int;
+}>;
+export interface UsageWindow extends Schema.Schema.Type<typeof UsageWindow> {
+}
+export declare const UsageWindow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly resource: Schema.String;
+    readonly unit: Schema.String;
+    readonly orientation: Schema.Literals<readonly ["used_percent", "remaining_percent", "amount", "count"]>;
+    readonly used: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+    readonly remaining: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+    readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+    readonly period: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+        readonly value: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+        readonly value: Schema.Int;
+    }>>, never, never>;
+    readonly durationMs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+    readonly resetAt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly state: Schema.Literals<readonly ["active", "exhausted", "unlimited", "not_in_plan", "unknown"]>;
+}>;
+export interface UsageSnapshot extends Schema.Schema.Type<typeof UsageSnapshot> {
+}
+export declare const UsageSnapshot: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly providerID: Schema.String;
+    readonly sourceKind: Schema.Literals<readonly ["kilo_managed", "direct"]>;
+    readonly providerLabel: Schema.String;
+    readonly planLabel: Schema.String;
+    readonly sourceLabel: Schema.String;
+    readonly fetchState: Schema.Literals<readonly ["ready", "stale", "unavailable", "error"]>;
+    readonly planState: Schema.Literals<readonly ["active", "past_due", "canceling", "unknown"]>;
+    readonly routingState: Schema.Literals<readonly ["active", "disabled", "missing", "replaced", "not_applicable", "unknown"]>;
+    readonly fetchedAt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly managementUrl: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly windows: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly resource: Schema.String;
+        readonly unit: Schema.String;
+        readonly orientation: Schema.Literals<readonly ["used_percent", "remaining_percent", "amount", "count"]>;
+        readonly used: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly remaining: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly period: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+            readonly value: Schema.Int;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+            readonly value: Schema.Int;
+        }>>, never, never>;
+        readonly durationMs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly resetAt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly state: Schema.Literals<readonly ["active", "exhausted", "unlimited", "not_in_plan", "unknown"]>;
+    }>>;
+    readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+        readonly retryable: Schema.Boolean;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+        readonly retryable: Schema.Boolean;
+    }>>, never, never>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly providerID: Schema.String;
+        readonly sourceKind: Schema.Literals<readonly ["kilo_managed", "direct"]>;
+        readonly providerLabel: Schema.String;
+        readonly planLabel: Schema.String;
+        readonly sourceLabel: Schema.String;
+        readonly fetchState: Schema.Literals<readonly ["ready", "stale", "unavailable", "error"]>;
+        readonly planState: Schema.Literals<readonly ["active", "past_due", "canceling", "unknown"]>;
+        readonly routingState: Schema.Literals<readonly ["active", "disabled", "missing", "replaced", "not_applicable", "unknown"]>;
+        readonly fetchedAt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly managementUrl: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly windows: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly resource: Schema.String;
+            readonly unit: Schema.String;
+            readonly orientation: Schema.Literals<readonly ["used_percent", "remaining_percent", "amount", "count"]>;
+            readonly used: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+            readonly remaining: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+            readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+            readonly period: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+                readonly value: Schema.Int;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+                readonly value: Schema.Int;
+            }>>, never, never>;
+            readonly durationMs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+            readonly resetAt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly state: Schema.Literals<readonly ["active", "exhausted", "unlimited", "not_in_plan", "unknown"]>;
+        }>>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly code: Schema.String;
+            readonly message: Schema.String;
+            readonly retryable: Schema.Boolean;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly code: Schema.String;
+            readonly message: Schema.String;
+            readonly retryable: Schema.Boolean;
+        }>>, never, never>;
+    }>>;
+    readonly generatedAt: Schema.String;
+}>;
+export declare const Definition: {
+    readonly id: "kilocode.provider-usage";
+    readonly methods: {
+        /** Cached for 60 seconds after a good answer and 10 seconds after a failure, as in v1. */
+        get: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly items: readonly {
+                    readonly id: string;
+                    readonly providerID: string;
+                    readonly sourceKind: "direct" | "kilo_managed";
+                    readonly providerLabel: string;
+                    readonly planLabel: string;
+                    readonly sourceLabel: string;
+                    readonly fetchState: "error" | "ready" | "stale" | "unavailable";
+                    readonly planState: "active" | "canceling" | "past_due" | "unknown";
+                    readonly routingState: "active" | "disabled" | "missing" | "not_applicable" | "replaced" | "unknown";
+                    readonly fetchedAt?: string | undefined;
+                    readonly managementUrl?: string | undefined;
+                    readonly windows: readonly {
+                        readonly id: string;
+                        readonly resource: string;
+                        readonly unit: string;
+                        readonly orientation: "amount" | "count" | "remaining_percent" | "used_percent";
+                        readonly used?: number | undefined;
+                        readonly remaining?: number | undefined;
+                        readonly limit?: number | undefined;
+                        readonly period?: {
+                            readonly unit: "day" | "hour" | "month" | "week";
+                            readonly value: number;
+                        } | undefined;
+                        readonly durationMs?: number | undefined;
+                        readonly resetAt?: string | undefined;
+                        readonly state: "active" | "exhausted" | "not_in_plan" | "unknown" | "unlimited";
+                    }[];
+                    readonly error?: {
+                        readonly code: string;
+                        readonly message: string;
+                        readonly retryable: boolean;
+                    } | undefined;
+                }[];
+                readonly generatedAt: string;
+            }, {
+                readonly items: readonly {
+                    readonly id: string;
+                    readonly providerID: string;
+                    readonly sourceKind: "direct" | "kilo_managed";
+                    readonly providerLabel: string;
+                    readonly planLabel: string;
+                    readonly sourceLabel: string;
+                    readonly fetchState: "error" | "ready" | "stale" | "unavailable";
+                    readonly planState: "active" | "canceling" | "past_due" | "unknown";
+                    readonly routingState: "active" | "disabled" | "missing" | "not_applicable" | "replaced" | "unknown";
+                    readonly fetchedAt?: string | undefined;
+                    readonly managementUrl?: string | undefined;
+                    readonly windows: readonly {
+                        readonly id: string;
+                        readonly resource: string;
+                        readonly unit: string;
+                        readonly orientation: "amount" | "count" | "remaining_percent" | "used_percent";
+                        readonly used?: number | undefined;
+                        readonly remaining?: number | undefined;
+                        readonly limit?: number | undefined;
+                        readonly period?: {
+                            readonly unit: "day" | "hour" | "month" | "week";
+                            readonly value: number;
+                        } | undefined;
+                        readonly durationMs?: number | undefined;
+                        readonly resetAt?: string | undefined;
+                        readonly state: "active" | "exhausted" | "not_in_plan" | "unknown" | "unlimited";
+                    }[];
+                    readonly error?: {
+                        readonly code: string;
+                        readonly message: string;
+                        readonly retryable: boolean;
+                    } | undefined;
+                }[];
+                readonly generatedAt: string;
+            }> & Schema.Struct<{
+                readonly items: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly providerID: Schema.String;
+                    readonly sourceKind: Schema.Literals<readonly ["kilo_managed", "direct"]>;
+                    readonly providerLabel: Schema.String;
+                    readonly planLabel: Schema.String;
+                    readonly sourceLabel: Schema.String;
+                    readonly fetchState: Schema.Literals<readonly ["ready", "stale", "unavailable", "error"]>;
+                    readonly planState: Schema.Literals<readonly ["active", "past_due", "canceling", "unknown"]>;
+                    readonly routingState: Schema.Literals<readonly ["active", "disabled", "missing", "replaced", "not_applicable", "unknown"]>;
+                    readonly fetchedAt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                    readonly managementUrl: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                    readonly windows: Schema.$Array<Schema.Struct<{
+                        readonly id: Schema.String;
+                        readonly resource: Schema.String;
+                        readonly unit: Schema.String;
+                        readonly orientation: Schema.Literals<readonly ["used_percent", "remaining_percent", "amount", "count"]>;
+                        readonly used: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+                        readonly remaining: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+                        readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+                        readonly period: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                            readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+                            readonly value: Schema.Int;
+                        }>>>, Schema.optionalKey<Schema.Struct<{
+                            readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+                            readonly value: Schema.Int;
+                        }>>, never, never>;
+                        readonly durationMs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+                        readonly resetAt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                        readonly state: Schema.Literals<readonly ["active", "exhausted", "unlimited", "not_in_plan", "unknown"]>;
+                    }>>;
+                    readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                        readonly code: Schema.String;
+                        readonly message: Schema.String;
+                        readonly retryable: Schema.Boolean;
+                    }>>>, Schema.optionalKey<Schema.Struct<{
+                        readonly code: Schema.String;
+                        readonly message: Schema.String;
+                        readonly retryable: Schema.Boolean;
+                    }>>, never, never>;
+                }>>;
+                readonly generatedAt: Schema.String;
+            }>;
+        };
+        /** Fetches every source again. */
+        refresh: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly items: readonly {
+                    readonly id: string;
+                    readonly providerID: string;
+                    readonly sourceKind: "direct" | "kilo_managed";
+                    readonly providerLabel: string;
+                    readonly planLabel: string;
+                    readonly sourceLabel: string;
+                    readonly fetchState: "error" | "ready" | "stale" | "unavailable";
+                    readonly planState: "active" | "canceling" | "past_due" | "unknown";
+                    readonly routingState: "active" | "disabled" | "missing" | "not_applicable" | "replaced" | "unknown";
+                    readonly fetchedAt?: string | undefined;
+                    readonly managementUrl?: string | undefined;
+                    readonly windows: readonly {
+                        readonly id: string;
+                        readonly resource: string;
+                        readonly unit: string;
+                        readonly orientation: "amount" | "count" | "remaining_percent" | "used_percent";
+                        readonly used?: number | undefined;
+                        readonly remaining?: number | undefined;
+                        readonly limit?: number | undefined;
+                        readonly period?: {
+                            readonly unit: "day" | "hour" | "month" | "week";
+                            readonly value: number;
+                        } | undefined;
+                        readonly durationMs?: number | undefined;
+                        readonly resetAt?: string | undefined;
+                        readonly state: "active" | "exhausted" | "not_in_plan" | "unknown" | "unlimited";
+                    }[];
+                    readonly error?: {
+                        readonly code: string;
+                        readonly message: string;
+                        readonly retryable: boolean;
+                    } | undefined;
+                }[];
+                readonly generatedAt: string;
+            }, {
+                readonly items: readonly {
+                    readonly id: string;
+                    readonly providerID: string;
+                    readonly sourceKind: "direct" | "kilo_managed";
+                    readonly providerLabel: string;
+                    readonly planLabel: string;
+                    readonly sourceLabel: string;
+                    readonly fetchState: "error" | "ready" | "stale" | "unavailable";
+                    readonly planState: "active" | "canceling" | "past_due" | "unknown";
+                    readonly routingState: "active" | "disabled" | "missing" | "not_applicable" | "replaced" | "unknown";
+                    readonly fetchedAt?: string | undefined;
+                    readonly managementUrl?: string | undefined;
+                    readonly windows: readonly {
+                        readonly id: string;
+                        readonly resource: string;
+                        readonly unit: string;
+                        readonly orientation: "amount" | "count" | "remaining_percent" | "used_percent";
+                        readonly used?: number | undefined;
+                        readonly remaining?: number | undefined;
+                        readonly limit?: number | undefined;
+                        readonly period?: {
+                            readonly unit: "day" | "hour" | "month" | "week";
+                            readonly value: number;
+                        } | undefined;
+                        readonly durationMs?: number | undefined;
+                        readonly resetAt?: string | undefined;
+                        readonly state: "active" | "exhausted" | "not_in_plan" | "unknown" | "unlimited";
+                    }[];
+                    readonly error?: {
+                        readonly code: string;
+                        readonly message: string;
+                        readonly retryable: boolean;
+                    } | undefined;
+                }[];
+                readonly generatedAt: string;
+            }> & Schema.Struct<{
+                readonly items: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly providerID: Schema.String;
+                    readonly sourceKind: Schema.Literals<readonly ["kilo_managed", "direct"]>;
+                    readonly providerLabel: Schema.String;
+                    readonly planLabel: Schema.String;
+                    readonly sourceLabel: Schema.String;
+                    readonly fetchState: Schema.Literals<readonly ["ready", "stale", "unavailable", "error"]>;
+                    readonly planState: Schema.Literals<readonly ["active", "past_due", "canceling", "unknown"]>;
+                    readonly routingState: Schema.Literals<readonly ["active", "disabled", "missing", "replaced", "not_applicable", "unknown"]>;
+                    readonly fetchedAt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                    readonly managementUrl: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                    readonly windows: Schema.$Array<Schema.Struct<{
+                        readonly id: Schema.String;
+                        readonly resource: Schema.String;
+                        readonly unit: Schema.String;
+                        readonly orientation: Schema.Literals<readonly ["used_percent", "remaining_percent", "amount", "count"]>;
+                        readonly used: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+                        readonly remaining: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+                        readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+                        readonly period: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                            readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+                            readonly value: Schema.Int;
+                        }>>>, Schema.optionalKey<Schema.Struct<{
+                            readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+                            readonly value: Schema.Int;
+                        }>>, never, never>;
+                        readonly durationMs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+                        readonly resetAt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                        readonly state: Schema.Literals<readonly ["active", "exhausted", "unlimited", "not_in_plan", "unknown"]>;
+                    }>>;
+                    readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                        readonly code: Schema.String;
+                        readonly message: Schema.String;
+                        readonly retryable: Schema.Boolean;
+                    }>>>, Schema.optionalKey<Schema.Struct<{
+                        readonly code: Schema.String;
+                        readonly message: Schema.String;
+                        readonly retryable: Schema.Boolean;
+                    }>>, never, never>;
+                }>>;
+                readonly generatedAt: Schema.String;
+            }>;
+        };
+    };
+    readonly events: {};
+};

package/dist/kilocode/provider-usage.js

@@ -0,0 +1,60 @@
+export * as ProviderUsage from "./provider-usage.js";
+import { Schema } from "effect";
+import { Rpc } from "../rpc.js";
+import { optional } from "../schema.js";
+// The `kilocode.provider-usage` RPC contract: plans and quota windows of Kilo coding plans and of direct
+// subscriptions (ChatGPT Codex, MiniMax Token Plan), as v1 served at `/kilocode/provider-usage`. The provider usage
+// plugin in packages/kilo-plugin registers the handlers; clients import this contract from
+// `@opencode/schema/kilocode/provider-usage`.
+const portable = Schema.toStandardSchemaV1;
+export const UsageError = Schema.Struct({
+    code: Schema.String,
+    message: Schema.String,
+    retryable: Schema.Boolean,
+}).annotate({ identifier: "ProviderUsageError" });
+export const UsagePeriod = Schema.Struct({
+    unit: Schema.Literals(["hour", "day", "week", "month"]),
+    value: Schema.Int,
+}).annotate({ identifier: "ProviderUsagePeriod" });
+export const UsageWindow = Schema.Struct({
+    id: Schema.String,
+    resource: Schema.String,
+    unit: Schema.String,
+    orientation: Schema.Literals(["used_percent", "remaining_percent", "amount", "count"]),
+    used: optional(Schema.Finite),
+    remaining: optional(Schema.Finite),
+    limit: optional(Schema.Finite),
+    period: optional(UsagePeriod),
+    durationMs: optional(Schema.Finite),
+    resetAt: optional(Schema.String),
+    state: Schema.Literals(["active", "exhausted", "unlimited", "not_in_plan", "unknown"]),
+}).annotate({ identifier: "ProviderUsageWindow" });
+export const UsageSnapshot = Schema.Struct({
+    id: Schema.String,
+    providerID: Schema.String,
+    sourceKind: Schema.Literals(["kilo_managed", "direct"]),
+    providerLabel: Schema.String,
+    planLabel: Schema.String,
+    sourceLabel: Schema.String,
+    fetchState: Schema.Literals(["ready", "stale", "unavailable", "error"]),
+    planState: Schema.Literals(["active", "past_due", "canceling", "unknown"]),
+    routingState: Schema.Literals(["active", "disabled", "missing", "replaced", "not_applicable", "unknown"]),
+    fetchedAt: optional(Schema.String),
+    managementUrl: optional(Schema.String),
+    windows: Schema.Array(UsageWindow),
+    error: optional(UsageError),
+}).annotate({ identifier: "ProviderUsageSnapshot" });
+export const Info = Schema.Struct({
+    items: Schema.Array(UsageSnapshot),
+    generatedAt: Schema.String,
+}).annotate({ identifier: "ProviderUsage" });
+export const Definition = Rpc.define({
+    id: "kilocode.provider-usage",
+    methods: {
+        /** Cached for 60 seconds after a good answer and 10 seconds after a failure, as in v1. */
+        get: { input: portable(Schema.Struct({})), output: portable(Info) },
+        /** Fetches every source again. */
+        refresh: { input: portable(Schema.Struct({})), output: portable(Info) },
+    },
+    events: {},
+});

package/dist/legacy-event.d.ts

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

package/dist/legacy-event.js

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

package/dist/llm.d.ts

@@ -0,0 +1,4 @@
+export * as LLM from "./llm.js";
+import { Schema } from "effect";
+export declare const FinishReason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+export type FinishReason = typeof FinishReason.Type;

package/dist/llm.js

@@ -0,0 +1,3 @@
+export * as LLM from "./llm.js";
+import { Schema } from "effect";
+export const FinishReason = Schema.Literals(["stop", "length", "tool-calls", "content-filter", "error", "unknown"]);

package/dist/location-event.d.ts

@@ -0,0 +1,68 @@
+export * as LocationEvent from "./location-event.js";
+/** The location's cached services were shut down; clients must revalidate its reads. */
+export declare const Shutdown: import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: import("effect/Schema").Finite;
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"location.shutdown">;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "location.shutdown";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+};
+export declare const Definitions: readonly [import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: import("effect/Schema").Finite;
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"location.shutdown">;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "location.shutdown";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+}];