@vellumai/assistant 0.9.0 → 0.9.1-staging.1

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

@@ -27,18 +27,11 @@ import {
   setCachedEmptyStateGreeting,
 } from "./empty-state-greeting-cache.js";
 import { BadRequestError, ServiceUnavailableError } from "./errors.js";
-import {
-  getCachedIntro,
-  readWorkspaceGreetings,
-  setCachedIntro,
-} from "./identity-intro-cache.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+import { readWorkspaceGreetings } from "./workspace-greetings.js";
 
 const log = getLogger("btw-routes");
 
-/** Conversation key used by the client for identity intro generation. */
-const IDENTITY_INTRO_KEY = "identity-intro";
-
 /** Conversation key used by the client for empty-state greeting generation. */
 const GREETING_KEY = "greeting";
 
@@ -72,15 +65,6 @@ async function handleBtw({
 
   const trimmedContent = content.trim();
 
-  // ----- Cached identity intro fast-path -----
-  if (conversationKey === IDENTITY_INTRO_KEY) {
-    const fastText = getCachedIntro()?.greetings[0];
-    if (fastText) {
-      log.debug("Returning identity intro fast-path");
-      return streamText(fastText);
-    }
-  }
-
   // ----- Empty-state greeting fast-path -----
   // User-authored `## Greetings` win; otherwise replay a cached greeting when
   // one is fresh within the configurable TTL (`ui.emptyStateGreetingCacheTtlMs`,
@@ -126,7 +110,6 @@ async function handleBtw({
     start(controller) {
       (async () => {
         try {
-          const isIntroRequest = conversationKey === IDENTITY_INTRO_KEY;
           const isGreeting = conversationKey === GREETING_KEY;
           const result = await runBtwSidechain({
             content: effectiveContent,
@@ -153,15 +136,6 @@ async function handleBtw({
             );
           }
 
-          if (isIntroRequest && result.text) {
-            try {
-              setCachedIntro([result.text]);
-              log.debug("Cached identity intro text");
-            } catch {
-              // Non-fatal — next request will regenerate.
-            }
-          }
-
           if (isGreeting && result.text) {
             // setCachedEmptyStateGreeting is a no-op when the TTL is 0.
             setCachedEmptyStateGreeting(result.text);

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

@@ -72,7 +72,7 @@ const log = getLogger("conversation-compaction-routes");
  * `responseBody` (below) is the source-of-truth for the generated
  * OpenAPI client type the frontend imports
  * (`ConversationsByIdCompactionGetResponse` in
- * `apps/web/src/generated/daemon/types.gen`); regenerate the client with
+ * `clients/web/src/generated/daemon/types.gen`); regenerate the client with
  * `bun run openapi-ts` after changing the schema.
  *
  * `null` means the value isn't known for the underlying row — either the

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

@@ -944,8 +944,8 @@ export function handleListMessages({
       ...(mergedMessageIds.length > 0 ? { mergedMessageIds } : {}),
       ...(m.clientMessageId ? { clientMessageId: m.clientMessageId } : {}),
       role: m.role,
-      // Flat plain-text body the legacy Swift client reads directly; see the
-      // `content` field on ConversationMessageSchema for why this must stay.
+      // Flat plain-text body; see the `content` field on
+      // ConversationMessageSchema for why this must stay.
       content: text,
       timestamp: new Date(displayTimestamp).toISOString(),
       attachments: msgAttachments,

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

@@ -141,7 +141,9 @@ interface CredentialLookup {
  * Resolve a credential lookup from service+field or UUID.
  * Throws BadRequestError when neither is provided or the UUID is not found.
  */
-function resolveCredentialLookup(body: Record<string, unknown>): CredentialLookup {
+function resolveCredentialLookup(
+  body: Record<string, unknown>,
+): CredentialLookup {
   const { service, field, id } = body as {
     service?: string;
     field?: string;
@@ -243,8 +245,9 @@ async function handleCredentialsInspect({ body }: RouteHandlerArgs) {
   }
 
   const lookup = resolveCredentialLookup(body);
-  const { value: secret, unreachable } =
-    await getSecureKeyResultAsync(lookup.storageKey);
+  const { value: secret, unreachable } = await getSecureKeyResultAsync(
+    lookup.storageKey,
+  );
 
   if (!lookup.metadata && (secret == null || secret.length === 0)) {
     if (unreachable) {
@@ -290,8 +293,9 @@ async function handleCredentialsReveal({ body }: RouteHandlerArgs) {
   }
 
   const lookup = resolveCredentialLookup(body);
-  const { value: secret, unreachable } =
-    await getSecureKeyResultAsync(lookup.storageKey);
+  const { value: secret, unreachable } = await getSecureKeyResultAsync(
+    lookup.storageKey,
+  );
 
   if (secret == null || secret.length === 0) {
     if (unreachable) {
@@ -372,11 +376,19 @@ async function handleCredentialsDelete({ body }: RouteHandlerArgs) {
 
   assertMetadataWritable();
 
+  // The Slack user_token only grants read access to channels the bot isn't a
+  // member of; Socket Mode itself runs on the bot + app tokens. Deleting just
+  // the user_token must leave the oauth_connection intact — disconnecting the
+  // provider would flap the integration's connected state until the next sync.
+  // Every other step (secret + metadata removal, not-found handling) is the
+  // same as a normal credential delete.
+  const preserveOAuthConnection =
+    service === "slack_channel" && field === "user_token";
+
   const key = credentialKey(service, field);
   const existing = await getSecureKeyAsync(key);
-  const deleteResult = existing != null
-    ? await deleteSecureKeyAsync(key)
-    : "not-found";
+  const deleteResult =
+    existing != null ? await deleteSecureKeyAsync(key) : "not-found";
 
   if (deleteResult === "error") {
     throw new InternalError(
@@ -388,10 +400,12 @@ async function handleCredentialsDelete({ body }: RouteHandlerArgs) {
 
   // Clean up OAuth connection (best-effort).
   let oauthResult: "disconnected" | "not-found" | "error" = "not-found";
-  try {
-    oauthResult = await disconnectOAuthProvider(service);
-  } catch {
-    // Best-effort — OAuth tables may not exist yet
+  if (!preserveOAuthConnection) {
+    try {
+      oauthResult = await disconnectOAuthProvider(service);
+    } catch {
+      // Best-effort — OAuth tables may not exist yet
+    }
   }
 
   if (oauthResult === "error") {
@@ -437,8 +451,12 @@ export const ROUTES: RouteDefinition[] = [
       search: z.string().optional().describe("Filter by substring match"),
     }),
     responseBody: z.object({
-      credentials: z.array(z.unknown()).describe("Local credentials with metadata"),
-      managedCredentials: z.array(z.unknown()).describe("Platform-managed credentials"),
+      credentials: z
+        .array(z.unknown())
+        .describe("Local credentials with metadata"),
+      managedCredentials: z
+        .array(z.unknown())
+        .describe("Platform-managed credentials"),
     }),
     handler: handleCredentialsList,
   },
@@ -507,8 +525,14 @@ export const ROUTES: RouteDefinition[] = [
       field: z.string().describe("Field name (e.g. client_secret)"),
       value: z.string().describe("Secret value to store"),
       label: z.string().optional().describe("Human-friendly label"),
-      description: z.string().optional().describe("What this credential is used for"),
-      allowedTools: z.array(z.string()).optional().describe("Tool names that may use this credential"),
+      description: z
+        .string()
+        .optional()
+        .describe("What this credential is used for"),
+      allowedTools: z
+        .array(z.string())
+        .optional()
+        .describe("Tool names that may use this credential"),
     }),
     responseBody: z.object({
       credentialId: z.string(),

package/src/runtime/routes/empty-state-greeting-cache.ts

@@ -8,8 +8,7 @@
  * the greeting regenerates on every request. This is the knob a workspace
  * sets to always receive a fresh greeting.
  *
- * Storage uses the existing `memory_checkpoints` table (simple key-value
- * store), mirroring {@link ./identity-intro-cache.ts}.
+ * Storage uses the existing `memory_checkpoints` table.
  */
 
 import { getConfig } from "../../config/loader.js";

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

@@ -8,13 +8,9 @@ import { availableParallelism, cpus, totalmem } from "node:os";
 import { z } from "zod";
 
 import { getCpuLimit, getIsPlatform } from "../../config/env-registry.js";
-import { resolveCallSiteConfig } from "../../config/llm-resolver.js";
-import { getConfig } from "../../config/loader.js";
 import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getProfilerRuntimeStatus } from "../../daemon/profiler-run-store.js";
 import { getMaxMigrationVersion } from "../../memory/migrations/registry.js";
-import { buildSystemPrompt } from "../../prompts/system-prompt.js";
-import { getConfiguredProvider } from "../../providers/provider-send-message.js";
 import { getCesClient } from "../../security/secure-keys.js";
 import {
   getDiskUsageInfo,
@@ -27,15 +23,8 @@ import { resolveHatchedAtReadOnly } from "../../workspace/hatched-date.js";
 import { WORKSPACE_MIGRATIONS } from "../../workspace/migrations/registry.js";
 import { getLastWorkspaceMigrationId } from "../../workspace/migrations/runner.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import { runBtwSidechain } from "../btw-sidechain.js";
 import { NotFoundError } from "./errors.js";
-import {
-  getCachedIntro,
-  readWorkspaceGreetings,
-  readWorkspaceIdentityIntro,
-  setCachedIntro,
-} from "./identity-intro-cache.js";
-import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+import type { RouteDefinition } from "./types.js";
 
 interface MemoryInfo {
   currentMb: number;
@@ -405,256 +394,6 @@ function resolveIdentityCreatedAt(identityPath: string): string | undefined {
   return resolveHatchedAtReadOnly(identityPath);
 }
 
-const FALLBACK_GREETINGS = [
-  "What are we working on?",
-  "I'm here whenever you need me.",
-  "What's on your mind?",
-  "Ready when you are.",
-];
-
-const GENERATED_GREETING_LIMIT = 5;
-const GREETING_GENERATION_TIMEOUT_MS = 10_000;
-const GREETING_GENERATION_FAILURE_COOLDOWN_MS = 60_000;
-const EMPTY_STATE_GREETING_CALLSITE = "emptyStateGreeting" as const;
-const EXPLICIT_TIME_OF_DAY_PATTERN =
-  /\b(?:morning|afternoon|evening|tonight|midnight|noon|sunrise|sunset)\b/i;
-
-type IdentityIntroSource = "workspace" | "cache" | "fallback";
-
-interface IdentityIntroResponse {
-  greetings: string[];
-  text: string;
-  source: IdentityIntroSource;
-  refreshing: boolean;
-}
-
-let greetingGenerationInFlight: Promise<void> | null = null;
-let lastGreetingGenerationFailureAt = 0;
-
-function identityIntroResponse(
-  greetings: string[],
-  source: IdentityIntroSource,
-  refreshing = false,
-): IdentityIntroResponse {
-  return {
-    greetings,
-    text: greetings[0] ?? "",
-    source,
-    refreshing,
-  };
-}
-
-function getIdentityIntro({
-  queryParams = {},
-}: RouteHandlerArgs = {}): IdentityIntroResponse {
-  const localTimeContext = buildLocalTimeContext(queryParams);
-
-  // 1. User-defined greetings from SOUL.md `## Greetings`
-  const workspaceGreetings = readWorkspaceGreetings();
-  if (workspaceGreetings) {
-    return identityIntroResponse(workspaceGreetings, "workspace");
-  }
-
-  // 2. Cached LLM-generated greetings
-  const cached = getCachedIntro();
-  if (cached) {
-    return identityIntroResponse(cached.greetings, "cache");
-  }
-
-  // 3. Identity intro tagline from `## Identity Intro` in IDENTITY.md
-  //    (written during onboarding by BOOTSTRAP.md instructions)
-  const identityIntro = readWorkspaceIdentityIntro();
-  if (identityIntro) {
-    // Still trigger background generation so the next request gets
-    // LLM-generated greetings instead of the static tagline.
-    const refreshing = triggerEmptyStateGreetingGeneration(localTimeContext);
-    return identityIntroResponse(
-      [identityIntro, ...FALLBACK_GREETINGS],
-      "workspace",
-      refreshing,
-    );
-  }
-
-  // 4. Trigger fresh generation without blocking the empty-state UI.
-  const refreshing = triggerEmptyStateGreetingGeneration(localTimeContext);
-
-  // 5. Generic fallback only when generation is unavailable.
-  return identityIntroResponse(FALLBACK_GREETINGS, "fallback", refreshing);
-}
-
-function buildLocalTimeContext(
-  queryParams: Record<string, string>,
-): string | null {
-  const rawHour = queryParams.localHour;
-  const rawMinute = queryParams.localMinute;
-  if (rawHour === undefined || rawMinute === undefined) {
-    return null;
-  }
-
-  const hour = Number(rawHour);
-  const minute = Number(rawMinute);
-  if (
-    !Number.isInteger(hour) ||
-    !Number.isInteger(minute) ||
-    hour < 0 ||
-    hour > 23 ||
-    minute < 0 ||
-    minute > 59
-  ) {
-    return null;
-  }
-
-  const period =
-    hour >= 5 && hour < 12
-      ? "morning"
-      : hour >= 12 && hour < 17
-        ? "afternoon"
-        : hour >= 17 && hour < 21
-          ? "evening"
-          : "late night";
-  const paddedHour = String(hour).padStart(2, "0");
-  const paddedMinute = String(minute).padStart(2, "0");
-  return `${period} (${paddedHour}:${paddedMinute})`;
-}
-
-function triggerEmptyStateGreetingGeneration(
-  localTimeContext: string | null,
-): boolean {
-  if (greetingGenerationInFlight) {
-    return true;
-  }
-
-  if (
-    lastGreetingGenerationFailureAt > 0 &&
-    Date.now() - lastGreetingGenerationFailureAt <
-      GREETING_GENERATION_FAILURE_COOLDOWN_MS
-  ) {
-    return false;
-  }
-
-  greetingGenerationInFlight = new Promise<void>((resolve) => {
-    queueMicrotask(() => {
-      void generateEmptyStateGreetings(localTimeContext)
-        .then((greetings) => {
-          lastGreetingGenerationFailureAt = greetings === null ? Date.now() : 0;
-        })
-        .finally(() => {
-          greetingGenerationInFlight = null;
-          resolve();
-        });
-    });
-  });
-
-  return true;
-}
-
-async function generateEmptyStateGreetings(
-  localTimeContext: string | null,
-): Promise<string[] | null> {
-  try {
-    const provider = await getConfiguredProvider(EMPTY_STATE_GREETING_CALLSITE);
-    if (!provider) {
-      return null;
-    }
-
-    const resolved = resolveCallSiteConfig(
-      EMPTY_STATE_GREETING_CALLSITE,
-      getConfig().llm,
-    );
-    const systemPrompt = buildSystemPrompt({
-      excludeBootstrap: true,
-      excludeCustomPrefix: true,
-    });
-    const localTimeInstruction = localTimeContext
-      ? ` Current user-local time for subtle tone only: ${localTimeContext}.`
-      : "";
-    const result = await runBtwSidechain({
-      content:
-        `Generate ${GENERATED_GREETING_LIMIT} short first-person greeting options for the empty new-chat screen. ` +
-        "Use the assistant identity, voice, and relationship guidance from IDENTITY.md and SOUL.md. " +
-        "Each greeting should feel personal and inviting, not like a generic assistant introduction. " +
-        "Return only a JSON array of strings. No markdown, keys, or explanation. " +
-        "Generated greetings are cached for 4 hours, so do not mention the current time " +
-        "or use explicit time-of-day words like morning, afternoon, evening, or tonight." +
-        localTimeInstruction,
-      provider,
-      systemPrompt,
-      messages: [],
-      tools: [],
-      callSite: EMPTY_STATE_GREETING_CALLSITE,
-      maxTokens: resolved.maxTokens,
-      timeoutMs: GREETING_GENERATION_TIMEOUT_MS,
-    });
-
-    const greetings = parseGeneratedGreetings(result.text);
-    if (greetings.length === 0) {
-      return null;
-    }
-
-    setCachedIntro(greetings);
-    return greetings;
-  } catch (err) {
-    getLogger("identity").warn(
-      { err },
-      "Failed to generate empty-state greetings",
-    );
-    return null;
-  }
-}
-
-function parseGeneratedGreetings(text: string): string[] {
-  const cleaned = text
-    .trim()
-    .replace(/^```(?:json)?\s*/i, "")
-    .replace(/\s*```$/i, "")
-    .trim();
-
-  try {
-    const parsed = JSON.parse(cleaned) as unknown;
-    if (Array.isArray(parsed)) {
-      return normalizeGeneratedGreetings(parsed);
-    }
-    if (
-      parsed &&
-      typeof parsed === "object" &&
-      Array.isArray((parsed as { greetings?: unknown }).greetings)
-    ) {
-      return normalizeGeneratedGreetings(
-        (parsed as { greetings: unknown[] }).greetings,
-      );
-    }
-  } catch {
-    // Fall through to line parsing for non-JSON model output.
-  }
-
-  return normalizeGeneratedGreetings(cleaned.split("\n"));
-}
-
-function normalizeGeneratedGreetings(values: unknown[]): string[] {
-  const greetings: string[] = [];
-  const seen = new Set<string>();
-
-  for (const value of values) {
-    if (typeof value !== "string") continue;
-    const greeting = value
-      .trim()
-      .replace(/^(?:[-*+]\s+|\d+[.)]\s+)/, "")
-      .replace(/^["'`]+|["'`]+$/g, "")
-      .trim();
-    if (!greeting) continue;
-    if (EXPLICIT_TIME_OF_DAY_PATTERN.test(greeting)) continue;
-
-    const key = greeting.toLowerCase();
-    if (seen.has(key)) continue;
-    seen.add(key);
-    greetings.push(greeting);
-
-    if (greetings.length >= GENERATED_GREETING_LIMIT) break;
-  }
-
-  return greetings;
-}
-
 // ---------------------------------------------------------------------------
 // Zod schemas for profiler health metadata
 // ---------------------------------------------------------------------------
@@ -787,38 +526,4 @@ export const ROUTES: RouteDefinition[] = [
       createdAt: z.string().optional(),
     }),
   },
-  {
-    operationId: "identity_intro",
-    endpoint: "identity/intro",
-    method: "GET",
-    policy: {
-      requiredScopes: ["settings.read"],
-      allowedPrincipalTypes: ACTOR_PRINCIPALS,
-    },
-    handler: getIdentityIntro,
-    summary: "Get identity greetings",
-    description:
-      "Returns greetings sourced from SOUL.md, the generated cache, or generic fallbacks while background generation refreshes the cache.",
-    tags: ["identity"],
-    queryParams: [
-      {
-        name: "localHour",
-        schema: { type: "integer", minimum: 0, maximum: 23 },
-        description:
-          "Optional client-local hour of day used only when refreshing generated greetings.",
-      },
-      {
-        name: "localMinute",
-        schema: { type: "integer", minimum: 0, maximum: 59 },
-        description:
-          "Optional client-local minute used only when refreshing generated greetings.",
-      },
-    ],
-    responseBody: z.object({
-      greetings: z.array(z.string()),
-      text: z.string(),
-      source: z.enum(["workspace", "cache", "fallback"]),
-      refreshing: z.boolean(),
-    }),
-  },
 ];

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

@@ -166,7 +166,7 @@ export async function enforceIngressAcl(
     if (canonicalSenderId) {
       const contactResult = findContactChannel({
         channelType: sourceChannel,
-        externalUserId: canonicalSenderId,
+        address: canonicalSenderId,
         externalChatId: conversationExternalId,
       });
       resolvedMember = contactResult