@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/runtime/routes/llm-context-normalization.ts

@@ -40,10 +40,27 @@ export interface LlmContextSection {
   language?: string;
 }
 
+/**
+ * Structured error extracted from a rejected call's response payload.
+ * Mirrors the on-disk `responsePayload.error` shape produced by
+ * `buildProviderErrorResponsePayload`. Present only when the call failed
+ * before returning a response — consumers branch on its presence to
+ * render the call as failed.
+ */
+export interface LlmContextError {
+  name?: string;
+  message?: string;
+  code?: string;
+  provider?: string;
+  statusCode?: number;
+  retryAfterMs?: number;
+}
+
 export interface LlmContextNormalizationResult {
   summary?: LlmContextSummary;
   requestSections?: LlmContextSection[];
   responseSections?: LlmContextSection[];
+  error?: LlmContextError;
 }
 
 interface NormalizedPayloadCandidate {
@@ -55,6 +72,60 @@ interface NormalizedPayloadCandidate {
 
 export function normalizeLlmContextPayloads(
   input: LlmContextNormalizationInput,
+): LlmContextNormalizationResult {
+  const base = normalizeSuccessPayloads(input);
+  const error = normalizeProviderErrorPayload(input.responsePayload);
+  if (!error) {
+    return base;
+  }
+  // A rejected call has no response sections to render — only the request
+  // side normalized. Attach the structured error so the inspector can show
+  // a failure banner and treat the cost as $0.00 instead of silently
+  // falling back to "section rendering unavailable".
+  return { ...base, error };
+}
+
+/**
+ * Detect a provider/transport error stored in the response payload.
+ *
+ * Error rows are written as `{ error: { name, message, code?, provider?,
+ * statusCode?, retryAfterMs? } }` by `buildProviderErrorResponsePayload`.
+ * Successful provider responses never carry a top-level `error` object, so
+ * the presence of one (with at least one identifying field) is a reliable
+ * signal that the call failed.
+ */
+function normalizeProviderErrorPayload(
+  responsePayload: unknown,
+): LlmContextError | null {
+  const error = asRecord(asRecord(responsePayload)?.error);
+  if (!error) {
+    return null;
+  }
+
+  const name = asString(error.name);
+  const message = asString(error.message);
+  const code = asString(error.code);
+  // Require at least one identifying field so an unrelated `error` key on a
+  // success payload isn't misread as a provider failure.
+  if (name === undefined && message === undefined && code === undefined) {
+    return null;
+  }
+
+  const normalized: LlmContextError = {};
+  if (name !== undefined) normalized.name = name;
+  if (message !== undefined) normalized.message = message;
+  if (code !== undefined) normalized.code = code;
+  const provider = asString(error.provider);
+  if (provider !== undefined) normalized.provider = provider;
+  const statusCode = asNumber(error.statusCode);
+  if (statusCode !== undefined) normalized.statusCode = statusCode;
+  const retryAfterMs = asNumber(error.retryAfterMs);
+  if (retryAfterMs !== undefined) normalized.retryAfterMs = retryAfterMs;
+  return normalized;
+}
+
+function normalizeSuccessPayloads(
+  input: LlmContextNormalizationInput,
 ): LlmContextNormalizationResult {
   const requestCandidates = [
     normalizeOpenAiRequestPayload(input.requestPayload),

package/src/runtime/routes/mcp-auth-routes.ts

@@ -24,7 +24,7 @@ import { getMcpAuthState } from "../../mcp/mcp-auth-state.js";
 import { deleteMcpOAuthCredentials } from "../../mcp/mcp-oauth-provider.js";
 import { getMcpToolsByServer } from "../../tools/registry.js";
 import { getLogger } from "../../util/logger.js";
-import { ACTOR_PRINCIPALS, GATEWAY_PRINCIPALS } from "../auth/route-policy.js";
+import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import type { RouteDefinition } from "./types.js";
 
@@ -281,6 +281,7 @@ async function handleMcpUpdate({
     maxTools,
     allowedTools,
     blockedTools,
+    headers,
   } = body as {
     name: string;
     enabled?: boolean;
@@ -288,6 +289,7 @@ async function handleMcpUpdate({
     maxTools?: number;
     allowedTools?: string[] | null;
     blockedTools?: string[] | null;
+    headers?: Record<string, string> | null;
   };
 
   const raw = loadRawConfig();
@@ -326,6 +328,19 @@ async function handleMcpUpdate({
       server.blockedTools = blockedTools;
     }
   }
+  if (headers !== undefined) {
+    const transport = server.transport as Record<string, unknown> | undefined;
+    if (
+      transport &&
+      (transport.type === "sse" || transport.type === "streamable-http")
+    ) {
+      if (headers === null || Object.keys(headers).length === 0) {
+        delete transport.headers;
+      } else {
+        transport.headers = headers;
+      }
+    }
+  }
 
   saveRawConfig(raw);
   triggerReload("internal_mcp_update");
@@ -342,15 +357,17 @@ async function handleMcpAdd({
 }: {
   body?: Record<string, unknown>;
 }): Promise<{ added: true }> {
-  const { name, transportType, url, command, args, risk, disabled } = body as {
-    name: string;
-    transportType: string;
-    url?: string;
-    command?: string;
-    args?: string[];
-    risk?: string;
-    disabled?: boolean;
-  };
+  const { name, transportType, url, command, args, risk, disabled, headers } =
+    body as {
+      name: string;
+      transportType: string;
+      url?: string;
+      command?: string;
+      args?: string[];
+      risk?: string;
+      disabled?: boolean;
+      headers?: Record<string, string>;
+    };
 
   const riskLevel = risk ?? "high";
   if (!["low", "medium", "high"].includes(riskLevel)) {
@@ -374,7 +391,11 @@ async function handleMcpAdd({
           `--url is required for ${transportType} transport`,
         );
       }
-      transport = { type: transportType, url };
+      transport = {
+        type: transportType,
+        url,
+        ...(headers && Object.keys(headers).length > 0 ? { headers } : {}),
+      };
       break;
     default:
       throw new BadRequestError(
@@ -455,8 +476,8 @@ export const ROUTES: RouteDefinition[] = [
     endpoint: "internal/mcp/auth/start",
     method: "POST",
     policy: {
-      requiredScopes: ["internal.write"],
-      allowedPrincipalTypes: GATEWAY_PRINCIPALS,
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
     },
     summary: "Start MCP OAuth flow",
     description:
@@ -470,8 +491,8 @@ export const ROUTES: RouteDefinition[] = [
     endpoint: "internal/mcp/auth/status/:serverId",
     method: "GET",
     policy: {
-      requiredScopes: ["internal.write"],
-      allowedPrincipalTypes: GATEWAY_PRINCIPALS,
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
     },
     summary: "Poll MCP OAuth flow status",
     description:
@@ -579,6 +600,7 @@ export const ROUTES: RouteDefinition[] = [
       maxTools: z.number().optional(),
       allowedTools: z.array(z.string()).nullable().optional(),
       blockedTools: z.array(z.string()).nullable().optional(),
+      headers: z.record(z.string(), z.string()).nullable().optional(),
     }),
     handler: handleMcpUpdate,
   },
@@ -602,6 +624,7 @@ export const ROUTES: RouteDefinition[] = [
       args: z.array(z.string()).optional(),
       risk: z.string().optional(),
       disabled: z.boolean().optional(),
+      headers: z.record(z.string(), z.string()).optional(),
     }),
     handler: handleMcpAdd,
   },

package/src/runtime/routes/migration-rollback-routes.ts

@@ -10,8 +10,9 @@
 import { z } from "zod";
 
 import { getDb } from "../../memory/db-connection.js";
-import { getMaxMigrationVersion } from "../../memory/migrations/registry.js";
+import { getMaxRollbackVersion } from "../../memory/migrations/run-migrations.js";
 import { rollbackMemoryMigration } from "../../memory/migrations/validate-migration-state.js";
+import { migrationSteps } from "../../memory/steps.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { WORKSPACE_MIGRATIONS } from "../../workspace/migrations/registry.js";
 import {
@@ -43,7 +44,7 @@ async function handleRollbackMigrations({ body = {} }: RouteHandlerArgs) {
 
   if (rollbackToRegistryCeiling === true) {
     if (effectiveDbVersion === undefined)
-      effectiveDbVersion = getMaxMigrationVersion();
+      effectiveDbVersion = getMaxRollbackVersion(migrationSteps);
     if (effectiveWorkspaceMigrationId === undefined)
       effectiveWorkspaceMigrationId =
         getLastWorkspaceMigrationId(WORKSPACE_MIGRATIONS) ?? undefined;
@@ -104,7 +105,7 @@ async function handleRollbackMigrations({ body = {} }: RouteHandlerArgs) {
   // Roll back DB migrations if requested.
   if (effectiveDbVersion !== undefined) {
     try {
-      rolledBack.db = rollbackMemoryMigration(getDb(), effectiveDbVersion);
+      rolledBack.db = rollbackMemoryMigration(getDb(), effectiveDbVersion, migrationSteps);
     } catch (err) {
       const detail = err instanceof Error ? err.message : "Unknown error";
       throw new InternalError(`DB migration rollback failed: ${detail}`);

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

@@ -28,9 +28,11 @@ import {
   getDb,
   getLogsSqlite,
   getMemorySqlite,
+  getTelemetrySqlite,
   resetDb,
 } from "../../memory/db-connection.js";
 import { validateMigrationState } from "../../memory/migrations/validate-migration-state.js";
+import { migrationSteps } from "../../memory/steps.js";
 import { credentialKey } from "../../security/credential-key.js";
 import {
   bulkSetSecureKeysAsync,
@@ -180,6 +182,7 @@ async function checkpointDbsForExport(): Promise<void> {
   for (const [label, sqlite] of [
     ["logs", getLogsSqlite()],
     ["memory", getMemorySqlite()],
+    ["telemetry", getTelemetrySqlite()],
   ] as const) {
     if (!sqlite) {
       log.warn(
@@ -1712,7 +1715,7 @@ function appendNewerMigrationWarningsIfAny(report: ImportCommitReport): void {
     return;
   }
   try {
-    const migrationValidation = validateMigrationState(getDb());
+    const migrationValidation = validateMigrationState(getDb(), migrationSteps);
     if (migrationValidation.unknownCheckpoints.length > 0) {
       report.warnings.push(
         `Imported data contains ${migrationValidation.unknownCheckpoints.length} migration(s) from a newer version. Some data may not be fully compatible.`,

package/src/runtime/routes/onboarding-checkin-routes.ts

@@ -0,0 +1,86 @@
+/**
+ * Route for programmatically scheduling the onboarding "Day 2 Check-in".
+ *
+ * POST /v1/onboarding/checkin — resolve the user's Google Calendar, find the
+ * first open 15-minute slot tomorrow afternoon, and book the check-in event.
+ *
+ * Called by the web `/onboarding/research` flow the moment Google Calendar
+ * OAuth lands. Best-effort by contract: a missing/insufficient calendar
+ * connection returns `{ scheduled: false }` rather than an error.
+ */
+
+import { z } from "zod";
+
+import { scheduleOnboardingCheckin } from "../../onboarding/schedule-checkin.js";
+import { getLogger } from "../../util/logger.js";
+import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const log = getLogger("onboarding-checkin-routes");
+
+function asOptionalString(value: unknown, field: string): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== "string") {
+    throw new BadRequestError(`${field} must be a string`);
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+async function handleScheduleOnboardingCheckin({
+  body = {},
+}: RouteHandlerArgs) {
+  // The shared route adapter does not runtime-validate the body against the
+  // Zod requestBody (codegen-only), so guard types before use.
+  const userName = asOptionalString(body.userName, "userName");
+  const assistantName = asOptionalString(body.assistantName, "assistantName");
+  const timeZone = asOptionalString(body.timezone, "timezone");
+
+  const result = await scheduleOnboardingCheckin({
+    userName,
+    assistantName,
+    timeZone,
+  });
+
+  if (!result.scheduled) {
+    log.info({ reason: result.reason }, "Onboarding check-in not scheduled");
+  }
+  return result;
+}
+
+const RESPONSE_SCHEMA = z.object({
+  scheduled: z.boolean(),
+  reason: z.string().optional(),
+  eventId: z.string().optional(),
+  htmlLink: z.string().nullable().optional(),
+  start: z.string().optional(),
+  end: z.string().optional(),
+  timeZone: z.string().optional(),
+});
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "scheduleOnboardingCheckin",
+    endpoint: "onboarding/checkin",
+    method: "POST",
+    policy: {
+      requiredScopes: ["chat.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Schedule the onboarding Day 2 check-in",
+    description:
+      "Find the first open 15-minute slot between 12pm and 5pm tomorrow " +
+      "(widening to 8am–8pm if booked) on the user's Google Calendar and " +
+      "create the Day 2 Check-in event. Best-effort: returns scheduled=false " +
+      "when no calendar is connected or the calendar scope wasn't granted.",
+    tags: ["onboarding"],
+    requestBody: z.object({
+      userName: z.string().optional(),
+      assistantName: z.string().optional(),
+      timezone: z.string().optional(),
+    }),
+    responseBody: RESPONSE_SCHEMA,
+    handler: handleScheduleOnboardingCheckin,
+  },
+];

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

@@ -39,6 +39,8 @@ export interface SubagentDetailResult {
     toolName?: string;
     isError?: boolean;
     messageId?: string;
+    toolUseId?: string;
+    input?: Record<string, unknown>;
   }>;
 }
 
@@ -112,6 +114,8 @@ export function parseSubagentMessages(
           type: "tool_use",
           content: JSON.stringify(input),
           toolName: name,
+          toolUseId: id || undefined,
+          input,
         });
         if (id) pendingTools.set(id, name);
       } else if (
@@ -147,6 +151,7 @@ export function parseSubagentMessages(
           content: resultContent,
           toolName: toolName ?? "unknown",
           isError,
+          toolUseId: toolUseId || undefined,
         });
       }
     }

package/src/runtime/routes/surface-action-routes.ts

@@ -9,20 +9,17 @@
  */
 import { z } from "zod";
 
-import type { ChannelId } from "../../channels/types.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
-import { findGuardianForChannel } from "../../contacts/contact-store.js";
+import type { TrustContext } from "../../daemon/trust-context.js";
 import { getLogger } from "../../util/logger.js";
-import type { TrustClass } from "../actor-trust-resolver.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { processGuardianDecision } from "../guardian-action-service.js";
-import { healGuardianBindingDrift } from "../guardian-vellum-migration.js";
-import { resolveLocalTrustContext } from "../local-actor-identity.js";
+import { reResolveTrustOnResetDrift } from "../guardian-vellum-migration.js";
 import {
-  resolveTrustContext,
-  withSourceChannel,
-} from "../trust-context-resolver.js";
+  findLocalGuardianPrincipalId,
+  resolveActorPrincipalIdForLocalGuardian,
+} from "../local-actor-identity.js";
+import { resolveLocalPrincipalTrustContext } from "../local-principal-trust.js";
 import { parseCallbackData } from "./channel-route-shared.js";
 import {
   BadRequestError,
@@ -40,58 +37,51 @@ const log = getLogger("surface-action-routes");
 // ---------------------------------------------------------------------------
 
 /**
- * Resolve trust context from the actor principal ID and set it on the
- * conversation, following the same pattern as POST /v1/messages. This ensures
- * surface actions inherit the correct trust class (guardian vs trusted_contact)
- * rather than defaulting to unknown.
+ * Resolve trust context for the actor principal from the gateway guardian
+ * binding and set it on the conversation. A vellum principal is the guardian or
+ * nobody, so the mapper yields guardian or unknown.
  */
-function applyTrustContext(
+async function applyTrustContext(
   conversation: {
-    setTrustContext?(ctx: {
-      trustClass: TrustClass;
-      sourceChannel: ChannelId;
-    }): void;
+    setTrustContext?(ctx: TrustContext): void;
   },
   actorPrincipalId: string | undefined,
-): void {
+): Promise<void> {
   if (!conversation.setTrustContext) return;
 
   const sourceChannel = "vellum";
 
-  if (actorPrincipalId) {
-    if (isHttpAuthDisabled() && actorPrincipalId === "dev-bypass") {
-      conversation.setTrustContext(resolveLocalTrustContext(sourceChannel));
-    } else {
-      const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
-      let trustCtx = resolveTrustContext({
-        assistantId,
-        sourceChannel,
-        conversationExternalId: "local",
-        actorExternalId: actorPrincipalId,
-      });
-      if (trustCtx.trustClass === "unknown") {
-        const healed = healGuardianBindingDrift(actorPrincipalId);
-        if (healed) {
-          trustCtx = resolveTrustContext({
-            assistantId,
-            sourceChannel,
-            conversationExternalId: "local",
-            actorExternalId: actorPrincipalId,
-          });
-          log.info(
-            {
-              actorPrincipalId,
-              trustClass: trustCtx.trustClass,
-            },
-            "Trust re-resolved after guardian binding drift heal (surface action)",
-          );
-        }
+  if (!actorPrincipalId) {
+    conversation.setTrustContext({ trustClass: "guardian", sourceChannel });
+    return;
+  }
+
+  // Dev-bypass injects a synthetic principal that won't match the real
+  // guardian binding, so resolve the actual guardian principalId (gateway
+  // first, local store fallback) before mapping trust.
+  let principalId = actorPrincipalId;
+  if (isHttpAuthDisabled() && actorPrincipalId === "dev-bypass") {
+    principalId = (await findLocalGuardianPrincipalId()) ?? actorPrincipalId;
+  }
+
+  let trustCtx = await resolveLocalPrincipalTrustContext({
+    actorPrincipalId: principalId,
+    sourceChannel,
+    conversationExternalId: "local",
+  });
+  if (trustCtx.trustClass === "unknown") {
+    const healed = await reResolveTrustOnResetDrift(principalId, sourceChannel);
+    if (healed) {
+      trustCtx = healed;
+      if (healed.trustClass !== "unknown") {
+        log.info(
+          { actorPrincipalId: principalId, trustClass: trustCtx.trustClass },
+          "Trust re-resolved from local mirror after gateway reset drift (surface action)",
+        );
       }
-      conversation.setTrustContext(withSourceChannel(sourceChannel, trustCtx));
     }
-  } else {
-    conversation.setTrustContext({ trustClass: "guardian", sourceChannel });
   }
+  conversation.setTrustContext(trustCtx);
 }
 
 // ---------------------------------------------------------------------------
@@ -129,16 +119,15 @@ async function handleSurfaceAction({
   const aprDecision = parseCallbackData(actionId, "vellum");
   if (aprDecision) {
     // Resolve the actor's guardian principal ID. In dev mode the synthetic
-    // "dev-bypass" principal won't match the real guardian binding, so fall
-    // back to the local guardian binding — mirrors guardian-action-routes.ts.
+    // "dev-bypass" principal won't match the real guardian binding, so resolve
+    // the local guardian principal — mirrors guardian-action-routes.ts.
     let guardianPrincipalId: string | undefined =
       headers?.["x-vellum-actor-principal-id"] ?? undefined;
     if (
       isHttpAuthDisabled() &&
       headers?.["x-vellum-actor-principal-id"] === "dev-bypass"
     ) {
-      const binding = findGuardianForChannel("vellum");
-      guardianPrincipalId = binding?.contact.principalId ?? undefined;
+      guardianPrincipalId = (await findLocalGuardianPrincipalId()) ?? undefined;
     }
 
     const result = await processGuardianDecision({
@@ -186,13 +175,20 @@ async function handleSurfaceAction({
   }
 
   const actorPrincipalId = headers?.["x-vellum-actor-principal-id"];
-  applyTrustContext(conversation, actorPrincipalId);
+  await applyTrustContext(conversation, actorPrincipalId);
+
+  // Translate dev-bypass → real guardian so the surface turn's principal matches
+  // the SSE host-proxy client's registered principal; otherwise CU/app-control
+  // same-actor checks reject the turn. Real principals pass through unchanged.
+  const resolvedActorPrincipalId =
+    await resolveActorPrincipalIdForLocalGuardian(actorPrincipalId ?? undefined);
 
   try {
     const raw = await conversation.handleSurfaceAction(
       surfaceId,
       actionId,
       data,
+      resolvedActorPrincipalId,
     );
     const result =
       raw && typeof raw === "object" && "accepted" in raw

package/src/runtime/services/__tests__/conversation-serializer.test.ts

@@ -48,6 +48,7 @@ function makeConversationRow(
     inferenceProfileSessionId: null,
     inferenceProfileExpiresAt: null,
     lastNotifiedInferenceProfile: null,
+    processingStartedAt: null,
     ...overrides,
   };
 }

package/src/runtime/services/conversation-serializer.ts

@@ -9,7 +9,6 @@
 
 import { parseChannelId } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
-import { findConversation } from "../../daemon/conversation-registry.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
 import {
   type AttentionState,
@@ -21,6 +20,7 @@ import {
   type ConversationRow,
   getConversation,
   getDisplayMetaForConversations,
+  isConversationProcessing,
 } from "../../memory/conversation-crud.js";
 import type { ExternalConversationBinding } from "../../memory/external-conversation-store.js";
 import { getBindingsForConversations } from "../../memory/external-conversation-store.js";
@@ -196,9 +196,9 @@ export function serializeConversationSummary(params: {
   parentCache: Map<string, ConversationRow | null>;
   /**
    * Whether the agent loop is currently mid-turn for this conversation.
-   * Sourced from the in-memory daemon `Conversation.isProcessing()` flag
-   * — callers resolve via `findConversation(id)?.isProcessing() ?? false`
-   * so cold (evicted / never-loaded) rows report `false`. Plumbed in
+   * Resolved by `isConversationProcessing(id)`, which checks the in-memory
+   * daemon flag first and falls back to the persisted
+   * `processing_started_at` column for cold conversations. Plumbed in
    * rather than read here so the serializer stays a pure shape mapper
    * with no daemon-store coupling.
    */
@@ -286,11 +286,9 @@ export function buildConversationDetailResponse(
       attentionState: attentionStates.get(conversation.id),
       displayMeta: displayMeta.get(conversation.id),
       parentCache,
-      // Cold (evicted / never-loaded) rows aren't in the in-memory
-      // store, so `findConversation` returns `undefined` and they
-      // report `isProcessing: false` — by definition they aren't
-      // mid-turn since the agent loop only runs on resident convs.
-      isProcessing: findConversation(conversation.id)?.isProcessing() ?? false,
+      // Checks in-memory flag first (hot path), falls back to the
+      // persisted `processing_started_at` column for cold conversations.
+      isProcessing: isConversationProcessing(conversation.id),
     }),
   };
 }

package/src/runtime/tool-grant-request-helper.ts

@@ -59,9 +59,9 @@ export type ToolGrantRequestResult =
  * Returns a result indicating whether a new request was created, an existing
  * one was deduped, or the escalation failed (no binding, missing identity).
  */
-export function createOrReuseToolGrantRequest(
+export async function createOrReuseToolGrantRequest(
   params: ToolGrantRequestParams,
-): ToolGrantRequestResult {
+): Promise<ToolGrantRequestResult> {
   const {
     assistantId,
     sourceChannel,
@@ -78,7 +78,7 @@ export function createOrReuseToolGrantRequest(
     return { failed: true, reason: "missing_identity" };
   }
 
-  const binding = getGuardianBinding(assistantId, sourceChannel);
+  const binding = await getGuardianBinding(assistantId, sourceChannel);
   if (!binding) {
     log.debug(
       { sourceChannel, assistantId },