@vellumai/assistant 0.11.8-staging.1 → 0.11.8

package/src/runtime/channel-invite-transports/email.ts

@@ -2,16 +2,18 @@
  * Email channel invite adapter.
  *
  * Resolves the assistant's email address for use in invite instructions.
- * Reads the address from workspace config (`email.address`). Returns
- * `undefined` when no address is configured, which causes the invite
+ * The address is a managed inbox registration, which lives on the platform
+ * (nothing about one lands in workspace config), so it resolves through the
+ * shared registered-inbox reader. Returns `undefined` when no address is
+ * registered or the platform cannot be asked, which causes the invite
  * instruction generator to emit generic "on Email" wording.
  *
  * Email invites use the universal 6-digit code path for redemption, so
- * this adapter only implements `resolveChannelHandleAsync` — no
+ * this adapter only implements `resolveChannelHandleAsync`, with no
  * `buildShareLink` or `extractInboundToken` needed.
  */
 
-import { getNestedValue, loadRawConfig } from "../../config/loader.js";
+import { resolveRegisteredInbox } from "../../email/registered-inbox.js";
 import type { ChannelInviteAdapter } from "../channel-invite-types.js";
 
 // ---------------------------------------------------------------------------
@@ -23,13 +25,12 @@ export const emailInviteAdapter: ChannelInviteAdapter = {
 
   async resolveChannelHandleAsync(): Promise<string | undefined> {
     try {
-      const raw = loadRawConfig();
-      const address = getNestedValue(raw, "email.address");
-      if (typeof address === "string" && address.length > 0) {
-        return address;
+      const inbox = await resolveRegisteredInbox();
+      if (inbox.status === "registered") {
+        return inbox.address;
       }
     } catch {
-      // Config unavailable
+      // Platform unavailable; fall through to generic wording
     }
     return undefined;
   },

package/src/runtime/channel-readiness-service.ts

@@ -283,32 +283,92 @@ const emailProbe: ChannelProbe = {
         "Email invite code redemption is enabled",
         "Email invite code redemption is disabled",
       ),
-      await checkIngress(),
+      // Managed callbacks allowed: inbound email arrives through the platform
+      // callback route the gateway registers (`registerEmailCallbackRoute`,
+      // the same pattern as Telegram's webhook route), so a platform-connected
+      // deployment with no public ingress URL still receives email.
+      await checkIngress(true),
     ];
   },
+  /**
+   * Ask the platform whether an inbox address is registered, falling back to
+   * a "your own" provider credential. The platform's email-addresses API is
+   * the only writer of managed inbox registrations (nothing about one lands
+   * in workspace config), and a BYO deployment's configuration claim is its
+   * stored provider API key, so those are the only sources this check may
+   * read.
+   *
+   * Three outcomes, matching the Telegram probe: an answer passes or fails
+   * the check outright, and an unreachable platform (with no BYO credential
+   * to fall back to) is indeterminate, which is not evidence of a fault and
+   * must not report the channel broken.
+   */
   async runRemoteChecks(): Promise<ReadinessCheckResult[]> {
-    try {
-      const raw = loadRawConfig();
-      const address = getNestedValue(raw, "email.address");
-      const hasInbox = typeof address === "string" && address.length > 0;
-      return [
-        {
-          name: "inbox_configured",
-          passed: hasInbox,
-          message: hasInbox
-            ? `Inbox address is configured (${address})`
-            : "No inbox address configured — register one with: assistant email register <username>",
-        },
-      ];
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return [
-        {
-          name: "inbox_configured",
-          passed: false,
-          message: `Failed to check inbox configuration: ${message}`,
-        },
-      ];
+    // Imported here rather than at module scope, matching the other probes:
+    // the platform client pulls in a module graph that unrelated consumers of
+    // this service should not have to mock.
+    const { resolveRegisteredInbox } =
+      await import("../email/registered-inbox.js");
+    // Fresh, because this service already caches remote checks for
+    // REMOTE_TTL_MS; layering the resolver's own cache under that would make
+    // an explicit readiness refresh serve a stale answer anyway.
+    const inbox = await resolveRegisteredInbox({ fresh: true });
+
+    // Published identifier (see the Telegram probe's `webhook_delivery` note):
+    // external clients search readiness responses for this name.
+    const name = "inbox_configured";
+
+    if (inbox.status !== "registered") {
+      const { resolveConfiguredByoEmailService } =
+        await import("../email/byo-email-credential.js");
+      const byoService = await resolveConfiguredByoEmailService();
+      if (byoService) {
+        return [
+          {
+            name,
+            passed: true,
+            message: `Email is configured through your own provider (${byoService} API key is stored)`,
+          },
+        ];
+      }
+    }
+
+    switch (inbox.status) {
+      case "registered":
+        return [
+          {
+            name,
+            passed: true,
+            message: `Inbox address is registered (${inbox.address})`,
+          },
+        ];
+      case "none":
+        return [
+          {
+            name,
+            passed: false,
+            message:
+              "No inbox address registered. Register one with: assistant email register <username>, or configure your own provider (Resend or Mailgun)",
+          },
+        ];
+      case "no_platform":
+        return [
+          {
+            name,
+            passed: false,
+            message:
+              "Email is not configured. Connect the platform for a managed inbox (assistant platform connect), or configure your own provider (Resend or Mailgun)",
+          },
+        ];
+      case "unavailable":
+        return [
+          {
+            name,
+            passed: true,
+            indeterminate: true,
+            message: `Could not reach the platform to check inbox registration (${inbox.detail})`,
+          },
+        ];
     }
   },
 };

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -1771,7 +1771,7 @@ describe("config invariant flag enrichment", () => {
     expect(profiles.custom!).not.toHaveProperty("invariant");
   });
 
-  test("every managed default is invariant on the wire, Speed included", async () => {
+  test("every managed default is invariant on the wire, Fast included", async () => {
     // The clients drive their read-only lock off this flag, so a default that
     // resolves from the catalog with no workspace stub must still carry it.
     const body = await configGetRoute.handler({});

package/src/runtime/routes/channel-availability-routes.ts

@@ -26,7 +26,8 @@ import {
   type ChannelInfo,
 } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
-import { VellumPlatformClient } from "../../platform/client.js";
+import { resolveConfiguredByoEmailService } from "../../email/byo-email-credential.js";
+import { resolveRegisteredInbox } from "../../email/registered-inbox.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -39,45 +40,31 @@ const BASE_AVAILABLE_CHANNELS: readonly ChannelId[] = [
   "phone",
 ] as const;
 
-interface EmailAddressListResponse {
-  count?: number;
-  results?: Array<{ id: string; address: string }>;
-}
-
 /**
- * Best-effort check that an inbox address is registered for this
- * assistant. A platform fetch failure is treated as "no inbox" — we
- * prefer to under-report than block the entire Contacts page when the
- * platform is briefly unreachable.
+ * Best-effort check that email is configured for this assistant: a managed
+ * inbox registered on the platform, or a "your own" provider credential
+ * (whose gateway webhook routes carry inbound just as the managed pipeline
+ * does). An unavailable platform is treated as "no inbox": we prefer to
+ * under-report than block the entire Contacts page when the platform is
+ * briefly unreachable.
+ *
+ * Fresh, preserving this route's long-standing live-read-per-request
+ * behavior: availability is fetched on surface loads, not on a poll, so it
+ * does not need the resolver's cache and should not inherit its staleness.
  */
-async function hasRegisteredInbox(): Promise<boolean> {
-  const client = await VellumPlatformClient.create();
-  if (!client?.platformAssistantId) {
-    return false;
-  }
-
-  try {
-    const response = await client.fetch(
-      `/v1/assistants/${client.platformAssistantId}/email-addresses/`,
-    );
-    if (!response.ok) {
-      return false;
-    }
-    const data = (await response.json()) as EmailAddressListResponse;
-    if (typeof data.count === "number") {
-      return data.count > 0;
-    }
-    return Array.isArray(data.results) && data.results.length > 0;
-  } catch {
-    return false;
+async function hasConfiguredEmail(): Promise<boolean> {
+  const inbox = await resolveRegisteredInbox({ fresh: true });
+  if (inbox.status === "registered") {
+    return true;
   }
+  return (await resolveConfiguredByoEmailService()) !== undefined;
 }
 
 async function handleGetChannelAvailability(
   _args: RouteHandlerArgs,
 ): Promise<{ channels: AvailableChannel[] }> {
   const ids: ChannelId[] = [...BASE_AVAILABLE_CHANNELS];
-  if (await hasRegisteredInbox()) {
+  if (await hasConfiguredEmail()) {
     ids.push("email");
   }
   if (isA2AEnabled(getConfig())) {

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

@@ -23,6 +23,7 @@ import {
   type ManagedCredentialDescriptor,
 } from "../../credential-execution/managed-catalog.js";
 import { buildForChatSentinel } from "../../daemon/chat-credential-redaction.js";
+import { invalidateEmailReadinessForByoCredential } from "../../email/byo-email-credential.js";
 import {
   disconnectOAuthProvider,
   getConnectionByProvider,
@@ -551,6 +552,8 @@ async function handleCredentialsDelete({ body }: RouteHandlerArgs) {
 
   invalidateConnectionsAfterCredentialDelete(affectedConnections);
 
+  await invalidateEmailReadinessForByoCredential(service);
+
   return { service, field, affectedConnections };
 }
 

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

@@ -7,7 +7,13 @@
 
 import { z } from "zod";
 
+import { getReadinessService } from "../../daemon/handlers/config-channels.js";
 import { markdownToEmailHtml } from "../../email/html-renderer.js";
+import {
+  invalidateRegisteredInboxCache,
+  listEmailAddresses,
+  type RegisteredEmailAddress,
+} from "../../email/registered-inbox.js";
 import { VellumPlatformClient } from "../../platform/client.js";
 import { LOCAL_PRINCIPALS } from "../auth/route-policy.js";
 import {
@@ -70,29 +76,42 @@ async function handleEmailRegister({ body = {} }: RouteHandlerArgs) {
     address: string;
     created_at: string;
   };
+  invalidateEmailReadinessState();
   return data;
 }
 
-async function handleEmailUnregister(_args: RouteHandlerArgs) {
-  const client = await requireClient();
-
-  const listResponse = await client.fetch(
-    `/v1/assistants/${client.platformAssistantId}/email-addresses/`,
-  );
+/**
+ * A registration change must be visible on the next readiness read: both the
+ * registered-inbox cache and the readiness service's cached email snapshot
+ * would otherwise keep answering with the pre-change state for their TTL.
+ */
+function invalidateEmailReadinessState(): void {
+  invalidateRegisteredInboxCache();
+  getReadinessService().invalidateChannel("email");
+}
 
-  if (!listResponse.ok) {
+/**
+ * The registered addresses, or the route-appropriate error: a listing
+ * failure maps to LIST_FAILED with the platform's status when it sent one.
+ */
+async function requireEmailAddressList(
+  client: VellumPlatformClient,
+): Promise<RegisteredEmailAddress[]> {
+  const list = await listEmailAddresses(client);
+  if (!list.ok) {
     throw new RouteError(
-      `Failed to list email addresses: HTTP ${listResponse.status}`,
+      `Failed to list email addresses: ${list.detail}`,
       "LIST_FAILED",
-      listResponse.status,
+      list.status ?? 502,
     );
   }
+  return list.addresses;
+}
 
-  const listData = (await listResponse.json()) as {
-    results: { id: string; address: string }[];
-  };
+async function handleEmailUnregister(_args: RouteHandlerArgs) {
+  const client = await requireClient();
 
-  const addresses = listData.results ?? [];
+  const addresses = await requireEmailAddressList(client);
   if (addresses.length === 0) {
     throw new NotFoundError("No email address registered for this assistant.");
   }
@@ -117,29 +136,14 @@ async function handleEmailUnregister(_args: RouteHandlerArgs) {
     );
   }
 
+  invalidateEmailReadinessState();
   return { unregistered: target.address };
 }
 
 async function handleEmailStatus(_args: RouteHandlerArgs) {
   const client = await requireClient();
 
-  const listResponse = await client.fetch(
-    `/v1/assistants/${client.platformAssistantId}/email-addresses/`,
-  );
-
-  if (!listResponse.ok) {
-    throw new RouteError(
-      `Failed to list email addresses: HTTP ${listResponse.status}`,
-      "LIST_FAILED",
-      listResponse.status,
-    );
-  }
-
-  const listData = (await listResponse.json()) as {
-    results: { id: string; address: string }[];
-  };
-
-  const addresses = listData.results ?? [];
+  const addresses = await requireEmailAddressList(client);
   if (addresses.length === 0) {
     throw new NotFoundError(
       "No email address registered for this assistant. Run: assistant email register <username>",
@@ -258,23 +262,7 @@ async function handleEmailSend({ body = {} }: RouteHandlerArgs) {
   const client = await requireClient();
 
   // Resolve "from" address
-  const listResponse = await client.fetch(
-    `/v1/assistants/${client.platformAssistantId}/email-addresses/`,
-  );
-
-  if (!listResponse.ok) {
-    throw new RouteError(
-      `Failed to list email addresses: HTTP ${listResponse.status}`,
-      "LIST_FAILED",
-      listResponse.status,
-    );
-  }
-
-  const listData = (await listResponse.json()) as {
-    results: { id: string; address: string }[];
-  };
-
-  const addresses = listData.results ?? [];
+  const addresses = await requireEmailAddressList(client);
   if (addresses.length === 0) {
     throw new NotFoundError(
       "No email address registered for this assistant. Run: assistant email register <username>",

package/src/runtime/verification-outbound-actions.ts

@@ -575,27 +575,23 @@ export function deliverVerificationEmail(
         return;
       }
 
-      const listResponse = await client.fetch(
-        `/v1/assistants/${client.platformAssistantId}/email-addresses/`,
-      );
-      if (!listResponse.ok) {
+      const { listEmailAddresses } =
+        await import("../email/registered-inbox.js");
+      const list = await listEmailAddresses(client);
+      if (!list.ok) {
         log.error(
-          { status: listResponse.status },
+          { status: list.status, detail: list.detail },
           "Failed to list email addresses for verification",
         );
         return;
       }
-      const listData = (await listResponse.json()) as {
-        results: { address: string }[];
-      };
-      const addresses = listData.results ?? [];
-      if (addresses.length === 0) {
+      const fromAddress = list.addresses[0]?.address;
+      if (!fromAddress) {
         log.error(
-          "No email address registered — cannot deliver verification email",
+          "No email address registered; cannot deliver verification email",
         );
         return;
       }
-      const fromAddress = addresses[0].address;
 
       const { markdownToEmailHtml } = await import("../email/html-renderer.js");
       const html = markdownToEmailHtml(text);

package/src/tools/credentials/store.ts

@@ -28,6 +28,7 @@ import {
   ACP_SERVICE,
   assertAcpCredentialFormat,
 } from "../../acp/acp-credentials.js";
+import { invalidateEmailReadinessForByoCredential } from "../../email/byo-email-credential.js";
 import { credentialKey } from "../../security/credential-key.js";
 import { normalizeSecretValue } from "../../security/secret-normalize.js";
 import {
@@ -176,5 +177,7 @@ export async function storeCredentialValue(
     );
   }
 
+  await invalidateEmailReadinessForByoCredential(service);
+
   return { credentialId: metadata.credentialId, service, field };
 }

package/src/util/pricing.ts

@@ -380,7 +380,8 @@ function calculateUsageCost(
     directInputCost +
     outputCost +
     calculateTokenCost(
-      effectivePricing.inputPer1M * ANTHROPIC_PROMPT_CACHE_MULTIPLIERS.read,
+      effectivePricing.cacheReadPer1M ??
+        effectivePricing.inputPer1M * ANTHROPIC_PROMPT_CACHE_MULTIPLIERS.read,
       usage.cacheReadInputTokens,
     ) +
     calculateTokenCost(