Turn events & idle users

const aggregators = new LLMContextAggregatorPair(context, {
  userParams: new LLMUserAggregatorParams({ vadAnalyzer: new SileroVADAnalyzer() }),
});
const user = aggregators.user();
const assistant = aggregators.assistant();

user.eventHandler(
  "on_user_turn_started",
  async (_aggregator, strategy: BaseUserTurnStartStrategy) => {
    console.log(`user turn started (${strategy.name})`);
  },
);

user.eventHandler(
  "on_user_turn_stopped",
  async (_aggregator, strategy: BaseUserTurnStopStrategy, message: UserTurnStoppedMessage) => {
    console.log(`user said "${message.content}" (${strategy.name}, from ${message.timestamp})`);
  },
);

// The text written to the context, in cascade and realtime mode alike.
user.eventHandler(
  "on_user_turn_message_added",
  async (_aggregator, message: UserTurnMessageAddedMessage) => {
    console.log(`added to context: ${message.content}`);
  },
);

assistant.eventHandler(
  "on_assistant_turn_stopped",
  async (_aggregator, message: AssistantTurnStoppedMessage) => {
    console.log(`bot said "${message.content}" (interrupted: ${message.interrupted})`);
  },
);

const aggregators = new LLMContextAggregatorPair(context, {
  userParams: new LLMUserAggregatorParams({
    vadAnalyzer: new SileroVADAnalyzer(),
    userIdleTimeout: 8.0, // seconds of silence after the bot stops speaking
  }),
});
const user = aggregators.user();

let idleCount = 0;

user.eventHandler("on_user_turn_idle", async (aggregator: LLMUserAggregator) => {
  idleCount += 1;
  if (idleCount === 1) {
    await aggregator.pushFrame(
      new LLMMessagesAppendFrame({
        messages: [
          { role: "developer", content: "The user has been quiet. Ask if they're still there." },
        ],
        runLlm: true,
      }),
    );
  } else if (idleCount === 2) {
    await aggregator.pushFrame(
      new LLMMessagesAppendFrame({
        messages: [
          {
            role: "developer",
            content: "The user is still quiet. Ask whether they'd like to continue.",
          },
        ],
        runLlm: true,
      }),
    );
  } else {
    await aggregator.pushFrame(new TTSSpeakFrame({ text: "I'll let you go. Goodbye!" }));
    await aggregator.pushFrame(new EndWorkerFrame());
  }
});

// Any user turn resets the count.
user.eventHandler("on_user_turn_started", async () => {
  idleCount = 0;
});

await worker.queueFrame(new UserIdleTimeoutUpdateFrame({ timeout: 15.0 })); // change or enable
await worker.queueFrame(new UserIdleTimeoutUpdateFrame({ timeout: 0 })); // disable

const worker = new PipelineWorker(pipeline); // enableTurnTracking defaults to true

worker.turnTrackingObserver?.eventHandler(
  "on_turn_started",
  async (_observer, turnNumber: number) => {
    console.log(`turn ${turnNumber} started`);
  },
);
worker.turnTrackingObserver?.eventHandler(
  "on_turn_ended",
  async (_observer, turnNumber: number, duration: number, wasInterrupted: boolean) => {
    console.log(`turn ${turnNumber}: ${duration.toFixed(2)}s, interrupted: ${wasInterrupted}`);
  },
);

const turns = new TurnTrackingObserver({ turnEndTimeoutSecs: 3.5 });
const worker = new PipelineWorker(pipeline, {
  observers: [turns],
  enableTurnTracking: false, // or the worker adds a second, default observer
});

const latency = new UserBotLatencyObserver();

latency.eventHandler("on_latency_measured", async (_observer, seconds: number) => {
  console.log(`user stopped -> bot started: ${seconds.toFixed(3)}s`);
});
latency.eventHandler("on_first_bot_speech_latency", async (_observer, seconds: number) => {
  console.log(`client connected -> first bot speech: ${seconds.toFixed(3)}s`);
});
// The per-service figures need enableMetrics.
latency.eventHandler("on_latency_breakdown", async (_observer, breakdown: LatencyBreakdown) => {
  for (const line of breakdown.turnContributionLines()) console.log(line);
});

const worker = new PipelineWorker(pipeline, {
  params: new PipelineParams({ enableMetrics: true }),
  observers: [latency],
});

0.200s  endpointing wait     [config: VAD stop_secs]
0.125s  transcription        [DeepgramSTTService#0]
0.336s  LLM inference        [OpenAILLMService#0]
0.359s  speech synthesis     [CartesiaTTSService#0]
1.020s  TOTAL