@vellumai/assistant 0.3.4 → 0.3.6

package/src/config/bundled-skills/media-processing/__tests__/preprocess.test.ts

@@ -0,0 +1,303 @@
+import { describe, it, expect } from 'bun:test';
+import {
+  parseDroppedFrameTimestamps,
+  buildDeadTimeRanges,
+  computeLiveRanges,
+  createSegments,
+  computeEffectiveInterval,
+  generateFrameTimestamps,
+  createDefaultSections,
+  sampleFrameIndices,
+  type TimeRange,
+} from '../services/preprocess.js';
+
+// ---------------------------------------------------------------------------
+// parseDroppedFrameTimestamps
+// ---------------------------------------------------------------------------
+
+describe('parseDroppedFrameTimestamps', () => {
+  it('extracts timestamps from mpdecimate-style stderr lines', () => {
+    const stderr = [
+      '[Parsed_mpdecimate_0 @ 0x...] pts_time:1.500 drop',
+      '[Parsed_mpdecimate_0 @ 0x...] pts_time:3.000 keep',
+      '[Parsed_mpdecimate_0 @ 0x...] pts_time:4.200 drop',
+      'some other line',
+    ].join('\n');
+
+    const result = parseDroppedFrameTimestamps(stderr);
+    expect(result).toEqual([1.5, 4.2]);
+  });
+
+  it('returns empty array for no drops', () => {
+    const stderr = 'pts_time:1.0 keep\npts_time:2.0 keep\n';
+    expect(parseDroppedFrameTimestamps(stderr)).toEqual([]);
+  });
+
+  it('returns sorted timestamps', () => {
+    const stderr = [
+      'pts_time:10.0 drop',
+      'pts_time:2.5 drop',
+      'pts_time:5.0 drop',
+    ].join('\n');
+
+    expect(parseDroppedFrameTimestamps(stderr)).toEqual([2.5, 5.0, 10.0]);
+  });
+
+  it('handles empty string', () => {
+    expect(parseDroppedFrameTimestamps('')).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildDeadTimeRanges
+// ---------------------------------------------------------------------------
+
+describe('buildDeadTimeRanges', () => {
+  it('groups consecutive timestamps into ranges', () => {
+    // Frames every 0.5s from 10.0 to 20.0 (>5s gap = dead time)
+    const timestamps: number[] = [];
+    for (let t = 10.0; t <= 20.0; t += 0.5) {
+      timestamps.push(parseFloat(t.toFixed(1)));
+    }
+
+    const ranges = buildDeadTimeRanges(timestamps, 1.0, 5.0);
+    expect(ranges).toEqual([{ start: 10.0, end: 20.0 }]);
+  });
+
+  it('splits into multiple ranges when gap exceeds threshold', () => {
+    const timestamps = [
+      1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7,
+      // gap of 10 seconds
+      17, 17.5, 18, 18.5, 19, 19.5, 20, 20.5, 21, 21.5, 22, 22.5, 23,
+    ];
+
+    const ranges = buildDeadTimeRanges(timestamps, 1.0, 5.0);
+    expect(ranges).toEqual([
+      { start: 1, end: 7 },
+      { start: 17, end: 23 },
+    ]);
+  });
+
+  it('filters out short ranges below minDuration', () => {
+    // Only 3 seconds of drops — below the 5s minimum
+    const timestamps = [10, 10.5, 11, 11.5, 12, 12.5, 13];
+    const ranges = buildDeadTimeRanges(timestamps, 1.0, 5.0);
+    expect(ranges).toEqual([]);
+  });
+
+  it('returns empty for no timestamps', () => {
+    expect(buildDeadTimeRanges([])).toEqual([]);
+  });
+
+  it('handles single long range', () => {
+    const timestamps = [0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6];
+    const ranges = buildDeadTimeRanges(timestamps, 1.0, 5.0);
+    expect(ranges).toEqual([{ start: 0, end: 6 }]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// computeLiveRanges
+// ---------------------------------------------------------------------------
+
+describe('computeLiveRanges', () => {
+  it('returns full duration when no dead time', () => {
+    const result = computeLiveRanges(300, []);
+    expect(result).toEqual([{ start: 0, end: 300 }]);
+  });
+
+  it('subtracts dead time from the middle', () => {
+    const dead: TimeRange[] = [{ start: 100, end: 150 }];
+    const result = computeLiveRanges(300, dead);
+    expect(result).toEqual([
+      { start: 0, end: 100 },
+      { start: 150, end: 300 },
+    ]);
+  });
+
+  it('handles dead time at the start', () => {
+    const dead: TimeRange[] = [{ start: 0, end: 30 }];
+    const result = computeLiveRanges(300, dead);
+    expect(result).toEqual([{ start: 30, end: 300 }]);
+  });
+
+  it('handles dead time at the end', () => {
+    const dead: TimeRange[] = [{ start: 280, end: 300 }];
+    const result = computeLiveRanges(300, dead);
+    expect(result).toEqual([{ start: 0, end: 280 }]);
+  });
+
+  it('handles multiple dead-time ranges', () => {
+    const dead: TimeRange[] = [
+      { start: 50, end: 60 },
+      { start: 150, end: 170 },
+    ];
+    const result = computeLiveRanges(300, dead);
+    expect(result).toEqual([
+      { start: 0, end: 50 },
+      { start: 60, end: 150 },
+      { start: 170, end: 300 },
+    ]);
+  });
+
+  it('handles unsorted dead-time ranges', () => {
+    const dead: TimeRange[] = [
+      { start: 150, end: 170 },
+      { start: 50, end: 60 },
+    ];
+    const result = computeLiveRanges(300, dead);
+    expect(result).toEqual([
+      { start: 0, end: 50 },
+      { start: 60, end: 150 },
+      { start: 170, end: 300 },
+    ]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createSegments
+// ---------------------------------------------------------------------------
+
+describe('createSegments', () => {
+  it('creates non-overlapping segments within a single live range', () => {
+    const live: TimeRange[] = [{ start: 0, end: 60 }];
+    const segments = createSegments(live, 20);
+    expect(segments).toEqual([
+      { id: 'seg-001', startSeconds: 0, endSeconds: 20 },
+      { id: 'seg-002', startSeconds: 20, endSeconds: 40 },
+      { id: 'seg-003', startSeconds: 40, endSeconds: 60 },
+    ]);
+  });
+
+  it('creates a shorter final segment for non-even durations', () => {
+    const live: TimeRange[] = [{ start: 0, end: 50 }];
+    const segments = createSegments(live, 20);
+    expect(segments).toHaveLength(3);
+    expect(segments[2]).toEqual({ id: 'seg-003', startSeconds: 40, endSeconds: 50 });
+  });
+
+  it('creates segments across multiple live ranges', () => {
+    const live: TimeRange[] = [
+      { start: 0, end: 30 },
+      { start: 60, end: 80 },
+    ];
+    const segments = createSegments(live, 20);
+    expect(segments).toHaveLength(3);
+    expect(segments[0]).toEqual({ id: 'seg-001', startSeconds: 0, endSeconds: 20 });
+    expect(segments[1]).toEqual({ id: 'seg-002', startSeconds: 20, endSeconds: 30 });
+    expect(segments[2]).toEqual({ id: 'seg-003', startSeconds: 60, endSeconds: 80 });
+  });
+
+  it('uses zero-padded IDs', () => {
+    const live: TimeRange[] = [{ start: 0, end: 10 }];
+    const segments = createSegments(live, 10);
+    expect(segments[0].id).toBe('seg-001');
+  });
+
+  it('returns empty for empty live ranges', () => {
+    expect(createSegments([], 20)).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// computeEffectiveInterval
+// ---------------------------------------------------------------------------
+
+describe('computeEffectiveInterval', () => {
+  it('returns requested interval when enough frames would be produced', () => {
+    // 20s segment / 3s interval = ~6 frames >= 4 minimum
+    expect(computeEffectiveInterval(20, 3)).toBe(3);
+  });
+
+  it('reduces interval for short segments to guarantee minimum frames', () => {
+    // 8s segment / 3s interval = ~2 frames < 4 minimum
+    // Should return 8/4 = 2
+    expect(computeEffectiveInterval(8, 3)).toBe(2);
+  });
+
+  it('reduces interval for very short segments', () => {
+    // 4s segment / 3s interval = 1 frame < 4 minimum
+    // Should return 4/4 = 1
+    expect(computeEffectiveInterval(4, 3)).toBe(1);
+  });
+
+  it('returns requested interval when exactly at minimum', () => {
+    // 12s segment / 3s interval = 4 frames = minimum
+    expect(computeEffectiveInterval(12, 3)).toBe(3);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// generateFrameTimestamps
+// ---------------------------------------------------------------------------
+
+describe('generateFrameTimestamps', () => {
+  it('generates evenly spaced timestamps within segment bounds', () => {
+    const ts = generateFrameTimestamps(0, 20, 3);
+    // 0, 3, 6, 9, 12, 15, 18
+    expect(ts).toEqual([0, 3, 6, 9, 12, 15, 18]);
+  });
+
+  it('uses reduced interval for short segments', () => {
+    const ts = generateFrameTimestamps(10, 18, 3);
+    // 8s segment, 3s interval gives floor(8/3)=2 frames < 4 min
+    // effective interval = 8/4 = 2
+    // 10, 12, 14, 16
+    expect(ts).toEqual([10, 12, 14, 16]);
+  });
+
+  it('handles segment not starting at zero', () => {
+    const ts = generateFrameTimestamps(60, 80, 3);
+    expect(ts[0]).toBe(60);
+    expect(ts[ts.length - 1]).toBeLessThan(80);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createDefaultSections
+// ---------------------------------------------------------------------------
+
+describe('createDefaultSections', () => {
+  it('splits duration into two equal halves', () => {
+    const sections = createDefaultSections(300);
+    expect(sections).toEqual([
+      { label: 'section_1', startSeconds: 0, endSeconds: 150 },
+      { label: 'section_2', startSeconds: 150, endSeconds: 300 },
+    ]);
+  });
+
+  it('handles odd duration', () => {
+    const sections = createDefaultSections(301);
+    expect(sections[0].endSeconds).toBe(150.5);
+    expect(sections[1].startSeconds).toBe(150.5);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// sampleFrameIndices
+// ---------------------------------------------------------------------------
+
+describe('sampleFrameIndices', () => {
+  it('returns all indices when fewer frames than sample count', () => {
+    const indices = sampleFrameIndices(5, 10);
+    expect(indices).toEqual([0, 1, 2, 3, 4]);
+  });
+
+  it('returns evenly spaced indices for large frame counts', () => {
+    const indices = sampleFrameIndices(100, 10);
+    expect(indices).toHaveLength(10);
+    // Should be roughly evenly spaced
+    expect(indices[0]).toBe(0);
+    expect(indices[9]).toBeLessThan(100);
+  });
+
+  it('returns correct count', () => {
+    const indices = sampleFrameIndices(50, 10);
+    expect(indices).toHaveLength(10);
+  });
+
+  it('handles single frame', () => {
+    const indices = sampleFrameIndices(1, 10);
+    expect(indices).toEqual([0]);
+  });
+});

package/src/config/bundled-skills/media-processing/services/concurrency-pool.ts

@@ -0,0 +1,55 @@
+/**
+ * Semaphore-based concurrency limiter for parallel segment processing.
+ *
+ * Limits how many async operations can run simultaneously to avoid
+ * overwhelming API rate limits or exhausting system resources.
+ */
+
+export class ConcurrencyPool {
+  private running = 0;
+  private queue: Array<() => void> = [];
+
+  constructor(private readonly maxConcurrency: number = 10) {
+    if (maxConcurrency < 1) {
+      throw new Error('maxConcurrency must be at least 1');
+    }
+  }
+
+  /**
+   * Acquire a slot in the pool. Resolves immediately if a slot is available,
+   * otherwise waits until one is freed via `release()`.
+   */
+  acquire(): Promise<void> {
+    if (this.running < this.maxConcurrency) {
+      this.running++;
+      return Promise.resolve();
+    }
+
+    return new Promise<void>((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+
+  /**
+   * Release a slot back to the pool, allowing the next queued caller to proceed.
+   */
+  release(): void {
+    const next = this.queue.shift();
+    if (next) {
+      // Hand the slot directly to the next waiter (running count stays the same)
+      next();
+    } else if (this.running > 0) {
+      this.running--;
+    }
+  }
+
+  /** Number of slots currently in use. */
+  get activeCount(): number {
+    return this.running;
+  }
+
+  /** Number of callers waiting for a slot. */
+  get waitingCount(): number {
+    return this.queue.length;
+  }
+}

package/src/config/bundled-skills/media-processing/services/cost-tracker.ts

@@ -0,0 +1,86 @@
+/**
+ * Tracks token usage and estimated costs across video segment processing.
+ *
+ * Cost estimation uses the shared pricing resolver from `assistant/src/util/pricing.ts`,
+ * which maintains a multi-provider pricing catalog including Gemini models.
+ */
+
+import { resolvePricing } from '../../../../util/pricing.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface SegmentCostEntry {
+  segmentId: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  estimatedUSD: number;
+}
+
+export interface CostSummary {
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalEstimatedUSD: number;
+  segmentCount: number;
+  entries: ReadonlyArray<SegmentCostEntry>;
+}
+
+// ---------------------------------------------------------------------------
+// CostTracker
+// ---------------------------------------------------------------------------
+
+export class CostTracker {
+  private entries: SegmentCostEntry[] = [];
+
+  constructor(private readonly provider: string = 'gemini') {}
+
+  /**
+   * Record token usage for a processed segment. Computes estimated cost
+   * via the shared pricing resolver.
+   */
+  record(params: {
+    segmentId: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+  }): SegmentCostEntry {
+    const result = resolvePricing(this.provider, params.model, params.inputTokens, params.outputTokens);
+    const estimatedUSD = result.estimatedCostUsd ?? 0;
+
+    const entry: SegmentCostEntry = {
+      segmentId: params.segmentId,
+      model: params.model,
+      inputTokens: params.inputTokens,
+      outputTokens: params.outputTokens,
+      estimatedUSD,
+    };
+
+    this.entries.push(entry);
+    return entry;
+  }
+
+  /**
+   * Return aggregate totals and the full list of per-segment entries.
+   */
+  getSummary(): CostSummary {
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalEstimatedUSD = 0;
+
+    for (const e of this.entries) {
+      totalInputTokens += e.inputTokens;
+      totalOutputTokens += e.outputTokens;
+      totalEstimatedUSD += e.estimatedUSD;
+    }
+
+    return {
+      totalInputTokens,
+      totalOutputTokens,
+      totalEstimatedUSD,
+      segmentCount: this.entries.length,
+      entries: [...this.entries],
+    };
+  }
+}