@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/runtime/routes/desktop-setup-routes.test.ts

@@ -0,0 +1,74 @@
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+import { desktopDependencyInstaller } from "../../desktop/desktop-dependencies.js";
+import { ROUTES } from "./desktop-setup-routes.js";
+import { NotFoundError } from "./errors.js";
+
+const originalContainerized = process.env.IS_CONTAINERIZED;
+const status = spyOn(desktopDependencyInstaller, "getStatus");
+const start = spyOn(desktopDependencyInstaller, "start");
+
+afterAll(() => {
+  status.mockRestore();
+  start.mockRestore();
+});
+
+beforeEach(() => {
+  process.env.IS_CONTAINERIZED = "true";
+  status.mockReturnValue({ state: "required" });
+  start.mockReturnValue({ state: "installing", stage: "packages" });
+});
+
+afterEach(() => {
+  if (originalContainerized === undefined) {
+    delete process.env.IS_CONTAINERIZED;
+  } else {
+    process.env.IS_CONTAINERIZED = originalContainerized;
+  }
+  setOverridesForTesting({});
+  status.mockClear();
+  start.mockClear();
+});
+
+describe("desktop setup route feature gate", () => {
+  for (const route of ROUTES) {
+    for (const flag of [false, undefined]) {
+      test(`${route.method} refuses a disabled or missing flag (${flag}) without touching setup`, () => {
+        setOverridesForTesting(
+          flag === undefined ? {} : { "assistant-desktop": flag },
+        );
+        expect(() => route.handler({})).toThrow(NotFoundError);
+        expect(status).not.toHaveBeenCalled();
+        expect(start).not.toHaveBeenCalled();
+      });
+    }
+
+    test(`${route.method} refuses non-containerized assistants even with the flag enabled`, () => {
+      process.env.IS_CONTAINERIZED = "false";
+      setOverridesForTesting({ "assistant-desktop": true });
+      expect(() => route.handler({})).toThrow(NotFoundError);
+      expect(status).not.toHaveBeenCalled();
+      expect(start).not.toHaveBeenCalled();
+    });
+
+    test(`${route.method} serves setup only with the flag enabled in a container`, () => {
+      setOverridesForTesting({ "assistant-desktop": true });
+      expect(route.handler({})).toEqual(
+        route.method === "GET"
+          ? { state: "required" }
+          : { state: "installing", stage: "packages" },
+      );
+      expect(route.method === "GET" ? status : start).toHaveBeenCalledTimes(1);
+      expect(route.method === "GET" ? start : status).not.toHaveBeenCalled();
+    });
+  }
+});

package/src/runtime/routes/desktop-setup-routes.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+
+import { getConfig } from "../../config/loader.js";
+import { desktopDependencyInstaller } from "../../desktop/desktop-dependencies.js";
+import { isAssistantDesktopEnabled } from "../../desktop/desktop-feature.js";
+import { GATEWAY_PRINCIPALS } from "../auth/route-policy.js";
+import { NotFoundError } from "./errors.js";
+import type { RouteDefinition } from "./types.js";
+
+const statusSchema = z.object({
+  state: z.enum(["required", "installing", "ready", "failed", "unsupported"]),
+  stage: z.enum(["packages", "chrome", "checking"]).optional(),
+});
+
+export const ROUTES: RouteDefinition[] = ["GET", "POST"].map((method) => ({
+  operationId:
+    method === "GET" ? "desktop_setup_status" : "desktop_setup_install",
+  endpoint: "desktop/setup",
+  method,
+  policy: { requiredScopes: [], allowedPrincipalTypes: GATEWAY_PRINCIPALS },
+  handler: () => {
+    if (!isAssistantDesktopEnabled(getConfig())) {
+      throw new NotFoundError("Desktop is not available on this assistant");
+    }
+    return method === "GET"
+      ? desktopDependencyInstaller.getStatus()
+      : desktopDependencyInstaller.start();
+  },
+  summary:
+    method === "GET"
+      ? "Get desktop setup status"
+      : "Install desktop components",
+  tags: ["desktop"],
+  responseBody: statusSchema,
+}));

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

@@ -22,7 +22,9 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../providers/provider-send-message.js";
+import { isMaxTokensStopReason } from "../../providers/stop-reasons.js";
 import { getLogger } from "../../util/logger.js";
+import { safeStringSlice } from "../../util/unicode.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -48,7 +50,11 @@ function sanitizeWindowTitle(title: string | undefined): string {
   if (!title) {
     return "";
   }
-  return title.replace(/[<>]/g, "").slice(0, MAX_WINDOW_TITLE_LENGTH);
+  return safeStringSlice(
+    title.replace(/[<>]/g, ""),
+    0,
+    MAX_WINDOW_TITLE_LENGTH,
+  );
 }
 
 interface DictationBody {
@@ -176,9 +182,44 @@ function buildCommandPrompt(body: DictationBody, stylePrompt?: string): string {
   return sections.join("\n");
 }
 
-function computeMaxTokens(inputLength: number): number {
+export function computeMaxTokens(inputLength: number): number {
   const estimatedInputTokens = Math.ceil(inputLength / 3);
-  return Math.max(256, estimatedInputTokens + 128);
+  // The cleanup tool call carries the whole transcript back in its `text`
+  // argument, plus a `reasoning` string and the JSON scaffolding around both,
+  // so the budget has to cover well more than the input alone. `max_tokens` is
+  // a ceiling rather than a target: a call that stops short of it costs no
+  // extra latency.
+  return Math.max(512, estimatedInputTokens * 2 + 256);
+}
+
+export type CleanupRejection = "truncated";
+
+/**
+ * Decide whether the cleanup model's rewrite is safe to use as the payload.
+ *
+ * The rewrite replaces what the user actually said. A token-cap stop means the
+ * tool JSON was cut mid-argument, so however complete the `text` argument
+ * happens to look, it is a fragment; the raw transcript is the safer payload
+ * then. Unpolished beats wrong.
+ *
+ * Whether a shorter rewrite still preserved the meaning is the model's call
+ * (the prompt asks it to drop fillers and tighten phrasing), so there is no
+ * length check here: a deterministic ratio cannot tell a concise cleanup from
+ * a summary.
+ */
+export function resolveCleanedDictation(
+  raw: string,
+  cleaned: string,
+  stopReason: string | null | undefined,
+): { text: string; rejected: CleanupRejection | null } {
+  const trimmed = cleaned.trim();
+  if (!trimmed) {
+    return { text: raw, rejected: null };
+  }
+  if (isMaxTokensStopReason(stopReason)) {
+    return { text: raw, rejected: "truncated" };
+  }
+  return { text: trimmed, rejected: null };
 }
 
 interface DictationResult {
@@ -329,7 +370,23 @@ async function handleDictation(body: DictationBody): Promise<DictationResult> {
             ...profileMeta,
           };
         }
-        const cleanedText = input.text?.trim() || transcription;
+        const { text: cleanedText, rejected } = resolveCleanedDictation(
+          transcription,
+          input.text ?? "",
+          response.stopReason,
+        );
+        if (rejected) {
+          // Lengths only -- transcript content must never be logged.
+          log.warn(
+            {
+              rejected,
+              stopReason: response.stopReason,
+              rawChars: transcription.length,
+              cleanedChars: input.text?.trim().length ?? 0,
+            },
+            "Dictation cleanup rejected, using raw transcription",
+          );
+        }
         const normalizedText = applyDictionary(cleanedText, profile.dictionary);
         return {
           text: normalizedText,

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

@@ -445,6 +445,10 @@ export function handleSubscribeAssistantEvents(
                 ? ["host_cu_window_capture" as const]
                 : []),
               ...(interfaceId === "macos" &&
+              headers?.["x-vellum-cu-sequence"] === "1"
+                ? ["host_cu_sequence" as const]
+                : []),
+              ...(interfaceId === "macos" &&
               headers?.["x-vellum-cu-annotate"] === "1"
                 ? ["host_cu_annotate" as const]
                 : []),

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

@@ -36,6 +36,10 @@ const HostCuResultBodySchema = z.object({
   executionError: z.string().optional(),
   secondaryWindows: z.string().optional(),
   userGuidance: z.string().optional(),
+  timings: z
+    .record(z.string(), z.number())
+    .describe("Per-phase helper timings in milliseconds")
+    .optional(),
 });
 
 // ---------------------------------------------------------------------------
@@ -56,6 +60,7 @@ async function handleHostCuResult({ body, headers }: RouteHandlerArgs) {
     executionError,
     secondaryWindows,
     userGuidance,
+    timings,
   } = parseBody(HostCuResultBodySchema, body);
 
   const peeked = pendingInteractions.get(requestId);
@@ -119,6 +124,7 @@ async function handleHostCuResult({ body, headers }: RouteHandlerArgs) {
     executionError,
     secondaryWindows,
     userGuidance,
+    timings,
   });
 
   return { accepted: true };

package/src/runtime/routes/index.ts

@@ -39,6 +39,7 @@ import { ROUTES as CALL_ROUTES } from "./call-routes.js";
 import { ROUTES as CHANNEL_AVAILABILITY_ROUTES } from "./channel-availability-routes.js";
 import { ROUTES as CHANNEL_READINESS_ROUTES } from "./channel-readiness-routes.js";
 import { CHANNEL_ROUTES } from "./channel-route-definitions.js";
+import { ROUTES as CHANNEL_SEND_ROUTES } from "./channel-send-routes.js";
 import { ROUTES as CHANNEL_VERIFICATION_ROUTES } from "./channel-verification-routes.js";
 import { ROUTES as CHATGPT_SUBSCRIPTION_AUTH_ROUTES } from "./chatgpt-subscription-auth-routes.js";
 import { ROUTES as CLIENT_ROUTES } from "./client-routes.js";
@@ -58,10 +59,10 @@ import { ROUTES as CONVERSATIONS_IMPORT_ROUTES } from "./conversations-import-ro
 import { ROUTES as CREDENTIAL_PROMPT_ROUTES } from "./credential-prompt-routes.js";
 import { ROUTES as CREDENTIAL_REQUEST_ROUTES } from "./credential-request-routes.js";
 import { ROUTES as CREDENTIAL_ROUTES } from "./credential-routes.js";
-import { ROUTES as DEBUG_BASH_ROUTES } from "./debug-bash-routes.js";
 import { ROUTES as DEBUG_ROUTES } from "./debug-routes.js";
 import { ROUTES as DEFAULT_PROVIDER_ROUTES } from "./default-provider-routes.js";
 import { ROUTES as DEFER_ROUTES } from "./defer-routes.js";
+import { ROUTES as DESKTOP_SETUP_ROUTES } from "./desktop-setup-routes.js";
 import { ROUTES as DIAGNOSTICS_ROUTES } from "./diagnostics-routes.js";
 import { ROUTES as DISK_PRESSURE_ROUTES } from "./disk-pressure-routes.js";
 import { ROUTES as DOCUMENT_COMMENT_ROUTES } from "./document-comments-routes.js";
@@ -191,6 +192,7 @@ export const ROUTES: RouteDefinition[] = [
   ...CHANNEL_VERIFICATION_ROUTES,
   ...CHANNEL_AVAILABILITY_ROUTES,
   ...CHANNEL_READINESS_ROUTES,
+  ...CHANNEL_SEND_ROUTES,
   ...BROWSER_ROUTES,
   ...BROWSER_TABS_ROUTES,
   ...BTW_ROUTES,
@@ -215,9 +217,9 @@ export const ROUTES: RouteDefinition[] = [
   ...CONVERSATION_QUERY_ROUTES,
   ...CONVERSATION_STARTER_ROUTES,
   ...ACTIVATION_ROUTES,
-  ...DEBUG_BASH_ROUTES,
   ...DEBUG_ROUTES,
   ...DEFAULT_PROVIDER_ROUTES,
+  ...DESKTOP_SETUP_ROUTES,
   ...DIAGNOSTICS_ROUTES,
   ...DISK_PRESSURE_ROUTES,
   ...RESOURCE_PRESSURE_ROUTES,

package/src/runtime/routes/log-export-routes.ts

@@ -22,6 +22,7 @@ import { join } from "node:path";
 import { and, desc, eq, gte, lte } from "drizzle-orm";
 import { z } from "zod";
 
+import { overlayWorkspaceMcpForConfigRead } from "../../mcp/workspace-mcp-config.js";
 import { getDb, getLogsDb } from "../../persistence/db-connection.js";
 import {
   llmRequestLogs,
@@ -568,6 +569,7 @@ function readSanitizedConfig(): Record<string, unknown> | undefined {
       }
     }
 
+    overlayWorkspaceMcpForConfigRead(config);
     const mcpServers = asRecord(asRecord(config.mcp)?.servers);
     for (const server of Object.values(mcpServers ?? {})) {
       const transport = asRecord(asRecord(server)?.transport);

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

@@ -14,8 +14,7 @@
 
 import { z } from "zod";
 
-import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
-import type { McpConfig, McpServerConfig } from "../../config/schemas/mcp.js";
+import type { McpServerConfig } from "../../config/schemas/mcp.js";
 import { estimateToolDefinitionTokens } from "../../context/token-estimator.js";
 import { reloadMcpServers } from "../../daemon/mcp-reload-service.js";
 import { McpClient } from "../../mcp/client.js";
@@ -31,6 +30,10 @@ import {
   deleteMcpOAuthCredentials,
   hasMcpOAuthTokens,
 } from "../../mcp/mcp-oauth-provider.js";
+import {
+  loadWorkspaceMcpConfig,
+  saveWorkspaceMcpConfig,
+} from "../../mcp/workspace-mcp-config.js";
 import { readPluginMcpServers } from "../../plugins/mcp-servers.js";
 import { getMcpToolsByServer } from "../../tools/registry.js";
 import { getLogger } from "../../util/logger.js";
@@ -65,6 +68,18 @@ const McpAddParams = z.object({
 
 const McpRemoveParams = z.object({ name: z.string() });
 
+function persistWorkspaceMcpConfig(config: {
+  servers: Record<string, McpServerConfig>;
+}): void {
+  try {
+    saveWorkspaceMcpConfig(config);
+  } catch (err) {
+    throw new InternalError(
+      err instanceof Error ? err.message : String(err),
+    );
+  }
+}
+
 async function handleMcpAuthStart({
   body,
 }: {
@@ -76,8 +91,7 @@ async function handleMcpAuthStart({
 }> {
   const { serverId } = parseBody(McpServerIdParams, body);
 
-  const raw = loadRawConfig();
-  const servers = (raw.mcp as Partial<McpConfig> | undefined)?.servers ?? {};
+  const servers = loadWorkspaceMcpConfig().servers;
   const serverConfig = servers[serverId];
 
   if (!serverConfig) {
@@ -253,9 +267,7 @@ function detectAuthType(headers: Record<string, string>): "bearer" | "api-key" {
 async function handleMcpList(_args: {
   body?: Record<string, unknown>;
 }): Promise<{ servers: McpServerEntry[] }> {
-  const raw = loadRawConfig();
-  const mcpConfig = raw.mcp as Partial<McpConfig> | undefined;
-  const servers = mcpConfig?.servers ?? {};
+  const servers = loadWorkspaceMcpConfig().servers;
   const configEntries = (
     Object.entries(servers) as [string, McpServerConfig][]
   ).filter(([, config]) => config && typeof config === "object");
@@ -434,18 +446,13 @@ async function handleMcpUpdate({
 }): Promise<{ updated: true }> {
   const { name, headers } = parseBody(McpUpdateParams, body);
 
-  const raw = loadRawConfig();
-  const mcpConfig = raw.mcp as Record<string, unknown> | undefined;
-  const serverMap = mcpConfig?.servers as
-    | Record<string, Record<string, unknown>>
-    | undefined;
+  const servers = loadWorkspaceMcpConfig().servers;
+  const server = servers[name];
 
-  if (!serverMap || !serverMap[name]) {
+  if (!server) {
     throw new NotFoundError(`MCP server "${name}" not found.`);
   }
 
-  const server = serverMap[name];
-
   if (headers !== undefined) {
     const transport = server.transport as Record<string, unknown> | undefined;
     if (
@@ -474,7 +481,7 @@ async function handleMcpUpdate({
     }
   }
 
-  saveRawConfig(raw);
+  persistWorkspaceMcpConfig({ servers });
   triggerReload("internal_mcp_update");
 
   return { updated: true };
@@ -494,7 +501,7 @@ async function handleMcpAdd({
     body,
   );
 
-  let transport: Record<string, unknown>;
+  let transport: McpServerConfig["transport"];
   switch (transportType) {
     case "stdio":
       if (!command) {
@@ -517,27 +524,16 @@ async function handleMcpAdd({
       );
   }
 
-  const raw = loadRawConfig();
-  if (!raw.mcp) {
-    raw.mcp = { servers: {} };
-  }
-  const mcpConfig = raw.mcp as Record<string, unknown>;
-  if (!mcpConfig.servers) {
-    mcpConfig.servers = {};
-  }
-  const serverMap = mcpConfig.servers as Record<string, unknown>;
+  const servers = { ...loadWorkspaceMcpConfig().servers };
 
-  if (serverMap[name]) {
+  if (servers[name]) {
     throw new BadRequestError(
       `MCP server "${name}" already exists. Remove it first with: assistant mcp remove ${name}`,
     );
   }
 
-  serverMap[name] = {
-    transport,
-  };
+  servers[name] = { transport };
 
-  // Store auth headers in credential store, not config
   if (headers && Object.keys(headers).length > 0) {
     const ok = await setMcpHeaders(name, headers);
     if (!ok) {
@@ -547,7 +543,7 @@ async function handleMcpAdd({
     }
   }
 
-  saveRawConfig(raw);
+  persistWorkspaceMcpConfig({ servers });
   triggerReload("internal_mcp_add");
 
   return { added: true };
@@ -564,8 +560,7 @@ async function handleMcpAuthRevoke({
 }): Promise<{ revoked: true }> {
   const { serverId } = parseBody(McpServerIdParams, body);
 
-  const raw = loadRawConfig();
-  const servers = (raw.mcp as Partial<McpConfig> | undefined)?.servers ?? {};
+  const servers = loadWorkspaceMcpConfig().servers;
   const serverConfig = servers[serverId];
 
   if (!serverConfig) {
@@ -602,32 +597,29 @@ async function handleMcpRemove({
 }): Promise<{ removed: true }> {
   const { name } = parseBody(McpRemoveParams, body);
 
-  const raw = loadRawConfig();
-  const mcpConfig = raw.mcp as Record<string, unknown> | undefined;
-  const serverMap = mcpConfig?.servers as Record<string, unknown> | undefined;
+  const servers = { ...loadWorkspaceMcpConfig().servers };
+  const serverConfig = servers[name];
 
-  if (!serverMap || !serverMap[name]) {
+  if (!serverConfig) {
     throw new NotFoundError(`MCP server "${name}" not found.`);
   }
 
-  // Best-effort cleanup of credentials stored for this server
-  const serverConfig = serverMap[name] as Record<string, unknown>;
-  const transport = serverConfig?.transport as
-    | Record<string, unknown>
-    | undefined;
-  if (transport?.type === "sse" || transport?.type === "streamable-http") {
+  if (
+    serverConfig.transport.type === "sse" ||
+    serverConfig.transport.type === "streamable-http"
+  ) {
     try {
       await Promise.all([
         deleteMcpOAuthCredentials(name),
         deleteMcpHeaders(name),
       ]);
     } catch {
-      // Ignore — credentials may not exist
+      // Credentials may not exist.
     }
   }
 
-  delete serverMap[name];
-  saveRawConfig(raw);
+  delete servers[name];
+  persistWorkspaceMcpConfig({ servers });
   triggerReload("internal_mcp_remove");
 
   return { removed: true };

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

@@ -22,8 +22,8 @@ import { PassThrough, Readable } from "node:stream";
 
 import { z } from "zod";
 
-import { getPlatformAssistantId } from "../../config/env.js";
 import { invalidateConfigCache } from "../../config/loader.js";
+import { resolvePlatformAssistantId } from "../../config/platform-identity.js";
 import { getAssistantName } from "../../daemon/identity-helpers.js";
 import { runAsyncSqlite } from "../../persistence/db-async-query.js";
 import {
@@ -236,28 +236,14 @@ interface ExportManifestInputs {
 /**
  * Resolve the `assistant.id` for an export.
  *
- * Mirrors `platform/client.ts`'s precedence: in-memory override (set at
- * daemon startup or by secret-routes) → credential store → daemon-internal
- * fallback. The schema requires `id` to be non-empty, so we fall back to
+ * In-memory identity (validate rehydration or secret-routes). The schema
+ * requires `id` to be non-empty, so we fall back to
  * `DAEMON_INTERNAL_ASSISTANT_ID` rather than the empty string.
  */
 async function resolveAssistantId(): Promise<string> {
-  const inMemory = getPlatformAssistantId();
-  if (inMemory) {
-    return inMemory;
-  }
-  try {
-    const stored = await getSecureKeyAsync(
-      credentialKey("vellum", "platform_assistant_id"),
-    );
-    if (stored) {
-      return stored;
-    }
-  } catch (err) {
-    log.warn(
-      { err },
-      "Failed to read platform_assistant_id from credential store; falling back to daemon-internal id",
-    );
+  const resolved = await resolvePlatformAssistantId();
+  if (resolved) {
+    return resolved;
   }
   return DAEMON_INTERNAL_ASSISTANT_ID;
 }

package/src/runtime/routes/oauth-commands-routes.ts

@@ -41,9 +41,11 @@ import {
   listConnections,
   type OAuthProviderRow,
 } from "../../oauth/oauth-store.js";
+import { missingScopesForStoredToken } from "../../oauth/scope-utils.js";
 import { VellumPlatformClient } from "../../platform/client.js";
 import { withValidToken } from "../../security/token-manager.js";
 import { matchHostPattern } from "../../tools/credentials/host-pattern-match.js";
+import { parseJsonSafe } from "../../util/json.js";
 import { getLogger } from "../../util/logger.js";
 import {
   findContentTypeHeader,
@@ -230,6 +232,31 @@ function assertOAuthRequestUrlAllowed(
   }
 }
 
+/**
+ * Required scopes the resolved connection's stored grant lacks. Credential
+ * health measures the same thing on the heartbeat; measuring it on the
+ * request names the gap at the moment a call may depend on it, since a
+ * connection made before a scope was required keeps working for every call
+ * that does not need it. A managed connection has no local row and reports
+ * nothing.
+ */
+function missingScopesForConnection(
+  providerRow: OAuthProviderRow,
+  connectionId: string,
+): string[] {
+  const row = getConnection(connectionId);
+  if (!row) {
+    return [];
+  }
+  return missingScopesForStoredToken(
+    parseJsonSafe<string[]>(providerRow.defaultScopes ?? "[]") ?? [],
+    parseJsonSafe<Record<string, string>>(providerRow.authorizeParams ?? "") ??
+      undefined,
+    providerRow.scopeSeparator,
+    parseJsonSafe<string[]>(row.grantedScopes ?? "[]") ?? [],
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Disconnect handler
 // ---------------------------------------------------------------------------
@@ -1002,6 +1029,15 @@ export async function handleRequest({ body = {} }: RouteHandlerArgs) {
       `(e.g. https://host/full/path) so the host and full path are set explicitly.`;
   }
 
+  const missingScopes = missingScopesForConnection(providerRow, connection.id);
+  if (missingScopes.length > 0) {
+    const scopeHint =
+      `The ${b.provider} connection is missing required scopes: ${missingScopes.join(", ")}. ` +
+      `It was connected before they were required, so calls that need them fail. ` +
+      `Reconnect it from Integrations, or run 'assistant oauth connect ${b.provider}', to grant them.`;
+    result.hint = result.hint ? `${scopeHint}\n\n${result.hint}` : scopeHint;
+  }
+
   return result;
 }
 

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

@@ -39,7 +39,17 @@ import {
 } from "@vellumai/service-contracts/platform-credential";
 import { z } from "zod";
 
+import {
+  setPlatformAssistantId,
+  setPlatformBaseUrl,
+  setPlatformOrganizationId,
+  setPlatformUserId,
+} from "../../config/env.js";
 import { isPlatformRemote } from "../../config/env-registry.js";
+import {
+  resolvePlatformOrganizationId,
+  resolvePlatformUserId,
+} from "../../config/platform-identity.js";
 import {
   registerCallbackRoute,
   resolvePlatformCallbackRegistrationContext,
@@ -289,24 +299,12 @@ async function handlePlatformStatus(
 ): Promise<PlatformStatusResponse> {
   const context = await resolvePlatformCallbackRegistrationContext();
 
-  const [orgIdRaw, userIdRaw, webhookSecretRaw] = await Promise.all([
-    getSecureKeyAsync(
-      credentialKey(
-        CREDENTIAL_KEYS.organizationId.service,
-        CREDENTIAL_KEYS.organizationId.field,
-      ),
-    ),
-    getSecureKeyAsync(
-      credentialKey(
-        CREDENTIAL_KEYS.userId.service,
-        CREDENTIAL_KEYS.userId.field,
-      ),
-    ),
+  const [organizationId, userId, webhookSecretRaw] = await Promise.all([
+    resolvePlatformOrganizationId(),
+    resolvePlatformUserId(),
     getSecureKeyAsync(credentialKey("vellum", "webhook_secret")),
   ]);
 
-  const organizationId = orgIdRaw?.trim() ?? "";
-  const userId = userIdRaw?.trim() ?? "";
   const hasWebhookSecret = !!webhookSecretRaw;
 
   return {
@@ -467,6 +465,11 @@ async function handlePlatformDisconnect(
     );
   }
 
+  setPlatformBaseUrl(undefined);
+  setPlatformAssistantId(undefined);
+  setPlatformOrganizationId(undefined);
+  setPlatformUserId(undefined);
+
   // Notify connected clients
   broadcastMessage({ type: "platform_disconnected" });