@vellumai/assistant 0.11.1 → 0.11.2-staging.2

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

@@ -3,17 +3,18 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { availableParallelism, cpus, totalmem } from "node:os";
+import { totalmem } from "node:os";
 
 import { z } from "zod";
 
-import { getCpuLimit, getIsPlatform } from "../../config/env-registry.js";
+import { getIsPlatform } from "../../config/env-registry.js";
 import { getDbMigrationReadiness } from "../../daemon/daemon-readiness.js";
 import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getProfilerRuntimeStatus } from "../../daemon/profiler-run-store.js";
 import { getMaxRollbackVersion } from "../../persistence/migrations/run-migrations.js";
 import { migrationSteps } from "../../persistence/steps.js";
 import { getCesClient } from "../../security/secure-keys.js";
+import { getContainerCpuCores } from "../../util/cgroup-cpu.js";
 import {
   getContainerMemoryLimitBytes,
   getContainerMemoryUsageBytes,
@@ -92,97 +93,6 @@ interface CpuInfo {
   maxCores: number;
 }
 
-/**
- * Parse a Kubernetes-style CPU string (e.g. "2000m", "1", "500m") into
- * fractional cores. Returns null if the value is not a recognized format.
- */
-function parseK8sCpuCores(value: string): number | null {
-  const trimmed = value.trim();
-  const milliMatch = trimmed.match(/^(\d+)m$/);
-  if (milliMatch) {
-    const millis = parseInt(milliMatch[1], 10);
-    return millis > 0 ? millis / 1000 : null;
-  }
-  if (/^\d+(\.\d+)?$/.test(trimmed)) {
-    const num = parseFloat(trimmed);
-    return !isNaN(num) && num > 0 ? num : null;
-  }
-  return null;
-}
-
-/**
- * Read the container's CPU core limit.
- *
- * Resolution order:
- * 1. VELLUM_CPU_LIMIT env var (K8s resource format, e.g. "2000m" or "2").
- *    In platform mode the container runs under gVisor where cgroup files may
- *    report the node's CPU count rather than the sandbox limit.
- * 2. cgroups v2 cpu.max (quota / period → fractional cores).
- * 3. cgroups v1 cpu.cfs_quota_us / cpu.cfs_period_us.
- * 4. os.cpus().length as last resort.
- */
-function getContainerCpuCores(): number {
-  // 1. Prefer the explicit env var set by the platform StatefulSet template.
-  try {
-    const envLimit = getCpuLimit();
-    if (envLimit) {
-      const parsed = parseK8sCpuCores(envLimit);
-      if (parsed !== null) {
-        return parsed;
-      }
-    }
-  } catch {
-    /* env var parsing failed – fall through */
-  }
-
-  // 2. Try cgroups v2: /sys/fs/cgroup/cpu.max contains "$MAX $PERIOD".
-  try {
-    const raw = readFileSync("/sys/fs/cgroup/cpu.max", "utf-8").trim();
-    if (!raw.startsWith("max")) {
-      const parts = raw.split(/\s+/);
-      const quota = parseInt(parts[0], 10);
-      const period = parseInt(parts[1], 10);
-      if (!isNaN(quota) && !isNaN(period) && period > 0 && quota > 0) {
-        const cores = quota / period;
-        // Sanity check: if the value looks like the node's full CPU count
-        // and we're on a platform pod, it's likely gVisor leaking the host value.
-        if (cores < cpus().length * 0.9 || !getIsPlatform()) {
-          return cores;
-        }
-      }
-    }
-  } catch {
-    /* not available */
-  }
-
-  // 3. Try cgroups v1.
-  try {
-    const quota = parseInt(
-      readFileSync("/sys/fs/cgroup/cpu/cpu.cfs_quota_us", "utf-8").trim(),
-      10,
-    );
-    const period = parseInt(
-      readFileSync("/sys/fs/cgroup/cpu/cpu.cfs_period_us", "utf-8").trim(),
-      10,
-    );
-    if (!isNaN(quota) && !isNaN(period) && period > 0 && quota > 0) {
-      const cores = quota / period;
-      if (cores < cpus().length * 0.9 || !getIsPlatform()) {
-        return cores;
-      }
-    }
-  } catch {
-    /* not available */
-  }
-
-  // 4. Fall back to the visible CPU count; 0 when even that syscall fails.
-  try {
-    return cpus().length || availableParallelism();
-  } catch {
-    return 0;
-  }
-}
-
 /**
  * Read the container's CPU usage from cgroup accounting files.
  *

package/src/runtime/routes/inbound-stages/admission-policy.test.ts

@@ -8,8 +8,13 @@
  */
 import { describe, expect, test } from "bun:test";
 
+import type { AdmissionPolicy } from "@vellumai/gateway-client";
+
 import type { AdmissionPolicyInput } from "./admission-policy.js";
-import { enforceAdmissionPolicy } from "./admission-policy.js";
+import {
+  enforceAdmissionPolicy,
+  trustedContactPromotionClearsFloor,
+} from "./admission-policy.js";
 
 function makeInput(
   overrides: Partial<AdmissionPolicyInput>,
@@ -176,3 +181,28 @@ describe("enforceAdmissionPolicy — rank vs floor", () => {
     expect(result.admitted).toBe(true);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Guardian approval reach: which floors a trusted-contact promotion clears
+// ---------------------------------------------------------------------------
+
+describe("trustedContactPromotionClearsFloor", () => {
+  const clears: AdmissionPolicy[] = [
+    "trusted_contacts",
+    "any_contact",
+    "strangers",
+  ];
+  const doesNotClear: AdmissionPolicy[] = ["guardian_only", "no_one"];
+
+  for (const policy of clears) {
+    test(`${policy} is cleared by a trusted-contact promotion`, () => {
+      expect(trustedContactPromotionClearsFloor(policy)).toBe(true);
+    });
+  }
+
+  for (const policy of doesNotClear) {
+    test(`${policy} is not cleared by a trusted-contact promotion`, () => {
+      expect(trustedContactPromotionClearsFloor(policy)).toBe(false);
+    });
+  }
+});

package/src/runtime/routes/inbound-stages/admission-policy.ts

@@ -102,6 +102,24 @@ const POLICIES_THAT_COULD_UPGRADE: ReadonlySet<AdmissionPolicy> = new Set([
   "strangers",
 ]);
 
+/**
+ * Whether promoting a caller to a trusted contact would lift them past this
+ * floor.
+ *
+ * A guardian approving an access request activates the requester as a trusted
+ * contact (directly for voice, per `guardian-request-resolvers.ts`; via the
+ * minted verification code for text), so approval only helps on floors at or
+ * below the trusted-contact rank. `guardian_only` and `no_one` sit above it:
+ * an approved caller would still be below the floor, so callers denied by
+ * those floors must not be routed into an approval flow that cannot admit
+ * them.
+ */
+export function trustedContactPromotionClearsFloor(
+  policy: AdmissionPolicy,
+): boolean {
+  return ADMISSION_FLOOR[policy] <= TRUST_CLASS_RANK.trusted_contact;
+}
+
 /**
  * Enforce the admission policy floor against the resolved trust class.
  *

package/src/runtime/routes/inference-provider-connection-routes.ts

@@ -39,7 +39,10 @@ import {
   updateConnection,
 } from "../../providers/inference/connections.js";
 import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
-import { isVellumManagedConnection } from "../../providers/vellum-model-routing.js";
+import {
+  isVellumManagedConnection,
+  VELLUM_MANAGED_PROVIDER,
+} from "../../providers/vellum-model-routing.js";
 import { credentialKey } from "../../security/credential-key.js";
 import { deleteSecureKeyAsync } from "../../security/secure-keys.js";
 import {
@@ -192,6 +195,39 @@ function deriveConnectionAuth(provider: string, credential: unknown): Auth {
   return derived;
 }
 
+/**
+ * Platform auth and `provider: "vellum"` record the same fact (the managed
+ * route) in two columns, and derivation always sets them together. Only an
+ * explicit `auth` object can split them, producing a row dispatch bills to
+ * the platform while every provider-keyed check reads it as BYOK, or the
+ * reverse.
+ */
+function assertAuthMatchesProvider(provider: string, auth: Auth): void {
+  const managedAuth = auth.type === "platform";
+  const managedProvider = provider === VELLUM_MANAGED_PROVIDER;
+  if (managedAuth === managedProvider) {
+    return;
+  }
+  throw new BadRequestError(
+    managedAuth
+      ? `Auth type "platform" is only valid for provider "${VELLUM_MANAGED_PROVIDER}", not "${provider}". Vellum-managed routing is selected by the provider, so omit "auth" to derive it.`
+      : `Provider "${VELLUM_MANAGED_PROVIDER}" is always platform-authenticated; "${auth.type}" auth is not valid for it. Omit "auth" to derive it, or name a real provider for key-based auth.`,
+  );
+}
+
+/**
+ * Stable form of an auth object for equality checks. Auth values are flat, so
+ * sorting the entries is enough to make two encodings of the same auth
+ * compare equal regardless of key order.
+ */
+function authFingerprint(auth: Auth): string {
+  return JSON.stringify(
+    Object.fromEntries(
+      Object.entries(auth).sort(([a], [b]) => a.localeCompare(b)),
+    ),
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------
@@ -300,6 +336,9 @@ async function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
   if (!authResult.success) {
     throw new BadRequestError(`Invalid auth: ${authResult.error.message}`);
   }
+  if (auth !== undefined) {
+    assertAuthMatchesProvider(providerResult.data, authResult.data);
+  }
 
   const labelRaw = body.label;
   if (
@@ -395,6 +434,16 @@ async function handleUpdateConnection({
   if (!authResult.success) {
     throw new BadRequestError(`Invalid auth: ${authResult.error.message}`);
   }
+  // The pairing is enforced on an actual auth change, not on the field being
+  // present: the web editor and the CLI both resend the stored auth on every
+  // edit, so a row whose columns already disagree stays relabelable and
+  // re-pointable.
+  if (
+    body.auth !== undefined &&
+    authFingerprint(authResult.data) !== authFingerprint(existing.auth)
+  ) {
+    assertAuthMatchesProvider(existing.provider, authResult.data);
+  }
 
   const labelRaw = body.label;
   if (
@@ -643,7 +692,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Create a provider connection",
     description:
-      "Create a new named provider connection. When auth is omitted it is derived from the provider (keyless providers get none, vellum gets platform, everything else needs credential for api_key auth). Fails with 409 if a connection with this name already exists.",
+      "Create a new named provider connection. When auth is omitted it is derived from the provider (keyless providers get none, vellum gets platform, everything else needs credential for api_key auth). An explicit auth object must agree with the provider; platform auth belongs to vellum and only to vellum. Fails with 409 if a connection with this name already exists.",
     tags: ["inference"],
     requestBody: z.object({
       name: z.string().min(1),
@@ -672,7 +721,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Update a provider connection",
     description:
-      "Update an existing connection. Cannot rename or change the provider. Omitting auth keeps the stored auth; passing credential alone rotates the key via provider-derived api_key auth. For the Vellum-managed connection (vellum) the auth is locked to platform; label remains editable.",
+      "Update an existing connection. Cannot rename or change the provider. Omitting auth keeps the stored auth; passing credential alone rotates the key via provider-derived api_key auth. An explicit auth object must agree with the connection's provider; platform auth belongs to vellum and only to vellum. For the Vellum-managed connection (vellum) the auth is locked to platform; label remains editable.",
     tags: ["inference"],
     pathParams: [{ name: "name", description: "Connection name" }],
     requestBody: z.object({

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

@@ -116,7 +116,10 @@ async function handleEmitSignal({ body = {} }: RouteHandlerArgs) {
 const EditNotificationParams = z
   .object({
     id: z.string().min(1).describe("Feed item id (notif:<uuid>) or bare uuid"),
-    title: z.string().optional(),
+    title: z
+      .string()
+      .optional()
+      .describe("New title. An empty value is ignored, never cleared."),
     body: z.string().optional(),
     urgency: UrgencySchema.optional(),
     status: z.enum(["new", "seen", "acted_on", "dismissed"]).optional(),

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

@@ -1,7 +1,7 @@
 /**
  * Platform route handlers for the shared HTTP/IPC route table.
  *
- * Serves eight operations:
+ * Serves ten operations:
  *   - platform_status (GET platform/status): aggregates platform context,
  *     credentials, assistant ID, and webhook secret. (Velay tunnel status
  *     lives on the gateway — see gateway_status.)
@@ -18,6 +18,10 @@
  *   - platform_subscription (GET platform/subscription): fetches the org's
  *     current plan, subscription status, and entitlements.
  *   - platform_plans (GET platform/plans): fetches the plan catalog with pricing.
+ *   - platform_invoices_list (GET platform/invoices): fetches one
+ *     cursor-paginated page of the org's Stripe invoice history.
+ *   - platform_invoices_by_id_get (GET platform/invoices/:id): pages through the
+ *     invoice list and returns a single invoice by Stripe invoice ID.
  */
 
 import { z } from "zod";
@@ -38,6 +42,7 @@ import { ACTOR_PRINCIPALS, LOCAL_PRINCIPALS } from "../auth/route-policy.js";
 import {
   BadRequestError,
   InternalError,
+  NotFoundError,
   UnprocessableEntityError,
 } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -126,6 +131,28 @@ const PlatformCreditsResponseSchema = z.object({
 });
 type PlatformCreditsResponse = z.infer<typeof PlatformCreditsResponseSchema>;
 
+const PlatformInvoiceSchema = z.object({
+  id: z.string(),
+  number: z.string().nullable(),
+  status: z.string().nullable(),
+  currency: z.string(),
+  amount_due: z.number(),
+  amount_paid: z.number(),
+  amount_remaining: z.number(),
+  created: z.number(),
+  hosted_invoice_url: z.string().nullable(),
+  invoice_pdf: z.string().nullable(),
+});
+type PlatformInvoice = z.infer<typeof PlatformInvoiceSchema>;
+
+const PlatformInvoicesListResponseSchema = z.object({
+  invoices: z.array(PlatformInvoiceSchema),
+  has_more: z.boolean(),
+});
+type PlatformInvoicesListResponse = z.infer<
+  typeof PlatformInvoicesListResponseSchema
+>;
+
 const SubscriptionPackageSchema = z.object({
   key: z.string(),
   name: z.string(),
@@ -383,15 +410,47 @@ async function handlePlatformCredits(
   };
 }
 
+/** Default per-request timeout for platform fetches. */
+const PLATFORM_FETCH_TIMEOUT_MS = 10_000;
+
+interface FetchPlatformJsonOptions {
+  /**
+   * Abort signal from the caller's request. Combined with the per-request
+   * timeout so whichever fires first cancels the fetch.
+   */
+  signal?: AbortSignal;
+  /**
+   * Per-request timeout override in milliseconds. Defaults to
+   * PLATFORM_FETCH_TIMEOUT_MS; callers with an aggregate deadline (the
+   * invoices_get cursor walk) pass the remaining budget instead.
+   */
+  timeoutMs?: number;
+  /**
+   * When set, an upstream HTTP 400 is surfaced as a BadRequestError combining
+   * the response detail with this hint, so caller-correctable input errors
+   * (e.g. an invalid pagination cursor) keep their 400 status. When unset, a
+   * 400 falls through to the generic InternalError path.
+   */
+  badRequestHint?: string;
+  /**
+   * When set, an upstream HTTP 404 resolves to this value instead of the
+   * generic InternalError path, for resources where the platform signals
+   * "nothing here" with a 404 (e.g. the invoice list for an organization
+   * without invoice history). When unset, a 404 stays an InternalError.
+   */
+  notFoundValue?: unknown;
+}
+
 /**
  * GET a JSON resource from the platform using the assistant's stored platform
  * credentials. Throws UnprocessableEntityError when credentials are missing and
  * InternalError on transport / non-2xx failures; `label` names the resource in
- * those error messages.
+ * those error messages. See FetchPlatformJsonOptions for per-call overrides.
  */
 async function fetchPlatformJson(
   path: string,
   label: string,
+  options?: FetchPlatformJsonOptions,
 ): Promise<unknown> {
   const context = await resolvePlatformCallbackRegistrationContext();
 
@@ -402,6 +461,9 @@ async function fetchPlatformJson(
   }
 
   const url = `${context.platformBaseUrl}${path}`;
+  const timeout = AbortSignal.timeout(
+    options?.timeoutMs ?? PLATFORM_FETCH_TIMEOUT_MS,
+  );
   let response: Response;
   try {
     response = await fetch(url, {
@@ -410,7 +472,9 @@ async function fetchPlatformJson(
         Authorization: context.authHeader,
         Accept: "application/json",
       },
-      signal: AbortSignal.timeout(10_000),
+      signal: options?.signal
+        ? AbortSignal.any([options.signal, timeout])
+        : timeout,
     });
   } catch (err) {
     throw new InternalError(
@@ -419,7 +483,16 @@ async function fetchPlatformJson(
   }
 
   if (!response.ok) {
+    if (response.status === 404 && options?.notFoundValue !== undefined) {
+      return options.notFoundValue;
+    }
     const detail = await response.text().catch(() => "");
+    if (response.status === 400 && options?.badRequestHint) {
+      throw new BadRequestError(
+        `Platform rejected the ${label} request${detail ? `: ${detail}` : ""}. ` +
+          options.badRequestHint,
+      );
+    }
     throw new InternalError(
       `Failed to fetch ${label} (HTTP ${response.status}): ${detail}`,
     );
@@ -485,6 +558,129 @@ async function handlePlatformPlans(
   return { plans: data.plans ?? [] };
 }
 
+/**
+ * Fetch one cursor-paginated page of the org's Stripe invoice history from
+ * the platform. Pass the previous page's last invoice id as `startingAfter`
+ * to fetch the next (older) page.
+ */
+async function fetchPlatformInvoicesPage(
+  startingAfter: string | undefined,
+  options?: FetchPlatformJsonOptions,
+): Promise<PlatformInvoicesListResponse> {
+  let path = "/v1/organizations/billing/invoices/";
+  if (startingAfter) {
+    path += `?${new URLSearchParams({ starting_after: startingAfter })}`;
+  }
+  return (await fetchPlatformJson(path, "invoices", {
+    ...options,
+    // The platform returns 404 for an organization without invoice history;
+    // the web client treats that as an empty page
+    // (clients/web/src/domains/settings/components/invoices-table.tsx) and
+    // the daemon matches it.
+    notFoundValue: { invoices: [], has_more: false },
+  })) as PlatformInvoicesListResponse;
+}
+
+async function handlePlatformInvoicesList(
+  args: RouteHandlerArgs,
+): Promise<PlatformInvoicesListResponse> {
+  const startingAfter = args.queryParams?.starting_after;
+  return await fetchPlatformInvoicesPage(startingAfter, {
+    signal: args.abortSignal,
+    // The platform returns 400 for an invalid or expired starting_after
+    // cursor. Only a caller-supplied cursor is caller-correctable, so the
+    // hint (and the BadRequestError it triggers) applies just when one was
+    // passed; a 400 on a cursor-less request stays an InternalError.
+    badRequestHint: startingAfter
+      ? "If you passed starting_after, use the id of the last invoice from the previous page."
+      : undefined,
+  });
+}
+
+/**
+ * Runaway guard for the invoices_get cursor walk: 25 pages is 2,500
+ * invoices at the platform's 100-per-page size.
+ */
+export const MAX_INVOICE_PAGES = 25;
+
+/**
+ * Aggregate wall-clock deadline for the invoices_get cursor walk, matching
+ * the gateway IPC client's 30s request timeout. Guards against the walk
+ * running long after the caller has given up, since a gateway IPC timeout
+ * does not abort the request signal.
+ */
+export const INVOICE_WALK_DEADLINE_MS = 30_000;
+
+function invoiceWalkTimeoutError(id: string): InternalError {
+  return new InternalError(
+    `Invoice lookup for "${id}" timed out after ` +
+      `${INVOICE_WALK_DEADLINE_MS / 1000} seconds while paging invoice history`,
+  );
+}
+
+async function handlePlatformInvoiceGet(
+  args: RouteHandlerArgs,
+): Promise<PlatformInvoice> {
+  const id = args.pathParams?.id;
+  if (!id) {
+    throw new BadRequestError("invoice id is required");
+  }
+
+  // There is no per-invoice platform endpoint, so walk the paginated list
+  // until the invoice turns up or the cursor is exhausted.
+  const walkStartedAt = Date.now();
+  let cursor: string | undefined;
+  for (let pages = 0; pages < MAX_INVOICE_PAGES; pages++) {
+    // Stop walking pages once the caller has gone away (gateway IPC timeout,
+    // disconnected HTTP client). In-flight fetches are cancelled via the
+    // signal passed to fetchPlatformInvoicesPage.
+    if (args.abortSignal?.aborted) {
+      throw new InternalError(
+        `Invoice lookup for "${id}" aborted: caller disconnected`,
+      );
+    }
+    const remainingMs = walkStartedAt + INVOICE_WALK_DEADLINE_MS - Date.now();
+    if (remainingMs <= 0) {
+      throw invoiceWalkTimeoutError(id);
+    }
+    // Bound the page fetch by the remaining aggregate budget so a fetch
+    // started just under the deadline cannot run the walk past it.
+    let page: PlatformInvoicesListResponse;
+    try {
+      // No badRequestHint: the cursor is internally generated, so an
+      // upstream 400 here is an internal failure, not a caller input error.
+      page = await fetchPlatformInvoicesPage(cursor, {
+        signal: args.abortSignal,
+        timeoutMs: Math.min(PLATFORM_FETCH_TIMEOUT_MS, remainingMs),
+      });
+    } catch (err) {
+      // A fetch cancelled by the deadline remainder should read as the
+      // walk's aggregate timeout, not a generic network failure.
+      if (
+        !args.abortSignal?.aborted &&
+        Date.now() - walkStartedAt >= INVOICE_WALK_DEADLINE_MS
+      ) {
+        throw invoiceWalkTimeoutError(id);
+      }
+      throw err;
+    }
+    const match = page.invoices.find((invoice) => invoice.id === id);
+    if (match) {
+      return match;
+    }
+    if (!page.has_more || page.invoices.length === 0) {
+      throw new NotFoundError(
+        `Invoice "${id}" not found. Run 'assistant platform invoices list' to see available invoices.`,
+      );
+    }
+    cursor = page.invoices.at(-1)!.id;
+  }
+
+  throw new InternalError(
+    `Invoice "${id}" not found in the first ${MAX_INVOICE_PAGES} pages of invoice history`,
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -611,4 +807,43 @@ export const ROUTES: RouteDefinition[] = [
     handler: handlePlatformPlans,
     responseBody: PlatformPlansResponseSchema,
   },
+  {
+    operationId: "platform_invoices_list",
+    endpoint: "platform/invoices",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "List one page of the organization's Stripe invoices",
+    description:
+      "Fetches one page of the org's Stripe invoice history (newest first) from the platform billing invoices endpoint. Amounts are in the currency's minor units. When has_more is true, pass the last invoice's id as starting_after to fetch the next page.",
+    tags: ["platform"],
+    queryParams: [
+      {
+        name: "starting_after",
+        type: "string",
+        required: false,
+        description:
+          "Cursor: return invoices older than the invoice with this id (from the previous page's last entry).",
+      },
+    ],
+    handler: handlePlatformInvoicesList,
+    responseBody: PlatformInvoicesListResponseSchema,
+  },
+  {
+    operationId: "platform_invoices_by_id_get",
+    endpoint: "platform/invoices/:id",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Get a single Stripe invoice by ID",
+    description:
+      "Pages through the org's invoice list from the platform and returns the invoice matching the given Stripe invoice ID (e.g. in_xxx). 404 if no such invoice.",
+    tags: ["platform"],
+    handler: handlePlatformInvoiceGet,
+    responseBody: PlatformInvoiceSchema,
+  },
 ];

package/src/runtime/routes/playground/guard.ts

@@ -1,5 +1,4 @@
 import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
-import { getConfig } from "../../../config/loader.js";
 import { RouteError } from "../errors.js";
 
 /**
@@ -16,7 +15,7 @@ import { RouteError } from "../errors.js";
 const PLAYGROUND_DISABLED_CODE = "playground_disabled";
 
 function isPlaygroundEnabled(): boolean {
-  return isAssistantFeatureFlagEnabled("compaction-playground", getConfig());
+  return isAssistantFeatureFlagEnabled("compaction-playground");
 }
 
 /**

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

@@ -4,10 +4,8 @@ import {
   conversationMetadataSyncTag,
   SYNC_TAGS,
 } from "../../daemon/message-types/sync.js";
-import {
-  getSlackConversationInfo,
-  SlackApiError,
-} from "../../messaging/providers/slack/api.js";
+import { getSlackConversationInfo } from "../../messaging/providers/slack/api.js";
+import { SlackApiError } from "../../messaging/providers/slack/web-api-transport.js";
 import {
   getBindingByConversation,
   updateExternalChatName,