@vellumai/assistant 0.10.1-staging.2 → 0.10.1-staging.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.1-staging.2",
+  "version": "0.10.1-staging.4",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/anthropic-provider.test.ts

@@ -3191,3 +3191,70 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
     expect(signatures).toContain("sig-step2");
   });
 });
+
+describe("AnthropicProvider — deprecated sampling params (temperature / top_p / top_k)", () => {
+  beforeEach(() => {
+    lastStreamParams = null;
+  });
+
+  // opus-4-7 / opus-4-8 (and, conservatively, fable) reject `temperature`,
+  // `top_p`, and `top_k` with a 400; the provider must strip all three.
+  for (const model of [
+    "claude-opus-4-8",
+    "claude-opus-4-7",
+    "claude-fable-5",
+  ]) {
+    test(`strips temperature, top_p, and top_k for ${model}`, async () => {
+      const provider = new AnthropicProvider("sk-ant-test", model);
+      await provider.sendMessage([userMsg("Hi")], {
+        systemPrompt: "You are helpful.",
+        config: { temperature: 0, top_p: 0.95, top_k: 40 },
+      });
+      expect(lastStreamParams!).not.toHaveProperty("temperature");
+      expect(lastStreamParams!).not.toHaveProperty("top_p");
+      expect(lastStreamParams!).not.toHaveProperty("top_k");
+    });
+  }
+
+  // opus-4-6 / sonnet-4-6 still accept the params — they must pass through,
+  // including `temperature: 0` (a value check, not truthiness).
+  test("forwards temperature (including 0), top_p, and top_k for opus-4-6", async () => {
+    const provider = new AnthropicProvider("sk-ant-test", "claude-opus-4-6");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+      config: { temperature: 0, top_p: 0.95, top_k: 40 },
+    });
+    expect(lastStreamParams!.temperature).toBe(0);
+    expect(lastStreamParams!.top_p).toBe(0.95);
+    expect(lastStreamParams!.top_k).toBe(40);
+  });
+
+  test("forwards temperature, top_p, and top_k for sonnet-4-6", async () => {
+    const provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+      config: { temperature: 0.7, top_p: 0.9, top_k: 20 },
+    });
+    expect(lastStreamParams!.temperature).toBe(0.7);
+    expect(lastStreamParams!.top_p).toBe(0.9);
+    expect(lastStreamParams!.top_k).toBe(20);
+  });
+
+  // A per-call model override targeting a deprecating model must win over the
+  // provider's default (accepting) model.
+  test("strips params when a per-call model override deprecates them", async () => {
+    const provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+      config: {
+        temperature: 0,
+        top_p: 0.95,
+        top_k: 40,
+        model: "claude-opus-4-8",
+      },
+    });
+    expect(lastStreamParams!).not.toHaveProperty("temperature");
+    expect(lastStreamParams!).not.toHaveProperty("top_p");
+    expect(lastStreamParams!).not.toHaveProperty("top_k");
+  });
+});

package/src/__tests__/card-surface-data.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+
+import { CardSurfaceDataSchema } from "../api/surfaces.js";
+
+// The wire keeps surface `data` opaque and the stream drops events that fail to
+// parse, so the canonical card schema must never reject a real payload: every
+// field is optional and unknown keys are stripped. The daemon's `ui_show`
+// normalizer parses against this schema and logs the stripped keys — that is
+// how unsupported shapes are surfaced rather than silently swallowed.
+describe("CardSurfaceDataSchema", () => {
+  test("parses an empty object", () => {
+    expect(CardSurfaceDataSchema.safeParse({}).success).toBe(true);
+  });
+
+  test("parses a title-less card and strips unknown keys", () => {
+    const parsed = CardSurfaceDataSchema.safeParse({
+      body: "hi",
+      surfaceWidgetHint: "ignored",
+    });
+    expect(parsed.success).toBe(true);
+    if (parsed.success) {
+      expect(parsed.data).toEqual({ body: "hi" });
+    }
+  });
+
+  test("a body-less, title-only card is still valid (renders its title)", () => {
+    expect(CardSurfaceDataSchema.safeParse({ title: "Heads up" }).success).toBe(
+      true,
+    );
+  });
+
+  test("coerces primitive metadata values to strings", () => {
+    const parsed = CardSurfaceDataSchema.safeParse({
+      metadata: [
+        { label: "Docs", value: 12 },
+        { label: "Passed", value: true },
+        { label: "Status", value: "OK" },
+      ],
+    });
+    expect(parsed.success).toBe(true);
+    if (parsed.success) {
+      expect(parsed.data.metadata).toEqual([
+        { label: "Docs", value: "12" },
+        { label: "Passed", value: "true" },
+        { label: "Status", value: "OK" },
+      ]);
+    }
+  });
+
+  test("the schema's keys define what the normalizer supports", () => {
+    expect(Object.keys(CardSurfaceDataSchema.shape).sort()).toEqual([
+      "body",
+      "metadata",
+      "subtitle",
+      "template",
+      "templateData",
+      "title",
+    ]);
+  });
+});

package/src/__tests__/conversation-surfaces-activation-emit.test.ts

@@ -184,7 +184,7 @@ describe("activation moment emission from ui_show surface commits", () => {
     await surfaceProxyResolver(ctx, "ui_show", {
       surface_type: "card",
       title: "Inbox cleaned",
-      data: { text: "Archived 1,240 emails" },
+      data: { body: "Archived 1,240 emails" },
       activation_moment: "first_wow_executed",
     });
 
@@ -210,7 +210,7 @@ describe("activation moment emission from ui_show surface commits", () => {
     await surfaceProxyResolver(ctx, "ui_show", {
       surface_type: "card",
       title: "Result",
-      data: { text: "x" },
+      data: { body: "x" },
       activation_moment: "first_wow_executed",
     });
     expect(queryUnreportedOnboardingEvents(0, undefined, 10)).toHaveLength(0);
@@ -283,7 +283,7 @@ describe("activation moment emission from ui_show surface commits", () => {
     await surfaceProxyResolver(ctx, "ui_show", {
       surface_type: "card",
       title: "Start something",
-      data: { text: "Kick off a draft" },
+      data: { body: "Kick off a draft" },
       actions: [{ id: "go", label: "Go", style: "primary" }],
       activation_moment: "moment_1",
     });

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -576,3 +576,355 @@ describe("task_progress surface compatibility", () => {
     expect(sent.some((m) => m.type === "ui_surface_show")).toBe(true);
   });
 });
+
+describe("ui_show card content recovery", () => {
+  function shownCard(sent: ServerMessage[]): CardSurfaceData | undefined {
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    );
+    if (!show || show.surfaceType !== "card") return undefined;
+    return show.data;
+  }
+
+  test("recovers body from a copy_block-style `text` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Inbox cleaned",
+      data: { text: "Archived 1,240 emails" },
+    });
+
+    expect(result.isError).toBe(false);
+    const card = shownCard(sent);
+    expect(card?.body).toBe("Archived 1,240 emails");
+    // The alias key is not a card field; it must not survive on the surface.
+    expect((card as Record<string, unknown>).text).toBeUndefined();
+  });
+
+  test("recovers body from a confirmation-style `message` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Heads up", message: "The server will restart." },
+    });
+
+    expect(shownCard(sent)?.body).toBe("The server will restart.");
+  });
+
+  test("recovers top-level subtitle and metadata into the card", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      subtitle: "saved just now",
+      metadata: [{ label: "Total", value: "$10" }],
+      data: { body: "Done" },
+    });
+
+    const card = shownCard(sent);
+    expect(card?.subtitle).toBe("saved just now");
+    expect(card?.metadata).toEqual([{ label: "Total", value: "$10" }]);
+  });
+
+  test("title-only card with actions renders with actions intact", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Restart the server?",
+      actions: [{ id: "yes", label: "Yes" }],
+      data: {},
+    });
+
+    expect(result.isError).toBe(false);
+    expect(shownCard(sent)?.title).toBe("Restart the server?");
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions).toBeDefined();
+    expect(show.actions!.length).toBe(1);
+    expect(show.actions![0].label).toBe("Yes");
+  });
+
+  test("title-only card without actions renders without error", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Status update",
+      data: {},
+    });
+
+    expect(result.isError).toBe(false);
+    expect(shownCard(sent)?.title).toBe("Status update");
+  });
+
+  test("card with body and actions is interactive", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Confirm",
+      actions: [{ id: "ok", label: "OK" }],
+      data: { body: "Are you sure?" },
+    });
+
+    expect(result.isError).toBe(false);
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions).toBeDefined();
+    expect(show.actions!.length).toBe(1);
+  });
+
+  // ── Body alias recovery from cross-surface keys ────────────────────
+
+  test("recovers body from choice/form-style `description` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Search results",
+      data: { description: "Found 12 matching documents." },
+    });
+
+    const card = shownCard(sent);
+    expect(card?.body).toBe("Found 12 matching documents.");
+    expect((card as Record<string, unknown>).description).toBeUndefined();
+  });
+
+  test("recovers body from work_result-style `summary` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Report", summary: "All tests passed." },
+    });
+
+    expect(shownCard(sent)?.body).toBe("All tests passed.");
+  });
+
+  test("recovers body from confirmation-style `detail` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Warning", detail: "This action cannot be undone." },
+    });
+
+    expect(shownCard(sent)?.body).toBe("This action cannot be undone.");
+  });
+
+  test("recovers body from top-level `description`", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Info",
+      description: "Top-level description text",
+      data: {},
+    });
+
+    expect(shownCard(sent)?.body).toBe("Top-level description text");
+  });
+
+  test("concatenates multiple body aliases when they co-occur", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Multi-alias",
+      data: {
+        description: "Found 12 documents.",
+        summary: "Search complete.",
+        detail: "Checked 3 sources.",
+      },
+    });
+
+    const body = shownCard(sent)?.body;
+    expect(body).toContain("Found 12 documents.");
+    expect(body).toContain("Search complete.");
+    expect(body).toContain("Checked 3 sources.");
+  });
+
+  // ── Title alias recovery ────────────────────────────────────────────
+
+  test("recovers title from `heading` alias", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { heading: "Results", body: "Done." },
+    });
+
+    expect(shownCard(sent)?.title).toBe("Results");
+  });
+
+  test("recovers title from `header` alias", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { header: "Status Update", body: "All good." },
+    });
+
+    expect(shownCard(sent)?.title).toBe("Status Update");
+  });
+
+  // ── Subtitle alias recovery ─────────────────────────────────────────
+
+  test("recovers subtitle from `subheading` alias", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Alert", body: "Check this.", subheading: "Important" },
+    });
+
+    expect(shownCard(sent)?.subtitle).toBe("Important");
+  });
+
+  test("recovers subtitle from table-style `caption` alias", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Table Summary", body: "Data below.", caption: "Q4 2024" },
+    });
+
+    expect(shownCard(sent)?.subtitle).toBe("Q4 2024");
+  });
+
+  // ── Alias precedence ───────────────────────────────────────────────
+
+  test("canonical `body` takes precedence over aliased `description`", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { body: "Real body", description: "Should be ignored" },
+    });
+
+    expect(shownCard(sent)?.body).toBe("Real body");
+  });
+
+  test("card with recovered `description` and actions keeps actions (has content)", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Confirm",
+      actions: [{ id: "ok", label: "OK" }],
+      data: { description: "Proceed with deployment?" },
+    });
+
+    expect(result.isError).toBe(false);
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions).toBeDefined();
+    expect(shownCard(sent)?.body).toBe("Proceed with deployment?");
+  });
+
+  test("recovers actions nested inside data when top-level actions is absent", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Confirm deployment",
+      data: {
+        body: "Deploy to production?",
+        actions: [{ id: "yes", label: "Yes" }],
+      },
+    });
+
+    expect(result.isError).toBe(false);
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions).toBeDefined();
+    expect(show.actions!.length).toBe(1);
+    expect(show.actions![0].label).toBe("Yes");
+  });
+
+  test("top-level actions take precedence over data.actions", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Confirm",
+      actions: [{ id: "top", label: "Top-level" }],
+      data: {
+        body: "Which actions?",
+        actions: [{ id: "nested", label: "Nested" }],
+      },
+    });
+
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions!.length).toBe(1);
+    expect(show.actions![0].label).toBe("Top-level");
+  });
+
+  test("genuinely empty card (no title, body, subtitle, metadata, template, or actions) is rejected", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: {},
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("requires content");
+    expect(sent.filter((m) => m.type === "ui_surface_show")).toHaveLength(0);
+  });
+
+  test("a card with a real body broadcasts unchanged", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Plain", body: "hi" },
+    });
+
+    expect(shownCard(sent)?.body).toBe("hi");
+  });
+
+  test("a task_progress card with empty data broadcasts (template renders a shell)", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      template: "task_progress",
+      templateData: { status: "in_progress", steps: [] },
+    });
+
+    expect(result.isError).toBe(false);
+    expect(shownCard(sent)?.template).toBe("task_progress");
+  });
+});

package/src/__tests__/dynamic-page-surface.test.ts

@@ -257,100 +257,6 @@ describe("ui_show dynamic_page app substitute guard", () => {
   });
 });
 
-describe("ui_show empty card guard", () => {
-  function makeCtx(onProxy: () => void) {
-    return {
-      conversationId: "conversation-123",
-      workingDir: "/tmp",
-      trustClass: "guardian" as const,
-      proxyToolResolver: async () => {
-        onProxy();
-        return { content: "proxied", isError: false };
-      },
-    };
-  }
-
-  test("rejects a card carrying only a title and does not proxy", async () => {
-    let proxied = false;
-    const result = await uiShowTool.execute(
-      {
-        surface_type: "card",
-        title: "Vellum Internal Usage app",
-        activity: "Showing progress",
-        data: {},
-      },
-      makeCtx(() => {
-        proxied = true;
-      }),
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("card requires content");
-    expect(proxied).toBe(false);
-  });
-
-  test("rejects a card with no content at all", async () => {
-    let proxied = false;
-    const result = await uiShowTool.execute(
-      { surface_type: "card", data: {} },
-      makeCtx(() => {
-        proxied = true;
-      }),
-    );
-
-    expect(result.isError).toBe(true);
-    expect(proxied).toBe(false);
-  });
-
-  test("allows a card with a body", async () => {
-    let proxied = false;
-    const result = await uiShowTool.execute(
-      { surface_type: "card", data: { title: "Plain", body: "hi" } },
-      makeCtx(() => {
-        proxied = true;
-      }),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(proxied).toBe(true);
-  });
-
-  test("allows a task_progress card with empty data (template renders a shell)", async () => {
-    let proxied = false;
-    const result = await uiShowTool.execute(
-      {
-        surface_type: "card",
-        template: "task_progress",
-        templateData: { status: "in_progress", steps: [] },
-      },
-      makeCtx(() => {
-        proxied = true;
-      }),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(proxied).toBe(true);
-  });
-
-  test("allows an action-only card", async () => {
-    let proxied = false;
-    const result = await uiShowTool.execute(
-      {
-        surface_type: "card",
-        title: "Confirm",
-        actions: [{ id: "ok", label: "OK" }],
-        data: {},
-      },
-      makeCtx(() => {
-        proxied = true;
-      }),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(proxied).toBe(true);
-  });
-});
-
 describe("ui_update empty payload guard", () => {
   function makeCtx(onProxy: () => void) {
     return {