@wengine-ai/llms 2.3.2416 → 2.3.2417

package/dist/provider-plugins/types.d.ts

@@ -56,30 +56,6 @@ export interface PluginDispatchInput {
      *  spreads) for per-request wrapper state. */
     req?: any;
 }
-/**
- * Outcome of a level-1 account-state check.
- *
- * `available: false` parks the provider without a network call; `parkedUntil`
- * lets the plugin tell the core when the account frees up (e.g. a quota reset
- * epoch), so the probe does not re-check before then.
- */
-export interface ManagedProbeVerdict {
-    available: boolean;
-    /** Epoch ms after which the account may be usable again. */
-    parkedUntil?: number;
-    /** Stable reason used for logging only — never shown to a client. */
-    reason?: string;
-}
-/** Input for a runtime-owned liveness probe. */
-export interface ManagedProbeInput {
-    /** One ordinary core dispatch attempt (same seam as `PluginDispatchInput.attempt`). */
-    attempt(): Promise<Response>;
-    /** Model to probe with (the first circuit-open model of the provider). */
-    model: string;
-    provider: LLMProvider;
-    /** Per-attempt config; the core sets `TIMEOUT` so a probe cannot outlive its budget. */
-    config: any;
-}
 /**
  * Managed-subscription semantics for one provider family. Everything the data
  * plane needs to talk to a subscription upstream without the core knowing it:
@@ -133,36 +109,6 @@ export interface ManagedRuntime {
      * hard attempt bound and must never swallow client aborts.
      */
     dispatchRequest?(input: PluginDispatchInput): Promise<Response>;
-    /**
-     * Cheap account-state check used by the background recovery probe.
-     *
-     * Two-level probing exists because account state and reachability fail
-     * independently: a parked/over-quota account must NOT spend a network call
-     * (the Gemini lesson), while a healthy-but-unreachable account must not be
-     * restored to the model list on the strength of its state alone. The core
-     * calls this FIRST and only issues the (expensive) real request when it
-     * resolves.
-     *
-     * Resolve to use the `available` hint semantics below; throw a classified
-     * error (e.g. `*_account_cooling`) to report the account as unusable. When
-     * absent, the core falls back to `ensureUsable()` — which is the same check
-     * every real request already performs — so plugins that only implement the
-     * circuit breaker still work.
-     */
-    probeAccountState?(): Promise<ManagedProbeVerdict>;
-    /**
-     * Optional runtime-owned liveness probe (level 2).
-     *
-     * Called only after `probeAccountState`/`ensureUsable` reported the account as
-     * usable. Implementations should make the cheapest request that still proves
-     * the upstream answers for THIS account (a quota/status endpoint is ideal,
-     * otherwise a 1-token chat). Must honour the supplied signal/timeout and must
-     * not persist cooldowns that a probe is not allowed to set.
-     *
-     * When absent the core performs a generic 1-token request through
-     * `dispatchRequest` (see `PluginDispatchInput`).
-     */
-    probeLiveness?(input: ManagedProbeInput): Promise<Response>;
     /**
      * Opt-in 401 handling: when set, the core performs ONE forced refresh and
      * re-dispatch on 401 before classifying. `refresh` must persist rotated

package/dist/services/active-probe.d.ts

@@ -57,13 +57,9 @@ export declare class ActiveProbeService {
     private resolveProxyUrl?;
     private logger?;
     private getConfig?;
-    /** Resolves the installed plugin runtime that owns a managed provider. */
-    private resolveManagedRuntime?;
-    /** Periodic timer for managed-subscription recovery probing. */
-    private managedProbeTimer?;
     private running;
     private probeTelemetry;
-    constructor(getProviders: () => LLMProvider[], config?: ActiveProbeConfig, resolveProxyUrl?: (provider: LLMProvider) => string | undefined, logger?: any, getConfig?: (key: string) => any, resolveManagedRuntime?: (provider: LLMProvider) => any);
+    constructor(getProviders: () => LLMProvider[], config?: ActiveProbeConfig, resolveProxyUrl?: (provider: LLMProvider) => string | undefined, logger?: any, getConfig?: (key: string) => any);
     /**
      * Record the latest reachability probe result for a provider.
      * Only /models-style reachability probes (health, manual, rate-limit header
@@ -106,43 +102,6 @@ export declare class ActiveProbeService {
      * Rate-limited models are NOT probed by runHealthProbe — they have a separate timer
      * so they can be checked more frequently (every 2 minutes) without affecting normal probes.
      */
-    /**
-     * Recover circuit-open MANAGED (subscription) providers with one real request.
-     *
-     * runHealthProbe deliberately skips managed providers: their credentials are
-     * plugin-owned, so an unauthenticated GET /v1/models would fail for reasons
-     * unrelated to health. The consequence was that a subscription provider whose
-     * circuit opened (exhausted quota, revoked token, upstream outage) had NO
-     * background path back to healthy — it stayed circuit-open and the only way it
-     * ever recovered was a real user request hitting it again, which is exactly the
-     * "keeps failing and keeps being called" behaviour.
-     *
-     * This closes that loop: for each managed provider with a circuit-open model
-     * whose probe interval has elapsed, issue one minimal request through the
-     * plugin's own dispatcher (so token refresh, account rotation and the plugin's
-     * error taxonomy all apply) and restore its models only when the upstream
-     * actually answered.
-     */
-    runManagedRecoveryProbe(): Promise<void>;
-    /**
-     * Level 1 of the managed recovery probe: is the ACCOUNT usable at all?
-     *
-     * Returns false when the account is parked (quota exhausted / verification
-     * needed / risk-blocked), in which case the caller must skip the liveness call
-     * entirely — testing the network for an account that cannot answer is pure
-     * waste and, for subscription providers, a rate-limit risk.
-     */
-    private probeManagedAccountState;
-    /**
-     * Level 2 of the managed recovery probe: does the upstream actually answer?
-     *
-     * Uses a runtime-owned `probeLiveness` when the plugin provides one (a quota or
-     * status endpoint costs no chat quota), otherwise performs a generic 1-token
-     * request through the runtime's dispatcher. The dispatcher input carries a real
-     * `attempt()` and a per-attempt `config` — both are REQUIRED by
-     * `PluginDispatchInput`, and omitting them made wrappers fail unconditionally.
-     */
-    private probeManagedLiveness;
     private runRateLimitProbe;
     /**
      * Run scheduled wake-up for configured providers
@@ -163,11 +122,11 @@ export declare class ActiveProbeService {
 /**
  * Initialize and get the active probe service
  */
-export declare function getActiveProbeService(getProviders: () => LLMProvider[], config?: ActiveProbeConfig, resolveProxyUrl?: (provider: LLMProvider) => string | undefined, logger?: any, getConfig?: (key: string) => any, resolveManagedRuntime?: (provider: LLMProvider) => any): ActiveProbeService;
+export declare function getActiveProbeService(getProviders: () => LLMProvider[], config?: ActiveProbeConfig, resolveProxyUrl?: (provider: LLMProvider) => string | undefined, logger?: any, getConfig?: (key: string) => any): ActiveProbeService;
 /**
  * Start the active probe service (convenience function)
  */
-export declare function startActiveProbe(getProviders: () => LLMProvider[], config?: ActiveProbeConfig, resolveProxyUrl?: (provider: LLMProvider) => string | undefined, logger?: any, getConfig?: (key: string) => any, resolveManagedRuntime?: (provider: LLMProvider) => any): ActiveProbeService;
+export declare function startActiveProbe(getProviders: () => LLMProvider[], config?: ActiveProbeConfig, resolveProxyUrl?: (provider: LLMProvider) => string | undefined, logger?: any, getConfig?: (key: string) => any): ActiveProbeService;
 /**
  * Stop the active probe service
  */

package/dist/services/provider-health.d.ts

@@ -76,23 +76,6 @@ export declare class ProviderHealthStore {
      * Get all models in fail pool (open status)
      */
     getFailPoolModels(): string[];
-    /**
-     * Stamp a background probe attempt without changing circuit state.
-     *
-     * Recovery probes need this: a failed probe must keep the model circuit-open
-     * but move `lastProbeTime` forward, otherwise the interval gate in
-     * isAvailable()/the probe loop would re-probe on every tick.
-     */
-    recordProbeAttempt(provider: string, model: string): void;
-    /**
-     * Park a model until the account's own reset epoch.
-     *
-     * A plugin that reports its quota window (e.g. `resets_at`) knows better than
-     * a fixed probe interval when the account can answer again. Setting
-     * `rateLimitUntil` keeps the model hidden from the list AND stops the recovery
-     * probe from spending network calls on a known-parked account.
-     */
-    markParkedUntil(provider: string, model: string, until: number): void;
     /**
      * Get all models in half-open state
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wengine-ai/llms",
-  "version": "2.3.2416",
+  "version": "2.3.2417",
   "description": "A universal LLM API transformation server",
   "main": "dist/cjs/server.cjs",
   "module": "dist/esm/server.mjs",
@@ -64,7 +64,7 @@
     "uuid": "^11.1.0",
     "@fastify/multipart": "^9.0.0",
     "@fastify/static": "^8.2.0",
-    "@wengine-ai/claude-code-router-shared": "^2.3.2416",
+    "@wengine-ai/claude-code-router-shared": "^2.3.2417",
     "adm-zip": "^0.5.16",
     "better-sqlite3": "^12.10.0",
     "rotating-file-stream": "^3.2.7"

package/dist/api/empty-answer-guard.d.ts

@@ -1,66 +0,0 @@
-/**
- * Detect an upstream answer that completed successfully (HTTP 200) but carried
- * no content blocks at all.
- *
- * The client shows such a turn as "no response" — a message is sent and nothing
- * happens. Because the wire response is an ordinary 200 with a normal
- * message_start / message_delta / message_stop sequence, nothing in the request
- * path throws, so neither the same-model retry nor the fallback chain runs, and
- * the empty turn is recorded as a provider success (which also keeps the
- * unhealthy model out of the fail pool).
- *
- * Judging the whole content-block set rather than the text keeps legitimate
- * turns alive: a tool_use-only turn, a stop_sequence hit, and a refusal (which
- * still emits a text block) all contain at least one content block.
- *
- * The probe is bounded by EMPTY_ANSWER_INSPECT_BYTES, so a healthy answer is
- * released right after its first content block and is never buffered further.
- */
-/** Upper bound on the bytes inspected before a stream is forwarded untouched. */
-export declare const EMPTY_ANSWER_INSPECT_BYTES: number;
-/**
- * Upper bound on how long the probe may hold the response before forwarding.
- *
- * Long enough that a thinking model's first content block arrives well within it
- * on a healthy stream, short enough that a stalled upstream cannot pin the
- * request (and its connection) open.
- */
-export declare const EMPTY_ANSWER_INSPECT_DEADLINE_MS = 10000;
-/** `content` = real output; `empty` = finished with no block; `pending` = undecided. */
-export type AnswerVerdict = "content" | "empty" | "pending";
-/**
- * Judge the buffered prefix of an answer.
- *
- * Line-prefix scanning (rather than JSON parsing) is deliberate: Anthropic SSE
- * names each event on both `event:` and `data:` lines, and payloads may be split
- * across reads, so a marker scan stays correct and cheap on every chunk.
- */
-export declare function inspectAnswerPrefix(text: string): AnswerVerdict;
-export interface AnswerProbeResult {
-    verdict: AnswerVerdict;
-    /** Chunks consumed while probing, in order, to be re-emitted verbatim. */
-    chunks: Uint8Array[];
-    /** Bytes consumed while probing. */
-    bytes: number;
-    /** Remaining upstream stream, or null when the answer ended / was cancelled. */
-    rest: ReadableStream<Uint8Array> | null;
-}
-/**
- * Read enough of `body` to decide whether the answer carries any content.
- *
- * Consumed bytes are returned in `chunks` so a healthy stream can be rebuilt
- * byte-for-byte. Reading stops at the first content block (fast, non-blocking
- * for real answers), at the byte budget (forwarded untouched — an unknown shape
- * is never second-guessed), at the terminal event (verdict `empty`), or when
- * `deadlineMs` elapses.
- *
- * The deadline matters: before this guard, the first SSE event was forwarded as
- * soon as it arrived. Waiting for a content block is open-ended by nature (a
- * thinking model may emit nothing but heartbeats for a long time), so an
- * upstream that stalls after `message_start` would hold the response — and the
- * whole request — forever. On timeout the answer is treated as `pending` and
- * forwarded as-is, which preserves the old behaviour for slow-but-alive streams.
- */
-export declare function probeAnswer(body: ReadableStream<Uint8Array>, limitBytes?: number, deadlineMs?: number): Promise<AnswerProbeResult>;
-/** Re-emit probed chunks, then continue with `rest`. */
-export declare function rebuildAnswerStream(chunks: Uint8Array[], rest: ReadableStream<Uint8Array> | null): ReadableStream<Uint8Array>;