dsh-subscriptions 0.1.0

package/lib/providers/cursor-adapter.d.ts

@@ -0,0 +1,15 @@
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
+import { CursorAdapter } from 'dsh-subscriptions/cursor-transport';
+/**
+ * The imported Cursor transport still reads tool results as user-role content
+ * blocks. DSH 0.1.7 carries them as first-class role=tool messages instead.
+ */
+export declare function projectCursorMessages(messages: GenerateOptions['messages']): unknown[];
+export declare class CursorCompatAdapter extends CursorAdapter {
+    private readonly visibleModels;
+    constructor(options: ConstructorParameters<typeof CursorAdapter>[0] & {
+        visibleModels?: () => readonly string[] | undefined;
+    });
+    listModels(provider: string): Promise<import("@deepseek-ai/dsh-llm").LlmModelInfo[]>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}

package/lib/providers/cursor-adapter.js

@@ -0,0 +1,39 @@
+import { CursorAdapter } from 'dsh-subscriptions/cursor-transport';
+/**
+ * The imported Cursor transport still reads tool results as user-role content
+ * blocks. DSH 0.1.7 carries them as first-class role=tool messages instead.
+ */
+export function projectCursorMessages(messages) {
+    return messages.map(message => message.role === 'tool'
+        ? {
+            ...message,
+            role: 'user',
+            content: [{
+                    type: 'tool-result',
+                    toolCallId: message.toolCallId,
+                    isError: message.isError,
+                    content: message.content,
+                }],
+        }
+        : message);
+}
+export class CursorCompatAdapter extends CursorAdapter {
+    visibleModels;
+    constructor(options) {
+        super(options);
+        this.visibleModels = options.visibleModels;
+    }
+    async listModels(provider) {
+        const models = await super.listModels(provider);
+        const visible = this.visibleModels?.();
+        return visible === undefined ? models : models.filter(model => visible.includes(model.id));
+    }
+    stream(options) {
+        return super.stream({
+            ...options,
+            // Existing DSH sessions may still hold this retired selection.
+            model: options.model === 'composer-2' ? 'composer-2.5' : options.model,
+            messages: projectCursorMessages(options.messages),
+        });
+    }
+}

package/lib/providers/cursor-auth.d.ts

@@ -0,0 +1,43 @@
+/** Cursor OAuth session and browser-login lifecycle. Credentials stay in DSH. */
+export declare const CURSOR_CREDENTIAL_REF: import("@deepseek-ai/dsh-credentials").CredentialRef;
+export interface CursorCredential {
+    type: 'oauth';
+    access: string;
+    refresh: string;
+    expires: number;
+}
+export interface CursorAuthStatus {
+    authenticated: boolean;
+    busy: boolean;
+    expiresAt?: number;
+    error?: string;
+}
+export interface CursorCredentialService {
+    resolve(ref: typeof CURSOR_CREDENTIAL_REF): Promise<{
+        value: string;
+    } | undefined>;
+    set(ref: typeof CURSOR_CREDENTIAL_REF, value: string): Promise<void>;
+    unset(ref: typeof CURSOR_CREDENTIAL_REF): Promise<void>;
+}
+export declare class CursorAuth {
+    private readonly credentials;
+    private readonly http;
+    private readonly now;
+    private loginTask;
+    private error;
+    private refreshTask;
+    constructor(credentials: CursorCredentialService, http?: typeof fetch, now?: () => number);
+    private read;
+    status(): Promise<CursorAuthStatus>;
+    accessToken({ signal }?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+    private refresh;
+    /** Return a Cursor browser URL immediately; polling continues on the host. */
+    login(): Promise<{
+        authorizeUrl: string;
+    }>;
+    private pollLogin;
+    cancel(): Promise<void>;
+    logout(): Promise<void>;
+}

package/lib/providers/cursor-auth.js

@@ -0,0 +1,169 @@
+/** Cursor OAuth session and browser-login lifecycle. Credentials stay in DSH. */
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { credentialRef } from '@deepseek-ai/dsh-credentials';
+export const CURSOR_CREDENTIAL_REF = credentialRef('CURSOR_SUBSCRIPTION_OAUTH');
+const API_ORIGIN = 'https://api2.cursor.sh';
+const REFRESH_AHEAD_MS = 5 * 60_000;
+function parseCredential(value) {
+    if (value === undefined || value.length === 0)
+        return undefined;
+    const parsed = JSON.parse(value);
+    if (parsed === null || typeof parsed !== 'object')
+        throw new Error('Cursor credential is malformed');
+    const item = parsed;
+    if (item.type !== 'oauth' || typeof item.access !== 'string' || item.access.length === 0
+        || typeof item.refresh !== 'string' || typeof item.expires !== 'number' || !Number.isFinite(item.expires)) {
+        throw new Error('Cursor credential is malformed');
+    }
+    return { type: 'oauth', access: item.access, refresh: item.refresh, expires: item.expires };
+}
+function tokenExpiry(token, now) {
+    try {
+        const payload = token.split('.')[1];
+        if (payload === undefined)
+            return now + 24 * 60 * 60_000;
+        const data = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+        const exp = data?.exp;
+        if (typeof exp === 'number' && Number.isFinite(exp))
+            return exp * 1000;
+    }
+    catch { /* JWTs without exp still receive a bounded lifetime. */ }
+    return now + 24 * 60 * 60_000;
+}
+function abortableDelay(ms, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { signal.removeEventListener('abort', aborted); resolve(); }, ms);
+        function aborted() { clearTimeout(timer); reject(signal.reason); }
+        signal.addEventListener('abort', aborted, { once: true });
+    });
+}
+export class CursorAuth {
+    credentials;
+    http;
+    now;
+    loginTask;
+    error;
+    refreshTask;
+    constructor(credentials, http = fetch, now = Date.now) {
+        this.credentials = credentials;
+        this.http = http;
+        this.now = now;
+    }
+    async read() {
+        return parseCredential((await this.credentials.resolve(CURSOR_CREDENTIAL_REF))?.value);
+    }
+    async status() {
+        const current = await this.read();
+        return {
+            authenticated: current !== undefined,
+            busy: this.loginTask !== undefined,
+            ...(current === undefined ? {} : { expiresAt: current.expires }),
+            ...(this.error === undefined ? {} : { error: this.error }),
+        };
+    }
+    async accessToken({ signal } = {}) {
+        signal?.throwIfAborted();
+        const current = await this.read();
+        if (current === undefined)
+            throw new Error('Cursor is not signed in');
+        if (current.expires - this.now() > REFRESH_AHEAD_MS)
+            return current.access;
+        if (current.refresh.length === 0)
+            throw new Error('Cursor sign-in needs to be renewed');
+        if (this.refreshTask === undefined) {
+            const pending = this.refresh(current, signal);
+            this.refreshTask = pending;
+            void pending.finally(() => { if (this.refreshTask === pending)
+                this.refreshTask = undefined; }).catch(() => undefined);
+        }
+        return (await this.refreshTask).access;
+    }
+    async refresh(current, signal) {
+        const response = await this.http(`${API_ORIGIN}/auth/exchange_user_api_key`, {
+            method: 'POST', redirect: 'error',
+            headers: { authorization: `Bearer ${current.refresh}`, accept: 'application/json', 'content-type': 'application/json' },
+            body: '{}',
+            ...(signal === undefined ? {} : { signal }),
+        });
+        if (!response.ok)
+            throw new Error(`Cursor token refresh failed (HTTP ${response.status})`);
+        const body = await response.json();
+        if (typeof body.accessToken !== 'string' || body.accessToken.length === 0) {
+            throw new Error('Cursor token refresh returned no access token');
+        }
+        const next = {
+            type: 'oauth', access: body.accessToken,
+            refresh: typeof body.refreshToken === 'string' && body.refreshToken.length > 0 ? body.refreshToken : current.refresh,
+            expires: tokenExpiry(body.accessToken, this.now()),
+        };
+        const latest = await this.read();
+        if (latest === undefined)
+            throw new Error('Cursor signed out during token refresh');
+        if (latest.refresh !== current.refresh)
+            return latest;
+        await this.credentials.set(CURSOR_CREDENTIAL_REF, JSON.stringify(next));
+        return next;
+    }
+    /** Return a Cursor browser URL immediately; polling continues on the host. */
+    async login() {
+        await this.cancel();
+        this.error = undefined;
+        const verifier = randomBytes(96).toString('base64url');
+        const challenge = createHash('sha256').update(verifier).digest('base64url');
+        const uuid = randomUUID();
+        const url = new URL('https://cursor.com/loginDeepControl');
+        url.search = new URLSearchParams({ challenge, uuid, mode: 'login', redirectTarget: 'cli' }).toString();
+        const abort = new AbortController();
+        const promise = this.pollLogin(uuid, verifier, abort.signal)
+            .catch(error => { if (!abort.signal.aborted)
+            this.error = error instanceof Error ? error.message : String(error); })
+            .finally(() => { if (this.loginTask?.abort === abort)
+            this.loginTask = undefined; });
+        this.loginTask = { abort, promise };
+        return { authorizeUrl: url.href };
+    }
+    async pollLogin(uuid, verifier, signal) {
+        let delay = 1000;
+        for (let attempt = 0; attempt < 150; attempt++) {
+            await abortableDelay(delay, signal);
+            const url = `${API_ORIGIN}/auth/poll?uuid=${encodeURIComponent(uuid)}&verifier=${encodeURIComponent(verifier)}`;
+            const response = await this.http(url, { headers: { accept: 'application/json' }, redirect: 'error', signal });
+            if (response.status === 404) {
+                delay = Math.min(Math.ceil(delay * 1.2), 10_000);
+                continue;
+            }
+            if (!response.ok)
+                throw new Error(`Cursor login failed (HTTP ${response.status})`);
+            const body = await response.json();
+            signal.throwIfAborted();
+            if (typeof body.accessToken !== 'string' || body.accessToken.length === 0) {
+                throw new Error('Cursor login returned no access token');
+            }
+            if (typeof body.refreshToken !== 'string' || body.refreshToken.length === 0) {
+                throw new Error('Cursor login returned no refresh token');
+            }
+            const value = {
+                type: 'oauth', access: body.accessToken,
+                refresh: body.refreshToken,
+                expires: tokenExpiry(body.accessToken, this.now()),
+            };
+            await this.credentials.set(CURSOR_CREDENTIAL_REF, JSON.stringify(value));
+            return;
+        }
+        throw new Error('Cursor login timed out');
+    }
+    async cancel() {
+        const task = this.loginTask;
+        task?.abort.abort(new Error('Cursor login cancelled'));
+        await task?.promise;
+        if (this.loginTask === task)
+            this.loginTask = undefined;
+        this.error = undefined;
+    }
+    async logout() {
+        await this.cancel();
+        await this.credentials.unset(CURSOR_CREDENTIAL_REF);
+    }
+}

package/lib/providers/cursor-model-settings.d.ts

@@ -0,0 +1,15 @@
+/** Cursor currently has one credential, so only provider-wide model visibility is configurable. */
+export interface CursorModelSettings {
+    visibleModels?: string[];
+}
+export declare function validateCursorModelSettings(input: unknown): CursorModelSettings;
+/** Durable visibility preference; account tokens remain in DSH credentials. */
+export declare class CursorModelSettingsStore {
+    readonly path: string;
+    private current;
+    private writes;
+    constructor(path?: string);
+    get(): CursorModelSettings;
+    visibleModels(): readonly string[] | undefined;
+    set(input: unknown): Promise<void>;
+}

package/lib/providers/cursor-model-settings.js

@@ -0,0 +1,51 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+export function validateCursorModelSettings(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('Cursor model settings must be an object');
+    }
+    const models = input.visibleModels;
+    if (models === undefined)
+        return {};
+    if (!Array.isArray(models) || models.some(id => typeof id !== 'string' || !id.trim())) {
+        throw new Error('visibleModels must be an array of model ids');
+    }
+    return { visibleModels: [...new Set(models)] };
+}
+/** Durable visibility preference; account tokens remain in DSH credentials. */
+export class CursorModelSettingsStore {
+    path;
+    current = {};
+    writes = Promise.resolve();
+    constructor(path = dshHomePath('plugins', 'subscriptions', 'cursor-model-settings.json')) {
+        this.path = path;
+        try {
+            this.current = validateCursorModelSettings(JSON.parse(readFileSync(path, 'utf8')));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw new Error(`Cannot read Cursor model settings at ${path}`, { cause: error });
+        }
+    }
+    get() { return structuredClone(this.current); }
+    visibleModels() { return this.current.visibleModels; }
+    set(input) {
+        const validated = validateCursorModelSettings(input);
+        const run = this.writes.then(async () => {
+            await mkdir(dirname(this.path), { recursive: true });
+            const temporary = `${this.path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+            try {
+                await writeFile(temporary, JSON.stringify(validated, null, 2), { mode: 0o600 });
+                await rename(temporary, this.path);
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
+            this.current = validated;
+        });
+        this.writes = run.catch(() => undefined);
+        return run;
+    }
+}

package/lib/providers/cursor-usage.d.ts

@@ -0,0 +1,9 @@
+/** Cursor individual-account quota projection from its dashboard endpoints. */
+import type { ProviderUsage } from './common.js';
+/** Cursor's WorkOS user id from the access JWT, without the identity prefix. */
+export declare function cursorUserId(token: string): string | undefined;
+/**
+ * Read Cursor's individual dashboard quota using an OAuth access token.
+ * The dashboard cookie is request-local; no token enters ProviderUsage.
+ */
+export declare function fetchCursorUsage(accessToken: string, http?: typeof fetch, signal?: AbortSignal): Promise<ProviderUsage>;

package/lib/providers/cursor-usage.js

@@ -0,0 +1,112 @@
+/** Cursor individual-account quota projection from its dashboard endpoints. */
+const ORIGIN = 'https://cursor.com';
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function number(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+/** Cursor's WorkOS user id from the access JWT, without the identity prefix. */
+export function cursorUserId(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3 || !parts[1])
+            return undefined;
+        const claims = record(JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8')));
+        const raw = claims?.sub;
+        if (typeof raw !== 'string' || raw.length === 0)
+            return undefined;
+        const id = raw.includes('|') ? raw.split('|').at(-1) : raw;
+        return id !== undefined && /^[A-Za-z0-9_-]+$/.test(id) ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function dashboardJson(url, cookie, http, signal) {
+    const response = await http(url, {
+        headers: {
+            accept: 'application/json',
+            cookie,
+            origin: ORIGIN,
+            referer: `${ORIGIN}/dashboard`,
+        },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (!response.ok)
+        throw new Error(`Cursor usage endpoint returned HTTP ${response.status}`);
+    return response.json();
+}
+function legacyRequestWindow(body, resetsAt) {
+    const usage = record(body);
+    if (usage === undefined)
+        return undefined;
+    const gpt4 = record(usage['gpt-4']);
+    const candidate = gpt4 !== undefined && number(gpt4.numRequests) !== undefined ? gpt4 : Object.values(usage)
+        .map(record)
+        .filter((value) => value !== undefined)
+        .sort((a, b) => (number(b.maxRequestUsage) ?? 0) - (number(a.maxRequestUsage) ?? 0))[0];
+    const used = number(candidate?.numRequests);
+    const limit = number(candidate?.maxRequestUsage);
+    if (used === undefined || limit === undefined || limit <= 0)
+        return undefined;
+    return {
+        kind: 'other', scope: 'Included requests',
+        usedPercent: Math.max(0, Math.min(100, used / limit * 100)),
+        ...(resetsAt === undefined ? {} : { resetsAt }),
+    };
+}
+/**
+ * Read Cursor's individual dashboard quota using an OAuth access token.
+ * The dashboard cookie is request-local; no token enters ProviderUsage.
+ */
+export async function fetchCursorUsage(accessToken, http = fetch, signal) {
+    const userId = cursorUserId(accessToken);
+    if (userId === undefined)
+        throw new Error('Cursor session token has no usable user identity');
+    const cookie = `WorkosCursorSessionToken=${userId}::${accessToken}`;
+    const [summaryResult, legacyResult] = await Promise.allSettled([
+        dashboardJson(`${ORIGIN}/api/usage-summary`, cookie, http, signal),
+        dashboardJson(`${ORIGIN}/api/usage?user=${encodeURIComponent(userId)}`, cookie, http, signal),
+    ]);
+    if (summaryResult.status === 'rejected' && legacyResult.status === 'rejected') {
+        throw summaryResult.reason instanceof Error ? summaryResult.reason : new Error('Cursor usage is unavailable');
+    }
+    const summary = summaryResult.status === 'fulfilled' ? record(summaryResult.value) : undefined;
+    const plan = record(record(summary?.individualUsage)?.plan) ?? record(record(summary?.teamUsage)?.plan);
+    const resetValue = summary?.billingCycleEnd;
+    const parsedReset = typeof resetValue === 'string' ? Date.parse(resetValue) : NaN;
+    const resetsAt = Number.isFinite(parsedReset) ? parsedReset : undefined;
+    const windows = [];
+    for (const [field, scope] of [
+        ['totalPercentUsed', 'Included'],
+        ['autoPercentUsed', 'Cursor Models'],
+        ['apiPercentUsed', 'Other Models'],
+    ]) {
+        const usedPercent = number(plan?.[field]);
+        if (usedPercent === undefined || usedPercent < 0 || usedPercent > 100)
+            continue;
+        windows.push({ kind: 'other', scope, usedPercent, ...(resetsAt === undefined ? {} : { resetsAt }) });
+    }
+    const legacy = legacyRequestWindow(legacyResult.status === 'fulfilled' ? legacyResult.value : undefined, resetsAt);
+    if (legacy !== undefined)
+        windows.push(legacy);
+    if (windows.length === 0 && summary?.isUnlimited !== true) {
+        throw new Error('Cursor usage response has no quota windows');
+    }
+    const membershipType = summary?.membershipType;
+    return {
+        supported: true,
+        windows,
+        ...(typeof membershipType === 'string' && membershipType.length > 0 ? { plan: membershipType } : {}),
+    };
+}

package/lib/providers/external-usage-controller.d.ts

@@ -0,0 +1,19 @@
+import type { ProviderUsage } from './common.js';
+/** Usage-only sources whose model routes are supplied by the DSH base install. */
+export type ExternalUsageSource = 'opencode-go' | 'kimi-code';
+export declare const EXTERNAL_USAGE_SOURCES: readonly ExternalUsageSource[];
+export interface ExternalUsageStatus {
+    configured: boolean;
+}
+type ResolveCredential = (name: string) => Promise<{
+    value: string;
+} | undefined>;
+export declare class ExternalUsageController {
+    private readonly resolveCredential;
+    private readonly http;
+    private readonly refs;
+    constructor(resolveCredential: ResolveCredential, http?: typeof fetch, refs?: Partial<Record<ExternalUsageSource, string>>);
+    status(): Promise<Record<ExternalUsageSource, ExternalUsageStatus>>;
+    usage(source: ExternalUsageSource, signal?: AbortSignal): Promise<ProviderUsage>;
+}
+export {};

package/lib/providers/external-usage-controller.js

@@ -0,0 +1,32 @@
+import { fetchKimiCodeUsage, fetchOpenCodeGoUsage } from './external-usage.js';
+export const EXTERNAL_USAGE_SOURCES = ['opencode-go', 'kimi-code'];
+const DEFAULT_REFS = {
+    'opencode-go': 'OPENCODE_GO_API_KEY',
+    'kimi-code': 'KIMI_CODING_API_KEY',
+};
+export class ExternalUsageController {
+    resolveCredential;
+    http;
+    refs;
+    constructor(resolveCredential, http = fetch, refs = {}) {
+        this.resolveCredential = resolveCredential;
+        this.http = http;
+        this.refs = { ...DEFAULT_REFS, ...refs };
+    }
+    async status() {
+        const [go, kimi] = await Promise.all(EXTERNAL_USAGE_SOURCES.map(async (source) => {
+            const value = await this.resolveCredential(this.refs[source]);
+            return typeof value?.value === 'string' && value.value.length > 0;
+        }));
+        return { 'opencode-go': { configured: go ?? false }, 'kimi-code': { configured: kimi ?? false } };
+    }
+    async usage(source, signal) {
+        const credential = await this.resolveCredential(this.refs[source]);
+        if (credential?.value === undefined || credential.value.length === 0) {
+            throw new Error(`${source} API key is not configured`);
+        }
+        return source === 'opencode-go'
+            ? fetchOpenCodeGoUsage(credential.value, this.http, signal)
+            : fetchKimiCodeUsage(credential.value, this.http, signal);
+    }
+}

package/lib/providers/external-usage.d.ts

@@ -0,0 +1,8 @@
+/** Usage readers for subscriptions whose model adapters are built into DSH. */
+import type { ProviderUsage } from './common.js';
+type HttpFetch = typeof fetch;
+/** Read the three account-wide OpenCode Go windows from its Go gateway. */
+export declare function fetchOpenCodeGoUsage(apiKey: string, http?: HttpFetch, signal?: AbortSignal): Promise<ProviderUsage>;
+/** Read the Kimi Code plan windows using the same API as the Kimi Code CLI. */
+export declare function fetchKimiCodeUsage(apiKey: string, http?: HttpFetch, signal?: AbortSignal): Promise<ProviderUsage>;
+export {};

package/lib/providers/external-usage.js

@@ -0,0 +1,82 @@
+/** Usage readers for subscriptions whose model adapters are built into DSH. */
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function percent(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100
+        ? value
+        : undefined;
+}
+function resetTime(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+async function getUsage(url, apiKey, http, signal) {
+    const response = await http(url, {
+        headers: { accept: 'application/json', authorization: `Bearer ${apiKey}` },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (!response.ok)
+        throw new Error(`Usage endpoint returned HTTP ${response.status}`);
+    return response.json();
+}
+/** Read the three account-wide OpenCode Go windows from its Go gateway. */
+export async function fetchOpenCodeGoUsage(apiKey, http = fetch, signal) {
+    const body = record(await getUsage('https://opencode.ai/zen/go/v1/usage', apiKey, http, signal));
+    const usage = record(body?.usage);
+    if (usage === undefined)
+        throw new Error('OpenCode Go usage response has no usage object');
+    const windows = [];
+    for (const [field, kind, scope] of [
+        ['rolling', 'session', undefined],
+        ['weekly', 'weekly', undefined],
+        ['monthly', 'other', 'Monthly'],
+    ]) {
+        const value = record(usage[field]);
+        const usedPercent = percent(value?.percent);
+        if (usedPercent === undefined)
+            continue;
+        const resetsAt = resetTime(value?.resetsAt);
+        windows.push({
+            kind,
+            ...(scope === undefined ? {} : { scope }),
+            usedPercent,
+            ...(resetsAt === undefined ? {} : { resetsAt }),
+        });
+    }
+    if (windows.length === 0)
+        throw new Error('OpenCode Go usage response has no valid windows');
+    return { supported: true, windows, plan: 'OpenCode Go' };
+}
+/** Read the Kimi Code plan windows using the same API as the Kimi Code CLI. */
+export async function fetchKimiCodeUsage(apiKey, http = fetch, signal) {
+    const body = record(await getUsage('https://api.kimi.com/coding/v1/usages', apiKey, http, signal));
+    if (body === undefined)
+        throw new Error('Kimi Code usage response is not an object');
+    const usages = record(body.usages);
+    if (usages === undefined)
+        throw new Error('Kimi Code usage response has no usages object');
+    const windows = [];
+    for (const [field, kind, scope] of [
+        ['limit_5h', 'session', undefined],
+        ['limit_7d', 'weekly', undefined],
+        ['limit_month_total', 'other', 'Monthly'],
+    ]) {
+        const value = record(usages[field]);
+        const ratio = value?.used_ratio ?? value?.usedRatio;
+        if (typeof ratio !== 'number' || !Number.isFinite(ratio) || ratio < 0 || ratio > 1)
+            continue;
+        const resetsAt = resetTime(value?.reset_time ?? value?.resetAt);
+        windows.push({
+            kind,
+            ...(scope === undefined ? {} : { scope }),
+            usedPercent: ratio * 100,
+            ...(resetsAt === undefined ? {} : { resetsAt }),
+        });
+    }
+    return { supported: true, windows, plan: 'Kimi Code' };
+}