@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

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

@@ -3,38 +3,33 @@
  *
  * Greetings are sourced from (in priority order):
  * 1. A `## Greetings` section in SOUL.md (user-defined bullet list)
- * 2. A cached greetings array (populated by the BTW side-chain LLM call)
- * 3. Fallback: the assistant name from IDENTITY.md
+ * 2. A cached greetings array (populated by the empty-state greeting callsite)
+ * 3. A generic fallback when generation is unavailable
  *
- * Cache uses TTL + content-hash invalidation: when IDENTITY.md, SOUL.md, or
- * the guardian persona change, the cache is busted.
+ * Cache invalidation is intentionally TTL-only. User-authored SOUL.md
+ * greetings are read before cache, so manual overrides still take priority
+ * without coupling cache validity to prompt-file edits.
  *
  * Storage uses the existing `memory_checkpoints` table (simple key-value store).
  */
 
-import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 
 import {
   getMemoryCheckpoint,
   setMemoryCheckpoint,
 } from "../../memory/checkpoints.js";
-import { resolveGuardianPersona } from "../../prompts/persona-resolver.js";
 import { getWorkspacePromptPath } from "../../util/platform.js";
 
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 
-const CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
+const CACHE_TTL_MS = 2 * 24 * 60 * 60 * 1000; // 2 days
 
 const CHECKPOINT_KEY_GREETINGS = "identity:intro:greetings";
-const CHECKPOINT_KEY_HASH = "identity:intro:content_hash";
 const CHECKPOINT_KEY_TIMESTAMP = "identity:intro:cached_at";
 
-/** Workspace files whose content influences the identity intro. */
-const IDENTITY_FILES = ["IDENTITY.md", "SOUL.md"] as const;
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -125,14 +120,6 @@ export function readWorkspaceGreetings(): string[] | null {
   return parseGreetingsSection(soulContent);
 }
 
-/** Compute a SHA-256 hex hash of the concatenated identity file contents. */
-export function computeIdentityContentHash(): string {
-  const staticFiles = IDENTITY_FILES.map(readWorkspaceFile).join("\n---\n");
-  const guardianPersona = resolveGuardianPersona() ?? "";
-  const combined = staticFiles + "\n---\n" + guardianPersona;
-  return createHash("sha256").update(combined).digest("hex");
-}
-
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -142,27 +129,22 @@ export interface CachedIntro {
 }
 
 /**
- * Retrieve the cached greetings array if it exists, is within the TTL window,
- * and the identity files have not changed since it was generated.
+ * Retrieve the cached greetings array if it exists and is within the TTL
+ * window.
  *
- * Returns `null` when the cache is missing, expired, or invalidated.
+ * Returns `null` when the cache is missing or expired.
  */
 export function getCachedIntro(): CachedIntro | null {
   try {
     const raw = getMemoryCheckpoint(CHECKPOINT_KEY_GREETINGS);
-    const hash = getMemoryCheckpoint(CHECKPOINT_KEY_HASH);
     const timestampStr = getMemoryCheckpoint(CHECKPOINT_KEY_TIMESTAMP);
 
-    if (!raw || !hash || !timestampStr) return null;
+    if (!raw || !timestampStr) return null;
 
     // TTL check
     const cachedAt = Number(timestampStr);
     if (isNaN(cachedAt) || Date.now() - cachedAt > CACHE_TTL_MS) return null;
 
-    // Content-hash check — bust cache when identity files change
-    const currentHash = computeIdentityContentHash();
-    if (currentHash !== hash) return null;
-
     // Parse stored value — handles both JSON array and legacy single string
     let greetings: string[];
     try {
@@ -178,16 +160,11 @@ export function getCachedIntro(): CachedIntro | null {
   }
 }
 
-/**
- * Store a greetings array in the cache along with the current content hash
- * and timestamp.
- */
+/** Store a greetings array in the cache along with the current timestamp. */
 export function setCachedIntro(greetings: string[]): void {
   try {
-    const hash = computeIdentityContentHash();
     const now = String(Date.now());
     setMemoryCheckpoint(CHECKPOINT_KEY_GREETINGS, JSON.stringify(greetings));
-    setMemoryCheckpoint(CHECKPOINT_KEY_HASH, hash);
     setMemoryCheckpoint(CHECKPOINT_KEY_TIMESTAMP, now);
   } catch {
     // Cache write failure is non-fatal — next request will regenerate.

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,13 @@ 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 } from "./types.js";
 
@@ -402,31 +410,204 @@ 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
+  // 2. Cached LLM-generated greetings (populated by background refresh)
   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. 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();
+    return identityIntroResponse(
+      [identityIntro, ...FALLBACK_GREETINGS],
+      "workspace",
+      refreshing,
+    );
+  }
+
+  // 4. Trigger fresh generation without blocking the empty-state UI.
+  const refreshing = triggerEmptyStateGreetingGeneration();
+
+  // 5. 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();
 
-  return { greetings: FALLBACK_GREETINGS, text: FALLBACK_GREETINGS[0] };
+  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;
 }
 
 // ---------------------------------------------------------------------------
@@ -464,14 +645,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 +748,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/inbound-message-handler.ts

@@ -20,7 +20,7 @@ import {
   createApprovalConversationGenerator,
   createApprovalCopyGenerator,
 } from "../../daemon/approval-generators.js";
-import { findConversation } from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import {
   canonicalizeTimeZone,
   resolveTurnTimezoneContext,

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(),
   },
 ];