@qianxude/tem 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qianxude/tem",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A lightweight task execution engine for IO-bound workloads with SQLite persistence, retry, and rate limiting",
   "module": "src/index.ts",
   "type": "module",
@@ -29,6 +29,7 @@
     "test:auto-detect": "bun test tests/integration/auto-detect.test.ts",
     "lint": "oxlint",
     "lint:file": "oxlint",
+    "example:llm-detect": "bun examples/llm-detect.ts",
     "dev": "bun --watch src/index.ts",
     "cli": "bun ./src/cli/index.ts",
     "publish:pkg": "bun publish --access public",

package/src/core/tem.ts

@@ -1,5 +1,5 @@
 import { Database, type DatabaseOptions } from '../database/index.js';
-import { BatchService, TaskService } from '../services/index.js';
+import { BatchService, TaskService, BatchInterruptionService } from '../services/index.js';
 import { Worker, type WorkerConfig } from './worker.js';
 import {
   detectConstraints,
@@ -27,12 +27,16 @@ export interface TEMConfig {
 
   // Polling
   pollIntervalMs: number;
+
+  // Optional: Specific batch ID to process (if set, only processes this batch)
+  batchId?: string;
 }
 
 export class TEM {
   readonly batch: BatchService;
   readonly task: TaskService;
   readonly worker: Worker;
+  readonly interruption: BatchInterruptionService;
 
   private database: Database;
 
@@ -70,6 +74,7 @@ export class TEM {
   }
 
   constructor(config: TEMConfig) {
+
     // Initialize database
     const dbOptions: DatabaseOptions = {
       path: config.databasePath,
@@ -79,12 +84,15 @@ export class TEM {
     // Initialize services
     this.batch = new BatchService(this.database);
     this.task = new TaskService(this.database);
+    this.interruption = new BatchInterruptionService(this.database, this.batch);
 
     // Initialize worker with config
     const workerConfig: WorkerConfig = {
       concurrency: config.concurrency,
       pollIntervalMs: config.pollIntervalMs,
       rateLimit: config.rateLimit,
+      batchId: config.batchId,
+      interruptionService: this.interruption,
     };
     this.worker = new Worker(this.task, workerConfig);
   }
@@ -97,4 +105,24 @@ export class TEM {
     await this.worker.stop();
     this.database.close();
   }
+
+  /**
+   * Manually interrupt a batch with a specified reason.
+   * This will stop the worker if processing this batch and prevent further tasks from being claimed.
+   *
+   * @param batchId - The ID of the batch to interrupt
+   * @param reason - The reason for interruption (default: 'manual')
+   * @param message - Optional custom message explaining the interruption
+   */
+  async interruptBatch(
+    batchId: string,
+    reason?: import('../interfaces/index.js').BatchInterruptionReason,
+    message?: string
+  ): Promise<void> {
+    await this.interruption.interrupt(
+      batchId,
+      reason ?? 'manual',
+      message ?? 'Batch manually interrupted'
+    );
+  }
 }

package/src/core/worker.ts

@@ -1,5 +1,5 @@
 import * as i from '../interfaces/index.js';
-import { TaskService } from '../services/task.js';
+import { TaskService, BatchInterruptionService } from '../services/index.js';
 import { ConcurrencyController, RateLimiter, type RateLimitConfig } from '../utils/index.js';
 
 /**
@@ -18,6 +18,10 @@ export interface WorkerConfig {
   concurrency: number;
   pollIntervalMs: number;
   rateLimit?: RateLimitConfig;
+  /** Specific batch ID to process (optional - if set, only processes this batch) */
+  batchId?: string;
+  /** Interruption service for checking batch status */
+  interruptionService?: BatchInterruptionService;
 }
 
 export class Worker {
@@ -28,6 +32,13 @@ export class Worker {
   private pollIntervalMs: number;
   private abortController: AbortController;
   private inFlightTasks: Set<Promise<void>> = new Set();
+  private batchId?: string;
+  private interruptionService?: BatchInterruptionService;
+
+  // Track failure context for interruption decisions
+  private consecutiveFailures = 0;
+  private rateLimitHits = 0;
+  private concurrencyErrors = 0;
 
   constructor(
     private taskService: TaskService,
@@ -36,6 +47,8 @@ export class Worker {
     this.concurrency = new ConcurrencyController(config.concurrency);
     this.pollIntervalMs = config.pollIntervalMs;
     this.abortController = new AbortController();
+    this.batchId = config.batchId;
+    this.interruptionService = config.interruptionService;
 
     if (config.rateLimit) {
       this.rateLimiter = new RateLimiter(config.rateLimit);
@@ -93,8 +106,18 @@ export class Worker {
           break;
         }
 
+        // For batch-specific workers: check batch is still active
+        if (this.batchId && this.interruptionService) {
+          const isActive = await this.interruptionService.isBatchActive(this.batchId);
+          if (!isActive) {
+            this.concurrency.release();
+            this.stop();
+            break;
+          }
+        }
+
         // Claim a task while holding the concurrency slot
-        const task = await this.taskService.claim();
+        const task = await this.taskService.claim(this.batchId);
 
         if (!task) {
           // No task available, release the slot and sleep
@@ -123,6 +146,8 @@ export class Worker {
    * Note: Assumes concurrency slot has already been acquired.
    */
   private async execute(task: i.Task): Promise<void> {
+    const taskStartTime = Date.now();
+
     try {
       if (this.rateLimiter) {
         await this.rateLimiter.acquire();
@@ -134,6 +159,8 @@ export class Worker {
       }
 
       const payload = JSON.parse(task.payload);
+
+      // Build context with optional deadline
       const context: i.TaskContext = {
         taskId: task.id,
         batchId: task.batchId,
@@ -141,10 +168,22 @@ export class Worker {
         signal: this.abortController.signal,
       };
 
+      // If we have interruption service and batchId, set deadline from criteria
+      if (this.interruptionService && task.batchId) {
+        const { criteria } = await this.interruptionService['batchService'].getWithCriteria(task.batchId);
+        if (criteria?.taskTimeoutMs) {
+          context.deadline = new Date(taskStartTime + criteria.taskTimeoutMs);
+        }
+      }
+
       const result = await handler(payload, context);
       await this.taskService.complete(task.id, result);
+
+      // Reset consecutive failures on success
+      this.consecutiveFailures = 0;
     } catch (error) {
-      await this.handleError(task, error);
+      const taskRuntimeMs = Date.now() - taskStartTime;
+      await this.handleError(task, error, taskRuntimeMs);
     } finally {
       this.concurrency.release();
     }
@@ -153,16 +192,49 @@ export class Worker {
   /**
    * Handle task execution errors.
    */
-  private async handleError(task: i.Task, error: unknown): Promise<void> {
+  private async handleError(task: i.Task, error: unknown, taskRuntimeMs?: number): Promise<void> {
     const isRetryable = !(error instanceof NonRetryableError);
     const shouldRetry = isRetryable && task.attempt < task.maxAttempt;
 
+    // Track failure type for interruption decisions
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (this.isRateLimitError(errorMessage)) {
+      this.rateLimitHits++;
+    } else if (this.isConcurrencyError(errorMessage)) {
+      this.concurrencyErrors++;
+    }
+
     if (shouldRetry) {
       // Reset to pending for automatic retry (attempt already incremented by claim)
       await this.taskService.retry(task.id);
+      this.consecutiveFailures++;
     } else {
-      const message = error instanceof Error ? error.message : String(error);
-      await this.taskService.fail(task.id, message);
+      await this.taskService.fail(task.id, errorMessage);
+      this.consecutiveFailures++;
+
+      // Check if batch should be interrupted
+      if (task.batchId && this.interruptionService) {
+        const interrupted = await this.interruptionService.checkAndInterruptIfNeeded(
+          task.batchId,
+          {
+            consecutiveFailures: this.consecutiveFailures,
+            rateLimitHits: this.rateLimitHits,
+            concurrencyErrors: this.concurrencyErrors,
+            currentTaskRuntimeMs: taskRuntimeMs,
+          }
+        );
+        if (interrupted) {
+          this.stop();
+        }
+      }
     }
   }
+
+  private isRateLimitError(message: string): boolean {
+    return message.includes('429') || message.toLowerCase().includes('rate limit');
+  }
+
+  private isConcurrencyError(message: string): boolean {
+    return message.includes('502') || message.includes('503') || message.toLowerCase().includes('bad gateway') || message.toLowerCase().includes('service unavailable');
+  }
 }

package/src/database/index.ts

@@ -33,13 +33,20 @@ export class Database implements i.DatabaseConnection {
       )
     `);
 
-    // Check if initial schema needs to be applied
-    const migrationCount = this.db
-      .query('SELECT COUNT(*) as count FROM _migration WHERE name = $name')
-      .get({ $name: '001_initial_schema' }) as { count: number };
-
-    if (migrationCount.count === 0) {
-      this.applyInitialSchema();
+    // Check and apply migrations in order
+    const migrations = [
+      { name: '001_initial_schema', apply: () => this.applyInitialSchema() },
+      { name: '002_batch_interruption', apply: () => this.applyBatchInterruptionMigration() },
+    ];
+
+    for (const migration of migrations) {
+      const migrationCount = this.db
+        .query('SELECT COUNT(*) as count FROM _migration WHERE name = $name')
+        .get({ $name: migration.name }) as { count: number };
+
+      if (migrationCount.count === 0) {
+        migration.apply();
+      }
     }
   }
 
@@ -90,6 +97,39 @@ export class Database implements i.DatabaseConnection {
     });
   }
 
+  private applyBatchInterruptionMigration(): void {
+    const migration = `
+      -- Add status to batch table
+      ALTER TABLE batch ADD COLUMN status TEXT NOT NULL DEFAULT 'active'
+        CHECK(status IN ('active', 'interrupted', 'completed'));
+
+      -- Add interruption criteria storage (JSON)
+      ALTER TABLE batch ADD COLUMN interruption_criteria TEXT;
+
+      -- Index for quickly finding active batches
+      CREATE INDEX IF NOT EXISTS idx_batch_status ON batch(status);
+
+      -- New table: interruption log
+      CREATE TABLE IF NOT EXISTS batch_interrupt_log (
+        id TEXT PRIMARY KEY,
+        batch_id TEXT NOT NULL REFERENCES batch(id) ON DELETE CASCADE,
+        reason TEXT NOT NULL,
+        message TEXT NOT NULL,
+        stats_snapshot TEXT NOT NULL, -- JSON of BatchStats
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_interrupt_log_batch_id ON batch_interrupt_log(batch_id);
+    `;
+
+    this.transaction(() => {
+      this.db.exec(migration);
+      this.db
+        .query('INSERT INTO _migration (name) VALUES ($name)')
+        .run({ $name: '002_batch_interruption' });
+    });
+  }
+
   query<T = unknown>(sql: string, params?: SQLQueryBindings[]): T[] {
     const stmt = this.db.prepare(sql);
     const results = stmt.all(...(params ?? []));

package/src/index.ts

@@ -1,7 +1,7 @@
 // Main exports for TEM framework
 export * as interfaces from './interfaces/index.js';
 export { Database, type DatabaseOptions } from './database/index.js';
-export { BatchService, TaskService } from './services/index.js';
+export { BatchService, TaskService, BatchInterruptionService } from './services/index.js';
 export {
   ConcurrencyController,
   RateLimiter,

package/src/interfaces/index.ts

@@ -6,18 +6,48 @@
 // ============================================================================
 
 export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type BatchStatus = 'active' | 'interrupted' | 'completed';
+
+export type BatchInterruptionReason =
+  | 'error_rate_exceeded'
+  | 'failed_tasks_exceeded'
+  | 'consecutive_failures_exceeded'
+  | 'rate_limit_hits_exceeded'
+  | 'concurrency_errors_exceeded'
+  | 'task_timeout'
+  | 'batch_runtime_exceeded'
+  | 'manual';
 
 // ============================================================================
 // Entity Types
 // ============================================================================
 
+export interface BatchInterruptionCriteria {
+  /** Max error rate (0-1, e.g., 0.1 = 10%) */
+  maxErrorRate?: number;
+  /** Max absolute number of failed tasks */
+  maxFailedTasks?: number;
+  /** Max consecutive failures before interruption */
+  maxConsecutiveFailures?: number;
+  /** Max rate limit (429) hits before interruption */
+  maxRateLimitHits?: number;
+  /** Max concurrency errors (502/503) before interruption - indicates too aggressive concurrency */
+  maxConcurrencyErrors?: number;
+  /** Max runtime for a single task in ms */
+  taskTimeoutMs?: number;
+  /** Max total batch runtime in ms */
+  maxBatchRuntimeMs?: number;
+}
+
 export interface Batch {
   id: string;
   code: string;
   type: string;
+  status: BatchStatus;
   createdAt: Date;
   completedAt: Date | null;
   metadata: Record<string, unknown> | null;
+  interruptionCriteria: BatchInterruptionCriteria | null;
 }
 
 export interface BatchStats {
@@ -29,6 +59,14 @@ export interface BatchStats {
   failed: number;
 }
 
+export interface BatchInterruption {
+  batchId: string;
+  reason: BatchInterruptionReason;
+  message: string;
+  statsAtInterruption: BatchStats;
+  createdAt: Date;
+}
+
 export interface Task {
   id: string;
   batchId: string | null;
@@ -88,6 +126,8 @@ export interface DetectOptions {
   maxConcurrencyToTest?: number;
   /** Duration to run rate limit tests (default: 10000) */
   rateLimitTestDurationMs?: number;
+  /** Maximum number of requests to send during rate limit detection (default: 200) */
+  maxRateLimitTestRequests?: number;
 }
 
 export interface DetectedConfig {
@@ -118,6 +158,8 @@ export interface TaskContext {
   batchId: string | null;
   attempt: number;
   signal: AbortSignal;
+  /** Deadline for task execution (for timeout enforcement) */
+  deadline?: Date;
 }
 
 // ============================================================================
@@ -144,6 +186,7 @@ export interface CreateBatchInput {
   code: string;
   type: string;
   metadata?: Record<string, unknown>;
+  interruptionCriteria?: BatchInterruptionCriteria;
 }
 
 export interface CreateTaskInput {
@@ -162,6 +205,23 @@ export interface BatchService {
   complete(id: string): Promise<void>;
   resume(id: string): Promise<number>;
   retryFailed(id: string): Promise<number>;
+  updateStatus(id: string, status: BatchStatus): Promise<void>;
+  getWithCriteria(id: string): Promise<{ batch: Batch; criteria: BatchInterruptionCriteria | null }>;
+}
+
+export interface BatchInterruptionService {
+  checkAndInterruptIfNeeded(
+    batchId: string,
+    context: {
+      consecutiveFailures?: number;
+      rateLimitHits?: number;
+      concurrencyErrors?: number;
+      currentTaskRuntimeMs?: number;
+    }
+  ): Promise<boolean>;
+  interrupt(batchId: string, reason: BatchInterruptionReason, message: string): Promise<void>;
+  isBatchActive(batchId: string): Promise<boolean>;
+  getInterruptionLog(batchId: string): Promise<BatchInterruption[]>;
 }
 
 export interface TaskService {

package/src/services/batch-interruption.ts

@@ -0,0 +1,192 @@
+import * as i from '../interfaces/index.js';
+import type { Database } from '../database/index.js';
+import type { BatchService } from './batch.js';
+
+export interface BatchInterruptionRow {
+  batch_id: string;
+  reason: i.BatchInterruptionReason;
+  message: string;
+  stats_snapshot: string;
+  created_at: string;
+}
+
+export class BatchInterruptionService implements i.BatchInterruptionService {
+  constructor(
+    private db: Database,
+    private batchService: BatchService
+  ) {}
+
+  /**
+   * Check if batch should be interrupted based on current stats.
+   * Called after each task failure or periodically.
+   */
+  async checkAndInterruptIfNeeded(
+    batchId: string,
+    context: {
+      consecutiveFailures?: number;
+      rateLimitHits?: number;
+      concurrencyErrors?: number;
+      currentTaskRuntimeMs?: number;
+    }
+  ): Promise<boolean> {
+    // Fetch batch with its interruption criteria
+    const { batch, criteria } = await this.batchService.getWithCriteria(batchId);
+
+    // If already interrupted or completed, no need to check
+    if (batch.status !== 'active') {
+      return false;
+    }
+
+    // If no criteria set, never interrupt
+    if (!criteria) {
+      return false;
+    }
+
+    // Get current stats
+    const stats = await this.batchService.getStats(batchId);
+
+    // Check each criterion in order of severity
+
+    // 1. Check maxBatchRuntimeMs - total batch runtime
+    if (criteria.maxBatchRuntimeMs) {
+      const batchRuntimeMs = Date.now() - batch.createdAt.getTime();
+      if (batchRuntimeMs > criteria.maxBatchRuntimeMs) {
+        await this.interrupt(
+          batchId,
+          'batch_runtime_exceeded',
+          `Batch runtime (${batchRuntimeMs}ms) exceeded maximum (${criteria.maxBatchRuntimeMs}ms)`
+        );
+        return true;
+      }
+    }
+
+    // 2. Check taskTimeoutMs - single task runtime
+    if (criteria.taskTimeoutMs && context.currentTaskRuntimeMs) {
+      if (context.currentTaskRuntimeMs > criteria.taskTimeoutMs) {
+        await this.interrupt(
+          batchId,
+          'task_timeout',
+          `Task runtime (${context.currentTaskRuntimeMs}ms) exceeded maximum (${criteria.taskTimeoutMs}ms)`
+        );
+        return true;
+      }
+    }
+
+    // 3. Check maxConsecutiveFailures
+    if (criteria.maxConsecutiveFailures && context.consecutiveFailures) {
+      if (context.consecutiveFailures >= criteria.maxConsecutiveFailures) {
+        await this.interrupt(
+          batchId,
+          'consecutive_failures_exceeded',
+          `Consecutive failures (${context.consecutiveFailures}) exceeded maximum (${criteria.maxConsecutiveFailures})`
+        );
+        return true;
+      }
+    }
+
+    // 4. Check maxRateLimitHits
+    if (criteria.maxRateLimitHits && context.rateLimitHits) {
+      if (context.rateLimitHits >= criteria.maxRateLimitHits) {
+        await this.interrupt(
+          batchId,
+          'rate_limit_hits_exceeded',
+          `Rate limit hits (${context.rateLimitHits}) exceeded maximum (${criteria.maxRateLimitHits})`
+        );
+        return true;
+      }
+    }
+
+    // 5. Check maxConcurrencyErrors (502/503 errors)
+    if (criteria.maxConcurrencyErrors && context.concurrencyErrors) {
+      if (context.concurrencyErrors >= criteria.maxConcurrencyErrors) {
+        await this.interrupt(
+          batchId,
+          'concurrency_errors_exceeded',
+          `Concurrency errors (${context.concurrencyErrors}) exceeded maximum (${criteria.maxConcurrencyErrors})`
+        );
+        return true;
+      }
+    }
+
+    // 6. Check maxFailedTasks (absolute count)
+    if (criteria.maxFailedTasks) {
+      if (stats.failed >= criteria.maxFailedTasks) {
+        await this.interrupt(
+          batchId,
+          'failed_tasks_exceeded',
+          `Failed tasks (${stats.failed}) exceeded maximum (${criteria.maxFailedTasks})`
+        );
+        return true;
+      }
+    }
+
+    // 7. Check maxErrorRate (percentage)
+    if (criteria.maxErrorRate && stats.total > 0) {
+      const errorRate = stats.failed / stats.total;
+      if (errorRate > criteria.maxErrorRate) {
+        await this.interrupt(
+          batchId,
+          'error_rate_exceeded',
+          `Error rate (${(errorRate * 100).toFixed(1)}%) exceeded maximum (${(criteria.maxErrorRate * 100).toFixed(1)}%)`
+        );
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Interrupt a batch atomically.
+   */
+  async interrupt(
+    batchId: string,
+    reason: i.BatchInterruptionReason,
+    message: string
+  ): Promise<void> {
+    // Get current stats for the log
+    const stats = await this.batchService.getStats(batchId);
+
+    // Update batch status to 'interrupted'
+    await this.batchService.updateStatus(batchId, 'interrupted');
+
+    // Log the interruption event
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+
+    this.db.run(
+      `INSERT INTO batch_interrupt_log (id, batch_id, reason, message, stats_snapshot, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [id, batchId, reason, message, JSON.stringify(stats), now]
+    );
+  }
+
+  /**
+   * Check if a batch is active (can claim tasks from it).
+   */
+  async isBatchActive(batchId: string): Promise<boolean> {
+    const batch = await this.batchService.getById(batchId);
+    return batch?.status === 'active';
+  }
+
+  /**
+   * Get interruption history for a batch.
+   */
+  async getInterruptionLog(batchId: string): Promise<i.BatchInterruption[]> {
+    const rows = this.db.query<BatchInterruptionRow>(
+      `SELECT batch_id, reason, message, stats_snapshot, created_at
+       FROM batch_interrupt_log
+       WHERE batch_id = ?
+       ORDER BY created_at DESC`,
+      [batchId]
+    );
+
+    return rows.map((row) => ({
+      batchId: row.batch_id,
+      reason: row.reason,
+      message: row.message,
+      statsAtInterruption: JSON.parse(row.stats_snapshot) as i.BatchStats,
+      createdAt: new Date(row.created_at),
+    }));
+  }
+}

package/src/services/batch.ts

@@ -5,9 +5,11 @@ export interface BatchRow {
   id: string;
   code: string;
   type: string;
+  status: i.BatchStatus;
   created_at: string;
   completed_at: string | null;
   metadata: string | null;
+  interruption_criteria: string | null;
 }
 
 function rowToBatch(row: BatchRow): i.Batch {
@@ -15,9 +17,13 @@ function rowToBatch(row: BatchRow): i.Batch {
     id: row.id,
     code: row.code,
     type: row.type,
+    status: row.status ?? 'active',
     createdAt: new Date(row.created_at),
     completedAt: row.completed_at ? new Date(row.completed_at) : null,
     metadata: row.metadata ? (JSON.parse(row.metadata) as Record<string, unknown>) : null,
+    interruptionCriteria: row.interruption_criteria
+      ? (JSON.parse(row.interruption_criteria) as i.BatchInterruptionCriteria)
+      : null,
   };
 }
 
@@ -29,9 +35,16 @@ export class BatchService implements i.BatchService {
     const now = new Date().toISOString();
 
     this.db.run(
-      `INSERT INTO batch (id, code, type, created_at, metadata)
-       VALUES (?, ?, ?, ?, ?)`,
-      [id, input.code, input.type, now, input.metadata ? JSON.stringify(input.metadata) : null]
+      `INSERT INTO batch (id, code, type, created_at, metadata, interruption_criteria)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        input.code,
+        input.type,
+        now,
+        input.metadata ? JSON.stringify(input.metadata) : null,
+        input.interruptionCriteria ? JSON.stringify(input.interruptionCriteria) : null,
+      ]
     );
 
     const rows = this.db.query<BatchRow>('SELECT * FROM batch WHERE id = ?', [id]);
@@ -60,7 +73,7 @@ export class BatchService implements i.BatchService {
   async complete(id: string): Promise<void> {
     const now = new Date().toISOString();
     this.db.run(
-      `UPDATE batch SET completed_at = ? WHERE id = ?`,
+      `UPDATE batch SET completed_at = ?, status = 'completed' WHERE id = ?`,
       [now, id]
     );
   }
@@ -118,4 +131,19 @@ export class BatchService implements i.BatchService {
     );
     return result.changes ?? 0;
   }
+
+  async updateStatus(id: string, status: i.BatchStatus): Promise<void> {
+    this.db.run(
+      `UPDATE batch SET status = ? WHERE id = ?`,
+      [status, id]
+    );
+  }
+
+  async getWithCriteria(id: string): Promise<{ batch: i.Batch; criteria: i.BatchInterruptionCriteria | null }> {
+    const batch = await this.getById(id);
+    if (!batch) {
+      throw new Error(`Batch not found: ${id}`);
+    }
+    return { batch, criteria: batch.interruptionCriteria };
+  }
 }

package/src/services/index.ts

@@ -1,2 +1,3 @@
 export { BatchService } from './batch.js';
 export { TaskService } from './task.js';
+export { BatchInterruptionService } from './batch-interruption.js';

package/src/utils/auto-detect.ts

@@ -6,6 +6,7 @@ export interface DetectOptions {
   timeoutMs?: number;
   maxConcurrencyToTest?: number;
   rateLimitTestDurationMs?: number;
+  maxRateLimitTestRequests?: number;
 }
 
 export interface DetectedConfig {
@@ -48,6 +49,7 @@ export async function detectConstraints(options: DetectOptions): Promise<Detecte
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const maxConcurrency = options.maxConcurrencyToTest ?? DEFAULT_MAX_CONCURRENCY;
   const rateLimitDurationMs = options.rateLimitTestDurationMs ?? DEFAULT_RATE_LIMIT_TEST_DURATION_MS;
+  const maxRateLimitTestRequests = options.maxRateLimitTestRequests ?? MAX_RATE_LIMIT_TEST_REQUESTS;
 
   const requestOptions: RequestOptions = {
     url: options.url,
@@ -64,7 +66,7 @@ export async function detectConstraints(options: DetectOptions): Promise<Detecte
 
   // Phase 2: Detect rate limit using safe concurrency (80% of detected)
   const safeConcurrency = Math.max(1, Math.floor(detectedConcurrency * 0.8));
-  const rateLimitResult = await detectRateLimit(requestOptions, safeConcurrency, rateLimitDurationMs, notes);
+  const rateLimitResult = await detectRateLimit(requestOptions, safeConcurrency, rateLimitDurationMs, maxRateLimitTestRequests, notes);
 
   // Calculate confidence
   const confidence = calculateConfidence(detectedConcurrency, rateLimitResult, notes);
@@ -206,6 +208,7 @@ async function detectRateLimit(
   options: RequestOptions,
   safeConcurrency: number,
   durationMs: number,
+  maxRequests: number,
   notes: string[]
 ): Promise<{ requests: number; windowMs: number }> {
   const startTime = Date.now();
@@ -214,7 +217,7 @@ async function detectRateLimit(
   let totalRequests = 0;
 
   // Send requests as fast as possible at safe concurrency
-  while (Date.now() - startTime < durationMs && totalRequests < MAX_RATE_LIMIT_TEST_REQUESTS) {
+  while (Date.now() - startTime < durationMs && totalRequests < maxRequests) {
     const batchStart = Date.now();
     const results = await sendBatch(options, safeConcurrency);