@librechat/agents 4.0.1 → 4.0.2

package/dist/types/decisions/transport.d.ts

@@ -0,0 +1,29 @@
+import type { DecisionCredential } from './types';
+export type DecisionFetch = (input: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+    signal: AbortSignal;
+    redirect: 'error';
+}) => Promise<Pick<Response, 'ok' | 'status' | 'headers' | 'body'>>;
+export interface TransportOptions {
+    providerId: string;
+    apiKey?: DecisionCredential;
+    requiresAuth?: boolean;
+    /** Full URL, not a base path. */
+    endpoint: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    fetch?: DecisionFetch;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    /** Called only after the response parses, with no state, answers, or credentials. */
+    onAnswered?: (label: string, ms: number) => void;
+}
+export type Transport = <T>(prepare: () => {
+    payload: string;
+    parse: (body: string) => T;
+}, signal: AbortSignal | undefined, label: string, timeoutOverrideMs?: number) => Promise<T>;
+export declare function failureForStatus(status: number): 'unauthorized' | 'rate_limited' | 'server_error' | 'bad_request';
+export declare function retryAfterMs(header: string | null): number | undefined;
+/** One immutable transport; every call owns its signal, deadline, and credentials. */
+export declare function createTransport(options: TransportOptions): Transport;

package/dist/types/decisions/types.d.ts

@@ -0,0 +1,119 @@
+/** Typed decisions over content, independent of the model that makes them. */
+export type DecisionJson = string | number | boolean | null | DecisionJson[] | {
+    [key: string]: DecisionJson;
+};
+export type DecisionText = string | DecisionJson[] | {
+    [key: string]: DecisionJson;
+};
+export type DecisionState = DecisionText;
+export interface BooleanCriteria {
+    true?: DecisionText;
+    false?: DecisionText;
+}
+/** A string criterion describes the yes side of a yes/no question. */
+export interface BooleanQuestion {
+    type: 'boolean';
+    instructions: DecisionText;
+    criteria?: BooleanCriteria | string;
+}
+export interface ChoiceQuestion {
+    type: 'choice';
+    instructions: DecisionText;
+    criteria: Record<string, DecisionText | null>;
+}
+/** The measured answer is an expected level, which may fall between two rubric levels. */
+export interface ScoreQuestion {
+    type: 'score';
+    instructions: DecisionText;
+    criteria: DecisionText[];
+}
+export type DecisionQuestion = BooleanQuestion | ChoiceQuestion | ScoreQuestion;
+/** `null` is an unmeasured decision, not a probability of zero. */
+export type BooleanAnswer = {
+    type: 'boolean';
+    probability: number;
+    decision?: never;
+} | {
+    type: 'boolean';
+    probability: null;
+    decision: boolean;
+};
+export interface ChoiceAnswer {
+    type: 'choice';
+    choice: string;
+    /** Backend-specific concentration measure; Jev and Laya use different definitions. */
+    confidence: number | null;
+    /** `null` when no distribution was measured; never substitute an empty distribution. */
+    probabilities: Record<string, number> | null;
+}
+export interface ScoreAnswer {
+    type: 'score';
+    /** Expected value over rubric levels, not an LLM's selection of one level. */
+    score: number;
+    /** Backend-specific concentration measure; do not transfer thresholds between checkpoints. */
+    confidence: number | null;
+    probabilities: Record<string, number> | null;
+}
+export type DecisionAnswer = BooleanAnswer | ChoiceAnswer | ScoreAnswer;
+/** Unknown counts are omitted, never inferred from an answer or replaced by zero. */
+export interface DecisionUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+}
+export interface DecisionRequest {
+    state: DecisionState;
+    questions: Record<string, DecisionQuestion>;
+    signal?: AbortSignal;
+    label?: string;
+    /** Overrides the provider's timeout for this request alone. */
+    timeoutMs?: number;
+}
+export interface DecisionResult {
+    model: string;
+    /** A requested answer can be omitted; callers must handle `undefined` explicitly. */
+    answers: Record<string, DecisionAnswer | undefined>;
+    usage: DecisionUsage | null;
+}
+export interface DecisionModel {
+    readonly id: string;
+    readonly model: string;
+    decide(request: DecisionRequest): Promise<DecisionResult>;
+}
+export type DecisionDialect = 'port' | 'systemone';
+/** A bearer key, or a per-request token minter; a 401 requests one fresh token for that call. */
+export type DecisionCredential = string | ((options: {
+    refresh: boolean;
+    signal?: AbortSignal;
+}) => Promise<string>);
+export interface DecisionProviderSettings {
+    /** Full URL of the decision endpoint, not a base path. */
+    baseURL?: string;
+    model?: string;
+    dialect?: DecisionDialect;
+    requestKey?: string;
+    responseKey?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    /** Auth is required by default; self-hosted Laya can be unauthenticated. */
+    requiresAuth?: boolean;
+    apiKeyEnv?: string;
+}
+export type DecisionFailure = 'timeout' | 'aborted' | 'rate_limited' | 'unauthorized' | 'bad_request' | 'server_error' | 'network' | 'unsupported_question' | 'unsupported_mode' | 'malformed_response';
+export declare class DecisionError extends Error {
+    readonly failure: DecisionFailure;
+    readonly provider: string;
+    readonly status?: number;
+    retryAfterMs?: number;
+    constructor(failure: DecisionFailure, message: string, options?: {
+        provider?: string;
+        status?: number;
+    });
+}
+/** A JSON boundary guard; never trust a parsed response's declared TypeScript type. */
+export declare function isDecisionObject(value: unknown): value is {
+    [key: string]: unknown;
+};
+export declare function readDecisionUsage(raw: unknown): DecisionUsage | null;
+export declare function isBooleanAnswer(answer: DecisionAnswer | undefined): answer is BooleanAnswer;
+export declare function isChoiceAnswer(answer: DecisionAnswer | undefined): answer is ChoiceAnswer;
+export declare function isScoreAnswer(answer: DecisionAnswer | undefined): answer is ScoreAnswer;

package/dist/types/graphs/Graph.d.ts

@@ -305,6 +305,7 @@ export declare class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode>
     /** See {@link t.StandardGraphInput.subagentExecutionContext}. */
     readonly subagentExecutionContext?: t.SubagentExecutionContext;
     private readonly subagentContext?;
+    private readonly onSubagentResolutionFailure?;
     /** See {@link t.StandardGraphInput.preemption}. */
     preemption?: t.StreamPreemption;
     /**
@@ -441,7 +442,7 @@ export declare class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode>
      * from a discard.
      */
     private preemptRestartPending;
-    constructor({ runId, signal, agents, langfuse, tokenCounter, indexTokenCountMap, calibrationRatio, fadingTier, fadingTiers, subagentUsageSink, subagentTasks, subagentScope, subagentExecutionContext, subagentContext, preemption, streamLimits, toolExecution, clientDelegatedToolNames, }: t.StandardGraphInput, dependencies?: GraphFactoryDependencies);
+    constructor({ runId, signal, agents, langfuse, tokenCounter, indexTokenCountMap, calibrationRatio, fadingTier, fadingTiers, subagentUsageSink, subagentTasks, subagentScope, subagentExecutionContext, subagentContext, onSubagentResolutionFailure, preemption, streamLimits, toolExecution, clientDelegatedToolNames, }: t.StandardGraphInput, dependencies?: GraphFactoryDependencies);
     /**
      * A compaction applies its remove-all inside the agent subgraph, so the
      * subgraph's result carries only the retained tail, and an outer reducer

package/dist/types/index.d.ts

@@ -59,3 +59,5 @@ export { canSealPreempt } from './llm/preempt';
 export { isThinkingEnabled, getMaxOutputTokensKey } from './llm/request';
 export { DEFAULT_MAX_TOOL_CALL_ARG_BYTES, StreamLimitExceededError, resolveStreamLimits, } from './llm/streamLimits';
 export type { StreamedToolCallArgTally, ResolvedStreamLimits, StreamLimitState, StreamLimitKind, } from './llm/streamLimits';
+export * from './decisions';
+export * from './rerank';

package/dist/types/rerank/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './types';
+export { createSystemOneReranker } from './systemone';
+export type { SystemOneRerankerOptions } from './systemone';
+export { createWebSearchReranker } from './search';

package/dist/types/rerank/search.d.ts

@@ -0,0 +1,7 @@
+import type { Logger, SearchReranker } from '@/tools/search/types';
+import type { Reranker } from './types';
+/** Adapts index-based rankings to web-search highlights and its existing metrics/fallback policy. */
+export declare function createWebSearchReranker(reranker: Reranker, options?: {
+    timeoutMs?: number;
+    logger?: Logger;
+}): SearchReranker;

package/dist/types/rerank/systemone.d.ts

@@ -0,0 +1,13 @@
+import type { Reranker } from './types';
+import type { DecisionModel } from '@/decisions';
+export interface SystemOneRerankerOptions {
+    /** Inject a configured Jev/Laya HTTP decision model; chat cannot produce expected scores. */
+    model: DecisionModel;
+    /** Relevance levels from least to most relevant; evaluate this rubric for the checkpoint. */
+    rubric: readonly string[];
+    /** Reject oversized batches instead of silently dropping candidates. Defaults to 128. */
+    maxDocuments?: number;
+    timeoutMs?: number;
+}
+/** One shared query/candidate state and one score question per candidate, in one request. */
+export declare function createSystemOneReranker(options: SystemOneRerankerOptions): Reranker;

package/dist/types/rerank/types.d.ts

@@ -0,0 +1,24 @@
+import type { DecisionUsage } from '@/decisions';
+export interface RerankRequest {
+    query: string;
+    documents: readonly string[];
+    topK?: number;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface RankedDocument {
+    /** Index into the submitted documents, not an identity derived from text. */
+    index: number;
+    /** Provider-specific relevance score, ordered descending; not a portable threshold. */
+    score: number;
+}
+export interface RerankResult {
+    results: RankedDocument[];
+    model: string;
+    usage: DecisionUsage | null;
+}
+/** Rankings retain candidate identity; failures reject rather than fabricate scores. */
+export interface Reranker {
+    readonly id: string;
+    rerank(request: RerankRequest): Promise<RerankResult>;
+}

package/dist/types/run.d.ts

@@ -24,6 +24,7 @@ export declare class Run<_T extends t.BaseGraphState> {
     private streamLimits?;
     private subagentTasks?;
     private subagentContext?;
+    private onSubagentResolutionFailure?;
     private indexTokenCountMap?;
     calibrationRatio: number;
     fadingTier?: t.FadingTier;

package/dist/types/tools/search/types.d.ts

@@ -239,6 +239,8 @@ export interface ScrapeResult {
     references?: References;
     highlights?: Highlight[];
 }
+/** Host implementations need only the public ranking seam, not BaseReranker's private state. */
+export type SearchReranker = Pick<BaseReranker, 'provider' | 'rerank'>;
 export interface ProcessSourcesConfig {
     topResults?: number;
     /** Max chars of scraped content stored per source and passed to the
@@ -258,7 +260,7 @@ export interface ProcessSourcesConfig {
     separatorExpandBy?: number;
     strategies?: string[];
     filterContent?: boolean;
-    reranker?: BaseReranker;
+    reranker?: SearchReranker;
     logger?: Logger;
 }
 export interface FirecrawlConfig {

package/dist/types/tools/subagent/SubagentExecutionRegistry.d.ts

@@ -98,6 +98,7 @@ export declare class SubagentSettlementBindingError extends Error {
 export declare class SubagentExecutionRecord<TResult, TResolvedConfig, TActiveRun, TSettledOutput = never> {
     readonly address: SubagentExecutionAddress;
     private identityValue?;
+    private attemptedIdentityValue?;
     private bindingValue?;
     private bindingAuthority?;
     private invocationValue?;
@@ -118,6 +119,9 @@ export declare class SubagentExecutionRecord<TResult, TResolvedConfig, TActiveRu
     constructor(address: SubagentExecutionAddress, resumeExecution?: SubagentResumeExecution);
     get snapshot(): ExecutionSnapshot<TResult, TResolvedConfig, TActiveRun>;
     get identity(): SubagentExecutionIdentity | undefined;
+    /** Correlation only; never committed identity or resume authority. */
+    get attemptedIdentity(): SubagentExecutionIdentity | undefined;
+    recordIdentityAttempt(identity: SubagentExecutionIdentity): void;
     get binding(): SubagentDefinitionBinding | undefined;
     get resumeExecution(): SubagentResumeExecution | undefined;
     get invocation(): SubagentInvocationBinding | undefined;

package/dist/types/tools/subagent/SubagentExecutor.d.ts

@@ -3,6 +3,7 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type { MultiAgentGraphState, HumanInTheLoopConfig, StandardGraphInput, ExecutableSubagentConfigEntry, SubagentExecutionContext, SubagentContextAdapter, SubagentContextResult, SubagentTaskConfig, SubagentTaskRuntime, SubagentUsageSink, TokenCounter } from '@/types';
 import type { SubagentResumeManifest, SettledSubagentToolOutput } from './SubagentReplay';
+import type { SubagentResolutionPhase, SubagentResolutionCause, SubagentResolutionFailureHandler } from './diagnostics';
 import type { GraphFactory } from '@/graphs/graphFactory';
 import type { StandardGraph } from '@/graphs/Graph';
 import { HookRegistry } from '@/hooks';
@@ -74,6 +75,11 @@ export type SubagentExecuteParams = {
 export type SubagentExecuteResult = SubagentContextResult & {
     /** Tagged internal failure; foreground callers retain the legacy content. */
     error?: string;
+    /** Safe startup classification retained for detached host delivery. */
+    resolutionFailure?: {
+        phase: SubagentResolutionPhase;
+        cause: SubagentResolutionCause;
+    };
     /** Completed child work whose host projection must be retried without re-execution. */
     retryableDelivery?: true;
 };
@@ -161,6 +167,8 @@ export type SubagentExecutorOptions = {
     /** Host-owned process-local task namespace for detached execution. */
     taskConfig?: SubagentTaskConfig;
     subagentContext?: SubagentContextAdapter;
+    /** Host diagnostic sink and safe cause classifier for startup failures. */
+    onResolutionFailure?: SubagentResolutionFailureHandler;
 };
 export declare class SubagentExecutor {
     private readonly configs;
@@ -189,6 +197,7 @@ export declare class SubagentExecutor {
     private readonly usageSink?;
     private readonly taskConfig?;
     private readonly subagentContext?;
+    private readonly onResolutionFailure?;
     private readonly executions;
     private replayCheckpointWorkflow?;
     private readonly resolveParentHandlerRegistry?;
@@ -264,9 +273,13 @@ export declare class SubagentExecutor {
     clearHeavyState(): void;
     private getResumeCheckpointMarker;
     getSettledToolOutput(call: ToolCall, config: RunnableConfig): Promise<SettledSubagentToolOutput | undefined>;
+    private restoreSettledToolOutput;
     persistSettledToolOutput(call: ToolCall, config: RunnableConfig, settled: SettledSubagentToolOutput): Promise<void>;
     private persistChildCheckpointMarker;
     execute(params: SubagentExecuteParams): Promise<SubagentExecuteResult>;
+    private getReplaySignal;
+    private createReplayResolutionError;
+    private createResolutionFailure;
     private executeOnce;
     private completeHostContext;
     /**

package/dist/types/tools/subagent/diagnostics.d.ts

@@ -4,17 +4,41 @@ import { describeCodeApiError } from '@/tools/diagnostics';
 export type SubagentResolutionPhase = 'identity' | 'config';
 declare const SUBAGENT_ERROR_TYPES: readonly [readonly ["SubagentExecutionInvalidatedError", typeof SubagentExecutionInvalidatedError], readonly ["SubagentDefinitionBindingError", typeof SubagentDefinitionBindingError], readonly ["SubagentInvocationBindingError", typeof SubagentInvocationBindingError], readonly ["SubagentSettlementBindingError", typeof SubagentSettlementBindingError]];
 type SubagentErrorLabel = (typeof SUBAGENT_ERROR_TYPES)[number][0] | ReturnType<typeof describeCodeApiError>['type'];
-/**
- * Follows the rule in `@/tools/diagnostics`: every field is a value this
- * module owns or a host-registered subagent type, never text from the error.
- * The failure the model sees is a fixed sentence, so this line is the only
- * operator account of it; the host logs its own error text where it throws.
- */
+declare const SUBAGENT_RESOLUTION_MESSAGES: {
+    readonly workspace_unavailable: "Subagent error: Workspace unavailable. Retry later or choose another workspace.";
+    readonly agent_unavailable: "Subagent error: Agent not found or not accessible.";
+    readonly model_unavailable: "Subagent error: Model or provider unavailable.";
+    readonly configuration_changed: "Subagent error: Subagent configuration changed. Start a new execution.";
+    readonly unknown: "Subagent error: Unable to initialize the selected subagent.";
+};
+/** Host classifications accepted at the public failure boundary. */
+export type SubagentResolutionCause = keyof typeof SUBAGENT_RESOLUTION_MESSAGES;
+export type SubagentResolutionContext = {
+    parentRunId: string;
+    parentAgentId?: string;
+    parentToolCallId?: string;
+    threadId?: string;
+    childRunId: string;
+    childThreadId: string;
+    taskId?: string;
+};
+/** No received error text, writable error names, or stacks enter this payload. */
 export type SubagentResolutionDiagnostic = {
     phase: SubagentResolutionPhase;
     subagentType: string;
     aborted: boolean;
     type: SubagentErrorLabel;
-};
-export declare function logSubagentResolutionFailure(phase: SubagentResolutionPhase, subagentType: string, signal: AbortSignal, error: unknown): void;
+    cause: SubagentResolutionCause;
+    message: (typeof SUBAGENT_RESOLUTION_MESSAGES)[SubagentResolutionCause];
+} & Partial<SubagentResolutionContext>;
+/** The original error is private. Return a classification, never error text. */
+export type SubagentResolutionFailureHandler = (detail: Readonly<SubagentResolutionDiagnostic>, error: unknown) => SubagentResolutionCause | void;
+export declare function getSubagentResolutionFailureMessage(cause: SubagentResolutionCause): SubagentResolutionDiagnostic['message'];
+/** Safe typed failure retained when detached execution crosses the host boundary. */
+export declare class SubagentResolutionError extends Error {
+    readonly phase: SubagentResolutionPhase;
+    readonly resolutionCause: SubagentResolutionCause;
+    constructor(phase: SubagentResolutionPhase, cause: SubagentResolutionCause);
+}
+export declare function logSubagentResolutionFailure(phase: SubagentResolutionPhase, subagentType: string, signal: AbortSignal, error: unknown, context?: SubagentResolutionContext, onResolutionFailure?: SubagentResolutionFailureHandler): SubagentResolutionDiagnostic;
 export {};

package/dist/types/tools/subagent/index.d.ts

@@ -2,3 +2,5 @@ export { DEFAULT_SUBAGENT_DESCRIPTION, SubagentExecutor, filterSubagentResult, f
 export type { SubagentExecuteParams, SubagentExecuteResult, SubagentExecutorOptions, ChildGraphFactory, } from './SubagentExecutor';
 export { InMemorySubagentTaskStore } from './InMemorySubagentTaskStore';
 export type { InMemorySubagentTaskStoreOptions } from './InMemorySubagentTaskStore';
+export { SubagentResolutionError, getSubagentResolutionFailureMessage, } from './diagnostics';
+export type { SubagentResolutionPhase, SubagentResolutionCause, SubagentResolutionContext, SubagentResolutionDiagnostic, SubagentResolutionFailureHandler, } from './diagnostics';

package/dist/types/types/graph.d.ts

@@ -8,6 +8,7 @@ import type { RunStep, ModelResponseEvent, ModelToolsClaimedEvent, RunStepDeltaE
 import type { SummarizationNodeInput, SummarizeCompleteEvent, CompactionSemanticIndex, SummarizationConfig, SummarizeStartEvent, SummarizeDeltaEvent } from '@/types/summarize';
 import type { ToolMap, ToolSessionMap, ToolEndEvent, GenericTool, LCTool, ToolExecutionConfig, ToolExecuteBatchRequest } from '@/types/tools';
 import type { TokenCounter, StreamLimits, StreamPreemption, TokenBudgetBreakdown } from '@/types/run';
+import type { SubagentResolutionFailureHandler } from '@/tools/subagent/diagnostics';
 import type { SubagentTaskConfig } from '@/types/subagentTasks';
 import type { StandardGraph, MultiAgentGraph } from '@/graphs';
 import type { ProviderClientOptionsConfig } from '@/types/llm';
@@ -320,6 +321,8 @@ export type StandardGraphInput = {
     subagentTasks?: SubagentTaskConfig;
     /** Host-owned context and result projection for each isolated child execution. */
     subagentContext?: SubagentContextAdapter;
+    /** Receives private startup errors; returns only an SDK-owned public cause. */
+    onSubagentResolutionFailure?: SubagentResolutionFailureHandler;
     /**
      * True when this graph IS a subagent child run (set by `SubagentExecutor`
      * when it constructs the child graph). Drives the hook-input `agentId`

package/dist/types/types/run.d.ts

@@ -281,6 +281,8 @@ export type RunConfig = {
     subagentTasks?: SubagentTaskConfig;
     /** Authorizes and supplies host-owned context to isolated child runs. */
     subagentContext?: g.SubagentContextAdapter;
+    /** Host diagnostic sink for foreground, detached, and nested startup failures. */
+    onSubagentResolutionFailure?: g.StandardGraphInput['onSubagentResolutionFailure'];
     /**
      * Pre-constructed hook registry for this run. Hooks fire at lifecycle
      * points in `processStream` (RunStart, UserPromptSubmit, Stop,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "reova": {
     "enabled": true,
     "endpoint": "https://telemetry.reo.dev/data"

package/src/decisions/deadline.ts

@@ -0,0 +1,92 @@
+import { DecisionError } from './types';
+
+export type AwaitWithinDeadline = <T>(task: Promise<T>) => Promise<T>;
+
+/** Bounds even non-cooperative credential minters, fetches, body reads, and model calls. */
+export async function withDecisionDeadline<T>(
+  provider: string,
+  timeoutMs: number,
+  callerSignal: AbortSignal | undefined,
+  operation: (signal: AbortSignal, waitFor: AwaitWithinDeadline) => Promise<T>
+): Promise<T> {
+  if (
+    !Number.isSafeInteger(timeoutMs) ||
+    timeoutMs <= 0 ||
+    timeoutMs > 3_600_000
+  ) {
+    throw new DecisionError('bad_request', 'invalid decision model timeout', {
+      provider,
+    });
+  }
+  if (callerSignal?.aborted === true) {
+    throw new DecisionError('aborted', 'caller aborted the request', {
+      provider,
+    });
+  }
+
+  const expiresAt = performance.now() + timeoutMs;
+  const deadline = new AbortController();
+  const signal = callerSignal
+    ? AbortSignal.any([callerSignal, deadline.signal])
+    : deadline.signal;
+  const timer = setTimeout(() => deadline.abort(), timeoutMs);
+  const expired = (): boolean => {
+    if (performance.now() >= expiresAt) {
+      deadline.abort();
+    }
+    return signal.aborted;
+  };
+  const abortError = (): DecisionError => {
+    if (callerSignal?.aborted === true) {
+      return new DecisionError('aborted', 'caller aborted the request', {
+        provider,
+      });
+    }
+    return new DecisionError('timeout', 'decision model deadline exceeded', {
+      provider,
+    });
+  };
+
+  const waitFor: AwaitWithinDeadline = <U>(task: Promise<U>): Promise<U> =>
+    new Promise<U>((resolve, reject) => {
+      if (expired()) {
+        void task.catch(() => {});
+        reject(abortError());
+        return;
+      }
+      const onAbort = (): void => {
+        signal.removeEventListener('abort', onAbort);
+        reject(abortError());
+      };
+      signal.addEventListener('abort', onAbort, { once: true });
+      if (expired()) {
+        onAbort();
+      }
+      task.then(
+        (value) => {
+          signal.removeEventListener('abort', onAbort);
+          if (expired()) {
+            reject(abortError());
+          } else {
+            resolve(value);
+          }
+        },
+        (error: unknown) => {
+          signal.removeEventListener('abort', onAbort);
+          reject(expired() ? abortError() : error);
+        }
+      );
+    });
+
+  try {
+    return await waitFor(operation(signal, waitFor));
+  } catch (error) {
+    if (expired()) {
+      throw abortError();
+    }
+    throw error;
+  } finally {
+    expired();
+    clearTimeout(timer);
+  }
+}