recker 1.0.5 → 1.0.6

package/dist/ai/providers/openai.js

@@ -0,0 +1,298 @@
+import { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError, } from './base.js';
+export class OpenAIProvider extends BaseAIProvider {
+    openaiConfig;
+    constructor(config = {}) {
+        super({ ...config, name: 'openai' });
+        this.openaiConfig = config;
+    }
+    getEnvApiKey() {
+        return process.env.OPENAI_API_KEY;
+    }
+    getBaseUrl() {
+        return this.config.baseUrl || 'https://api.openai.com/v1';
+    }
+    buildHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${this.getApiKey()}`,
+            ...this.config.headers,
+        };
+        if (this.openaiConfig.organization) {
+            headers['OpenAI-Organization'] = this.openaiConfig.organization;
+        }
+        return headers;
+    }
+    transformMessages(messages) {
+        return messages.map((msg) => {
+            const openaiMsg = {
+                role: msg.role,
+                content: this.transformContent(msg.content),
+            };
+            if (msg.name)
+                openaiMsg.name = msg.name;
+            if (msg.tool_call_id)
+                openaiMsg.tool_call_id = msg.tool_call_id;
+            if (msg.tool_calls)
+                openaiMsg.tool_calls = msg.tool_calls;
+            return openaiMsg;
+        });
+    }
+    transformContent(content) {
+        if (typeof content === 'string')
+            return content;
+        if (!content)
+            return null;
+        return content.map((part) => {
+            if (part.type === 'text') {
+                return { type: 'text', text: part.text };
+            }
+            if (part.type === 'image_url') {
+                return {
+                    type: 'image_url',
+                    image_url: {
+                        url: part.image_url.url,
+                        detail: part.image_url.detail,
+                    },
+                };
+            }
+            if (part.type === 'image') {
+                const base64 = Buffer.from(part.data).toString('base64');
+                return {
+                    type: 'image_url',
+                    image_url: {
+                        url: `data:${part.mediaType};base64,${base64}`,
+                    },
+                };
+            }
+            return { type: 'text', text: '' };
+        });
+    }
+    transformTools(tools) {
+        if (!tools)
+            return undefined;
+        return tools.map((tool) => ({
+            type: tool.type,
+            function: tool.function,
+        }));
+    }
+    async chat(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const messages = this.prepareMessages(options);
+        const body = this.buildChatBody(options, messages, false);
+        const response = await this.makeRequest('/chat/completions', body, options.signal);
+        const data = await response.json();
+        return this.parseResponse(data, context);
+    }
+    async stream(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const messages = this.prepareMessages(options);
+        const body = this.buildChatBody(options, messages, true);
+        const response = await this.makeRequest('/chat/completions', body, options.signal);
+        return this.parseSSEStream(response, context);
+    }
+    async embed(options) {
+        const startTime = performance.now();
+        const body = {
+            model: options.model || this.config.defaultModel || 'text-embedding-3-large',
+            input: options.input,
+            ...(options.dimensions && { dimensions: options.dimensions }),
+        };
+        const response = await this.makeRequest('/embeddings', body, options.signal);
+        const data = await response.json();
+        const latency = {
+            ttft: performance.now() - startTime,
+            tps: 0,
+            total: performance.now() - startTime,
+        };
+        return {
+            embeddings: data.data.map((d) => d.embedding),
+            usage: {
+                inputTokens: data.usage.prompt_tokens,
+                outputTokens: 0,
+                totalTokens: data.usage.total_tokens,
+            },
+            model: data.model,
+            provider: 'openai',
+            latency,
+        };
+    }
+    prepareMessages(options) {
+        const messages = [...options.messages];
+        if (options.systemPrompt) {
+            messages.unshift({
+                role: 'system',
+                content: options.systemPrompt,
+            });
+        }
+        return messages;
+    }
+    buildChatBody(options, messages, stream) {
+        const body = {
+            model: options.model || this.config.defaultModel || 'gpt-5.1',
+            messages: this.transformMessages(messages),
+            stream,
+        };
+        if (options.temperature !== undefined)
+            body.temperature = options.temperature;
+        if (options.topP !== undefined)
+            body.top_p = options.topP;
+        if (options.maxTokens !== undefined)
+            body.max_tokens = options.maxTokens;
+        if (options.stop)
+            body.stop = options.stop;
+        if (options.tools)
+            body.tools = this.transformTools(options.tools);
+        if (options.toolChoice)
+            body.tool_choice = options.toolChoice;
+        if (options.responseFormat) {
+            if (options.responseFormat.type === 'json_object') {
+                body.response_format = { type: 'json_object' };
+            }
+            else if (options.responseFormat.type === 'json_schema') {
+                body.response_format = {
+                    type: 'json_schema',
+                    json_schema: options.responseFormat.schema,
+                };
+            }
+        }
+        if (stream) {
+            body.stream_options = { include_usage: true };
+        }
+        return body;
+    }
+    async makeRequest(endpoint, body, signal) {
+        const url = `${this.getBaseUrl()}${endpoint}`;
+        const headers = this.buildHeaders();
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok) {
+            await this.handleError(response);
+        }
+        return response;
+    }
+    async handleError(response) {
+        let errorData = {};
+        try {
+            errorData = await response.json();
+        }
+        catch {
+        }
+        const message = errorData.error?.message || response.statusText;
+        const code = errorData.error?.code || errorData.error?.type;
+        switch (response.status) {
+            case 401:
+                throw new AuthenticationError('openai');
+            case 429:
+                const retryAfter = parseInt(response.headers.get('retry-after') || '0', 10);
+                throw new RateLimitError('openai', retryAfter || undefined);
+            case 400:
+                if (code === 'context_length_exceeded' || message.includes('maximum context length')) {
+                    throw new ContextLengthError('openai');
+                }
+                break;
+            case 503:
+            case 529:
+                throw new OverloadedError('openai');
+        }
+        throw new AIError(message, 'openai', code, response.status, response.status >= 500);
+    }
+    parseResponse(data, context) {
+        const choice = data.choices[0];
+        const message = choice?.message;
+        const content = typeof message?.content === 'string' ? message.content : '';
+        const toolCalls = message?.tool_calls ? this.parseToolCalls(message.tool_calls) : undefined;
+        const usage = data.usage
+            ? {
+                inputTokens: data.usage.prompt_tokens,
+                outputTokens: data.usage.completion_tokens,
+                totalTokens: data.usage.total_tokens,
+            }
+            : this.emptyUsage();
+        context.tokenCount = usage.outputTokens;
+        return {
+            content,
+            usage,
+            latency: this.calculateLatency(context),
+            model: data.model,
+            provider: 'openai',
+            cached: false,
+            finishReason: choice?.finish_reason,
+            toolCalls,
+            raw: data,
+        };
+    }
+    parseStreamEvent(chunk, context) {
+        const data = JSON.parse(chunk);
+        const choice = data.choices?.[0];
+        if (!choice) {
+            if (data.usage) {
+                return {
+                    type: 'usage',
+                    usage: {
+                        inputTokens: data.usage.prompt_tokens,
+                        outputTokens: data.usage.completion_tokens,
+                        totalTokens: data.usage.total_tokens,
+                    },
+                };
+            }
+            return null;
+        }
+        const delta = choice.delta;
+        if (delta.content) {
+            context.tokenCount++;
+            return {
+                type: 'text',
+                content: delta.content,
+            };
+        }
+        if (delta.tool_calls?.length) {
+            const tc = delta.tool_calls[0];
+            if (tc.id) {
+                return {
+                    type: 'tool_call',
+                    toolCall: {
+                        id: tc.id,
+                        type: 'function',
+                        function: {
+                            name: tc.function?.name || '',
+                            arguments: tc.function?.arguments || '',
+                        },
+                    },
+                };
+            }
+            else if (tc.function?.arguments) {
+                return {
+                    type: 'tool_call_delta',
+                    index: tc.index,
+                    delta: {
+                        arguments: tc.function.arguments,
+                    },
+                };
+            }
+        }
+        if (choice.finish_reason) {
+            return {
+                type: 'done',
+                finishReason: choice.finish_reason,
+                usage: data.usage
+                    ? {
+                        inputTokens: data.usage.prompt_tokens,
+                        outputTokens: data.usage.completion_tokens,
+                        totalTokens: data.usage.total_tokens,
+                    }
+                    : undefined,
+            };
+        }
+        return null;
+    }
+}

package/dist/ai/rate-limiter.d.ts

@@ -0,0 +1,44 @@
+import type { TokenRateLimitConfig, ChatOptions } from '../types/ai.js';
+export declare class TokenRateLimiter {
+    private config;
+    private state;
+    private queue;
+    private processing;
+    private nextId;
+    constructor(config?: TokenRateLimitConfig);
+    execute<T>(fn: () => Promise<T>, options?: {
+        estimatedTokens?: number;
+        priority?: 'high' | 'normal' | 'low';
+    }): Promise<T>;
+    executeChat<T>(options: ChatOptions, fn: () => Promise<T>): Promise<T>;
+    recordUsage(actualTokens: number, estimatedTokens: number): void;
+    getUsage(): {
+        tokensUsed: number;
+        tokensRemaining: number;
+        requestsUsed: number;
+        requestsRemaining: number;
+        resetIn: number;
+        queueLength: number;
+    };
+    clearQueue(): void;
+    reset(): void;
+    private canExecute;
+    private executeNow;
+    private enqueue;
+    private processQueue;
+    private maybeResetWindow;
+    private getResetTime;
+    private getRetryAfter;
+    private sleep;
+}
+export declare class RateLimitExceededError extends Error {
+    readonly retryAfter: number;
+    constructor(retryAfter: number);
+}
+export declare const PROVIDER_RATE_LIMITS: Record<string, Partial<TokenRateLimitConfig>>;
+export declare function createRateLimiter(providerTier?: string, overrides?: Partial<TokenRateLimitConfig>): TokenRateLimiter;
+export declare const tokenEstimators: {
+    estimateMessage(content: string): number;
+    estimateChatTokens(options: ChatOptions): number;
+};
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/ai/rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../src/ai/rate-limiter.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAyFxE,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,MAAM,CAAa;gBAEf,MAAM,GAAE,oBAAyB;IAYvC,OAAO,CAAC,CAAC,EACb,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAA;KAAE,GAC3E,OAAO,CAAC,CAAC,CAAC;IA4BP,WAAW,CAAC,CAAC,EACjB,OAAO,EAAE,WAAW,EACpB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC;IAUb,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI;IAchE,QAAQ,IAAI;QACV,UAAU,EAAE,MAAM,CAAC;QACnB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;KACrB;IAeD,UAAU,IAAI,IAAI;IAUlB,KAAK,IAAI,IAAI;IAYb,OAAO,CAAC,UAAU;YAYJ,UAAU;IAUxB,OAAO,CAAC,OAAO;YAmCD,YAAY;IAkC1B,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,KAAK;CAGd;AAKD,qBAAa,sBAAuB,SAAQ,KAAK;aACnB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAKD,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAa9E,CAAC;AAKF,wBAAgB,iBAAiB,CAC/B,YAAY,CAAC,EAAE,MAAM,EACrB,SAAS,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,GACxC,gBAAgB,CAGlB;AAKD,eAAO,MAAM,eAAe;6BA/UD,MAAM,GAAG,MAAM;gCAQZ,WAAW,GAAG,MAAM;CAuUH,CAAC"}

package/dist/ai/rate-limiter.js

@@ -0,0 +1,212 @@
+const DEFAULT_LIMITS = {
+    tokensPerMinute: 90000,
+    requestsPerMinute: 500,
+    strategy: 'queue',
+    priority: () => 'normal',
+};
+const TOKEN_ESTIMATORS = {
+    estimateMessage(content) {
+        if (!content)
+            return 0;
+        return Math.ceil(content.length / 4);
+    },
+    estimateChatTokens(options) {
+        let tokens = 0;
+        for (const msg of options.messages) {
+            if (typeof msg.content === 'string') {
+                tokens += this.estimateMessage(msg.content);
+            }
+            else if (Array.isArray(msg.content)) {
+                for (const part of msg.content) {
+                    if (part.type === 'text') {
+                        tokens += this.estimateMessage(part.text);
+                    }
+                    else if (part.type === 'image' || part.type === 'image_url') {
+                        tokens += 1000;
+                    }
+                }
+            }
+        }
+        if (options.systemPrompt) {
+            tokens += this.estimateMessage(options.systemPrompt);
+        }
+        tokens += options.maxTokens || 1000;
+        if (options.tools?.length) {
+            tokens += options.tools.length * 100;
+        }
+        return tokens;
+    },
+};
+export class TokenRateLimiter {
+    config;
+    state;
+    queue = [];
+    processing = false;
+    nextId = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_LIMITS, ...config };
+        this.state = {
+            tokenCount: 0,
+            requestCount: 0,
+            windowStart: Date.now(),
+        };
+    }
+    async execute(fn, options) {
+        const estimatedTokens = options?.estimatedTokens || 1000;
+        const priority = options?.priority || 'normal';
+        if (this.canExecute(estimatedTokens)) {
+            return this.executeNow(fn, estimatedTokens);
+        }
+        switch (this.config.strategy) {
+            case 'throw':
+                throw new RateLimitExceededError(this.getRetryAfter());
+            case 'retry-after':
+                const retryAfter = this.getRetryAfter();
+                await this.sleep(retryAfter);
+                return this.execute(fn, options);
+            case 'queue':
+            default:
+                return this.enqueue(fn, estimatedTokens, priority);
+        }
+    }
+    async executeChat(options, fn) {
+        const estimatedTokens = TOKEN_ESTIMATORS.estimateChatTokens(options);
+        const priority = this.config.priority(options);
+        return this.execute(fn, { estimatedTokens, priority });
+    }
+    recordUsage(actualTokens, estimatedTokens) {
+        const diff = actualTokens - estimatedTokens;
+        this.state.tokenCount += diff;
+        if (this.state.tokenCount < 0) {
+            this.state.tokenCount = 0;
+        }
+    }
+    getUsage() {
+        this.maybeResetWindow();
+        return {
+            tokensUsed: this.state.tokenCount,
+            tokensRemaining: Math.max(0, this.config.tokensPerMinute - this.state.tokenCount),
+            requestsUsed: this.state.requestCount,
+            requestsRemaining: Math.max(0, this.config.requestsPerMinute - this.state.requestCount),
+            resetIn: this.getResetTime(),
+            queueLength: this.queue.length,
+        };
+    }
+    clearQueue() {
+        for (const req of this.queue) {
+            req.reject(new Error('Queue cleared'));
+        }
+        this.queue = [];
+    }
+    reset() {
+        this.state = {
+            tokenCount: 0,
+            requestCount: 0,
+            windowStart: Date.now(),
+        };
+        this.clearQueue();
+    }
+    canExecute(estimatedTokens) {
+        this.maybeResetWindow();
+        const hasTokenBudget = this.state.tokenCount + estimatedTokens <= this.config.tokensPerMinute;
+        const hasRequestBudget = this.state.requestCount + 1 <= this.config.requestsPerMinute;
+        return hasTokenBudget && hasRequestBudget;
+    }
+    async executeNow(fn, estimatedTokens) {
+        this.state.tokenCount += estimatedTokens;
+        this.state.requestCount++;
+        return fn();
+    }
+    enqueue(fn, estimatedTokens, priority) {
+        return new Promise((resolve, reject) => {
+            const request = {
+                id: `req-${this.nextId++}`,
+                priority,
+                estimatedTokens,
+                execute: fn,
+                resolve,
+                reject,
+                enqueueTime: Date.now(),
+            };
+            let insertIndex = this.queue.length;
+            const priorityOrder = { high: 0, normal: 1, low: 2 };
+            for (let i = 0; i < this.queue.length; i++) {
+                if (priorityOrder[priority] < priorityOrder[this.queue[i].priority]) {
+                    insertIndex = i;
+                    break;
+                }
+            }
+            this.queue.splice(insertIndex, 0, request);
+            this.processQueue();
+        });
+    }
+    async processQueue() {
+        if (this.processing)
+            return;
+        this.processing = true;
+        try {
+            while (this.queue.length > 0) {
+                const next = this.queue[0];
+                while (!this.canExecute(next.estimatedTokens)) {
+                    const waitTime = this.getRetryAfter();
+                    await this.sleep(Math.min(waitTime, 1000));
+                    this.maybeResetWindow();
+                }
+                this.queue.shift();
+                try {
+                    const result = await this.executeNow(next.execute, next.estimatedTokens);
+                    next.resolve(result);
+                }
+                catch (error) {
+                    next.reject(error);
+                }
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    maybeResetWindow() {
+        const now = Date.now();
+        const windowDuration = 60000;
+        if (now - this.state.windowStart >= windowDuration) {
+            this.state.tokenCount = 0;
+            this.state.requestCount = 0;
+            this.state.windowStart = now;
+        }
+    }
+    getResetTime() {
+        const windowDuration = 60000;
+        return Math.max(0, windowDuration - (Date.now() - this.state.windowStart));
+    }
+    getRetryAfter() {
+        return this.getResetTime();
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+export class RateLimitExceededError extends Error {
+    retryAfter;
+    constructor(retryAfter) {
+        super(`Rate limit exceeded. Retry after ${retryAfter}ms`);
+        this.retryAfter = retryAfter;
+        this.name = 'RateLimitExceededError';
+    }
+}
+export const PROVIDER_RATE_LIMITS = {
+    'openai-tier1': { tokensPerMinute: 200000, requestsPerMinute: 500 },
+    'openai-tier2': { tokensPerMinute: 450000, requestsPerMinute: 5000 },
+    'openai-tier3': { tokensPerMinute: 600000, requestsPerMinute: 5000 },
+    'openai-tier4': { tokensPerMinute: 800000, requestsPerMinute: 10000 },
+    'openai-tier5': { tokensPerMinute: 10000000, requestsPerMinute: 10000 },
+    'anthropic-tier1': { tokensPerMinute: 80000, requestsPerMinute: 50 },
+    'anthropic-tier2': { tokensPerMinute: 160000, requestsPerMinute: 1000 },
+    'anthropic-tier3': { tokensPerMinute: 400000, requestsPerMinute: 2000 },
+    'anthropic-tier4': { tokensPerMinute: 800000, requestsPerMinute: 4000 },
+};
+export function createRateLimiter(providerTier, overrides) {
+    const baseConfig = providerTier ? PROVIDER_RATE_LIMITS[providerTier] || {} : {};
+    return new TokenRateLimiter({ ...baseConfig, ...overrides });
+}
+export const tokenEstimators = TOKEN_ESTIMATORS;

package/dist/bench/generator.d.ts

@@ -0,0 +1,19 @@
+import { LoadStats } from './stats.js';
+export type LoadMode = 'throughput' | 'stress' | 'realistic';
+export interface LoadConfig {
+    url: string;
+    users: number;
+    duration: number;
+    mode: LoadMode;
+    http2?: boolean;
+    rampUp?: number;
+}
+export declare class LoadGenerator {
+    private config;
+    stats: LoadStats;
+    private running;
+    constructor(config: LoadConfig);
+    start(): Promise<void[]>;
+    stop(): void;
+}
+//# sourceMappingURL=generator.d.ts.map

package/dist/bench/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/bench/generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE7D,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAa;IACpB,KAAK,EAAE,SAAS,CAAC;IACxB,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,EAAE,UAAU;IAKxB,KAAK;IA4FX,IAAI;CAGL"}

package/dist/bench/generator.js

@@ -0,0 +1,86 @@
+import { createClient } from '../core/client.js';
+import { LoadStats } from './stats.js';
+export class LoadGenerator {
+    config;
+    stats;
+    running = false;
+    constructor(config) {
+        this.config = config;
+        this.stats = new LoadStats();
+    }
+    async start() {
+        this.running = true;
+        const startTime = Date.now();
+        const client = createClient({
+            baseUrl: new URL(this.config.url).origin,
+            observability: false,
+            http2: this.config.http2,
+            concurrency: {
+                max: this.config.users * 2,
+                requestsPerInterval: Infinity,
+                interval: 1000,
+                agent: {
+                    connections: this.config.users,
+                    pipelining: this.config.mode === 'throughput' ? 2 : 1,
+                    keepAlive: false
+                }
+            },
+            retry: {
+                maxAttempts: this.config.mode === 'stress' ? 0 : 2
+            },
+            timeout: 5000
+        });
+        const path = new URL(this.config.url).pathname;
+        const userLoop = async () => {
+            this.stats.activeUsers++;
+            while (this.running) {
+                const start = performance.now();
+                const controller = new AbortController();
+                try {
+                    if (this.config.mode === 'realistic') {
+                        await new Promise(r => setTimeout(r, 50 + Math.random() * 450));
+                    }
+                    const res = await client.get(path, { signal: controller.signal });
+                    const duration = performance.now() - start;
+                    const bytes = Number(res.headers.get('content-length') || 0);
+                    this.stats.addResult(duration, res.status, bytes);
+                }
+                catch (err) {
+                    if (err.name === 'AbortError' || err.code === 'UND_ERR_ABORTED') {
+                        this.stats.addResult(performance.now() - start, 0, 0, new Error('Request Aborted (timeout)'));
+                    }
+                    else {
+                        this.stats.addResult(performance.now() - start, 0, 0, err);
+                    }
+                }
+                finally {
+                    controller.abort();
+                }
+                if (this.config.mode === 'stress') {
+                    await new Promise(r => setImmediate(r));
+                }
+            }
+            this.stats.activeUsers--;
+        };
+        const users = [];
+        const rampUpMs = (this.config.rampUp || 0) * 1000;
+        for (let i = 0; i < this.config.users; i++) {
+            const delay = rampUpMs > 0 ? (i / this.config.users) * rampUpMs : 0;
+            const userSession = async () => {
+                if (delay > 0)
+                    await new Promise(r => setTimeout(r, delay));
+                if (!this.running)
+                    return;
+                await userLoop();
+            };
+            users.push(userSession());
+        }
+        setTimeout(() => {
+            this.running = false;
+        }, this.config.duration * 1000);
+        return Promise.all(users);
+    }
+    stop() {
+        this.running = false;
+    }
+}