dsh-autotier 0.1.0

package/lib/types/policy.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The routing decision state machine: it turns one classified intent plus the
+ * per-agent runtime state into the tier to apply, and owns the TTL semantics of
+ * escalation, fallback and the judge cooldown. Pure and synchronous — the
+ * asynchronous judge call lives in `judge.ts`.
+ *
+ * @module dsh-autotier/policy
+ */
+import type { ResolvedConfig } from './config.js';
+import type { IntentInput, IntentResult, RuleHit } from './intent.js';
+import { type FallbackRecord } from './tiers.js';
+import type { RouteSource, RoutingMode, TierId } from './types.js';
+/** Mutable per-agent routing state. Never persisted: it is per-process runtime. */
+export interface RouteState {
+    /** The decision for the newest user input, reused by every step of its turn. */
+    decision: IntentResult | undefined;
+    /** The classifier input the decision was computed from. */
+    input: IntentInput | undefined;
+    /** Session-level override set by `/tier`; `undefined` = follow the configuration. */
+    override: RoutingMode | undefined;
+    /** The tier actually applied to the last request (hysteresis anchor). */
+    appliedTier: TierId | undefined;
+    /** The source that produced `appliedTier`; hysteresis only damps classifier-driven changes. */
+    appliedSource: RouteSource | undefined;
+    /** Plan mode as last observed. */
+    planActive: boolean;
+    /** Failure escalation. */
+    escalation: {
+        count: number;
+        signature: string;
+        until: number;
+        rung: number;
+        lastAt: number;
+    } | undefined;
+    /** Fallback-chain position (scoped to one tier). */
+    fallback: FallbackRecord | undefined;
+    /** Judge resilience. */
+    judge: {
+        failures: number;
+        lastCall: number;
+    };
+    /** Attempt-first band: the strong review has already run for this input. */
+    verified: boolean;
+    /** The fingerprint that owes one strong review after a cheap-run signal. */
+    reviewOwedFor: string | undefined;
+    /** The posterior exploration roll, taken once per user input. */
+    probe: 'strong' | 'cheap' | undefined;
+    /** How many calls the guard denied for this agent. */
+    denials: number;
+    /** The last rule the guard fired, for `/tier status`. */
+    lastDenial: string;
+}
+/** A fresh per-agent state. */
+export declare function createRouteState(): RouteState;
+/** One routing decision with provenance. */
+export interface Decision {
+    readonly tier: TierId;
+    readonly source: RouteSource;
+    readonly reason: string;
+    readonly confidence: number;
+}
+/** Inputs to {@link decideTier}. */
+export interface DecideInput {
+    readonly config: ResolvedConfig;
+    readonly state: RouteState;
+    readonly intent: IntentResult;
+    readonly rule: RuleHit | null;
+    /** Session/plugin override; `undefined` means the configured routing mode. */
+    readonly override: RoutingMode | undefined;
+    readonly now: number;
+}
+/** Whether the current failure escalation is still in force. */
+export declare function escalationActive(state: RouteState, now: number): boolean;
+/**
+ * Resolve the tier for the current step.
+ *
+ * Precedence (highest first): explicit override, active failure escalation,
+ * plan mode, declarative rule, fingerprint posterior, classifier verdict.
+ * Hysteresis applies only to the classifier verdict, so an explicit override
+ * or an escalation takes effect immediately.
+ *
+ * @param input - the live state and the classification.
+ * @returns the decision with its provenance.
+ */
+export declare function decideTier(input: DecideInput): Decision;
+/** Whether the low-confidence judge should be consulted for this input. */
+export declare function judgeNeeded(config: ResolvedConfig, state: RouteState, intent: IntentResult, rule: RuleHit | null, now: number): boolean;
+/** Whether the middle band should start cheap and verify on a signal. */
+export declare function attemptBandApplies(config: ResolvedConfig, intent: IntentResult): boolean;
+/** Record one judge call attempt. */
+export declare function noteJudgeCall(state: RouteState, now: number, ok: boolean): void;
+/**
+ * Record one failure against the escalation counter.
+ * @param state - the agent's state.
+ * @param signature - the failure signature (`code|fingerprint`); only identical
+ *   signatures accumulate when `escalation.signature` is enabled.
+ * @param config - the resolved configuration.
+ * @param now - current epoch millis.
+ * @returns whether this failure escalated the tier.
+ */
+export declare function noteFailure(state: RouteState, signature: string, config: ResolvedConfig, now: number): boolean;
+/** Clear an expired escalation lazily. A record that never escalated keeps its window count. */
+export declare function clearExpiredEscalation(state: RouteState, now: number): void;
+/**
+ * Advance the agent's fallback chain for one tier after an unusable route.
+ * @returns whether a chain entry was taken (false = chain exhausted).
+ */
+export declare function noteFallback(state: RouteState, tier: TierId, chainLength: number, config: ResolvedConfig, now: number): boolean;
+//# sourceMappingURL=policy.d.ts.map

package/lib/types/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/policy.ts"],"names":[],"mappings":"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"}

package/lib/types/routing.d.ts

@@ -0,0 +1,135 @@
+/**
+ * The routing wiring: the listeners that turn a classification into a tier, and
+ * the failure/fallback handlers that keep a cheap run alive.
+ *
+ * Every registration is an effect on the plugin fiber. The request listener is
+ * registered at load time on the root scope with `{ prepend: true }` so it wraps
+ * the official `installModelSelection` listener (registered later, during agent
+ * setup) and its replacement wins. It always awaits `next()` exactly once and
+ * never returns `undefined`: the inner listener destructures the result without
+ * a guard.
+ *
+ * @module dsh-autotier/routing
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { AutotierService } from './service.js';
+import type { AgentStateStore } from './state.js';
+import type { RouteSource, TierId, TierRoute } from './types.js';
+/** One proposed tier, offered to third parties on the `autotier/route` event. */
+export interface RouteProposal {
+    readonly agent: Agent;
+    readonly turn: number;
+    readonly step: number;
+    readonly tier: TierId;
+    readonly source: RouteSource;
+    readonly reason: string;
+    readonly confidence: number;
+}
+/** A third party's replacement tier. Returning one from a listener vetoes. */
+export interface RouteVeto {
+    readonly tier: TierId;
+    readonly reason: string;
+}
+/** Emitted whenever the effective tier changes. */
+export interface TierChange {
+    readonly agent: Agent;
+    readonly from: TierId | undefined;
+    readonly to: TierId;
+    readonly source: RouteSource;
+    readonly reason: string;
+    readonly route: TierRoute;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        /**
+         * Serial veto over one proposed tier. Listeners run in order and the first
+         * one returning a {@link RouteVeto} replaces the proposal.
+         * @mode serial
+         */
+        'autotier/route'(proposal: RouteProposal): RouteVeto | void | Promise<RouteVeto | void>;
+        /**
+         * The effective tier changed for one agent.
+         * @mode emit
+         */
+        'autotier/tier-changed'(payload: TierChange): void;
+    }
+}
+/** Options for {@link AutotierRouter}. */
+export interface RouterOptions {
+    readonly ctx: Context;
+    readonly service: AutotierService;
+    readonly states: AgentStateStore;
+}
+/** The router owns every autotier listener. */
+export declare class AutotierRouter {
+    private readonly ctx;
+    private readonly service;
+    private readonly states;
+    private readonly pendingJudges;
+    /** Per-session classifier counters, keyed by session so no agent registry is needed. */
+    private readonly counters;
+    /** Router-owned lifetime signal: aborts in-flight judge calls on unload. */
+    private readonly lifetime;
+    private disposed;
+    /**
+     * Register every listener on the plugin fiber.
+     * @param options - the plugin context, the service and the state store.
+     */
+    constructor(options: RouterOptions);
+    /** Pending judge calls (diagnostics and tests). */
+    get judgeCallsInFlight(): number;
+    /** The classifier input for one agent. */
+    private inputFor;
+    /** The per-session classifier counters, created on first use. */
+    private counterFor;
+    /** The routing mode in force for one agent. */
+    private modeFor;
+    /** Capture the newest user input, classify it, and start the judge when needed. */
+    private onInboxInserted;
+    /** Fire the judge without blocking the emit dispatch. */
+    private startJudge;
+    /** Open plan mode through the service, or through the log when it is absent. */
+    private enterPlanMode;
+    /**
+     * Offer the proposal to third parties on the `autotier/route` serial event.
+     * A listener failure is contained, and a listener that never settles cannot
+     * stall the turn: the race resolves with our own decision after the timeout.
+     * The timer is owned by `ctx.effect`, so unloading clears it (no HMR leak).
+     */
+    private serialVeto;
+    /** The tier landing for one tier, resolving the vision override, an active
+     * fallback record, and the effort-first escalation ladder.
+     *
+     * The ladder is the point of escalation: raise the current model's effort one
+     * step at a time (the KV prefix survives and the official notice stays quiet
+     * for an effort-only change) before paying for a model switch. `rung` counts
+     * how many times escalation has triggered for this agent, so repeated failures
+     * walk the ladder instead of jumping to the strongest landing.
+     */
+    private routeFor;
+    /**
+     * The configured landing of one tier. `followSession` means the session's own
+     * effort wins when it has one; when it has none, the tier's configured effort
+     * is the floor (an omitted effort would fall through to the adapter default,
+     * which is the strongest level).
+     */
+    private tierRoute;
+    /** Resolve the tier for this step and apply it to the proposed configuration. */
+    private onRequest;
+    /** The routing body, separated so one try/catch guards the whole seam. */
+    private routeRequest;
+    /** Count failures and escalate on the configured signature recurrence. */
+    private onAgentError;
+    /**
+     * Walk the tier's fallback chain. Permanent codes switch immediately;
+     * transient codes wait for `dsh-llm-retry` to exhaust its own retries first
+     * (this listener is registered after it on purpose).
+     */
+    private onRequestError;
+    /** Maintain the classifier counters and the plan-mode fallback fold. */
+    private onSessionEvent;
+    /** Resolve the agent that owns one session, when the registry is reachable. */
+    private agentOf;
+}
+//# sourceMappingURL=routing.d.ts.map

package/lib/types/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/routing.ts"],"names":[],"mappings":"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"}

package/lib/types/schema.d.ts

@@ -0,0 +1,134 @@
+/**
+ * The raw (possibly partial) configuration surface of dsh-autotier: the
+ * Schemastery schema the Loader validates and the settings UI renders, plus the
+ * interfaces it resolves to. The judgement that turns a raw config into a
+ * resolved one lives in `config.ts`, so this module stays free of executable
+ * logic (a schema module must not mix function values into its declarations).
+ *
+ * @module dsh-autotier/schema
+ */
+import z from '@deepseek-ai/schemastery';
+import { type CostMode, type EffortId, type RoutingMode, type Scenario } from './types.js';
+/** One fallback landing in a tier's chain (provider/model only; effort follows the target tier). */
+export interface FallbackEntry {
+    provider?: string;
+    model?: string;
+}
+/** One tier's landing plus its fallback chain. */
+export interface TierConfig {
+    provider?: string;
+    model?: string;
+    effort?: EffortId;
+    followSession?: boolean;
+    fallback?: FallbackEntry[];
+}
+/** The image-capable landing used when a turn carries images. */
+export interface VisionConfig {
+    provider?: string;
+    model?: string;
+}
+/** One declarative intent rule: highest priority match wins. */
+export interface IntentRule {
+    id?: string;
+    when?: {
+        patterns?: string[];
+        tools?: string[];
+        cwd?: string;
+    };
+    tier?: 'cheap' | 'strong';
+    priority?: number;
+}
+/** Low-confidence judge (a cheap model classifies intent only). */
+export interface JudgeConfig {
+    enabled?: boolean;
+    /** Empty = pick the first catalog model whose id contains `flash`. */
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    cooldownMs?: number;
+    timeoutMs?: number;
+    /** Consecutive judge failures after which this turn skips the judge. */
+    unavailableSkip?: number;
+}
+/** Per-scenario switches; a disabled scenario never routes itself. */
+export type ScenarioToggles = {
+    [K in Scenario]?: boolean;
+};
+/** Intent classification and arbitration. */
+export interface IntentConfig {
+    /** Confidence at or above which the rule layer decides without the judge. */
+    ruleThreshold?: number;
+    /** Attempt-first middle band; disabled until calibration lands. */
+    attemptBand?: {
+        enabled?: boolean;
+        tauLow?: number;
+    };
+    /** Application-side double threshold that stops tier flapping. */
+    hysteresis?: {
+        toStrong?: number;
+        toCheap?: number;
+    };
+    rules?: IntentRule[];
+    judge?: JudgeConfig;
+    scenarios?: ScenarioToggles;
+    costMode?: CostMode;
+}
+/** High-risk guard switches. */
+export interface GuardConfig {
+    enabled?: boolean;
+    /** Tiers whose execution the guard protects (only `cheap` is meaningful). */
+    tiers?: ('cheap')[];
+    /** Command/tool names or path prefixes that never trip the guard. */
+    whitelist?: string[];
+    /** Self-modification surfaces that force strong-tier review. */
+    protectedPaths?: string[];
+    /** Relationship with dsh-defend: `auto` audits coexistence, `none` stays silent. */
+    interopDefend?: 'auto' | 'none';
+}
+/** Failure escalation and TTL fallback. */
+export interface EscalationConfig {
+    threshold?: number;
+    windowMs?: number;
+    ttlMs?: number;
+    fallbackTtlMs?: number;
+    /** Count same-signature recurrences instead of every failure. */
+    signature?: boolean;
+}
+/**
+ * Raw (possibly partial) plugin configuration. Every field is optional because
+ * the resolver supplies the defaults; {@link resolveConfig} turns it into the
+ * fully-resolved {@link ResolvedConfig}.
+ */
+export interface Config {
+    tiers?: {
+        strong?: TierConfig;
+        cheap?: TierConfig;
+        vision?: VisionConfig;
+    };
+    intent?: IntentConfig;
+    guard?: GuardConfig;
+    escalation?: EscalationConfig;
+    routingMode?: RoutingMode;
+}
+/** The default strong tier: the catalog's quality-critical model at high effort. */
+export declare const DEFAULT_STRONG: {
+    provider: string;
+    model: string;
+    effort: "high";
+    followSession: boolean;
+};
+/** The default cheap tier: the catalog's routine/parallel model at low effort. */
+export declare const DEFAULT_CHEAP: {
+    provider: string;
+    model: string;
+    effort: "low";
+    followSession: boolean;
+};
+/** The default vision landing: the catalog's only image-capable model. */
+export declare const DEFAULT_VISION: {
+    provider: string;
+    model: string;
+};
+/** Schemastery schema: the loader validates and fills defaults before `apply`. */
+export declare const Config: z<Config>;
+//# sourceMappingURL=schema.d.ts.map

package/lib/types/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema.ts"],"names":[],"mappings":"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"}

package/lib/types/service.d.ts

@@ -0,0 +1,67 @@
+/**
+ * `ctx.autotier`: the Service Provider for autotier's public read surface. The
+ * service owns the live resolved configuration, the compiled rule table and the
+ * fingerprint posteriors, and serves the status snapshot that `/tier status`,
+ * the `tier_status` tool and any third-party consumer read. Routing decisions
+ * themselves live in `policy.ts`/`routing.ts`; this class is the stable contract
+ * other plugins may depend on.
+ * @module dsh-autotier/service
+ */
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { SettingsScope } from '@deepseek-ai/dsh-settings';
+import { type Config, type ResolvedConfig } from './config.js';
+import { PosteriorTable, type CompiledRule } from './intent.js';
+import type { AutotierStatus } from './types.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** The autotier routing service (absent when the plugin is not composed). */
+        autotier: AutotierService;
+    }
+}
+/** Dependencies the service needs from the plugin's `apply`. */
+export interface AutotierServiceOptions {
+    /** The live settings scope; its value is re-resolved on every committed change. */
+    scope: SettingsScope<Config>;
+    /** The configuration resolved at mount time (the composition base layer). */
+    config: ResolvedConfig;
+}
+/**
+ * Service Provider for `ctx.autotier`. Registration rides the owning fiber: the
+ * plugin unloading removes the service with every listener it owns.
+ */
+export declare class AutotierService extends Service {
+    private readonly scope;
+    private readonly posteriorTable;
+    private resolved;
+    private compiled;
+    /**
+     * Register the service as `ctx.autotier` and start following the settings
+     * namespace.
+     * @param ctx - the owning plugin context.
+     * @param options - the live settings scope and the mount-time configuration.
+     */
+    constructor(ctx: Context, options: AutotierServiceOptions);
+    /** The live resolved configuration. */
+    config(): ResolvedConfig;
+    /** The compiled declarative rule table, ordered by descending priority. */
+    rules(): readonly CompiledRule[];
+    /** The per-fingerprint win-rate posteriors. */
+    posteriors(): PosteriorTable;
+    /**
+     * The registered provider/model catalog, as the minimal serializable subset a
+     * configuration UI needs. Never hardcoded: it reads the live `ctx.llm`
+     * registry, so a model the adapter does not advertise cannot be selected.
+     * @returns one entry per registered provider with its models.
+     */
+    catalog(): Promise<{
+        provider: string;
+        models: {
+            id: string;
+            name: string;
+            inputModalities: readonly string[];
+        }[];
+    }[]>;
+    /** Read-only status snapshot. */
+    status(): AutotierStatus;
+}
+//# sourceMappingURL=service.d.ts.map

package/lib/types/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,EAAiB,KAAK,MAAM,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAA;AAC7E,OAAO,EAAgB,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAA;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,YAAY,CAAA;AAErE,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,6EAA6E;QAC7E,QAAQ,EAAE,eAAe,CAAA;KAC1B;CACF;AAED,gEAAgE;AAChE,MAAM,WAAW,sBAAsB;IACrC,mFAAmF;IACnF,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC5B,6EAA6E;IAC7E,MAAM,EAAE,cAAc,CAAA;CACvB;AAQD;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,OAAO;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;IACtD,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,QAAQ,CAAgB;IAEhC;;;;;OAKG;gBACS,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,sBAAsB;IAezD,uCAAuC;IACvC,MAAM,IAAI,cAAc;IAIxB,2EAA2E;IAC3E,KAAK,IAAI,SAAS,YAAY,EAAE;IAIhC,+CAA+C;IAC/C,UAAU,IAAI,cAAc;IAI5B;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAA;SAAE,EAAE,CAAA;KAAE,EAAE,CAAC;IAqB5H,iCAAiC;IACjC,MAAM,IAAI,cAAc;CAmBzB"}

package/lib/types/state.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Per-agent routing state and the replayable tier projection.
+ *
+ * Two different kinds of state live here, on purpose:
+ *
+ * - **Runtime state** (escalation counters, fallback position, judge cooldown,
+ *   the per-input decision cache, the hysteresis anchor) is mutable and NOT
+ *   derivable from the session log, so it lives in a `WeakMap<Agent, RouteState>`.
+ *   `ctx.sessionProjections` is a read-only fold registry — it exposes
+ *   `register`/`stateOf`/`snapshot` and has no setter — so runtime state cannot
+ *   live there; the earlier design note that said otherwise is corrected here.
+ * - **Derived state** (which route the last request actually used, and whether
+ *   plan mode is active) IS a pure fold over `request/header` and `plan/mode`,
+ *   so it is registered as a host+wire projection key. That makes the effective
+ *   tier replayable from the log and visible to clients.
+ *
+ * @module dsh-autotier/state
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type RouteState } from './policy.js';
+/** The projection key autotier owns. */
+export declare const TIER_PROJECTION_KEY = "autotier";
+/** Host fold state for the tier projection (plain JSON by contract). */
+export interface TierProjectionState {
+    provider: string;
+    model: string;
+    /** Empty string = the route carries no explicit effort. */
+    effort: string;
+    plan: boolean;
+}
+/**
+ * Register the tier projection when the registry is composed.
+ * @param ctx - the plugin context; the registration rides its fiber.
+ * @returns the registration disposer, or undefined when the registry is absent.
+ */
+export declare function registerTierProjection(ctx: Context): (() => void) | undefined;
+/** The per-agent runtime state store. */
+export declare class AgentStateStore {
+    private readonly states;
+    /** The state for one agent, created on first use. */
+    for(agent: Agent): RouteState;
+    /** Whether one agent already has state (diagnostics). */
+    has(agent: Agent): boolean;
+}
+//# sourceMappingURL=state.d.ts.map

package/lib/types/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAKnD,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAE/D,wCAAwC;AACxC,eAAO,MAAM,mBAAmB,aAAa,CAAA;AAE7C,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,OAAO,CAAA;CACd;AAoCD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAmC7E;AAED,yCAAyC;AACzC,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmC;IAE1D,qDAAqD;IACrD,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU;IAS7B,yDAAyD;IACzD,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;CAG3B"}

package/lib/types/tiers.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Pure tier arithmetic: the adapter-owned effort ladder, tier-route
+ * application, the effort-first escalation ladder, and the fallback-chain
+ * classifier/advance helpers.
+ *
+ * The fallback vocabulary is ported from `dsh-tier-router`'s `lib/pure.js`
+ * (MIT; see `THIRD_PARTY_NOTICES.md`), with two corrections: the effort ladder
+ * is DeepSeek's `off | low | high | max` (upstream's `medium` does not exist and
+ * would fail every request with `UNSUPPORTED_REASONING_EFFORT`), and the
+ * classification is split into permanent/transient so the request-error handler
+ * can honour the division of labour with `dsh-llm-retry` (permanent codes switch
+ * the chain immediately; transient codes wait for retry exhaustion).
+ *
+ * @module dsh-autotier/tiers
+ */
+import type { LlmCallConfig } from '@deepseek-ai/dsh-llm';
+import type { EffortId, TierId, TierRoute } from './types.js';
+/** The adapter-owned effort ladder, cheapest to strongest. */
+export declare const EFFORT_LADDER: readonly ["off", "low", "high", "max"];
+/** Position of one effort on the ladder (0..3); unknown ids rank lowest. */
+export declare function effortRank(effort: string): number;
+/**
+ * The next effort step above `current`, never above `ceiling`.
+ * @param current - the effort currently in force.
+ * @param ceiling - the strongest effort to consider (default `max`).
+ * @returns the next effort id, or null when already at or above the ceiling.
+ */
+export declare function nextEffortStep(current: EffortId, ceiling?: EffortId): EffortId | null;
+/** Whether two routes land on the same provider/model/effort triple. */
+export declare function routeEquals(a: TierRoute, b: TierRoute): boolean;
+/**
+ * Apply one tier route to a request configuration. The sampling scalars the
+ * session already chose (`temperature`, `maxTokens`, `stop`) are preserved
+ * exactly; the provider/model/effort triple is replaced. Returns the input
+ * object unchanged when the route already matches, so the caller can skip a
+ * logged header change.
+ *
+ * @param base - the configuration the loop proposed.
+ * @param target - the tier landing to apply.
+ * @returns the replacement configuration (or `base` when identical).
+ */
+export declare function resolveRoute(base: LlmCallConfig, target: TierRoute): LlmCallConfig;
+/** One rung of the effort-first escalation ladder. */
+export interface EscalationRung {
+    /** The landing this rung applies. */
+    readonly route: TierRoute;
+    /** The tier the rung belongs to (an effort rung on the cheap model is still cheap). */
+    readonly tier: TierId;
+    /** Why this rung exists, for logs and `/tier status`. */
+    readonly note: string;
+}
+/**
+ * Build the effort-first escalation ladder: raise the current model's effort
+ * one step at a time (the KV prefix survives, and the official model-selection
+ * notice is not emitted for an effort-only change) before paying for a model
+ * switch. When both tiers share one model the ladder collapses to a single
+ * effort-only rung.
+ *
+ * @param base - the configuration the loop proposed for the failing step.
+ * @param cheap - the cheap tier landing.
+ * @param strong - the strong tier landing.
+ * @returns the ordered rungs; empty when escalation cannot change anything.
+ */
+export declare function escalationLadder(base: LlmCallConfig, cheap: TierRoute, strong: TierRoute): EscalationRung[];
+/** Failure codes that mean the route itself is unusable: switch the chain now. */
+export declare const FALLBACK_PERMANENT_CODES: readonly ["UNKNOWN_MODEL", "MISSING_CREDENTIAL", "INVALID_CREDENTIAL", "QUOTA"];
+/** Failure codes owned by `dsh-llm-retry` first: switch the chain only after retries are exhausted. */
+export declare const FALLBACK_TRANSIENT_CODES: readonly ["RATE_LIMIT", "SERVER", "TIMEOUT", "TRANSPORT"];
+/** Failure codes that must never switch the model. */
+export declare const FALLBACK_IGNORE_CODES: readonly ["CONTEXT_WINDOW_EXCEEDED", "UNSUPPORTED_REASONING_EFFORT", "ABORTED", "EMPTY_RESPONSE"];
+/** How one failure relates to the fallback chain. */
+export type FallbackClass = 'permanent' | 'transient' | 'ignore' | 'unknown';
+/**
+ * Classify one failed model request for the fallback machinery.
+ * @param failure - the normalized failure facts (`code` and optional `status`).
+ * @returns the chain verdict.
+ */
+export declare function classifyFallback(failure: {
+    code?: unknown;
+    status?: unknown;
+} | undefined): FallbackClass;
+/** One agent's position in one tier's fallback chain. */
+export interface FallbackRecord {
+    /** The tier whose chain this record belongs to. */
+    tier: TierId;
+    /** Index in that tier's chain; -1 means the tier's own landing. */
+    index: number;
+    /** Epoch millis until which the record stays in force. */
+    until: number;
+}
+/** Whether a fallback record is currently pinning the agent to a chain entry. */
+export declare function fallbackActive(record: FallbackRecord | undefined, now: number): boolean;
+/**
+ * Advance a fallback record one step down one tier's chain.
+ * @param record - the current record (absent or from another tier = start of this chain).
+ * @param tier - the tier whose chain is being walked.
+ * @param chainLength - the number of configured fallback entries.
+ * @param now - current epoch millis.
+ * @param ttlMs - how long the new entry stays in force.
+ * @returns the next record, or null when the chain is exhausted.
+ */
+export declare function advanceFallback(record: FallbackRecord | undefined, tier: TierId, chainLength: number, now: number, ttlMs: number): FallbackRecord | null;
+//# sourceMappingURL=tiers.d.ts.map

package/lib/types/tiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiers.d.ts","sourceRoot":"","sources":["../../src/tiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE7D,8DAA8D;AAC9D,eAAO,MAAM,aAAa,wCAAuE,CAAA;AAEjG,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGjD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAE,QAAgB,GAAG,QAAQ,GAAG,IAAI,CAK5F;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAE/D;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,GAAG,aAAa,CAalF;AAED,sDAAsD;AACtD,MAAM,WAAW,cAAc;IAC7B,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,uFAAuF;IACvF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,cAAc,EAAE,CAkC3G;AAED,kFAAkF;AAClF,eAAO,MAAM,wBAAwB,iFAK3B,CAAA;AAEV,uGAAuG;AACvG,eAAO,MAAM,wBAAwB,2DAA4D,CAAA;AAEjG,sDAAsD;AACtD,eAAO,MAAM,qBAAqB,mGAKxB,CAAA;AAEV,qDAAqD;AACrD,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE5E;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,GAAG,aAAa,CAUzG;AAED,yDAAyD;AACzD,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAA;IACb,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAA;CACd;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,cAAc,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACZ,cAAc,GAAG,IAAI,CAKvB"}

package/lib/types/tools.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The two read-only tools: `tier_status` reports the live routing state, and
+ * `tier_route` dry-runs the classifier on one intent string without sending a
+ * model request.
+ * @module dsh-autotier/tools
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { AutotierService } from './service.js';
+import type { AgentStateStore } from './state.js';
+/** Services the tools read. */
+export interface ToolServices {
+    readonly service: AutotierService;
+    readonly states: AgentStateStore;
+}
+/** Build the `tier_status` tool. */
+export declare function tierStatusTool({ service, states }: ToolServices): ToolDefinition;
+/** Build the `tier_route` tool. */
+export declare function tierRouteTool({ service }: ToolServices): ToolDefinition;
+/**
+ * Register both tools on the plugin fiber.
+ * @param ctx - the plugin context (must have `tools`).
+ * @param services - the service and the state store.
+ */
+export declare function registerTierTools(ctx: Context, services: ToolServices): void;
+//# sourceMappingURL=tools.d.ts.map