qlogicagent 0.3.0 → 0.4.0

package/dist/types/llm/transports/openai-chat.d.ts

@@ -1,36 +0,0 @@
-/**
- * OpenAI Chat Completions Transport — SSE streaming implementation.
- *
- * Covers all OpenAI-compatible providers:
- *   DeepSeek, Qwen, 硅基, Minimax, Moonshot, Groq, Together, OpenRouter, etc.
- *
- * POST {baseUrl}/v1/chat/completions with stream: true
- * Auth: Authorization: Bearer {apiKey}
- *
- * SSE format: lines prefixed with "data: ", JSON parsing per event.
- *
- * Adapted from admin-infer-proxy-client.ts SSE logic + Hermes openai_chat.py transport.
- */
-import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
-export interface OpenAIChatTransportConfig {
-    baseUrl: string;
-    /** Additional headers (e.g. for specific providers) */
-    extraHeaders?: Record<string, string>;
-    /** Timeout in ms (default 180_000) */
-    timeoutMs?: number;
-    /** Whether to include stream_options (default true). Set false for providers that reject it. */
-    supportsStreamOptions?: boolean;
-    /** Whether to omit temperature when it equals 0 (e.g. Moonshot rejects 0) */
-    omitZeroTemperature?: boolean;
-}
-export declare class OpenAIChatTransport implements LLMTransport {
-    private baseUrl;
-    private extraHeaders;
-    private timeoutMs;
-    private supportsStreamOptions;
-    private omitZeroTemperature;
-    constructor(config: OpenAIChatTransportConfig);
-    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
-    private parseSSEStream;
-    private mapChunk;
-}

package/dist/types/orchestration/agent-registry.d.ts

@@ -1,41 +0,0 @@
-/**
- * Built-in Agent Registry — CC-aligned agent definitions for fork/subagent.
- *
- * Each built-in agent defines a role with constrained tools, system prompt,
- * and execution budget. The LLM can invoke these via the AgentTool.
- */
-export interface AgentDefinition {
-    /** Unique identifier for the agent (kebab-case). */
-    name: string;
-    /** Human-readable label. */
-    label: string;
-    /** Short description (appears in tool_search / LLM prompt). */
-    description: string;
-    /** Maximum turns this agent can execute before forced stop. */
-    maxTurns: number;
-    /** Tool access mode. */
-    toolAccessMode: "full" | "read-only" | "none";
-    /** Explicit allowed tool names (if empty, uses toolAccessMode filter). */
-    allowedTools?: string[];
-    /** Whether this agent can fork sub-agents itself. */
-    canFork: boolean;
-    /** System prompt override for this agent. */
-    systemPromptSuffix?: string;
-}
-/**
- * Get the full list of built-in agent definitions.
- */
-export declare function getBuiltInAgents(): AgentDefinition[];
-/**
- * Look up a built-in agent by name.
- */
-export declare function getBuiltInAgent(name: string): AgentDefinition | undefined;
-/**
- * Check if a given agent name is a built-in agent.
- */
-export declare function isBuiltInAgent(name: string): boolean;
-/**
- * Resolve tool access for an agent definition.
- * Returns the set of tool names the agent is allowed to use.
- */
-export declare function resolveAgentToolSet(agent: AgentDefinition, availableTools: string[]): string[];

package/dist/types/orchestration/approval-aware-tool-plan.d.ts

@@ -1,32 +0,0 @@
-import type { ToolCallBatch, ToolCallLike } from "./parallel-tool-calls.js";
-import type { ToolEligibilityLike } from "./tool-choice-policy.js";
-export type ToolExecutionStepContext = {
-    stepIndex?: number;
-    stepTotal?: number;
-    stepSummary?: string;
-};
-export type ApprovalAwareToolCapability = {
-    name: string;
-    requiresApproval?: boolean;
-    approvalMode?: string;
-};
-export type ApprovalAwareToolPlanStep = {
-    stepIndex: number;
-    stepCount: number;
-    mode: "parallel" | "serial";
-    callIds: string[];
-    toolNames: string[];
-    approvalRequired: boolean;
-    approvalToolNames: string[];
-    summary: string;
-};
-export declare function summarizeApprovalAwareToolPlan<TCall extends ToolCallLike>(params: {
-    batches: Array<ToolCallBatch<TCall>>;
-    toolCapabilities: readonly ApprovalAwareToolCapability[];
-    eligibility?: readonly ToolEligibilityLike[];
-}): ApprovalAwareToolPlanStep[];
-export declare function buildApprovalAwareReason(params: {
-    toolName: string;
-    step: ApprovalAwareToolPlanStep | undefined;
-}): string;
-export declare function buildApprovalStepContext(step: ApprovalAwareToolPlanStep | undefined): ToolExecutionStepContext;

package/dist/types/orchestration/context-compression.d.ts

@@ -1,220 +0,0 @@
-export interface CompressibleMessage {
-    role: string;
-    content?: string | unknown;
-    tool_call_id?: string;
-    tool_calls?: unknown;
-    name?: string;
-}
-export interface CompressionResult {
-    messages: CompressibleMessage[];
-    droppedCount: number;
-    strategy: string;
-    /** Phase 4: optional metrics from the compression pass */
-    metrics?: CompressionMetrics;
-}
-export interface CompressionMetrics {
-    tokensBefore: number;
-    tokensAfter: number;
-    compressionRatio: number;
-    /** ms elapsed for this strategy pass */
-    latencyMs: number;
-    /** Whether an LLM call was made during this pass */
-    usedLlm: boolean;
-    /** Whether prompt cache was invalidated by compression */
-    cacheInvalidated?: boolean;
-}
-export interface CompressionStrategy {
-    compress(messages: CompressibleMessage[], budget: number): CompressionResult;
-}
-/**
- * Async compression strategy — required for LLM-based summarization.
- * Falls back to sync `compress` when the caller doesn't support async.
- */
-export interface AsyncCompressionStrategy extends CompressionStrategy {
-    compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
-}
-export declare function isAsyncCompressionStrategy(s: CompressionStrategy): s is AsyncCompressionStrategy;
-/** Caller-provided LLM summarization function (wired by Hub). */
-export type SummarizeFn = (messages: CompressibleMessage[], instruction: string) => Promise<string>;
-export declare class SlidingWindowStrategy implements CompressionStrategy {
-    private estimateTokens;
-    constructor(estimateTokens: (msg: CompressibleMessage) => number);
-    compress(messages: CompressibleMessage[], budget: number): CompressionResult;
-}
-export declare class SummarizeOldStrategy implements CompressionStrategy {
-    private recentCount;
-    private summarize;
-    constructor(recentCount: number, summarize: (messages: CompressibleMessage[]) => string);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-}
-export declare class ToolResultTrimStrategy implements CompressionStrategy {
-    private maxToolResultChars;
-    constructor(maxToolResultChars?: number);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-}
-export declare function composeStrategies(...strategies: CompressionStrategy[]): CompressionStrategy;
-/**
- * Compose strategies with async support — if any strategy is async,
- * the pipeline becomes async.
- */
-export declare function composeAsyncStrategies(...strategies: CompressionStrategy[]): AsyncCompressionStrategy;
-/**
- * Build the structured 9-section summary instruction for the LLM.
- * Based on Claude Code's Full Compact mode, adapted for Hub.
- */
-export declare function buildStructuredSummaryPrompt(messagesToSummarize: CompressibleMessage[], opts?: {
-    taskContext?: string;
-}): string;
-export interface HeadTailProtectionConfig {
-    /** Number of initial user-assistant exchanges to protect (default: 1) */
-    protectedHeadExchanges: number;
-    /** Number of recent messages to always keep (default: 8 = ~4 exchanges) */
-    protectedTailMessages: number;
-    /** The summarization callback */
-    summarize: SummarizeFn;
-    /** Optional token estimator */
-    estimateTokens?: (msg: CompressibleMessage) => number;
-    /** Optional extra context for the summary prompt */
-    taskContext?: string;
-}
-/**
- * Phase 2.2: Head/Tail protected summarization.
- *
- * Protects: system messages + first exchange + last N messages.
- * Compresses: middle section via LLM summarization.
- */
-export declare class HeadTailProtectedStrategy implements AsyncCompressionStrategy {
-    private config;
-    constructor(config: HeadTailProtectionConfig);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-    compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
-}
-export interface IncrementalCompactConfig {
-    /** Messages newer than this count are never summarized (default: 12) */
-    preserveRecentCount: number;
-    /** Summarization callback */
-    summarize: SummarizeFn;
-    /** Token estimator */
-    estimateTokens?: (msg: CompressibleMessage) => number;
-}
-/**
- * Phase 2.3: Incremental (partial) compaction.
- *
- * Only summarizes the oldest messages beyond the preserve window.
- * Avoids repeatedly re-summarizing already-compressed content.
- * If a previous summary marker exists, only new old messages are compressed.
- */
-export declare class IncrementalCompactStrategy implements AsyncCompressionStrategy {
-    private config;
-    constructor(config: IncrementalCompactConfig);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-    compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
-}
-export interface CacheAwareCompressionConfig {
-    /** The inner strategy to delegate to */
-    inner: CompressionStrategy;
-    /** Token estimator */
-    estimateTokens?: (msg: CompressibleMessage) => number;
-    /**
-     * Callback: notify when prompt cache was invalidated by compression.
-     * Hub uses this to set pendingPostCompaction and track cache miss rate.
-     */
-    onCacheInvalidated?: (info: {
-        droppedCount: number;
-        strategy: string;
-    }) => void;
-}
-/**
- * Phase 3: Cache-aware wrapper.
- *
- * Wraps any strategy and tracks whether compression invalidated the
- * provider prompt cache. System prompt prefix stability is preserved
- * by never modifying system[0] (the original system prompt).
- */
-export declare class CacheAwareCompressionStrategy implements AsyncCompressionStrategy {
-    private config;
-    constructor(config: CacheAwareCompressionConfig);
-    compress(messages: CompressibleMessage[], budget: number): CompressionResult;
-    compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
-}
-export interface AdaptiveBudgetConfig {
-    /** Model context window size in tokens */
-    modelContextWindow: number;
-    /** Target usage ratio (0.0–1.0, default 0.75) — trigger compaction at this fraction */
-    targetUsageRatio: number;
-    /** Minimum guaranteed budget in tokens */
-    minBudget: number;
-    /** Maximum budget (usually = modelContextWindow) */
-    maxBudget: number;
-}
-export declare const DEFAULT_ADAPTIVE_BUDGET_CONFIG: AdaptiveBudgetConfig;
-/**
- * Compute the adaptive token budget for a given model + message history.
- *
- * Adjusts based on model context window, and uses the target ratio
- * so compression triggers before hitting the hard limit.
- */
-export declare function computeAdaptiveBudget(config?: Partial<AdaptiveBudgetConfig>): number;
-/**
- * Decide which compression tier to use based on current token count vs budget.
- */
-export type CompressionTier = "none" | "trim-only" | "sliding-window" | "llm-summarize";
-export declare function selectCompressionTier(currentTokens: number, budget: number): CompressionTier;
-export interface CompressionEvent {
-    timestamp: number;
-    strategy: string;
-    tokensBefore: number;
-    tokensAfter: number;
-    droppedCount: number;
-    latencyMs: number;
-    usedLlm: boolean;
-    cacheInvalidated: boolean;
-    tier: CompressionTier;
-}
-export interface CompressionMetricsSnapshot {
-    totalCompressions: number;
-    totalLlmCalls: number;
-    totalCacheInvalidations: number;
-    averageCompressionRatio: number;
-    averageLatencyMs: number;
-    totalTokensSaved: number;
-    recentEvents: CompressionEvent[];
-}
-export declare class CompressionMetricsCollector {
-    private events;
-    private maxEvents;
-    constructor(maxEvents?: number);
-    record(event: CompressionEvent): void;
-    snapshot(): CompressionMetricsSnapshot;
-    reset(): void;
-}
-/**
- * A pluggable context engine. Only one can be active at a time.
- * The default engine uses the 4-layer compression funnel.
- */
-export interface ContextEngine {
-    /** Unique engine identifier */
-    readonly id: string;
-    /** Human-readable label */
-    readonly label: string;
-    /** Compress messages for a turn */
-    compressAsync(messages: CompressibleMessage[], budget: number, context?: {
-        model?: string;
-        sessionId?: string;
-    }): Promise<CompressionResult>;
-}
-/**
- * Registry for context engines. Enforces single-active constraint.
- */
-export declare class ContextEngineRegistry {
-    private engines;
-    private activeId;
-    register(engine: ContextEngine): void;
-    activate(id: string): boolean;
-    getActive(): ContextEngine | undefined;
-    listEngines(): Array<{
-        id: string;
-        label: string;
-        active: boolean;
-    }>;
-}

package/dist/types/orchestration/conversation-repair.d.ts

@@ -1,61 +0,0 @@
-export interface OpenAiToolCall {
-    id: string;
-    type: "function";
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-export interface OpenAiChatToolCallRef {
-    id?: string;
-    function?: {
-        name?: string;
-        arguments?: string;
-    };
-    name?: string;
-    [key: string]: unknown;
-}
-export interface OpenAiChatMessageLike {
-    role: string;
-    content?: unknown;
-    tool_calls?: OpenAiChatToolCallRef[];
-    tool_call_id?: string;
-    [key: string]: unknown;
-}
-export interface OpenAiResponsesItemLike {
-    type: string;
-    id?: string;
-    call_id?: string;
-    role?: string;
-    content?: unknown;
-    status?: string;
-    [key: string]: unknown;
-}
-export interface ConversationRepairOptions {
-    stopReason?: string;
-    placeholderToolResult?: string;
-    placeholderFunctionCallOutput?: string;
-    forcedStopReasons?: readonly string[];
-}
-type ContentPart = {
-    type: string;
-    text?: string;
-    [key: string]: unknown;
-};
-export type { ContentPart };
-export declare function sanitizeOpenAiChatMessages<T extends OpenAiChatMessageLike>(messages: readonly T[]): T[];
-export declare function ensureAssistantReasoningContent<T extends Record<string, unknown>>(messages: readonly T[], defaultValue?: string): T[];
-export declare function stripForcedStopAssistantToolMetadata<T extends OpenAiChatMessageLike>(messages: readonly T[], options?: ConversationRepairOptions): T[];
-export declare function injectDanglingToolCallPlaceholders<T extends OpenAiChatMessageLike>(messages: readonly T[], options?: ConversationRepairOptions): T[];
-export declare function repairOpenAiChatConversation<T extends OpenAiChatMessageLike>(messages: readonly T[], options?: ConversationRepairOptions): T[];
-export declare function downgradeOpenAiFunctionCallReasoningPairs<T extends {
-    role?: unknown;
-    content?: unknown;
-    toolCallId?: unknown;
-    toolUseId?: unknown;
-}>(messages: readonly T[]): T[];
-export declare function downgradeOpenAiReasoningBlocks<T extends {
-    role?: unknown;
-    content?: unknown;
-}>(messages: readonly T[]): T[];
-export declare function repairOpenAiResponsesItems<T extends OpenAiResponsesItemLike>(items: readonly T[], options?: ConversationRepairOptions): T[];

package/dist/types/orchestration/curator-scheduler.d.ts

@@ -1,119 +0,0 @@
-/**
- * Curator scheduler — pure strategy for autonomous skill library
- * maintenance. Decides WHEN to run the curator review cycle and
- * computes automatic lifecycle transitions (active → stale → archived).
- *
- * No I/O — all functions are pure; the caller supplies timestamps and
- * skill records, and receives transition instructions back.
- */
-/** Policy knobs for the curator scheduler. */
-export interface CuratorSchedulePolicy {
-    /** Minimum idle seconds before curator may trigger (default: 7200 = 2 h). */
-    minIdleSeconds: number;
-    /** Minimum interval between curator runs in seconds (default: 604800 = 7 days). */
-    intervalSeconds: number;
-    /** Days without activity before marking a skill stale (default: 30). */
-    staleAfterDays: number;
-    /** Days without activity before archiving a stale skill (default: 90). */
-    archiveAfterDays: number;
-    /** Maximum skills to process in one LLM review pass (default: 50). */
-    maxReviewBatchSize: number;
-}
-export declare const DEFAULT_CURATOR_SCHEDULE_POLICY: CuratorSchedulePolicy;
-/** Persistent curator state (stored by the host runtime). */
-export interface CuratorState {
-    /** ISO-8601 timestamp of last curator run. */
-    lastRunAt: string | null;
-    /** Duration of last run in seconds. */
-    lastRunDurationSeconds: number;
-    /** Human-readable summary of last run. */
-    lastRunSummary: string;
-    /** Whether curator is paused by the user. */
-    paused: boolean;
-    /** Cumulative run count. */
-    runCount: number;
-}
-export declare const INITIAL_CURATOR_STATE: CuratorState;
-/** Lifecycle state of an agent-created skill. */
-export type CuratorSkillLifecycleState = "active" | "stale" | "archived";
-/** Minimal skill activity record consumed by the scheduler. */
-export interface CuratorSkillRecord {
-    /** Skill name / identifier. */
-    name: string;
-    /** Whether this skill was agent-created (only these are curated). */
-    agentCreated: boolean;
-    /** Current lifecycle state. */
-    state: CuratorSkillLifecycleState;
-    /** Whether the user pinned this skill (immune to auto-transitions). */
-    pinned: boolean;
-    /** ISO-8601 timestamp of last activity. */
-    lastActivityAt: string | null;
-    /** Cumulative use count. */
-    useCount: number;
-    /** ISO-8601 timestamp of creation. */
-    createdAt: string;
-}
-/** Input for the gate check. */
-export interface CuratorGateInput {
-    /** Current ISO-8601 timestamp. */
-    now: string;
-    /** Seconds the session has been idle. */
-    idleSeconds: number;
-    /** Current curator state. */
-    state: CuratorState;
-    /** Whether the feature is enabled at all. */
-    enabled: boolean;
-    /** Policy overrides. */
-    policy?: Partial<CuratorSchedulePolicy>;
-}
-/** Result of the gate check: should the curator run? */
-export interface CuratorGateResult {
-    shouldRun: boolean;
-    reason: string;
-}
-/**
- * Determine whether the curator should run now.
- *
- * All gates must pass:
- * 1. Feature enabled
- * 2. Not paused
- * 3. Session idle ≥ minIdleSeconds
- * 4. Time since last run ≥ intervalSeconds
- */
-export declare function shouldRunCurator(input: CuratorGateInput): CuratorGateResult;
-/** A single lifecycle transition computed by the scheduler. */
-export interface CuratorLifecycleTransition {
-    skillName: string;
-    from: CuratorSkillLifecycleState;
-    to: CuratorSkillLifecycleState;
-    reason: string;
-}
-/** Summary of all auto-transitions in one pass. */
-export interface CuratorAutoTransitionResult {
-    checked: number;
-    transitions: CuratorLifecycleTransition[];
-    markedStale: number;
-    archived: number;
-    reactivated: number;
-}
-/**
- * Compute automatic lifecycle transitions for agent-created skills.
- *
- * Pure function — no I/O, no mutations. The caller applies the
- * returned transitions to its skill storage.
- *
- * Rules:
- * - Pinned skills are never transitioned.
- * - Non-agent-created skills are skipped.
- * - active → stale: no activity for staleAfterDays.
- * - stale → archived: no activity for archiveAfterDays.
- * - stale/archived → active: if useCount increased (reactivation).
- */
-export declare function computeLifecycleTransitions(skills: readonly CuratorSkillRecord[], now: string, policy?: Partial<CuratorSchedulePolicy>): CuratorAutoTransitionResult;
-/**
- * Select skills that should be reviewed by the LLM curator.
- *
- * Only non-pinned, agent-created skills in active or stale state
- * are eligible for review. Returns at most maxReviewBatchSize names.
- */
-export declare function selectReviewCandidates(skills: readonly CuratorSkillRecord[], policy?: Partial<CuratorSchedulePolicy>): string[];

package/dist/types/orchestration/embedded-failover-policy.d.ts

@@ -1,110 +0,0 @@
-export type EmbeddedPromptFailureAction<TThinkingLevel extends string = string, TFailoverReason extends string = string> = {
-    kind: "retry-rotated";
-} | {
-    kind: "retry-thinking";
-    thinkLevel: TThinkingLevel;
-} | {
-    kind: "throw-failover";
-    reason: TFailoverReason | null;
-} | {
-    kind: "unhandled";
-};
-export type EmbeddedAssistantFailureAction<TFailoverReason extends string = string> = {
-    kind: "retry-rotated";
-} | {
-    kind: "throw-failover";
-    reason: TFailoverReason | null;
-} | {
-    kind: "unhandled";
-};
-export type EmbeddedPromptErrorPolicyResolution<TThinkingLevel extends string = string, TFailoverReason extends string = string> = {
-    kind: "noop";
-} | {
-    kind: "return-error";
-    errorKind: "role_ordering" | "image_size";
-    text: string;
-    message: string;
-} | {
-    kind: "retry-rotated";
-} | {
-    kind: "retry-thinking";
-    thinkLevel: TThinkingLevel;
-} | {
-    kind: "throw-failover";
-    reason: TFailoverReason | null;
-} | {
-    kind: "throw-original";
-};
-export declare function resolveRetryableFailureReason<TReason extends string = string>(params: {
-    reason: TReason | null | undefined;
-    nonRetryableReasons?: readonly TReason[];
-}): TReason | null;
-export declare function resolveAuthProfileFailoverReason<TFailoverReason extends string = string>(params: {
-    allInCooldown: boolean;
-    unavailableReason?: TFailoverReason | null;
-    classifiedReason?: TFailoverReason | null;
-    cooldownFallbackReason: TFailoverReason;
-    defaultReason: TFailoverReason;
-}): TFailoverReason;
-export declare function resolveFallbackThinkingDecision<TThinkingLevel extends string = string>(params: {
-    aborted: boolean;
-    fallbackThinking?: TThinkingLevel;
-    provider: string;
-    modelId: string;
-}): {
-    thinkLevel: TThinkingLevel;
-    warningMessage: string;
-} | undefined;
-export declare function pickFallbackThinkingLevel<TThinkingLevel extends string = string>(params: {
-    message?: string;
-    attempted: Set<TThinkingLevel>;
-    normalizeThinkLevel: (raw: string) => TThinkingLevel | undefined;
-    offLevel?: TThinkingLevel;
-}): TThinkingLevel | undefined;
-export declare function shouldAttemptPromptFailureRotation<TFailoverReason extends string = string>(params: {
-    promptFailoverFailure: boolean;
-    promptFailoverReason: TFailoverReason | null;
-    nonRotatableReasons?: readonly TFailoverReason[];
-}): boolean;
-export declare function shouldAttemptAssistantFailureRotation(params: {
-    timedOut: boolean;
-    timedOutDuringCompaction: boolean;
-    failoverFailure: boolean;
-}): boolean;
-export declare function resolvePromptFailureActionDecision<TThinkingLevel extends string = string, TFailoverReason extends string = string>(params: {
-    promptFailoverFailure: boolean;
-    canRotate: boolean;
-    fallbackThinking?: TThinkingLevel;
-    fallbackConfigured: boolean;
-    promptFailoverReason: TFailoverReason | null;
-}): EmbeddedPromptFailureAction<TThinkingLevel, TFailoverReason>;
-export declare function resolveAssistantFailureActionDecision<TFailoverReason extends string = string>(params: {
-    timedOut: boolean;
-    timedOutDuringCompaction: boolean;
-    failoverFailure: boolean;
-    canRotate: boolean;
-    shouldThrowFailover: boolean;
-    failoverReason: TFailoverReason | null;
-}): EmbeddedAssistantFailureAction<TFailoverReason>;
-export declare function resolvePromptErrorPolicy<TThinkingLevel extends string = string, TFailoverReason extends string = string>(params: {
-    hasPromptError: boolean;
-    aborted: boolean;
-    errorText: string;
-    roleAlternationError: boolean;
-    imageSizeMaxMb?: number | null;
-    promptFailureAction: EmbeddedPromptFailureAction<TThinkingLevel, TFailoverReason>;
-}): EmbeddedPromptErrorPolicyResolution<TThinkingLevel, TFailoverReason>;
-export declare function buildAssistantFailoverErrorDetails(params: {
-    formattedAssistantErrorText?: string;
-    assistantErrorMessage?: string;
-    timedOut: boolean;
-    rateLimitFailure: boolean;
-    billingFailureMessage?: string;
-    authFailure: boolean;
-    failoverStatus?: number;
-    timeoutDetectedFromMessage: boolean;
-    timeoutStatus?: number;
-}): {
-    message: string;
-    status: number | undefined;
-};

package/dist/types/orchestration/error-classification.d.ts

@@ -1,12 +0,0 @@
-import type { FailoverReason } from "./failover-classification.js";
-export type ErrorCategory = "RETRYABLE_TRANSIENT" | "RETRYABLE_DEGRADED" | "NON_RETRYABLE_AUTH" | "NON_RETRYABLE_CONTENT" | "NON_RETRYABLE_QUOTA" | "TOOL_EXECUTION_FAILED";
-export interface RetryStrategy {
-    retryable: boolean;
-    maxRetries: number;
-    baseDelayMs: number;
-    backoffMultiplier: number;
-    switchProvider: boolean;
-}
-export declare function classifyError(status: number | undefined, message?: string): ErrorCategory;
-export declare function classifyErrorFromReason(reason: FailoverReason): ErrorCategory;
-export declare function getRetryStrategy(category: ErrorCategory): RetryStrategy;

package/dist/types/orchestration/failover-classification.d.ts

@@ -1,8 +0,0 @@
-export type FailoverReason = "auth" | "auth_permanent" | "format" | "rate_limit" | "overloaded" | "billing" | "timeout" | "model_not_found" | "session_expired" | "unknown";
-export declare function isTimeoutErrorMessage(raw: string): boolean;
-export declare function isCloudflareOrHtmlErrorPage(raw: string): boolean;
-export declare function isTransientHttpError(raw: string): boolean;
-export declare function classifyFailoverReasonFromHttpStatus(status: number | undefined, message?: string): FailoverReason | null;
-export declare function isModelNotFoundErrorMessage(raw: string): boolean;
-export declare function classifyFailoverReason(raw: string): FailoverReason | null;
-export declare function isFailoverErrorMessage(raw: string): boolean;

package/dist/types/orchestration/failover-error.d.ts

@@ -1,33 +0,0 @@
-import { type FailoverReason } from "./failover-classification.js";
-export declare class FailoverError extends Error {
-    readonly reason: FailoverReason;
-    readonly provider?: string;
-    readonly model?: string;
-    readonly profileId?: string;
-    readonly status?: number;
-    readonly code?: string;
-    constructor(message: string, params: {
-        reason: FailoverReason;
-        provider?: string;
-        model?: string;
-        profileId?: string;
-        status?: number;
-        code?: string;
-        cause?: unknown;
-    });
-}
-export declare function isFailoverError(err: unknown): err is FailoverError;
-export declare function resolveFailoverStatus(reason: FailoverReason): number | undefined;
-export declare function isTimeoutError(err: unknown): boolean;
-export declare function resolveFailoverReasonFromError(err: unknown): FailoverReason | null;
-export declare function describeFailoverError(err: unknown): {
-    message: string;
-    reason?: FailoverReason;
-    status?: number;
-    code?: string;
-};
-export declare function coerceToFailoverError(err: unknown, context?: {
-    provider?: string;
-    model?: string;
-    profileId?: string;
-}): FailoverError | null;