@wrongstack/core 0.306.4 → 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/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/index.d.ts

@@ -4,6 +4,7 @@ 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 { 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';