@vellumai/assistant 0.8.7 → 0.8.8

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

@@ -7,10 +7,15 @@ import { availableParallelism, cpus, totalmem } from "node:os";
 
 import { z } from "zod";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 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,
@@ -23,10 +28,12 @@ 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,
+  setCachedIntro,
 } from "./identity-intro-cache.js";
 import type { RouteDefinition } from "./types.js";
 
@@ -402,31 +409,190 @@ const FALLBACK_GREETINGS = [
   "Ready when you are.",
 ];
 
-function getIdentityIntro() {
+const GENERATED_GREETING_LIMIT = 4;
+const GREETING_GENERATION_TIMEOUT_MS = 10_000;
+const GREETING_GENERATION_FAILURE_COOLDOWN_MS = 60_000;
+const EMPTY_STATE_GREETING_CALLSITE = "emptyStateGreeting" as const;
+const EMPTY_STATE_DYNAMIC_GREETINGS_FLAG =
+  "empty-state-dynamic-greetings" as const;
+
+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(): IdentityIntroResponse {
   // 1. User-defined greetings from SOUL.md `## Greetings`
   const workspaceGreetings = readWorkspaceGreetings();
   if (workspaceGreetings) {
-    return { greetings: workspaceGreetings, text: workspaceGreetings[0] };
+    return identityIntroResponse(workspaceGreetings, "workspace");
+  }
+
+  const config = getConfig();
+  if (
+    !isAssistantFeatureFlagEnabled(EMPTY_STATE_DYNAMIC_GREETINGS_FLAG, config)
+  ) {
+    return identityIntroResponse(FALLBACK_GREETINGS, "fallback");
   }
 
   // 2. Cached LLM-generated greetings
   const cached = getCachedIntro();
   if (cached) {
-    return { greetings: cached.greetings, text: cached.greetings[0] };
+    return identityIntroResponse(cached.greetings, "cache");
   }
 
-  // 3. Fallback: name-based greeting + static defaults
-  const identityPath = getWorkspacePromptPath("IDENTITY.md");
-  if (existsSync(identityPath)) {
-    const content = readFileSync(identityPath, "utf-8");
-    const fields = parseIdentityFields(content);
-    if (fields.name) {
-      const greetings = [`Hi, I'm ${fields.name}!`, ...FALLBACK_GREETINGS];
-      return { greetings, text: greetings[0] };
+  // 3. Trigger fresh generation without blocking the empty-state UI.
+  const refreshing = triggerEmptyStateGreetingGeneration();
+
+  // 4. Generic fallback only when generation is unavailable.
+  return identityIntroResponse(FALLBACK_GREETINGS, "fallback", refreshing);
+}
+
+function triggerEmptyStateGreetingGeneration(): 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()
+        .then((greetings) => {
+          lastGreetingGenerationFailureAt = greetings === null ? Date.now() : 0;
+        })
+        .finally(() => {
+          greetingGenerationInFlight = null;
+          resolve();
+        });
+    });
+  });
+
+  return true;
+}
+
+async function generateEmptyStateGreetings(): 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 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.",
+      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;
+
+    const key = greeting.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    greetings.push(greeting);
+
+    if (greetings.length >= GENERATED_GREETING_LIMIT) break;
   }
 
-  return { greetings: FALLBACK_GREETINGS, text: FALLBACK_GREETINGS[0] };
+  return greetings;
 }
 
 // ---------------------------------------------------------------------------
@@ -464,14 +630,37 @@ const cesHealthSchema = z.object({
   connected: z.boolean(),
 });
 
+const healthDiskSchema = z.object({
+  path: z.string(),
+  totalMb: z.number(),
+  usedMb: z.number(),
+  freeMb: z.number(),
+});
+
+const healthMemorySchema = z.object({
+  currentMb: z.number(),
+  maxMb: z.number(),
+});
+
+const healthCpuSchema = z.object({
+  currentPercent: z.number(),
+  maxCores: z.number(),
+});
+
+const healthMigrationsSchema = z.object({
+  dbVersion: z.number(),
+  lastWorkspaceMigrationId: z.string().nullable(),
+});
+
 const detailedHealthSchema = z.object({
   status: z.string(),
   timestamp: z.string(),
   version: z.string(),
-  disk: z.object({}).passthrough(),
-  memory: z.object({}).passthrough(),
-  cpu: z.object({}).passthrough(),
-  migrations: z.object({}).passthrough(),
+  // `getDiskUsageInfo()` returns null when usage can't be measured.
+  disk: healthDiskSchema.nullable(),
+  memory: healthMemorySchema,
+  cpu: healthCpuSchema,
+  migrations: healthMigrationsSchema,
   ces: cesHealthSchema,
   profiler: profilerStatusSchema.optional(),
 });
@@ -544,11 +733,13 @@ export const ROUTES: RouteDefinition[] = [
     handler: getIdentityIntro,
     summary: "Get identity greetings",
     description:
-      "Returns an array of greetings sourced from SOUL.md, LLM cache, or static fallbacks.",
+      "Returns greetings sourced from SOUL.md, the generated cache, or generic fallbacks while background generation refreshes the cache.",
     tags: ["identity"],
     responseBody: z.object({
       greetings: z.array(z.string()),
       text: z.string(),
+      source: z.enum(["workspace", "cache", "fallback"]),
+      refreshing: z.boolean(),
     }),
   },
 ];

package/src/runtime/routes/image-generation-routes.ts

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 import { getConfig } from "../../config/loader.js";
 import { resolveImageGenCredentials } from "../../media/image-credentials.js";
 import {
@@ -6,16 +8,50 @@ import {
   providerForModel,
 } from "../../media/image-service.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import { BadRequestError, InternalError, UnprocessableEntityError } from "./errors.js";
+import {
+  BadRequestError,
+  InternalError,
+  UnprocessableEntityError,
+} from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
+const SourceImageSchema = z.object({
+  mimeType: z.string(),
+  dataBase64: z.string(),
+});
+
+const ImageGenerationRequestSchema = z.object({
+  prompt: z.string(),
+  mode: z.enum(["generate", "edit"]).optional(),
+  sourceImages: z.array(SourceImageSchema).optional(),
+  model: z.string().optional(),
+  variants: z.number().optional(),
+});
+
+const GeneratedImageSchema = z.object({
+  mimeType: z.string(),
+  dataBase64: z.string(),
+  title: z.string().optional(),
+});
+
+const ImageGenerationResponseSchema = z.object({
+  images: z.array(GeneratedImageSchema),
+  text: z.string().optional(),
+  resolvedModel: z.string(),
+});
+type ImageGenerationResponse = z.infer<typeof ImageGenerationResponseSchema>;
+
 // ---------------------------------------------------------------------------
 // Handler
 // ---------------------------------------------------------------------------
 
 async function handleImageGenerationGenerate(
   args: RouteHandlerArgs,
-): Promise<unknown> {
+): Promise<ImageGenerationResponse> {
   const { prompt, mode, sourceImages, model, variants } = args.body ?? {};
 
   // Validate prompt
@@ -99,6 +135,8 @@ export const ROUTES: RouteDefinition[] = [
     description:
       "Calls the configured image-generation provider (Gemini or OpenAI) to produce one or more images.",
     tags: ["image-generation"],
+    requestBody: ImageGenerationRequestSchema,
+    responseBody: ImageGenerationResponseSchema,
     handler: handleImageGenerationGenerate,
   },
 ];

package/src/runtime/routes/index.ts

@@ -85,6 +85,7 @@ import { ROUTES as TELEGRAM_ROUTES } from "./integrations/telegram.js";
 import { ROUTES as TWILIO_ROUTES } from "./integrations/twilio.js";
 import { ROUTES as VERCEL_ROUTES } from "./integrations/vercel.js";
 import { ROUTES as INTERNAL_OAUTH_ROUTES } from "./internal-oauth-routes.js";
+import { ROUTES as INTERNAL_TELEMETRY_ROUTES } from "./internal-telemetry-routes.js";
 import { ROUTES as INTERNAL_TWILIO_ROUTES } from "./internal-twilio-routes.js";
 import { ROUTES as LLM_CALL_SITES_ROUTES } from "./llm-call-sites-routes.js";
 import { ROUTES as LOG_EXPORT_ROUTES } from "./log-export-routes.js";
@@ -212,6 +213,7 @@ export const ROUTES: RouteDefinition[] = [
   ...INFERENCE_PROVIDER_CONNECTION_ROUTES,
   ...INFERENCE_SEND_ROUTES,
   ...INTERNAL_OAUTH_ROUTES,
+  ...INTERNAL_TELEMETRY_ROUTES,
   ...MCP_AUTH_ROUTES,
   ...OAUTH_CONNECT_ROUTES,
   ...INTERNAL_TWILIO_ROUTES,

package/src/runtime/routes/integrations/a2a.ts

@@ -10,17 +10,20 @@
  * POST   /v1/integrations/a2a/invite/accept   — self-hosted broker: orchestrate complete + redeem
  */
 
-import { z } from "zod";
-
 import { isA2AEnabled } from "../../../a2a/feature-gate.js";
 import { getConfig } from "../../../config/loader.js";
 import {
+  A2AConfigResultSchema,
   acceptA2AInvite,
+  AcceptA2AInviteResultSchema,
   clearA2AConfig,
   completeA2AInvite,
+  CompleteA2AInviteResultSchema,
   createA2AInvite,
+  CreateA2AInviteResultSchema,
   getA2AConfig,
   redeemA2AInvite,
+  RedeemA2AInviteResultSchema,
   setA2AConfig,
 } from "../../../daemon/handlers/config-a2a.js";
 import {
@@ -232,6 +235,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Check current A2A channel configuration status.",
     tags: ["integrations"],
     handler: () => handleGetA2AConfig(),
+    responseBody: A2AConfigResultSchema,
   },
   {
     operationId: "integrations_a2a_config_post",
@@ -242,6 +246,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Enable the A2A channel for inter-assistant communication.",
     tags: ["integrations"],
     handler: () => handleSetA2AConfig(),
+    responseBody: A2AConfigResultSchema,
   },
   {
     operationId: "integrations_a2a_config_delete",
@@ -252,6 +257,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Disable the A2A channel.",
     tags: ["integrations"],
     handler: () => handleClearA2AConfig(),
+    responseBody: A2AConfigResultSchema,
   },
   {
     operationId: "integrations_a2a_invite_post",
@@ -266,14 +272,7 @@ export const ROUTES: RouteDefinition[] = [
       "Create a shareable A2A invite token for link-based contact creation.",
     tags: ["integrations"],
     handler: handleCreateA2AInvite,
-    responseBody: z.object({
-      success: z.boolean(),
-      inviteId: z.string().optional(),
-      token: z.string().optional(),
-      expiresAt: z.number().optional(),
-      senderGatewayUrl: z.string().optional(),
-      error: z.string().optional(),
-    }),
+    responseBody: CreateA2AInviteResultSchema,
   },
   {
     operationId: "integrations_a2a_invite_complete_post",
@@ -288,6 +287,7 @@ export const ROUTES: RouteDefinition[] = [
       "Called by the platform to finalize the sender side of a link-based A2A connection.",
     tags: ["integrations"],
     handler: handleCompleteA2AInvite,
+    responseBody: CompleteA2AInviteResultSchema,
   },
   {
     operationId: "integrations_a2a_invite_redeem_post",
@@ -302,6 +302,7 @@ export const ROUTES: RouteDefinition[] = [
       "Called by the platform to create a trusted contact on the receiver side of a link-based A2A connection.",
     tags: ["integrations"],
     handler: handleRedeemA2AInvite,
+    responseBody: RedeemA2AInviteResultSchema,
   },
   {
     operationId: "integrations_a2a_invite_accept_post",
@@ -313,5 +314,6 @@ export const ROUTES: RouteDefinition[] = [
       "Orchestrate cross-daemon invite acceptance for self-hosted deployments. Calls the sender's invite/complete, then creates a local contact via invite/redeem.",
     tags: ["integrations"],
     handler: handleAcceptA2AInvite,
+    responseBody: AcceptA2AInviteResultSchema,
   },
 ];

package/src/runtime/routes/integrations/slack/__tests__/channel.test.ts

@@ -7,6 +7,8 @@
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
 
+import { z } from "zod";
+
 import type { SlackChannelConfigResult } from "../../../../../daemon/handlers/config-slack-channel.js";
 
 // ---------------------------------------------------------------------------
@@ -29,6 +31,20 @@ let mockSetConfigResult: SlackChannelConfigResult = {
 };
 
 mock.module("../../../../../daemon/handlers/config-slack-channel.js", () => ({
+  SlackChannelConfigResultSchema: z.object({
+    success: z.boolean(),
+    hasBotToken: z.boolean(),
+    hasAppToken: z.boolean(),
+    hasUserToken: z.boolean(),
+    connected: z.boolean(),
+    teamId: z.string().optional(),
+    teamName: z.string().optional(),
+    teamUrl: z.string().optional(),
+    botUserId: z.string().optional(),
+    botUsername: z.string().optional(),
+    error: z.string().optional(),
+    warning: z.string().optional(),
+  }),
   setSlackChannelConfig: async (
     botToken?: string,
     appToken?: string,

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

@@ -12,6 +12,7 @@ import {
   clearSlackChannelConfig,
   getSlackChannelConfig,
   setSlackChannelConfig,
+  SlackChannelConfigResultSchema,
 } from "../../../../daemon/handlers/config-slack-channel.js";
 import { ACTOR_PRINCIPALS } from "../../../auth/route-policy.js";
 import { BadRequestError } from "../../errors.js";
@@ -62,6 +63,7 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Get Slack channel config",
     description: "Check current Slack channel configuration status.",
     tags: ["integrations"],
+    responseBody: SlackChannelConfigResultSchema,
     handler: () => handleGetSlackChannelConfig(),
   },
   {
@@ -80,6 +82,7 @@ export const ROUTES: RouteDefinition[] = [
       botToken: z.string().describe("Slack bot token"),
       appToken: z.string().describe("Slack app-level token"),
     }),
+    responseBody: SlackChannelConfigResultSchema,
   },
   {
     operationId: "integrations_slack_channel_config_delete",
@@ -92,6 +95,7 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Clear Slack channel config",
     description: "Clear stored Slack channel credentials.",
     tags: ["integrations"],
+    responseBody: SlackChannelConfigResultSchema,
     handler: () => handleClearSlackChannelConfig(),
   },
 ];

package/src/runtime/routes/integrations/slack/share.ts

@@ -5,6 +5,8 @@
  * without going through the legacy Slack share flow.
  */
 
+import { z } from "zod";
+
 import { getApp } from "../../../../memory/app-store.js";
 import {
   listConversations,
@@ -29,12 +31,24 @@ const log = getLogger("slack-share");
 // GET /v1/slack/channels
 // ---------------------------------------------------------------------------
 
-interface NormalizedChannel {
-  id: string;
-  name: string;
-  type: "channel" | "group" | "dm";
-  isPrivate: boolean;
-}
+const NormalizedChannelSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.enum(["channel", "group", "dm"]),
+  isPrivate: z.boolean(),
+});
+
+type NormalizedChannel = z.infer<typeof NormalizedChannelSchema>;
+
+const SlackChannelsListResultSchema = z.object({
+  channels: z.array(NormalizedChannelSchema),
+});
+
+const SlackShareResultSchema = z.object({
+  ok: z.boolean(),
+  ts: z.string(),
+  channel: z.string(),
+});
 
 function classifyConversation(
   conv: SlackConversation,
@@ -205,6 +219,7 @@ export const ROUTES: RouteDefinition[] = [
     summary: "List Slack channels",
     description: "List Slack channels, groups, and DMs for the channel picker.",
     tags: ["integrations"],
+    responseBody: SlackChannelsListResultSchema,
     handler: () => handleListSlackChannels(),
   },
   {
@@ -218,6 +233,12 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Share to Slack channel",
     description: "Post an app link directly to a Slack channel.",
     tags: ["integrations"],
+    requestBody: z.object({
+      appId: z.string().describe("App to share"),
+      channelId: z.string().describe("Target Slack channel ID"),
+      message: z.string().optional().describe("Optional accompanying message"),
+    }),
+    responseBody: SlackShareResultSchema,
     handler: handleShareToSlackChannel,
   },
 ];

package/src/runtime/routes/integrations/telegram.ts

@@ -16,6 +16,7 @@ import {
   setTelegramCommands,
   setTelegramConfig,
   setupTelegram,
+  TelegramConfigResultSchema,
 } from "../../../daemon/handlers/config-telegram.js";
 import { ACTOR_PRINCIPALS } from "../../auth/route-policy.js";
 import { BadRequestError } from "../errors.js";
@@ -87,6 +88,7 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Get Telegram config",
     description: "Check current Telegram bot configuration status.",
     tags: ["integrations"],
+    responseBody: TelegramConfigResultSchema,
     handler: () => handleGetTelegramConfig(),
   },
   {
@@ -104,6 +106,7 @@ export const ROUTES: RouteDefinition[] = [
     requestBody: z.object({
       botToken: z.string().describe("Telegram bot token"),
     }),
+    responseBody: TelegramConfigResultSchema,
   },
   {
     operationId: "integrations_telegram_config_delete",
@@ -116,6 +119,7 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Clear Telegram config",
     description: "Clear credentials and deregister webhook.",
     tags: ["integrations"],
+    responseBody: TelegramConfigResultSchema,
     handler: () => handleClearTelegramConfig(),
   },
   {
@@ -129,6 +133,7 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Register Telegram commands",
     description: "Register bot commands with the Telegram API.",
     tags: ["integrations"],
+    responseBody: TelegramConfigResultSchema,
     handler: handleSetTelegramCommands,
   },
   {
@@ -142,6 +147,7 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Setup Telegram",
     description: "Composite: set config + register commands.",
     tags: ["integrations"],
+    responseBody: TelegramConfigResultSchema,
     handler: handleSetupTelegram,
   },
 ];