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

package/dist/kilocode/gateway.js

@@ -0,0 +1,328 @@
+export * as KiloGatewayRpc from "./gateway.js";
+import { Schema } from "effect";
+import { Rpc } from "../rpc.js";
+import { optional } from "../schema.js";
+// The `kilocode.gateway` RPC contract: the reference Kilo RPC. The Gateway plugin in packages/kilo-plugin
+// registers the handlers; clients (TUI, VS Code, JetBrains) import this contract from
+// `@opencode/schema/kilocode/gateway`, never from Core or the plugin.
+// Standard Schemas, so the promise client of the TUI accepts the contract too.
+const portable = Schema.toStandardSchemaV1;
+const Failure = { unauthorized: portable(Schema.Undefined), failed: portable(Schema.Undefined) };
+const OrganizationID = Schema.NullOr(Schema.String);
+export const Profile = Schema.Struct({
+    email: Schema.String,
+    name: Schema.optional(Schema.String),
+    organizations: Schema.Array(Schema.Struct({ id: Schema.String, name: Schema.String, role: Schema.optional(Schema.String) })),
+    hasPersonalAccount: Schema.Boolean,
+    /** The team that requests use now. `null` is the personal account. */
+    organizationID: OrganizationID,
+});
+export const AuthStatus = Schema.Struct({
+    authenticated: Schema.Boolean,
+    organizationID: OrganizationID,
+    server: Schema.String,
+});
+export const Balance = Schema.Struct({
+    balance: Schema.NullOr(Schema.Number),
+    isDepleted: Schema.optional(Schema.Boolean),
+});
+export const KiloPass = Schema.NullOr(Schema.Struct({
+    currentPeriodBaseCreditsUsd: Schema.Number,
+    currentPeriodUsageUsd: Schema.Number,
+    currentPeriodBonusCreditsUsd: Schema.Number,
+    nextBillingAt: Schema.NullOr(Schema.String),
+}));
+export const ByokEntry = Schema.Struct({
+    id: Schema.String,
+    provider_id: Schema.String,
+    management_source: Schema.Literals(["user", "coding_plan"]),
+    is_enabled: Schema.Boolean,
+});
+export const CodingPlanSubscription = Schema.Struct({
+    id: Schema.String,
+    planId: Schema.String,
+    planName: Schema.String,
+    providerName: Schema.String,
+    providerId: Schema.String,
+    canQueryUsage: Schema.Boolean,
+    hasInstalledByokKey: Schema.Boolean,
+    status: Schema.Literals(["active", "past_due", "canceled"]),
+    cancelAtPeriodEnd: Schema.Boolean,
+});
+export const CodingPlanUsage = Schema.Struct({
+    schemaVersion: Schema.Literal(1),
+    fetchedAt: Schema.String,
+    subscription: Schema.Struct({
+        id: Schema.String,
+        planName: Schema.String,
+        providerId: Schema.String,
+        providerName: Schema.String,
+        windows: Schema.Array(Schema.Struct({
+            id: Schema.String,
+            remainingPercent: Schema.Number,
+            resetsAt: Schema.String,
+            startsAt: Schema.optional(Schema.String),
+            period: Schema.Struct({
+                unit: Schema.Literals(["hour", "day", "week", "month"]),
+                value: Schema.Number,
+            }),
+        })),
+    }),
+});
+export const OrganizationMode = Schema.Struct({
+    id: Schema.String,
+    organization_id: Schema.String,
+    name: Schema.String,
+    slug: Schema.String,
+    created_by: Schema.String,
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    config: Schema.Struct({
+        roleDefinition: Schema.optional(Schema.String),
+        whenToUse: Schema.optional(Schema.String),
+        description: Schema.optional(Schema.String),
+        customInstructions: Schema.optional(Schema.String),
+        groups: Schema.optional(Schema.Array(Schema.Union([
+            Schema.String,
+            Schema.Tuple([
+                Schema.String,
+                Schema.Struct({
+                    fileRegex: Schema.optional(Schema.String),
+                    description: Schema.optional(Schema.String),
+                }),
+            ]),
+        ]))),
+    }),
+});
+export const Notification = Schema.Struct({
+    id: Schema.String,
+    title: Schema.String,
+    message: Schema.String,
+    action: Schema.optional(Schema.Struct({
+        actionText: Schema.String,
+        actionURL: Schema.String,
+    })),
+    showIn: Schema.optional(Schema.Array(Schema.String)),
+    suggestModelId: Schema.optional(Schema.String),
+});
+export const ImageModel = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    description: Schema.optional(Schema.String),
+});
+export const TranscriptionModel = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+});
+// The wire shape of the `models.embeddings` answer. `@kilocode/gateway-core/embedding-catalog` decodes the same shape
+// from the Kilo API; a logic package imports nothing from `@opencode/*` and Schema depends on no Kilo package, so
+// each side keeps its definition and packages/kilo-plugin/test/gateway.test.ts checks that they stay equal.
+export const EmbeddingCatalog = Schema.Struct({
+    defaultModel: Schema.String,
+    models: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        name: Schema.String,
+        dimension: Schema.Int.check(Schema.isGreaterThan(0)),
+        scoreThreshold: Schema.Finite,
+        note: Schema.optionalKey(Schema.String),
+    })),
+    aliases: Schema.Record(Schema.String, Schema.String),
+});
+export const FimTarget = Schema.Struct({
+    provider: Schema.Literals(["kilo", "inception", "mistral"]),
+    model: Schema.String,
+    url: Schema.optional(Schema.String),
+});
+export const EditTarget = Schema.Struct({
+    provider: Schema.Literals(["kilo", "inception"]),
+    model: Schema.String,
+    url: Schema.String,
+});
+export const ModelEntry = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    recommended: Schema.optional(Schema.Boolean).annotate({
+        description: "The current Gateway scope's default model, not a catalog ranking.",
+    }),
+    isFree: Schema.Boolean,
+    recommendedIndex: Schema.optional(Schema.Number),
+    hasUserByokAvailable: Schema.optional(Schema.Boolean),
+    mayTrainOnYourPrompts: Schema.optional(Schema.Boolean),
+    autoRouting: Schema.optional(Schema.Struct({
+        models: Schema.Array(Schema.String),
+    })),
+    terminalBench: Schema.optional(Schema.Struct({
+        overallScore: Schema.Number,
+        avgAttemptCostUsd: Schema.Number,
+    })),
+    description: Schema.optional(Schema.String),
+    reasoning: Schema.optional(Schema.Boolean),
+    family: Schema.optional(Schema.String),
+    aiSDKProvider: Schema.optional(Schema.String),
+});
+export const CatalogFailure = Schema.Struct({
+    kind: Schema.Literals(["unauthorized", "network", "schema", "http", "organization_missing"]),
+    status: optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(100), Schema.isLessThanOrEqualTo(599))),
+}).annotate({ identifier: "KiloGateway.CatalogFailure" });
+export const SessionMetadata = Schema.Struct({
+    routedModelID: Schema.optional(Schema.String),
+    vercelID: Schema.optional(Schema.String),
+});
+// kilo_port(unattributed:session:142910b3fc8c) kilo_port(unattributed:session:5dd7101d7cc6) v1 `platform` on session
+// create. A client sets this key in the session metadata on `session.create`, for example `"vscode"`,
+// `"agent-manager"` or `"cli"`. Children and forks inherit it; the Gateway reads it from the root session to set
+// `X-KILOCODE-FEATURE`.
+export const PLATFORM_METADATA_KEY = "kilocode.platform";
+// Custom auto routers (ADR 0005). The payloads are the Cloud contract, decoded by `KiloCustomRouter` in
+// @kilocode/gateway-core; these methods run them in the Gateway account scope and pass them through unchanged.
+// A failed Cloud request fails with `router`: the user-facing message and the Cloud error code.
+const RouterFailure = {
+    ...Failure,
+    router: portable(Schema.Struct({ code: Schema.String, retryAt: Schema.optional(Schema.String) })),
+};
+const RouterTarget = Schema.Struct({
+    /** Router model ID or slug, as `kilo auto router` accepts it. */
+    router: Schema.String,
+    /** `<provider>/<model>` of a catalog model. */
+    model: Schema.String,
+});
+export const RouterEvalConfig = Schema.Struct({
+    server: Schema.String,
+    organizationID: OrganizationID,
+    provider: Schema.String,
+    model: Schema.String,
+    /** Config for the published CLI in the eval container. Has no credentials. */
+    config: Schema.Unknown,
+    /** Credentials for the published CLI in the eval container. Secret. */
+    auth: Schema.Unknown,
+});
+// The TUI, VS Code, and JetBrains clients use this contract for account/profile, balance, Kilo Pass,
+// BYOK, coding plans, team modes, notifications, media and embedding models, and FIM/edit routing.
+export const Definition = Rpc.define({
+    id: "kilocode.gateway",
+    methods: {
+        authStatus: {
+            input: portable(Schema.Struct({})),
+            output: portable(AuthStatus),
+            errors: Failure,
+        },
+        profile: {
+            input: portable(Schema.Struct({})),
+            output: portable(Profile),
+            errors: Failure,
+        },
+        balance: {
+            input: portable(Schema.Struct({})),
+            output: portable(Balance),
+            errors: Failure,
+        },
+        kiloPass: {
+            input: portable(Schema.Struct({})),
+            output: portable(KiloPass),
+            errors: Failure,
+        },
+        byok: {
+            input: portable(Schema.Struct({})),
+            output: portable(Schema.Array(ByokEntry)),
+            errors: Failure,
+        },
+        codingPlans: {
+            input: portable(Schema.Struct({})),
+            output: portable(Schema.Array(CodingPlanSubscription)),
+            errors: Failure,
+        },
+        codingPlanUsage: {
+            input: portable(Schema.Struct({ subscriptionID: Schema.String })),
+            output: portable(CodingPlanUsage),
+            errors: Failure,
+        },
+        "organization.set": {
+            input: portable(Schema.Struct({ organizationID: OrganizationID })),
+            output: portable(Schema.Struct({})),
+            errors: Failure,
+        },
+        modes: {
+            input: portable(Schema.Struct({})),
+            output: portable(Schema.Array(OrganizationMode)),
+            errors: Failure,
+        },
+        notifications: {
+            input: portable(Schema.Struct({})),
+            output: portable(Schema.Array(Notification)),
+            errors: Failure,
+        },
+        models: {
+            input: portable(Schema.Struct({})),
+            output: portable(Schema.Array(ModelEntry)),
+            errors: { ...Failure, failed: portable(CatalogFailure) },
+        },
+        "models.images": {
+            input: portable(Schema.Struct({})),
+            output: portable(Schema.Array(ImageModel)),
+            errors: Failure,
+        },
+        "models.transcriptions": {
+            input: portable(Schema.Struct({})),
+            output: portable(Schema.Array(TranscriptionModel)),
+            errors: Failure,
+        },
+        "models.embeddings": {
+            input: portable(Schema.Struct({})),
+            output: portable(EmbeddingCatalog),
+            errors: Failure,
+        },
+        "autocomplete.fimTarget": {
+            input: portable(Schema.Struct({ provider: Schema.optional(Schema.String), model: Schema.optional(Schema.String) })),
+            output: portable(FimTarget),
+            errors: Failure,
+        },
+        "autocomplete.editTarget": {
+            input: portable(Schema.Struct({ provider: Schema.optional(Schema.String), model: Schema.optional(Schema.String) })),
+            output: portable(EditTarget),
+            errors: Failure,
+        },
+        "session.metadata": {
+            input: portable(Schema.Struct({ sessionID: Schema.String })),
+            output: portable(SessionMetadata),
+            errors: Failure,
+        },
+        "routers.list": {
+            input: portable(Schema.Struct({})),
+            output: portable(Schema.Unknown),
+            errors: RouterFailure,
+        },
+        "routers.add": {
+            input: portable(RouterTarget),
+            output: portable(Schema.Unknown),
+            errors: RouterFailure,
+        },
+        "routers.remove": {
+            input: portable(RouterTarget),
+            output: portable(Schema.Unknown),
+            errors: RouterFailure,
+        },
+        "routers.evalPlan": {
+            input: portable(Schema.Struct({ routerID: Schema.String })),
+            output: portable(Schema.Unknown),
+            errors: RouterFailure,
+        },
+        "routers.evalCase": {
+            input: portable(Schema.Struct({ routerID: Schema.String, caseID: Schema.String })),
+            output: portable(Schema.Unknown),
+            errors: RouterFailure,
+        },
+        "routers.evalConfig": {
+            input: portable(Schema.Struct({ entry: Schema.Unknown })),
+            output: portable(RouterEvalConfig),
+            errors: RouterFailure,
+        },
+        "routers.evalResult": {
+            input: portable(Schema.Struct({ result: Schema.Unknown })),
+            output: portable(Schema.Unknown),
+            errors: RouterFailure,
+        },
+    },
+    events: {
+        organization: { schema: portable(Schema.Struct({ organizationID: OrganizationID })) },
+    },
+});

package/dist/kilocode/handshake.d.ts

@@ -0,0 +1,36 @@
+export * as KiloHandshakeRpc from "./handshake.js";
+import { Schema } from "effect";
+export declare const Info: Schema.Struct<{
+    /** Always `kilo`. The app name of the server can be the name of the client that started it (`KILO_CLIENT`). */
+    readonly product: Schema.Literal<"kilo">;
+    /** The Kilo version of the server build. */
+    readonly version: Schema.String;
+    /** The release channel of the server build. */
+    readonly channel: Schema.String;
+}>;
+export type Info = typeof Info.Type;
+export declare const Definition: {
+    readonly id: "kilocode.handshake";
+    readonly methods: {
+        get: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly product: "kilo";
+                readonly version: string;
+                readonly channel: string;
+            }, {
+                readonly product: "kilo";
+                readonly version: string;
+                readonly channel: string;
+            }> & Schema.Struct<{
+                /** Always `kilo`. The app name of the server can be the name of the client that started it (`KILO_CLIENT`). */
+                readonly product: Schema.Literal<"kilo">;
+                /** The Kilo version of the server build. */
+                readonly version: Schema.String;
+                /** The release channel of the server build. */
+                readonly channel: Schema.String;
+            }>;
+        };
+    };
+    readonly events: {};
+};

package/dist/kilocode/handshake.js

@@ -0,0 +1,29 @@
+export * as KiloHandshakeRpc from "./handshake.js";
+import { Schema } from "effect";
+import { Rpc } from "../rpc.js";
+// The `kilocode.handshake` RPC contract: the identity of a Kilo v2 server. The handshake plugin in
+// packages/kilo-plugin registers the handler; clients (TUI, VS Code, JetBrains) import this contract from
+// `@opencode/schema/kilocode/handshake`.
+//
+// A client calls `get` first to confirm that it talks to a Kilo v2 server. The other servers answer differently: an
+// upstream OpenCode server has no `kilocode.handshake` RPC (RPC error `rpc.unavailable`), and a Kilo v1 server has no
+// `/api/rpc` route (HTTP 404).
+const portable = Schema.toStandardSchemaV1;
+export const Info = Schema.Struct({
+    /** Always `kilo`. The app name of the server can be the name of the client that started it (`KILO_CLIENT`). */
+    product: Schema.Literal("kilo"),
+    /** The Kilo version of the server build. */
+    version: Schema.String,
+    /** The release channel of the server build. */
+    channel: Schema.String,
+});
+export const Definition = Rpc.define({
+    id: "kilocode.handshake",
+    methods: {
+        get: {
+            input: portable(Schema.Struct({})),
+            output: portable(Info),
+        },
+    },
+    events: {},
+});