Skip to content
TypeScript

fix(server): avoid message ordering scans during recovery and settlement (#30582)

Yash Singh647bd148b3fb
diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.ts
index 010b62bf022..b4bdbd705c2 100644
--- a/apps/server/src/orchestration-v2/Orchestrator.ts
+++ b/apps/server/src/orchestration-v2/Orchestrator.ts
@@ -3331,16 +3331,19 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
}
}
if (command.type === "thread.settle") {
- const projection = yield* loadProjectionForCommand(
- command,
- ["runs", "runtimeRequests", "messages"],
- { turnItemTypes: [], messageRoles: ["user"] },
- );
+ const projection = yield* loadProjectionForCommand(command, ["runs", "runtimeRequests"]);
+ const queuedMessages = yield* projectionStore
+ .getMessagesById(
+ command.threadId,
+ projection.runs.filter((run) => run.status === "queued").map((run) => run.userMessageId),
+ )
+ .pipe(mapDispatchError(command));
const automaticMessageIds = new Set(
- projection.messages
+ [...queuedMessages.values()]
.filter(
(message) =>
- message.notification !== undefined || message.delegatedCompletion !== undefined,
+ message.role === "user" &&
+ (message.notification !== undefined || message.delegatedCompletion !== undefined),
)
.map((message) => message.id),
);
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.test.ts b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
index 9d412e498c4..c6187a97ea8 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.test.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
@@ -282,6 +282,27 @@ it.effect("routes full projection reads to readers and retains uncommitted write
forkedFrom: { type: "run", threadId: parentId, runId: parent.runs[0]!.id },
},
});
+ const messageId = MessageId.make("message:reader-routing");
+ yield* store.apply({
+ id: EventId.make("event:reader-routing:message"),
+ type: "message.updated",
+ threadId,
+ occurredAt: parent.thread.createdAt,
+ payload: {
+ id: messageId,
+ threadId,
+ runId: null,
+ nodeId: null,
+ role: "user",
+ text: "Committed message",
+ attachments: [],
+ streaming: false,
+ createdBy: "user",
+ creationSource: "web",
+ createdAt: parent.thread.createdAt,
+ updatedAt: parent.thread.createdAt,
+ },
+ });
const { queries, trace } = traceSqlRouting();
yield* store.getAgentAwarenessSnapshot().pipe(trace);
const projection = yield* store.getThreadProjection(threadId).pipe(trace);
@@ -292,6 +313,10 @@ it.effect("routes full projection reads to readers and retains uncommitted write
.map((row) => row.sourceItemId),
parent.turnItems.map((item) => item.id),
);
+ assert.equal(
+ (yield* store.getMessagesById(threadId, [messageId]).pipe(trace)).get(messageId)?.text,
+ "Committed message",
+ );
assert.isAbove(queries.length, 1);
assert.deepEqual([...new Set(queries.map((row) => row.connection))], ["reader"]);
const commitRequested = yield* Deferred.make<void>();
@@ -343,6 +368,15 @@ it.effect("routes full projection reads to readers and retains uncommitted write
SET payload_json = json_set(payload_json, '$.title', 'Uncommitted title')
WHERE thread_id = ${threadId}
`;
+ yield* sql`
+ UPDATE orchestration_v2_projection_messages
+ SET payload_json = json_set(payload_json, '$.text', 'Uncommitted message')
+ WHERE message_id = ${messageId}
+ `;
+ assert.equal(
+ (yield* store.getMessagesById(threadId, [messageId])).get(messageId)?.text,
+ "Uncommitted message",
+ );
assert.equal(
(yield* store.getAgentAwarenessSnapshot()).threads.find(
(thread) => thread.id === threadId,
@@ -2638,10 +2672,28 @@ it.layer(layerTest)("ProjectionStoreV2", (it) => {
);
yield* insertMessageItem("null-id", threadId, -2, null);
yield* insertMessageItem("missing-id", threadId, -3, undefined);
+ const absentMessageId = MessageId.make("message:bounded-sql-history:absent");
+ const messageReadTrace = traceSqlStatements();
+ const selected = yield* projectionStore
+ .getMessagesById(threadId, [firstMessageId, lastMessageId, firstMessageId, absentMessageId])
+ .pipe(Effect.withTracer(messageReadTrace.tracer));
+ assert.isFalse(messageReadTrace.statements.some((query) => query.includes("turn_items")));
+ assert.equal(selected.size, 2);
+ assert.equal(selected.get(firstMessageId)?.id, firstMessageId);
+ assert.equal(selected.get(lastMessageId)?.id, lastMessageId);
+ assert.isFalse(selected.has(absentMessageId));
+ assert.equal((yield* projectionStore.getMessagesById(threadId, [])).size, 0);
+ assert.equal(
+ (yield* projectionStore.getMessagesById(ThreadId.make("other-thread"), [firstMessageId]))
+ .size,
+ 0,
+ );
const readMessageIds = (filter?: ProjectionStore.ProjectionRecordFilter) =>
projectionStore
.getThreadRecords(threadId, ["messages"], filter)
.pipe(Effect.map(({ messages }) => messages.map((message) => message.id)));
+ const canonical = yield* projectionStore.getThreadRecords(threadId, ["messages"]);
+ for (const message of canonical.messages) assert.deepEqual(selected.get(message.id), message);
assert.deepEqual(yield* readMessageIds(), [lastMessageId, firstMessageId]);
assert.deepEqual(yield* readMessageIds({ messageRoles: ["user", "assistant"] }), [
lastMessageId,
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.ts
index 5d03be7753d..b5a0f2cfb55 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.ts
@@ -473,6 +473,13 @@ export interface ProjectionStoreV2Shape {
readonly threadId: ThreadId;
readonly itemId: TurnItemId;
}) => Effect.Effect<OrchestrationV2TurnItem | null, ProjectionStoreV2Error>;
+ readonly getMessagesById: (
+ threadId: ThreadId,
+ messageIds: ReadonlyArray<MessageId>,
+ ) => Effect.Effect<
+ ReadonlyMap<MessageId, OrchestrationV2ConversationMessage>,
+ ProjectionStoreV2Error
+ >;
readonly getThreadRecords: <K extends ProjectionRecordField>(
threadId: ThreadId,
fields: ReadonlyArray<K>,
@@ -5563,6 +5570,23 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
Effect.mapError((cause) => new ProjectionStoreReadError({ threadId, cause })),
);
+ const getMessagesById = Effect.fn("ProjectionStore.getMessagesById")(
+ function* (threadId: ThreadId, messageIds: ReadonlyArray<MessageId>) {
+ if (messageIds.length === 0)
+ return new Map<MessageId, OrchestrationV2ConversationMessage>();
+ const rows = yield* sql<PayloadRow>`
+ SELECT message.payload_json
+ FROM json_each(${encodeIdList([...new Set(messageIds)])}) AS requested
+ CROSS JOIN orchestration_v2_projection_messages AS message
+ ON message.message_id = requested.value
+ WHERE message.thread_id = ${threadId}
+ `;
+ const messages = yield* decodeRows(decodeMessagePayload, threadId)(rows);
+ return new Map(messages.map((message) => [message.id, message]));
+ },
+ (effect, threadId) => effect.pipe(Effect.mapError(controlReadError(threadId))),
+ );
+
const getThreadRecords: ProjectionStoreV2Shape["getThreadRecords"] = (
threadId,
fields,
@@ -7385,6 +7409,7 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
listAppOwnedChildThreadIds: readOnReader(listAppOwnedChildThreadIds),
getNextTurnItemOrdinal: readOnReader(getNextTurnItemOrdinal),
getTurnItem: readOnReader(getTurnItem),
+ getMessagesById: readOnReader(getMessagesById),
getThreadRecords: (threadId, fields, filter) =>
getThreadRecords(threadId, fields, filter).pipe(NodeSqliteClient.readOnly),
getRuntimeRequest: readOnReader(getRuntimeRequest),
diff --git a/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.test.ts b/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.test.ts
index d300cf59ca3..28f1df58a6b 100644
--- a/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.test.ts
@@ -601,6 +601,16 @@ it.effect.each([
Layer.mock(ProjectionStore.ProjectionStoreV2)({
getRecoveryThreadIds: () => Effect.succeed([threadId]),
getRuntimeRecoveryProjection: () => Effect.succeed(projection),
+ getMessagesById: (requestedThreadId, messageIds) =>
+ Effect.succeed(
+ new Map(
+ projection.messages
+ .filter(
+ (message) => requestedThreadId === threadId && messageIds.includes(message.id),
+ )
+ .map((message) => [message.id, message]),
+ ),
+ ),
getThreadRecords: () => Effect.succeed(projection),
}),
Layer.mock(EventSink.EventSinkV2)({
diff --git a/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.ts b/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.ts
index fa6298ce3f5..5abaab7f122 100644
--- a/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.ts
+++ b/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.ts
@@ -342,20 +342,23 @@ export const make = Effect.gen(function* () {
const queuedMessages =
pendingRuns.length === 0
? []
- : (yield* projections
- .getThreadRecords(projection.thread.id, ["messages"], {
- messageIds: pendingRuns.map((run) => run.userMessageId),
- })
- .pipe(
- Effect.mapError(
- (cause) =>
- new ProviderRuntimeRecoveryError({
- operation: "read-projections",
- threadId: projection.thread.id,
- cause,
- }),
- ),
- )).messages;
+ : [
+ ...(yield* projections
+ .getMessagesById(
+ projection.thread.id,
+ pendingRuns.map((run) => run.userMessageId),
+ )
+ .pipe(
+ Effect.mapError(
+ (cause) =>
+ new ProviderRuntimeRecoveryError({
+ operation: "read-projections",
+ threadId: projection.thread.id,
+ cause,
+ }),
+ ),
+ )).values(),
+ ];
const bufferedMessageIds = new Set(
queuedMessages.filter(isBufferedProviderNotification).map((message) => message.id),
);
diff --git a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts
index 63cb35749b4..ad5341dd99e 100644
--- a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts
@@ -241,6 +241,7 @@ it.effect(
listAppOwnedChildThreadIds: () => Effect.die("unused listAppOwnedChildThreadIds"),
getNextTurnItemOrdinal: () => Effect.die("unused ordinal read"),
getTurnItem: () => Effect.die("unused turn item read"),
+ getMessagesById: () => Effect.die("unused getMessagesById"),
getThreadRecords: () => Effect.die("unused record read"),
getRuntimeRequest: () => Effect.die("unused getRuntimeRequest"),
getRunningTurnContext: () => Effect.die("unused getRunningTurnContext"),