@cursor/july 0.1.107 → 0.1.108

package/src/internal/platform-timers.ts

@@ -8,6 +8,14 @@
  * executes fires.
  */
 
+import {
+  REMINDER_CP_PROTOCOL_VERSION,
+  type ReminderControlPlane,
+  type ReminderCreateIntent,
+  type ReminderExecutionOutcome,
+  type ReminderFireClaim,
+  type ReminderOutcomeApplyResult,
+} from "./reminder-control-plane-protocol.js";
 import { isReminderRecord, type ReminderRecord } from "./reminder-store.js";
 
 const DEFAULT_CURSOR_EXTERNAL_API_URL = "https://api.cursor.com";
@@ -171,3 +179,186 @@ export function createCursorHostedPlatformTimers(
     },
   };
 }
+
+/** v2 reminder CP is factory ECS (`/internal/agentsdk/*`), not timed-work. */
+const AGENTSDK_REMINDERS_PREFIX = "/internal/agentsdk";
+
+/**
+ * Bounded retries for idempotent CP outcome writes after the guest handler
+ * has already run. Delivery is at-least-once: a transient apply failure may
+ * re-enter the handler on the next Temporal admission. Do not claim
+ * exactly-once handler execution.
+ */
+const APPLY_REMINDER_OUTCOME_MAX_ATTEMPTS = 3;
+const APPLY_REMINDER_OUTCOME_RETRY_DELAY_MS = 50;
+
+async function sleepMs(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function withBoundedApplyRetries<T>(run: () => Promise<T>): Promise<T> {
+  let lastError: unknown;
+  for (
+    let attempt = 1;
+    attempt <= APPLY_REMINDER_OUTCOME_MAX_ATTEMPTS;
+    attempt++
+  ) {
+    try {
+      return await run();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= APPLY_REMINDER_OUTCOME_MAX_ATTEMPTS) {
+        break;
+      }
+      await sleepMs(APPLY_REMINDER_OUTCOME_RETRY_DELAY_MS * attempt);
+    }
+  }
+  throw lastError;
+}
+
+async function timedWorkJsonFetch(
+  options: CursorHostedPlatformTimersOptions,
+  method: "GET" | "POST" | "PUT" | "DELETE",
+  path: string,
+  body?: unknown
+): Promise<Response> {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error("reminder control plane requires fetch");
+  }
+  return fetchImpl(`${resolveBaseUrl(options)}${path}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${resolveApiKey(options)}`,
+      ...(body === undefined ? {} : { "Content-Type": "application/json" }),
+    },
+    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+  });
+}
+
+/**
+ * Cursor-hosted HTTP ReminderControlPlane for architecture v2.
+ * Speaks factory `/internal/agentsdk/reminders` (ELB → factory ECS).
+ * CP owns ids and time. v1 PUT/DELETE reminders stay on timed-work.
+ */
+export function createCursorHostedReminderControlPlane(
+  options: CursorHostedPlatformTimersOptions = {}
+): ReminderControlPlane {
+  return {
+    protocolVersion: REMINDER_CP_PROTOCOL_VERSION,
+    async createReminder(intent: ReminderCreateIntent) {
+      const response = await timedWorkJsonFetch(
+        options,
+        "POST",
+        `${AGENTSDK_REMINDERS_PREFIX}/reminders`,
+        intent
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+          `reminder CP create failed: HTTP ${response.status} ${text}`
+        );
+      }
+      const parsed: unknown = await response.json();
+      if (!isReminderRecord(parsed)) {
+        throw new Error("reminder CP create returned invalid record");
+      }
+      return parsed;
+    },
+    async getReminder(id) {
+      const response = await timedWorkJsonFetch(
+        options,
+        "GET",
+        `${AGENTSDK_REMINDERS_PREFIX}/reminders/${encodeURIComponent(id)}`
+      );
+      if (response.status === 404) {
+        return undefined;
+      }
+      if (!response.ok) {
+        throw new Error(`reminder CP get failed: HTTP ${response.status}`);
+      }
+      const parsed: unknown = await response.json();
+      return isReminderRecord(parsed) ? parsed : undefined;
+    },
+    async listReminders() {
+      const response = await timedWorkJsonFetch(
+        options,
+        "GET",
+        `${AGENTSDK_REMINDERS_PREFIX}/reminders`
+      );
+      if (!response.ok) {
+        throw new Error(`reminder CP list failed: HTTP ${response.status}`);
+      }
+      const parsed: unknown = await response.json();
+      if (
+        parsed === null ||
+        typeof parsed !== "object" ||
+        !("reminders" in parsed) ||
+        !Array.isArray((parsed as { reminders: unknown }).reminders)
+      ) {
+        return [];
+      }
+      return (parsed as { reminders: unknown[] }).reminders.filter(
+        isReminderRecord
+      );
+    },
+    async cancelReminder(id, reason) {
+      const response = await timedWorkJsonFetch(
+        options,
+        "POST",
+        `${AGENTSDK_REMINDERS_PREFIX}/reminders/${encodeURIComponent(id)}/cancel`,
+        reason === undefined ? {} : { reason }
+      );
+      if (response.status === 404) {
+        return undefined;
+      }
+      if (!response.ok) {
+        throw new Error(`reminder CP cancel failed: HTTP ${response.status}`);
+      }
+      const parsed: unknown = await response.json();
+      return isReminderRecord(parsed) ? parsed : undefined;
+    },
+    async rekeyReminders(channelId, oldToken, newToken) {
+      const response = await timedWorkJsonFetch(
+        options,
+        "POST",
+        `${AGENTSDK_REMINDERS_PREFIX}/reminders/rekey`,
+        { channelId, oldToken, newToken }
+      );
+      if (!response.ok) {
+        throw new Error(`reminder CP rekey failed: HTTP ${response.status}`);
+      }
+      const parsed: unknown = await response.json();
+      if (
+        parsed === null ||
+        typeof parsed !== "object" ||
+        typeof (parsed as { count?: unknown }).count !== "number"
+      ) {
+        throw new Error("reminder CP rekey returned invalid body");
+      }
+      return (parsed as { count: number }).count;
+    },
+    async applyReminderOutcome(
+      claim: ReminderFireClaim,
+      outcome: ReminderExecutionOutcome
+    ): Promise<ReminderOutcomeApplyResult> {
+      // Handler side effects may already have run; retry only the idempotent
+      // CP write. Exhausted failures stay thrown so Temporal can re-admit
+      // (at-least-once — not exactly-once).
+      return await withBoundedApplyRetries(async () => {
+        const response = await timedWorkJsonFetch(
+          options,
+          "POST",
+          `${AGENTSDK_REMINDERS_PREFIX}/reminders/outcome`,
+          { claim, outcome }
+        );
+        if (!response.ok) {
+          throw new Error(
+            `reminder CP outcome apply failed: HTTP ${response.status}`
+          );
+        }
+        return (await response.json()) as ReminderOutcomeApplyResult;
+      });
+    },
+  };
+}

package/src/internal/reminder-control-plane-protocol.ts

@@ -27,6 +27,8 @@ import type { ReminderRecord } from "./reminder-store.js";
 
 /** Wire / persistence version for this control-plane protocol. */
 export const REMINDER_CP_PROTOCOL_VERSION = 1 as const;
+/** Each recurring/retry fire can spend a model turn and create hosted work. */
+export const REMINDER_CP_MIN_RECURRING_INTERVAL_MS = 60_000 as const;
 
 export type ReminderCpProtocolVersion = typeof REMINDER_CP_PROTOCOL_VERSION;
 
@@ -293,6 +295,14 @@ export function intentToNewRecord(
     scheduleSpecToCreateFields(intent.schedule),
     nowMs
   );
+  if (
+    resolved.kind === "every" &&
+    (resolved.intervalMs ?? 0) < REMINDER_CP_MIN_RECURRING_INTERVAL_MS
+  ) {
+    throw new ReminderValidationError(
+      `every must be >= 1m (got ${intent.schedule.kind === "every" ? intent.schedule.every : ""})`
+    );
+  }
   const nowIso = new Date(nowMs).toISOString();
   return {
     version: 1,
@@ -429,11 +439,14 @@ export function applyOutcomeToRecord(
   const nowIso = new Date(nowMs).toISOString();
 
   if (outcome.kind === "retry") {
-    const delayMs = outcome.delayMs ?? 0;
+    const delayMs = Math.max(
+      REMINDER_CP_MIN_RECURRING_INTERVAL_MS,
+      outcome.delayMs ?? REMINDER_CP_MIN_RECURRING_INTERVAL_MS
+    );
     const updated: ReminderRecord = {
       ...record,
       status: "armed",
-      nextFireAtMs: nowMs + Math.max(0, delayMs),
+      nextFireAtMs: nowMs + delayMs,
       // Same fireCount; bump generation so a second apply of the old claim is stale.
       generation: recordGeneration(record) + 1,
       updatedAt: nowIso,

package/src/internal/reminder-runner.ts

@@ -18,6 +18,11 @@ import type {
   ReminderStatus,
   ReminderUntilContext,
 } from "../types.js";
+import {
+  channelContinuationIdentity,
+  httpContinuationIdentity,
+} from "./continuation-channel.js";
+import { continuationSource } from "./continuation-identity.js";
 import { NAME_PATTERN } from "./discovery/names.js";
 import { parseDuration } from "./duration.js";
 import type { PlatformTimers } from "./platform-timers.js";
@@ -39,7 +44,12 @@ import {
 } from "./reminder-schedule.js";
 import type { ReminderBusyPolicy, ReminderRecord } from "./reminder-store.js";
 import { APP_AUTH } from "./schedule-runner.js";
-import { SessionBusyError, type SessionEngine } from "./session-engine.js";
+import {
+  type EngineSendOptions,
+  HTTP_CHANNEL_ID,
+  SessionBusyError,
+  type SessionEngine,
+} from "./session-engine.js";
 
 export { ReminderValidationError } from "./reminder-schedule.js";
 
@@ -1040,16 +1050,56 @@ export class ReminderRunner {
     return this.sendFollowup(record, buildFirePrompt(record), auth);
   }
 
+  /**
+   * Join the reminder's existing session. Control-plane (`/v2`) channels
+   * refuse authored `continuationToken`; pass the stored key as
+   * {@link EngineSendOptions.mailboxContinuation} so the engine reuses the
+   * CP-selected identity without channel admission.
+   */
+  private followupSendOptions(
+    record: ReminderRecord,
+    auth: AuthContext | null
+  ): EngineSendOptions {
+    if (this.channelUsesControlPlaneContinuation(record.channelId)) {
+      return {
+        auth,
+        mailboxContinuation: { key: record.continuationToken },
+      };
+    }
+    return {
+      auth,
+      continuationToken: record.continuationToken,
+    };
+  }
+
+  private channelUsesControlPlaneContinuation(channelId: string): boolean {
+    const project = this.engine.project;
+    // Test doubles may omit `project`; keep the legacy continuationToken path.
+    if (project === undefined) {
+      return false;
+    }
+    const identity =
+      channelId === HTTP_CHANNEL_ID
+        ? httpContinuationIdentity(project.httpChannel)
+        : channelContinuationIdentity(
+            project.channels.find((channel) => channel.id === channelId)
+              ?.definition
+          );
+    return continuationSource(identity) === "control-plane";
+  }
+
   private async sendFollowup(
     record: ReminderRecord,
     message: string,
     auth: AuthContext | null
   ): Promise<ReminderFireResult> {
+    const sendOptions = this.followupSendOptions(record, auth);
     try {
-      const session = await this.engine.send(record.channelId, message, {
-        auth,
-        continuationToken: record.continuationToken,
-      });
+      const session = await this.engine.send(
+        record.channelId,
+        message,
+        sendOptions
+      );
       this.engine.trackBackground(this.engine.waitForCompletion(session.id));
       return { action: "delivered" };
     } catch (error) {
@@ -1059,10 +1109,11 @@ export class ReminderRunner {
         }
         await this.whenSessionIdle(record.channelId, record.continuationToken);
         try {
-          const session = await this.engine.send(record.channelId, message, {
-            auth,
-            continuationToken: record.continuationToken,
-          });
+          const session = await this.engine.send(
+            record.channelId,
+            message,
+            sendOptions
+          );
           this.engine.trackBackground(
             this.engine.waitForCompletion(session.id)
           );

package/src/internal/resolve-prod-target.ts

@@ -16,6 +16,7 @@ import {
   validateDeploymentSlug,
 } from "./deploy-client.js";
 import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
+import { rejectV2ForLegacyCommand } from "./legacy-command-guard.js";
 import { sleep as defaultSleep } from "./sleep.js";
 import { stderrPalette } from "./terminal-style.js";
 
@@ -38,6 +39,8 @@ export interface ResolveProdTargetOptions {
   apiKey?: string;
   fetchImpl?: typeof fetch;
   err?: (text: string) => void;
+  /** Skip when the caller already ran {@link rejectV2ForLegacyCommand}. */
+  skipLegacyArchitectureCheck?: boolean;
   /** Test seam for reachability-retry backoff. */
   sleep?: (ms: number) => Promise<void>;
 }
@@ -95,6 +98,13 @@ export async function resolveProdTarget(
       `Could not resolve Cursor credentials/team for the hosted deployment (see above).`
     );
   }
+  if (options.skipLegacyArchitectureCheck !== true) {
+    await rejectV2ForLegacyCommand({
+      client: auth.client,
+      teamId: auth.teamId,
+      slug,
+    });
+  }
 
   // A hibernated engine can briefly omit engineAccess while getPod fails
   // during wake. Retry a few times before surfacing "not reachable yet".
@@ -198,6 +208,11 @@ export async function resolveProdAliasPlaygroundUrl(
       `Could not resolve Cursor credentials/team for the hosted deployment (see above).`
     );
   }
+  await rejectV2ForLegacyCommand({
+    client: auth.client,
+    teamId: auth.teamId,
+    slug,
+  });
 
   let detail: DeploymentDetail;
   try {

package/src/internal/sdk-runner.ts

@@ -518,7 +518,7 @@ export class CursorSdkRunner implements AgentRunner {
     const resolved = resolveApiKeySync({ apiKey: this.options.apiKey });
     if (resolved === undefined) {
       throw new Error(
-        `The Cursor SDK runner requires a Cursor credential: run \`${CLI} login\`, set CURSOR_API_KEY or CURSOR_API_KEY_FILE, or pass serve({ apiKey }).`
+        `The Cursor SDK runner requires a Cursor credential: run \`${CLI} login\`, set CURSOR_API_KEY, CURSOR_SERVICE_ACCOUNT_KEY, or CURSOR_API_KEY_FILE, or pass serve({ apiKey }).`
       );
     }
     return resolved.apiKey;
@@ -805,6 +805,7 @@ function toTurnOutcome(result: RunResult): TurnOutcome {
     ...(result.status === "error"
       ? { errorMessage: runErrorMessage(result) }
       : {}),
+    errorCode: result.status === "error" ? result.error?.code : undefined,
     ...(usage === undefined ? {} : { usage }),
   };
 }

package/src/internal/server.ts

@@ -66,6 +66,7 @@ import type {
   ReminderInfo,
   ServeOptions,
 } from "../types.js";
+import { invokeChannelRoute } from "./channel-route-dispatch.js";
 import { selectConversationMirror } from "./conversation-mirror.js";
 import {
   type CursorAccountConnectionRef,
@@ -129,6 +130,7 @@ import {
 } from "./handleAgentServeTrigger.js";
 import { createHostPlatforms, warmupHostGitHubAuth } from "./host-platforms.js";
 import { registerHostedDeliveryRoute } from "./hosted-delivery.js";
+import type { HostedReminderFireDescriptorPayload } from "./hosted-delivery-protocol.js";
 import {
   HOSTED_DELIVERY_HEADER,
   HOSTED_GUEST_RETRY_TERMINAL,
@@ -143,7 +145,6 @@ import {
   readJsonObject,
   requireSessionOwner,
 } from "./http-channel.js";
-import { validateToolInput } from "./json-schema.js";
 import { DEFAULT_SERVE_PORT, listenHttpServer } from "./listen-port.js";
 import {
   createLocalControlPlane,
@@ -176,7 +177,10 @@ import {
   PLATFORM_SCHEDULE_CATALOG_FILENAME,
   syncHostedPlatformSchedules,
 } from "./platform-schedule-sync.js";
-import { createCursorHostedPlatformTimers } from "./platform-timers.js";
+import {
+  createCursorHostedPlatformTimers,
+  createCursorHostedReminderControlPlane,
+} from "./platform-timers.js";
 import {
   type AgentIndexEntry,
   renderAgentsIndexHtml,
@@ -193,6 +197,11 @@ import {
   collectMemoryHealthFields,
   sumEventLogStats,
 } from "./process-memory-telemetry.js";
+import {
+  claimFromDescriptor,
+  type ReminderControlPlane,
+  type ReminderFireDescriptor,
+} from "./reminder-control-plane-protocol.js";
 import {
   ReminderRunner,
   ReminderValidationError,
@@ -210,6 +219,7 @@ import { RuntimeDispatchingRunner } from "./runtime-dispatch-runner.js";
 import { ScheduleRunner, UnknownScheduleError } from "./schedule-runner.js";
 import { type AgentRunner, CursorSdkRunner } from "./sdk-runner.js";
 import {
+  HTTP_CHANNEL_ID,
   InvalidContinuationTokenError,
   SessionEngine,
   ToolInputError,
@@ -252,6 +262,11 @@ interface MountedRuntime {
   scheduleRunner: ScheduleRunner;
   reminderRunner: ReminderRunner;
   controlPlane?: LocalControlPlane;
+  /**
+   * Hosted (or local) reminder CP client for architecture v2 descriptor
+   * execution. Undefined when the project is not on the CP protocol.
+   */
+  reminderControlPlane?: ReminderControlPlane;
   /** Playground eval batches (`/v1/dev/evals`); loopbackUrl set after listen. */
   evalRuns: EvalRunStore;
 }
@@ -325,9 +340,12 @@ 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;
+  const scmProxyRequested =
+    hosted.cursorScmProxy === true || hosted.cursorGithubProxy === true;
   const runSchedules = options.schedules ?? !dev;
   const runReminders = options.reminders ?? !dev;
 
@@ -371,13 +389,15 @@ export async function startServer(
   // One resolution for every Cursor credential consumer (SDK runner, account
   // MCP bridge, SCM event relay, GitHub credentials): explicit option →
   // CURSOR_API_KEY → CURSOR_API_KEY_FILE (or the hosted default path) →
-  // stored `agent-sdk login`. SDK / GitHub / account MCP re-read later;
-  // Slack and deployment-event relays capture the key at start.
+  // CURSOR_SERVICE_ACCOUNT_KEY → stored `agent-sdk login`. SDK / GitHub /
+  // account MCP re-read later; Slack and deployment-event relays capture
+  // the key at start.
   const accountKey = await resolveApiKey(
     options.apiKey === undefined ? {} : { apiKey: options.apiKey }
   );
   // First present source wins (we define the order): option → env → file →
-  // stored login. Re-read so bind can drop env or file onto a listening process.
+  // service account → stored login. Re-read so bind can drop env or file
+  // onto a listening process.
   const liveCursorApiKey = (): string | undefined =>
     resolveApiKeySync(
       options.apiKey === undefined ? {} : { apiKey: options.apiKey }
@@ -850,7 +870,7 @@ 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 useReminderCpProtocol = architecture === "v2";
     const localControlPlane = noControlPlane
       ? undefined
       : await createLocalControlPlane({
@@ -873,6 +893,13 @@ export async function startServer(
     const timerClient = noControlPlane
       ? createCursorHostedPlatformTimers()
       : localControlPlane;
+    const hostedReminderControlPlane =
+      noControlPlane && useReminderCpProtocol
+        ? createCursorHostedReminderControlPlane()
+        : undefined;
+    const reminderControlPlane = useReminderCpProtocol
+      ? (localControlPlane ?? hostedReminderControlPlane)
+      : undefined;
     reminderRunner = new ReminderRunner(engine, logger, timerClient, {
       namedHandlers: project.reminders ?? [],
       // Architecture v2 rejects anonymous run/until everywhere (local + hosted).
@@ -881,7 +908,7 @@ export async function startServer(
         architecture,
       }),
       architecture,
-      controlPlane: useReminderCpProtocol ? localControlPlane : undefined,
+      controlPlane: reminderControlPlane,
     });
     const evalRuns = new EvalRunStore(
       project.rootDir,
@@ -920,6 +947,7 @@ export async function startServer(
       ...(localControlPlane === undefined
         ? {}
         : { controlPlane: localControlPlane }),
+      ...(reminderControlPlane === undefined ? {} : { reminderControlPlane }),
     };
     runtimes.push(runtime);
     const accountRefs = accountRefsBySlug.get(slug);
@@ -1479,7 +1507,14 @@ function mountAgentRoutes(
     evictSdkSession?: (sessionId: string) => void;
   }
 ): void {
-  const { slug, project, engine, scheduleRunner, reminderRunner } = runtime;
+  const {
+    slug,
+    project,
+    engine,
+    scheduleRunner,
+    reminderRunner,
+    reminderControlPlane,
+  } = runtime;
   const {
     dev,
     playground,
@@ -1538,7 +1573,12 @@ function mountAgentRoutes(
     registerHostedDeliveryRoute({
       router,
       base,
-      channels: project.channels,
+      // The built-in http channel is not in `project.channels`; the control
+      // plane's session start (`agentsdk.session`) is delivered to it.
+      channels: [
+        ...project.channels,
+        { id: HTTP_CHANNEL_ID, definition: project.httpChannel },
+      ],
       buildHandlerArgs: (channelId, hostedSessionId) =>
         buildChannelHandlerArgs({
           runtime,
@@ -1547,6 +1587,33 @@ function mountAgentRoutes(
         }),
       fireReminder: (reminderId, fireCount) =>
         reminderRunner.dispatch(reminderId, { expectedFireCount: fireCount }),
+      executeReminderDescriptor: async (descriptor) => {
+        if (reminderControlPlane === undefined) {
+          throw new Error("hosted reminder CP client is not configured");
+        }
+        const fireDescriptor = descriptor as unknown as ReminderFireDescriptor;
+        const outcome = await reminderRunner.executeFire(fireDescriptor);
+        // applyReminderOutcome is idempotent and internally retries transient
+        // CP failures. Handler execution is at-least-once across Temporal
+        // re-admission if apply ultimately fails.
+        const apply = await reminderControlPlane.applyReminderOutcome(
+          claimFromDescriptor(fireDescriptor),
+          outcome
+        );
+        // Cancel/rekey winning the race is a successful no-op from the guest's
+        // perspective (fired work may have run; lifecycle authority stayed CP).
+        if (!apply.applied && apply.reason === "missing") {
+          return {
+            reminderId: descriptor.id,
+            outcome: "noop" as const,
+            reason: apply.reason,
+          };
+        }
+        return {
+          reminderId: descriptor.id,
+          outcome: "fired" as const,
+        };
+      },
       drainSessionDurability: (sessionId) =>
         engine.drainSessionDurability(sessionId),
       flushOtel: args.flushOtel,
@@ -2360,75 +2427,18 @@ function mountAgentRoutes(
         method: channelRoute.method,
         pattern: `${base}/v1/channels/${channel.id}${channelRoute.path}`,
         auth: channelAuth,
-        handler: async (request, ctx) => {
-          const handlerArgs = buildChannelHandlerArgs({
-            runtime,
-            channelId: channel.id,
-            params: ctx.params,
-            requestIp: ctx.requestIp,
-            auth: ctx.auth,
-          });
-
-          if (channelRoute.querySchema !== undefined) {
-            const rawQuery = Object.fromEntries(
-              new URL(request.url).searchParams.entries()
-            );
-            const queryValidation = validateToolInput(
-              channelRoute.querySchema,
-              rawQuery
-            );
-            if (!queryValidation.ok) {
-              return jsonResponse(
-                { error: queryValidation.message },
-                { status: 400 }
-              );
-            }
-            handlerArgs.query = queryValidation.value;
-          }
-
-          if (channelRoute.bodySchema !== undefined) {
-            // Buffer once so handlers that need the raw body (e.g. GitHub
-            // HMAC) can still read `request.text()` / `request.json()`.
-            let bodyText: string;
-            try {
-              bodyText = await request.text();
-            } catch {
-              return jsonResponse(
-                { error: "Failed to read request body" },
-                { status: 400 }
-              );
-            }
-            let rawBody: unknown;
-            try {
-              rawBody = bodyText === "" ? {} : JSON.parse(bodyText);
-            } catch {
-              return jsonResponse(
-                { error: "Request body must be valid JSON" },
-                { status: 400 }
-              );
-            }
-            const bodyValidation = validateToolInput(
-              channelRoute.bodySchema,
-              rawBody
-            );
-            if (!bodyValidation.ok) {
-              return jsonResponse(
-                { error: bodyValidation.message },
-                { status: 400 }
-              );
-            }
-            handlerArgs.body = bodyValidation.value;
-            request = new Request(request.url, {
-              method: request.method,
-              headers: request.headers,
-              body: bodyText === "" ? undefined : bodyText,
-              // node: undici / fetch may require duplex for streamed bodies;
-              // a string body does not.
-            });
-          }
-
-          return channelRoute.handler(request, handlerArgs);
-        },
+        handler: (request, ctx) =>
+          invokeChannelRoute({
+            route: channelRoute,
+            request,
+            handlerArgs: buildChannelHandlerArgs({
+              runtime,
+              channelId: channel.id,
+              params: ctx.params,
+              requestIp: ctx.requestIp,
+              auth: ctx.auth,
+            }),
+          }),
       });
     }
   }