@vellumai/assistant 0.6.4 → 0.6.5

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

@@ -1,6 +1,36 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 
-import { isBoundGuardianActor } from "./background-dispatch.js";
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../../memory/delivery-channels.js", () => ({
+  updateDeliveredSegmentCount: () => {},
+}));
+
+mock.module("../../../memory/delivery-crud.js", () => ({
+  linkMessage: () => {},
+}));
+
+mock.module("../../../memory/delivery-status.js", () => ({
+  markProcessed: () => {},
+  recordProcessingFailure: () => {},
+}));
+
+import type { TrustContext } from "../../../daemon/conversation-runtime-assembly.js";
+import {
+  clearThreadTs,
+  getThreadTs,
+  setThreadTs,
+} from "../../../memory/slack-thread-store.js";
+import type { MessageProcessor } from "../../http-types.js";
+import {
+  isBoundGuardianActor,
+  processChannelMessageInBackground,
+} from "./background-dispatch.js";
 
 describe("isBoundGuardianActor", () => {
   test("returns true only when requester matches bound guardian", () => {
@@ -42,3 +72,84 @@ describe("isBoundGuardianActor", () => {
     ).toBe(false);
   });
 });
+
+describe("processChannelMessageInBackground — slack thread mapping", () => {
+  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));
+
+  test("restores prior thread mapping when processMessage is rejected as already-processing", async () => {
+    const conversationId = "conv-restore-on-busy";
+    const channelId = "C-RESTORE";
+    const inFlightThreadTs = "1700000000.000001";
+
+    // Simulate a prior threaded turn that installed the mapping and is
+    // still in flight when a new channel-root event arrives.
+    setThreadTs(conversationId, channelId, inFlightThreadTs);
+
+    const processMessage: MessageProcessor = async () => {
+      throw new Error("Conversation is already processing a message");
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-1",
+      content: "root-level message",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      // Callback URL has no threadTs query param → channel-root event
+      // that would otherwise call `clearThreadTs`.
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}`,
+      mintBearerToken: () => "test-token",
+    });
+
+    await flush();
+
+    // The in-flight threaded turn's mapping must survive the busy rejection.
+    expect(getThreadTs(conversationId)).toBe(inFlightThreadTs);
+
+    clearThreadTs(conversationId);
+  });
+
+  test("retains updated mapping when processMessage succeeds", async () => {
+    const conversationId = "conv-retain-on-success";
+    const channelId = "C-SUCCESS";
+    const newThreadTs = "1700000000.000002";
+
+    // No prior mapping; this turn arrives in a thread and should install one.
+    clearThreadTs(conversationId);
+
+    const processMessage: MessageProcessor = async () => ({
+      messageId: "user-msg-1",
+    });
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-2",
+      content: "thread reply",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${newThreadTs}`,
+      mintBearerToken: () => "test-token",
+    });
+
+    await flush();
+
+    expect(getThreadTs(conversationId)).toBe(newThreadTs);
+
+    clearThreadTs(conversationId);
+  });
+});

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

@@ -14,9 +14,11 @@ import * as deliveryChannels from "../../../memory/delivery-channels.js";
 import * as deliveryCrud from "../../../memory/delivery-crud.js";
 import * as deliveryStatus from "../../../memory/delivery-status.js";
 import {
+  clearThreadTs,
   extractChannelFromCallbackUrl,
   extractMessageTsFromCallbackUrl,
   extractThreadTsFromCallbackUrl,
+  peekThreadMapping,
   setThreadTs,
 } from "../../../memory/slack-thread-store.js";
 import { resolveGuardianName } from "../../../prompts/user-reference.js";
@@ -31,6 +33,7 @@ import { deliverChannelReply } from "../../gateway-client.js";
 import type {
   ApprovalCopyGenerator,
   MessageProcessor,
+  SlackInboundMessageMetadata,
 } from "../../http-types.js";
 import { resolveRoutingState } from "../../trust-context-resolver.js";
 import { deliverReplyViaCallback } from "../channel-delivery-routes.js";
@@ -78,6 +81,12 @@ export interface BackgroundProcessingParams {
   sourceLanguageCode?: string;
   /** Chat type from the gateway (e.g. "private", "group", "supergroup"). */
   chatType?: string;
+  /**
+   * Slack-specific inbound metadata extracted at the HTTP boundary. Threaded
+   * through to `persistUserMessage` so the row can be tagged with a
+   * `slackMeta` envelope for the chronological renderer.
+   */
+  slackInbound?: SlackInboundMessageMetadata;
 }
 
 /**
@@ -106,6 +115,7 @@ export function processChannelMessageInBackground(
     commandIntent,
     sourceLanguageCode,
     chatType,
+    slackInbound,
   } = params;
 
   (async () => {
@@ -163,12 +173,32 @@ export function processChannelMessageInBackground(
         })
       : undefined;
 
-    // Track Slack thread mapping so replies go to the correct thread
+    // Align the Slack thread mapping with this turn's inbound state:
+    // set it when the inbound arrived in a thread, clear it when the
+    // inbound arrived at the channel root. `getThreadTs` is consulted
+    // at outbound-persistence time, so the mapping must reflect the
+    // current turn — a lingering mapping from a prior thread turn
+    // would otherwise be stamped onto a channel-root reply.
+    //
+    // The update must happen BEFORE `processMessage` runs because outbound
+    // persistence (inside the agent loop) reads the mapping. But if a prior
+    // threaded turn is still in flight, our `processMessage` call will be
+    // rejected as already-processing and our update would erase that
+    // in-flight turn's mapping. Snapshot the prior state here and restore
+    // it in the `already processing` rejection path below.
+    let priorSlackMapping: { threadTs: string; channelId: string } | null =
+      null;
+    let slackMappingMutated = false;
     if (sourceChannel === "slack" && replyCallbackUrl) {
+      priorSlackMapping = peekThreadMapping(conversationId);
       const inboundThreadTs = extractThreadTsFromCallbackUrl(replyCallbackUrl);
       const inboundChannel = extractChannelFromCallbackUrl(replyCallbackUrl);
       if (inboundThreadTs && inboundChannel) {
         setThreadTs(conversationId, inboundChannel, inboundThreadTs);
+        slackMappingMutated = true;
+      } else {
+        clearThreadTs(conversationId);
+        slackMappingMutated = true;
       }
     }
 
@@ -200,6 +230,7 @@ export function processChannelMessageInBackground(
           trustContext: trustCtx,
           isInteractive: resolveRoutingState(trustCtx).promptWaitingAllowed,
           ...(cmdIntent ? { commandIntent: cmdIntent } : {}),
+          ...(slackInbound ? { slackInbound } : {}),
         },
         sourceChannel,
         sourceInterface,
@@ -221,6 +252,27 @@ export function processChannelMessageInBackground(
         );
       }
     } catch (err) {
+      // When another turn is already processing this conversation,
+      // `prepareConversationForMessage` throws before any of this turn's
+      // work runs. Our pre-await mapping update would otherwise stomp the
+      // in-flight turn's mapping, causing its outbound persistence to
+      // record `slackMeta` with the wrong (or missing) `threadTs`. Restore
+      // the snapshot so the in-flight turn sees the mapping it installed.
+      if (
+        slackMappingMutated &&
+        err instanceof Error &&
+        err.message.includes("already processing a message")
+      ) {
+        if (priorSlackMapping) {
+          setThreadTs(
+            conversationId,
+            priorSlackMapping.channelId,
+            priorSlackMapping.threadTs,
+          );
+        } else {
+          clearThreadTs(conversationId);
+        }
+      }
       log.error(
         { err, conversationId },
         "Background channel message processing failed",
@@ -343,7 +395,10 @@ export function setSlackThinkingStatus(
       },
       mintBearerToken(),
     ).catch((err) => {
-      log.debug({ err, chatId, messageTs }, "Failed to add Slack eyes reaction");
+      log.debug(
+        { err, chatId, messageTs },
+        "Failed to add Slack eyes reaction",
+      );
     });
 
     const clearReaction = () => {
@@ -368,7 +423,10 @@ export function setSlackThinkingStatus(
       );
     };
 
-    const safetyTimer = setTimeout(clearReaction, SLACK_THINKING_MAX_DURATION_MS);
+    const safetyTimer = setTimeout(
+      clearReaction,
+      SLACK_THINKING_MAX_DURATION_MS,
+    );
     (safetyTimer as { unref?: () => void }).unref?.();
 
     return clearReaction;

package/src/runtime/routes/inbound-stages/edit-intercept.ts

@@ -7,13 +7,26 @@
  * webhook arrives before the original message has been linked via
  * linkMessage (the original agent loop may still be in progress).
  *
+ * For Slack edits, the stage additionally stamps `slackMeta.editedAt` into
+ * the message's metadata via a single transactional content+metadata update,
+ * so downstream renderers can surface the edited marker.
+ *
  * Extracted from inbound-message-handler.ts to keep the top-level handler
  * focused on orchestration.
  */
 import type { ChannelId } from "../../../channels/types.js";
 import { touchContactInteraction } from "../../../contacts/contacts-write.js";
-import { updateMessageContent } from "../../../memory/conversation-crud.js";
+import {
+  getMessageById,
+  updateMessageContent,
+  updateMessageContentAndMetadata,
+} from "../../../memory/conversation-crud.js";
 import * as deliveryCrud from "../../../memory/delivery-crud.js";
+import {
+  mergeSlackMetadata,
+  readSlackMetadata,
+} from "../../../messaging/providers/slack/message-metadata.js";
+import { safeParseRecord } from "../../../util/json.js";
 import { getLogger } from "../../../util/logger.js";
 
 const log = getLogger("runtime-http");
@@ -106,16 +119,70 @@ export async function handleEditIntercept(
   }
 
   if (original) {
-    updateMessageContent(original.messageId, content ?? "");
+    const newContent = content ?? "";
+    // Short-circuit no-op edits: Slack fires `message_changed` for link
+    // unfurls and other decorations where the text is identical to the
+    // previous revision. Skipping the DB write here covers that case and
+    // also drops trivially-redundant edit webhooks. We only have the
+    // authoritative previous text once the original row is located, so
+    // this check lives after the lookup.
+    const existingRow = getMessageById(original.messageId);
+    if (existingRow && existingRow.content === newContent) {
+      log.debug(
+        {
+          assistantId,
+          sourceChannel,
+          sourceMessageId,
+          messageId: original.messageId,
+        },
+        "Edit text unchanged; skipping update",
+      );
+      return Response.json({
+        accepted: true,
+        duplicate: false,
+        noop: true,
+        eventId: editResult.eventId,
+      });
+    }
+    if (sourceChannel === "slack") {
+      // Slack edits stamp `slackMeta.editedAt` so the chronological
+      // transcript renderer can surface the edited marker. The merge
+      // tolerates rows that lack slackMeta enrichment by synthesizing
+      // the minimum-required fields from the lookup data.
+      applySlackEditMetadata({
+        messageId: original.messageId,
+        conversationExternalId,
+        sourceMessageId,
+        newContent,
+      });
+    } else {
+      updateMessageContent(original.messageId, newContent);
+    }
     log.info(
       { assistantId, sourceMessageId, messageId: original.messageId },
       "Updated message content from edited_message",
     );
   } else {
-    log.warn(
-      { assistantId, sourceChannel, conversationExternalId, sourceMessageId },
-      "Could not find original message for edit after retries, ignoring",
-    );
+    // For Slack, treat missing-target edits as `debug` (the row may have
+    // been compacted, never stored, or pre-date this upgrade); for other
+    // channels, retain the louder `warn` since their edit pipelines
+    // historically expect the row to exist.
+    if (sourceChannel === "slack") {
+      log.debug(
+        {
+          assistantId,
+          sourceChannel,
+          channelId: conversationExternalId,
+          externalMessageId: sourceMessageId,
+        },
+        "Slack edit target not found, ignoring",
+      );
+    } else {
+      log.warn(
+        { assistantId, sourceChannel, conversationExternalId, sourceMessageId },
+        "Could not find original message for edit after retries, ignoring",
+      );
+    }
   }
 
   return Response.json({
@@ -124,3 +191,59 @@ export async function handleEditIntercept(
     eventId: editResult.eventId,
   });
 }
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Apply a Slack edit to the stored message: update content and stamp
+ * `slackMeta.editedAt` in the same transaction.
+ *
+ * If the row already has a valid `slackMeta` sub-object, the merge preserves
+ * all existing fields and only sets/refreshes `editedAt`. If the row lacks
+ * `slackMeta` enrichment, the helper synthesizes the minimum-required fields
+ * (`source`, `channelId`, `channelTs`, `eventKind`) from the values that
+ * brought us here so the resulting metadata is still readable by
+ * `readSlackMetadata`.
+ */
+function applySlackEditMetadata(params: {
+  messageId: string;
+  conversationExternalId: string;
+  sourceMessageId: string;
+  newContent: string;
+}): void {
+  const { messageId, conversationExternalId, sourceMessageId, newContent } =
+    params;
+
+  const row = getMessageById(messageId);
+  const outerMetadata: Record<string, unknown> =
+    row?.metadata != null ? safeParseRecord(row.metadata) : {};
+  const existingSlackMeta =
+    typeof outerMetadata.slackMeta === "string"
+      ? outerMetadata.slackMeta
+      : undefined;
+
+  const editedAt = Date.now();
+  const parsedExisting = readSlackMetadata(existingSlackMeta ?? null);
+
+  // When the row has no valid existing slackMeta, `mergeSlackMetadata`
+  // would produce a record missing the required fields and fail subsequent
+  // `readSlackMetadata` calls. Seed defaults from the lookup-derived facts
+  // so the post-merge value is always a valid `SlackMessageMetadata`.
+  const mergedSlackMeta = mergeSlackMetadata(existingSlackMeta ?? null, {
+    ...(parsedExisting
+      ? {}
+      : {
+          source: "slack" as const,
+          channelId: conversationExternalId,
+          channelTs: sourceMessageId,
+          eventKind: "message" as const,
+        }),
+    editedAt,
+  });
+
+  updateMessageContentAndMetadata(messageId, newContent, {
+    slackMeta: mergedSlackMeta,
+  });
+}

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

@@ -1,9 +1,10 @@
 /**
  * Route handlers for Slack channel configuration.
  *
- * GET    /v1/integrations/slack/channel/config — get current config status
- * POST   /v1/integrations/slack/channel/config — validate and store credentials
- * DELETE /v1/integrations/slack/channel/config — clear credentials
+ * GET    /v1/integrations/slack/channel/config        — get current config status
+ * POST   /v1/integrations/slack/channel/config        — validate and store credentials
+ * DELETE /v1/integrations/slack/channel/config        — clear credentials
+ * POST   /v1/integrations/slack/channel/oauth-install — run OAuth loopback to capture bot+user tokens
  */
 
 import {
@@ -11,6 +12,7 @@ import {
   getSlackChannelConfig,
   setSlackChannelConfig,
 } from "../../../../daemon/handlers/config-slack-channel.js";
+import { runSlackChannelOAuthInstall } from "../../../../daemon/handlers/slack-channel-oauth-install.js";
 import type { RouteDefinition } from "../../../http-router.js";
 
 // ---------------------------------------------------------------------------
@@ -55,6 +57,21 @@ export async function handleClearSlackChannelConfig(): Promise<Response> {
   return Response.json(result);
 }
 
+/**
+ * POST /v1/integrations/slack/channel/oauth-install
+ *
+ * Runs an OAuth2 loopback flow to install the Slack app and capture
+ * bot + user tokens. Requires client_id, client_secret, and app_token
+ * to be pre-stored in the credential vault.
+ *
+ * Blocks until the user completes the OAuth flow or the 5-minute timeout.
+ */
+export async function handleSlackChannelOAuthInstall(): Promise<Response> {
+  const result = await runSlackChannelOAuthInstall();
+  const status = result.success ? 200 : 400;
+  return Response.json(result, { status });
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -76,5 +93,10 @@ export function slackChannelRouteDefinitions(): RouteDefinition[] {
       method: "DELETE",
       handler: () => handleClearSlackChannelConfig(),
     },
+    {
+      endpoint: "integrations/slack/channel/oauth-install",
+      method: "POST",
+      handler: () => handleSlackChannelOAuthInstall(),
+    },
   ];
 }

package/src/runtime/routes/llm-context-normalization.ts

@@ -400,7 +400,8 @@ function normalizeOpenAiResponsesResponsePayload(
     output.some(
       (item) =>
         asString(item.type) === "message" ||
-        asString(item.type) === "function_call",
+        asString(item.type) === "function_call" ||
+        asString(item.type) === "web_search_call",
     );
   if (!hasResponsesSignal) {
     return null;
@@ -444,6 +445,23 @@ function normalizeOpenAiResponsesResponsePayload(
       };
       toolCallSections.push(section);
       responseSections.push(section);
+      continue;
+    }
+
+    if (itemType === "web_search_call") {
+      toolCallIndex++;
+      const status = asString(item.status);
+      const section: LlmContextSection = {
+        kind: "tool_use",
+        label: `Response tool call ${toolCallIndex}`,
+        role: "assistant",
+        toolName: "web_search",
+        data: omitRecordKeys(item, ["type"]) ?? undefined,
+        text: status ? `[Web search: ${status}]` : "[Web search]",
+      };
+      toolCallSections.push(section);
+      responseSections.push(section);
+      continue;
     }
   }
 
@@ -1037,6 +1055,10 @@ function extractOpenAiResponsesRequestToolNames(tools: unknown): string[] {
       if (asString(tool.type) === "function" && asString(tool.name)) {
         return asString(tool.name);
       }
+      // Native web search tool: { type: "web_search_preview" }
+      if (asString(tool.type) === "web_search_preview") {
+        return "web_search";
+      }
       return undefined;
     })
     .filter((name): name is string => typeof name === "string");