Skip to content

Commit db41c18

Browse files
test: takeover tests for #25754 message loading speedups
Takeover's tests for the PR: one test per latency fix. - ws.test.ts: a resume replay sends only the newest streaming message.updated, in order, before the synchronized marker and live tail. - threadCommands.test.ts: Send dispatches while an earlier-history load on the same thread is pending. - authorization/layer.test.ts: a cold direct bearer prepare through the real resolver makes one descriptor GET and one ticket request; a warm prepare whose fresh descriptor changes identity is blocked. Main's TTL-cache test now expects a fresh descriptor per authorization. Drops the hardcoded byte-count transport test, the protocol, cached and renewed DPoP variants, and the remotePerformance.bench.ts additions. Co-Authored-By: Claude Opus 5.5 <[email protected]>
1 parent 277e236 commit db41c18

4 files changed

Lines changed: 98 additions & 454 deletions

File tree

‎apps/server/src/orchestration-v2/ThreadTransportPerformance.test.ts‎

Lines changed: 2 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
import {
22
EventId,
3-
MessageId,
43
OrchestrationV2RpcSchemas,
54
ThreadId,
65
TurnItemId,
@@ -14,7 +13,6 @@ import type * as RpcMessage from "effect/rpc/RpcMessage";
1413
import { describe, expect, it } from "vite-plus/test";
1514

1615
import { projectDomainEventForWire } from "./WireProjection.ts";
17-
import { coalesceLiveUpdatedEvents } from "./ThreadLiveEventCoalescer.ts";
1816

1917
const OUTPUT_BYTES_PER_ROW = 8_192;
2018
const NOW = DateTime.makeUnsafe("2026-06-20T00:00:00.000Z");
@@ -31,14 +29,11 @@ function encodedBytes(value: unknown): number {
3129
return Buffer.byteLength(JSON.stringify(value), "utf8");
3230
}
3331

34-
function encodedThreadStreamChunkBytes(
35-
value: OrchestrationV2ThreadStreamItem,
36-
...values: ReadonlyArray<OrchestrationV2ThreadStreamItem>
37-
): number {
32+
function encodedThreadStreamChunkBytes(value: OrchestrationV2ThreadStreamItem): number {
3833
const response = {
3934
_tag: "Chunk",
4035
requestId: 0,
41-
values: [encodeThreadStreamItem(value), ...values.map((item) => encodeThreadStreamItem(item))],
36+
values: [encodeThreadStreamItem(value)],
4237
} satisfies RpcMessage.ResponseChunkEncoded;
4338
return encodedBytes(response);
4439
}
@@ -77,45 +72,6 @@ function makeTurnItemEvent(item: OrchestrationV2TurnItem): OrchestrationV2Domain
7772
}
7873

7974
describe("thread transport payload budget", () => {
80-
it("sends only the newest growing message when coalescing a reconnect replay", () => {
81-
const replay = Array.from({ length: 64 }, (_, index) => {
82-
const sequence = index + 1;
83-
return {
84-
kind: "event",
85-
sequence,
86-
event: {
87-
id: EventId.make(`event-${sequence}`),
88-
type: "message.updated",
89-
threadId: THREAD_ID,
90-
occurredAt: NOW,
91-
payload: {
92-
id: MessageId.make("message-perf"),
93-
threadId: THREAD_ID,
94-
runId: null,
95-
nodeId: null,
96-
createdBy: "agent",
97-
creationSource: "provider",
98-
role: "assistant",
99-
text: "x".repeat(sequence * 256),
100-
attachments: [],
101-
streaming: true,
102-
createdAt: NOW,
103-
updatedAt: NOW,
104-
},
105-
},
106-
} satisfies Extract<OrchestrationV2ThreadStreamItem, { readonly kind: "event" }>;
107-
});
108-
const coalesced = coalesceLiveUpdatedEvents(replay);
109-
const beforeBytes = encodedThreadStreamChunkBytes(replay[0]!, ...replay.slice(1));
110-
const afterBytes = encodedThreadStreamChunkBytes(coalesced[0]!, ...coalesced.slice(1));
111-
112-
expect(coalesced).toEqual([replay.at(-1)]);
113-
expect(coalesced[0]?.sequence).toBe(64);
114-
expect(beforeBytes).toBe(559_383);
115-
expect(afterBytes).toBe(16_845);
116-
expect(afterBytes / beforeBytes).toBeLessThan(0.04);
117-
});
118-
11975
it("omits command output from a live event without changing persisted source data", () => {
12076
const sourceItem = makeCommandItem(0);
12177
const sourceEvent = makeTurnItemEvent(sourceItem);

‎packages/client-runtime/src/authorization/layer.test.ts‎

Lines changed: 78 additions & 138 deletions
Original file line numberDiff line numberDiff line change
@@ -19,11 +19,11 @@ import * as RpcHttp from "../rpc/http.ts";
1919
import * as ClientCapabilities from "../platform/capabilities.ts";
2020
import * as RemoteEnvironmentAuthorization from "./service.ts";
2121
import * as TokenStore from "./tokenStore.ts";
22-
import * as ConnectionResolver from "../connection/resolver.ts";
23-
import * as ConnectionProfileStore from "../connection/profileStore.ts";
24-
import * as ConnectionCredentialStore from "../connection/credentialStore.ts";
2522
import { BearerConnectionCredential, BearerConnectionProfile } from "../connection/catalog.ts";
23+
import * as ConnectionCredentialStore from "../connection/credentialStore.ts";
2624
import { BearerConnectionTarget } from "../connection/model.ts";
25+
import * as ConnectionProfileStore from "../connection/profileStore.ts";
26+
import * as ConnectionResolver from "../connection/resolver.ts";
2727

2828
const ENVIRONMENT_ID = EnvironmentId.make("environment-1");
2929
const ENDPOINT = {
@@ -52,17 +52,12 @@ const BOOTSTRAP: RelayEnvironmentConnectResponse = {
5252

5353
type RecordedResponse = Response | ((init: RequestInit) => Response);
5454

55-
function recordedFetch(
56-
responses:
57-
| ReadonlyArray<RecordedResponse>
58-
| ((input: RequestInfo | URL, init: RequestInit) => Response),
59-
) {
55+
function recordedFetch(responses: ReadonlyArray<RecordedResponse>) {
6056
const calls: Array<readonly [RequestInfo | URL, RequestInit]> = [];
6157
let responseIndex = 0;
6258
const fetchFn = ((input, init) => {
6359
calls.push([input, init ?? {}]);
64-
const response =
65-
typeof responses === "function" ? responses(input, init ?? {}) : responses[responseIndex++];
60+
const response = responses[responseIndex++];
6661
return response === undefined
6762
? Promise.reject(new Error(`Unexpected fetch call to ${String(input)}`))
6863
: Promise.resolve(typeof response === "function" ? response(init ?? {}) : response);
@@ -116,7 +111,7 @@ const persistedToken = (
116111

117112
const makeHarness = Effect.fn("TestRemoteAuthorization.makeHarness")(function* (input: {
118113
readonly initialToken?: TokenStore.RemoteDpopAccessToken;
119-
readonly responses: Parameters<typeof recordedFetch>[0];
114+
readonly responses: ReadonlyArray<RecordedResponse>;
120115
readonly bootstrap?: RelayEnvironmentConnectResponse;
121116
readonly beforeBootstrap?: Effect.Effect<void, ManagedRelay.ManagedRelayClientError>;
122117
readonly beforePut?: Effect.Effect<void>;
@@ -239,29 +234,29 @@ const makeHarness = Effect.fn("TestRemoteAuthorization.makeHarness")(function* (
239234
};
240235
});
241236

242-
const makeResolverHarness = Effect.fn("TestRemoteAuthorization.makeResolverHarness")(function* (
243-
responses: Parameters<typeof recordedFetch>[0],
244-
options?: {
245-
readonly authorization?: "t3-connect";
246-
readonly initialToken?: TokenStore.RemoteDpopAccessToken;
247-
readonly bootstrap?: RelayEnvironmentConnectResponse;
248-
},
237+
const prepareDirectBearer = Effect.fn("TestRemoteAuthorization.prepareDirectBearer")(function* (
238+
harness: Effect.Success<ReturnType<typeof makeHarness>>,
239+
times: number,
249240
) {
250-
const harness = yield* makeHarness({ ...options, responses });
251241
const target = new BearerConnectionTarget({
252242
environmentId: ENVIRONMENT_ID,
253243
label: DESCRIPTOR.label,
254244
connectionId: "direct-1",
255245
});
256-
const profile = new BearerConnectionProfile({
257-
connectionId: target.connectionId,
258-
environmentId: target.environmentId,
259-
label: target.label,
260-
httpBaseUrl: ENDPOINT.httpBaseUrl,
261-
wsBaseUrl: ENDPOINT.wsBaseUrl,
262-
...(options?.authorization === undefined ? {} : { authorization: options.authorization }),
263-
});
264-
const unused = () => Effect.die("Unexpected connection store or SSH operation");
246+
const entry = {
247+
target,
248+
profile: Option.some(
249+
new BearerConnectionProfile({
250+
connectionId: target.connectionId,
251+
environmentId: ENVIRONMENT_ID,
252+
label: target.label,
253+
httpBaseUrl: ENDPOINT.httpBaseUrl,
254+
wsBaseUrl: ENDPOINT.wsBaseUrl,
255+
}),
256+
),
257+
enabled: true,
258+
};
259+
const unused = () => Effect.die("unused");
265260
const layer = ConnectionResolver.layer.pipe(
266261
Layer.provide(
267262
Layer.mergeAll(
@@ -287,75 +282,74 @@ const makeResolverHarness = Effect.fn("TestRemoteAuthorization.makeResolverHarne
287282
),
288283
),
289284
);
290-
return { ...harness, layer, entry: { target, profile: Option.some(profile), enabled: true } };
285+
const resolver = yield* ConnectionResolver.ConnectionResolver.pipe(Effect.provide(layer));
286+
return yield* Effect.forEach(Array.from({ length: times }), () =>
287+
resolver.prepare(entry).pipe(Effect.result),
288+
);
291289
});
292290

293291
describe("RemoteEnvironmentAuthorization", () => {
294-
it.effect("uses one fresh descriptor GET for a cold direct bearer prepare", () =>
292+
it.effect("prepares a cold direct bearer connection with one descriptor request", () =>
295293
Effect.gen(function* () {
296-
const descriptor = {
297-
...DESCRIPTOR,
298-
orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
299-
};
300-
const harness = yield* makeResolverHarness((url) =>
301-
String(url).endsWith("/.well-known/t3/environment")
302-
? Response.json(descriptor)
303-
: websocketTicket("cold-ticket"),
304-
);
305-
const prepared = yield* Effect.gen(function* () {
306-
const resolver = yield* ConnectionResolver.ConnectionResolver;
307-
return yield* resolver.prepare(harness.entry);
308-
}).pipe(Effect.provide(harness.layer));
294+
const harness = yield* makeHarness({
295+
responses: [
296+
Response.json({
297+
...DESCRIPTOR,
298+
orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
299+
}),
300+
websocketTicket("cold-ticket"),
301+
],
302+
});
309303

310-
expect(prepared.socketUrl).toContain("wsTicket=cold-ticket");
311-
expect(prepared).not.toHaveProperty("descriptor");
312-
expect(
313-
harness.fetch.calls
314-
.filter(([url]) => String(url).endsWith("/.well-known/t3/environment"))
315-
.map(([, init]) => init.method ?? "GET"),
316-
).toEqual(["GET"]);
304+
const [prepared] = yield* prepareDirectBearer(harness, 1);
305+
306+
expect(prepared).toMatchObject({
307+
_tag: "Success",
308+
success: { socketUrl: expect.stringContaining("wsTicket=cold-ticket") },
309+
});
310+
expect(harness.fetch.calls.map(([url]) => new URL(String(url)).pathname)).toEqual([
311+
"/.well-known/t3/environment",
312+
"/api/auth/websocket-ticket/rpc",
313+
]);
317314
}),
318315
);
319316

320-
it.effect.each([
321-
{
322-
name: "identity",
323-
environmentId: EnvironmentId.make("another-environment"),
324-
reason: "configuration",
325-
},
326-
{ name: "protocol", orchestrationProtocolVersion: 0, reason: "unsupported" },
327-
])("checks fresh $name data on a warm direct bearer prepare", (change) =>
317+
it.effect("blocks a warm direct bearer prepare when the environment changes identity", () =>
328318
Effect.gen(function* () {
329-
let descriptor = {
330-
...DESCRIPTOR,
331-
orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
332-
};
333-
const harness = yield* makeResolverHarness((url) =>
334-
String(url).endsWith("/.well-known/t3/environment")
335-
? Response.json(descriptor)
336-
: websocketTicket("warm-ticket"),
337-
);
338-
yield* Effect.gen(function* () {
339-
const resolver = yield* ConnectionResolver.ConnectionResolver;
340-
yield* resolver.prepare(harness.entry);
341-
descriptor = { ...descriptor, ...change };
342-
const failure = yield* resolver.prepare(harness.entry).pipe(Effect.flip);
343-
expect(failure).toMatchObject({
344-
_tag: "ConnectionBlockedError",
345-
reason: change.reason,
346-
});
347-
}).pipe(Effect.provide(harness.layer));
319+
const harness = yield* makeHarness({
320+
responses: [
321+
Response.json({
322+
...DESCRIPTOR,
323+
orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
324+
}),
325+
websocketTicket("first-ticket"),
326+
Response.json({
327+
...DESCRIPTOR,
328+
environmentId: "another-environment",
329+
orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
330+
}),
331+
websocketTicket("second-ticket"),
332+
],
333+
});
334+
335+
const [first, second] = yield* prepareDirectBearer(harness, 2);
336+
337+
expect(first?._tag).toBe("Success");
338+
expect(second).toMatchObject({
339+
_tag: "Failure",
340+
failure: { _tag: "ConnectionBlockedError", reason: "configuration" },
341+
});
348342
}),
349343
);
350-
351-
it.effect("fetches a fresh bearer descriptor while issuing fresh websocket tickets", () =>
344+
it.effect("validates a fresh bearer descriptor while issuing fresh websocket tickets", () =>
352345
Effect.gen(function* () {
353-
let ticketCount = 0;
354346
const harness = yield* makeHarness({
355-
responses: (url) =>
356-
String(url).endsWith("/.well-known/t3/environment")
357-
? Response.json(DESCRIPTOR)
358-
: websocketTicket(++ticketCount === 1 ? "first-ticket" : "second-ticket"),
347+
responses: [
348+
Response.json(DESCRIPTOR),
349+
websocketTicket("first-ticket"),
350+
Response.json(DESCRIPTOR),
351+
websocketTicket("second-ticket"),
352+
],
359353
});
360354

361355
const [first, second] = yield* Effect.gen(function* () {
@@ -384,60 +378,6 @@ describe("RemoteEnvironmentAuthorization", () => {
384378
}),
385379
);
386380

387-
it.effect.each(["cached", "renewed"] as const)(
388-
"uses one fresh direct descriptor with a %s DPoP token and permits old-host updates",
389-
(tokenState) =>
390-
Effect.gen(function* () {
391-
const directDescriptor = { ...DESCRIPTOR, orchestrationProtocolVersion: 0 };
392-
const relayHttpBaseUrl = "https://relay-route.example.test";
393-
const harness = yield* makeResolverHarness(
394-
(url) => {
395-
const endpoint = String(url);
396-
if (endpoint.endsWith("/.well-known/t3/environment")) {
397-
return Response.json(
398-
endpoint.startsWith(ENDPOINT.httpBaseUrl)
399-
? directDescriptor
400-
: { ...DESCRIPTOR, orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION },
401-
);
402-
}
403-
return endpoint.endsWith("/oauth/token")
404-
? accessToken("renewed-token")
405-
: websocketTicket("direct-ticket");
406-
},
407-
{
408-
authorization: "t3-connect",
409-
...(tokenState === "cached" ? { initialToken: persistedToken() } : {}),
410-
bootstrap: {
411-
...BOOTSTRAP,
412-
endpoint: {
413-
...ENDPOINT,
414-
httpBaseUrl: relayHttpBaseUrl,
415-
wsBaseUrl: "wss://relay-route.example.test",
416-
},
417-
},
418-
},
419-
);
420-
yield* Effect.gen(function* () {
421-
const resolver = yield* ConnectionResolver.ConnectionResolver;
422-
const { prepared, descriptor } = yield* resolver.prepareForUpdate(harness.entry);
423-
expect(descriptor).toMatchObject(directDescriptor);
424-
expect(prepared.socketUrl).toContain("wsTicket=direct-ticket");
425-
expect(prepared.httpBaseUrl).toBe(ENDPOINT.httpBaseUrl);
426-
expect(prepared).not.toHaveProperty("descriptor");
427-
expect(
428-
harness.fetch.calls.filter(
429-
([url]) => String(url) === `${ENDPOINT.httpBaseUrl}/.well-known/t3/environment`,
430-
),
431-
).toHaveLength(1);
432-
expect(yield* resolver.prepare(harness.entry).pipe(Effect.flip)).toMatchObject({
433-
_tag: "ConnectionBlockedError",
434-
reason: "unsupported",
435-
});
436-
}).pipe(Effect.provide(harness.layer));
437-
expect(yield* Ref.get(harness.bootstrapCalls)).toBe(tokenState === "cached" ? 0 : 1);
438-
}),
439-
);
440-
441381
it.effect("reuses a same-account persisted environment token without contacting the relay", () =>
442382
Effect.gen(function* () {
443383
const cached = new TokenStore.RemoteDpopAccessToken({

0 commit comments

Comments
 (0)