@wrongstack/core 0.306.3 → 0.307.0

package/dist/core/agent-loop-context.d.ts

@@ -0,0 +1,28 @@
+import type { Request } from '../types/provider.js';
+import { type RequestTokenBreakdown } from '../utils/token-estimate.js';
+import type { AgentInternals } from './agent-internals.js';
+import type { AgentResponseHandler } from './agent-response.js';
+import { type RunOptions } from './context.js';
+export interface AgentLoopContextManager {
+    refreshProviderContextLimit(provider: import('../types/provider.js').Provider, model: string, opts?: {
+        probe?: boolean;
+    }): Promise<void>;
+    compactContextIfNeeded(): Promise<boolean>;
+    stashRequestTokens(req: Request): RequestTokenBreakdown;
+    refreshContextRequestTokenStash(opts?: {
+        force?: boolean | undefined;
+    }): number;
+    buildRequestWithPreflightCompaction(opts: RunOptions): Promise<{
+        req: Request;
+        provider: import('../types/provider.js').Provider;
+        preFlight: RequestTokenBreakdown;
+    }>;
+    emitContextPct(): void;
+    currentMaxContext(): number;
+    calibrationKey(model?: string): string;
+    get lastPreFlightMsgCount(): number;
+}
+export declare function createAgentLoopContextManager(a: AgentInternals, handlers: {
+    response: AgentResponseHandler;
+}): AgentLoopContextManager;
+//# sourceMappingURL=agent-loop-context.d.ts.map

package/dist/core/agent-loop-detector.d.ts

@@ -0,0 +1,25 @@
+import type { ContentBlock, ToolUseBlock } from '../types/blocks.js';
+import type { AgentInternals } from './agent-internals.js';
+export declare function iterationFingerprint(blocks: ContentBlock[]): string;
+export declare function stableStringify(value: unknown): string;
+export declare function canonicalize(value: unknown): unknown;
+export declare function hashSmall(s: string): string;
+export interface LoopDetectorResult {
+    action: 'none' | 'steer' | 'cut';
+    cutSummary?: string;
+    steerMessage?: string;
+}
+export declare class AgentLoopDetector {
+    private readonly a;
+    private lastToolSignature;
+    private toolLoopCount;
+    private iterationSteerDone;
+    private readonly recentCallKeys;
+    private readonly steeredCallKeys;
+    constructor(a: AgentInternals);
+    checkIteration(iterationIndex: number, content: ContentBlock[], toolUses: ToolUseBlock[], queueSteer: (text: string) => void): {
+        cut: boolean;
+        cutSummary?: string;
+    };
+}
+//# sourceMappingURL=agent-loop-detector.d.ts.map

package/dist/core/conversation-state.d.ts

@@ -1,7 +1,6 @@
 import type { ContentBlock } from '../types/blocks.js';
 import type { Message } from '../types/messages.js';
-import type { TodoItem } from './context.js';
-import { Context } from './context.js';
+import type { Context, TodoItem } from './context.js';
 /**
  * Observable wrapper for mutable conversation state. Production code should
  * mutate messages, todos, and meta through this API so subscribers see a

package/dist/core/fallback-doctor.d.ts

@@ -0,0 +1,72 @@
+/**
+ * FallbackDoctor — diagnostic and simulation engine for WrongStack fallback systems.
+ *
+ * Provides deep inspection of active fallback configurations, diagnosing:
+ * - Single-provider sibling quarantine risks (account-wide token/quota blocks)
+ * - Context window bottlenecks (models too small for long sessions)
+ * - Provider credential and configuration health
+ * - Real-time quarantine / waiting room blocks
+ * - Step-by-step failover simulation for hypothetical errors (429, quota, etc.)
+ */
+import type { ProviderModelStatusTracker } from '../coordination/provider-status-tracker.js';
+import type { Config } from '../types/config.js';
+import { type ProviderErrorKind } from '../types/provider.js';
+export interface FallbackDiagnosticWarning {
+    readonly code: 'EMPTY_CHAIN' | 'SIBLING_QUARANTINE_RISK' | 'PROVIDER_UNUSABLE' | 'MODEL_QUARANTINED' | 'CALENDAR_BLOCKED' | 'CONTEXT_WINDOW_WARNING';
+    readonly severity: 'warning' | 'critical' | 'info';
+    readonly message: string;
+    readonly target?: string | undefined;
+    readonly recommendation?: string | undefined;
+}
+export interface FallbackDiagnosticReport {
+    readonly primary: {
+        readonly providerId: string;
+        readonly model: string;
+    };
+    readonly activeProfile: string | undefined;
+    readonly explicitChain: readonly string[];
+    readonly effectiveOrder: readonly string[];
+    readonly autoEnabled: boolean;
+    readonly status: 'healthy' | 'warning' | 'critical';
+    readonly warnings: readonly FallbackDiagnosticWarning[];
+    readonly crossProviderCount: number;
+    readonly uniqueProviders: readonly string[];
+}
+export interface FallbackSimulationStep {
+    readonly index: number;
+    readonly providerId: string;
+    readonly model: string;
+    readonly skipped: boolean;
+    readonly reason?: string | undefined;
+    readonly providerSwitched: boolean;
+}
+export interface FallbackSimulationResult {
+    readonly triggeringError: ProviderErrorKind;
+    readonly isFallbackEligible: boolean;
+    readonly primary: {
+        readonly providerId: string;
+        readonly model: string;
+    };
+    readonly steps: readonly FallbackSimulationStep[];
+    readonly finalTarget: {
+        readonly providerId: string;
+        readonly model: string;
+    } | null;
+    readonly summary: string;
+}
+/**
+ * Diagnose the active fallback configuration and chain for common failure modes.
+ */
+export declare function diagnoseFallbackConfig(config: Config, tracker?: ProviderModelStatusTracker | undefined, opts?: {
+    modelContextLimitMap?: Record<string, number> | undefined;
+} | undefined): FallbackDiagnosticReport;
+/**
+ * Simulate a failover scenario for a given error kind and token level.
+ */
+export declare function simulateFallbackFailover(config: Config, opts?: {
+    errorKind?: ProviderErrorKind | undefined;
+    currentTokens?: number | undefined;
+    statusTracker?: ProviderModelStatusTracker | undefined;
+    modelContextLimitMap?: Record<string, number> | undefined;
+}): FallbackSimulationResult;
+//# sourceMappingURL=fallback-doctor.d.ts.map

package/dist/core/fallback-model.d.ts

@@ -143,9 +143,27 @@ export declare function fallbackProfileChain(config: Config, profileName: string
 export declare function smartDefaultFallbackChain(config: Config): string[];
 /**
  * The effective fallback chain for a turn: the explicit `fallbackModels` list
- * when non-empty, otherwise the smart default (unless `fallbackAuto` is off).
+ * when non-empty, otherwise the selected profile, otherwise the smart default
+ * (unless `fallbackAuto` is off).
+ *
+ * NOTE: this is the SELECTED chain, not the full runtime order — it omits the
+ * bridge, the primary re-insertion, the extra `default`-profile depth and the
+ * last-resort sweep that {@link runtimeFallbackChain} adds. Use
+ * `runtimeFallbackChain` for anything shown to a user as "what will be tried".
  */
 export declare function effectiveFallbackChain(config: Config): string[];
+/**
+ * The chain the agent loop will ACTUALLY rotate through, in order, if the
+ * current primary fails right now — the same `resolveCandidates` call the
+ * fallback extension makes, including bridge, primary re-insertion, the
+ * `default`-profile depth and the last-resort sweep.
+ *
+ * `/fallback` used to render `effectiveFallbackChain` instead, so the
+ * displayed chain could be four entries while the runtime rotated through
+ * seventeen — the view was structurally unable to match the behavior it
+ * claimed to describe.
+ */
+export declare function runtimeFallbackChain(config: Config): string[];
 /**
  * Build the cross-provider fallback extension. Always returns an extension —
  * the effective chain (`effectiveFallbackChain`) is recomputed every turn from

package/dist/core/fallback-profile-manager.d.ts

@@ -59,12 +59,30 @@ export declare class FallbackProfileManager {
     setStatusTracker(tracker: ProviderModelStatusTracker | undefined): void;
     hasProfile(name: string): boolean;
     listProfiles(): readonly string[];
+    /**
+     * The profile the session has selected (`config.fallbackProfile`, set by
+     * `/fallback profile use <name>`), or undefined when none is selected or the
+     * name no longer resolves to a defined profile.
+     *
+     * Consulted by every resolution entry point when the caller does not name a
+     * profile itself. Without this the leader — which passes no profile — could
+     * never use a named profile at all: `config.fallbackProfiles` was reachable
+     * only by copying a chain into `fallbackModels`.
+     */
+    activeProfileName(): string | undefined;
     /**
      * Resolve a named fallback profile to a validated, provider-filtered chain.
      *
-     * Returns an empty chain when:
-     * - The profile doesn't exist.
-     * - Every entry's provider is missing, has no key, or has no matching model.
+     * Returns an empty chain when the profile doesn't exist, or when every entry
+     * is excluded, quarantined, or blacked out.
+     *
+     * Filtering is intentionally identical to {@link resolveRefs} (the explicit
+     * `fallbackModels` path): the self-exclusion, the runtime status tracker,
+     * and the availability calendar — nothing else. Anything a named profile
+     * drops, an explicit chain drops too, and vice versa. Profiles used to apply
+     * two extra filters (provider "usability" and the `providers[].models`
+     * snapshot) that the explicit path did not, which silently rerouted roles
+     * pinned to a profile onto a different model than the one configured.
      *
      * @param name - Profile name from config.fallbackProfiles.
      * @param defaultProvider - Used when an entry has no explicit provider.

package/dist/core/index.d.ts

@@ -4,7 +4,8 @@ export { buildBtwBlock, consumeBtwNotes, pendingBtwCount, setBtwNote, } from './
 export { Context, type ContextInit, type ProviderMemoryEvidence, type RunOptions, type TodoItem, } from './context.js';
 export { type ContinuationInput, type ContinuationSource, detectContinueIntent, type ResolvedContinuation, resolveContinuation, } from './continue-intent.js';
 export { ConversationState, type ReadonlyConversationState, type StateChange, type StateChangeHandler, wrapAsState, } from './conversation-state.js';
-export { createFallbackModelExtension, effectiveFallbackChain, type FallbackGateFn, type FallbackModelDeps, fallbackProfileChain, smartDefaultFallbackChain, } from './fallback-model.js';
+export { diagnoseFallbackConfig, type FallbackDiagnosticReport, type FallbackDiagnosticWarning, type FallbackSimulationResult, type FallbackSimulationStep, simulateFallbackFailover, } from './fallback-doctor.js';
+export { createFallbackModelExtension, effectiveFallbackChain, type FallbackGateFn, type FallbackModelDeps, fallbackProfileChain, runtimeFallbackChain, smartDefaultFallbackChain, } from './fallback-model.js';
 export { FallbackProfileManager } from './fallback-profile-manager.js';
 export { InputBuilder, type InputBuilderEvent, type InputBuilderOptions, } from './input-builder.js';
 export { type InstructionBundle, type InstructionBundlePaths, loadInstructionBundle, type SystemInstructionVariant, } from './instruction-bundle.js';