qlogicagent 0.2.1 → 0.4.0

package/dist/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/orchestration/embedded-failover-policy.js

@@ -1,168 +0,0 @@
-export function resolveRetryableFailureReason(params) {
-    if (!params.reason) {
-        return null;
-    }
-    if ((params.nonRetryableReasons ?? []).includes(params.reason)) {
-        return null;
-    }
-    return params.reason;
-}
-export function resolveAuthProfileFailoverReason(params) {
-    if (params.allInCooldown) {
-        return params.unavailableReason ?? params.cooldownFallbackReason;
-    }
-    return params.classifiedReason ?? params.defaultReason;
-}
-export function resolveFallbackThinkingDecision(params) {
-    if (params.aborted || !params.fallbackThinking) {
-        return undefined;
-    }
-    return {
-        thinkLevel: params.fallbackThinking,
-        warningMessage: `unsupported thinking level for ${params.provider}/${params.modelId}; ` +
-            `retrying with ${params.fallbackThinking}`,
-    };
-}
-function extractSupportedThinkingValues(raw) {
-    const match = raw.match(/supported values are:\s*([^\n.]+)/i) ??
-        raw.match(/supported values:\s*([^\n.]+)/i);
-    if (!match?.[1]) {
-        return [];
-    }
-    const fragment = match[1];
-    const quoted = Array.from(fragment.matchAll(/['"]([^'"]+)['"]/g)).map((entry) => entry[1]?.trim());
-    if (quoted.length > 0) {
-        return quoted.filter((entry) => Boolean(entry));
-    }
-    return fragment
-        .split(/,|\band\b/gi)
-        .map((entry) => entry.replace(/^[^a-zA-Z]+|[^a-zA-Z]+$/g, "").trim())
-        .filter(Boolean);
-}
-export function pickFallbackThinkingLevel(params) {
-    const raw = params.message?.trim();
-    if (!raw) {
-        return undefined;
-    }
-    const supported = extractSupportedThinkingValues(raw);
-    if (supported.length === 0) {
-        if (/not supported/i.test(raw) &&
-            params.offLevel &&
-            !params.attempted.has(params.offLevel)) {
-            return params.offLevel;
-        }
-        return undefined;
-    }
-    for (const entry of supported) {
-        const normalized = params.normalizeThinkLevel(entry);
-        if (!normalized || params.attempted.has(normalized)) {
-            continue;
-        }
-        return normalized;
-    }
-    return undefined;
-}
-export function shouldAttemptPromptFailureRotation(params) {
-    if (!params.promptFailoverFailure) {
-        return false;
-    }
-    return !(params.nonRotatableReasons ?? []).includes(params.promptFailoverReason);
-}
-export function shouldAttemptAssistantFailureRotation(params) {
-    return params.failoverFailure || (params.timedOut && !params.timedOutDuringCompaction);
-}
-export function resolvePromptFailureActionDecision(params) {
-    if (params.canRotate) {
-        return { kind: "retry-rotated" };
-    }
-    if (params.fallbackThinking) {
-        return {
-            kind: "retry-thinking",
-            thinkLevel: params.fallbackThinking,
-        };
-    }
-    if (params.fallbackConfigured && params.promptFailoverFailure) {
-        return {
-            kind: "throw-failover",
-            reason: params.promptFailoverReason,
-        };
-    }
-    return { kind: "unhandled" };
-}
-export function resolveAssistantFailureActionDecision(params) {
-    const shouldRotate = shouldAttemptAssistantFailureRotation({
-        timedOut: params.timedOut,
-        timedOutDuringCompaction: params.timedOutDuringCompaction,
-        failoverFailure: params.failoverFailure,
-    });
-    if (!shouldRotate) {
-        return { kind: "unhandled" };
-    }
-    if (params.canRotate) {
-        return { kind: "retry-rotated" };
-    }
-    if (params.shouldThrowFailover) {
-        return {
-            kind: "throw-failover",
-            reason: params.failoverReason,
-        };
-    }
-    return { kind: "unhandled" };
-}
-export function resolvePromptErrorPolicy(params) {
-    if (!params.hasPromptError || params.aborted) {
-        return { kind: "noop" };
-    }
-    if (params.roleAlternationError) {
-        return {
-            kind: "return-error",
-            errorKind: "role_ordering",
-            text: "Message ordering conflict - please try again. " +
-                "If this persists, use /new to start a fresh session.",
-            message: params.errorText,
-        };
-    }
-    if (typeof params.imageSizeMaxMb === "number" && Number.isFinite(params.imageSizeMaxMb)) {
-        const maxBytesHint = ` (max ${params.imageSizeMaxMb}MB)`;
-        return {
-            kind: "return-error",
-            errorKind: "image_size",
-            text: `Image too large for the model${maxBytesHint}. ` +
-                "Please compress or resize the image and try again.",
-            message: params.errorText,
-        };
-    }
-    if (params.promptFailureAction.kind === "retry-rotated") {
-        return { kind: "retry-rotated" };
-    }
-    if (params.promptFailureAction.kind === "retry-thinking") {
-        return {
-            kind: "retry-thinking",
-            thinkLevel: params.promptFailureAction.thinkLevel,
-        };
-    }
-    if (params.promptFailureAction.kind === "throw-failover") {
-        return {
-            kind: "throw-failover",
-            reason: params.promptFailureAction.reason,
-        };
-    }
-    return { kind: "throw-original" };
-}
-export function buildAssistantFailoverErrorDetails(params) {
-    const message = params.formattedAssistantErrorText ||
-        params.assistantErrorMessage?.trim() ||
-        (params.timedOut
-            ? "LLM request timed out."
-            : params.rateLimitFailure
-                ? "LLM request rate limited."
-                : params.billingFailureMessage
-                    ? params.billingFailureMessage
-                    : params.authFailure
-                        ? "LLM request unauthorized."
-                        : "LLM request failed.");
-    return {
-        message,
-        status: params.failoverStatus ?? (params.timeoutDetectedFromMessage ? (params.timeoutStatus ?? 408) : undefined),
-    };
-}

package/dist/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/orchestration/error-classification.js

@@ -1,77 +0,0 @@
-// ============================================================
-// Error classification — maps FailoverReason to high-level
-// retry categories for consumers that need a simple decision.
-// ============================================================
-import { classifyFailoverReason, classifyFailoverReasonFromHttpStatus, } from "./failover-classification.js";
-const FAILOVER_TO_CATEGORY = {
-    timeout: "RETRYABLE_TRANSIENT",
-    overloaded: "RETRYABLE_TRANSIENT",
-    rate_limit: "RETRYABLE_DEGRADED",
-    auth: "NON_RETRYABLE_AUTH",
-    auth_permanent: "NON_RETRYABLE_AUTH",
-    billing: "NON_RETRYABLE_QUOTA",
-    format: "NON_RETRYABLE_CONTENT",
-    model_not_found: "NON_RETRYABLE_CONTENT",
-    session_expired: "NON_RETRYABLE_CONTENT",
-    unknown: "RETRYABLE_TRANSIENT",
-};
-const RETRY_STRATEGIES = {
-    RETRYABLE_TRANSIENT: {
-        retryable: true,
-        maxRetries: 3,
-        baseDelayMs: 1000,
-        backoffMultiplier: 2,
-        switchProvider: true,
-    },
-    RETRYABLE_DEGRADED: {
-        retryable: true,
-        maxRetries: 2,
-        baseDelayMs: 5000,
-        backoffMultiplier: 3,
-        switchProvider: true,
-    },
-    NON_RETRYABLE_AUTH: {
-        retryable: false,
-        maxRetries: 0,
-        baseDelayMs: 0,
-        backoffMultiplier: 1,
-        switchProvider: true,
-    },
-    NON_RETRYABLE_CONTENT: {
-        retryable: false,
-        maxRetries: 0,
-        baseDelayMs: 0,
-        backoffMultiplier: 1,
-        switchProvider: false,
-    },
-    NON_RETRYABLE_QUOTA: {
-        retryable: false,
-        maxRetries: 0,
-        baseDelayMs: 0,
-        backoffMultiplier: 1,
-        switchProvider: true,
-    },
-    TOOL_EXECUTION_FAILED: {
-        retryable: true,
-        maxRetries: 1,
-        baseDelayMs: 500,
-        backoffMultiplier: 1,
-        switchProvider: false,
-    },
-};
-export function classifyError(status, message) {
-    const reason = classifyFailoverReasonFromHttpStatus(status, message) ??
-        (message ? classifyFailoverReason(message) : null);
-    if (!reason) {
-        return typeof status === "number" && status >= 400 && status < 500
-            ? "NON_RETRYABLE_CONTENT"
-            : "RETRYABLE_TRANSIENT";
-    }
-    return FAILOVER_TO_CATEGORY[reason];
-}
-export function classifyErrorFromReason(reason) {
-    return FAILOVER_TO_CATEGORY[reason];
-}
-export function getRetryStrategy(category) {
-    return RETRY_STRATEGIES[category];
-}

package/dist/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;