@zakstam/codex-local-component 0.2.1 → 0.3.0

package/dist/component/syncIngest.js

@@ -1,727 +1,11 @@
-import { makeFunctionReference } from "convex/server";
-import { authzError, now, requireThreadForActor, requireTurnForActor } from "./utils.js";
-import { parseDurableMessageDeltaEvent, parseDurableMessageEvent, parseApprovalRequest, parseApprovalResolution, pickHigherPriorityTerminalStatus, terminalStatusForEvent, } from "./syncHelpers.js";
-import { CLEANUP_SWEEP_MIN_INTERVAL_MS, DELTA_EVENT_KINDS, DELTA_TTL_MS, DEFAULT_STREAM_DELETE_BATCH_SIZE, HEARTBEAT_WRITE_MIN_INTERVAL_MS, LIFECYCLE_EVENT_KINDS, STALE_SWEEP_MIN_INTERVAL_MS, resolveRuntimeOptions, syncError, } from "./syncRuntime.js";
-import { addStreamDeltaStats, ensureStreamStat, setStreamStatState, } from "./streamStats.js";
-const RECOVERABLE_INGEST_CODES = new Set([
-    "E_SYNC_SESSION_NOT_FOUND",
-    "E_SYNC_SESSION_THREAD_MISMATCH",
-    "E_SYNC_SESSION_DEVICE_MISMATCH",
-]);
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function parseSyncErrorCode(error) {
-    const message = getErrorMessage(error);
-    const match = /^\[([A-Z0-9_]+)\]/.exec(message);
-    return match?.[1] ?? null;
-}
-function mapIngestSafeCode(rawCode) {
-    switch (rawCode) {
-        case "E_SYNC_SESSION_NOT_FOUND":
-            return "SESSION_NOT_FOUND";
-        case "E_SYNC_SESSION_THREAD_MISMATCH":
-            return "SESSION_THREAD_MISMATCH";
-        case "E_SYNC_SESSION_DEVICE_MISMATCH":
-            return "SESSION_DEVICE_MISMATCH";
-        case "E_SYNC_OUT_OF_ORDER":
-            return "OUT_OF_ORDER";
-        case "E_SYNC_REPLAY_GAP":
-            return "REPLAY_GAP";
-        default:
-            return "UNKNOWN";
-    }
-}
-function syntheticTurnStatusForEvent(kind, payloadJson) {
-    const terminal = terminalStatusForEvent(kind, payloadJson);
-    if (terminal?.status === "completed") {
-        return "completed";
-    }
-    if (terminal?.status === "interrupted") {
-        return "interrupted";
-    }
-    if (terminal?.status === "failed") {
-        return "failed";
-    }
-    if (kind === "turn/started" || kind.startsWith("item/")) {
-        return "inProgress";
-    }
-    return "queued";
-}
+import { ingestEvents } from "./ingest/index.js";
+import { upsertCheckpoint } from "./ingest/checkpoints.js";
+import { errorMessage, isRecoverableIngestErrorCode, mapIngestSafeCode, parseSyncErrorCode, upsertSessionHeartbeat, } from "./ingest/sessionGuard.js";
 export async function ingestHandler(ctx, args) {
-    await requireThreadForActor(ctx, args.actor, args.threadId);
-    const runtime = resolveRuntimeOptions(args.runtime);
-    const deltas = [...args.streamDeltas, ...args.lifecycleEvents];
-    deltas.sort((a, b) => a.createdAt - b.createdAt);
-    if (deltas.length === 0) {
-        syncError("E_SYNC_EMPTY_BATCH", "ingest received an empty delta batch");
-    }
-    const session = await ctx.db
-        .query("codex_sessions")
-        .withIndex("tenantId_sessionId", (q) => q.eq("tenantId", args.actor.tenantId).eq("sessionId", args.sessionId))
-        .first();
-    if (!session) {
-        syncError("E_SYNC_SESSION_NOT_FOUND", `No active session found for sessionId=${args.sessionId}`);
-    }
-    if (session.threadId !== args.threadId) {
-        syncError("E_SYNC_SESSION_THREAD_MISMATCH", `Session threadId=${session.threadId} does not match request threadId=${args.threadId}`);
-    }
-    if (session.deviceId !== args.actor.deviceId) {
-        syncError("E_SYNC_SESSION_DEVICE_MISMATCH", `Session deviceId=${session.deviceId} does not match actor deviceId=${args.actor.deviceId}`);
-    }
-    if (session.userId !== args.actor.userId) {
-        authzError("E_AUTH_SESSION_FORBIDDEN", `User ${args.actor.userId} is not allowed to access session ${args.sessionId}`);
-    }
-    let lastPersistedCursor = session.lastEventCursor;
-    let persistedAnyEvent = false;
-    const inBatchEventIds = new Set();
-    const knownTurnIds = new Set();
-    const startedTurns = new Set();
-    const terminalTurns = new Map();
-    const pendingApprovals = new Map();
-    const resolvedApprovals = new Map();
-    const messageOrderCacheByTurn = new Map();
-    const messageByKey = new Map();
-    const streamById = new Map();
-    const approvalByKey = new Map();
-    const persistedStatsByStreamId = new Map();
-    const streamCheckpointCursorByStreamId = new Map();
-    let ingestStatus = "ok";
-    const streamStats = await ctx.db
-        .query("codex_stream_stats")
-        .withIndex("tenantId_threadId", (q) => q.eq("tenantId", args.actor.tenantId).eq("threadId", args.threadId))
-        .take(500);
-    const expectedCursorByStreamId = new Map(streamStats.map((stat) => [String(stat.streamId), Number(stat.latestCursor)]));
-    const nextOrderForTurn = async (turnId) => {
-        const cached = messageOrderCacheByTurn.get(turnId);
-        if (cached !== undefined) {
-            messageOrderCacheByTurn.set(turnId, cached + 1);
-            return cached;
-        }
-        const lastMessage = await ctx.db
-            .query("codex_messages")
-            .withIndex("tenantId_threadId_turnId_orderInTurn", (q) => q
-            .eq("tenantId", args.actor.tenantId)
-            .eq("threadId", args.threadId)
-            .eq("turnId", turnId))
-            .order("desc")
-            .take(1);
-        const next = (lastMessage[0]?.orderInTurn ?? -1) + 1;
-        messageOrderCacheByTurn.set(turnId, next + 1);
-        return next;
-    };
-    const messageKey = (turnId, messageId) => `${args.actor.tenantId}:${args.threadId}:${turnId}:${messageId}`;
-    const approvalKey = (turnId, itemId) => `${args.actor.tenantId}:${args.threadId}:${turnId}:${itemId}`;
-    const getMessageRecord = async (turnId, messageId) => {
-        const key = messageKey(turnId, messageId);
-        if (messageByKey.has(key)) {
-            return messageByKey.get(key);
-        }
-        const existing = await ctx.db
-            .query("codex_messages")
-            .withIndex("tenantId_threadId_turnId_messageId", (q) => q
-            .eq("tenantId", args.actor.tenantId)
-            .eq("threadId", args.threadId)
-            .eq("turnId", turnId)
-            .eq("messageId", messageId))
-            .first();
-        const normalized = existing
-            ? {
-                _id: existing._id,
-                status: existing.status,
-                text: existing.text,
-            }
-            : null;
-        messageByKey.set(key, normalized);
-        return normalized;
-    };
-    const setMessageRecord = (turnId, messageId, value) => {
-        messageByKey.set(messageKey(turnId, messageId), value);
-    };
-    const getApprovalRecord = async (turnId, itemId) => {
-        const key = approvalKey(turnId, itemId);
-        if (approvalByKey.has(key)) {
-            return approvalByKey.get(key);
-        }
-        const existing = await ctx.db
-            .query("codex_approvals")
-            .withIndex("tenantId_threadId_turnId_itemId", (q) => q
-            .eq("tenantId", args.actor.tenantId)
-            .eq("threadId", args.threadId)
-            .eq("turnId", turnId)
-            .eq("itemId", itemId))
-            .first();
-        const normalized = existing
-            ? {
-                _id: existing._id,
-                status: existing.status,
-            }
-            : null;
-        approvalByKey.set(key, normalized);
-        return normalized;
-    };
-    const setApprovalRecord = (turnId, itemId, value) => {
-        approvalByKey.set(approvalKey(turnId, itemId), value);
-    };
-    const getStreamRecord = async (streamId) => {
-        if (streamById.has(streamId)) {
-            return streamById.get(streamId);
-        }
-        const stream = await ctx.db
-            .query("codex_streams")
-            .withIndex("tenantId_streamId", (q) => q.eq("tenantId", args.actor.tenantId).eq("streamId", streamId))
-            .first();
-        const normalized = stream
-            ? {
-                _id: stream._id,
-                turnId: stream.turnId,
-                state: { kind: stream.state.kind },
-            }
-            : null;
-        streamById.set(streamId, normalized);
-        return normalized;
-    };
-    const setStreamRecord = (streamId, value) => {
-        streamById.set(streamId, value);
-    };
-    for (const delta of deltas) {
-        const turnId = delta.turnId;
-        if (turnId && !knownTurnIds.has(turnId)) {
-            const existingTurn = await ctx.db
-                .query("codex_turns")
-                .withIndex("tenantId_threadId_turnId", (q) => q
-                .eq("tenantId", args.actor.tenantId)
-                .eq("threadId", args.threadId)
-                .eq("turnId", turnId))
-                .first();
-            if (!existingTurn) {
-                const syntheticStatus = syntheticTurnStatusForEvent(delta.kind, delta.payloadJson);
-                await ctx.db.insert("codex_turns", {
-                    tenantId: args.actor.tenantId,
-                    userId: args.actor.userId,
-                    threadId: args.threadId,
-                    turnId,
-                    status: syntheticStatus,
-                    idempotencyKey: `sync:${args.threadId}:${turnId}`,
-                    startedAt: now(),
-                    ...(syntheticStatus === "completed" ||
-                        syntheticStatus === "interrupted" ||
-                        syntheticStatus === "failed"
-                        ? { completedAt: now() }
-                        : {}),
-                });
-            }
-            else if (existingTurn.userId !== args.actor.userId) {
-                authzError("E_AUTH_TURN_FORBIDDEN", `User ${args.actor.userId} is not allowed to access turn ${turnId}`);
-            }
-            knownTurnIds.add(turnId);
-        }
-        if (turnId && delta.kind === "turn/started") {
-            startedTurns.add(turnId);
-        }
-        if (turnId) {
-            const terminal = terminalStatusForEvent(delta.kind, delta.payloadJson);
-            if (terminal) {
-                const current = terminalTurns.get(turnId);
-                terminalTurns.set(turnId, pickHigherPriorityTerminalStatus(current, terminal));
-            }
-            const approvalRequest = parseApprovalRequest(delta.kind, delta.payloadJson);
-            if (approvalRequest) {
-                pendingApprovals.set(`${turnId}:${approvalRequest.itemId}`, approvalRequest);
-            }
-            const approvalResolution = parseApprovalResolution(delta.kind, delta.payloadJson);
-            if (approvalResolution) {
-                resolvedApprovals.set(`${turnId}:${approvalResolution.itemId}`, approvalResolution);
-            }
-            const durableMessage = parseDurableMessageEvent(delta.kind, delta.payloadJson);
-            if (durableMessage) {
-                const existing = await getMessageRecord(turnId, durableMessage.messageId);
-                if (!existing) {
-                    const nextOrder = await nextOrderForTurn(turnId);
-                    const newId = await ctx.db.insert("codex_messages", {
-                        tenantId: args.actor.tenantId,
-                        userId: args.actor.userId,
-                        threadId: args.threadId,
-                        turnId,
-                        messageId: durableMessage.messageId,
-                        role: durableMessage.role,
-                        status: durableMessage.status,
-                        text: durableMessage.text,
-                        sourceItemType: durableMessage.sourceItemType,
-                        orderInTurn: nextOrder,
-                        payloadJson: durableMessage.payloadJson,
-                        ...(durableMessage.status === "failed" ? { error: "item failed" } : {}),
-                        createdAt: delta.createdAt,
-                        updatedAt: now(),
-                        ...(durableMessage.status !== "streaming" ? { completedAt: now() } : {}),
-                    });
-                    setMessageRecord(turnId, durableMessage.messageId, {
-                        _id: newId,
-                        status: durableMessage.status,
-                        text: durableMessage.text,
-                    });
-                }
-                else {
-                    const nextStatus = (() => {
-                        if (existing.status === "failed") {
-                            return "failed";
-                        }
-                        if (existing.status === "interrupted" && durableMessage.status !== "failed") {
-                            return "interrupted";
-                        }
-                        if (durableMessage.status === "streaming") {
-                            return existing.status;
-                        }
-                        return durableMessage.status;
-                    })();
-                    await ctx.db.patch(existing._id, {
-                        role: durableMessage.role,
-                        status: nextStatus,
-                        text: durableMessage.text,
-                        sourceItemType: durableMessage.sourceItemType,
-                        payloadJson: durableMessage.payloadJson,
-                        ...(nextStatus === "failed" ? { error: "item failed" } : {}),
-                        updatedAt: now(),
-                        ...(nextStatus !== "streaming" ? { completedAt: now() } : {}),
-                    });
-                    setMessageRecord(turnId, durableMessage.messageId, {
-                        ...existing,
-                        status: nextStatus,
-                        text: durableMessage.text,
-                    });
-                }
-            }
-            const durableDelta = parseDurableMessageDeltaEvent(delta.kind, delta.payloadJson);
-            if (durableDelta) {
-                const existing = await getMessageRecord(turnId, durableDelta.messageId);
-                if (!existing) {
-                    const nextOrder = await nextOrderForTurn(turnId);
-                    const messageId = await ctx.db.insert("codex_messages", {
-                        tenantId: args.actor.tenantId,
-                        userId: args.actor.userId,
-                        threadId: args.threadId,
-                        turnId,
-                        messageId: durableDelta.messageId,
-                        role: "assistant",
-                        status: "streaming",
-                        text: durableDelta.delta,
-                        sourceItemType: "agentMessage",
-                        orderInTurn: nextOrder,
-                        payloadJson: JSON.stringify({
-                            type: "agentMessage",
-                            id: durableDelta.messageId,
-                            text: durableDelta.delta,
-                        }),
-                        createdAt: delta.createdAt,
-                        updatedAt: now(),
-                    });
-                    setMessageRecord(turnId, durableDelta.messageId, {
-                        _id: messageId,
-                        status: "streaming",
-                        text: durableDelta.delta,
-                    });
-                }
-                else if (existing.status === "streaming") {
-                    const nextText = `${existing.text}${durableDelta.delta}`;
-                    await ctx.db.patch(existing._id, {
-                        text: nextText,
-                        payloadJson: JSON.stringify({
-                            type: "agentMessage",
-                            id: durableDelta.messageId,
-                            text: nextText,
-                        }),
-                        updatedAt: now(),
-                    });
-                    setMessageRecord(turnId, durableDelta.messageId, {
-                        ...existing,
-                        text: nextText,
-                    });
-                }
-            }
-        }
-        if (delta.type === "lifecycle_event") {
-            const existingLifecycle = await ctx.db
-                .query("codex_lifecycle_events")
-                .withIndex("tenantId_threadId_eventId", (q) => q
-                .eq("tenantId", args.actor.tenantId)
-                .eq("threadId", args.threadId)
-                .eq("eventId", delta.eventId))
-                .first();
-            if (!existingLifecycle) {
-                await ctx.db.insert("codex_lifecycle_events", {
-                    tenantId: args.actor.tenantId,
-                    threadId: args.threadId,
-                    eventId: delta.eventId,
-                    kind: delta.kind,
-                    payloadJson: delta.payloadJson,
-                    createdAt: delta.createdAt,
-                    ...(delta.turnId ? { turnId: delta.turnId } : {}),
-                });
-            }
-            continue;
-        }
-        const stream = await getStreamRecord(delta.streamId);
-        if (!stream) {
-            const streamId = await ctx.db.insert("codex_streams", {
-                tenantId: args.actor.tenantId,
-                threadId: args.threadId,
-                turnId: delta.turnId,
-                streamId: delta.streamId,
-                state: { kind: "streaming", lastHeartbeatAt: now() },
-                startedAt: now(),
-            });
-            setStreamRecord(delta.streamId, {
-                _id: streamId,
-                state: { kind: "streaming" },
-                turnId: delta.turnId,
-            });
-            await ensureStreamStat(ctx, {
-                tenantId: args.actor.tenantId,
-                threadId: args.threadId,
-                turnId: delta.turnId,
-                streamId: delta.streamId,
-                state: "streaming",
-            });
-        }
-        if (delta.cursorStart >= delta.cursorEnd) {
-            syncError("E_SYNC_INVALID_CURSOR_RANGE", `Invalid cursor range start=${delta.cursorStart} end=${delta.cursorEnd} for eventId=${delta.eventId}`);
-        }
-        const streamExpectedCursor = expectedCursorByStreamId.get(delta.streamId) ?? 0;
-        const existingStreamEvent = await ctx.db
-            .query("codex_stream_deltas_ttl")
-            .withIndex("tenantId_streamId_eventId", (q) => q
-            .eq("tenantId", args.actor.tenantId)
-            .eq("streamId", delta.streamId)
-            .eq("eventId", delta.eventId))
-            .first();
-        if (existingStreamEvent) {
-            expectedCursorByStreamId.set(delta.streamId, Math.max(streamExpectedCursor, Number(existingStreamEvent.cursorEnd)));
-            streamCheckpointCursorByStreamId.set(delta.streamId, Math.max(streamCheckpointCursorByStreamId.get(delta.streamId) ?? 0, Number(existingStreamEvent.cursorEnd)));
-            continue;
-        }
-        if (delta.cursorStart < streamExpectedCursor) {
-            syncError("E_SYNC_OUT_OF_ORDER", `Expected cursorStart>=${streamExpectedCursor} for streamId=${delta.streamId} but got ${delta.cursorStart} for eventId=${delta.eventId}`);
-        }
-        if (delta.cursorStart > streamExpectedCursor) {
-            ingestStatus = "partial";
-        }
-        if (inBatchEventIds.has(delta.eventId)) {
-            syncError("E_SYNC_DUP_EVENT_IN_BATCH", `Duplicate eventId in request batch: ${delta.eventId}`);
-        }
-        inBatchEventIds.add(delta.eventId);
-        const shouldPersist = LIFECYCLE_EVENT_KINDS.has(delta.kind) ||
-            (runtime.saveStreamDeltas && DELTA_EVENT_KINDS.has(delta.kind));
-        if (shouldPersist) {
-            await ctx.db.insert("codex_stream_deltas_ttl", {
-                tenantId: args.actor.tenantId,
-                streamId: delta.streamId,
-                turnId: delta.turnId,
-                eventId: delta.eventId,
-                cursorStart: delta.cursorStart,
-                cursorEnd: delta.cursorEnd,
-                kind: delta.kind,
-                payloadJson: delta.payloadJson,
-                createdAt: delta.createdAt,
-                expiresAt: now() + DELTA_TTL_MS,
-            });
-            const existing = persistedStatsByStreamId.get(delta.streamId);
-            if (existing) {
-                existing.deltaCount += 1;
-                existing.latestCursor = Math.max(existing.latestCursor, delta.cursorEnd);
-            }
-            else {
-                persistedStatsByStreamId.set(delta.streamId, {
-                    threadId: args.threadId,
-                    turnId: delta.turnId,
-                    latestCursor: delta.cursorEnd,
-                    deltaCount: 1,
-                });
-            }
-            lastPersistedCursor = delta.cursorEnd;
-            persistedAnyEvent = true;
-        }
-        streamCheckpointCursorByStreamId.set(delta.streamId, Math.max(streamCheckpointCursorByStreamId.get(delta.streamId) ?? 0, delta.cursorEnd));
-        expectedCursorByStreamId.set(delta.streamId, delta.cursorEnd);
-    }
-    for (const turnId of startedTurns) {
-        const turn = await requireTurnForActor(ctx, args.actor, args.threadId, turnId);
-        if (turn.status === "queued") {
-            await ctx.db.patch(turn._id, { status: "inProgress" });
-        }
-    }
-    for (const [turnId, terminal] of terminalTurns) {
-        await ctx.scheduler.runAfter(0, makeFunctionReference("turnsInternal:finalizeTurnFromStream"), {
-            tenantId: args.actor.tenantId,
-            threadId: args.threadId,
-            turnId,
-            status: terminal.status,
-            ...(terminal.error ? { error: terminal.error } : {}),
-        });
-        if (terminal.status === "failed" || terminal.status === "interrupted") {
-            const pendingMessages = await ctx.db
-                .query("codex_messages")
-                .withIndex("tenantId_threadId_turnId_status", (q) => q
-                .eq("tenantId", args.actor.tenantId)
-                .eq("threadId", args.threadId)
-                .eq("turnId", turnId)
-                .eq("status", "streaming"))
-                .take(500);
-            await Promise.all(pendingMessages.map((message) => ctx.db.patch(message._id, {
-                status: terminal.status,
-                ...(terminal.error ? { error: terminal.error } : {}),
-                updatedAt: now(),
-                completedAt: now(),
-            })));
-        }
-    }
-    for (const [key, approval] of pendingApprovals) {
-        const turnId = key.split(":")[0];
-        if (!turnId) {
-            continue;
-        }
-        const existing = await getApprovalRecord(turnId, approval.itemId);
-        if (!existing) {
-            const approvalId = await ctx.db.insert("codex_approvals", {
-                tenantId: args.actor.tenantId,
-                userId: args.actor.userId,
-                threadId: args.threadId,
-                turnId,
-                itemId: approval.itemId,
-                kind: approval.kind,
-                status: "pending",
-                ...(approval.reason ? { reason: approval.reason } : {}),
-                createdAt: now(),
-            });
-            setApprovalRecord(turnId, approval.itemId, {
-                _id: approvalId,
-                status: "pending",
-            });
-        }
-    }
-    for (const [key, resolution] of resolvedApprovals) {
-        const turnId = key.split(":")[0];
-        if (!turnId) {
-            continue;
-        }
-        const existing = await getApprovalRecord(turnId, resolution.itemId);
-        if (!existing || existing.status !== "pending") {
-            continue;
-        }
-        await ctx.db.patch(existing._id, {
-            status: resolution.status,
-            decidedBy: "runtime",
-            decidedAt: now(),
-        });
-        setApprovalRecord(turnId, resolution.itemId, {
-            ...existing,
-            status: resolution.status,
-        });
-    }
-    const terminalByStream = new Map();
-    for (const delta of deltas) {
-        if (delta.type !== "stream_delta") {
-            continue;
-        }
-        const terminal = terminalStatusForEvent(delta.kind, delta.payloadJson);
-        if (!terminal) {
-            continue;
-        }
-        const current = terminalByStream.get(delta.streamId);
-        terminalByStream.set(delta.streamId, pickHigherPriorityTerminalStatus(current, terminal));
-    }
-    for (const [streamId, terminal] of terminalByStream) {
-        const stream = await getStreamRecord(streamId);
-        if (!stream || stream.state.kind !== "streaming") {
-            continue;
-        }
-        const endedAt = now();
-        const cleanupFnId = await ctx.scheduler.runAfter(runtime.finishedStreamDeleteDelayMs, makeFunctionReference("streams:cleanupFinishedStream"), {
-            tenantId: args.actor.tenantId,
-            streamId,
-            batchSize: DEFAULT_STREAM_DELETE_BATCH_SIZE,
-        });
-        if (terminal.status === "completed") {
-            await ctx.db.patch(stream._id, {
-                state: { kind: "finished", endedAt },
-                endedAt,
-                cleanupScheduledAt: endedAt,
-                cleanupFnId,
-            });
-            await setStreamStatState(ctx, {
-                tenantId: args.actor.tenantId,
-                threadId: args.threadId,
-                turnId: stream.turnId,
-                streamId,
-                state: "finished",
-            });
-            setStreamRecord(streamId, {
-                ...stream,
-                state: { kind: "finished" },
-            });
-        }
-        else {
-            await ctx.db.patch(stream._id, {
-                state: {
-                    kind: "aborted",
-                    reason: terminal.error ?? terminal.status,
-                    endedAt,
-                },
-                endedAt,
-                cleanupScheduledAt: endedAt,
-                cleanupFnId,
-            });
-            await setStreamStatState(ctx, {
-                tenantId: args.actor.tenantId,
-                threadId: args.threadId,
-                turnId: stream.turnId,
-                streamId,
-                state: "aborted",
-            });
-            setStreamRecord(streamId, {
-                ...stream,
-                state: { kind: "aborted" },
-            });
-        }
-    }
-    for (const [streamId, stats] of persistedStatsByStreamId) {
-        await addStreamDeltaStats(ctx, {
-            tenantId: args.actor.tenantId,
-            threadId: stats.threadId,
-            turnId: stats.turnId,
-            streamId,
-            deltaCount: stats.deltaCount,
-            latestCursor: stats.latestCursor,
-        });
-    }
-    const sessionPatch = { status: "active" };
-    const nextLastEventCursor = Math.max(session.lastEventCursor, lastPersistedCursor);
-    if (nextLastEventCursor !== session.lastEventCursor) {
-        sessionPatch.lastEventCursor = nextLastEventCursor;
-    }
-    const nowMs = now();
-    if (persistedAnyEvent || nowMs - session.lastHeartbeatAt >= HEARTBEAT_WRITE_MIN_INTERVAL_MS) {
-        sessionPatch.lastHeartbeatAt = nowMs;
-    }
-    await ctx.db.patch(session._id, sessionPatch);
-    const streamCheckpointRows = await ctx.db
-        .query("codex_stream_checkpoints")
-        .withIndex("tenantId_threadId_deviceId_streamId", (q) => q
-        .eq("tenantId", args.actor.tenantId)
-        .eq("threadId", args.threadId)
-        .eq("deviceId", args.actor.deviceId))
-        .take(2000);
-    const existingCheckpointByStreamId = new Map(streamCheckpointRows.map((row) => [row.streamId, row]));
-    for (const [streamId, cursor] of streamCheckpointCursorByStreamId) {
-        const existing = existingCheckpointByStreamId.get(streamId);
-        if (existing) {
-            if (cursor > Number(existing.ackedCursor)) {
-                await ctx.db.patch(existing._id, {
-                    ackedCursor: cursor,
-                    updatedAt: now(),
-                });
-            }
-            continue;
-        }
-        await ctx.db.insert("codex_stream_checkpoints", {
-            tenantId: args.actor.tenantId,
-            userId: args.actor.userId,
-            deviceId: args.actor.deviceId,
-            threadId: args.threadId,
-            streamId,
-            ackedCursor: cursor,
-            updatedAt: now(),
-        });
-    }
-    if (nowMs - session.lastHeartbeatAt >= STALE_SWEEP_MIN_INTERVAL_MS) {
-        await ctx.scheduler.runAfter(0, makeFunctionReference("sessions:timeoutStaleSessions"), {
-            tenantId: args.actor.tenantId,
-            staleBeforeMs: nowMs - 1000 * 60 * 3,
-        });
-    }
-    if (persistedAnyEvent && nowMs - session.lastHeartbeatAt >= CLEANUP_SWEEP_MIN_INTERVAL_MS) {
-        await ctx.scheduler.runAfter(0, makeFunctionReference("streams:cleanupExpiredDeltas"), {
-            nowMs,
-            batchSize: 1000,
-        });
-    }
-    const ackedStreams = Array.from(streamCheckpointCursorByStreamId.entries())
-        .map(([streamId, ackCursorEnd]) => ({ streamId, ackCursorEnd }))
-        .sort((a, b) => a.streamId.localeCompare(b.streamId));
-    return { ackedStreams, ingestStatus };
+    return ingestEvents(ctx, args);
 }
 export async function upsertCheckpointHandler(ctx, args) {
-    await requireThreadForActor(ctx, args.actor, args.threadId);
-    const existing = await ctx.db
-        .query("codex_stream_checkpoints")
-        .withIndex("tenantId_threadId_deviceId_streamId", (q) => q
-        .eq("tenantId", args.actor.tenantId)
-        .eq("threadId", args.threadId)
-        .eq("deviceId", args.actor.deviceId)
-        .eq("streamId", args.streamId))
-        .first();
-    if (existing) {
-        if (args.cursor > Number(existing.ackedCursor)) {
-            await ctx.db.patch(existing._id, {
-                ackedCursor: args.cursor,
-                updatedAt: now(),
-            });
-        }
-        return { ok: true };
-    }
-    await ctx.db.insert("codex_stream_checkpoints", {
-        tenantId: args.actor.tenantId,
-        userId: args.actor.userId,
-        deviceId: args.actor.deviceId,
-        threadId: args.threadId,
-        streamId: args.streamId,
-        ackedCursor: Math.max(0, Math.floor(args.cursor)),
-        updatedAt: now(),
-    });
-    return { ok: true };
-}
-async function upsertSessionHeartbeat(ctx, args) {
-    await requireThreadForActor(ctx, args.actor, args.threadId);
-    const session = await ctx.db
-        .query("codex_sessions")
-        .withIndex("tenantId_sessionId", (q) => q.eq("tenantId", args.actor.tenantId).eq("sessionId", args.sessionId))
-        .first();
-    if (!session) {
-        await ctx.db.insert("codex_sessions", {
-            tenantId: args.actor.tenantId,
-            userId: args.actor.userId,
-            deviceId: args.actor.deviceId,
-            threadId: args.threadId,
-            sessionId: args.sessionId,
-            status: "active",
-            lastHeartbeatAt: now(),
-            lastEventCursor: args.lastEventCursor,
-            startedAt: now(),
-        });
-        return {
-            sessionId: args.sessionId,
-            threadId: args.threadId,
-            status: "created",
-        };
-    }
-    if (session.userId !== args.actor.userId) {
-        authzError("E_AUTH_SESSION_FORBIDDEN", `User ${args.actor.userId} is not allowed to access session ${args.sessionId}`);
-    }
-    if (session.threadId !== args.threadId) {
-        syncError("E_SYNC_SESSION_THREAD_MISMATCH", `Session threadId=${session.threadId} does not match request threadId=${args.threadId}`);
-    }
-    if (session.deviceId !== args.actor.deviceId) {
-        syncError("E_SYNC_SESSION_DEVICE_MISMATCH", `Session deviceId=${session.deviceId} does not match actor deviceId=${args.actor.deviceId}`);
-    }
-    await ctx.db.patch(session._id, {
-        status: "active",
-        lastHeartbeatAt: now(),
-        lastEventCursor: Math.max(args.lastEventCursor, session.lastEventCursor),
-    });
-    return {
-        sessionId: args.sessionId,
-        threadId: args.threadId,
-        status: "active",
-    };
+    return upsertCheckpoint(ctx, args);
 }
 export async function ensureSessionHandler(ctx, args) {
     return upsertSessionHeartbeat(ctx, args);
@@ -743,9 +27,8 @@ export async function ingestSafeHandler(ctx, args) {
     }
     catch (initialError) {
         const initialCode = parseSyncErrorCode(initialError);
-        const initialMessage = getErrorMessage(initialError);
-        const recoverable = initialCode ? RECOVERABLE_INGEST_CODES.has(initialCode) : false;
-        if (!recoverable) {
+        const initialMessage = errorMessage(initialError);
+        if (!isRecoverableIngestErrorCode(initialCode)) {
             return {
                 status: "rejected",
                 ingestStatus: "partial",
@@ -788,8 +71,8 @@ export async function ingestSafeHandler(ctx, args) {
                 errors: [
                     {
                         code: mapIngestSafeCode(retryCode),
-                        message: getErrorMessage(retryError),
-                        recoverable: retryCode ? RECOVERABLE_INGEST_CODES.has(retryCode) : false,
+                        message: errorMessage(retryError),
+                        recoverable: isRecoverableIngestErrorCode(retryCode),
                     },
                 ],
             };