@vellumai/assistant 0.8.5 → 0.8.6

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

@@ -8,10 +8,11 @@ import { z } from "zod";
 import { getDb } from "../../memory/db-connection.js";
 import { notificationDeliveries } from "../../memory/schema.js";
 import { bufferIfDeferred } from "../../notifications/deferred-emit.js";
+import { editNotification } from "../../notifications/edit-notification.js";
 import { emitNotificationSignal } from "../../notifications/emit-signal.js";
 import { listEvents } from "../../notifications/events-store.js";
 import type { AttentionHints } from "../../notifications/signal.js";
-import { BadRequestError } from "./errors.js";
+import { BadRequestError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 function handleNotificationIntentResult({ body = {} }: RouteHandlerArgs) {
@@ -89,6 +90,26 @@ const ListNotificationEventsParams = z.object({
   sourceEventName: z.string().optional(),
 });
 
+const EditNotificationParams = z
+  .object({
+    id: z.string().min(1).describe("Feed item id (notif:<uuid>) or bare uuid"),
+    title: z.string().optional(),
+    body: z.string().optional(),
+    urgency: z.enum(["low", "medium", "high", "critical"]).optional(),
+    status: z.enum(["new", "seen", "acted_on", "dismissed"]).optional(),
+  })
+  .refine(
+    (v) =>
+      v.title !== undefined ||
+      v.body !== undefined ||
+      v.urgency !== undefined ||
+      v.status !== undefined,
+    {
+      message:
+        "At least one of `title`, `body`, `urgency`, or `status` must be supplied",
+    },
+  );
+
 // ── Notification pipeline handlers ───────────────────────────────────
 
 async function handleEmitSignal({ body = {} }: RouteHandlerArgs) {
@@ -125,6 +146,19 @@ async function handleEmitSignal({ body = {} }: RouteHandlerArgs) {
   };
 }
 
+async function handleEditNotification({ body = {} }: RouteHandlerArgs) {
+  const validated = EditNotificationParams.parse(body);
+  const result = await editNotification(validated);
+  if (!result) {
+    throw new NotFoundError(`No notification found for id ${validated.id}`);
+  }
+  return {
+    ok: true,
+    feedItem: result.feedItem,
+    channels: result.channels,
+  };
+}
+
 function handleListEvents({ body = {} }: RouteHandlerArgs) {
   const validated = ListNotificationEventsParams.parse(body);
   const rows = listEvents({
@@ -175,6 +209,34 @@ export const ROUTES: RouteDefinition[] = [
       reason: z.string(),
     }),
   },
+  {
+    operationId: "edit_notification",
+    endpoint: "notifications/edit",
+    method: "POST",
+    handler: handleEditNotification,
+    summary: "Edit an already-sent notification",
+    description:
+      "Patch the home-feed entry for a notification and, where supported (Slack today), update the delivered message in place.",
+    tags: ["notifications"],
+    requestBody: EditNotificationParams,
+    responseBody: z.object({
+      ok: z.boolean(),
+      feedItem: z.record(z.string(), z.unknown()),
+      channels: z.array(
+        z.object({
+          channel: z.string(),
+          deliveryId: z.string(),
+          outcome: z.enum(["updated", "unsupported", "skipped", "failed"]),
+          reason: z.string().optional(),
+        }),
+      ),
+    }),
+    additionalResponses: {
+      "404": {
+        description: "No notification found for the supplied id",
+      },
+    },
+  },
   {
     operationId: "list_notification_events",
     endpoint: "notifications/events",

package/src/runtime/routes/oauth-commands-routes.ts

@@ -23,6 +23,7 @@ import {
   resolveOAuthConnection,
   type ResolveOAuthConnectionOptions,
 } from "../../oauth/connection-resolver.js";
+import { syncManualTokenConnection } from "../../oauth/manual-token-connection.js";
 import {
   disconnectOAuthProvider,
   getActiveConnection,
@@ -516,6 +517,10 @@ async function handleStatus({ queryParams = {} }: RouteHandlerArgs) {
   }
 
   // BYO path
+  if (providerRow.authorizeUrl === "urn:manual-token") {
+    await syncManualTokenConnection(provider);
+  }
+
   const allConnections = listConnections(provider);
   const activeRows = allConnections.filter((r) => r.status === "active");
 
@@ -914,7 +919,7 @@ async function handleManagedConnect({ body = {} }: RouteHandlerArgs) {
     reqBody.requested_scopes = b.scopes;
   }
   reqBody.redirect_after_connect =
-    b.redirect_after_connect ?? "/account/oauth/desktop-complete";
+    b.redirect_after_connect ?? "/account/oauth/complete";
 
   const response = await client.fetch(startPath, {
     method: "POST",

package/src/runtime/routes/surface-action-routes.ts

@@ -11,13 +11,6 @@ import { z } from "zod";
 
 import type { ChannelId } from "../../channels/types.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
-import type { Conversation } from "../../daemon/conversation.js";
-import {
-  findConversation,
-  findConversationBySurfaceId,
-  getOrCreateConversation,
-} from "../../daemon/conversation-store.js";
-import { rawGet } from "../../memory/raw-query.js";
 import { getLogger } from "../../util/logger.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import { healGuardianBindingDrift } from "../guardian-vellum-migration.js";
@@ -27,6 +20,7 @@ import {
   withSourceChannel,
 } from "../trust-context-resolver.js";
 import { BadRequestError, InternalError, NotFoundError, RouteError } from "./errors.js";
+import { resolveSurfaceConversation } from "./surface-conversation-resolver.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("surface-action-routes");
@@ -90,37 +84,6 @@ function applyTrustContext(
   }
 }
 
-/**
- * Resolve the conversation owning a surface, rehydrating from the DB when
- * the in-memory lookup misses (daemon restart or LRU eviction). The DB scan
- * is also the source of truth that the surface exists — without it,
- * `getOrCreateConversation` would silently create a phantom conversation
- * for any caller-supplied id.
- */
-async function resolveSurfaceConversation(
-  conversationId: string | null | undefined,
-  surfaceId: string,
-): Promise<Conversation | undefined> {
-  const found = conversationId
-    ? findConversation(conversationId)
-    : findConversationBySurfaceId(surfaceId);
-  if (found) return found;
-
-  // Escape LIKE wildcards so a `surfaceId` like "%" or "_" can't match
-  // unrelated rows.
-  const escaped = surfaceId.replace(/[\\%_]/g, "\\$&");
-  const row = rawGet<{ conversation_id: string }>(
-    `SELECT conversation_id FROM messages
-     WHERE content LIKE ? ESCAPE '\\'
-     ORDER BY created_at DESC
-     LIMIT 1`,
-    `%"surfaceId":"${escaped}"%`,
-  );
-  if (!row) return undefined;
-  if (conversationId && conversationId !== row.conversation_id) return undefined;
-  return await getOrCreateConversation(row.conversation_id);
-}
-
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------

package/src/runtime/routes/surface-content-routes.ts

@@ -2,14 +2,16 @@
  * Route handler for fetching surface content by ID.
  *
  * GET /v1/surfaces/:surfaceId — return the full surface payload from the
- * conversation's in-memory surface state. Used by clients to re-hydrate surfaces
- * whose data was stripped during memory compaction.
+ * conversation's in-memory surface state. Used by clients to re-hydrate
+ * surfaces whose data was stripped during memory compaction, or whose
+ * owning conversation has been evicted from the daemon's in-memory map
+ * (daemon restart, LRU eviction).
  */
 import { z } from "zod";
 
-import { findConversation } from "../../daemon/conversation-store.js";
 import { getLogger } from "../../util/logger.js";
 import { BadRequestError, NotFoundError } from "./errors.js";
+import { resolveSurfaceConversation } from "./surface-conversation-resolver.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("surface-content-routes");
@@ -18,7 +20,7 @@ const log = getLogger("surface-content-routes");
 // GET /v1/surfaces/:surfaceId?conversationId=...
 // ---------------------------------------------------------------------------
 
-function handleGetSurfaceContent({
+async function handleGetSurfaceContent({
   pathParams = {},
   queryParams = {},
 }: RouteHandlerArgs) {
@@ -32,7 +34,12 @@ function handleGetSurfaceContent({
     throw new BadRequestError("surfaceId path parameter is required");
   }
 
-  const conversation = findConversation(conversationId);
+  // Resolve via the shared surface→conversation helper: in-memory first,
+  // falling back to a DB scan that rehydrates the conversation when the
+  // owning Conversation has been evicted or the daemon was restarted. The
+  // DB scan uses the surfaceId itself as the existence check so a stale
+  // or made-up conversationId can't materialize a phantom conversation.
+  const conversation = await resolveSurfaceConversation(conversationId, surfaceId);
   if (!conversation) {
     throw new NotFoundError(
       "No active conversation found for this conversationId",

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

@@ -0,0 +1,65 @@
+/**
+ * Shared helper for resolving the conversation that owns a surface.
+ *
+ * Used by both `surface-action-routes` (POST /v1/surface-actions) and
+ * `surface-content-routes` (GET /v1/surfaces/:surfaceId) so the
+ * in-memory-miss → DB-scan → rehydrate flow stays in one place.
+ *
+ * Why this exists: surfaces live on the in-memory `Conversation` object
+ * (`surfaceState` is rebuilt from `ui_surface` blocks in message
+ * history by `restoreSurfaceStateFromHistory()` whenever a Conversation
+ * is constructed). A bare `findConversation` lookup 404s after daemon
+ * restart or LRU eviction even though the surface data is still in the
+ * SQLite `messages` table. The DB scan below uses the surfaceId itself
+ * as the existence check so `getOrCreateConversation` can't be tricked
+ * into materializing a phantom conversation for any caller-supplied id.
+ */
+import type { Conversation } from "../../daemon/conversation.js";
+import {
+  findConversation,
+  findConversationBySurfaceId,
+  getOrCreateConversation,
+} from "../../daemon/conversation-store.js";
+import { rawGet } from "../../memory/raw-query.js";
+
+/**
+ * Resolve the {@link Conversation} that owns the given surface.
+ *
+ * Lookup order:
+ * 1. In-memory map keyed by `conversationId` (or by `surfaceId` when no
+ *    id is supplied).
+ * 2. SQLite `messages` table — find the conversation whose history
+ *    contains a `ui_surface` block with this `surfaceId`. The result is
+ *    validated against the caller's `conversationId` (when supplied) so
+ *    a mismatched pair returns `undefined` rather than silently
+ *    re-routing to a different conversation.
+ * 3. `getOrCreateConversation` rehydrates the row, which triggers
+ *    `restoreSurfaceStateFromHistory()` and repopulates `surfaceState`.
+ *
+ * Returns `undefined` when neither lookup nor DB scan turns up a
+ * matching conversation. Callers are expected to translate that into
+ * the route-appropriate 404.
+ */
+export async function resolveSurfaceConversation(
+  conversationId: string | null | undefined,
+  surfaceId: string,
+): Promise<Conversation | undefined> {
+  const found = conversationId
+    ? findConversation(conversationId)
+    : findConversationBySurfaceId(surfaceId);
+  if (found) return found;
+
+  // Escape LIKE wildcards so a `surfaceId` like "%" or "_" can't match
+  // unrelated rows.
+  const escaped = surfaceId.replace(/[\\%_]/g, "\\$&");
+  const row = rawGet<{ conversation_id: string }>(
+    `SELECT conversation_id FROM messages
+     WHERE content LIKE ? ESCAPE '\\'
+     ORDER BY created_at DESC
+     LIMIT 1`,
+    `%"surfaceId":"${escaped}"%`,
+  );
+  if (!row) return undefined;
+  if (conversationId && conversationId !== row.conversation_id) return undefined;
+  return await getOrCreateConversation(row.conversation_id);
+}

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

@@ -5,6 +5,7 @@
 import { z } from "zod";
 
 import { destroyActiveConversation } from "../../daemon/conversation-store.js";
+import { stripConversationIds } from "../../home/feed-writer.js";
 import {
   countConversationsByScheduleJobId,
   getConversation,
@@ -54,6 +55,8 @@ async function handleWipeConversation({ body = {} }: RouteHandlerArgs) {
     });
   }
 
+  void stripConversationIds(conversationId);
+
   return {
     wiped: true,
     unsupersededItems: 0,

package/src/runtime/services/__tests__/analyze-conversation.test.ts

@@ -46,6 +46,7 @@ mock.module("../../../memory/conversation-crud.js", () => ({
   addMessage: mockAddMessage,
   findAnalysisConversationFor: mockFindAnalysisConversationFor,
   getConversationSource: mockGetConversationSource,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../../../export/transcript-formatter.js", () => ({
@@ -80,6 +81,7 @@ const testHub = new AssistantEventHub();
 mock.module("../../assistant-event-hub.js", () => ({
   AssistantEventHub,
   assistantEventHub: testHub,
+  broadcastMessage: async () => {},
 }));
 
 import { analyzeConversation } from "../analyze-conversation.js";

package/src/runtime/slack-dm-text-delivery.ts

@@ -0,0 +1,177 @@
+import type { ChannelId } from "../channels/types.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import { getLogger } from "../util/logger.js";
+import { deliverChannelReply } from "./gateway-client.js";
+
+const log = getLogger("runtime-http");
+
+const NO_RESPONSE_INLINE_RE = /<no_response\s*\/?>/gi;
+
+export function isSlackDeliveryCallbackUrl(replyCallbackUrl?: string): boolean {
+  if (!replyCallbackUrl) return false;
+  try {
+    return new URL(replyCallbackUrl).pathname.endsWith("/deliver/slack");
+  } catch {
+    return replyCallbackUrl.endsWith("/deliver/slack");
+  }
+}
+
+export function shouldDeliverSlackDmTextResponses(params: {
+  sourceChannel: ChannelId;
+  chatType?: string;
+  replyCallbackUrl?: string;
+}): boolean {
+  return (
+    params.sourceChannel === "slack" &&
+    params.chatType === "im" &&
+    isSlackDeliveryCallbackUrl(params.replyCallbackUrl)
+  );
+}
+
+export type SlackDmTextDeliveryController = {
+  observeEvent: (msg: ServerMessage) => void;
+  waitForPendingDeliveries: () => Promise<void>;
+  getFinalDeliveryResumeOptions: (
+    messageId: string | undefined,
+  ) => { startFromSegment: number; messageTs?: string } | undefined;
+};
+
+export function createSlackDmTextDeliveryController(params: {
+  sourceChannel: ChannelId;
+  chatType?: string;
+  replyCallbackUrl?: string;
+  chatId: string;
+  assistantId?: string;
+  deliveredTextResponseIndexes?: readonly number[];
+  onTextResponseDelivered?: (
+    responseIndex: number,
+    reason: "before_tool" | "message_complete",
+  ) => void;
+}): SlackDmTextDeliveryController | undefined {
+  const { replyCallbackUrl } = params;
+  if (!shouldDeliverSlackDmTextResponses(params) || !replyCallbackUrl) {
+    return undefined;
+  }
+
+  const deliveredTextResponseIndexes = new Set(
+    params.deliveredTextResponseIndexes ?? [],
+  );
+  const messageIdToResponseIndexes = new Map<string, number[]>();
+  const responseIndexToMessageTs = new Map<number, string>();
+  let textResponseIndex = 0;
+  let pendingText = "";
+  let currentMessageResponseIndexes: number[] = [];
+  let deliveryChain = Promise.resolve();
+
+  const associateCurrentMessageResponses = (
+    messageId: string | undefined,
+  ): void => {
+    if (!messageId || currentMessageResponseIndexes.length === 0) return;
+    const responseIndexes = messageIdToResponseIndexes.get(messageId) ?? [];
+    for (const responseIndex of currentMessageResponseIndexes) {
+      if (!responseIndexes.includes(responseIndex)) {
+        responseIndexes.push(responseIndex);
+      }
+    }
+    messageIdToResponseIndexes.set(messageId, responseIndexes);
+    currentMessageResponseIndexes = [];
+  };
+
+  const flushPendingText = (
+    reason: "before_tool" | "message_complete",
+  ): void => {
+    const text = pendingText;
+    pendingText = "";
+
+    const deliverableText = text.replace(NO_RESPONSE_INLINE_RE, "").trim();
+    if (deliverableText.length === 0) return;
+
+    textResponseIndex += 1;
+    const currentResponseIndex = textResponseIndex;
+    currentMessageResponseIndexes.push(currentResponseIndex);
+    if (deliveredTextResponseIndexes.has(currentResponseIndex)) return;
+
+    deliveryChain = deliveryChain
+      .catch(() => undefined)
+      .then(async () => {
+        let result: Awaited<ReturnType<typeof deliverChannelReply>>;
+        try {
+          result = await deliverChannelReply(replyCallbackUrl, {
+            chatId: params.chatId,
+            text: deliverableText,
+            assistantId: params.assistantId,
+            useBlocks: true,
+          });
+        } catch (err) {
+          log.warn(
+            { err, chatId: params.chatId },
+            "Failed to deliver intermediate Slack DM assistant text",
+          );
+          return;
+        }
+
+        if (result.ts) {
+          responseIndexToMessageTs.set(currentResponseIndex, result.ts);
+        }
+        deliveredTextResponseIndexes.add(currentResponseIndex);
+        try {
+          params.onTextResponseDelivered?.(currentResponseIndex, reason);
+        } catch (err) {
+          log.warn(
+            { err, chatId: params.chatId, responseIndex: currentResponseIndex },
+            "Failed to persist intermediate Slack DM assistant text progress",
+          );
+        }
+      });
+  };
+
+  return {
+    observeEvent(msg) {
+      if (msg.type === "assistant_text_delta") {
+        pendingText += msg.text;
+        return;
+      }
+
+      if (msg.type === "message_complete") {
+        flushPendingText("message_complete");
+        if (typeof msg.messageId === "string") {
+          associateCurrentMessageResponses(msg.messageId);
+        }
+        currentMessageResponseIndexes = [];
+        return;
+      }
+
+      if (msg.type === "tool_use_start") {
+        flushPendingText("before_tool");
+      }
+    },
+    waitForPendingDeliveries: () => deliveryChain,
+    getFinalDeliveryResumeOptions: (messageId) => {
+      if (typeof messageId !== "string") {
+        return undefined;
+      }
+      const responseIndexes = messageIdToResponseIndexes.get(messageId) ?? [];
+      let deliveredPrefixCount = 0;
+      for (const responseIndex of responseIndexes) {
+        if (!deliveredTextResponseIndexes.has(responseIndex)) break;
+        deliveredPrefixCount += 1;
+      }
+      if (deliveredPrefixCount === 0) return undefined;
+
+      const firstLiveResponseIndex = responseIndexes[0];
+      const allTextResponsesDelivered =
+        responseIndexes.length > 0 &&
+        responseIndexes.every((responseIndex) =>
+          deliveredTextResponseIndexes.has(responseIndex),
+        );
+      const messageTs =
+        allTextResponsesDelivered && firstLiveResponseIndex !== undefined
+          ? responseIndexToMessageTs.get(firstLiveResponseIndex)
+          : undefined;
+      return {
+        startFromSegment: deliveredPrefixCount,
+        ...(messageTs ? { messageTs } : {}),
+      };
+    },
+  };
+}

package/src/runtime/sync/resource-sync-events.ts

@@ -64,7 +64,7 @@ const SHAPE_CHANGING_REASONS: ReadonlySet<ConversationListInvalidatedReason> =
  *
  * Web consumes `sync_changed` (`conversationsList` for shape changes,
  * `conversation:<id>:metadata` for content changes) directly and patches
- * the cached list in place — see `useAssistantSyncStream` for the consumer
+ * the cached list in place — see `useConversationSync` for the consumer
  * side. macOS (`ConversationRestorer.swift`) still listens for the typed
  * broadcast.
  *

package/src/runtime/tool-grant-request-helper.ts

@@ -147,6 +147,7 @@ export function createOrReuseToolGrantRequest(
     sourceEventName: "guardian.question",
     sourceChannel: sourceChannel as NotificationSourceChannel,
     sourceContextId: conversationId,
+    requiresConversation: true,
     attentionHints: {
       requiresAction: true,
       urgency: "high",

package/src/schedule/schedule-store.ts

@@ -17,6 +17,13 @@ const logger = getLogger("schedule-store");
 
 function notifySchedulesChanged(): void {
   publishSchedulesChanged();
+  void import("../background-wake/publisher.js")
+    .then(({ refreshBackgroundWakeIntent }) =>
+      refreshBackgroundWakeIntent("schedule-changed"),
+    )
+    .catch((err) =>
+      logger.warn({ err }, "Failed to queue background wake refresh"),
+    );
 }
 
 export type ScheduleMode = "notify" | "execute" | "script" | "wake";
@@ -124,7 +131,7 @@ export function createSchedule(params: {
   const routingIntent = params.routingIntent ?? "all_channels";
   const routingHints = params.routingHints ?? {};
   const quiet = params.quiet ?? false;
-  const reuseConversation = params.reuseConversation ?? false;
+  const reuseConversation = params.reuseConversation ?? !isOneShot;
   const maxRetries = params.maxRetries ?? 3;
   const retryBackoffMs = params.retryBackoffMs ?? 60000;