opencode-peak-scheduler 0.1.0

package/dist/src/balance.d.ts

@@ -0,0 +1,6 @@
+export type Balance = {
+    currency: string;
+    total: number;
+};
+export declare function parseBalance(raw: unknown): Balance | null;
+export declare function fetchBalance(baseURL: string, apiKey: string): Promise<Balance | null>;

package/dist/src/config.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const schedulerDefaults: {
+    readonly providerID: "deepseek";
+    readonly peakModel: "deepseek-v4-flash";
+    readonly offModel: "deepseek-v4-pro";
+    readonly timezone: "Asia/Shanghai";
+    readonly autoID: "auto";
+    readonly checkIntervalMs: 30000;
+};
+export declare const SchedulerConfigSchema: z.ZodObject<{
+    providerID: z.ZodDefault<z.ZodString>;
+    peakModel: z.ZodDefault<z.ZodString>;
+    offModel: z.ZodDefault<z.ZodString>;
+    timezone: z.ZodDefault<z.ZodString>;
+    autoID: z.ZodDefault<z.ZodString>;
+    checkIntervalMs: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    providerID: string;
+    peakModel: string;
+    offModel: string;
+    timezone: string;
+    autoID: string;
+    checkIntervalMs: number;
+}, {
+    providerID?: string | undefined;
+    peakModel?: string | undefined;
+    offModel?: string | undefined;
+    timezone?: string | undefined;
+    autoID?: string | undefined;
+    checkIntervalMs?: number | undefined;
+}>;
+export type SchedulerConfig = z.infer<typeof SchedulerConfigSchema>;
+/** Validate an options bag (e.g. the `[spec, options]` plugin tuple) into a full config. */
+export declare function parseSchedulerOptions(options?: Record<string, unknown>): SchedulerConfig;
+export declare function loadSchedulerConfig(path?: string): Promise<SchedulerConfig>;

package/dist/src/cost.d.ts

@@ -0,0 +1,54 @@
+export type TokenCount = {
+    input: number;
+    output: number;
+    reasoning: number;
+    cacheRead: number;
+    cacheWrite: number;
+};
+export type SessionTokens = {
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cache?: {
+        read?: number;
+        write?: number;
+    };
+};
+export type ModelPrice = {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+};
+export type PricedModel = {
+    cost?: {
+        input?: number;
+        output?: number;
+        cache?: {
+            read?: number;
+            write?: number;
+        };
+    };
+};
+export type ProviderLike = {
+    id: string;
+    models: Record<string, PricedModel>;
+};
+export declare function tokenCountFrom(tokens?: SessionTokens | null): TokenCount;
+export declare function priceFrom(model?: PricedModel | null): ModelPrice | null;
+export declare function computeCost(tokens: TokenCount, price: ModelPrice): number;
+export declare const PEAK_PRICE_MULTIPLIER = 2;
+export declare function scalePrice(price: ModelPrice | null, factor: number): ModelPrice | null;
+export declare class CostTracker {
+    private prev;
+    private total;
+    record(now: TokenCount, price: ModelPrice | null): number;
+}
+export declare class CostTrackerRegistry {
+    private readonly trackers;
+    get(sessionID: string | null): CostTracker | null;
+}
+export declare function resolvePrices(providers: readonly ProviderLike[], providerID: string, peakModel: string, offModel: string): {
+    peak: ModelPrice | null;
+    off: ModelPrice | null;
+};

package/dist/src/engine.d.ts

@@ -0,0 +1,39 @@
+import type { SchedulerConfig } from "./config";
+import { type Period } from "./scheduler";
+export type SessionMeta = {
+    providerID?: string | null;
+    modelID?: string | null;
+};
+export type EngineDelegate = {
+    switchModel(sessionID: string, target: {
+        id: string;
+        providerID: string;
+    }): Promise<boolean>;
+};
+export type TickResult = {
+    period: Period;
+    changed: boolean;
+    switched: string[];
+    failed: string[];
+};
+export declare class PeakSchedulerEngine {
+    private readonly cfg;
+    private readonly delegate;
+    private readonly sessions;
+    currentPeriod: Period | null;
+    constructor(cfg: SchedulerConfig, delegate: EngineDelegate);
+    get tracked(): string[];
+    track(sessionID: string, providerID?: string | null, modelID?: string | null): void;
+    untrack(sessionID: string): void;
+    noteSessionEvent(type: string, sessionID: string, providerID?: string | null, modelID?: string | null): void;
+    /**
+     * Sessions that should be (re)pointed at the auto pseudo-model so the provider
+     * can route by window: model-less sessions, and sessions a previous run parked
+     * on a concrete peak/off model. Sessions already on auto are left alone.
+     */
+    private shouldSwitch;
+    /** The row model that keeps routing window-aware: always the auto pseudo-model. */
+    private autoTarget;
+    ensureModel(now: Date, sessionID: string): Promise<"switched" | "skipped" | "no-period" | "failed">;
+    tick(now: Date): Promise<TickResult>;
+}

package/dist/src/mode.d.ts

@@ -0,0 +1,13 @@
+import type { ResolvedModel } from "./scheduler";
+export type Mode = "auto" | "manual";
+export declare function transitionMode(current: Mode, sessionModelID: string | null, autoID: string): Mode;
+export type ModeAdvance = {
+    mode: Mode;
+    prev: string | null;
+};
+export declare function advanceMode(prev: string | null | undefined, curr: string | null, mode: Mode, autoID: string): ModeAdvance;
+export type ModeDescription = {
+    label: string;
+    model: string;
+};
+export declare function describeMode(mode: Mode, r: ResolvedModel): ModeDescription;

package/dist/src/provider/override.d.ts

@@ -0,0 +1,7 @@
+export type SchedulerOverride = {
+    peakModel: string;
+    offModel: string;
+    timezone: string;
+    autoID: string;
+};
+export declare function parseSchedulerOverride(raw: unknown): SchedulerOverride;

package/dist/src/provider/scheduler-provider.d.ts

@@ -0,0 +1,27 @@
+import type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult } from "@ai-sdk/provider";
+import { type SchedulerOverride } from "./override";
+export type SchedulerLanguageModelProvider = {
+    languageModel(modelID: string): LanguageModelV3;
+};
+export type ProviderFactoryOptions = Record<string, unknown> & {
+    name?: string;
+};
+export declare function defaultInnerFactory(options: ProviderFactoryOptions): SchedulerLanguageModelProvider;
+/**
+ * A LanguageModelV3 whose doGenerate/doStream resolve the real model by the
+ * Beijing window at call time, then delegate to the inner provider.
+ */
+export declare class TimeRoutedLanguageModel implements LanguageModelV3 {
+    readonly specificationVersion: "v3";
+    readonly provider: string;
+    readonly modelId: string;
+    private readonly inner;
+    private readonly override;
+    private readonly clock;
+    constructor(inner: SchedulerLanguageModelProvider, provider: string, override: SchedulerOverride, clock?: () => Date);
+    private resolved;
+    get supportedUrls(): PromiseLike<Record<string, RegExp[]>> | Record<string, RegExp[]>;
+    doGenerate(options: LanguageModelV3CallOptions): PromiseLike<LanguageModelV3GenerateResult>;
+    doStream(options: LanguageModelV3CallOptions): PromiseLike<LanguageModelV3StreamResult>;
+}
+export declare function createSchedulerProvider(options: ProviderFactoryOptions, innerFactory?: (options: ProviderFactoryOptions) => SchedulerLanguageModelProvider): SchedulerLanguageModelProvider;

package/dist/src/scheduler.d.ts

@@ -0,0 +1,15 @@
+export type Period = "peak" | "off";
+export type Window = "morning" | "afternoon" | null;
+export type ResolvedModel = {
+    period: Period;
+    providerID: string;
+    modelID: string;
+    window: Window;
+};
+export type ResolveOptions = {
+    providerID?: string;
+    peakModel?: string;
+    offModel?: string;
+    timezone?: string;
+};
+export declare function resolveModel(date: Date, opts?: ResolveOptions): ResolvedModel;

package/dist/src/switch-model.d.ts

@@ -0,0 +1,18 @@
+export type SwitchModelTarget = {
+    id: string;
+    providerID: string;
+};
+/** The narrow slice of the v2 OpencodeClient we rely on (keeps tests mock-friendly). */
+export type SwitchSessionClient = {
+    v2: {
+        session: {
+            switchModel(params: {
+                sessionID: string;
+                model: SwitchModelTarget;
+            }, options?: {
+                throwOnError?: boolean;
+            }): Promise<unknown>;
+        };
+    };
+};
+export declare function switchModelForSession(client: SwitchSessionClient, sessionID: string, model: SwitchModelTarget): Promise<boolean>;

package/dist/src/tui-plugin.d.ts

@@ -0,0 +1,5 @@
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+export type PeakSchedulerHandle = {
+    dispose(): void;
+};
+export declare function runPeakScheduler(api: TuiPluginApi, options?: Record<string, unknown>): PeakSchedulerHandle;

package/dist/src/tui-sidebar.d.ts

@@ -0,0 +1,6 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import type { ResolvedModel } from "./scheduler";
+import { type Mode } from "./mode";
+import type { Balance } from "./balance";
+export declare function registerSidebarSlot(api: TuiPluginApi, model: () => ResolvedModel, mode: () => Mode, cost: () => number | null, balance: () => Balance | null): void;

package/dist/tui.d.ts

@@ -0,0 +1,6 @@
+import type { TuiPluginModule } from "@opencode-ai/plugin/tui";
+export { runPeakScheduler } from "./src/tui-plugin";
+declare const plugin: TuiPluginModule & {
+    id: string;
+};
+export default plugin;