@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/__tests__/list-messages-provider-error.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Tests for handleListMessages provider-error projection.
+ *
+ * When a turn dies on the provider-error path the agent loop persists the
+ * classified error text as a synthetic assistant row stamped with
+ * `metadata.messageKind: "provider_error"` (plus the classified
+ * code/category). The history projection must surface that marker as the
+ * wire `providerError` field, asserted against the FINAL response payload:
+ * the final projection rebuilds each message object field by field, so a
+ * field carried only on the intermediate object is silently dropped.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "./helpers/set-config.js";
+
+// Keep the memory system off so addMessage skips indexing side effects.
+setConfig("memory", { enabled: false });
+
+import { ConversationMessageSchema } from "../api/responses/conversation-message.js";
+import {
+  addMessage,
+  createConversation,
+  PROVIDER_ERROR_MESSAGE_KIND,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+await initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+interface ProjectedMessage {
+  role: string;
+  providerError?: { code?: string; category?: string };
+}
+
+describe("handleListMessages provider-error projection", () => {
+  beforeEach(resetTables);
+
+  test("surfaces providerError on tagged rows in the final payload", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+    );
+    // Mirror the agent loop's provider-error persist site: a synthetic
+    // assistant row carrying the classified error, tagged in metadata.
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([
+        {
+          type: "text",
+          text: "I couldn't reply because you ran out of credits. Add credits in Settings → Billing and we can pick up where we left off.",
+        },
+      ]),
+      {
+        metadata: {
+          messageKind: PROVIDER_ERROR_MESSAGE_KIND,
+          providerErrorCode: "PROVIDER_BILLING",
+          providerErrorCategory: "credits_exhausted",
+        },
+      },
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    }) as { messages: ProjectedMessage[] };
+
+    // Every projected message validates against the wire schema.
+    for (const message of response.messages) {
+      expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
+    }
+
+    expect(response.messages).toHaveLength(2);
+    const [userRow, errorRow] = response.messages;
+    expect(userRow?.providerError).toBeUndefined();
+    expect(errorRow?.role).toBe("assistant");
+    expect(errorRow?.providerError).toEqual({
+      code: "PROVIDER_BILLING",
+      category: "credits_exhausted",
+    });
+  });
+
+  test("coerces non-string code/category to absent fields", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "something went wrong" }]),
+      {
+        metadata: {
+          messageKind: PROVIDER_ERROR_MESSAGE_KIND,
+          providerErrorCode: 402,
+          providerErrorCategory: null,
+        },
+      },
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    }) as { messages: ProjectedMessage[] };
+
+    expect(response.messages).toHaveLength(1);
+    expect(response.messages[0]?.providerError).toEqual({});
+    expect(() =>
+      ConversationMessageSchema.parse(response.messages[0]),
+    ).not.toThrow();
+  });
+
+  test("omits providerError on untagged rows", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "hi there" }]),
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    }) as { messages: ProjectedMessage[] };
+
+    expect(response.messages).toHaveLength(2);
+    for (const message of response.messages) {
+      expect(message.providerError).toBeUndefined();
+      expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
+    }
+  });
+});

package/src/__tests__/list-messages-system-card.test.ts

@@ -0,0 +1,100 @@
+/**
+ * Tests for handleListMessages system-card projection.
+ *
+ * Daemon-authored status cards (the /compact, /clean, and summarize-up-to
+ * result cards persisted via `persistCannedAssistantCard`) are stamped
+ * `messageKind: "system_card"`. The history projection must surface the
+ * `systemCard` flag so clients render them as standalone system notices
+ * instead of assistant-persona speech after a reload.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "./helpers/set-config.js";
+
+// Keep the memory system off so addMessage skips indexing side effects.
+setConfig("memory", { enabled: false });
+
+import { ConversationMessageSchema } from "../api/responses/conversation-message.js";
+import {
+  addMessage,
+  createConversation,
+  SYSTEM_CARD_MESSAGE_KIND,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+await initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+interface ProjectedMessage {
+  id: string;
+  role: string;
+  systemCard?: boolean;
+}
+
+describe("handleListMessages system-card projection", () => {
+  beforeEach(resetTables);
+
+  test("projects systemCard from the persisted card row metadata", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "/compact" }]),
+    );
+    // Mirror persistCannedAssistantCard: an assistant row stamped with the
+    // system-card marker.
+    const card = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Compacted 12 messages." }]),
+      { metadata: { messageKind: SYSTEM_CARD_MESSAGE_KIND } },
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    }) as { messages: ProjectedMessage[] };
+
+    // Every projected message validates against the wire schema.
+    for (const message of response.messages) {
+      expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
+    }
+
+    const cardRow = response.messages.find((m) => m.id === card.id);
+    expect(cardRow).toBeDefined();
+    expect(cardRow?.systemCard).toBe(true);
+  });
+
+  test("omits systemCard on ordinary user and assistant rows", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "hi there" }]),
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    }) as { messages: ProjectedMessage[] };
+
+    expect(response.messages).toHaveLength(2);
+    for (const message of response.messages) {
+      expect(message.systemCard).toBeUndefined();
+      expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
+    }
+  });
+});

package/src/__tests__/llm-resolver.test.ts

@@ -6,6 +6,7 @@ import { CODE_DEFAULT_PROFILE_ENTRIES } from "../config/default-profile-catalog.
 import {
   type ResolutionFallbackReason,
   resolveCallSiteConfig,
+  resolveCallSiteConfigWithProfile,
   resolveDefaultProfileKey,
   resolveEffectiveProfileKey,
 } from "../config/llm-resolver.js";
@@ -697,9 +698,7 @@ describe("resolveCallSiteConfig", () => {
     const resolved = resolveCallSiteConfig("memoryExtraction", llm);
     expect(resolved.provider).toBe("openai");
     expect(resolved.provider_connection).toBe("openai-personal");
-    expect(resolved.model).toBe(
-      resolveModelIntent("openai", "latency-optimized"),
-    );
+    expect(resolved.model).toBe(resolveModelIntent("openai", "cost-optimized"));
   });
 
   test("BYOK full-workspace: every call site resolves through the default provider, never the managed connection", () => {
@@ -751,9 +750,7 @@ describe("resolveCallSiteConfig", () => {
 
     // Cost-optimized call sites resolve the intent through the BYOK provider.
     const costSite = resolveCallSiteConfig("heartbeatAgent", byokConfig);
-    expect(costSite.model).toBe(
-      resolveModelIntent("openai", "latency-optimized"),
-    );
+    expect(costSite.model).toBe(resolveModelIntent("openai", "cost-optimized"));
 
     // mainAgent uses the user's active profile.
     const balancedSite = resolveCallSiteConfig("mainAgent", byokConfig);
@@ -770,9 +767,7 @@ describe("resolveCallSiteConfig", () => {
 
     const resolved = resolveCallSiteConfig("commitMessage", byokConfig);
     expect(resolved.provider).toBe("openai");
-    expect(resolved.model).toBe(
-      resolveModelIntent("openai", "latency-optimized"),
-    );
+    expect(resolved.model).toBe(resolveModelIntent("openai", "cost-optimized"));
     expect(resolved.maxTokens).toBe(120);
     expect(resolved.effort).toBe("low");
     expect(resolved.thinking.enabled).toBe(false);
@@ -859,6 +854,21 @@ describe("mix profiles", () => {
     }
   });
 
+  test("config and profile attribution share one mix selection", () => {
+    const selectedArms: string[] = [];
+    const resolved = resolveCallSiteConfigWithProfile("mainAgent", mixLlm, {
+      onMixSelected: ({ chosenProfile }) => {
+        selectedArms.push(chosenProfile);
+      },
+    });
+
+    expect(resolved.profileName).toBe("ab");
+    expect(selectedArms).toHaveLength(1);
+    expect(resolved.config.model).toBe(
+      selectedArms[0] === "a" ? "model-a" : "model-b",
+    );
+  });
+
   test("all dereference spots in a turn agree for the same seed", () => {
     // mainAgent (mix as activeProfile) and a non-main call site resolving the
     // same mix as its call-site profile must pick the same arm when given the

package/src/__tests__/managed-profile-guard.test.ts

@@ -263,6 +263,29 @@ describe("PUT /v1/config/llm/profiles/:name — managed profile guard", () => {
     expectNothingCommitted();
   });
 
+  test("PUT on the code-owned latency profile is rejected, status re-enable included", async () => {
+    // Speed fronts live voice, so it takes no writes at all: the re-enable
+    // escape hatch the other managed profiles keep would persist a stub that
+    // never governs what the name resolves to.
+    seedRawConfig({ llm: { profiles: {} } });
+
+    for (const body of [
+      { label: "Zippy" },
+      { status: "active" as const },
+      { status: null },
+    ]) {
+      await expect(
+        replaceRoute.handler({
+          pathParams: { name: "latency-optimized" },
+          body,
+        }),
+      ).rejects.toThrow(
+        'Profile "latency-optimized" is code-owned and cannot be edited.',
+      );
+    }
+    expectNothingCommitted();
+  });
+
   test("PUT { status: null } on managed profile clears status (back to active-by-absence)", async () => {
     seedRawConfig({
       llm: {

package/src/__tests__/notification-platform-adapter.test.ts

@@ -33,11 +33,13 @@ interface FetchCall {
   path: string;
   method: string;
   body: Record<string, unknown>;
+  hasAbortSignal: boolean;
 }
 
 const fetchCalls: FetchCall[] = [];
 const fetchResponses: Array<{ ok: boolean; status: number; body?: string }> =
   [];
+const fetchErrors: Error[] = [];
 let clientAvailable = true;
 
 mock.module("../platform/client.js", () => ({
@@ -52,7 +54,16 @@ mock.module("../platform/client.js", () => ({
           const body = init?.body
             ? (JSON.parse(init.body as string) as Record<string, unknown>)
             : {};
-          fetchCalls.push({ path, method: init?.method ?? "GET", body });
+          fetchCalls.push({
+            path,
+            method: init?.method ?? "GET",
+            body,
+            hasAbortSignal: init?.signal instanceof AbortSignal,
+          });
+          const error = fetchErrors.shift();
+          if (error) {
+            throw error;
+          }
           const response = fetchResponses.shift() ?? {
             ok: true,
             status: 200,
@@ -62,6 +73,7 @@ mock.module("../platform/client.js", () => ({
             ok: response.ok,
             status: response.status,
             text: async () => response.body ?? "",
+            json: async () => JSON.parse(response.body ?? "") as unknown,
           };
         },
       };
@@ -82,6 +94,7 @@ function makePayload(
 ): ChannelDeliveryPayload {
   return {
     deliveryId: "delivery-uuid-1",
+    correlationId: "signal-1",
     sourceEventName: "schedule.notify",
     copy: { title: "Reminder", body: "Check the oven!" },
     deepLinkTarget: { type: "conversation", id: "conv-1" },
@@ -106,6 +119,7 @@ describe("PlatformPushAdapter", () => {
   beforeEach(() => {
     fetchCalls.length = 0;
     fetchResponses.length = 0;
+    fetchErrors.length = 0;
     clientAvailable = true;
   });
 
@@ -123,7 +137,7 @@ describe("PlatformPushAdapter", () => {
     const call = fetchCalls[0]!;
     expect(call.path).toBe("/v1/assistants/test-assistant-id/push/dispatch/");
     expect(call.method).toBe("POST");
-    expect(call.body.delivery_id).toBe("delivery-uuid-1");
+    expect(call.body.delivery_id).toBe("signal-1");
     expect(call.body.source_event_name).toBe("schedule.notify");
     expect(call.body.title).toBe("Reminder");
     expect(call.body.body).toBe("Check the oven!");
@@ -202,6 +216,28 @@ describe("PlatformPushAdapter", () => {
     expect(fetchCalls).toHaveLength(4);
   });
 
+  test("bounds every attempt with an abort signal", async () => {
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(fetchCalls[0]?.hasAbortSignal).toBe(true);
+  });
+
+  test("retries attempts that abort on the per-attempt timeout", async () => {
+    fetchErrors.push(
+      new DOMException("The operation timed out.", "TimeoutError"),
+    );
+    fetchResponses.push({ ok: true, status: 200, body: '{"tokens_sent": 1}' });
+
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(result.remotePushAccepted).toBe(true);
+    expect(fetchCalls).toHaveLength(2);
+  });
+
   test("does not retry on 4xx responses", async () => {
     fetchResponses.push({ ok: false, status: 400, body: "bad request" });
     const adapter = new PlatformPushAdapter();
@@ -212,6 +248,98 @@ describe("PlatformPushAdapter", () => {
     expect(fetchCalls).toHaveLength(1);
   });
 
+  test("preserves an explicit empty platform list with legacy acceptance", async () => {
+    fetchResponses.push({
+      ok: true,
+      status: 200,
+      body: '{"tokens_sent":2,"accepted_platforms":[]}',
+    });
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(result.remotePushAccepted).toBe(true);
+    expect(result.remotePushPlatforms).toEqual([]);
+  });
+
+  test("preserves a successful provider from the final partial 503", async () => {
+    fetchResponses.push(
+      {
+        ok: false,
+        status: 503,
+        body: '{"accepted_platforms":["ios"]}',
+      },
+      { ok: false, status: 503, body: "{}" },
+      { ok: false, status: 503, body: "{}" },
+      {
+        ok: false,
+        status: 503,
+        body: '{"accepted_platforms":["android"]}',
+      },
+    );
+
+    const result = await new PlatformPushAdapter().send(
+      makePayload(),
+      makeDestination(),
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.remotePushPlatforms).toEqual(["ios", "android"]);
+  });
+
+  test("reports remotePushAccepted: false on 202 skipped (flag off)", async () => {
+    fetchResponses.push({
+      ok: true,
+      status: 202,
+      body: '{"skipped": "flag_off"}',
+    });
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(result.remotePushAccepted).toBe(false);
+  });
+
+  test("reports remotePushAccepted: false on 200 with tokens_sent 0", async () => {
+    fetchResponses.push({
+      ok: true,
+      status: 200,
+      body: '{"idempotent": true, "tokens_sent": 0}',
+    });
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(result.remotePushAccepted).toBe(false);
+  });
+
+  test("reports remotePushAccepted: false when the success body is unparseable", async () => {
+    fetchResponses.push({ ok: true, status: 200, body: "not json" });
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(result.remotePushAccepted).toBe(false);
+  });
+
+  test("leaves remotePushAccepted unset on non-2xx failure", async () => {
+    fetchResponses.push({ ok: false, status: 400, body: "bad request" });
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(false);
+    expect(result.remotePushAccepted).toBeUndefined();
+  });
+
+  test("leaves remotePushAccepted unset when the platform client is unavailable", async () => {
+    clientAvailable = false;
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(false);
+    expect(result.remotePushAccepted).toBeUndefined();
+  });
+
   test("omits optional fields when absent from payload", async () => {
     const adapter = new PlatformPushAdapter();
     const payload: ChannelDeliveryPayload = {

package/src/__tests__/notification-telegram-adapter.test.ts

@@ -27,6 +27,9 @@ mock.module("../messaging/providers/telegram-bot/send.js", () => ({
       text,
       approval: approval as (typeof sendCalls)[0]["approval"],
     });
+    // Mirror the real send result: the id of the sent message, which the
+    // adapter surfaces so the delivery row can address the card later.
+    return { lastMessageId: String(1000 + sendCalls.length) };
   },
   sendTelegramAttachments: async () => ({
     allFailed: false,
@@ -196,6 +199,9 @@ describe("TelegramAdapter", () => {
     const result = await adapter.send(payload, makeDestination());
 
     expect(result.success).toBe(true);
+    // The sent message's channel-native id is surfaced so the delivery row
+    // can address the card for in-place withdrawal later.
+    expect(result.messageId).toBe("1001");
     expect(sendCalls).toHaveLength(1);
 
     const call = sendCalls[0]!;

package/src/__tests__/notification-vellum-adapter.test.ts

@@ -111,3 +111,48 @@ describe("VellumAdapter silent flag", () => {
     expect(intent.silent).toBe(false);
   });
 });
+
+describe("VellumAdapter remotePushDispatched pass-through", () => {
+  test("broadcasts remote push acceptance fields verbatim", async () => {
+    const { adapter, sent } = captureBroadcast();
+    await adapter.send(
+      makePayload({
+        remotePushDispatched: true,
+        remotePushPlatforms: ["ios"],
+      }),
+      makeDestination(),
+    );
+
+    const intent = sent[0] as Extract<
+      AssistantEvent,
+      { type: "notification_intent" }
+    >;
+    expect(intent.remotePushDispatched).toBe(true);
+    expect(intent.remotePushPlatforms).toEqual(["ios"]);
+  });
+
+  test("broadcasts remotePushDispatched: false verbatim", async () => {
+    const { adapter, sent } = captureBroadcast();
+    await adapter.send(
+      makePayload({ remotePushDispatched: false }),
+      makeDestination(),
+    );
+
+    const intent = sent[0] as Extract<
+      AssistantEvent,
+      { type: "notification_intent" }
+    >;
+    expect(intent.remotePushDispatched).toBe(false);
+  });
+
+  test("leaves remotePushDispatched undefined when absent from the payload", async () => {
+    const { adapter, sent } = captureBroadcast();
+    await adapter.send(makePayload(), makeDestination());
+
+    const intent = sent[0] as Extract<
+      AssistantEvent,
+      { type: "notification_intent" }
+    >;
+    expect(intent.remotePushDispatched).toBeUndefined();
+  });
+});

package/src/__tests__/plugin-api-model-profiles.test.ts

@@ -64,6 +64,7 @@ describe("getModelProfiles", () => {
       "balanced",
       "cost-optimized",
       "alpha",
+      "latency-optimized",
       "quality-optimized",
       "zeta",
     ]);
@@ -95,6 +96,7 @@ describe("getModelProfiles", () => {
       ["blend", true],
       ["balanced", false],
       ["cost-optimized", false],
+      ["latency-optimized", false],
       ["quality-optimized", false],
     ]);
   });
@@ -144,6 +146,7 @@ describe("getModelProfiles", () => {
       ["beta", true],
       ["balanced", false],
       ["cost-optimized", false],
+      ["latency-optimized", false],
       ["quality-optimized", false],
     ]);
   });
@@ -188,6 +191,7 @@ describe("getModelProfiles", () => {
       ["beta", true],
       ["balanced", false],
       ["cost-optimized", false],
+      ["latency-optimized", false],
       ["quality-optimized", false],
     ]);
   });
@@ -224,6 +228,11 @@ describe("getModelProfiles", () => {
       getModelProfiles()
         .map((p) => p.key)
         .sort(),
-    ).toEqual(["balanced", "cost-optimized", "quality-optimized"]);
+    ).toEqual([
+      "balanced",
+      "cost-optimized",
+      "latency-optimized",
+      "quality-optimized",
+    ]);
   });
 });

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -125,6 +125,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../daemon/turn-latency-sub-spans.js",
     "../../../../notifications/emit-signal.js",
     "../../../../persistence/checkpoints.js",
+    "../../../../persistence/conversation-types.js",
     "../../../../persistence/db-connection.js",
     "../../../../persistence/embeddings/embed.js",
     "../../../../persistence/embeddings/embedding-backend.js",
@@ -183,6 +184,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../persistence/checkpoints.js",
     "../../../persistence/cleanup-schedule-state.js",
     "../../../persistence/conversation-crud.js",
+    "../../../persistence/conversation-types.js",
     "../../../persistence/db-connection.js",
     "../../../persistence/db-maintenance.js",
     "../../../persistence/embeddings/embedding-backend.js",
@@ -222,6 +224,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../util/sqlite-retry.js",
     "../../../util/strip-comment-lines.js",
     "../../../util/truncate.js",
+    "../../../util/worker-compute.js",
     "../../../util/worker-memory.js",
     "../../../util/worker-process.js",
     "../../types.js",