title: string;

status: "pass" | "fail";

details: string;

rttMs?: number;

requestStartedAt?: string;

responseObservedAt?: string;

sentMessageId?: number;

responseMessageId?: number;

};

type TelegramQaCanaryPhase = "sut_reply_timeout" | "sut_reply_not_threaded" | "sut_reply_empty";

};

params.observedMessages.push(observedMessage);

if (matchedScenario) {

return { message: observedMessage, nextOffset: offset };

return { message: observedMessage, nextOffset: offset, observedAtMs: Date.now() };

}

}

}

lines.push("");

lines.push(`- Status: ${scenario.status}`);

lines.push(`- Details: ${scenario.details}`);

if (scenario.rttMs !== undefined) {

lines.push(`- RTT: ${scenario.rttMs}ms`);

}

lines.push("");

}

if (params.cleanupIssues.length > 0) {

observedMessages: TelegramObservedMessage[];

}) {

const offset = await flushTelegramUpdates(params.driverToken);

const requestStartedAtMs = Date.now();

const driverMessage = await sendGroupMessage(

params.driverToken,

params.groupId,

`/help@${params.sutUsername}`,

);

const requestStartedAt = new Date(requestStartedAtMs).toISOString();

let firstUnthreadedReply:

| Pick<TelegramObservedMessage, "messageId" | "replyToMessageId" | "text">

| undefined;

},

);

}

return {

requestStartedAt,

responseObservedAt: new Date(sutObserved.observedAtMs).toISOString(),

rttMs: sutObserved.observedAtMs - requestStartedAtMs,

sentMessageId: driverMessage.message_id,

responseMessageId: sutObserved.message.messageId,

};

}

function canaryFailureMessage(params: {

assertLeaseHealthy();

try {

writeTelegramQaProgress(progressEnabled, "canary start");

await runCanary({

const canaryTiming = await runCanary({

driverToken: runtimeEnv.driverToken,

groupId: runtimeEnv.groupId,

sutUsername,

sutBotId: sutIdentity.id,

observedMessages,

});

scenarioResults.push({

id: "telegram-canary",

title: "Telegram canary",

status: "pass",

details: redactPublicMetadata

? `reply matched in ${canaryTiming.rttMs}ms`

: `reply message ${canaryTiming.responseMessageId} matched in ${canaryTiming.rttMs}ms`,

rttMs: canaryTiming.rttMs,

requestStartedAt: canaryTiming.requestStartedAt,

responseObservedAt: canaryTiming.responseObservedAt,

sentMessageId: redactPublicMetadata ? undefined : canaryTiming.sentMessageId,

responseMessageId: redactPublicMetadata ? undefined : canaryTiming.responseMessageId,

});

writeTelegramQaProgress(progressEnabled, "canary pass");

} catch (error) {

canaryFailure = canaryFailureMessage({

assertLeaseHealthy();

const scenarioRun = scenario.buildRun(sutUsername);

try {

const requestStartedAtMs = Date.now();

const sent = await sendGroupMessage(

runtimeEnv.driverToken,

runtimeEnv.groupId,

scenarioRun.input,

);

const requestStartedAt = new Date(requestStartedAtMs).toISOString();

const matched = await waitForObservedMessage({

token: runtimeEnv.driverToken,

initialOffset: driverOffset,

expectedTextIncludes: scenarioRun.expectedTextIncludes,

message: matched.message,

});

const rttMs = matched.observedAtMs - requestStartedAtMs;

const result = {

id: scenario.id,

title: scenario.title,

status: "pass",

details: redactPublicMetadata

? "reply matched"

: `reply message ${matched.message.messageId} matched`,

? `reply matched in ${rttMs}ms`

: `reply message ${matched.message.messageId} matched in ${rttMs}ms`,

rttMs,

requestStartedAt,

responseObservedAt: new Date(matched.observedAtMs).toISOString(),

sentMessageId: redactPublicMetadata ? undefined : sent.message_id,

responseMessageId: redactPublicMetadata ? undefined : matched.message.messageId,

} satisfies TelegramQaScenarioResult;

scenarioResults.push(result);

writeTelegramQaProgress(

sanitizeTelegramQaProgressValue,

shouldLogTelegramQaLiveProgress,

formatTelegramQaProgressDetails,

renderTelegramQaMarkdown,

};