@qvac/harness 0.7.0 → 1.0.0-rc.0

package/dist-lib/lib/capabilities/download.d.ts

@@ -45,4 +45,4 @@ export type SdkOrLoader = DownloadSdk | (() => Promise<DownloadSdk>);
 export interface DownloadEventStream extends Readable {
     [Symbol.asyncIterator](): AsyncIterableIterator<DownloadEvent>;
 }
-export declare function download(sdkOrLoader: SdkOrLoader, args: DownloadArgs, onSettled?: () => void): DownloadEventStream;
+export declare function download(sdkOrLoader: SdkOrLoader, args: DownloadArgs, onSettled?: () => void, onDrained?: () => void): DownloadEventStream;

package/dist-lib/lib/capabilities/download.js

@@ -2,7 +2,7 @@ import { Readable } from 'streamx';
 import { errorMessage } from '../guards.js';
 import { resolveModelSrc } from '../models/model-source.js';
 const noop = () => { };
-export function download(sdkOrLoader, args, onSettled) {
+export function download(sdkOrLoader, args, onSettled, onDrained) {
     const { model, addon = 'llm', seed, signal, projection, companions = [], assetSizes } = args;
     const loadSdk = typeof sdkOrLoader === 'function' ? sdkOrLoader : () => Promise.resolve(sdkOrLoader);
     let transferred = false;
@@ -36,7 +36,9 @@ export function download(sdkOrLoader, args, onSettled) {
     };
     const start = async () => {
         if (signal?.aborted) {
-            return finish({ type: 'aborted' });
+            finish({ type: 'aborted' });
+            onDrained?.();
+            return;
         }
         try {
             sdkRef = await loadSdk();
@@ -86,6 +88,9 @@ export function download(sdkOrLoader, args, onSettled) {
             }
             finish({ type: 'error', message: errorMessage(err) });
         }
+        finally {
+            onDrained?.();
+        }
     };
     const stream = new Readable({
         open(cb) {

package/dist-lib/lib/capabilities/invoke.js

@@ -1,5 +1,6 @@
 import { errorMessage } from '../guards.js';
 import { AbortedError } from '../helpers/race-abort.js';
+import { detachJson } from '../helpers/detach-json.js';
 const CAPABILITY_TOOLS = {
     image: { tool: 'generate_image', enhances: 'prompt' },
     translate: { tool: 'translate' }
@@ -34,13 +35,14 @@ export async function* invoke({ capability, args, tools, ctx, enhance = 'never',
     if (ctx.signal?.aborted) {
         return yield { type: 'aborted' };
     }
-    yield { type: 'tool-call', name: entry.tool, args: called, effect: tool.effect(called, ctx) };
+    const effect = tool.effect(detachJson(called), ctx);
+    yield { type: 'tool-call', name: entry.tool, args: detachJson(called), effect };
     try {
-        const result = await tool.execute(called, ctx);
+        const result = await tool.execute(detachJson(called), ctx);
         if (ctx.signal?.aborted) {
             return yield { type: 'aborted' };
         }
-        yield { type: 'tool-result', name: entry.tool, result };
+        yield { type: 'tool-result', name: entry.tool, result: detachJson(result) };
     }
     catch (err) {
         if (err instanceof AbortedError || ctx.signal?.aborted) {

package/dist-lib/lib/capabilities/tool-plan.d.ts

@@ -0,0 +1,35 @@
+import type { ToolEffect, ToolExecuteContext } from './completion.ts';
+import type { CompletionSkillEntry, ResolvedCall } from './completion-loop/index.ts';
+import { type SkillActivation } from './tool-selection.ts';
+import type { HookRejection, ResolvedCallSnapshot } from '../machine/index.ts';
+export interface ToolPolicyFacts {
+    readonly call: ResolvedCallSnapshot;
+    readonly toolAvailable: boolean;
+    readonly skillCall: boolean;
+    readonly skillAlreadyLoaded: boolean;
+    readonly skillStatus: string | null;
+    readonly skillActive: boolean;
+    readonly skillName: string;
+    readonly alreadyLoadedLabel: string;
+    readonly unavailableSkillMessage: string;
+    readonly searchCapReached: boolean;
+    readonly searchCapMessage: string;
+    readonly hookRejection: HookRejection | null;
+    readonly source: 'skill' | 'tool-result';
+    readonly effect: ToolEffect | undefined;
+}
+export interface PlanToolCallOptions {
+    readonly activation: SkillActivation;
+    readonly skillCatalog: readonly CompletionSkillEntry[];
+    readonly loadedThisTurn: ReadonlySet<string>;
+    readonly loadedFilesThisTurn: ReadonlySet<string>;
+    readonly webSearches: number;
+    readonly context: ToolExecuteContext;
+    readonly listShown: boolean;
+}
+interface KeyedResolvedCall extends ResolvedCall {
+    key: string;
+}
+export declare function planToolCall(resolved: KeyedResolvedCall, opts: PlanToolCallOptions): ToolPolicyFacts;
+export declare function skillFileKey(skillName: string, args: Record<string, unknown>): string | null;
+export {};

package/dist-lib/lib/capabilities/tool-plan.js

@@ -0,0 +1,66 @@
+import { MAX_WEB_SEARCHES_PER_TURN, unreadySkillState, WEB_SEARCH_LIMIT_MESSAGE } from './completion-loop/index.js';
+import { unquoteArg } from '../tools/model-args.js';
+import { mainFileRequested, skillFileArg, skillFileStem } from '../tools/skill.js';
+import { SKILL_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from './tool-names.js';
+import { skillIsActive } from './tool-selection.js';
+import { detachJson } from '../helpers/detach-json.js';
+function skillCallFacts({ skillCall, skillName, args, fileKey, tool, reloaded, opts }) {
+    const skillActive = skillIsActive(skillName, opts.activation);
+    return {
+        skillAlreadyLoaded: tool?.name === SKILL_TOOL_NAME && reloaded,
+        skillStatus: skillCall ? unreadySkillState(skillName, opts.skillCatalog) : null,
+        skillActive,
+        skillName: tool?.name === SKILL_TOOL_NAME ? skillName : '',
+        alreadyLoadedLabel: fileKey === null ? skillName : `${skillName} ${unquoteArg(skillFileArg(args))}`,
+        unavailableSkillMessage: skillCall && (!tool || !skillActive)
+            ? blockedSkillMessage(skillName, opts.skillCatalog, opts.listShown)
+            : ''
+    };
+}
+function blockedSkillMessage(name, catalog, listShown) {
+    if (catalog.some((entry) => entry.name === name)) {
+        return (`skill "${name}" is not enabled for this agent. Do not rebuild what it does with another ` +
+            `tool — answer from what you already have, or tell the user to enable it in Skills.`);
+    }
+    return listShown
+        ? `there is no skill named "${name}". Load one from the skills list you were shown, or ` +
+            `answer from what you already have — do not guess another name.`
+        : `there is no skill named "${name}". You were not shown a skills list, which means no ` +
+            `skill is available this turn — do not guess another name, and answer from what you ` +
+            `already have.`;
+}
+export function planToolCall(resolved, opts) {
+    const { call, tool, args, rejection } = resolved;
+    const skillCall = call.name === SKILL_TOOL_NAME;
+    const effect = tool?.effect(detachJson(args), opts.context) ?? (skillCall ? 'read' : undefined);
+    const source = skillCall ? 'skill' : 'tool-result';
+    const skillName = unquoteArg(args.name ?? args.skill_name ?? args.skill);
+    const fileKey = skillFileKey(skillName, args);
+    const reloaded = fileKey === null ? opts.loadedThisTurn.has(skillName) : opts.loadedFilesThisTurn.has(fileKey);
+    const skillFacts = skillCallFacts({ skillCall, skillName, args, fileKey, tool, reloaded, opts });
+    return {
+        call: {
+            id: call.id,
+            key: resolved.key,
+            name: call.name,
+            args,
+            rawCall: call.raw,
+            intent: resolved.intent,
+            rejection
+        },
+        toolAvailable: Boolean(tool),
+        skillCall,
+        ...skillFacts,
+        searchCapReached: tool?.name === WEB_SEARCH_TOOL_NAME && opts.webSearches >= MAX_WEB_SEARCHES_PER_TURN,
+        searchCapMessage: WEB_SEARCH_LIMIT_MESSAGE,
+        hookRejection: rejection ?? null,
+        source,
+        effect
+    };
+}
+export function skillFileKey(skillName, args) {
+    const file = skillFileArg(args);
+    return mainFileRequested(skillName, file)
+        ? null
+        : `${skillName}\0${skillFileStem(unquoteArg(file))}`;
+}

package/dist-lib/lib/capabilities/tool-turns.d.ts

@@ -1,9 +1,18 @@
 import type { Message } from './completion.ts';
+import { type CompletionHistoryEntry, type FailureResultValue } from '../machine/index.ts';
 export declare const DIRECT_CALL_ID = "call-direct";
-export declare const TOOL_CONTINUATION_NUDGE = "[Tool results above. Continue the user's request: call the next tool, or answer.]";
+export { TOOL_CONTINUATION_NUDGE } from '../machine/index.ts';
 export declare function toolResultTurn(name: string, id: string, output: unknown): string;
+interface ToolResultHistoryInput {
+    name: string;
+    id: string;
+    output: unknown;
+    resultRef?: string;
+}
+export declare function toolResultHistoryEntry({ name, id, output, resultRef }: ToolResultHistoryInput): CompletionHistoryEntry;
+export declare function materializeCompletionHistory(history: readonly CompletionHistoryEntry[], values: Readonly<Record<string, FailureResultValue>>): Message[];
 export declare function skillLoadedTurn(name: string): string;
 export declare function attachmentTurn(name: string, result: unknown): string | null;
 export declare function loadedSkillsFrom(messages: readonly Message[]): Set<string>;
 export declare function loadedSkillFilesFrom(messages: readonly Message[]): Map<string, Set<string>>;
-export declare function withoutSkillLoadTurns(messages: readonly Message[], name: string): Message[];
+export declare function withoutSkillLoadTurns(messages: readonly CompletionHistoryEntry[], name: string): CompletionHistoryEntry[];

package/dist-lib/lib/capabilities/tool-turns.js

@@ -1,10 +1,35 @@
 import { isRecord } from '../guards.js';
 import { SKILL_TOOL_NAME } from './tool-names.js';
+import { isFailureResultReference, readFailureResult } from '../machine/index.js';
 export const DIRECT_CALL_ID = 'call-direct';
-export const TOOL_CONTINUATION_NUDGE = "[Tool results above. Continue the user's request: call the next tool, or answer.]";
+export { TOOL_CONTINUATION_NUDGE } from '../machine/index.js';
 export function toolResultTurn(name, id, output) {
     return `[Tool: ${name} (${id})]\n${JSON.stringify(historyPayload(output))}`;
 }
+export function toolResultHistoryEntry({ name, id, output, resultRef }) {
+    return resultRef
+        ? {
+            type: 'qvac-failure-result-ref',
+            ref: resultRef,
+            callId: id
+        }
+        : { role: 'tool', content: toolResultTurn(name, id, output) };
+}
+export function materializeCompletionHistory(history, values) {
+    return history.map((entry) => {
+        if (!isFailureResultReference(entry)) {
+            return entry;
+        }
+        const stored = values[entry.ref];
+        if (!stored) {
+            throw new Error(`History references missing failed tool result: ${entry.ref}`);
+        }
+        return {
+            role: 'tool',
+            content: toolResultTurn(stored.name, entry.callId, readFailureResult(stored.result))
+        };
+    });
+}
 export function skillLoadedTurn(name) {
     return toolResultTurn(SKILL_TOOL_NAME, DIRECT_CALL_ID, {
         name,
@@ -12,8 +37,9 @@ export function skillLoadedTurn(name) {
     });
 }
 function refFrom(value) {
-    if (!value || typeof value !== 'object')
+    if (!value || typeof value !== 'object') {
         return null;
+    }
     if (!('attachmentId' in value) || typeof value.attachmentId !== 'string') {
         return null;
     }
@@ -66,6 +92,8 @@ export function loadedSkillFilesFrom(messages) {
 }
 export function withoutSkillLoadTurns(messages, name) {
     return messages.filter((turn) => {
+        if (isFailureResultReference(turn))
+            return true;
         const payload = skillLoadPayload(turn);
         return !payload || payload.name !== name || payload.file !== undefined;
     });

package/dist-lib/lib/capabilities/types.d.ts

@@ -0,0 +1,287 @@
+import type { CompletionFinal, Tool as SdkTool, ToolDialect } from '@qvac/sdk';
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { TextEvent } from '../helpers/thinking.ts';
+import type { LlmGenerationParams } from '../models/llm-presets.ts';
+import type { DriveRoot } from '../tools/fs/scope.ts';
+import type { CliValidator } from '../tools/skills/cli-schema.ts';
+import type { Toolset } from '../tools/toolsets.ts';
+import type { ToolCallDisplay } from '../tool-call-display.ts';
+import type { UsageBreakdown } from './usage-breakdown.ts';
+import type { Message, ResourceDescriptor, RunBackendUse, RunBudget, RunLifecycleEvent, ToolActivityEvent, ToolDecision, ToolEffect } from '../machine/index.ts';
+export type { Message, ResourceDescriptor, RunBackendUse, RunBudget, RunLifecycleEvent, ToolActivityEvent, ToolDecision, ToolEffect };
+export interface Agent {
+    id?: string;
+    name?: string;
+    bio?: string;
+    enabledTools?: string[] | null;
+    enabledSkills?: string[] | null;
+    toolsScope?: 'all' | 'selected' | null;
+    skillsScope?: 'all' | 'selected' | null;
+    reasoning?: 'inherit' | 'enabled' | 'disabled' | null;
+    ctxSize?: number | null;
+    kvCacheK?: string | null;
+    kvCacheV?: string | null;
+    imageModelChoice?: string | null;
+    imageSteps?: number | null;
+    imageWidth?: number | null;
+    imageHeight?: number | null;
+    approvalMode?: 'ask' | 'skip-all' | null;
+    disabledToolsets?: string[] | null;
+    sandboxMode?: boolean | null;
+}
+export interface ImageSettings {
+    modelChoice?: string;
+    steps?: number;
+    width?: number;
+    height?: number;
+}
+export interface MusicSettings {
+    modelChoice?: string;
+    steps?: number;
+    duration?: number;
+}
+export type ApproveFn = (call: {
+    name: string;
+    arguments: Record<string, unknown>;
+    callId?: string;
+    round?: number;
+    resource?: ResourceDescriptor | null;
+    effect?: ToolEffect;
+    intent?: string | null;
+    display?: ToolCallDisplay | null;
+}) => Promise<boolean>;
+export type ToolActivityFn = (entry: ToolActivityEvent) => void;
+export interface AttachInput {
+    fileName: string;
+    mimeType: string;
+    bytes: Uint8Array;
+    raw?: boolean;
+}
+export interface AttachmentRecord {
+    id: string;
+    fileName: string;
+    mimeType: string;
+    byteLength: number;
+}
+export type AttachFn = (input: AttachInput) => Promise<AttachmentRecord>;
+export interface AttachmentMeta {
+    id: string;
+    fileName: string;
+    mimeType: string;
+    byteLength: number;
+}
+export interface FetchedAttachment extends AttachmentMeta {
+    bytes: Uint8Array;
+}
+export type FetchAttachmentFn = (query: {
+    attachmentId?: string;
+    signal?: BareAbortSignal;
+    meta?: boolean;
+}) => Promise<FetchedAttachment | AttachmentMeta | null>;
+export type ProgressFn = (update: {
+    percentage: number;
+} | null) => void;
+export type RagSearchFn = (input: {
+    query: string;
+    limit?: number;
+}) => Promise<RagSearchResult>;
+export interface RagSearchResult {
+    enabled: boolean;
+    indexEmpty: boolean;
+    hasKnowledge: boolean;
+    pendingReferenced?: boolean;
+    errorMessage?: string | null;
+    hits: ReadonlyArray<{
+        content: string;
+        metadataJson?: string | null;
+        score: number;
+    }>;
+}
+export type AskUserFn = (question: {
+    question: string;
+    options?: string[];
+}) => Promise<string | null>;
+export interface ToolExecuteContext {
+    agentId?: string | null | undefined;
+    skills?: readonly string[] | undefined;
+    runId?: string;
+    callId?: string;
+    ctxSize?: number | undefined;
+    image?: ImageSettings | undefined;
+    settings?: Record<string, unknown> | undefined;
+    turnImages?: {
+        path: string;
+    }[] | undefined;
+    attach?: AttachFn | undefined;
+    fetchAttachment?: FetchAttachmentFn | undefined;
+    ragSearch?: RagSearchFn | undefined;
+    progress?: ProgressFn | undefined;
+    askUser?: AskUserFn | undefined;
+    signal?: BareAbortSignal | undefined;
+    fsRoots?: readonly DriveRoot[] | undefined;
+    fsWriteRoots?: readonly DriveRoot[] | undefined;
+    toolOps?: ReadonlyMap<string, readonly CliValidator[]> | undefined;
+    runBudget?: RunBudget | undefined;
+    reportBackend?: ((use: RunBackendUse) => void) | undefined;
+    uncappedResponse?: boolean | undefined;
+    sandboxMode?: boolean | undefined;
+    toolNames?: readonly string[] | undefined;
+    approval?: ToolDecision | undefined;
+}
+export type ToolParameterType = 'string' | 'number' | 'boolean' | 'object' | 'integer' | 'array' | 'null';
+export interface ToolParameterSchema {
+    type: ToolParameterType | readonly ToolParameterType[];
+    sensitive?: true;
+    description?: string;
+    enum?: string[];
+    items?: ToolParameterSchema;
+    properties?: Record<string, ToolParameterSchema>;
+    required?: string[];
+}
+export interface ToolParameters {
+    type: 'object';
+    properties: Record<string, ToolParameterSchema>;
+    required?: string[];
+}
+export interface ToolPromptDefinition {
+    description?: string;
+    parameters?: ToolParameters;
+}
+export interface ToolDefinition {
+    name: string;
+    policyVersion?: string;
+    description: string;
+    parameters: ToolParameters;
+    prompt?: ToolPromptDefinition;
+    autoApprove?: boolean;
+    skillGated?: boolean;
+    rootsRequired?: boolean;
+    writeRootsRequired?: boolean;
+    externalWrite?: boolean;
+    owningSkill?: string;
+    toolset: Toolset | null;
+    validate?: (args: Record<string, unknown>, ctx?: ToolExecuteContext) => string | null;
+    effect: (args: Record<string, unknown>, ctx?: ToolExecuteContext) => ToolEffect;
+    resource?: (args: Record<string, unknown>, ctx?: ToolExecuteContext) => ResourceDescriptor | null;
+    compiled?: true;
+    landedWrite?: (args: Record<string, unknown>, output: unknown) => string | null;
+    execute: (args: Record<string, unknown>, ctx?: ToolExecuteContext) => Promise<unknown>;
+}
+export interface ToolCallEvent {
+    type: 'tool-call';
+    name: string;
+    args: Record<string, unknown>;
+    rawCall?: string | undefined;
+    effect?: ToolEffect | undefined;
+    display?: ToolCallDisplay | undefined;
+}
+export interface ToolResultEvent {
+    type: 'tool-result';
+    name: string;
+    result: unknown;
+}
+export interface ErrorEvent {
+    type: 'error';
+    message: string;
+    name?: string;
+    code?: string;
+    kind?: 'machine' | 'log' | 'xstate';
+    found?: string;
+    expected?: string;
+    forkAt?: number | null;
+    forkSafe?: boolean;
+    recoveryOperationIds?: string[];
+}
+export interface AbortedEvent {
+    type: 'aborted';
+}
+export interface MetricsEvent {
+    type: 'metrics';
+    totalTokens: number;
+    durationMs: number;
+    timeToFirstToken?: number | undefined;
+    tokensPerSecond?: number | undefined;
+    promptTokensPerSecond?: number | undefined;
+    promptTokens?: number | undefined;
+    cacheTokens?: number | undefined;
+    ctxSize?: number | undefined;
+    backends?: RunBackendUse[] | undefined;
+    usage?: UsageBreakdown | undefined;
+    stopReason?: string | undefined;
+    route?: 'direct' | 'enhanced' | undefined;
+    routeModel?: string | undefined;
+}
+export interface InferenceCall {
+    round: number;
+    droppedTurns: number;
+    modelId: string;
+    messages: Message[];
+    tools: SdkTool[] | undefined;
+    generationParams: LlmGenerationParams | undefined;
+    responseFormat: ResponseFormat | undefined;
+    toolDialect: ToolDialect | undefined;
+    cacheKey: string | undefined;
+    promptPrefix: string;
+}
+export interface InferenceCallEvent {
+    type: 'inference-call';
+    call: InferenceCall;
+}
+export interface InferenceSentEvent {
+    type: 'inference-sent';
+    round: number;
+    droppedTurns: number;
+    messages: Message[] | undefined;
+    tokens: InferenceTokens | undefined;
+    outcome: 'completed' | 'overflowed' | 'failed';
+    reason: string | undefined;
+}
+export interface InferenceTokens {
+    prompt?: number | undefined;
+    generated?: number | undefined;
+    cached?: number | undefined;
+    timeToFirstToken?: number | undefined;
+}
+export type CompletionEvent = (RunLifecycleEvent | TextEvent | ToolCallEvent | ToolResultEvent | ToolActivityEvent | ErrorEvent | AbortedEvent | MetricsEvent | InferenceCallEvent | InferenceSentEvent) & {
+    runId?: string;
+    round?: number;
+    callId?: string;
+};
+export interface CompletionSdkResult {
+    requestId?: string;
+    tokenStream: AsyncIterable<string>;
+    final: Promise<CompletionFinal>;
+}
+export type ResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json_object';
+} | {
+    type: 'json_schema';
+    json_schema: {
+        name: string;
+        description?: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+};
+export interface CompletionSdk {
+    completion(params: {
+        modelId: string;
+        history: Message[];
+        stream: true;
+        tools?: SdkTool[] | undefined;
+        generationParams?: LlmGenerationParams | undefined;
+        responseFormat?: ResponseFormat | undefined;
+        toolDialect?: ToolDialect | undefined;
+        kvCache?: string | boolean;
+    }): CompletionSdkResult;
+    cancel?(params: {
+        requestId: string;
+    }): Promise<void>;
+}
+export interface RoundModelLease {
+    modelId: string;
+    sdk?: CompletionSdk;
+    release: () => void;
+}

package/dist-lib/lib/capabilities/types.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/completion-lifecycle.d.ts

@@ -0,0 +1,14 @@
+import { type AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { CompletionEvent } from './capabilities/completion.ts';
+export interface CompletionRun {
+    abort: () => void;
+    close: () => Promise<void>;
+    readonly started: boolean;
+}
+type CompletionIterator = AsyncGenerator<CompletionEvent, unknown, unknown>;
+export declare function trackCompletion(createSource: (signal: BareAbortSignal) => CompletionIterator, signal: BareAbortSignal | undefined, onFinish: (run: CompletionRun) => void): TrackedCompletionResult;
+interface TrackedCompletionResult {
+    iterator: CompletionIterator;
+    run: CompletionRun;
+}
+export {};

package/dist-lib/lib/completion-lifecycle.js

@@ -0,0 +1,126 @@
+import { AbortController } from 'bare-abort-controller';
+import { raceDrain } from './machine/index.js';
+export function trackCompletion(createSource, signal, onFinish) {
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted) {
+            controller.abort(undefined);
+        }
+    };
+    const onAbort = () => abort();
+    if (signal?.aborted) {
+        abort();
+    }
+    else {
+        signal?.addEventListener('abort', onAbort);
+    }
+    let started = false;
+    const source = createSource(controller.signal);
+    let settled = false;
+    let run;
+    const finish = () => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        signal?.removeEventListener('abort', onAbort);
+        onFinish(run);
+    };
+    const iterator = new TrackedCompletionIterator({
+        source,
+        start: () => {
+            started = true;
+        },
+        finish,
+        abort
+    });
+    run = {
+        abort,
+        get started() {
+            return started;
+        },
+        close: async () => {
+            abort();
+            await raceDrain(iterator.return());
+        }
+    };
+    return { iterator, run };
+}
+class TrackedCompletionIterator {
+    _source;
+    _start;
+    _finish;
+    _abort;
+    _started = false;
+    _closed = false;
+    _returnResult = null;
+    constructor({ source, start, finish, abort }) {
+        this._source = source;
+        this._start = start;
+        this._finish = finish;
+        this._abort = abort;
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    [Symbol.asyncDispose]() {
+        return this.return().then(() => { });
+    }
+    next(value) {
+        if (this._closed) {
+            return Promise.resolve({ done: true, value: undefined });
+        }
+        this._started = true;
+        this._start();
+        return this._source.next(value).then((result) => {
+            if (result.done) {
+                this._closed = true;
+                this._finish();
+            }
+            return result;
+        }, (error) => {
+            this._closed = true;
+            this._finish();
+            throw error;
+        });
+    }
+    return(value) {
+        if (this._returnResult) {
+            return this._returnResult;
+        }
+        this._closed = true;
+        this._abort();
+        if (!this._started) {
+            this._finish();
+            this._returnResult = Promise.resolve({ done: true, value });
+            return this._returnResult;
+        }
+        this._returnResult = this._source.return(value).then((result) => {
+            this._finish();
+            return result;
+        }, (error) => {
+            this._finish();
+            throw error;
+        });
+        return this._returnResult;
+    }
+    throw(error) {
+        if (this._closed) {
+            return Promise.reject(error);
+        }
+        this._abort();
+        this._started = true;
+        this._start();
+        return this._source.throw(error).then((result) => {
+            if (result.done) {
+                this._closed = true;
+                this._finish();
+            }
+            return result;
+        }, (reason) => {
+            this._closed = true;
+            this._finish();
+            throw reason;
+        });
+    }
+}