@vellumai/assistant 0.8.4 → 0.8.5

package/src/runtime/routes/conversation-starter-routes.ts

@@ -21,7 +21,10 @@ import {
   isValidConversationStarterText,
 } from "../../memory/conversation-starter-validation.js";
 import { getDb } from "../../memory/db-connection.js";
-import { enqueueMemoryJob } from "../../memory/jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+} from "../../memory/jobs-store.js";
 import { conversationStarters, memoryJobs } from "../../memory/schema.js";
 import { NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -203,7 +206,7 @@ function handleListConversationStarters({
       checkpointAhead ||
       (invalidItemCount > 0 && totalActive > 0 && !withinCooldown);
 
-    if (shouldRefresh && !hasActiveJob) {
+    if (shouldRefresh && !hasActiveJob && isMemoryEnabled()) {
       enqueueMemoryJob("generate_conversation_starters", { scopeId });
       hasActiveJob = true;
     }
@@ -225,7 +228,7 @@ function handleListConversationStarters({
 
   const existing = hasActiveConversationStarterJob(db, scopeId);
 
-  if (!existing) {
+  if (!existing && isMemoryEnabled()) {
     enqueueMemoryJob("generate_conversation_starters", { scopeId });
   }
 

package/src/runtime/routes/disk-pressure-routes.ts

@@ -11,7 +11,7 @@ import type { RouteDefinition } from "./types.js";
 
 const DiskPressureStatusSchema = z.object({
   enabled: z.boolean(),
-  state: z.enum(["disabled", "ok", "critical", "unknown"]),
+  state: z.enum(["disabled", "ok", "warning", "critical", "unknown"]),
   locked: z.boolean(),
   acknowledged: z.boolean(),
   overrideActive: z.boolean(),

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

@@ -35,7 +35,10 @@ async function requireClient(): Promise<VellumPlatformClient> {
 // ── Handlers ──────────────────────────────────────────────────────────
 
 async function handleDomainRegister({ body = {} }: RouteHandlerArgs) {
-  const { subdomain } = body as { subdomain?: string };
+  const { subdomain, email_username } = body as {
+    subdomain?: string;
+    email_username?: string;
+  };
   const client = await requireClient();
   const apexDomain = getApexDomain();
 
@@ -43,6 +46,9 @@ async function handleDomainRegister({ body = {} }: RouteHandlerArgs) {
   if (subdomain) {
     reqBody.subdomain = subdomain;
   }
+  if (email_username) {
+    reqBody.email_username = email_username;
+  }
 
   const response = await client.fetch(
     `/v1/assistants/${client.platformAssistantId}/domains/`,
@@ -58,12 +64,18 @@ async function handleDomainRegister({ body = {} }: RouteHandlerArgs) {
       string,
       unknown
     >;
+    const firstFieldError = ["subdomain", "email_username"].reduce<
+      string | undefined
+    >(
+      (found, field) =>
+        found ??
+        (Array.isArray(respBody[field])
+          ? (respBody[field][0] as string)
+          : undefined),
+      undefined,
+    );
     const detail =
-      respBody.detail ??
-      (Array.isArray(respBody.subdomain)
-        ? respBody.subdomain[0]
-        : undefined) ??
-      `HTTP ${response.status}`;
+      respBody.detail ?? firstFieldError ?? `HTTP ${response.status}`;
     throw new BadRequestError(String(detail));
   }
 
@@ -71,10 +83,9 @@ async function handleDomainRegister({ body = {} }: RouteHandlerArgs) {
     id: string;
     subdomain?: string;
     domain?: string;
-    status?: string;
-    verified?: boolean;
     created_at?: string;
     created?: string;
+    email_error?: { detail: string; code: string };
   };
 
   // Persist the subdomain to config so getAssistantDomain() can use it
@@ -117,8 +128,6 @@ async function handleDomainStatus(_args: RouteHandlerArgs) {
       id: string;
       subdomain?: string;
       domain?: string;
-      status?: string;
-      verified?: boolean;
       created_at?: string;
       created?: string;
     }[];
@@ -145,6 +154,39 @@ async function handleDomainStatus(_args: RouteHandlerArgs) {
   return data;
 }
 
+async function handleDomainVerificationStatus({
+  body = {},
+}: RouteHandlerArgs) {
+  const { domain_id } = body as { domain_id?: string };
+  if (!domain_id) {
+    throw new BadRequestError("domain_id is required");
+  }
+  const client = await requireClient();
+
+  const response = await client.fetch(
+    `/v1/assistants/${client.platformAssistantId}/domains/${domain_id}/verification-status/`,
+  );
+
+  if (!response.ok) {
+    const respBody = (await response.json().catch(() => ({}))) as Record<
+      string,
+      unknown
+    >;
+    const detail = respBody.detail ?? `HTTP ${response.status}`;
+    throw new RouteError(
+      String(detail),
+      "VERIFICATION_STATUS_FAILED",
+      response.status,
+    );
+  }
+
+  return (await response.json()) as {
+    domain: string;
+    status: string;
+    message: string;
+  };
+}
+
 // ── Route definitions ─────────────────────────────────────────────────
 
 export const ROUTES: RouteDefinition[] = [
@@ -164,4 +206,12 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Show domain registration and health",
     tags: ["domain"],
   },
+  {
+    operationId: "domain_verification_status",
+    endpoint: "domain/verification-status",
+    method: "POST",
+    handler: handleDomainVerificationStatus,
+    summary: "Get live DNS verification status for a domain",
+    tags: ["domain"],
+  },
 ];

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

@@ -277,13 +277,16 @@ async function handleEmailSend({ body = {} }: RouteHandlerArgs) {
 
   const fromAddress = addresses[0].address;
 
+  // LLMs often produce literal "\n" escape sequences instead of real newlines.
+  const normalizedText = text?.replace(/\\n/g, "\n") ?? "";
+
   // Auto-generate HTML from text if not provided
-  const resolvedHtml = html ?? markdownToEmailHtml(text);
+  const resolvedHtml = html ?? markdownToEmailHtml(normalizedText);
 
   const payload: Record<string, unknown> = {
     to,
     from_address: fromAddress,
-    text,
+    text: normalizedText,
   };
   if (subject) payload.subject = subject;
   if (resolvedHtml) payload.html = resolvedHtml;

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

@@ -26,6 +26,7 @@ import { z } from "zod";
 import type { HostProxyCapability } from "../../channels/types.js";
 import { parseInterfaceId, supportsHostProxy } from "../../channels/types.js";
 import { emitContactChange } from "../../contacts/contact-events.js";
+import { getConversation } from "../../memory/conversation-crud.js";
 import { getOrCreateConversation } from "../../memory/conversation-key-store.js";
 import { getLogger } from "../../util/logger.js";
 import { formatSseFrame, formatSseHeartbeat } from "../assistant-event.js";
@@ -39,7 +40,11 @@ import {
   assistantEventHub,
 } from "../assistant-event-hub.js";
 import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
-import { BadRequestError, ServiceUnavailableError } from "./errors.js";
+import {
+  BadRequestError,
+  NotFoundError,
+  ServiceUnavailableError,
+} from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("events-routes");
@@ -220,9 +225,17 @@ const defaultSseShedReporter: SseShedReporter = (reason, inst) => {
  * Stream assistant events as Server-Sent Events.
  *
  * Query params:
- *   conversationKey -- optional; when provided, scopes the stream to one
- *                      conversation. When omitted, the stream delivers events
- *                      from ALL conversations for this assistant.
+ *   conversationId  -- optional; assistant-minted internal conversation id.
+ *                      When provided, the stream is scoped to that one
+ *                      conversation; the daemon 404s if no such conversation
+ *                      exists (clients must obtain the id from a prior
+ *                      response).
+ *   conversationKey -- optional; external key (non-vellum channels) or the
+ *                      web idempotency key. Resolved via the conversation
+ *                      keys table; materializes a row on first use.
+ *                      Ignored when `conversationId` is also provided.
+ *   When both are omitted, the stream delivers events from ALL
+ *   conversations for this assistant.
  *
  * Headers (optional):
  *   X-Vellum-Client-Id    -- stable per-install UUID identifying this client.
@@ -248,8 +261,18 @@ export function handleSubscribeAssistantEvents(
 ): ReadableStream<Uint8Array> {
   const { queryParams, headers, abortSignal } = args;
 
-  const conversationKey = queryParams?.conversationKey;
-  if ("conversationKey" in (queryParams ?? {}) && !conversationKey?.trim()) {
+  const rawConversationId = queryParams?.conversationId;
+  const rawConversationKey = queryParams?.conversationKey;
+  if (
+    "conversationId" in (queryParams ?? {}) &&
+    !rawConversationId?.trim()
+  ) {
+    throw new BadRequestError("conversationId must not be empty");
+  }
+  if (
+    "conversationKey" in (queryParams ?? {}) &&
+    !rawConversationKey?.trim()
+  ) {
     throw new BadRequestError("conversationKey must not be empty");
   }
 
@@ -293,10 +316,25 @@ export function handleSubscribeAssistantEvents(
     "host_browser",
   ];
 
+  // Resolve the scope. `conversationId` (when supplied) is the
+  // assistant-minted internal id — looked up directly; 404 if absent.
+  // Otherwise fall through to `conversationKey`, which is treated as an
+  // external key and resolved via the conversation_keys table
+  // (materialized on first use, preserving the existing subscribe-time
+  // create behavior for the web idempotency flow).
   const filter: AssistantEventFilter = {};
-  if (conversationKey) {
-    const mapping = getOrCreateConversation(conversationKey);
+  let scopeConversationKey: string | null = null;
+  if (rawConversationId) {
+    const existing = getConversation(rawConversationId);
+    if (!existing) {
+      throw new NotFoundError(`Conversation ${rawConversationId} not found`);
+    }
+    filter.conversationId = existing.id;
+    scopeConversationKey = existing.id;
+  } else if (rawConversationKey) {
+    const mapping = getOrCreateConversation(rawConversationKey);
     filter.conversationId = mapping.conversationId;
+    scopeConversationKey = rawConversationKey;
   }
 
   const encoder = new TextEncoder();
@@ -316,7 +354,7 @@ export function handleSubscribeAssistantEvents(
     heartbeatsSent: 0,
     clientId,
     interfaceId,
-    conversationKey: conversationKey ?? null,
+    conversationKey: scopeConversationKey,
   };
 
   ensureEventLoopDelayMonitorStarted();
@@ -470,9 +508,15 @@ export const ROUTES: RouteDefinition[] = [
     description: "Stream assistant events as Server-Sent Events (SSE).",
     tags: ["events"],
     queryParams: [
+      {
+        name: "conversationId",
+        description:
+          "Scope to a single conversation by its assistant-minted internal id. 404s if no such conversation exists.",
+      },
       {
         name: "conversationKey",
-        description: "Scope to a single conversation",
+        description:
+          "Scope to a single conversation by an external key (non-vellum channels) or the web idempotency key. Materializes a row on first use. Ignored when conversationId is also provided.",
       },
     ],
     responseHeaders: {

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

@@ -41,14 +41,17 @@ function handleListGroups() {
   return { groups: groups.map(serializeGroup) };
 }
 
-function handleCreateGroup({ body = {} }: RouteHandlerArgs) {
+function handleCreateGroup({ body = {}, headers }: RouteHandlerArgs) {
   const name = body.name;
   if (!name || typeof name !== "string") {
     throw new BadRequestError("Missing or invalid name");
   }
   try {
     const group = createGroup(name);
-    publishConversationListChanged("created");
+    publishConversationListChanged(
+      "created",
+      headers?.["x-vellum-client-id"]?.trim() || undefined,
+    );
     return serializeGroup(group);
   } catch (err) {
     if (
@@ -63,7 +66,11 @@ function handleCreateGroup({ body = {} }: RouteHandlerArgs) {
   }
 }
 
-function handleUpdateGroup({ pathParams = {}, body = {} }: RouteHandlerArgs) {
+function handleUpdateGroup({
+  pathParams = {},
+  body = {},
+  headers,
+}: RouteHandlerArgs) {
   const groupId = pathParams.groupId;
   const existing = getGroup(groupId);
   if (!existing) {
@@ -92,11 +99,14 @@ function handleUpdateGroup({ pathParams = {}, body = {} }: RouteHandlerArgs) {
   if (!updated) {
     throw new NotFoundError("Group not found");
   }
-  publishConversationListChanged("reordered");
+  publishConversationListChanged(
+    "reordered",
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return serializeGroup(updated);
 }
 
-function handleDeleteGroup({ pathParams = {} }: RouteHandlerArgs) {
+function handleDeleteGroup({ pathParams = {}, headers }: RouteHandlerArgs) {
   const groupId = pathParams.groupId;
   const existing = getGroup(groupId);
   if (!existing) {
@@ -106,10 +116,13 @@ function handleDeleteGroup({ pathParams = {} }: RouteHandlerArgs) {
     throw new ForbiddenError("System groups cannot be deleted");
   }
   deleteGroup(groupId);
-  publishConversationListChanged("reordered");
+  publishConversationListChanged(
+    "reordered",
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
 }
 
-function handleReorderGroups({ body = {} }: RouteHandlerArgs) {
+function handleReorderGroups({ body = {}, headers }: RouteHandlerArgs) {
   const updates = body.updates as
     | Array<{ groupId: string; sortPosition: number }>
     | undefined;
@@ -135,7 +148,10 @@ function handleReorderGroups({ body = {} }: RouteHandlerArgs) {
     }
   }
   reorderGroups(updates);
-  publishConversationListChanged("reordered");
+  publishConversationListChanged(
+    "reordered",
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return { ok: true };
 }
 

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

@@ -223,8 +223,9 @@ export type HostBrowserSessionInvalidatedResolution =
 export function resolveHostBrowserSessionInvalidated(frame: {
   targetId?: unknown;
   reason?: unknown;
+  clientId?: unknown;
 }): HostBrowserSessionInvalidatedResolution {
-  const { targetId, reason } = frame;
+  const { targetId, reason, clientId } = frame;
 
   if (targetId !== undefined && typeof targetId !== "string") {
     return {
@@ -235,6 +236,9 @@ export function resolveHostBrowserSessionInvalidated(frame: {
     };
   }
 
+  const resolvedClientId =
+    typeof clientId === "string" && clientId.length > 0 ? clientId : undefined;
+
   if (typeof targetId === "string" && targetId.length > 0) {
     markTargetInvalidated(
       targetId,
@@ -245,7 +249,7 @@ export function resolveHostBrowserSessionInvalidated(frame: {
     // Without this, a user closing the pinned tab manually would see
     // their next browser command fail with a `cdp_session_not_found`
     // until the daemon process restarts.
-    clearPinnedTabByTabId(targetId);
+    clearPinnedTabByTabId(targetId, resolvedClientId);
   }
 
   return { ok: true };
@@ -387,6 +391,10 @@ export const ROUTES: RouteDefinition[] = [
         .optional()
         .describe("CDP target that was detached"),
       reason: z.string().optional().describe("Detach reason"),
+      clientId: z
+        .string()
+        .optional()
+        .describe("Extension client ID that reported the invalidation"),
     }),
     responseBody: z.object({
       accepted: z.boolean(),

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

@@ -107,12 +107,12 @@ function handleHostCuResult({ body, headers }: RouteHandlerArgs) {
 
   const conversation = findConversation(peeked.conversationId);
   if (!conversation) {
-    pendingInteractions.resolve(requestId);
+    pendingInteractions.resolve(requestId, "cancelled");
     throw new NotFoundError("Conversation not found for host CU result");
   }
 
   if (!conversation.hostCuProxy) {
-    pendingInteractions.resolve(requestId);
+    pendingInteractions.resolve(requestId, "cancelled");
     throw new NotFoundError("No host CU proxy for conversation");
   }
 

package/src/runtime/routes/inbound-stages/acl-enforcement.ts

@@ -342,6 +342,49 @@ export async function enforceIngressAcl(
           }
         }
 
+        // Email: initiate a verification challenge via the guardian notification
+        // pipeline. Unlike Slack, we cannot DM the requester directly — the
+        // verification code is delivered to the guardian, who decides whether
+        // to share it with the email sender out-of-band.
+        if (sourceChannel === "email" && (canonicalSenderId ?? rawSenderId)) {
+          const emailVerifyResult = initiateEmailVerificationChallenge({
+            sourceChannel,
+            senderUserId: (canonicalSenderId ?? rawSenderId)!,
+          });
+
+          if (emailVerifyResult.initiated) {
+            try {
+              notifyGuardianOfAccessRequest({
+                canonicalAssistantId,
+                sourceChannel,
+                conversationExternalId,
+                actorExternalId: canonicalSenderId ?? rawSenderId,
+                actorDisplayName,
+                actorUsername,
+                messagePreview: truncate(
+                  trimmedContent,
+                  MESSAGE_PREVIEW_MAX_LENGTH,
+                ),
+              });
+            } catch (err) {
+              log.error(
+                { err, sourceChannel, conversationExternalId },
+                "Failed to notify guardian of access request (email verification)",
+              );
+            }
+
+            return {
+              resolvedMember: null,
+              earlyResponse: ({
+                accepted: true,
+                denied: true,
+                reason: "verification_challenge_sent",
+                verificationSessionId: emailVerifyResult.sessionId,
+              }),
+            };
+          }
+        }
+
         // Notify the guardian about the access request so they can approve/deny.
         // Uses the shared helper which handles guardian binding lookup,
         // deduplication, canonical request creation, and notification emission.
@@ -1048,10 +1091,10 @@ async function handleInviteCodeIntercept(params: {
 }
 
 // ---------------------------------------------------------------------------
-// Slack verification challenge
+// Channel verification challenges
 // ---------------------------------------------------------------------------
 
-interface SlackVerificationResult {
+interface VerificationChallengeResult {
   initiated: boolean;
   sessionId?: string;
 }
@@ -1066,7 +1109,7 @@ interface SlackVerificationResult {
 function initiateSlackVerificationChallenge(params: {
   sourceChannel: ChannelId;
   senderUserId: string;
-}): SlackVerificationResult {
+}): VerificationChallengeResult {
   const { sourceChannel, senderUserId } = params;
 
   // Skip if there is already a pending challenge or active session for
@@ -1121,3 +1164,53 @@ function initiateSlackVerificationChallenge(params: {
     return { initiated: false };
   }
 }
+
+// ---------------------------------------------------------------------------
+// Email verification challenge
+// ---------------------------------------------------------------------------
+
+function initiateEmailVerificationChallenge(params: {
+  sourceChannel: ChannelId;
+  senderUserId: string;
+}): VerificationChallengeResult {
+  const { sourceChannel, senderUserId } = params;
+
+  const existingChallenge = getPendingSession(sourceChannel);
+  const existingSession = findActiveSession(sourceChannel);
+  const senderHasPending =
+    (existingChallenge &&
+      existingChallenge.expectedExternalUserId === senderUserId) ||
+    (existingSession &&
+      existingSession.expectedExternalUserId === senderUserId);
+  if (senderHasPending) {
+    log.debug(
+      { sourceChannel, senderUserId },
+      "Email verification: skipping — existing challenge/session for this sender",
+    );
+    return { initiated: false };
+  }
+
+  try {
+    const session = createOutboundSession({
+      channel: sourceChannel,
+      expectedExternalUserId: senderUserId,
+      expectedChatId: senderUserId,
+      identityBindingStatus: "bound",
+      destinationAddress: senderUserId,
+      verificationPurpose: "trusted_contact",
+    });
+
+    log.info(
+      { sourceChannel, senderUserId, sessionId: session.sessionId },
+      "Email verification challenge initiated for unknown contact",
+    );
+
+    return { initiated: true, sessionId: session.sessionId };
+  } catch (err) {
+    log.error(
+      { err, sourceChannel, senderUserId },
+      "Failed to initiate email verification challenge",
+    );
+    return { initiated: false };
+  }
+}

package/src/runtime/routes/index.ts

@@ -18,10 +18,12 @@ import { ROUTES as AUDIT_ROUTES } from "./audit-routes.js";
 import { ROUTES as AUTH_ROUTES } from "./auth-routes.js";
 import { ROUTES as AVATAR_ROUTES } from "./avatar-routes.js";
 import { ROUTES as BACKGROUND_TOOL_ROUTES } from "./background-tool-routes.js";
+import { ROUTES as BACKGROUND_WAKE_ROUTES } from "./background-wake-routes.js";
 import { ROUTES as BACKUP_ROUTES } from "./backup-routes.js";
 import { ROUTES as BOOKMARK_ROUTES } from "./bookmark-routes.js";
 import { ROUTES as BRAIN_GRAPH_ROUTES } from "./brain-graph-routes.js";
 import { ROUTES as BROWSER_ROUTES } from "./browser-routes.js";
+import { ROUTES as BROWSER_TABS_ROUTES } from "./browser-tabs-routes.js";
 import { ROUTES as BTW_ROUTES } from "./btw-routes.js";
 import { ROUTES as CACHE_ROUTES } from "./cache-routes.js";
 import { ROUTES as CALL_ROUTES } from "./call-routes.js";
@@ -88,6 +90,7 @@ import { ROUTES as LOG_EXPORT_ROUTES } from "./log-export-routes.js";
 import { ROUTES as MCP_AUTH_ROUTES } from "./mcp-auth-routes.js";
 import { ROUTES as MEMORY_ITEM_ROUTES } from "./memory-item-routes.js";
 import { ROUTES as MEMORY_V2_ROUTES } from "./memory-v2-routes.js";
+import { ROUTES as MEMORY_V3_ROUTES } from "./memory-v3-routes.js";
 import { ROUTES as MIGRATION_ROLLBACK_ROUTES } from "./migration-rollback-routes.js";
 import { ROUTES as MIGRATION_ROUTES } from "./migration-routes.js";
 import { ROUTES as NOTIFICATION_ROUTES } from "./notification-routes.js";
@@ -98,6 +101,7 @@ import { ROUTES as OAUTH_LIFECYCLE_ROUTES } from "./oauth-lifecycle-routes.js";
 import { ROUTES as OAUTH_PROVIDERS_ROUTES } from "./oauth-providers.js";
 import { ROUTES as PLATFORM_ROUTES } from "./platform-routes.js";
 import { ROUTES as PLAYGROUND_ROUTES } from "./playground/index.js";
+import { ROUTES as PLUGINS_ROUTES } from "./plugins-routes.js";
 import { ROUTES as PROFILER_ROUTES } from "./profiler-routes.js";
 import { ROUTES as PS_ROUTES } from "./ps-routes.js";
 import { ROUTES as PUBLISH_ROUTES } from "./publish-routes.js";
@@ -145,6 +149,7 @@ export const ROUTES: RouteDefinition[] = [
   ...AUDIT_ROUTES,
   ...AUTH_ROUTES,
   ...AVATAR_ROUTES,
+  ...BACKGROUND_WAKE_ROUTES,
   ...BACKGROUND_TOOL_ROUTES,
   ...BACKUP_ROUTES,
   ...BOOKMARK_ROUTES,
@@ -156,6 +161,7 @@ export const ROUTES: RouteDefinition[] = [
   ...CHANNEL_AVAILABILITY_ROUTES,
   ...CHANNEL_READINESS_ROUTES,
   ...BROWSER_ROUTES,
+  ...BROWSER_TABS_ROUTES,
   ...BTW_ROUTES,
   ...BRAIN_GRAPH_ROUTES,
   ...CLIENT_ROUTES,
@@ -211,6 +217,7 @@ export const ROUTES: RouteDefinition[] = [
   ...LLM_CALL_SITES_ROUTES,
   ...MEMORY_ITEM_ROUTES,
   ...MEMORY_V2_ROUTES,
+  ...MEMORY_V3_ROUTES,
   ...MIGRATION_ROLLBACK_ROUTES,
   ...MIGRATION_ROUTES,
   ...NOTIFICATION_ROUTES,
@@ -220,6 +227,7 @@ export const ROUTES: RouteDefinition[] = [
   ...OAUTH_PROVIDERS_ROUTES,
   ...PLATFORM_ROUTES,
   ...PLAYGROUND_ROUTES,
+  ...PLUGINS_ROUTES,
   ...PROFILER_ROUTES,
   ...PS_ROUTES,
   ...PUBLISH_ROUTES,

package/src/runtime/routes/inference-profile-session-handler.ts

@@ -67,11 +67,13 @@ export async function setInferenceProfileSession({
   profile,
   ttlSeconds,
   sessionId: callerSessionId,
+  originClientId,
 }: {
   conversationId: string;
   profile: string | null;
   ttlSeconds?: number | null;
   sessionId?: string;
+  originClientId?: string;
 }): Promise<InferenceProfileSessionResult> {
   const resolvedId = resolveConversationId(conversationId) ?? conversationId;
   const conversation = getConversation(resolvedId);
@@ -116,12 +118,15 @@ export async function setInferenceProfileSession({
       };
     }
     setConversationInferenceProfileSession(resolvedId, null, null, null);
-    publishConversationInferenceProfileChanged({
-      conversationId: resolvedId,
-      profile: null,
-      sessionId: null,
-      expiresAt: null,
-    });
+    publishConversationInferenceProfileChanged(
+      {
+        conversationId: resolvedId,
+        profile: null,
+        sessionId: null,
+        expiresAt: null,
+      },
+      originClientId,
+    );
     return {
       conversationId: resolvedId,
       profile: null,
@@ -184,12 +189,15 @@ export async function setInferenceProfileSession({
     newExpiresAt ?? null,
   );
 
-  publishConversationInferenceProfileChanged({
-    conversationId: resolvedId,
-    profile,
-    sessionId: newSessionId ?? null,
-    expiresAt: newExpiresAt ?? null,
-  });
+  publishConversationInferenceProfileChanged(
+    {
+      conversationId: resolvedId,
+      profile,
+      sessionId: newSessionId ?? null,
+      expiresAt: newExpiresAt ?? null,
+    },
+    originClientId,
+  );
 
   return {
     conversationId: resolvedId,
@@ -218,6 +226,7 @@ export async function setInferenceProfileSession({
  */
 export async function closeInferenceProfileSession(
   conversationId: string,
+  originClientId?: string,
 ): Promise<{
   conversationId: string;
   closed: { profile: string | null; sessionId: string | null } | null;
@@ -241,6 +250,7 @@ export async function closeInferenceProfileSession(
   const result = await setInferenceProfileSession({
     conversationId: resolvedId,
     profile: null,
+    originClientId,
   });
   return {
     conversationId: result.conversationId,