@cursor/july 0.1.104 → 0.1.107

package/src/internal/reminder-schedule.ts

@@ -23,8 +23,14 @@ export interface ResolvedSchedule {
   nextFireAtMs: number;
 }
 
-/** Resolve create-input schedule fields into a concrete next-fire plan. */
-export function resolveSchedule(input: ReminderCreateInput): ResolvedSchedule {
+/**
+ * Resolve create-input schedule fields into a concrete next-fire plan.
+ * Pass `nowMs` for deterministic CP / test resolution; CP owns this call.
+ */
+export function resolveSchedule(
+  input: Pick<ReminderCreateInput, "every" | "cron" | "delay" | "at">,
+  nowMs: number = Date.now()
+): ResolvedSchedule {
   const shapes = [
     input.every !== undefined,
     input.cron !== undefined,
@@ -37,7 +43,6 @@ export function resolveSchedule(input: ReminderCreateInput): ResolvedSchedule {
     );
   }
 
-  const now = Date.now();
   if (input.every !== undefined) {
     const intervalMs = parseDuration(input.every);
     if (intervalMs <= 0) {
@@ -49,7 +54,7 @@ export function resolveSchedule(input: ReminderCreateInput): ResolvedSchedule {
       kind: "every",
       value: String(input.every),
       intervalMs,
-      nextFireAtMs: now + intervalMs,
+      nextFireAtMs: nowMs + intervalMs,
     };
   }
   if (input.cron !== undefined) {
@@ -57,7 +62,7 @@ export function resolveSchedule(input: ReminderCreateInput): ResolvedSchedule {
     return {
       kind: "cron",
       value: input.cron,
-      nextFireAtMs: nextCronFireMs(input.cron, now),
+      nextFireAtMs: nextCronFireMs(input.cron, nowMs),
     };
   }
   if (input.delay !== undefined) {
@@ -65,7 +70,7 @@ export function resolveSchedule(input: ReminderCreateInput): ResolvedSchedule {
     return {
       kind: "delay",
       value: String(input.delay),
-      nextFireAtMs: now + delayMs,
+      nextFireAtMs: nowMs + delayMs,
     };
   }
   const atMs =

package/src/internal/reminder-store.ts

@@ -2,10 +2,10 @@
  * Reminder document store used by the local control plane
  * (`<stateRoot>/control-plane/reminders/`).
  *
- * Handlers (`run` / function `until`) are not serializable — they live only
- * in the in-memory {@link ReminderRunner} registry. The control plane holds
- * schedule, prompt, target, and status so prompt-form reminders survive
- * restart.
+ * Anonymous `run` / function `until` handlers are not serializable — they live
+ * only in the in-memory {@link ReminderRunner} registry. Named `handler` +
+ * `args` and prompt-form reminders survive restart (handlers resolve from
+ * `agent/reminders/` on every fire).
  */
 
 import {
@@ -18,6 +18,7 @@ import {
 } from "node:fs/promises";
 import { join } from "node:path";
 import type {
+  JsonObject,
   ReminderBusyPolicy,
   ReminderScheduleKind,
   ReminderStatus,
@@ -31,6 +32,12 @@ export type {
   ReminderStatus,
 } from "../types.js";
 
+/**
+ * Internal record status. `firing` is CP claim state and must not appear on
+ * public {@link ReminderStatus} / {@link ReminderInfo}.
+ */
+export type ReminderRecordStatus = ReminderStatus | "firing";
+
 /** Serializable reminder record (no function bodies). */
 export interface ReminderRecord {
   version: typeof REMINDER_SNAPSHOT_VERSION;
@@ -46,8 +53,15 @@ export interface ReminderRecord {
   /** Raw schedule value: every/delay string, cron expression, or ISO `at`. */
   scheduleValue: string;
   intervalMs?: number;
-  /** Prompt form — mutually exclusive with in-memory `run`. */
+  /** Prompt form — mutually exclusive with `handler` and in-memory `run`. */
   prompt?: string;
+  /**
+   * Named handler stem (`agent/reminders/<name>.ts`). Mutually exclusive with
+   * `prompt` and in-memory `run`.
+   */
+  handler?: string;
+  /** Serializable args for {@link handler}. */
+  args?: JsonObject;
   /**
    * True when create() registered a `run` handler. Handlers are not
    * serializable; after restart, armed records with this flag and no live
@@ -59,9 +73,14 @@ export interface ReminderRecord {
   /** Natural-language until (agent-facing); function until is in-memory only. */
   untilPrompt?: string;
   busyPolicy: ReminderBusyPolicy;
-  status: ReminderStatus;
+  status: ReminderRecordStatus;
   disarmReason?: string;
   fireCount: number;
+  /**
+   * CAS generation. Cancel/rekey and successful outcome apply bump this so
+   * in-flight outcomes cannot resurrect a superseded reminder.
+   */
+  generation?: number;
   nextFireAtMs: number;
   createdAt: string;
   updatedAt: string;
@@ -120,7 +139,8 @@ export class ReminderStore {
 
   async listArmed(): Promise<ReminderRecord[]> {
     const all = await this.list();
-    return all.filter((r) => r.status === "armed");
+    // Treat in-flight claims as still armed for restart / listing purposes.
+    return all.filter((r) => r.status === "armed" || r.status === "firing");
   }
 
   async get(id: string): Promise<ReminderRecord | undefined> {

package/src/internal/request-error-status.ts

@@ -7,12 +7,18 @@ import {
   hasGuestNetworkErrno,
   isQuietGuestConnectStall,
 } from "./guest-network.js";
+import {
+  HOSTED_GUEST_RETRY_TERMINAL,
+  HOSTED_GUEST_RETRY_TRANSIENT,
+  type HostedGuestRetryDisposition,
+} from "./hosted-delivery-protocol.js";
 import { SessionAuthError, SessionBusyError } from "./session-engine.js";
 
 export interface MappedRequestError {
   status: 400 | 403 | 409 | 503;
   code: string;
   message: string;
+  retry: HostedGuestRetryDisposition;
 }
 
 /**
@@ -23,23 +29,39 @@ export function mapThrownRequestError(
   error: unknown
 ): MappedRequestError | undefined {
   if (error instanceof SessionBusyError) {
-    return { status: 409, code: "session_busy", message: error.message };
+    return {
+      status: 409,
+      code: "session_busy",
+      message: error.message,
+      retry: HOSTED_GUEST_RETRY_TRANSIENT,
+    };
   }
   if (error instanceof V2EngineError) {
     return {
       status: 409,
       code: "v2_identity_conflict",
       message: "Control-plane session identity conflicts with existing state.",
+      retry: HOSTED_GUEST_RETRY_TERMINAL,
     };
   }
   if (error instanceof SessionAuthError) {
-    return { status: 403, code: "forbidden", message: error.message };
+    return {
+      status: 403,
+      code: "forbidden",
+      message: error.message,
+      retry: HOSTED_GUEST_RETRY_TERMINAL,
+    };
   }
   if (
     error instanceof InvalidAsOfError ||
     error instanceof VacuousTimeArgsError
   ) {
-    return { status: 400, code: "invalid_request", message: error.message };
+    return {
+      status: 400,
+      code: "invalid_request",
+      message: error.message,
+      retry: HOSTED_GUEST_RETRY_TERMINAL,
+    };
   }
   if (
     error instanceof GuestNetworkUnavailableError ||
@@ -52,6 +74,7 @@ export function mapThrownRequestError(
         error instanceof Error
           ? error.message
           : "Guest network is not ready for outbound requests.",
+      retry: HOSTED_GUEST_RETRY_TRANSIENT,
     };
   }
   if (isQuietGuestConnectStall(error)) {
@@ -62,6 +85,7 @@ export function mapThrownRequestError(
         error instanceof Error
           ? error.message
           : "Guest Connect stalled without a network errno.",
+      retry: HOSTED_GUEST_RETRY_TRANSIENT,
     };
   }
   return undefined;

package/src/internal/scm/pr-url.ts

@@ -1,10 +1,21 @@
 /**
  * Provider-neutral PR URL parse. GitHub.com plus the Origin page shapes
  * humans paste: cursor.com/codebase, review.cursor.com/pr, origin.cursor.com.
+ *
+ * {@link parseScmPrUrl} is the wider parse the review seams use: it also
+ * recognizes GitLab merge requests (`/-/merge_requests/<iid>` on any host),
+ * Bitbucket Cloud / Data Center pull requests, and GitHub Enterprise Server
+ * (`/<owner>/<repo>/pull/<n>` on a host that is none of the above). The
+ * narrow {@link parsePrUrl} keeps its github.com + Origin contract for the
+ * free-text callers (Slack `pr-ref`) where "any host with /pull/N" would be
+ * too eager.
  */
 
 export type PrProvider = "github" | "origin";
 
+/** Every SCM the review seams can address. */
+export type ScmPrProvider = PrProvider | "gitlab" | "bitbucket";
+
 export type ParsedPrUrl = {
   provider: PrProvider;
   owner: string;
@@ -13,6 +24,27 @@ export type ParsedPrUrl = {
   url: string;
 };
 
+export type ParsedScmPrUrl = {
+  provider: ScmPrProvider;
+  /**
+   * Namespace half of the repo: GitHub owner, GitLab group path (nested
+   * groups joined with `/`), Bitbucket workspace / project key (`~user`
+   * for Data Center personal repos).
+   */
+  owner: string;
+  repo: string;
+  number: number;
+  /** Canonical PR page URL. */
+  url: string;
+  /**
+   * Hostname the PR lives on (lowercase). `github.com` for dotcom, the
+   * GHES hostname for GitHub Enterprise, `gitlab.com` or the self-managed
+   * host for GitLab, `bitbucket.org` or the Data Center host for Bitbucket.
+   * Origin PRs report the Origin page host.
+   */
+  host: string;
+};
+
 const ORIGIN_PAGE = /^origin(-[a-z0-9]+)?\.cursor\.com$/i;
 
 function positiveInt(raw: string | undefined): number | undefined {
@@ -27,19 +59,28 @@ function positiveInt(raw: string | undefined): number | undefined {
 }
 
 function parsed(
-  provider: PrProvider,
+  provider: ScmPrProvider,
+  host: string,
   owner: string | undefined,
   repo: string | undefined,
-  number: number | undefined
-): ParsedPrUrl | undefined {
-  if (owner === undefined || repo === undefined || number === undefined) {
+  number: number | undefined,
+  url?: string
+): ParsedScmPrUrl | undefined {
+  if (
+    owner === undefined ||
+    owner === "" ||
+    repo === undefined ||
+    repo === "" ||
+    number === undefined
+  ) {
     return undefined;
   }
-  const url =
-    provider === "origin"
+  const canonical =
+    url ??
+    (provider === "origin"
       ? `https://cursor.com/codebase/${owner}/${repo}/pull/${number}`
-      : `https://github.com/${owner}/${repo}/pull/${number}`;
-  return { provider, owner, repo, number, url };
+      : `https://${host}/${owner}/${repo}/pull/${number}`);
+  return { provider, owner, repo, number, url: canonical, host };
 }
 
 /** Strip Slack mrkdwn wrappers and trailing punctuation before `URL`. */
@@ -50,27 +91,49 @@ function normalizeRaw(raw: string): string {
     .replace(/[>\].,;]+$/, "");
 }
 
+function isGithubDotCom(host: string): boolean {
+  return host === "github.com" || host === "www.github.com";
+}
+
+/** github.com and Origin only — the contract free-text PR references use. */
 export function parsePrUrl(raw: string): ParsedPrUrl | undefined {
+  const wide = parseScmPrUrl(raw);
+  if (wide === undefined) {
+    return undefined;
+  }
+  if (wide.provider === "origin") {
+    return { ...wide, provider: "origin" };
+  }
+  if (wide.provider === "github" && isGithubDotCom(wide.host)) {
+    return { ...wide, provider: "github" };
+  }
+  return undefined;
+}
+
+/**
+ * Every provider shape, including GitHub Enterprise Server. The GitLab and
+ * Bitbucket path shapes are unambiguous on any host; a plain
+ * `/<owner>/<repo>/pull/<n>` on a host that is not github.com, Origin,
+ * GitLab, or Bitbucket is taken as GHES (the only remaining forge with that
+ * route). Callers that must not accept arbitrary hosts use
+ * {@link parsePrUrl}.
+ */
+export function parseScmPrUrl(raw: string): ParsedScmPrUrl | undefined {
   let url: URL;
   try {
     url = new URL(normalizeRaw(raw));
   } catch {
     return undefined;
   }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    return undefined;
+  }
 
   const parts = url.pathname.split("/").filter(Boolean);
   const host = url.hostname.toLowerCase();
 
-  if (
-    (host === "github.com" || host === "www.github.com") &&
-    parts.length >= 4 &&
-    parts[2] === "pull"
-  ) {
-    return parsed("github", parts[0], parts[1], positiveInt(parts[3]));
-  }
-
   if (ORIGIN_PAGE.test(host) && parts.length >= 4 && parts[2] === "github") {
-    return parsed("origin", parts[0], parts[1], positiveInt(parts[3]));
+    return parsed("origin", host, parts[0], parts[1], positiveInt(parts[3]));
   }
 
   if (
@@ -79,17 +142,101 @@ export function parsePrUrl(raw: string): ParsedPrUrl | undefined {
     parts.length >= 5 &&
     parts[3] === "pull"
   ) {
-    return parsed("origin", parts[1], parts[2], positiveInt(parts[4]));
+    return parsed("origin", host, parts[1], parts[2], positiveInt(parts[4]));
   }
 
   if (host === "review.cursor.com" && parts[0] === "pr") {
     if (parts.length >= 5 && parts[3] === "github") {
-      return parsed("origin", parts[1], parts[2], positiveInt(parts[4]));
+      return parsed("origin", host, parts[1], parts[2], positiveInt(parts[4]));
     }
     if (parts.length >= 4) {
-      return parsed("origin", parts[1], parts[2], positiveInt(parts[3]));
+      return parsed("origin", host, parts[1], parts[2], positiveInt(parts[3]));
     }
   }
 
+  // GitLab MR page: /<group>/[<subgroup>/…]<project>/-/merge_requests/<iid>
+  const separator = parts.indexOf("-");
+  if (
+    separator >= 2 &&
+    parts[separator + 1] === "merge_requests" &&
+    parts.length >= separator + 3
+  ) {
+    const owner = parts.slice(0, separator - 1).join("/");
+    const repo = parts[separator - 1];
+    const number = positiveInt(parts[separator + 2]);
+    return parsed(
+      "gitlab",
+      host,
+      owner,
+      repo,
+      number,
+      number === undefined
+        ? undefined
+        : `https://${host}/${owner}/${repo}/-/merge_requests/${number}`
+    );
+  }
+
+  // Bitbucket Cloud: bitbucket.org/<workspace>/<slug>/pull-requests/<id>
+  if (
+    (host === "bitbucket.org" || host === "www.bitbucket.org") &&
+    parts.length >= 4 &&
+    parts[2] === "pull-requests"
+  ) {
+    const number = positiveInt(parts[3]);
+    return parsed(
+      "bitbucket",
+      "bitbucket.org",
+      parts[0],
+      parts[1],
+      number,
+      number === undefined
+        ? undefined
+        : `https://bitbucket.org/${parts[0]}/${parts[1]}/pull-requests/${number}`
+    );
+  }
+
+  // Bitbucket Data Center: [/<context>]/projects/<KEY>/repos/<slug>/pull-requests/<id>
+  // (personal repos: /users/<name>/repos/<slug>/…, full name `~name/slug`).
+  const dc = parts.findIndex(
+    (part, index) =>
+      (part === "projects" || part === "users") &&
+      parts[index + 2] === "repos" &&
+      parts[index + 4] === "pull-requests"
+  );
+  if (dc !== -1 && parts.length >= dc + 6) {
+    const number = positiveInt(parts[dc + 5]);
+    const owner = parts[dc] === "users" ? `~${parts[dc + 1]}` : parts[dc + 1];
+    const slug = parts[dc + 3];
+    const context = parts.slice(0, dc).join("/");
+    return parsed(
+      "bitbucket",
+      host,
+      owner,
+      slug,
+      number,
+      number === undefined
+        ? undefined
+        : `${url.origin}/${context === "" ? "" : `${context}/`}${parts.slice(dc, dc + 4).join("/")}/pull-requests/${number}`
+    );
+  }
+
+  // GitHub (dotcom or Enterprise Server): /<owner>/<repo>/pull/<n>. Checked
+  // last so the forge-specific shapes above win on shared hosts.
+  if (
+    parts.length >= 4 &&
+    parts[2] === "pull" &&
+    !ORIGIN_PAGE.test(host) &&
+    !/(^|\.)cursor\.com$/.test(host)
+  ) {
+    const githubHost = isGithubDotCom(host) ? "github.com" : host;
+    return parsed(
+      "github",
+      githubHost,
+      parts[0],
+      parts[1],
+      positiveInt(parts[3])
+    );
+  }
+
   return undefined;
 }

package/src/internal/sdk-runner.ts

@@ -432,6 +432,25 @@ export class CursorSdkRunner implements AgentRunner {
     return { warmed: true };
   }
 
+  /**
+   * Drop the cached SDK agent for this session, if one is open.
+   *
+   * Hosted v2 parks and hibernates this process as soon as the execution
+   * reply lands on non-interactive channels. A leftover handle still holds
+   * the pre-freeze Connect/HTTP2 session; the next wake then reuses it and
+   * `AgentService/Run` never starts. Call after `waitForCompletion` so the
+   * hibernate snapshot has an empty cache. Slack's interactive hot-window
+   * still reuses handles because that path does not go through hosted
+   * delivery.
+   */
+  evictSession(sessionId: string): void {
+    const cached = this.agents.get(sessionId);
+    if (cached === undefined) {
+      return;
+    }
+    this.evictAgent(sessionId, cached.agent);
+  }
+
   async dispose(): Promise<void> {
     const releases = this.prewarmReleases.splice(0);
     await Promise.allSettled(releases.map((release) => release()));

package/src/internal/server.ts

@@ -129,6 +129,11 @@ import {
 } from "./handleAgentServeTrigger.js";
 import { createHostPlatforms, warmupHostGitHubAuth } from "./host-platforms.js";
 import { registerHostedDeliveryRoute } from "./hosted-delivery.js";
+import {
+  HOSTED_DELIVERY_HEADER,
+  HOSTED_GUEST_RETRY_TERMINAL,
+  hostedGuestErrorResponse,
+} from "./hosted-delivery-protocol.js";
 import { hostedErrorStackSnippet } from "./hosted-execution-diag.js";
 import { flushHostedExecutionProcessDeath } from "./hosted-execution-flush.js";
 import {
@@ -191,6 +196,7 @@ import {
 import {
   ReminderRunner,
   ReminderValidationError,
+  rejectAnonymousReminderHandlers,
   UnknownReminderError,
 } from "./reminder-runner.js";
 import { mapThrownRequestError } from "./request-error-status.js";
@@ -319,12 +325,9 @@ export async function startServer(
     noControlPlane?: boolean;
     /** `--cursor-scm-proxy`: every cursorAccount SCM pack routes via the backend forwarder. */
     cursorScmProxy?: boolean;
-    /** Deprecated alias (`--cursor-github-proxy`); same effect as cursorScmProxy. */
-    cursorGithubProxy?: boolean;
   };
   const noControlPlane = hosted.noControlPlane === true;
-  const scmProxyRequested =
-    hosted.cursorScmProxy === true || hosted.cursorGithubProxy === true;
+  const scmProxyRequested = hosted.cursorScmProxy === true;
   const runSchedules = options.schedules ?? !dev;
   const runReminders = options.reminders ?? !dev;
 
@@ -846,12 +849,23 @@ export async function startServer(
     }
     const scheduleRunner = new ScheduleRunner(engine, project, logger);
     let reminderRunner!: ReminderRunner;
+    const architecture = project.agent.architecture;
+    const useReminderCpProtocol = !noControlPlane && architecture === "v2";
     const localControlPlane = noControlPlane
       ? undefined
       : await createLocalControlPlane({
           fireSchedule: (name) => scheduleRunner.dispatch(name),
-          fireReminder: (id, fireCount) =>
-            reminderRunner.dispatch(id, { expectedFireCount: fireCount }),
+          ...(useReminderCpProtocol
+            ? {
+                executeReminder: (descriptor) =>
+                  reminderRunner.executeFire(descriptor),
+              }
+            : {
+                fireReminder: (id, fireCount) =>
+                  reminderRunner.dispatch(id, {
+                    expectedFireCount: fireCount,
+                  }),
+              }),
           stateDir: join(stateRoot, "control-plane"),
           armReminderClocks: runReminders,
           logger,
@@ -859,7 +873,16 @@ export async function startServer(
     const timerClient = noControlPlane
       ? createCursorHostedPlatformTimers()
       : localControlPlane;
-    reminderRunner = new ReminderRunner(engine, logger, timerClient);
+    reminderRunner = new ReminderRunner(engine, logger, timerClient, {
+      namedHandlers: project.reminders ?? [],
+      // Architecture v2 rejects anonymous run/until everywhere (local + hosted).
+      rejectAnonymousHandlers: rejectAnonymousReminderHandlers({
+        noControlPlane,
+        architecture,
+      }),
+      architecture,
+      controlPlane: useReminderCpProtocol ? localControlPlane : undefined,
+    });
     const evalRuns = new EvalRunStore(
       project.rootDir,
       logger,
@@ -918,6 +941,13 @@ export async function startServer(
       ...(accountRefs !== undefined && accountBridge !== undefined
         ? { accountBridge, accountRefs }
         : {}),
+      ...(sdkRunner instanceof CursorSdkRunner
+        ? {
+            evictSdkSession: (sessionId: string) => {
+              sdkRunner.evictSession(sessionId);
+            },
+          }
+        : {}),
     });
     for (const channel of project.channels) {
       const definition = channel.definition;
@@ -928,6 +958,7 @@ export async function startServer(
         const startArgs: ChannelStartArgs = {
           send: (message, sendOptions) =>
             engine.send(channel.id, message, sendOptions),
+          architecture: project.agent.architecture,
           getSession: (sessionId) =>
             engine.getChannelSession(channel.id, sessionId),
           receive: (target, input) => engine.receive(target, input),
@@ -1440,6 +1471,12 @@ function mountAgentRoutes(
      * here so the Temporal host can read a stable path after the POST.
      */
     diagStateRoot?: string;
+    /**
+     * Drop the cached SDK agent handle after a hosted turn so hibernate
+     * cannot snapshot a frozen Connect/HTTP2 session. Injected test
+     * runners may omit this.
+     */
+    evictSdkSession?: (sessionId: string) => void;
   }
 ): void {
   const { slug, project, engine, scheduleRunner, reminderRunner } = runtime;
@@ -1508,6 +1545,8 @@ function mountAgentRoutes(
           channelId,
           hostedSessionId,
         }),
+      fireReminder: (reminderId, fireCount) =>
+        reminderRunner.dispatch(reminderId, { expectedFireCount: fireCount }),
       drainSessionDurability: (sessionId) =>
         engine.drainSessionDurability(sessionId),
       flushOtel: args.flushOtel,
@@ -1523,6 +1562,9 @@ function mountAgentRoutes(
             flushStartLog,
           }),
       snapshotLogs: () => logRing.since(),
+      ...(args.evictSdkSession === undefined
+        ? {}
+        : { evictSdkSession: args.evictSdkSession }),
     });
   }
   // Playground lists/opens Slack (and other channel) sessions across
@@ -2969,19 +3011,34 @@ async function handleRequest(
   logger: (line: string) => void
 ): Promise<void> {
   let response: Response;
+  let hostedDeliveryRequest = false;
   const method = req.method ?? "GET";
   try {
     const request = await toFetchRequest(req);
+    hostedDeliveryRequest = request.headers.get(HOSTED_DELIVERY_HEADER) === "1";
+    const requestErrorResponse = (
+      status: number,
+      error: string,
+      message: string
+    ) =>
+      hostedDeliveryRequest
+        ? hostedGuestErrorResponse({
+            status,
+            error,
+            retry: HOSTED_GUEST_RETRY_TERMINAL,
+            message,
+          })
+        : errorResponse(status, error, message);
     const url = new URL(request.url);
     const match = router.match(request.method, url.pathname);
     if (match === undefined) {
       response = router.hasPath(url.pathname)
-        ? errorResponse(
+        ? requestErrorResponse(
             405,
             "method_not_allowed",
             `${request.method} is not supported on ${url.pathname}.`
           )
-        : errorResponse(
+        : requestErrorResponse(
             404,
             "not_found",
             `No route for ${request.method} ${url.pathname}.`
@@ -2995,7 +3052,7 @@ async function handleRequest(
         unauthorized = auth === null;
       }
       response = unauthorized
-        ? errorResponse(
+        ? requestErrorResponse(
             401,
             "unauthorized",
             "No auth policy admitted this request. In production, configure channel auth (e.g. bearerAuth) — the default localDevStrict() policy only admits loopback callers with a loopback Host."
@@ -3009,7 +3066,14 @@ async function handleRequest(
   } catch (error) {
     const mapped = mapThrownRequestError(error);
     if (mapped !== undefined) {
-      response = errorResponse(mapped.status, mapped.code, mapped.message);
+      response = hostedDeliveryRequest
+        ? hostedGuestErrorResponse({
+            status: mapped.status,
+            error: mapped.code,
+            retry: mapped.retry,
+            message: mapped.message,
+          })
+        : errorResponse(mapped.status, mapped.code, mapped.message);
     } else {
       logger(
         `[agent-sdk] request failed: ${
@@ -3019,13 +3083,18 @@ async function handleRequest(
         }`
       );
       const snippet = hostedErrorStackSnippet(error);
-      response = errorResponse(
-        500,
-        "internal_error",
+      const message =
         snippet.length > 0
           ? `Internal server error: ${snippet}`
-          : "Internal server error."
-      );
+          : "Internal server error.";
+      response = hostedDeliveryRequest
+        ? hostedGuestErrorResponse({
+            status: 500,
+            error: "internal_error",
+            retry: HOSTED_GUEST_RETRY_TERMINAL,
+            message,
+          })
+        : errorResponse(500, "internal_error", message);
     }
   }