@librechat/agents 3.3.12 → 3.4.0

package/src/llm/stream/chunkAdapters.ts

@@ -0,0 +1,317 @@
+import { AIMessageChunk } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { SmoothItem, SmoothPiece } from '@/llm/stream/smoother';
+import { smoothStream } from '@/llm/stream/smoother';
+
+/**
+ * Rebuilds a generation chunk carrying one piece of a split plain-text chunk.
+ * Unsplit pieces return the original chunk untouched, so disabled smoothing is
+ * byte-identical to no smoothing. Usage metadata, additional kwargs and
+ * response metadata survive only on the first piece: the aggregator merges
+ * dicts by concatenating string fields, so replicating them across pieces
+ * would duplicate reasoning text and scalar metadata once per piece.
+ */
+export function cloneGenerationChunkPiece(
+  chunk: ChatGenerationChunk,
+  piece: SmoothPiece
+): ChatGenerationChunk {
+  if (piece.isFirst && piece.isLast) {
+    return chunk;
+  }
+  const message = chunk.message as AIMessageChunk;
+  return new ChatGenerationChunk({
+    text: piece.text,
+    generationInfo: piece.isFirst ? chunk.generationInfo : undefined,
+    message: new AIMessageChunk(
+      Object.assign({}, message, {
+        content: piece.text,
+        usage_metadata: piece.isFirst ? message.usage_metadata : undefined,
+        additional_kwargs: piece.isFirst ? message.additional_kwargs : {},
+        response_metadata: piece.isFirst ? message.response_metadata : {},
+      })
+    ),
+  });
+}
+
+const SPLITTABLE_TEXT_PART_KEYS: ReadonlySet<string> = new Set([
+  'type',
+  'text',
+  'index',
+]);
+
+/**
+ * Returns the sole plain text part of a single-element complex content array
+ * (the shape google-common emits for text deltas), or null when the part
+ * carries anything beyond `type`/`text`/`index` (thought signatures, media,
+ * function calls) and must not be sliced. The part must carry a numeric
+ * `index`: it is the aggregator's list-merge key, and without it each split
+ * piece would append as a separate content part instead of merging back
+ * into one — index-less parts pace whole instead.
+ */
+function getSplittableTextPart(
+  message: AIMessageChunk,
+  chunkText: string
+): Record<string, unknown> | null {
+  const content = message.content;
+  if (!Array.isArray(content) || content.length !== 1) {
+    return null;
+  }
+  const part: unknown = content[0];
+  if (part == null || typeof part !== 'object') {
+    return null;
+  }
+  const record = part as Record<string, unknown>;
+  if (typeof record.text !== 'string' || record.text !== chunkText) {
+    return null;
+  }
+  if (record.type != null && record.type !== 'text') {
+    return null;
+  }
+  if (typeof record.index !== 'number') {
+    return null;
+  }
+  if (!Object.keys(record).every((key) => SPLITTABLE_TEXT_PART_KEYS.has(key))) {
+    return null;
+  }
+  return record;
+}
+
+function clonePartGenerationChunkPiece(
+  chunk: ChatGenerationChunk,
+  part: Record<string, unknown>,
+  piece: SmoothPiece
+): ChatGenerationChunk {
+  if (piece.isFirst && piece.isLast) {
+    return chunk;
+  }
+  const message = chunk.message as AIMessageChunk;
+  return new ChatGenerationChunk({
+    text: piece.text,
+    generationInfo: piece.isFirst ? chunk.generationInfo : undefined,
+    message: new AIMessageChunk(
+      Object.assign({}, message, {
+        content: [Object.assign({}, part, { text: piece.text })],
+        usage_metadata: piece.isFirst ? message.usage_metadata : undefined,
+        additional_kwargs: piece.isFirst ? message.additional_kwargs : {},
+        response_metadata: piece.isFirst ? message.response_metadata : {},
+      })
+    ),
+  });
+}
+
+/**
+ * Provider-agnostic classification of a `ChatGenerationChunk` for the
+ * smoothing engine:
+ * - splittable: plain visible text — string content equal to `chunk.text`, or
+ *   a single plain text part (google-common's delta shape) — with no
+ *   logprobs / finish_reason; sliced adaptively at the pacing cadence.
+ * - atomic: any other text-bearing chunk (complex content arrays, logprobs,
+ *   finish_reason, provider-specific reasoning payloads surfaced via
+ *   `getAtomicText`) — paced as one piece, never split.
+ * - passthrough: tool-call deltas, usage-only and metadata chunks — strict
+ *   FIFO, zero delay.
+ */
+/**
+ * google-common stamps `logprobs: { content: [] }` on every chunk, so only
+ * logprobs that actually carry data may block splitting here. This is looser
+ * than the OpenAI-family adapter in `llm/openai/index.ts`, which treats ANY
+ * logprobs as atomic (its providers only attach logprobs when requested, and
+ * the DeepSeek suite pins that contract) — do not unify the two predicates.
+ */
+function hasMeaningfulLogprobs(
+  generationInfo: ChatGenerationChunk['generationInfo']
+): boolean {
+  const logprobs = generationInfo?.logprobs;
+  if (logprobs == null) {
+    return false;
+  }
+  const content = (logprobs as { content?: unknown }).content;
+  if (Array.isArray(content)) {
+    return content.length > 0;
+  }
+  return true;
+}
+
+/** google-common reports the terminal reason camelCase (`finishReason`). */
+function hasFinishReason(
+  generationInfo: ChatGenerationChunk['generationInfo']
+): boolean {
+  return (
+    generationInfo?.finish_reason != null || generationInfo?.finishReason != null
+  );
+}
+
+/**
+ * Chunks that pair visible text with reasoning payloads in
+ * `additional_kwargs` (Gemini thought summaries, reasoning_content deltas,
+ * OpenRouter reasoning_details) must pace whole: split pieces would each
+ * carry the same kwargs and downstream merging — the aggregator's dict merge
+ * or OpenRouter's reasoning_details accumulation — duplicates them once per
+ * piece.
+ */
+/**
+ * Mixed text/tool-call deltas must never split: cloned pieces would each
+ * carry the same tool_call_chunks and downstream accumulation would corrupt
+ * the assembled tool arguments.
+ */
+export function hasToolCallChunks(message: AIMessageChunk): boolean {
+  return (message.tool_call_chunks?.length ?? 0) > 0;
+}
+
+export function hasReasoningKwargs(message: AIMessageChunk): boolean {
+  const kwargs = message.additional_kwargs;
+  if (
+    typeof kwargs.reasoning_content === 'string' &&
+    kwargs.reasoning_content !== ''
+  ) {
+    return true;
+  }
+  if (
+    Array.isArray(kwargs.reasoning_details) &&
+    kwargs.reasoning_details.length > 0
+  ) {
+    return true;
+  }
+  return kwargs.reasoning != null;
+}
+
+/**
+ * Extracts the visible reasoning text a kwargs-borne delta contributes, so
+ * reasoning-only chunks (Gemini thoughts, DeepSeek reasoning_content,
+ * OpenAI reasoning summaries, OpenRouter reasoning_details) pace atomically
+ * at the cadence instead of passing through unsmoothed.
+ */
+export function getReasoningKwargsText(message: AIMessageChunk): string {
+  const kwargs = message.additional_kwargs;
+  if (
+    typeof kwargs.reasoning_content === 'string' &&
+    kwargs.reasoning_content !== ''
+  ) {
+    return kwargs.reasoning_content;
+  }
+  const reasoning = kwargs.reasoning;
+  if (typeof reasoning === 'string' && reasoning !== '') {
+    return reasoning;
+  }
+  if (reasoning != null && typeof reasoning === 'object') {
+    const summaryText = (
+      reasoning as { summary?: { text?: unknown }[] }
+    ).summary?.[0]?.text;
+    if (typeof summaryText === 'string' && summaryText !== '') {
+      return summaryText;
+    }
+  }
+  const details = kwargs.reasoning_details;
+  if (Array.isArray(details)) {
+    let text = '';
+    for (const detail of details) {
+      if (detail != null && typeof detail === 'object') {
+        const detailText = (detail as { text?: unknown }).text;
+        if (typeof detailText === 'string') {
+          text += detailText;
+        }
+      }
+    }
+    if (text !== '') {
+      return text;
+    }
+  }
+  return '';
+}
+
+export function toGenerationSmoothItem(
+  chunk: ChatGenerationChunk,
+  getAtomicText?: (message: AIMessageChunk) => string
+): SmoothItem<ChatGenerationChunk> {
+  const { message } = chunk;
+  const isMessageChunk = message instanceof AIMessageChunk;
+  const cleanGenerationInfo =
+    !hasMeaningfulLogprobs(chunk.generationInfo) &&
+    !hasFinishReason(chunk.generationInfo);
+  const splittable =
+    Boolean(chunk.text) &&
+    isMessageChunk &&
+    typeof message.content === 'string' &&
+    message.content === chunk.text &&
+    cleanGenerationInfo &&
+    !hasReasoningKwargs(message) &&
+    !hasToolCallChunks(message);
+
+  if (splittable) {
+    return {
+      text: chunk.text,
+      smooth: true,
+      emit: (piece) => cloneGenerationChunkPiece(chunk, piece),
+    };
+  }
+
+  const splittablePart =
+    Boolean(chunk.text) &&
+    isMessageChunk &&
+    cleanGenerationInfo &&
+    !hasReasoningKwargs(message) &&
+    !hasToolCallChunks(message)
+      ? getSplittableTextPart(message, chunk.text)
+      : null;
+  if (splittablePart != null) {
+    return {
+      text: chunk.text,
+      smooth: true,
+      emit: (piece) =>
+        clonePartGenerationChunkPiece(chunk, splittablePart, piece),
+    };
+  }
+
+  const pacedText =
+    chunk.text ||
+    (isMessageChunk && getAtomicText != null ? getAtomicText(message) : '');
+  if (pacedText !== '') {
+    return {
+      text: pacedText,
+      smooth: true,
+      atomic: true,
+      emit: () => chunk,
+    };
+  }
+
+  return { text: '', smooth: false, emit: () => chunk };
+}
+
+/**
+ * Wraps a provider's raw chunk stream with adaptive smoothing and per-piece
+ * `handleLLMNewToken` dispatch. The raw stream must NOT dispatch runManager
+ * callbacks itself — callback-echo consumers would otherwise observe the
+ * unsmoothed deltas.
+ */
+export async function* smoothGenerationChunks({
+  chunks,
+  delayMs,
+  signal,
+  runManager,
+}: {
+  chunks: AsyncGenerator<ChatGenerationChunk>;
+  delayMs: number;
+  signal?: AbortSignal;
+  runManager?: CallbackManagerForLLMRun;
+}): AsyncGenerator<ChatGenerationChunk> {
+  const source = (async function* (): AsyncGenerator<
+    SmoothItem<ChatGenerationChunk>
+    > {
+    for await (const chunk of chunks) {
+      yield toGenerationSmoothItem(chunk, getReasoningKwargsText);
+    }
+  })();
+
+  for await (const outputChunk of smoothStream({ source, delayMs, signal })) {
+    yield outputChunk;
+    await runManager?.handleLLMNewToken(
+      outputChunk.text || '',
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      { chunk: outputChunk }
+    );
+  }
+}

package/src/llm/stream/reassembly.test.ts

@@ -0,0 +1,241 @@
+import { concat } from '@langchain/core/utils/stream';
+import { AIMessageChunk } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { SmoothItem } from './smoother';
+import { toSmoothItem } from '@/llm/openai';
+import {
+  toGenerationSmoothItem,
+  getReasoningKwargsText,
+} from './chunkAdapters';
+import { findStreamChunkBoundary } from './smoother';
+
+/**
+ * Lossless-reassembly property: for ANY chunk shape an adapter classifies,
+ * aggregating the emitted pieces must reproduce the original chunk's
+ * observable payload — text, content, kwargs, response metadata, usage,
+ * tool calls. This is the invariant behind every split-corruption bug class
+ * (duplicated reasoning/kwargs, summed usage, cloned tool args): if a field
+ * cannot survive slicing, the adapter must classify the chunk atomic or
+ * scope the field to a single piece, and this property proves it did.
+ */
+
+type AdapterName = 'openai-family' | 'generic';
+
+const ADAPTERS: Record<
+  AdapterName,
+  (chunk: ChatGenerationChunk) => SmoothItem<ChatGenerationChunk>
+> = {
+  'openai-family': (chunk) => toSmoothItem(chunk),
+  generic: (chunk) => toGenerationSmoothItem(chunk, getReasoningKwargsText),
+};
+
+/** Emits the item the way the engine would: split smooth+splittable items
+ * into ≥2 boundary-aligned pieces; atomic and passthrough emit whole. */
+function emitPieces(item: SmoothItem<ChatGenerationChunk>): ChatGenerationChunk[] {
+  if (!item.smooth || item.atomic === true || item.text.length < 8) {
+    return [item.emit({ text: item.text, isFirst: true, isLast: true })];
+  }
+  const pieces: ChatGenerationChunk[] = [];
+  let offset = 0;
+  while (offset < item.text.length) {
+    const end = offset + findStreamChunkBoundary(item.text.slice(offset), 4);
+    pieces.push(
+      item.emit({
+        text: item.text.slice(offset, end),
+        isFirst: offset === 0,
+        isLast: end === item.text.length,
+      })
+    );
+    offset = end;
+  }
+  return pieces;
+}
+
+function aggregate(pieces: ChatGenerationChunk[]): AIMessageChunk {
+  let merged = pieces[0].message as AIMessageChunk;
+  for (const piece of pieces.slice(1)) {
+    merged = concat(merged, piece.message as AIMessageChunk);
+  }
+  return merged;
+}
+
+function assertLossless(
+  adapter: AdapterName,
+  chunk: ChatGenerationChunk
+): void {
+  const item = ADAPTERS[adapter](chunk);
+  const pieces = emitPieces(item);
+  const original = chunk.message as AIMessageChunk;
+
+  const joinedText = pieces.map((p) => p.text).join('');
+  if (item.smooth) {
+    expect(joinedText === chunk.text || joinedText === item.text).toBe(true);
+  }
+
+  const merged = aggregate(pieces);
+  expect(merged.content).toEqual(original.content);
+  expect(merged.additional_kwargs).toEqual(original.additional_kwargs);
+  expect(merged.response_metadata).toEqual(original.response_metadata);
+  /** concat() adds empty *_token_details objects during merge; token COUNTS
+   * are the corruption signal (replicated usage would sum). */
+  expect(merged.usage_metadata?.input_tokens).toBe(
+    original.usage_metadata?.input_tokens
+  );
+  expect(merged.usage_metadata?.output_tokens).toBe(
+    original.usage_metadata?.output_tokens
+  );
+  expect(merged.usage_metadata?.total_tokens).toBe(
+    original.usage_metadata?.total_tokens
+  );
+  expect(merged.tool_call_chunks ?? []).toEqual(
+    original.tool_call_chunks ?? []
+  );
+}
+
+type MatrixCase = {
+  name: string;
+  chunk: () => ChatGenerationChunk;
+  adapters: AdapterName[];
+};
+
+const TEXT = 'the quick brown fox jumps over the lazy dog again and again ';
+
+const MATRIX: MatrixCase[] = [
+  {
+    name: 'plain string text',
+    adapters: ['openai-family', 'generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: TEXT,
+        message: new AIMessageChunk({ content: TEXT }),
+      }),
+  },
+  {
+    name: 'text with usage metadata',
+    adapters: ['openai-family', 'generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: TEXT,
+        message: new AIMessageChunk({
+          content: TEXT,
+          usage_metadata: { input_tokens: 7, output_tokens: 11, total_tokens: 18 },
+        }),
+      }),
+  },
+  {
+    name: 'text with an unknown string kwargs field',
+    adapters: ['openai-family', 'generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: TEXT,
+        message: new AIMessageChunk({
+          content: TEXT,
+          additional_kwargs: { annotation: 'gateway-added-value' },
+        }),
+      }),
+  },
+  {
+    name: 'text with scalar response metadata',
+    adapters: ['openai-family', 'generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: TEXT,
+        message: new AIMessageChunk({
+          content: TEXT,
+          response_metadata: { model_name: 'test-model', system_fingerprint: 'fp_1' },
+        }),
+      }),
+  },
+  {
+    name: 'text with reasoning_content kwargs',
+    adapters: ['openai-family', 'generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: TEXT,
+        message: new AIMessageChunk({
+          content: TEXT,
+          additional_kwargs: { reasoning_content: 'a hidden thought' },
+        }),
+      }),
+  },
+  {
+    name: 'text with reasoning_details kwargs',
+    adapters: ['openai-family', 'generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: TEXT,
+        message: new AIMessageChunk({
+          content: TEXT,
+          additional_kwargs: {
+            reasoning_details: [{ type: 'reasoning.text', text: 'thought' }],
+          },
+        }),
+      }),
+  },
+  {
+    name: 'text alongside tool_call_chunks',
+    adapters: ['openai-family', 'generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: TEXT,
+        message: new AIMessageChunk({
+          content: TEXT,
+          tool_call_chunks: [
+            { name: 'lookup', args: '{"q":1}', id: 'call_1', index: 0, type: 'tool_call_chunk' },
+          ],
+        }),
+      }),
+  },
+  {
+    name: 'indexed text-part array content (google shape)',
+    adapters: ['generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: TEXT,
+        message: new AIMessageChunk({
+          content: [{ type: 'text', text: TEXT, index: 0 }],
+        }),
+      }),
+  },
+  {
+    name: 'index-less text-part array content (no merge key)',
+    adapters: ['generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: TEXT,
+        message: new AIMessageChunk({
+          content: [{ type: 'text', text: TEXT }],
+        }),
+      }),
+  },
+  {
+    name: 'reasoning-only delta',
+    adapters: ['openai-family', 'generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: '',
+        message: new AIMessageChunk({
+          content: '',
+          additional_kwargs: { reasoning_content: 'thought only delta here' },
+        }),
+      }),
+  },
+  {
+    name: 'usage-only delta',
+    adapters: ['openai-family', 'generic'],
+    chunk: () =>
+      new ChatGenerationChunk({
+        text: '',
+        message: new AIMessageChunk({
+          content: '',
+          usage_metadata: { input_tokens: 1, output_tokens: 2, total_tokens: 3 },
+        }),
+      }),
+  },
+];
+
+describe.each(MATRIX)('lossless reassembly: $name', ({ chunk, adapters }) => {
+  it.each(adapters)('%s adapter', (adapter) => {
+    assertLossless(adapter, chunk());
+  });
+});

package/src/llm/stream/smoother.bench.test.ts

@@ -0,0 +1,155 @@
+import http from 'node:http';
+import { HumanMessage } from '@langchain/core/messages';
+import type { AddressInfo } from 'node:net';
+import { ChatOpenAI } from '@/llm/openai';
+import { SMOOTH_TARGET_LATENCY_MS } from './smoother';
+
+/**
+ * End-to-end cadence/lag benchmark: drives the real ChatOpenAI client against
+ * a local SSE server that emits large chunks fast (the big-chunk gateway
+ * profile smoothing exists for), asserting the properties that define the
+ * feature: even cadence at the configured tick, and render lag pinned near
+ * the target latency instead of growing with reply length.
+ */
+describe('adaptive smoothing benchmark (big-chunk provider)', () => {
+  const WORDS =
+    'ClickHouse stores data in columns so queries read only what they touch and compress well '.split(
+      ' '
+    );
+  const CHUNK_CHARS = 110;
+  const PROVIDER_INTERVAL_MS = 20;
+
+  function buildChunks(totalWords: number): string[] {
+    const out: string[] = [];
+    let current = '';
+    for (let i = 0; i < totalWords; i++) {
+      current += WORDS[i % WORDS.length] + ' ';
+      if (current.length >= CHUNK_CHARS) {
+        out.push(current);
+        current = '';
+      }
+    }
+    if (current) {
+      out.push(current);
+    }
+    return out;
+  }
+
+  function startServer(chunks: string[], stamp: { doneAt: number }): Promise<{
+    server: http.Server;
+    port: number;
+  }> {
+    return new Promise((resolve) => {
+      const server = http.createServer((req, res) => {
+        res.writeHead(200, { 'Content-Type': 'text/event-stream' });
+        const frame = (
+          delta: Record<string, unknown>,
+          finish: string | null
+        ): string =>
+          `data: ${JSON.stringify({
+            id: 'bench',
+            object: 'chat.completion.chunk',
+            created: 1,
+            model: 'bench-model',
+            choices: [{ index: 0, delta, finish_reason: finish }],
+          })}\n\n`;
+        res.write(frame({ role: 'assistant', content: '' }, null));
+        let i = 0;
+        const send = (): void => {
+          if (i < chunks.length) {
+            res.write(frame({ content: chunks[i] }, null));
+            i += 1;
+            setTimeout(send, PROVIDER_INTERVAL_MS);
+          } else {
+            stamp.doneAt = Date.now();
+            res.write(frame({}, 'stop'));
+            res.write('data: [DONE]\n\n');
+            res.end();
+          }
+        };
+        send();
+      });
+      server.listen(0, '127.0.0.1', () => {
+        resolve({ server, port: (server.address() as AddressInfo).port });
+      });
+    });
+  }
+
+  async function measure(
+    totalWords: number,
+    tick: number
+  ): Promise<{
+    meanGap: number;
+    jitter: number;
+    lag: number;
+    totalText: string;
+    expected: string;
+  }> {
+    const chunks = buildChunks(totalWords);
+    const stamp = { doneAt: 0 };
+    const { server, port } = await startServer(chunks, stamp);
+    try {
+      const model = new ChatOpenAI({
+        model: 'bench-model',
+        apiKey: 'bench',
+        streaming: true,
+        configuration: { baseURL: `http://127.0.0.1:${port}/v1` },
+        _lc_stream_delay: tick,
+      });
+
+      const gaps: number[] = [];
+      let totalText = '';
+      let last = Date.now();
+      for await (const piece of await model.stream([new HumanMessage('go')])) {
+        if (typeof piece.content !== 'string' || piece.content === '') {
+          continue;
+        }
+        const now = Date.now();
+        gaps.push(now - last);
+        last = now;
+        totalText += piece.content;
+      }
+      const renderDoneAt = Date.now();
+
+      const paint = gaps.slice(1);
+      const mean = paint.reduce((a, b) => a + b, 0) / paint.length;
+      const jitter = Math.sqrt(
+        paint.reduce((a, b) => a + (b - mean) ** 2, 0) / paint.length
+      );
+      return {
+        meanGap: mean,
+        jitter,
+        lag: renderDoneAt - stamp.doneAt,
+        totalText,
+        expected: chunks.join(''),
+      };
+    } finally {
+      server.close();
+    }
+  }
+
+  /** Bounds are deliberately loose on absolutes (CI machines and parallel
+   * jest workers add scheduling noise); the discriminating assertion is the
+   * last one — lag must stay FLAT as reply length grows, which is the
+   * property fixed-rate smoothing lacks (it lagged +31s at 4x length). */
+  test('holds cadence at the tick with bounded lag on a medium reply', async () => {
+    const tick = 15;
+    const result = await measure(500, tick);
+
+    expect(result.totalText).toBe(result.expected);
+    expect(result.meanGap).toBeGreaterThan(tick * 0.5);
+    expect(result.meanGap).toBeLessThan(tick * 2.5);
+    expect(result.jitter).toBeLessThan(25);
+    expect(result.lag).toBeLessThan(SMOOTH_TARGET_LATENCY_MS * 4);
+  }, 60000);
+
+  test('lag does not grow with reply length', async () => {
+    const tick = 15;
+    const short = await measure(250, tick);
+    const long = await measure(1000, tick);
+
+    expect(long.totalText).toBe(long.expected);
+    expect(long.lag).toBeLessThan(SMOOTH_TARGET_LATENCY_MS * 4);
+    expect(long.lag).toBeLessThan(short.lag + SMOOTH_TARGET_LATENCY_MS * 2);
+  }, 60000);
+});