@vellumai/assistant 0.11.10 → 0.11.11-staging.1

package/src/runtime/routes/heartbeat-routes.ts

@@ -20,6 +20,7 @@ import { listHeartbeatRuns } from "../../heartbeat/heartbeat-run-store.js";
 import { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
 import { getConversation } from "../../persistence/conversation-crud.js";
 import { getUsageCostForConversationWindow } from "../../persistence/llm-usage-store.js";
+import { resolveScheduleTimezone } from "../../schedule/schedule-timezone.js";
 import { readTextFileSync } from "../../util/fs.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspacePromptPath } from "../../util/platform.js";
@@ -36,6 +37,41 @@ import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("heartbeat-routes");
 
+const HeartbeatConfigResponseSchema = z.object({
+  enabled: z.boolean(),
+  intervalMs: z.number(),
+  activeHoursStart: z.number().nullable(),
+  activeHoursEnd: z.number().nullable(),
+  cronExpression: z.string().nullable(),
+  timezone: z.string().nullable(),
+  effectiveTimezone: z
+    .string()
+    .nullable()
+    .describe(
+      "Timezone used for cron and active-hours evaluation after resolving heartbeat.timezone, then the user's configured or detected zone",
+    ),
+  nextRunAt: z.number().nullable(),
+  lastRunAt: z.number().nullable(),
+  success: z.boolean(),
+});
+
+function heartbeatConfigResponse() {
+  const heartbeat = getConfig().heartbeat;
+  const svc = HeartbeatService.getInstance();
+  return {
+    enabled: heartbeat.enabled,
+    intervalMs: heartbeat.intervalMs,
+    activeHoursStart: heartbeat.activeHoursStart ?? null,
+    activeHoursEnd: heartbeat.activeHoursEnd ?? null,
+    cronExpression: heartbeat.cronExpression ?? null,
+    timezone: heartbeat.timezone ?? null,
+    effectiveTimezone: resolveScheduleTimezone(heartbeat.timezone),
+    nextRunAt: svc?.nextRunAt ?? null,
+    lastRunAt: svc?.lastRunAt ?? null,
+    success: true,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Handlers (transport-agnostic)
 // ---------------------------------------------------------------------------
@@ -196,32 +232,8 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Get heartbeat config",
     description: "Return the current heartbeat schedule configuration.",
     tags: ["heartbeat"],
-    responseBody: z.object({
-      enabled: z.boolean(),
-      intervalMs: z.number(),
-      activeHoursStart: z.number().nullable(),
-      activeHoursEnd: z.number().nullable(),
-      cronExpression: z.string().nullable(),
-      timezone: z.string().nullable(),
-      nextRunAt: z.number().nullable(),
-      lastRunAt: z.number().nullable(),
-      success: z.boolean(),
-    }),
-    handler: async (_args: RouteHandlerArgs) => {
-      const config = getConfig().heartbeat;
-      const svc = HeartbeatService.getInstance();
-      return {
-        enabled: config.enabled,
-        intervalMs: config.intervalMs,
-        activeHoursStart: config.activeHoursStart ?? null,
-        activeHoursEnd: config.activeHoursEnd ?? null,
-        cronExpression: config.cronExpression ?? null,
-        timezone: config.timezone ?? null,
-        nextRunAt: svc?.nextRunAt ?? null,
-        lastRunAt: svc?.lastRunAt ?? null,
-        success: true,
-      };
-    },
+    responseBody: HeartbeatConfigResponseSchema,
+    handler: async (_args: RouteHandlerArgs) => heartbeatConfigResponse(),
   },
   {
     operationId: "updateHeartbeatConfig",
@@ -258,19 +270,9 @@ export const ROUTES: RouteDefinition[] = [
         .string()
         .nullable()
         .optional()
-        .describe("Timezone for cron evaluation"),
-    }),
-    responseBody: z.object({
-      enabled: z.boolean(),
-      intervalMs: z.number(),
-      activeHoursStart: z.number().nullable(),
-      activeHoursEnd: z.number().nullable(),
-      cronExpression: z.string().nullable(),
-      timezone: z.string().nullable(),
-      nextRunAt: z.number().nullable(),
-      lastRunAt: z.number().nullable(),
-      success: z.boolean(),
+        .describe("Timezone for cron and active-hours evaluation"),
     }),
+    responseBody: HeartbeatConfigResponseSchema,
     handler: async ({ body = {} }: RouteHandlerArgs) => {
       // Build a patch containing only the fields the caller actually set.
       // Writing back the full Zod-defaulted heartbeat object would bake
@@ -316,24 +318,10 @@ export const ROUTES: RouteDefinition[] = [
         throw new InternalError("Failed to save config");
       }
 
-      // Read effective values back through the schema-defaulting loader so
-      // callers that only set a subset of fields still see the resolved
-      // (post-default) shape in the response.
-      const heartbeat = getConfig().heartbeat;
       const svc = HeartbeatService.getInstance();
       svc?.reconfigure();
 
-      return {
-        enabled: heartbeat.enabled,
-        intervalMs: heartbeat.intervalMs,
-        activeHoursStart: heartbeat.activeHoursStart ?? null,
-        activeHoursEnd: heartbeat.activeHoursEnd ?? null,
-        cronExpression: heartbeat.cronExpression ?? null,
-        timezone: heartbeat.timezone ?? null,
-        nextRunAt: svc?.nextRunAt ?? null,
-        lastRunAt: svc?.lastRunAt ?? null,
-        success: true,
-      };
+      return heartbeatConfigResponse();
     },
   },
   {

package/src/runtime/routes/host-app-control-routes.ts

@@ -19,15 +19,10 @@ import type {
   HostAppControlResultPayload,
   HostAppControlState,
 } from "../../daemon/message-types/host-app-control.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import {
-  enforceSameActorOrThrow,
-  SAME_ACTOR_FORBIDDEN_DESCRIPTION,
-} from "../auth/same-actor.js";
-import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+import { SAME_ACTOR_FORBIDDEN_DESCRIPTION } from "../auth/same-actor.js";
 import * as pendingInteractions from "../pending-interactions.js";
-import { BadRequestError, ForbiddenError } from "./errors.js";
+import { assertHostProxyResultBinding } from "./host-proxy-result-binding.js";
 import { parseBody } from "./parse-body.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -93,35 +88,14 @@ async function handleHostAppControlResult({ body, headers }: RouteHandlerArgs) {
     return { accepted: true };
   }
 
-  // Same-actor binding: when the pending interaction has a targetClientId,
-  // validate the submitting client matches and the actor principals align.
-  // Mirrors host-browser / host-cu / host-bash result routes.
-  if (peeked.targetClientId != null) {
-    const headerMap = headers ?? {};
-    const submittingClientId =
-      headerMap["x-vellum-client-id"]?.trim() || undefined;
-    if (!submittingClientId) {
-      throw new BadRequestError(
-        "x-vellum-client-id header is missing for a targeted host app-control request.",
-      );
-    }
-    if (submittingClientId !== peeked.targetClientId) {
-      throw new ForbiddenError(
-        `Client "${submittingClientId}" is not the target for this request (expected "${peeked.targetClientId}"). The targeted client must submit the result.`,
-      );
-    }
-    const submittingActorPrincipalId =
-      await resolveActorPrincipalIdForLocalGuardian(
-        headerMap["x-vellum-actor-principal-id"]?.trim() || undefined,
-      );
-    enforceSameActorOrThrow({
-      sourceActorPrincipalId: submittingActorPrincipalId,
-      targetActorPrincipalId: peeked.targetActorPrincipalId,
-      targetClientId: peeked.targetClientId,
-      op: "host_app_control",
-      hubForMissingTarget: assistantEventHub,
-    });
-  }
+  await assertHostProxyResultBinding({
+    headers,
+    targetClientId: peeked.targetClientId,
+    targetActorPrincipalId: peeked.targetActorPrincipalId,
+    op: "host_app_control",
+    missingClientIdMessage:
+      "x-vellum-client-id header is missing for a targeted host app-control request.",
+  });
 
   const interaction = pendingInteractions.resolve(requestId, "answered")!;
   const conversation = findConversation(interaction.conversationId);

package/src/runtime/routes/host-bash-routes.ts

@@ -7,20 +7,11 @@
 import { z } from "zod";
 
 import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import {
-  enforceSameActorOrThrow,
-  SAME_ACTOR_FORBIDDEN_DESCRIPTION,
-} from "../auth/same-actor.js";
-import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+import { SAME_ACTOR_FORBIDDEN_DESCRIPTION } from "../auth/same-actor.js";
 import * as pendingInteractions from "../pending-interactions.js";
-import {
-  BadRequestError,
-  ConflictError,
-  ForbiddenError,
-  NotFoundError,
-} from "./errors.js";
+import { ConflictError, NotFoundError } from "./errors.js";
+import { assertHostProxyResultBinding } from "./host-proxy-result-binding.js";
 import { parseBody } from "./parse-body.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -59,13 +50,6 @@ async function handleHostBashResult({ body, headers }: RouteHandlerArgs) {
     body,
   );
 
-  const submittingClientId =
-    headers?.["x-vellum-client-id"]?.trim() || undefined;
-  const submittingActorPrincipalId =
-    await resolveActorPrincipalIdForLocalGuardian(
-      headers?.["x-vellum-actor-principal-id"]?.trim() || undefined,
-    );
-
   const peeked = pendingInteractions.get(requestId);
   if (!peeked) {
     throw new NotFoundError("No pending interaction found for this requestId");
@@ -77,32 +61,14 @@ async function handleHostBashResult({ body, headers }: RouteHandlerArgs) {
     );
   }
 
-  const { targetClientId } = peeked;
-  if (targetClientId) {
-    if (!submittingClientId) {
-      throw new BadRequestError(
-        "x-vellum-client-id header is required for targeted host bash requests",
-      );
-    }
-    if (submittingClientId !== targetClientId) {
-      throw new ForbiddenError(
-        `Client "${submittingClientId}" is not the target for this request (expected "${targetClientId}"). The targeted client must submit the result.`,
-      );
-    }
-
-    // Defense-in-depth on top of the client-id header binding above: the
-    // submitting actor's principal must match the actor principal stored
-    // for the target client at SSE subscription time. This prevents a
-    // cross-user submission even when the attacker can guess or spoof the
-    // target's client ID.
-    enforceSameActorOrThrow({
-      sourceActorPrincipalId: submittingActorPrincipalId,
-      targetActorPrincipalId: peeked.targetActorPrincipalId,
-      targetClientId,
-      op: "host_bash",
-      hubForMissingTarget: assistantEventHub,
-    });
-  }
+  await assertHostProxyResultBinding({
+    headers,
+    targetClientId: peeked.targetClientId,
+    targetActorPrincipalId: peeked.targetActorPrincipalId,
+    op: "host_bash",
+    missingClientIdMessage:
+      "x-vellum-client-id header is required for targeted host bash requests",
+  });
 
   HostBashProxy.instance.resolveResult(requestId, {
     stdout: stdout ?? "",

package/src/runtime/routes/host-browser-routes.ts

@@ -149,6 +149,30 @@ export async function resolveHostBrowserResultByRequestId(
         message: err instanceof Error ? err.message : "Same-actor check failed",
       };
     }
+  } else if (peeked.targetActorPrincipalId) {
+    const headerMap = headers ?? {};
+    const submittingClientId =
+      headerMap["x-vellum-client-id"]?.trim() || undefined;
+    const submittingActorPrincipalId =
+      await resolveActorPrincipalIdForLocalGuardian(
+        headerMap["x-vellum-actor-principal-id"]?.trim() || undefined,
+      );
+    try {
+      enforceSameActorOrThrow({
+        sourceActorPrincipalId: submittingActorPrincipalId,
+        targetActorPrincipalId: peeked.targetActorPrincipalId,
+        targetClientId: submittingClientId ?? "",
+        op: "host_browser",
+        hubForMissingTarget: assistantEventHub,
+      });
+    } catch (err) {
+      return {
+        ok: false,
+        code: "FORBIDDEN",
+        status: 403,
+        message: err instanceof Error ? err.message : "Same-actor check failed",
+      };
+    }
   }
 
   const normalizedContent = typeof content === "string" ? content : "";

package/src/runtime/routes/host-cu-routes.ts

@@ -7,20 +7,11 @@
 import { z } from "zod";
 
 import { findConversation } from "../../daemon/conversation-registry.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import {
-  enforceSameActorOrThrow,
-  SAME_ACTOR_FORBIDDEN_DESCRIPTION,
-} from "../auth/same-actor.js";
-import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+import { SAME_ACTOR_FORBIDDEN_DESCRIPTION } from "../auth/same-actor.js";
 import * as pendingInteractions from "../pending-interactions.js";
-import {
-  BadRequestError,
-  ConflictError,
-  ForbiddenError,
-  NotFoundError,
-} from "./errors.js";
+import { ConflictError, NotFoundError } from "./errors.js";
+import { assertHostProxyResultBinding } from "./host-proxy-result-binding.js";
 import { parseBody } from "./parse-body.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -78,39 +69,14 @@ async function handleHostCuResult({ body, headers }: RouteHandlerArgs) {
     );
   }
 
-  // Validate submitting client matches the targeted client (if any).
-  if (peeked.targetClientId != null) {
-    const headerMap = (headers as Record<string, string | undefined>) ?? {};
-    const submittingClientId =
-      headerMap["x-vellum-client-id"]?.trim() || undefined;
-    if (!submittingClientId) {
-      throw new BadRequestError(
-        "x-vellum-client-id header is missing for a targeted host CU request.",
-      );
-    }
-    if (submittingClientId !== peeked.targetClientId) {
-      throw new ForbiddenError(
-        `Client "${submittingClientId}" is not the target for this request (expected "${peeked.targetClientId}"). The targeted client must submit the result.`,
-      );
-    }
-
-    // Defense-in-depth: require the submitting actor's principal id to match
-    // the actor principal id captured when the target client opened its SSE
-    // stream. This prevents a different authenticated user with knowledge of
-    // both the requestId and target clientId from submitting a result on
-    // behalf of the targeted client.
-    const submittingActorPrincipalId =
-      await resolveActorPrincipalIdForLocalGuardian(
-        headerMap["x-vellum-actor-principal-id"]?.trim() || undefined,
-      );
-    enforceSameActorOrThrow({
-      sourceActorPrincipalId: submittingActorPrincipalId,
-      targetActorPrincipalId: peeked.targetActorPrincipalId,
-      targetClientId: peeked.targetClientId,
-      op: "host_cu",
-      hubForMissingTarget: assistantEventHub,
-    });
-  }
+  await assertHostProxyResultBinding({
+    headers: headers as Record<string, string | undefined> | undefined,
+    targetClientId: peeked.targetClientId,
+    targetActorPrincipalId: peeked.targetActorPrincipalId,
+    op: "host_cu",
+    missingClientIdMessage:
+      "x-vellum-client-id header is missing for a targeted host CU request.",
+  });
 
   // Conversation-agnostic observation (see `runtime/host-observe.ts`): the
   // request was raised outside any turn, so there is no conversation and no CU

package/src/runtime/routes/host-file-routes.ts

@@ -7,20 +7,11 @@
 import { z } from "zod";
 
 import { HostFileProxy } from "../../daemon/host-file-proxy.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import {
-  enforceSameActorOrThrow,
-  SAME_ACTOR_FORBIDDEN_DESCRIPTION,
-} from "../auth/same-actor.js";
-import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+import { SAME_ACTOR_FORBIDDEN_DESCRIPTION } from "../auth/same-actor.js";
 import * as pendingInteractions from "../pending-interactions.js";
-import {
-  BadRequestError,
-  ConflictError,
-  ForbiddenError,
-  NotFoundError,
-} from "./errors.js";
+import { ConflictError, NotFoundError } from "./errors.js";
+import { assertHostProxyResultBinding } from "./host-proxy-result-binding.js";
 import { parseBody } from "./parse-body.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -69,38 +60,14 @@ async function handleHostFileResult({ body, headers }: RouteHandlerArgs) {
     );
   }
 
-  // Validate submitting client matches the targeted client (if any).
-  if (peeked.targetClientId != null) {
-    const headerMap = (headers as Record<string, string | undefined>) ?? {};
-    const submittingClientId =
-      headerMap["x-vellum-client-id"]?.trim() || undefined;
-    if (!submittingClientId) {
-      throw new BadRequestError(
-        "x-vellum-client-id header is missing for a targeted host file request.",
-      );
-    }
-    if (submittingClientId !== peeked.targetClientId) {
-      throw new ForbiddenError(
-        `Client "${submittingClientId}" is not the target for this request (expected "${peeked.targetClientId}"). The targeted client must submit the result.`,
-      );
-    }
-
-    // Defense-in-depth: also require the submitting actor's principal id to
-    // match the actor that opened the target client's SSE stream. This blocks
-    // cross-user submissions even if a different user somehow obtains the
-    // target client id.
-    const submittingActorPrincipalId =
-      await resolveActorPrincipalIdForLocalGuardian(
-        headerMap["x-vellum-actor-principal-id"]?.trim() || undefined,
-      );
-    enforceSameActorOrThrow({
-      sourceActorPrincipalId: submittingActorPrincipalId,
-      targetActorPrincipalId: peeked.targetActorPrincipalId,
-      targetClientId: peeked.targetClientId,
-      op: "host_file",
-      hubForMissingTarget: assistantEventHub,
-    });
-  }
+  await assertHostProxyResultBinding({
+    headers: headers as Record<string, string | undefined> | undefined,
+    targetClientId: peeked.targetClientId,
+    targetActorPrincipalId: peeked.targetActorPrincipalId,
+    op: "host_file",
+    missingClientIdMessage:
+      "x-vellum-client-id header is missing for a targeted host file request.",
+  });
 
   HostFileProxy.instance.resolve(requestId, {
     content: content ?? "",

package/src/runtime/routes/host-proxy-result-binding.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared binding checks for host-proxy result (and transfer content) routes.
+ *
+ * Targeted requests still require the submitting client id to match the
+ * pending `targetClientId`. When a request was dispatched untargeted, the
+ * pending interaction may still carry `targetActorPrincipalId` (the turn's
+ * source actor). In that case the same-actor check still runs so a different
+ * principal cannot forge stdout/stderr/exitCode for someone else's command.
+ *
+ * Identity-less local flows (neither target client nor source actor recorded)
+ * keep the open path.
+ */
+import { assistantEventHub } from "../assistant-event-hub.js";
+import {
+  enforceSameActorOrThrow,
+  type SameActorOp,
+} from "../auth/same-actor.js";
+import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+import { BadRequestError, ForbiddenError } from "./errors.js";
+
+export async function assertHostProxyResultBinding(args: {
+  headers?: Record<string, string | undefined>;
+  targetClientId?: string;
+  targetActorPrincipalId?: string;
+  op: SameActorOp;
+  missingClientIdMessage: string;
+}): Promise<void> {
+  const submittingClientId =
+    args.headers?.["x-vellum-client-id"]?.trim() || undefined;
+  const submittingActorPrincipalId =
+    await resolveActorPrincipalIdForLocalGuardian(
+      args.headers?.["x-vellum-actor-principal-id"]?.trim() || undefined,
+    );
+
+  if (args.targetClientId) {
+    if (!submittingClientId) {
+      throw new BadRequestError(args.missingClientIdMessage);
+    }
+    if (submittingClientId !== args.targetClientId) {
+      throw new ForbiddenError(
+        `Client "${submittingClientId}" is not the target for this request (expected "${args.targetClientId}"). The targeted client must submit the result.`,
+      );
+    }
+  }
+
+  if (!args.targetClientId && !args.targetActorPrincipalId) {
+    return;
+  }
+
+  enforceSameActorOrThrow({
+    sourceActorPrincipalId: submittingActorPrincipalId,
+    targetActorPrincipalId: args.targetActorPrincipalId,
+    targetClientId: args.targetClientId ?? submittingClientId ?? "",
+    op: args.op,
+    hubForMissingTarget: assistantEventHub,
+  });
+}

package/src/runtime/routes/host-transfer-routes.ts

@@ -22,6 +22,7 @@ import {
   ForbiddenError,
   NotFoundError,
 } from "./errors.js";
+import { assertHostProxyResultBinding } from "./host-proxy-result-binding.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 /**
@@ -86,6 +87,18 @@ async function handleTransferContentGet({
       op: "host_transfer",
       hubForMissingTarget: assistantEventHub,
     });
+  } else {
+    const targetActorPrincipalId =
+      match.proxy.getTargetActorPrincipalIdForTransfer(transferId);
+    if (targetActorPrincipalId) {
+      await assertHostProxyResultBinding({
+        headers: headers as Record<string, string | undefined>,
+        targetActorPrincipalId,
+        op: "host_transfer",
+        missingClientIdMessage:
+          "x-vellum-client-id header required for targeted transfer",
+      });
+    }
   }
 
   const content = match.proxy.getTransferContent(transferId);
@@ -172,6 +185,18 @@ async function handleTransferContentPut({
       op: "host_transfer",
       hubForMissingTarget: assistantEventHub,
     });
+  } else {
+    const targetActorPrincipalId =
+      match.proxy.getTargetActorPrincipalIdForTransfer(transferId);
+    if (targetActorPrincipalId) {
+      await assertHostProxyResultBinding({
+        headers: headers as Record<string, string | undefined>,
+        targetActorPrincipalId,
+        op: "host_transfer",
+        missingClientIdMessage:
+          "x-vellum-client-id header required for targeted transfer",
+      });
+    }
   }
 
   const data = rawBody ? Buffer.from(rawBody) : Buffer.alloc(0);
@@ -221,31 +246,14 @@ async function handleTransferResult({ body, headers }: RouteHandlerArgs) {
     );
   }
 
-  if (peeked.targetClientId != null) {
-    const headerMap = (headers as Record<string, string | undefined>) ?? {};
-    const rawClientId = headerMap["x-vellum-client-id"];
-    const submittingClientId = rawClientId?.trim() || undefined;
-    if (!submittingClientId) {
-      throw new BadRequestError(
-        "x-vellum-client-id header is missing for a targeted host transfer request.",
-      );
-    }
-    if (submittingClientId !== peeked.targetClientId) {
-      throw new ForbiddenError(
-        `Client "${submittingClientId}" is not the target for this request (expected "${peeked.targetClientId}").`,
-      );
-    }
-
-    enforceSameActorOrThrow({
-      sourceActorPrincipalId: await resolveActorPrincipalIdForLocalGuardian(
-        headerMap["x-vellum-actor-principal-id"]?.trim() || undefined,
-      ),
-      targetActorPrincipalId: peeked.targetActorPrincipalId,
-      targetClientId: peeked.targetClientId,
-      op: "host_transfer",
-      hubForMissingTarget: assistantEventHub,
-    });
-  }
+  await assertHostProxyResultBinding({
+    headers: headers as Record<string, string | undefined> | undefined,
+    targetClientId: peeked.targetClientId,
+    targetActorPrincipalId: peeked.targetActorPrincipalId,
+    op: "host_transfer",
+    missingClientIdMessage:
+      "x-vellum-client-id header is missing for a targeted host transfer request.",
+  });
 
   HostTransferProxy.instance.resolveTransferResult(requestId, {
     isError: isError ?? false,

package/src/runtime/routes/index.ts

@@ -140,7 +140,6 @@ import { ROUTES as SCHEDULE_WORKER_ROUTES } from "./schedule-worker-routes.js";
 import { ROUTES as SECRET_ROUTES } from "./secret-routes.js";
 import { ROUTES as SEQUENCE_ROUTES } from "./sequence-routes.js";
 import { ROUTES as SETTINGS_ROUTES } from "./settings-routes.js";
-import { ROUTES as SIGHT_FRAME_ROUTES } from "./sight-frame-routes.js";
 import { ROUTES as SKILL_ROUTES } from "./skills-routes.js";
 import { ROUTES as SLACK_CHANNEL_RESOLVE_ROUTES } from "./slack-channel-routes.js";
 import { ROUTES as SOUNDS_CONFIG_ROUTES } from "./sounds-config-routes.js";
@@ -290,7 +289,6 @@ export const ROUTES: RouteDefinition[] = [
   ...SANITY_ROUTES,
   ...SECRET_ROUTES,
   ...SETTINGS_ROUTES,
-  ...SIGHT_FRAME_ROUTES,
   ...SOUNDS_CONFIG_ROUTES,
   ...SKILL_ROUTES,
   ...A2A_ROUTES,

package/src/runtime/routes/integrations/a2a.ts

@@ -230,7 +230,10 @@ export const ROUTES: RouteDefinition[] = [
     operationId: "integrations_a2a_config_get",
     endpoint: "integrations/a2a/config",
     method: "GET",
-    policy: null,
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
     summary: "Get A2A config",
     description: "Check current A2A channel configuration status.",
     tags: ["integrations"],
@@ -241,7 +244,10 @@ export const ROUTES: RouteDefinition[] = [
     operationId: "integrations_a2a_config_post",
     endpoint: "integrations/a2a/config",
     method: "POST",
-    policy: null,
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
     summary: "Enable A2A channel",
     description: "Enable the A2A channel for inter-assistant communication.",
     tags: ["integrations"],
@@ -252,7 +258,10 @@ export const ROUTES: RouteDefinition[] = [
     operationId: "integrations_a2a_config_delete",
     endpoint: "integrations/a2a/config",
     method: "DELETE",
-    policy: null,
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
     summary: "Disable A2A channel",
     description: "Disable the A2A channel.",
     tags: ["integrations"],