fix(webapp): address #3417 PR review feedback (round 2)

Two fixes from Devin review on the sessions-as-run-manager commit:

- `SessionItem.currentRunId`'s contract is the `run_*` friendlyId, but
  `serializeSession` returns the raw Prisma cuid. The `POST /sessions`
  create path overrides correctly via a TaskRun lookup, but GET, PATCH,
  and the three return paths in close.ts were passing the cuid through.
  A consumer using `currentRunId` from those endpoints in a downstream
  `GET /api/v1/runs/:runId` call would 404. Add a
  `serializeSessionWithFriendlyRunId` helper next to `serializeSession`
  that resolves via `$replica.taskRun.findFirst` (TaskRun friendlyIds
  are immutable, so replica lag is harmless), and switch the five
  affected return sites to use it. List endpoints stay on
  `serializeSession` to avoid N+1 lookups when paginating. The create
  endpoint keeps its existing manual lookup because it also needs the
  friendlyId for the response's `runId` field, and `session.currentRunId`
  is stale relative to the post-`ensureRunForSession` claim outcome.

- Drop dead `lastChunkType` recomputation in
  `streamResponseFromSessionStream`. The variable was bound but never
  used; the conditional below it re-evaluated the same expression.
  Use the bound value in the condition.

Author: ericallam

apps/webapp/app/routes/api.v1.sessions.$session.close.ts

@@ -7,7 +7,7 @@ import { z } from "zod";
 import { $replica, prisma } from "~/db.server";
 import {
   resolveSessionByIdOrExternalId,
-  serializeSession,
+  serializeSessionWithFriendlyRunId,
 } from "~/services/realtime/sessions.server";
 import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
 
@@ -43,7 +43,9 @@ const { action, loader } = createActionApiRoute(
     // Idempotent: if already closed, return the current row without clobbering
     // the original closedAt / closedReason.
     if (existing.closedAt) {
-      return json<RetrieveSessionResponseBody>(serializeSession(existing));
+      return json<RetrieveSessionResponseBody>(
+        await serializeSessionWithFriendlyRunId(existing)
+      );
     }
 
     // `closedAt: null` on the where clause makes the update conditional at
@@ -61,12 +63,16 @@ const { action, loader } = createActionApiRoute(
     if (count === 0) {
       const final = await prisma.session.findFirst({ where: { id: existing.id } });
       if (!final) return json({ error: "Session not found" }, { status: 404 });
-      return json<RetrieveSessionResponseBody>(serializeSession(final));
+      return json<RetrieveSessionResponseBody>(
+        await serializeSessionWithFriendlyRunId(final)
+      );
     }
 
     const updated = await prisma.session.findFirst({ where: { id: existing.id } });
     if (!updated) return json({ error: "Session not found" }, { status: 404 });
-    return json<RetrieveSessionResponseBody>(serializeSession(updated));
+    return json<RetrieveSessionResponseBody>(
+      await serializeSessionWithFriendlyRunId(updated)
+    );
   }
 );
 

apps/webapp/app/routes/api.v1.sessions.$session.ts

@@ -8,7 +8,7 @@ import { z } from "zod";
 import { $replica, prisma } from "~/db.server";
 import {
   resolveSessionByIdOrExternalId,
-  serializeSession,
+  serializeSessionWithFriendlyRunId,
 } from "~/services/realtime/sessions.server";
 import {
   createActionApiRoute,
@@ -34,7 +34,9 @@ export const loader = createLoaderApiRoute(
     },
   },
   async ({ resource: session }) => {
-    return json<RetrieveSessionResponseBody>(serializeSession(session));
+    return json<RetrieveSessionResponseBody>(
+      await serializeSessionWithFriendlyRunId(session)
+    );
   }
 );
 
@@ -80,7 +82,9 @@ const { action } = createActionApiRoute(
         },
       });
 
-      return json<RetrieveSessionResponseBody>(serializeSession(updated));
+      return json<RetrieveSessionResponseBody>(
+        await serializeSessionWithFriendlyRunId(updated)
+      );
     } catch (error) {
       // A duplicate externalId in the same environment violates the
       // `(runtimeEnvironmentId, externalId)` unique constraint. Surface that

apps/webapp/app/services/realtime/s2realtimeStreams.server.ts

@@ -329,11 +329,7 @@ export class S2RealtimeStreams implements StreamResponder, StreamIngestor {
         lastChunk != null && typeof lastChunk === "object"
           ? (lastChunk as { type?: unknown }).type
           : null;
-      if (
-        lastChunk != null &&
-        typeof lastChunk === "object" &&
-        (lastChunk as { type?: unknown }).type === "trigger:turn-complete"
-      ) {
+      if (lastChunkType === "trigger:turn-complete") {
         settled = true;
         waitSeconds = 0;
       }

apps/webapp/app/services/realtime/sessions.server.ts

@@ -1,5 +1,6 @@
 import type { PrismaClient, Session } from "@trigger.dev/database";
 import type { SessionItem } from "@trigger.dev/core/v3";
+import { $replica } from "~/db.server";
 
 /**
  * Prefix that {@link SessionId.generate} attaches to every Session friendlyId.
@@ -74,10 +75,10 @@ export function canonicalSessionAddressingKey(
  *
  * Note: `currentRunId` is left as-is — Prisma stores the internal run id
  * (cuid), but `SessionItem.currentRunId` is the *friendly* form. Routes
- * that emit `SessionItem` are responsible for resolving the friendlyId
- * (typically via a separate TaskRun lookup) and overriding the field.
- * `serializeSession` returns it raw so list endpoints don't pay an N+1
- * lookup just to surface the friendly form.
+ * that emit a single `SessionItem` should use
+ * {@link serializeSessionWithFriendlyRunId} instead, which resolves the
+ * friendlyId via a TaskRun lookup. List endpoints stay on this raw form
+ * to avoid N+1 lookups when paginating.
  */
 export function serializeSession(session: Session): SessionItem {
   return {
@@ -96,3 +97,31 @@ export function serializeSession(session: Session): SessionItem {
     updatedAt: session.updatedAt,
   };
 }
+
+/**
+ * Same as {@link serializeSession} but resolves `currentRunId` from the
+ * internal cuid to the public `run_*` friendlyId via a TaskRun lookup.
+ * Single-row endpoints (`POST/GET/PATCH/close /api/v1/sessions/:s`) use
+ * this so the wire-side `currentRunId` is consistent with the rest of
+ * the public API (which only accepts friendlyIds for run lookups).
+ *
+ * Skips the lookup when `currentRunId` is null. The read goes through
+ * `$replica` — a TaskRun's `friendlyId` is immutable so replica lag is
+ * harmless, and serializing on the writer would just add hot-path load.
+ */
+export async function serializeSessionWithFriendlyRunId(
+  session: Session
+): Promise<SessionItem> {
+  const base = serializeSession(session);
+  if (!session.currentRunId) return base;
+
+  const run = await $replica.taskRun.findFirst({
+    where: { id: session.currentRunId },
+    select: { friendlyId: true },
+  });
+
+  return {
+    ...base,
+    currentRunId: run?.friendlyId ?? null,
+  };
+}