@vellumai/assistant 0.10.12 → 0.11.0-staging.1

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

@@ -22,15 +22,16 @@
 import { z } from "zod";
 
 import {
-  buildBatchEntries,
-  type QuestionBatchMetadata,
   type QuestionBatchSubmission,
   QuestionBatchValidationError,
-  type QuestionPromptResult,
 } from "../../permissions/question-prompter.js";
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import * as pendingInteractions from "../pending-interactions.js";
+import {
+  readBatchMetadata,
+  resolvePendingQuestion,
+} from "../question-resolution.js";
 import { BadRequestError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -111,35 +112,20 @@ function handleQuestionResponse({ body }: RouteHandlerArgs) {
   const response: QuestionResponseBody = parsed.data;
   const { requestId } = response;
 
-  const interaction = pendingInteractions.get(requestId);
-  if (!interaction || interaction.kind !== "question") {
-    log.warn(
-      { requestId, foundKind: interaction?.kind },
-      "Question response for unknown or wrong-kind requestId",
-    );
-    throw new NotFoundError(
-      "No pending question interaction found for this requestId",
-    );
-  }
-
-  // Build + validate the result BEFORE touching `pendingInteractions`, so a
-  // bad payload leaves the pending interaction (and its timer) intact and the
-  // user gets another chance to submit a correct batch.
-  let result: QuestionPromptResult;
+  // The legacy single-question shim needs the interaction's stashed metadata to
+  // synthesize a one-element batch; peek (don't consume) before resolving.
+  let input;
   try {
-    if (response.kind === "close") {
-      const { orderedIds } = readBatchMetadata(interaction);
-      result = {
-        entries: orderedIds.map((id) => ({
-          questionId: id,
-          decision: "skipped" as const,
-        })),
-        overall: "closed",
-      };
-    } else {
-      const submissions = buildSubmissions(response, interaction);
-      result = buildCompletedResult(submissions, interaction);
-    }
+    input =
+      response.kind === "close"
+        ? ({ kind: "close" } as const)
+        : ({
+            kind: "submit",
+            submissions: buildSubmissions(
+              response,
+              pendingInteractions.get(requestId),
+            ),
+          } as const);
   } catch (err) {
     if (err instanceof QuestionBatchValidationError) {
       throw new BadRequestError(err.message);
@@ -147,34 +133,36 @@ function handleQuestionResponse({ body }: RouteHandlerArgs) {
     throw err;
   }
 
-  // Validation passed — deregister now to clear the prompter timer, then
-  // hand the result to the prompter's caller via rpcResolve.
-  pendingInteractions.resolve(
-    requestId,
-    response.kind === "close" ? "cancelled" : "answered",
-  );
+  const outcome = resolvePendingQuestion(requestId, input);
+
+  if (outcome.status === "not_found") {
+    log.warn(
+      { requestId },
+      "Question response for unknown or wrong-kind requestId",
+    );
+    throw new NotFoundError(
+      "No pending question interaction found for this requestId",
+    );
+  }
+  if (outcome.status === "invalid") {
+    throw new BadRequestError(outcome.message);
+  }
 
   log.info(
     {
       requestId,
-      overall: result.overall,
-      conversationId: interaction.conversationId,
+      overall: outcome.result.overall,
+      conversationId: outcome.conversationId,
     },
     "Question resolved",
   );
 
-  (
-    interaction.rpcResolve as
-      | ((value: QuestionPromptResult) => void)
-      | undefined
-  )?.(result);
-
   return { success: true };
 }
 
 /**
  * Normalize the incoming body to a `QuestionBatchSubmission[]` for the
- * submit/legacy paths. Returns `null` for the `close` path (no submissions).
+ * submit/legacy paths.
  */
 function buildSubmissions(
   body: SubmitBody | LegacyOptionBody | LegacyFreeTextBody,
@@ -203,47 +191,6 @@ function buildSubmissions(
   return [{ questionId, kind: "free_text", text: body.text }];
 }
 
-/**
- * Build a `completed` QuestionPromptResult from a batched submission and the
- * per-question metadata the prompter stashed on the interaction. Delegates
- * the validation + ordering loop to {@link buildBatchEntries} so the
- * prompter and the route share a single implementation.
- */
-function buildCompletedResult(
-  submissions: QuestionBatchSubmission[],
-  interaction: ReturnType<typeof pendingInteractions.get>,
-): QuestionPromptResult {
-  const { orderedIds, optionsById } = readBatchMetadata(interaction);
-  if (orderedIds.length === 0) {
-    throw new QuestionBatchValidationError(
-      "No registered question ids for this batch",
-    );
-  }
-  const entries = buildBatchEntries(
-    orderedIds,
-    (qid, oid) => (optionsById[qid] ?? []).includes(oid),
-    new Set(Object.keys(optionsById)),
-    submissions,
-  );
-  return { entries, overall: "completed" };
-}
-
-/**
- * Pull the prompter-stashed batch bookkeeping off a pending interaction.
- * Returns empty defaults if the metadata is absent.
- */
-function readBatchMetadata(
-  interaction: ReturnType<typeof pendingInteractions.get>,
-): QuestionBatchMetadata {
-  const meta = interaction?.metadata as
-    | Partial<QuestionBatchMetadata>
-    | undefined;
-  return {
-    orderedIds: meta?.orderedIds ?? [],
-    optionsById: meta?.optionsById ?? {},
-  };
-}
-
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------

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

@@ -32,13 +32,14 @@ import {
 } from "../../daemon/credential-transcript-scrub.js";
 import { syncManualTokenConnection } from "../../oauth/manual-token-connection.js";
 import { clearEmbeddingBackendCache } from "../../persistence/embeddings/embedding-backend.js";
-import { maybeReseedCapabilitiesAfterManagedCredential } from "../../plugins/defaults/memory/v3/substrate/memory-v2-startup.js";
+import { maybeReseedCapabilitiesAfterManagedCredential } from "../../plugins/defaults/memory/substrate/boot-maintenance.js";
 import { validateAnthropicApiKey } from "../../providers/anthropic/client.js";
 import { validateAtlasCloudApiKey } from "../../providers/atlascloud/client.js";
 import { validateBasetenApiKey } from "../../providers/baseten/client.js";
 import { validateGeminiApiKey } from "../../providers/gemini/client.js";
 import { validateMinimaxApiKey } from "../../providers/minimax/client.js";
 import { validateOpenAIApiKey } from "../../providers/openai/client.js";
+import { validatePoolsideApiKey } from "../../providers/poolside/client.js";
 import { API_KEY_PROVIDERS } from "../../providers/provider-secret-catalog.js";
 import { initializeProviders } from "../../providers/registry.js";
 import { credentialKey } from "../../security/credential-key.js";
@@ -235,6 +236,15 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
           );
           return { success: false, error: validation.reason };
         }
+      } else if (name === "poolside") {
+        const validation = await validatePoolsideApiKey(value);
+        if (!validation.valid) {
+          log.warn(
+            { provider: name, reason: validation.reason },
+            "API key validation failed",
+          );
+          return { success: false, error: validation.reason };
+        }
       }
 
       const stored = await setSecureKeyAsync(

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

@@ -69,8 +69,7 @@ import { generateAvatarImage } from "../../tools/system/avatar-generator.js";
 import { pathExists } from "../../util/fs.js";
 import { getLogger } from "../../util/logger.js";
 import { getAvatarImagePath, getWorkspaceDir } from "../../util/platform.js";
-import { buildAssistantEvent } from "../assistant-event.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
+import { broadcastMessage } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { publishAvatarChanged } from "../sync/resource-sync-events.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
@@ -250,22 +249,13 @@ async function handleOAuthConnectStart({ body = {} }: RouteHandlerArgs) {
           // DB not ready — use orchestrator value
         }
 
-        assistantEventHub
-          .publish(
-            buildAssistantEvent({
-              type: "oauth_connect_result",
-              success: deferredResult.success,
-              service: deferredResult.service,
-              accountInfo,
-              error: deferredResult.error,
-            }),
-          )
-          .catch((err) => {
-            log.warn(
-              { err, service: deferredResult.service },
-              "Failed to publish oauth_connect_result event",
-            );
-          });
+        broadcastMessage({
+          type: "oauth_connect_result",
+          success: deferredResult.success,
+          service: deferredResult.service,
+          accountInfo,
+          error: deferredResult.error,
+        });
 
         if (!deferredResult.success) {
           log.warn(

package/src/runtime/routes/upgrade-broadcast-routes.ts

@@ -8,8 +8,7 @@ import { z } from "zod";
 import type { ServiceGroupUpdateCompleteEvent } from "../../api/events/service-group-update-complete.js";
 import type { ServiceGroupUpdateProgressEvent } from "../../api/events/service-group-update-progress.js";
 import type { ServiceGroupUpdateStartingEvent } from "../../api/events/service-group-update-starting.js";
-import { buildAssistantEvent } from "../assistant-event.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
+import { broadcastMessage } from "../assistant-event-hub.js";
 import { GATEWAY_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -48,7 +47,7 @@ async function handleUpgradeBroadcast({ body }: RouteHandlerArgs) {
       expectedDowntimeSeconds: downtime,
     };
 
-    await assistantEventHub.publish(buildAssistantEvent(message));
+    broadcastMessage(message);
 
     return { ok: true };
   }
@@ -67,7 +66,7 @@ async function handleUpgradeBroadcast({ body }: RouteHandlerArgs) {
       statusMessage,
     };
 
-    await assistantEventHub.publish(buildAssistantEvent(message));
+    broadcastMessage(message);
 
     return { ok: true };
   }
@@ -108,7 +107,7 @@ async function handleUpgradeBroadcast({ body }: RouteHandlerArgs) {
         : {}),
     };
 
-    await assistantEventHub.publish(buildAssistantEvent(message));
+    broadcastMessage(message);
 
     return { ok: true };
   }

package/src/runtime/routes/workspace-routes.test.ts

@@ -17,8 +17,8 @@ import {
 import { join } from "node:path";
 import { beforeAll, describe, expect, test } from "bun:test";
 
+import type { AssistantEventEnvelope } from "../../api/index.js";
 import { SYNC_TAGS } from "../../daemon/message-types/sync.js";
-import type { AssistantEvent } from "../assistant-event.js";
 import { assistantEventHub } from "../assistant-event-hub.js";
 
 // ---------------------------------------------------------------------------
@@ -66,15 +66,18 @@ beforeAll(() => {
 
 function getRoute(operationId: string): RouteDefinition {
   const route = ROUTES.find((r) => r.operationId === operationId);
-  if (!route)
+  if (!route) {
     throw new Error(`No shared route found for operationId: ${operationId}`);
+  }
   return route;
 }
 
 async function waitFor(predicate: () => boolean): Promise<void> {
   const deadline = Date.now() + 500;
   while (Date.now() < deadline) {
-    if (predicate()) return;
+    if (predicate()) {
+      return;
+    }
     await new Promise((resolve) => setTimeout(resolve, 5));
   }
   throw new Error("Timed out waiting for workspace route event");
@@ -557,7 +560,7 @@ describe("POST /v1/workspace/write", () => {
   });
 
   test("publishes sounds sync events when writing sounds config", async () => {
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
       callback: (event) => {

package/src/runtime/slack-reply-session.test.ts

@@ -28,7 +28,7 @@ mock.module("./gateway-client.js", () => ({
   },
 }));
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { SLACK_STREAM_MARKDOWN_LIMIT } from "../messaging/providers/slack/api.js";
 import {
   createSlackReplySession,
@@ -39,34 +39,34 @@ const CHANNEL = "D-STREAM";
 const THREAD_TS = "1700000000.000001";
 const CALLBACK_URL = `https://example.test/deliver/slack?channel=${CHANNEL}&threadTs=${THREAD_TS}`;
 
-const textDelta = (text: string): ServerMessage =>
+const textDelta = (text: string): AssistantEvent =>
   ({
     type: "assistant_text_delta",
     text,
     conversationId: "conv-stream",
-  }) as ServerMessage;
+  }) as AssistantEvent;
 
-const toolUseStart = (toolUseId: string): ServerMessage =>
+const toolUseStart = (toolUseId: string): AssistantEvent =>
   ({
     type: "tool_use_start",
     toolName: "web_search",
     input: { query: "example" },
     conversationId: "conv-stream",
     toolUseId,
-  }) as ServerMessage;
+  }) as AssistantEvent;
 
-const messageComplete = (messageId: string): ServerMessage =>
+const messageComplete = (messageId: string): AssistantEvent =>
   ({
     type: "message_complete",
     conversationId: "conv-stream",
     messageId,
-  }) as ServerMessage;
+  }) as AssistantEvent;
 
 const taskProgressShow = (
   surfaceId: string,
   steps: Array<{ label: string; status: string; detail?: string }>,
   templateTitle?: string,
-): ServerMessage =>
+): AssistantEvent =>
   ({
     type: "ui_surface_show",
     conversationId: "conv-stream",
@@ -80,18 +80,18 @@ const taskProgressShow = (
         steps,
       },
     },
-  }) as ServerMessage;
+  }) as AssistantEvent;
 
 const taskProgressUpdate = (
   surfaceId: string,
   steps: Array<{ label: string; status: string }>,
-): ServerMessage =>
+): AssistantEvent =>
   ({
     type: "ui_surface_update",
     conversationId: "conv-stream",
     surfaceId,
     data: { templateData: { steps } },
-  }) as ServerMessage;
+  }) as AssistantEvent;
 
 const tick = (ms: number): Promise<void> =>
   new Promise((resolve) => setTimeout(resolve, ms));
@@ -351,7 +351,7 @@ describe("createSlackReplySession", () => {
   test("falls back when stopStream throws after streaming text", async () => {
     deliverImpl = async (_url, payload) => {
       const op = payload.slackStream as { action: string };
-      if (op.action === "stop") throw new Error("stop failed");
+      if (op.action === "stop") {throw new Error("stop failed");}
       return { ok: true, ts: "stream-ts-1" };
     };
     const session = createSlackReplySession({

package/src/runtime/slack-reply-session.ts

@@ -1,5 +1,6 @@
 import type { SlackStreamTask } from "@vellumai/gateway-client";
 
+import type { AssistantEvent } from "../api/index.js";
 import {
   extractThreadTsFromCallbackUrl,
   isSlackDeliveryCallbackUrl,
@@ -9,7 +10,6 @@ import {
   incompleteVellumLinkSuffixLength,
   stripVellumLinks,
 } from "../daemon/assistant-attachments.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import { SLACK_STREAM_MARKDOWN_LIMIT } from "../messaging/providers/slack/api.js";
 import { renderSlackBlocks } from "../messaging/providers/slack/render.js";
 import { getLogger } from "../util/logger.js";
@@ -51,7 +51,7 @@ export type SlackStreamReconciliation =
   | { mode: "fallback" };
 
 export type SlackReplySession = {
-  observeEvent: (msg: ServerMessage) => void;
+  observeEvent: (msg: AssistantEvent) => void;
   /**
    * Settle in-flight stream operations, finalize the stream, and report how
    * durable delivery should reconcile. Call once after processing completes.
@@ -79,12 +79,12 @@ export function shouldStreamSlackReply(params: {
   recipientUserId?: string;
   recipientTeamId?: string;
 }): boolean {
-  if (params.sourceChannel !== "slack") return false;
-  if (!isSlackDeliveryCallbackUrl(params.replyCallbackUrl)) return false;
+  if (params.sourceChannel !== "slack") {return false;}
+  if (!isSlackDeliveryCallbackUrl(params.replyCallbackUrl)) {return false;}
   if (extractThreadTsFromCallbackUrl(params.replyCallbackUrl) === null) {
     return false;
   }
-  if (params.chatType === "im") return true;
+  if (params.chatType === "im") {return true;}
   return Boolean(params.recipientUserId && params.recipientTeamId);
 }
 
@@ -130,7 +130,7 @@ export function createSlackReplySession(params: {
   const coalesceMs = params.coalesceMs ?? STREAM_COALESCE_MS;
   const replyCallbackUrl = params.replyCallbackUrl;
   const threadTs = extractThreadTsFromCallbackUrl(replyCallbackUrl);
-  if (threadTs === null) return undefined;
+  if (threadTs === null) {return undefined;}
 
   let state: StreamState = "idle";
   let started = false;
@@ -172,7 +172,7 @@ export function createSlackReplySession(params: {
   // (and `stripVellumLinks` can remove it). Once `finished`, no delta can
   // extend the text, so the full cleaned reply is safe to emit.
   const streamableText = (): string => {
-    if (finished) return cleanedText();
+    if (finished) {return cleanedText();}
     const hold = incompleteVellumLinkSuffixLength(rawText);
     const stable = hold > 0 ? rawText.slice(0, rawText.length - hold) : rawText;
     return stripVellumLinks(stable).replace(NO_RESPONSE_INLINE_RE, "");
@@ -205,7 +205,7 @@ export function createSlackReplySession(params: {
   const enqueueStart = (): void => {
     enqueue(async () => {
       const clean = streamableText();
-      if (clean.trim().length === 0) return;
+      if (clean.trim().length === 0) {return;}
       const firstChunk = clean.slice(0, SLACK_STREAM_MARKDOWN_LIMIT);
       const title = activeProgress?.title;
       const tasks = planTasks();
@@ -259,7 +259,7 @@ export function createSlackReplySession(params: {
 
   const enqueueAppend = (): void => {
     enqueue(async () => {
-      if (state !== "streaming" || !streamTs) return;
+      if (state !== "streaming" || !streamTs) {return;}
       const clean = streamableText();
       const title = activeProgress?.title;
       const tasks = planTasks();
@@ -329,9 +329,9 @@ export function createSlackReplySession(params: {
       clearTimeout(coalesceTimer);
       coalesceTimer = undefined;
     }
-    if (finished || state === "fallback") return;
+    if (finished || state === "fallback") {return;}
     if (!started) {
-      if (!hasDeliverableAssistantText(streamableText())) return;
+      if (!hasDeliverableAssistantText(streamableText())) {return;}
       started = true;
       enqueueStart();
       return;
@@ -340,7 +340,7 @@ export function createSlackReplySession(params: {
   };
 
   const scheduleFlush = (): void => {
-    if (coalesceTimer || finished) return;
+    if (coalesceTimer || finished) {return;}
     coalesceTimer = setTimeout(() => {
       coalesceTimer = undefined;
       flush();
@@ -356,15 +356,15 @@ export function createSlackReplySession(params: {
     }
   };
 
-  const observeTaskProgress = (msg: ServerMessage): void => {
+  const observeTaskProgress = (msg: AssistantEvent): void => {
     if (msg.type === "ui_surface_show") {
       const progress = getTaskProgressDataFromSurfaceData(msg.data);
-      if (!progress) return;
+      if (!progress) {return;}
       taskProgressBySurfaceId.set(msg.surfaceId, progress);
     } else if (msg.type === "ui_surface_update") {
       const existing = taskProgressBySurfaceId.get(msg.surfaceId);
       const progress = mergeTaskProgressData(existing, msg.data);
-      if (!progress) return;
+      if (!progress) {return;}
       taskProgressBySurfaceId.set(msg.surfaceId, progress);
     } else {
       return;
@@ -375,7 +375,7 @@ export function createSlackReplySession(params: {
 
   return {
     observeEvent(msg) {
-      if (finished) return;
+      if (finished) {return;}
 
       if (msg.type === "ui_surface_show" || msg.type === "ui_surface_update") {
         observeTaskProgress(msg);
@@ -415,7 +415,7 @@ export function createSlackReplySession(params: {
 
       enqueueAppend();
       enqueue(async () => {
-        if (state !== "streaming" || !streamTs) return;
+        if (state !== "streaming" || !streamTs) {return;}
         const clean = cleanedText();
         const remaining = clean.slice(confirmedLength);
         const blocks = imageBlocks(clean);

package/src/runtime/sync/sync-publisher.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
+import type { AssistantEventEnvelope } from "../../api/index.js";
 import { SYNC_TAGS } from "../../daemon/message-types/sync.js";
-import type { AssistantEvent } from "../assistant-event.js";
 import { assistantEventHub, broadcastMessage } from "../assistant-event-hub.js";
 import { publishSyncInvalidation } from "./sync-publisher.js";
 
@@ -18,7 +18,7 @@ async function waitFor(predicate: () => boolean): Promise<void> {
 
 describe("sync publisher", () => {
   test("publishes a deduped sync_changed event", async () => {
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
       callback: (event) => {
@@ -104,7 +104,7 @@ describe("sync publisher", () => {
   });
 
   test("forwards originClientId when provided", async () => {
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
       callback: (event) => {
@@ -132,7 +132,7 @@ describe("sync publisher", () => {
   });
 
   test("omits originClientId when not provided", async () => {
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
       callback: (event) => {
@@ -141,7 +141,9 @@ describe("sync publisher", () => {
     });
 
     try {
-      const message = await publishSyncInvalidation([SYNC_TAGS.assistantAvatar]);
+      const message = await publishSyncInvalidation([
+        SYNC_TAGS.assistantAvatar,
+      ]);
 
       await waitFor(() => received.length === 1);
 

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

@@ -21,6 +21,7 @@ import {
   recordApprovalCardDelivery,
   recordGuardianRequestDeliveries,
 } from "../notifications/guardian-delivery-recorder.js";
+import { buildVellumCardAffinity } from "../notifications/vellum-card-affinity.js";
 import { getLogger } from "../util/logger.js";
 import { resolveApprovalSourceReference } from "./approval-source-link.js";
 import { getGuardianBinding } from "./channel-verification-service.js";
@@ -177,6 +178,9 @@ export async function createOrReuseToolGrantRequest(
     sourceChannel,
     sourceContextId: conversationId,
     requiresConversation: true,
+    // Pin the in-app (vellum) card to the conversation the escalated tool is
+    // running in, so the guardian decides it in context.
+    ...(buildVellumCardAffinity(conversationId) ?? {}),
     attentionHints: {
       requiresAction: true,
       urgency: "high",