@@ -0,0 +1,97 @@
+import { json } from "@remix-run/server-runtime";
+import { pageTranscriptEntries, parseTranscriptSnapshot } from "@trigger.dev/core/v3";
+import { z } from "zod";
+import { $replica } from "~/db.server";
+import { chatSnapshotStorageKey } from "~/services/realtime/chatSnapshot.server";
+import { resolveSessionByIdOrExternalId } from "~/services/realtime/sessions.server";
+import { anyResource, createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { downloadPacketFromObjectStore } from "~/v3/objectStore.server";
+import { logger } from "~/services/logger.server";
+
+const ParamsSchema = z.object({
+  sessionId: z.string(),
+});
+
+const SearchParamsSchema = z.object({
+  limit: z.coerce.number().int().min(1).max(1000).optional(),
+  before: z.string().optional(),
+});
+
+function sessionResource(
+  paramId: string,
+  session: { friendlyId: string; externalId: string | null } | null | undefined
+) {
+  const ids = new Set<string>([paramId]);
+  if (session) {
+    ids.add(session.friendlyId);
+    if (session.externalId) ids.add(session.externalId);
+  }
+  return anyResource([...ids].map((id) => ({ type: "sessions" as const, id })));
+}
+
+function isObjectNotFound(error: unknown): boolean {
+  if (!error) return false;
+  const name = (error as { name?: unknown }).name;
+  if (name === "NoSuchKey" || name === "NotFound") return true;
+  const status = (error as { $metadata?: { httpStatusCode?: number } }).$metadata?.httpStatusCode;
+  if (status === 404) return true;
+  const message = error instanceof Error ? error.message : String(error);
+  return /not found|nosuchkey|404|does not exist/i.test(message);
+}
+
+export const loader = createLoaderApiRoute(
+  {
+    params: ParamsSchema,
+    searchParams: SearchParamsSchema,
+    corsStrategy: "none",
+    findResource: async (params, auth) =>
+      resolveSessionByIdOrExternalId($replica, auth.environment.id, params.sessionId),
+    authorization: {
+      action: "read",
+      resource: (session, params) => sessionResource(params.sessionId, session),
+    },
+  },
+  async ({ authentication, resource: session, searchParams }) => {
+    if (!session) {
+      return json({ error: "Session not found" }, { status: 404 });
+    }
+
+    let body: unknown;
+    try {
+      const packet = await downloadPacketFromObjectStore(
+        { dataType: "application/store", data: chatSnapshotStorageKey(session) },
+        authentication.environment
+      );
+      body = typeof packet.data === "string" ? JSON.parse(packet.data) : undefined;
+    } catch (error) {
+      // A missing blob is a valid empty transcript (a session that has not
+      // saved yet). Any other read failure must NOT look like an empty chat:
+      // return an error so the client falls back to the whole-blob read
+      // instead of rendering a saved conversation as empty.
+      if (isObjectNotFound(error)) {
+        return json({ messages: [], state: null });
+      }
+      logger.error("transcript endpoint: snapshot read failed", {
+        sessionId: session.friendlyId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return json({ error: "Failed to read transcript" }, { status: 502 });
+    }
+
+    const snapshot = parseTranscriptSnapshot(body);
+    if (!snapshot) {
+      return json({ messages: [], state: null });
+    }
+
+    const page = pageTranscriptEntries(snapshot.messages, searchParams);
+    return json({
+      messages: page.entries.map((entry) => entry.message),
+      state: snapshot.state,
+      cursors: {
+        lastOutEventId: snapshot.lastOutEventId,
+        lastInEventId: snapshot.lastInEventId,
+      },
+      nextCursor: page.nextCursor,
+    });
+  }
+);
@@ -51,6 +51,7 @@ import {
   CreateSessionStreamWaitpointResponseBody,
   CreateStreamResponseBody,
   CreateUploadPayloadUrlResponseBody,
+  SessionTranscriptResponseBody,
   CreateWaitpointTokenResponseBody,
   CreatedSessionResponseBody,
   DeletedScheduleObject,
@@ -709,6 +710,30 @@ export class ApiClient {
     );
   }
 
+  /**
+   * One page of a `chat.agent` session's persisted transcript, most recent
+   * messages first when `limit` is set. Secret key only.
+   */
+  getSessionTranscript(
+    sessionId: string,
+    options?: { limit?: number; before?: string },
+    requestOptions?: ZodFetchOptions
+  ) {
+    const query = new URLSearchParams();
+    if (options?.limit !== undefined) query.set("limit", String(options.limit));
+    if (options?.before !== undefined) query.set("before", options.before);
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return zodfetch(
+      SessionTranscriptResponseBody,
+      `${this.baseUrl}/api/v1/sessions/${encodeURIComponent(sessionId)}/transcript${suffix}`,
+      {
+        method: "GET",
+        headers: this.#getHeaders(false),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
   retrieveRun(runId: string, requestOptions?: ZodFetchOptions) {
     return zodfetch(
       RetrieveRunResponse,
 
@@ -1005,6 +1005,21 @@ export const CreateUploadPayloadUrlResponseBody = z.object({
   storagePath: z.string().optional(),
 });
 
+/** One page of a `chat.agent` session transcript, from `GET /api/v1/sessions/{id}/transcript`. */
+export const SessionTranscriptResponseBody = z.object({
+  messages: z.array(z.unknown()),
+  state: z.unknown().nullable(),
+  cursors: z
+    .object({
+      lastOutEventId: z.string().optional(),
+      lastInEventId: z.string().optional(),
+    })
+    .optional(),
+  nextCursor: z.string().optional(),
+});
+
+export type SessionTranscriptResponseBody = z.infer<typeof SessionTranscriptResponseBody>;
+
 export const WorkersListResponseBody = z
   .object({
     type: z.string(),
 
@@ -142,6 +142,29 @@ export function parseTranscriptSnapshot<TUIMessage extends UIMessage = UIMessage
   return undefined;
 }
 
+/**
+ * Select one page of transcript entries, newest last. `before` keeps only the
+ * entries ordered before that id; `limit` keeps the last that many. The
+ * returned `nextCursor` is the id to pass as `before` for the previous page,
+ * absent when there is no earlier page.
+ */
+export function pageTranscriptEntries<TUIMessage extends UIMessage = UIMessage>(
+  all: TranscriptSnapshotEntry<TUIMessage>[],
+  opts: { limit?: number; before?: string } | undefined
+): { entries: TranscriptSnapshotEntry<TUIMessage>[]; nextCursor: string | undefined } {
+  let entries = all;
+  if (opts?.before !== undefined) {
+    const idx = entries.findIndex((e) => e.id === opts.before);
+    if (idx !== -1) entries = entries.slice(0, idx);
+  }
+  let nextCursor: string | undefined;
+  if (opts?.limit !== undefined && opts.limit >= 0 && entries.length > opts.limit) {
+    entries = entries.slice(entries.length - opts.limit);
+    nextCursor = entries[0]?.id;
+  }
+  return { entries, nextCursor };
+}
+
 /**
  * S3 key suffix for a session's snapshot blob. The webapp's presigned
  * URL routes prefix this with `packets/{projectRef}/{envSlug}/`.
 
@@ -1,10 +1,43 @@
 import { describe, expect, it } from "vitest";
 import {
+  pageTranscriptEntries,
   parseTranscriptSnapshot,
   type ChatSnapshotV1,
+  type TranscriptSnapshotEntry,
   type TranscriptSnapshotV2,
 } from "../src/v3/sessionStreams/chatSnapshot.js";
 
+describe("pageTranscriptEntries", () => {
+  const entries: TranscriptSnapshotEntry[] = ["a", "b", "c", "d", "e"].map((id) => ({
+    id,
+    final: true,
+    message: { id, role: "user", parts: [] },
+  }));
+
+  it("returns everything with no options and no cursor", () => {
+    expect(pageTranscriptEntries(entries, undefined)).toEqual({ entries, nextCursor: undefined });
+  });
+
+  it("returns the newest `limit` entries with the cursor for the page before", () => {
+    const page = pageTranscriptEntries(entries, { limit: 2 });
+    expect(page.entries.map((e) => e.id)).toEqual(["d", "e"]);
+    expect(page.nextCursor).toBe("d");
+  });
+
+  it("pages backwards with `before` until the cursor runs out", () => {
+    const page = pageTranscriptEntries(entries, { limit: 2, before: "d" });
+    expect(page.entries.map((e) => e.id)).toEqual(["b", "c"]);
+    expect(page.nextCursor).toBe("b");
+    const last = pageTranscriptEntries(entries, { limit: 2, before: "b" });
+    expect(last.entries.map((e) => e.id)).toEqual(["a"]);
+    expect(last.nextCursor).toBeUndefined();
+  });
+
+  it("ignores an unknown `before` id", () => {
+    expect(pageTranscriptEntries(entries, { before: "zz" }).entries).toHaveLength(5);
+  });
+});
+
 const user = { id: "u-1", role: "user" as const, parts: [{ type: "text" as const, text: "hi" }] };
 const assistant = {
   id: "a-1",