@vellumai/assistant 0.7.3 → 0.8.1

package/src/runtime/routes/http-adapter.ts

@@ -35,6 +35,7 @@ export function routeDefinitionsToHTTPRoutes(
   return routes.map((r) => ({
     endpoint: r.endpoint,
     method: r.method,
+    operationId: r.operationId,
     policyKey:
       r.policyKey ?? r.endpoint.replace(/\/:[^/]+/g, "").replace(/^:/, ""),
     pathParams: r.pathParams,
@@ -47,6 +48,7 @@ export function routeDefinitionsToHTTPRoutes(
     responseStatus:
       typeof r.responseStatus === "string" ? r.responseStatus : undefined,
     additionalResponses: r.additionalResponses,
+    logging: r.logging,
     handler: async ({ req, url, params, authContext }) => {
       try {
         if (r.requireGuardian) {

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

@@ -449,6 +449,10 @@ export const ROUTES: RouteDefinition[] = [
       "Returns runtime health including version, disk, memory, CPU, and migration status.",
     tags: ["system"],
     responseBody: detailedHealthSchema,
+    // Clients (notably the macOS app) poll this every few seconds; the
+    // first handful of 200s confirm the route works and every line after
+    // is just noise. Non-2xx still logs.
+    logging: { silenceSuccessAfter: 5 },
   },
   {
     operationId: "healthz",
@@ -461,6 +465,7 @@ export const ROUTES: RouteDefinition[] = [
       "Alias for /v1/health. Returns runtime health including version, disk, memory, CPU, and migration status.",
     tags: ["system"],
     responseBody: detailedHealthSchema,
+    logging: { silenceSuccessAfter: 5 },
   },
   {
     operationId: "identity",

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

@@ -0,0 +1,99 @@
+import { getConfig } from "../../config/loader.js";
+import { resolveImageGenCredentials } from "../../media/image-credentials.js";
+import {
+  generateImage,
+  mapImageGenError,
+  providerForModel,
+} from "../../media/image-service.js";
+import { BadRequestError, InternalError, UnprocessableEntityError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+
+async function handleImageGenerationGenerate(
+  args: RouteHandlerArgs,
+): Promise<unknown> {
+  const { prompt, mode, sourceImages, model, variants } = args.body ?? {};
+
+  // Validate prompt
+  if (typeof prompt !== "string" || !prompt.trim()) {
+    throw new BadRequestError("prompt must be a non-empty string");
+  }
+
+  // Validate / default mode
+  const resolvedMode: "generate" | "edit" =
+    mode === "edit" ? "edit" : "generate";
+
+  // Validate edit mode requirements
+  if (
+    resolvedMode === "edit" &&
+    (!sourceImages ||
+      !Array.isArray(sourceImages) ||
+      (sourceImages as unknown[]).length === 0)
+  ) {
+    throw new BadRequestError("Edit mode requires at least one source image");
+  }
+
+  // Resolve config
+  const config = getConfig();
+  const svc = config.services["image-generation"];
+
+  // Derive provider from explicit model override when supplied
+  const provider = providerForModel(model, svc.provider);
+
+  // Resolve credentials
+  const { credentials, errorHint } = await resolveImageGenCredentials({
+    provider,
+    mode: svc.mode,
+  });
+
+  if (!credentials) {
+    throw new UnprocessableEntityError(
+      errorHint ?? "No credentials available for image generation",
+    );
+  }
+
+  // Clamp variants to 1-4
+  const clampedVariants = Math.max(1, Math.min(Number(variants) || 1, 4));
+
+  // Generate image
+  try {
+    const result = await generateImage(provider, credentials, {
+      prompt,
+      mode: resolvedMode,
+      sourceImages: sourceImages as
+        | Array<{ mimeType: string; dataBase64: string }>
+        | undefined,
+      model: (model as string | undefined) ?? svc.model,
+      variants: clampedVariants,
+    });
+
+    return {
+      images: result.images,
+      text: result.text,
+      resolvedModel: result.resolvedModel,
+    };
+  } catch (error) {
+    const errorMessage = mapImageGenError(provider, error);
+    throw new InternalError(errorMessage);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "image_generation_generate",
+    endpoint: "image-generation/generate",
+    method: "POST",
+    summary: "Generate or edit images using AI",
+    description:
+      "Calls the configured image-generation provider (Gemini or OpenAI) to produce one or more images.",
+    tags: ["image-generation"],
+    handler: handleImageGenerationGenerate,
+  },
+];

package/src/runtime/routes/inbound-stages/background-dispatch.test.ts

@@ -1,4 +1,9 @@
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const deliveredChannelReplies: Array<{
+  callbackUrl: string;
+  payload: Record<string, unknown>;
+}> = [];
 
 mock.module("../../../util/logger.js", () => ({
   getLogger: () =>
@@ -20,6 +25,19 @@ mock.module("../../../memory/delivery-status.js", () => ({
   recordProcessingFailure: () => {},
 }));
 
+mock.module("../../gateway-client.js", () => ({
+  deliverChannelReply: async (
+    callbackUrl: string,
+    payload: Record<string, unknown>,
+  ) => {
+    deliveredChannelReplies.push({ callbackUrl, payload });
+    return { ok: true };
+  },
+}));
+
+mock.module("../channel-delivery-routes.js", () => ({
+  deliverReplyViaCallback: async () => {},
+}));
 
 import type { TrustContext } from "../../../daemon/trust-context.js";
 import {
@@ -31,6 +49,7 @@ import type { MessageProcessor } from "../../http-types.js";
 import {
   isBoundGuardianActor,
   processChannelMessageInBackground,
+  shouldStartSlackThinkingStatusForText,
 } from "./background-dispatch.js";
 
 describe("isBoundGuardianActor", () => {
@@ -152,3 +171,120 @@ describe("processChannelMessageInBackground — slack thread mapping", () => {
     clearThreadTs(conversationId);
   });
 });
+
+describe("Slack thinking status timing", () => {
+  const trustCtx: TrustContext = {
+    trustClass: "guardian",
+    guardianExternalUserId: "guardian-1",
+    requesterExternalUserId: "guardian-1",
+  } as unknown as TrustContext;
+
+  const flush = (): Promise<void> =>
+    new Promise((resolve) => setTimeout(resolve, 10));
+
+  beforeEach(() => {
+    deliveredChannelReplies.length = 0;
+  });
+
+  test("recognizes only deliverable text as a Slack thinking-status trigger", () => {
+    expect(shouldStartSlackThinkingStatusForText("")).toBe(false);
+    expect(shouldStartSlackThinkingStatusForText("   ")).toBe(false);
+    expect(shouldStartSlackThinkingStatusForText("<")).toBe(false);
+    expect(shouldStartSlackThinkingStatusForText("<no_response")).toBe(false);
+    expect(shouldStartSlackThinkingStatusForText("<no_response/>")).toBe(false);
+    expect(shouldStartSlackThinkingStatusForText("  <no_response />  ")).toBe(
+      false,
+    );
+    expect(shouldStartSlackThinkingStatusForText("Real response.")).toBe(true);
+    expect(
+      shouldStartSlackThinkingStatusForText("<no_response/>\nReal response."),
+    ).toBe(true);
+  });
+
+  test("does not set Slack thinking status for no_response text deltas", async () => {
+    const conversationId = "conv-no-response-status";
+    const channelId = "C-NO-RESPONSE";
+    const threadTs = "1700000000.000003";
+
+    const processMessage: MessageProcessor = async (
+      _conversationId,
+      _content,
+      _attachmentIds,
+      options,
+    ) => {
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "<no_response/>",
+        conversationId,
+      });
+      return { messageId: "user-msg-no-response" };
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-no-response-status",
+      content: "ambient channel chatter",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${threadTs}`,
+    });
+
+    await flush();
+
+    expect(deliveredChannelReplies).toEqual([]);
+  });
+
+  test("sets and clears Slack thinking status after real assistant text starts", async () => {
+    const conversationId = "conv-real-response-status";
+    const channelId = "C-REAL-RESPONSE";
+    const threadTs = "1700000000.000004";
+
+    const processMessage: MessageProcessor = async (
+      _conversationId,
+      _content,
+      _attachmentIds,
+      options,
+    ) => {
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "<",
+        conversationId,
+      });
+      expect(deliveredChannelReplies).toEqual([]);
+
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "b>Working on it.",
+        conversationId,
+      });
+      return { messageId: "user-msg-real-response" };
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-real-response-status",
+      content: "please respond",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${threadTs}`,
+    });
+
+    await flush();
+
+    const statuses = deliveredChannelReplies.map((entry) => {
+      const status = entry.payload.assistantThreadStatus as
+        | { status?: string }
+        | undefined;
+      return status?.status;
+    });
+    expect(statuses).toEqual(["is thinking...", ""]);
+  });
+});

package/src/runtime/routes/inbound-stages/background-dispatch.ts

@@ -9,6 +9,7 @@
  */
 import type { ChannelId, InterfaceId } from "../../../channels/types.js";
 import { findGuardianForChannel } from "../../../contacts/contact-store.js";
+import type { ServerMessage } from "../../../daemon/message-protocol.js";
 import type { TrustContext } from "../../../daemon/trust-context.js";
 import { updateDeliveredSegmentCount } from "../../../memory/delivery-channels.js";
 import { linkMessage } from "../../../memory/delivery-crud.js";
@@ -135,13 +136,12 @@ export function processChannelMessageInBackground(
         )
       : undefined;
 
-    // Set Slack Assistants API "is thinking..." status indicator
-    const clearSlackThinkingStatus = shouldEmitSlackReaction(
+    const slackThinkingStatus = createSlackThinkingStatusController({
       sourceChannel,
       replyCallbackUrl,
-    )
-      ? setSlackThinkingStatus(replyCallbackUrl!, externalChatId, assistantId)
-      : undefined;
+      chatId: externalChatId,
+      assistantId,
+    });
     const stopApprovalWatcher = replyCallbackUrl
       ? startPendingApprovalPromptWatcher({
           conversationId,
@@ -226,6 +226,12 @@ export function processChannelMessageInBackground(
           ...(cmdIntent ? { commandIntent: cmdIntent } : {}),
           ...(slackRuntimeContextNotice ? { slackRuntimeContextNotice } : {}),
           ...(slackInbound ? { slackInbound } : {}),
+          ...(slackThinkingStatus
+            ? {
+                onEvent: (msg: ServerMessage) =>
+                  slackThinkingStatus.observeEvent(msg),
+              }
+            : {}),
         },
         sourceChannel,
         sourceInterface,
@@ -274,7 +280,7 @@ export function processChannelMessageInBackground(
       recordProcessingFailure(eventId, err);
     } finally {
       stopTypingHeartbeat?.();
-      clearSlackThinkingStatus?.();
+      slackThinkingStatus?.stop();
       stopApprovalWatcher?.();
       stopTcApprovalNotifier?.();
     }
@@ -341,7 +347,36 @@ function startTelegramTypingHeartbeat(
 // Slack Assistants API thinking status indicator
 // ---------------------------------------------------------------------------
 
-function shouldEmitSlackReaction(
+type SlackThinkingStatusController = {
+  observeEvent: (msg: ServerMessage) => void;
+  stop: () => void;
+};
+
+const NO_RESPONSE_RE = /^\s*<no_response\s*\/?>\s*$/i;
+const NO_RESPONSE_INLINE_RE = /<no_response\s*\/?>/gi;
+const NO_RESPONSE_SENTINEL_FORMS = [
+  "<no_response/>",
+  "<no_response />",
+  "<no_response>",
+] as const;
+
+function isPotentialNoResponsePrefix(text: string): boolean {
+  const lower = text.toLowerCase();
+  return NO_RESPONSE_SENTINEL_FORMS.some((sentinel) =>
+    sentinel.startsWith(lower),
+  );
+}
+
+export function shouldStartSlackThinkingStatusForText(text: string): boolean {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return false;
+  if (NO_RESPONSE_RE.test(trimmed)) return false;
+  if (isPotentialNoResponsePrefix(trimmed)) return false;
+
+  return trimmed.replace(NO_RESPONSE_INLINE_RE, "").trim().length > 0;
+}
+
+function shouldEmitSlackThinkingStatus(
   sourceChannel: ChannelId,
   replyCallbackUrl?: string,
 ): boolean {
@@ -353,6 +388,51 @@ function shouldEmitSlackReaction(
   }
 }
 
+function createSlackThinkingStatusController(params: {
+  sourceChannel: ChannelId;
+  replyCallbackUrl?: string;
+  chatId: string;
+  assistantId?: string;
+}): SlackThinkingStatusController | undefined {
+  const { sourceChannel, replyCallbackUrl, chatId, assistantId } = params;
+  if (
+    !replyCallbackUrl ||
+    !shouldEmitSlackThinkingStatus(sourceChannel, replyCallbackUrl)
+  ) {
+    return undefined;
+  }
+  const callbackUrl = replyCallbackUrl;
+
+  let stopped = false;
+  let clearSlackThinkingStatus: (() => void) | undefined;
+  let observedAssistantText = "";
+
+  const start = (): void => {
+    if (stopped || clearSlackThinkingStatus) return;
+    clearSlackThinkingStatus = setSlackThinkingStatus(
+      callbackUrl,
+      chatId,
+      assistantId,
+    );
+  };
+
+  return {
+    observeEvent(msg) {
+      if (stopped || clearSlackThinkingStatus) return;
+      if (msg.type !== "assistant_text_delta") return;
+
+      observedAssistantText += msg.text;
+      if (shouldStartSlackThinkingStatusForText(observedAssistantText)) {
+        start();
+      }
+    },
+    stop() {
+      stopped = true;
+      clearSlackThinkingStatus?.();
+    },
+  };
+}
+
 const SLACK_THINKING_MAX_DURATION_MS = 120_000;
 
 /**

package/src/runtime/routes/inbound-stages/guardian-reply-intercept.test.ts

@@ -0,0 +1,156 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+let mockDeliveryScopedRequests: { id: string }[] = [];
+let mockIdentityRequests: { id: string }[] = [];
+let routeGuardianReplyCalls: unknown[] = [];
+let deliverChannelReplyCalls: unknown[][] = [];
+
+mock.module("../../../memory/canonical-guardian-store.js", () => ({
+  listPendingCanonicalGuardianRequestsByDestinationChat: () =>
+    mockDeliveryScopedRequests,
+  listCanonicalGuardianRequests: () => mockIdentityRequests,
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+mock.module("../../gateway-client.js", () => ({
+  deliverChannelReply: (url: unknown, payload: unknown, token: unknown) => {
+    deliverChannelReplyCalls.push([url, payload, token]);
+    return Promise.resolve({ ok: true });
+  },
+}));
+
+mock.module("../../guardian-reply-router.js", () => ({
+  routeGuardianReply: (ctx: unknown) => {
+    routeGuardianReplyCalls.push(ctx);
+    return Promise.resolve({
+      consumed: false,
+      decisionApplied: false,
+      type: "not_consumed",
+    });
+  },
+}));
+
+// Import after mocks are installed
+const { handleGuardianReplyIntercept } =
+  await import("./guardian-reply-intercept.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeParams(
+  overrides: Partial<Parameters<typeof handleGuardianReplyIntercept>[0]> = {},
+) {
+  return {
+    isDuplicate: false,
+    trimmedContent: "hello",
+    hasCallbackData: false,
+    callbackData: undefined,
+    rawSenderId: "user-42",
+    canonicalSenderId: "user-42",
+    canonicalAssistantId: "self",
+    sourceChannel: "slack" as const,
+    conversationExternalId: "chat-123",
+    conversationId: "conv-abc",
+    eventId: "evt-1",
+    replyCallbackUrl: "https://gateway/reply",
+    trustClass: "guardian",
+    guardianPrincipalId: "principal-1",
+    approvalConversationGenerator: undefined,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("handleGuardianReplyIntercept", () => {
+  beforeEach(() => {
+    mockDeliveryScopedRequests = [];
+    mockIdentityRequests = [];
+    routeGuardianReplyCalls = [];
+    deliverChannelReplyCalls = [];
+  });
+
+  test("passes empty pendingRequestIds when Slack guardian sends message in non-delivery chat", async () => {
+    // No delivery-scoped requests for this chat
+    mockDeliveryScopedRequests = [];
+    // Identity-based lookup would find a pending request in a different chat
+    mockIdentityRequests = [{ id: "identity-req" }];
+
+    await handleGuardianReplyIntercept(makeParams({ sourceChannel: "slack" }));
+
+    expect(routeGuardianReplyCalls).toHaveLength(1);
+    const ctx = routeGuardianReplyCalls[0] as Record<string, unknown>;
+    // Must be [] (empty array), NOT undefined — blocks identity fallback
+    expect(ctx.pendingRequestIds).toEqual([]);
+  });
+
+  test("preserves identity fallback for non-Slack channels when no deliveries exist", async () => {
+    // No delivery-scoped requests for this chat
+    mockDeliveryScopedRequests = [];
+    mockIdentityRequests = [{ id: "identity-req" }];
+
+    await handleGuardianReplyIntercept(
+      makeParams({ sourceChannel: "telegram" }),
+    );
+
+    expect(routeGuardianReplyCalls).toHaveLength(1);
+    const ctx = routeGuardianReplyCalls[0] as Record<string, unknown>;
+    // Must be undefined — identity-based fallback stays active
+    expect(ctx.pendingRequestIds).toBeUndefined();
+  });
+
+  test("includes identity-unioned pendingRequestIds when Slack guardian is in delivery chat", async () => {
+    mockDeliveryScopedRequests = [{ id: "delivered-req" }];
+    mockIdentityRequests = [
+      { id: "delivered-req" },
+      { id: "identity-only-req" },
+    ];
+
+    await handleGuardianReplyIntercept(makeParams({ sourceChannel: "slack" }));
+
+    expect(routeGuardianReplyCalls).toHaveLength(1);
+    const ctx = routeGuardianReplyCalls[0] as Record<string, unknown>;
+    const ids = ctx.pendingRequestIds as string[];
+    expect(ids).toContain("delivered-req");
+    expect(ids).toContain("identity-only-req");
+  });
+
+  test("skips intercept for non-guardian trust class", async () => {
+    const result = await handleGuardianReplyIntercept(
+      makeParams({ trustClass: "unknown" }),
+    );
+
+    expect(routeGuardianReplyCalls).toHaveLength(0);
+    expect(result).toEqual({
+      response: null,
+      skipApprovalInterception: false,
+    });
+  });
+
+  test("skips intercept when replyCallbackUrl is missing", async () => {
+    const result = await handleGuardianReplyIntercept(
+      makeParams({ replyCallbackUrl: undefined }),
+    );
+
+    expect(routeGuardianReplyCalls).toHaveLength(0);
+    expect(result).toEqual({
+      response: null,
+      skipApprovalInterception: false,
+    });
+  });
+});

package/src/runtime/routes/inbound-stages/guardian-reply-intercept.ts

@@ -101,8 +101,22 @@ export async function handleGuardianReplyIntercept(
   // When delivery-scoped matches exist, union them with any identity-
   // based pending requests so that requests without delivery rows (e.g.
   // tool_approval requests created inline) are not silently excluded.
-  // Pass undefined (not []) when there are zero combined results so the
-  // router's own identity-based fallback stays active.
+  //
+  // On Slack, when no delivery-scoped results exist for the current
+  // chat, pass [] (empty array) instead of undefined. This prevents the
+  // router's identity-based fallback from intercepting unrelated
+  // messages in other channels/threads — a cross-chat hijacking vector
+  // unique to Slack where a single guardian is active in many threaded
+  // contexts. Explicit callbacks (apr:<id>:<action>) and request codes
+  // still work cross-chat because they carry specific request
+  // identifiers and bypass the pendingRequests list.
+  //
+  // Non-Slack channels (Telegram, WhatsApp) keep undefined so the
+  // identity-based fallback stays active. On those channels, delivery
+  // rows are created asynchronously (fire-and-forget .then()) so the
+  // guardian can reply before the row is persisted. Cross-chat
+  // contamination is unlikely there because each chat is a distinct
+  // conversation with no thread concept.
   const deliveryScopedPendingRequests =
     listPendingCanonicalGuardianRequestsByDestinationChat(
       sourceChannel,
@@ -121,6 +135,10 @@ export async function handleGuardianReplyIntercept(
       deliveryIds.add(r.id);
     }
     pendingRequestIds = [...deliveryIds];
+  } else if (sourceChannel === "slack") {
+    // Block identity-based fallback on Slack to prevent cross-chat
+    // NL/free-text interception. See comment above for rationale.
+    pendingRequestIds = [];
   }
 
   const routerResult = await routeGuardianReply({
@@ -168,16 +186,13 @@ export async function handleGuardianReplyIntercept(
     }
 
     return {
-      response: ({
+      response: {
         accepted: true,
         duplicate: false,
         eventId,
         canonicalRouter: routerResult.type,
         requestId: routerResult.requestId,
-        ...(routerResult.activatedContact
-          ? { activatedContact: routerResult.activatedContact }
-          : {}),
-      }),
+      },
       skipApprovalInterception: false,
     };
   }