@wayai/cli 0.3.173 → 0.3.174

package/dist/index.js

@@ -30200,6 +30200,23 @@ function pcmClip(buf) {
   for (let i = 0; i < samples.length; i++) samples[i] = buf.readInt16LE(2 * i);
   return { samples, sampleRate: OPENAI_PCM_SAMPLE_RATE };
 }
+function trailingSilenceMs(clip) {
+  const frame = Math.max(1, Math.round(clip.sampleRate / 100));
+  const frames = Math.ceil(clip.samples.length / frame);
+  const rms = (f) => {
+    let sum = 0;
+    const end = Math.min(clip.samples.length, (f + 1) * frame);
+    for (let i = f * frame; i < end; i++) sum += clip.samples[i] * clip.samples[i];
+    return Math.sqrt(sum / Math.max(1, end - f * frame));
+  };
+  let loudest = 0;
+  for (let f = 0; f < frames; f++) loudest = Math.max(loudest, rms(f));
+  if (loudest === 0) return 0;
+  let last = frames - 1;
+  while (last > 0 && rms(last) < loudest / 10) last--;
+  const spokenSamples = Math.min(clip.samples.length, (last + 1) * frame);
+  return (clip.samples.length - spokenSamples) * 1e3 / clip.sampleRate;
+}
 function resample(clip, rate) {
   if (clip.sampleRate === rate) return clip.samples;
   const out = new Int16Array(Math.max(1, Math.round(clip.samples.length * rate / clip.sampleRate)));
@@ -30403,6 +30420,12 @@ var init_call_media = __esm({
       onsetAfter(afterMs) {
         return this.onsets.find((t) => t > afterMs) ?? null;
       }
+      /** The utterances begun at or after `sinceMs`, in order; the last one's end is null while it goes on. */
+      utterancesSince(sinceMs) {
+        let first = this.onsets.length;
+        while (first > 0 && this.onsets[first - 1] >= sinceMs) first--;
+        return this.onsets.slice(first).map((startMs, i) => ({ startMs, endMs: this.offsets[first + i] ?? null }));
+      }
       /** When the voice last stopped speaking; null while it speaks or before it has. */
       quietSince() {
         return this.isSpeaking ? null : this.offsets[this.offsets.length - 1] ?? null;
@@ -30530,14 +30553,19 @@ var init_call_media = __esm({
         await waitFor(() => this.voice.onsetAfter(afterMs) !== null || abort(), timeoutMs, this.clock);
         return this.voice.onsetAfter(afterMs);
       }
-      async waitForVoiceDone(sinceMs, quietMs, timeoutMs, abort = () => false, notBeforeMs = Number.NEGATIVE_INFINITY) {
-        const done = () => {
-          if (this.clock.now() < notBeforeMs || this.voice.onsetAfter(sinceMs - 1) === null) return false;
+      async waitForVoiceDone(sinceMs, quietMs, timeoutMs, abort = () => false, owedUntil = () => Number.NEGATIVE_INFINITY) {
+        let boundFrom = this.clock.now();
+        const check = () => {
+          const now = this.clock.now();
+          const said = this.voice.utterancesSince(sinceMs);
+          const owed = owedUntil(said);
+          boundFrom = Math.max(boundFrom, owed);
+          if (said.length === 0 || now < owed) return false;
           const quiet = this.voice.quietSince();
-          return quiet !== null && quiet > sinceMs && this.clock.now() - quiet >= quietMs;
+          return quiet !== null && quiet > sinceMs && now - quiet >= quietMs;
         };
-        await waitFor(() => done() || abort(), timeoutMs + Math.max(0, notBeforeMs - this.clock.now()), this.clock);
-        return done();
+        await waitFor(() => check() || abort() || this.clock.now() >= boundFrom + timeoutMs, Number.POSITIVE_INFINITY, this.clock);
+        return check();
       }
       delegationsSeen() {
         return this.delegations.size;
@@ -31405,6 +31433,25 @@ var init_score = __esm({
 });
 
 // src/lib/call-eval/runner.ts
+function latestStretchBegan(said) {
+  let k = said.length - 1;
+  if (k < 0) return null;
+  while (k > 0 && said[k].startMs - (said[k - 1].endMs ?? said[k].startMs) < SPEECH_STRETCH_GAP_MS) k--;
+  return said[k].startMs;
+}
+function delegatedAnswerOwedUntil(speechEnd, progressCues, answerDueMs) {
+  const dueAt = speechEnd + answerDueMs;
+  if (!progressCues) return () => dueAt;
+  return (said) => {
+    const began = latestStretchBegan(said);
+    if (began === null) return Number.NEGATIVE_INFINITY;
+    const after = began - speechEnd;
+    const cue = PROGRESS_CUES_HEARD_AT_MS.findIndex((at) => after >= at - CUE_HEARD_EARLY_MS && after <= at + CUE_HEARD_LATE_MS);
+    if (cue < 0) return Number.NEGATIVE_INFINITY;
+    const next = PROGRESS_CUES_HEARD_AT_MS[cue + 1];
+    return next === void 0 ? dueAt : Math.min(dueAt, speechEnd + next + CUE_HEARD_LATE_MS);
+  };
+}
 function runPassed(run) {
   return run.status === "completed" && run.score?.pass === true;
 }
@@ -31439,6 +31486,7 @@ async function runOneCall(options, run, clips) {
     cost: { connected_ms: 0, provider_usd: 0, operations: 0, operations_settled: false }
   };
   const quietAfter = (delegated) => delegated ? timings.delegatedAnswerQuietMs : timings.ownAnswerQuietMs;
+  const speechTailsMs = clips.map(trailingSilenceMs);
   let media = null;
   let callStartedAt = null;
   let hungUp = false;
@@ -31463,8 +31511,10 @@ async function runOneCall(options, run, clips) {
     result.call_id = created.call_id;
     result.conversation_id = created.conversation_id;
     log(`run ${run}: call ${created.call_id} placed (at most ${created.max_call_seconds} s)`);
-    const silentWaitMs = created.progress_cues === false ? created.delegation_timeout_seconds * 1e3 + timings.silentWaitMarginMs : null;
-    if (silentWaitMs !== null) {
+    const progressCues = created.progress_cues !== false;
+    const answerDueMs = Number.isFinite(created.delegation_timeout_seconds) ? created.delegation_timeout_seconds * 1e3 + timings.answerTimeoutMarginMs : null;
+    const answerOwedUntil = answerDueMs === null ? null : (speechEnd) => delegatedAnswerOwedUntil(speechEnd, progressCues, answerDueMs);
+    if (!progressCues) {
       log(`run ${run}: progress cues are off: each delegated answer is awaited up to its ${created.delegation_timeout_seconds} s timeout`);
     }
     await port.connect(created.sdp_answer);
@@ -31488,20 +31538,22 @@ async function runOneCall(options, run, clips) {
       if (reason) result.stopped_by = reason;
       return reason !== null;
     };
-    const waitForAnswer = (lineEnd, delegated) => {
-      const notBeforeMs = delegated && silentWaitMs !== null ? lineEnd + silentWaitMs : void 0;
-      return port.waitForVoiceDone(lineEnd, quietAfter(delegated), timings.answerDoneTimeoutMs, stop, notBeforeMs);
-    };
+    const waitForAnswer = (line) => port.waitForVoiceDone(
+      line.endedAtMs,
+      quietAfter(line.delegated),
+      timings.answerDoneTimeoutMs,
+      stop,
+      line.delegated && answerOwedUntil ? answerOwedUntil(line.speechEnd) : void 0
+    );
     await port.waitForVoiceDone(connectedAt, timings.ownAnswerQuietMs, timings.greetingTimeoutMs, stop);
-    let previousEnd = connectedAt;
-    let previousDelegated = false;
+    let previous = { endedAtMs: connectedAt, speechEnd: connectedAt, delegated: false };
     for (const [i, line] of script.lines.entries()) {
       if (stop()) break;
       if (line.interrupt) {
-        const onset2 = await port.waitForVoiceOnset(previousEnd, timings.answerOnsetTimeoutMs, stop);
+        const onset2 = await port.waitForVoiceOnset(previous.endedAtMs, timings.answerOnsetTimeoutMs, stop);
         if (onset2 !== null) await clock.sleep(Math.max(0, onset2 + timings.interruptAfterMs - clock.now()));
       } else if (i > 0) {
-        await waitForAnswer(previousEnd, previousDelegated);
+        await waitForAnswer(previous);
       }
       if (stop()) break;
       const span = await port.play(clips[i], stop);
@@ -31509,11 +31561,10 @@ async function runOneCall(options, run, clips) {
       result.lines_said += 1;
       const onset = await port.waitForVoiceOnset(span.endedAtMs, timings.answerOnsetTimeoutMs, stop);
       result.timings.push({ n: line.n, started_at_ms: span.startedAtMs, ended_at_ms: span.endedAtMs, voice_onset_ms: onset });
-      previousEnd = span.endedAtMs;
-      previousDelegated = line.expect_delegation;
+      previous = { endedAtMs: span.endedAtMs, speechEnd: span.endedAtMs - speechTailsMs[i], delegated: line.expect_delegation };
     }
     if (!result.stopped_by) {
-      await waitForAnswer(previousEnd, previousDelegated);
+      await waitForAnswer(previous);
     }
     if (result.stopped_by) {
       result.status = "stopped";
@@ -31606,13 +31657,14 @@ async function runCallEvalSuite(options) {
     cost: { provider_usd: ledger.spentUsd, operations: ledger.spentOperations }
   };
 }
-var systemRunnerClock, LONGEST_SPOKEN_LINE_MS, DEFAULT_RUNNER_TIMINGS, RECORD_SETTLE_TIMEOUT_MS, RECORD_POLL_MS;
+var systemRunnerClock, LONGEST_SPOKEN_LINE_MS, DEFAULT_RUNNER_TIMINGS, PROGRESS_CUES_HEARD_AT_MS, CUE_HEARD_EARLY_MS, CUE_HEARD_LATE_MS, SPEECH_STRETCH_GAP_MS, RECORD_SETTLE_TIMEOUT_MS, RECORD_POLL_MS;
 var init_runner = __esm({
   "src/lib/call-eval/runner.ts"() {
     "use strict";
     init_dist();
     init_contracts();
     init_errors2();
+    init_caller_audio();
     init_cost_cap();
     init_score();
     systemRunnerClock = {
@@ -31625,10 +31677,14 @@ var init_runner = __esm({
       answerOnsetTimeoutMs: 2e4,
       answerDoneTimeoutMs: 45e3 + 2 * LONGEST_SPOKEN_LINE_MS,
       delegatedAnswerQuietMs: 5500,
-      silentWaitMarginMs: 3e3,
+      answerTimeoutMarginMs: 3e3,
       ownAnswerQuietMs: 2e3,
       interruptAfterMs: 1e3
     };
+    PROGRESS_CUES_HEARD_AT_MS = [5e3, 1e4];
+    CUE_HEARD_EARLY_MS = 1e3;
+    CUE_HEARD_LATE_MS = 2e3;
+    SPEECH_STRETCH_GAP_MS = 1e3;
     RECORD_SETTLE_TIMEOUT_MS = 3e4;
     RECORD_POLL_MS = 1e3;
   }