@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/runtime/pending-interactions.ts

@@ -265,14 +265,14 @@ export function getByConversation(
  * /v1/host-transfer-result after completing the operation, get a 404, and the
  * proxy timer would fire with a spurious timeout error.
  *
- * `question` interactions are also skipped: a new message supersedes an open
- * ask_question by steering to it (see the enqueue path in
- * conversation-routes.ts), which aborts the parked turn and settles the
- * question via its abort signal. Clearing the entry here instead would drop it
- * without settling the prompt's Promise (questions carry no `rpcResolve`
- * fallback like secrets do) and would strip the steer of the entry it needs to
- * fire — which can co-occur with a confirmation, since one model response can
- * open both tools concurrently.
+ * `question` interactions are also skipped: a new message settles an open
+ * ask_question at the enqueue path (see `daemon/handlers/conversations.ts`),
+ * either by answering it with the typed text or by steering to the message,
+ * which aborts the parked turn and settles the question via its abort signal.
+ * Clearing the entry here instead would drop it without settling the prompt's
+ * Promise (questions carry no `rpcResolve` fallback like secrets do) and would
+ * strip both paths of the entry they need, which can co-occur with a
+ * confirmation since one model response can open both tools concurrently.
  */
 export function removeByConversation(
   conversationId: string,

package/src/runtime/question-resolution.ts

@@ -2,7 +2,7 @@
  * Shared resolution core for pending `ask_question` interactions.
  *
  * A pending `question` interaction (registered by {@link QuestionPrompter}) can
- * be resolved from two places:
+ * be resolved from three places:
  *
  *  - `POST /v1/question-response` — an app/web client submits the user's
  *    batched selection (see `routes/question-routes.ts`).
@@ -10,8 +10,11 @@
  *    or bare-text answer routes through the guardian reply router to the
  *    `pending_question` resolver, which builds the submission (see
  *    `approvals/guardian-request-resolvers.ts`).
+ *  - the enqueue path: a message typed into the chat while the card is open
+ *    answers the parked question as free text (see
+ *    `daemon/handlers/conversations.ts`).
  *
- * Both funnel through {@link resolvePendingQuestion} so the validate → consume
+ * All funnel through {@link resolvePendingQuestion} so the validate → consume
  * → `rpcResolve` sequence has a single implementation. The helper is
  * transport-agnostic: it returns a discriminated outcome rather than throwing
  * route errors, so each caller maps the outcome to its own surface (HTTP status
@@ -28,12 +31,20 @@ import {
 import * as pendingInteractions from "./pending-interactions.js";
 
 /**
- * How to resolve a pending question: a batched submission (one entry per
- * question) or a close (every question reported as `skipped`).
+ * How to resolve a pending question:
+ *
+ *  - `submit`: a batched submission, one entry per question.
+ *  - `close`: the card was dismissed; every question is reported as
+ *    `skipped`.
+ *  - `chat_reply`: the user typed a message into the chat while the card was
+ *    open. The text answers the first question as free text and the rest stay
+ *    `skipped`; the result is flagged so the tool tells the model where the
+ *    answer came from.
  */
 export type QuestionResolutionInput =
   | { kind: "submit"; submissions: QuestionBatchSubmission[] }
-  | { kind: "close" };
+  | { kind: "close" }
+  | { kind: "chat_reply"; text: string };
 
 /**
  * Outcome of {@link resolvePendingQuestion}.
@@ -57,9 +68,10 @@ export type QuestionResolutionOutcome =
   | { status: "invalid"; message: string };
 
 /**
- * Resolve a pending `question` interaction with a batched submission or a
- * close. Validation runs BEFORE the interaction is consumed, so an `invalid`
- * outcome leaves the pending prompt (and its timer) intact for a retry.
+ * Resolve a pending `question` interaction with a batched submission, a close,
+ * or a chat reply. Validation runs BEFORE the interaction is consumed, so an
+ * `invalid` outcome leaves the pending prompt (and its timer) intact for a
+ * retry.
  */
 export function resolvePendingQuestion(
   requestId: string,
@@ -81,6 +93,8 @@ export function resolvePendingQuestion(
         })),
         overall: "closed",
       };
+    } else if (input.kind === "chat_reply") {
+      result = buildChatReplyResult(input.text, interaction);
     } else {
       result = buildCompletedResult(input.submissions, interaction);
     }
@@ -136,6 +150,38 @@ function buildCompletedResult(
   return { entries, overall: "completed" };
 }
 
+/**
+ * Build the result for a chat reply: the typed text answers the first question
+ * as free text, every other question stays `skipped`.
+ *
+ * The daemon holds no partial per-question state (the card keeps the user's
+ * in-progress answers locally until the whole batch is posted), so the first
+ * question is by construction the first unanswered one. Which question the
+ * text really speaks to is the model's call, not the daemon's: the flag on the
+ * result tells it the answer came from the chat rather than the card, and it
+ * maps the reply onto the batch from there.
+ */
+function buildChatReplyResult(
+  text: string,
+  interaction: ReturnType<typeof pendingInteractions.get>,
+): QuestionPromptResult {
+  const { orderedIds } = readBatchMetadata(interaction);
+  if (orderedIds.length === 0) {
+    throw new QuestionBatchValidationError(
+      "No registered question ids for this batch",
+    );
+  }
+  return {
+    entries: orderedIds.map((id, index) =>
+      index === 0
+        ? { questionId: id, decision: "free_text" as const, text }
+        : { questionId: id, decision: "skipped" as const },
+    ),
+    overall: "completed",
+    answeredInChat: true,
+  };
+}
+
 /**
  * Pull the prompter-stashed batch bookkeeping off a pending interaction.
  * Returns empty defaults if the metadata is absent.

package/src/runtime/routes/__tests__/conversation-list-routes.test.ts

@@ -1302,3 +1302,149 @@ describe("GET /v1/conversations/sections", () => {
     expect(sections.some((s) => s.kind === "pinned")).toBe(false);
   });
 });
+
+describe("GET /v1/conversations, conversationType=all", () => {
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  function setLastMessageAt(id: string, at: number): void {
+    rawRun(
+      "test:setLastMessageAt",
+      "UPDATE conversations SET last_message_at = ? WHERE id = ?",
+      at,
+      id,
+    );
+  }
+
+  test("returns the standard listing and the background umbrella together", async () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    const result = (await invoke({ conversationType: "all" })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "bg-1",
+      "foreground-1",
+      "sched-1",
+    ]);
+  });
+
+  test("with archiveStatus=all one page spans live and done rows of every type", async () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    seedArchived("archived-1");
+    const archivedBackground = createConversation({
+      title: "archived-bg",
+      conversationType: "background",
+    });
+    rawRun(
+      "test:archiveConversation",
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      archivedBackground.id,
+    );
+
+    const result = (await invoke({
+      conversationType: "all",
+      archiveStatus: "all",
+    })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "archived-1",
+      "archived-bg",
+      "bg-1",
+      "foreground-1",
+    ]);
+    expect(result.hasMore).toBe(false);
+  });
+
+  test("orders by last message time descending across the types it merges", async () => {
+    const oldest = createConversation("oldest-foreground");
+    const middle = createConversation({
+      title: "middle-background",
+      conversationType: "background",
+    });
+    const newest = createConversation("newest-foreground");
+    setLastMessageAt(oldest.id, 1000);
+    setLastMessageAt(middle.id, 2000);
+    setLastMessageAt(newest.id, 3000);
+
+    const result = (await invoke({ conversationType: "all" })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual([
+      "newest-foreground",
+      "middle-background",
+      "oldest-foreground",
+    ]);
+  });
+
+  test("excludes legacy private rows and subagent runs", async () => {
+    createConversation("foreground-1");
+    const legacyPrivate = createConversation("legacy-private");
+    rawRun(
+      "test:legacyPrivateRow",
+      "UPDATE conversations SET conversation_type = 'private', group_id = 'system:background' WHERE id = ?",
+      legacyPrivate.id,
+    );
+    const subagent = createConversation({
+      title: "subagent-run",
+      conversationType: "background",
+    });
+    rawRun(
+      "test:subagentRun",
+      "UPDATE conversations SET source = 'subagent' WHERE id = ?",
+      subagent.id,
+    );
+
+    const result = (await invoke({ conversationType: "all" })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual(["foreground-1"]);
+  });
+
+  test("never appends pinned rows outside the page", async () => {
+    // Pinned injection is the compatibility shim for the default sidebar
+    // read. A whole-history page already contains the pinned row in recency
+    // order, so appending it would duplicate it and put hasMore out of step
+    // with the count.
+    const pinned = createConversation("pinned-1");
+    rawRun(
+      "test:pinConversation",
+      "UPDATE conversations SET is_pinned = 1, group_id = 'system:pinned' WHERE id = ?",
+      pinned.id,
+    );
+    const newer = createConversation("newer-1");
+    setLastMessageAt(pinned.id, 1000);
+    setLastMessageAt(newer.id, 2000);
+
+    const result = (await invoke({
+      conversationType: "all",
+      limit: "1",
+    })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual(["newer-1"]);
+    expect(result.hasMore).toBe(true);
+  });
+
+  test("hasMore describes the combined total, so pagination drains it", async () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    const first = (await invoke({
+      conversationType: "all",
+      limit: "2",
+    })) as ListResponse;
+    expect(first.conversations).toHaveLength(2);
+    expect(first.hasMore).toBe(true);
+
+    const second = (await invoke({
+      conversationType: "all",
+      limit: "2",
+      offset: String(first.nextOffset),
+    })) as ListResponse;
+    expect(second.conversations).toHaveLength(1);
+    expect(second.hasMore).toBe(false);
+  });
+});

package/src/runtime/routes/__tests__/dictation-processing.test.ts

@@ -0,0 +1,174 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { DictationProfile } from "../../../daemon/dictation-profile-store.js";
+
+let profile: DictationProfile;
+let nextToolInput: { mode?: string; text?: string } | null;
+let providerAvailable: boolean;
+let providerFails: boolean;
+let providerResolutions: number;
+let requestedProperties: Record<string, unknown> | undefined;
+
+mock.module("../../../providers/provider-send-message.js", () => ({
+  getConfiguredProvider: async () => {
+    providerResolutions += 1;
+    if (!providerAvailable) {
+      return null;
+    }
+    return {
+      sendMessage: async (
+        _messages: unknown,
+        options: {
+          tools: Array<{
+            input_schema: { properties: Record<string, unknown> };
+          }>;
+        },
+      ) => {
+        if (providerFails) {
+          throw new Error("Provider unavailable");
+        }
+        requestedProperties = options.tools[0]?.input_schema.properties;
+        return {
+          content: nextToolInput
+            ? [{ type: "tool_use", input: nextToolInput }]
+            : [{ type: "text", text: "Rewritten text." }],
+        };
+      },
+    };
+  },
+  extractToolUse: (response: { content: Array<{ type: string }> }) =>
+    response.content.find((block) => block.type === "tool_use"),
+  userMessage: (text: string) => ({ role: "user", content: text }),
+  createTimeout: () => ({ signal: undefined, cleanup: () => undefined }),
+}));
+
+mock.module("../../../daemon/dictation-profile-store.js", () => ({
+  resolveProfile: () => ({ profile, source: "default" }),
+}));
+
+const { ROUTES, computeMaxTokens } = await import("../diagnostics-routes.js");
+const route = ROUTES.find((entry) => entry.operationId === "dictation_post")!;
+
+async function dictate(
+  transcription: string,
+  context: { cursorInTextField?: boolean; selectedText?: string } = {
+    cursorInTextField: true,
+  },
+) {
+  return (await route.handler({
+    body: { transcription, context },
+  } as unknown as Parameters<typeof route.handler>[0])) as {
+    text: string;
+    mode: string;
+    actionPlan?: string;
+  };
+}
+
+beforeEach(() => {
+  profile = { id: "general", name: "General" };
+  nextToolInput = { mode: "dictation", text: "We should ship it." };
+  providerAvailable = true;
+  providerFails = false;
+  providerResolutions = 0;
+  requestedProperties = undefined;
+});
+
+describe("dictation preserves recognized words", () => {
+  test.each([
+    "I think we probably shouldn't ship it, at least not yet.",
+    "Um, I don't, I don't want to say yes. Maybe next week?",
+    "First onions, then tomatoes. Actually, no tomatoes.",
+    "  Please don't send that.\nI mean it.  ",
+    "send me the draft, but don't send it to anyone else",
+  ])(
+    "preserves text-field dictation despite an attempted model rewrite: %s",
+    async (words) => {
+      expect(await dictate(words)).toMatchObject({
+        mode: "dictation",
+        text: words,
+      });
+      expect(providerResolutions).toBe(1);
+    },
+  );
+
+  test("a style profile cannot automatically rewrite ordinary dictation", async () => {
+    profile.stylePrompt = "Make every sentence confident and professional.";
+    const words = "I guess maybe we shouldn't do this.";
+
+    expect(await dictate(words)).toMatchObject({ text: words });
+    expect(providerResolutions).toBe(1);
+  });
+
+  test("whitespace-only selection is ordinary dictation", async () => {
+    expect(
+      await dictate("Don't change my words.", {
+        cursorInTextField: true,
+        selectedText: "  \n ",
+      }),
+    ).toMatchObject({ mode: "dictation", text: "Don't change my words." });
+    expect(providerResolutions).toBe(1);
+  });
+
+  test("keeps explicitly configured snippet and dictionary replacements", async () => {
+    profile.snippets = [
+      { trigger: "my sign off", expansion: "Thanks, user one" },
+    ];
+    profile.dictionary = [{ spoken: "user one", written: "Example User" }];
+
+    expect(await dictate("Maybe later. my sign off")).toMatchObject({
+      mode: "dictation",
+      text: "Maybe later. Thanks, Example User",
+    });
+    expect(providerResolutions).toBe(1);
+  });
+
+  test("classification outside a text field cannot supply replacement text", async () => {
+    const words = "I think we probably shouldn't ship it.";
+
+    expect(await dictate(words, {})).toMatchObject({
+      mode: "dictation",
+      text: words,
+    });
+    expect(providerResolutions).toBe(1);
+    expect(Object.keys(requestedProperties ?? {})).toEqual(["mode"]);
+  });
+
+  test.each([true, false])(
+    "action classification preserves the original command with cursorInTextField=%s",
+    async (cursorInTextField) => {
+      nextToolInput = { mode: "action", text: "Send the files." };
+      profile.snippets = [{ trigger: "files", expansion: "all files" }];
+      const words = "Send the files, but not the private ones.";
+
+      expect(await dictate(words, { cursorInTextField })).toMatchObject({
+        mode: "action",
+        text: words,
+        actionPlan: `User wants to: ${words}`,
+      });
+    },
+  );
+
+  test.each([
+    "missing-provider",
+    "provider-error",
+    "missing-tool",
+    "invalid-mode",
+  ])("classification fallback preserves words when %s", async (failure) => {
+    providerAvailable = failure !== "missing-provider";
+    providerFails = failure === "provider-error";
+    nextToolInput = failure === "missing-tool" ? null : { mode: "invalid" };
+    const words = "I don't think that's what I meant, you know?";
+
+    expect(await dictate(words, {})).toMatchObject({
+      mode: "dictation",
+      text: words,
+    });
+  });
+});
+
+describe("selected-text output budget", () => {
+  test("reserves space for the edit and tool-call JSON", () => {
+    expect(computeMaxTokens(900)).toBeGreaterThan(600);
+    expect(computeMaxTokens(5)).toBe(512);
+  });
+});

package/src/runtime/routes/__tests__/global-search-routes.test.ts

@@ -8,7 +8,10 @@
  *
  * Also covers the search-query parser: `is:archived` and its synonyms in the
  * `q` string flip the conversation arm to `includeArchived: true`, and the
- * filter token is stripped from the term before any backend is called.
+ * filter token is stripped from the term before any backend is called. Under
+ * the `sidebar-done` flag the unfiltered default is `true` instead and
+ * `is:unarchived` is the opt-out, so the flag-on twins assert the mirror
+ * image of the default ones.
  */
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -30,9 +33,13 @@ const searchConversationsMock = mock(
   },
 );
 
+let sidebarDoneEnabled = false;
+
 const actualContactStore = await import("../../../contacts/contact-store.js");
 const actualConvQueries =
   await import("../../../persistence/conversation-queries.js");
+const actualSidebarDoneGate =
+  await import("../../../config/sidebar-done-gate.js");
 
 mock.module("../../../contacts/contact-store.js", () => ({
   ...actualContactStore,
@@ -42,6 +49,10 @@ mock.module("../../../persistence/conversation-queries.js", () => ({
   ...actualConvQueries,
   searchConversations: searchConversationsMock,
 }));
+mock.module("../../../config/sidebar-done-gate.js", () => ({
+  ...actualSidebarDoneGate,
+  isSidebarDoneEnabled: () => sidebarDoneEnabled,
+}));
 
 const { ROUTES } = await import("../global-search-routes.js");
 
@@ -69,6 +80,7 @@ afterEach(() => {
   searchConversationsCalls = [];
   searchConversationsResult = [];
   searchConversationsMock.mockClear();
+  sidebarDoneEnabled = false;
 });
 
 describe("global-search contacts recency source", () => {
@@ -268,3 +280,64 @@ describe("global-search q parser", () => {
     expect(result.queryTokens).toEqual(["alpha", "beta"]);
   });
 });
+
+describe("global-search q parser under sidebar-done", () => {
+  test("plain term reaches done chats by default", async () => {
+    sidebarDoneEnabled = true;
+
+    await handler({
+      queryParams: { q: "shema", categories: "conversations" },
+    });
+
+    expect(searchConversationsCalls[0]?.query).toBe("shema");
+    expect(searchConversationsCalls[0]?.opts).toMatchObject({
+      includeArchived: true,
+    });
+  });
+
+  test("is:unarchived (and archive:no / archive:false) narrows back to live chats", async () => {
+    for (const filter of ["is:unarchived", "archive:no", "archive:false"]) {
+      sidebarDoneEnabled = true;
+      searchConversationsCalls = [];
+      searchConversationsMock.mockClear();
+
+      await handler({
+        queryParams: {
+          q: `${filter} shema`,
+          categories: "conversations",
+        },
+      });
+
+      expect(searchConversationsCalls[0]?.query).toBe("shema");
+      expect(searchConversationsCalls[0]?.opts).toMatchObject({
+        includeArchived: false,
+      });
+    }
+  });
+
+  test("is:archived stays a no-op the term is still stripped of", async () => {
+    sidebarDoneEnabled = true;
+
+    await handler({
+      queryParams: { q: "is:archived shema", categories: "conversations" },
+    });
+
+    expect(searchConversationsCalls[0]?.query).toBe("shema");
+    expect(searchConversationsCalls[0]?.opts).toMatchObject({
+      includeArchived: true,
+    });
+  });
+
+  test("unknown filter tokens stay in the term and do not narrow the default", async () => {
+    sidebarDoneEnabled = true;
+
+    await handler({
+      queryParams: { q: "is:starred shema", categories: "conversations" },
+    });
+
+    expect(searchConversationsCalls[0]?.query).toBe("is:starred shema");
+    expect(searchConversationsCalls[0]?.opts).toMatchObject({
+      includeArchived: true,
+    });
+  });
+});

package/src/runtime/routes/__tests__/inference-provider-connection-routes.test.ts

@@ -405,6 +405,66 @@ describe("POST inference/provider-connections (create)", () => {
     expect(result.auth).toEqual({ type: "platform" });
   });
 
+  test("stores an openai-compatible row pointed at opencode.ai as provider opencode", async () => {
+    const created = (await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "opencode-go",
+          provider: "openai-compatible",
+          credential: "vault/opencode/key",
+          base_url: "https://opencode.ai/zen/go/v1",
+          models: [{ id: "mimo-v2.6-flash" }],
+        },
+      },
+    )) as { provider: string; baseUrl: string | null };
+    expect(created.provider).toBe("opencode");
+    expect(created.baseUrl).toBe("https://opencode.ai/zen/go/v1");
+
+    const lookalike = (await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "lookalike",
+          provider: "openai-compatible",
+          base_url: "https://opencode.ai.evil.example/v1",
+          models: [{ id: "m" }],
+        },
+      },
+    )) as { provider: string };
+    expect(lookalike.provider).toBe("openai-compatible");
+  });
+
+  test("rejects a keyless openai-compatible row pointed at opencode.ai", async () => {
+    await expect(
+      call(findHandler("inference_provider_connections_create"), {
+        body: {
+          name: "opencode-keyless",
+          provider: "openai-compatible",
+          base_url: "https://opencode.ai/zen/v1",
+          models: [{ id: "m" }],
+        },
+      }),
+    ).rejects.toThrow(/Provider "opencode" requires an API key/);
+  });
+
+  test("rejects repointing an existing openai-compatible row at opencode.ai", async () => {
+    await call(findHandler("inference_provider_connections_create"), {
+      body: {
+        name: "my-proxy",
+        provider: "openai-compatible",
+        base_url: "http://localhost:8080/v1",
+        models: [{ id: "m" }],
+      },
+    });
+    await expect(
+      call(findHandler("inference_provider_connections_update"), {
+        pathParams: { name: "my-proxy" },
+        body: { base_url: "https://opencode.ai/zen/v1" },
+      }),
+    ).rejects.toThrow(/needs an "opencode" connection/);
+  });
+
   test("rejects a whitespace-only label", async () => {
     await expect(
       call(findHandler("inference_provider_connections_create"), {

package/src/runtime/routes/__tests__/llm-call-sites-routes.test.ts

@@ -4,8 +4,9 @@ import { CALL_SITE_DEFAULTS } from "../../../config/call-site-defaults.js";
 import {
   type LLMCallSite,
   LLMCallSiteEnum,
+  LLMSchema,
 } from "../../../config/schemas/llm.js";
-import { ROUTES } from "../llm-call-sites-routes.js";
+import { buildCallSiteCatalog, ROUTES } from "../llm-call-sites-routes.js";
 
 const route = ROUTES.find((r) => r.operationId === "llm_call_sites_list")!;
 
@@ -89,6 +90,20 @@ describe("llm-call-sites-routes", () => {
     }
   });
 
+  test("omits an unavailable managed-only shipped default under BYOK", () => {
+    const managed = buildCallSiteCatalog(LLMSchema.parse({})).find(
+      ({ id }) => id === "voiceEscalationJudge",
+    );
+    expect(managed?.defaultProfile).toBe("jev-managed");
+    expect(managed?.shippedDefaultProfile).toBe("jev-managed");
+
+    const byok = buildCallSiteCatalog(
+      LLMSchema.parse({ defaultProvider: { provider: "anthropic" } }),
+    ).find(({ id }) => id === "voiceEscalationJudge");
+    expect(byok?.defaultProfile).toBeUndefined();
+    expect(byok?.shippedDefaultProfile).toBeUndefined();
+  });
+
   test("domains have non-empty id and displayName", async () => {
     const result = (await route.handler({})) as {
       domains: Array<{ id: string; displayName: string }>;