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

package/src/daemon/conversation-surfaces.ts

@@ -1,5 +1,9 @@
+import * as Sentry from "@sentry/node";
 import { v4 as uuid } from "uuid";
+import { z } from "zod";
 
+import { SurfaceActionSchema } from "../api/events/ui-surface-show.js";
+import { CardSurfaceDataSchema } from "../api/surfaces.js";
 import { isActivationSession } from "../memory/activation-session-store.js";
 import {
   addAppConversationId,
@@ -70,6 +74,16 @@ import type { TrustContext } from "./trust-context.js";
 
 const log = getLogger("conversation-surfaces");
 
+// Tolerant variant of SurfaceActionSchema for parsing raw model output.
+// The canonical schema rejects unknown style values; this one coerces them
+// to "secondary" so a single mistyped style doesn't drop all actions.
+const ModelActionSchema = SurfaceActionSchema.extend({
+  style: z
+    .enum(["primary", "secondary", "destructive"])
+    .catch("secondary")
+    .optional(),
+});
+
 const MAX_UNDO_DEPTH = 10;
 
 /**
@@ -472,6 +486,27 @@ function normalizeDynamicPageShowData(
   return normalized as unknown as DynamicPageSurfaceData;
 }
 
+/** First entry that is a non-empty (trimmed) string, else undefined. */
+function firstNonEmptyString(values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+/** All non-empty (trimmed) strings from the values list. */
+function allNonEmptyStrings(values: unknown[]): string[] {
+  const result: string[] = [];
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
 function normalizeCardShowData(
   input: Record<string, unknown>,
   rawData: Record<string, unknown>,
@@ -507,6 +542,113 @@ function normalizeCardShowData(
     normalized.body = input.body;
   }
 
+  // The model sees every surface type's schema in the ui_show tool description,
+  // so it frequently borrows keys from sibling surfaces when emitting a card.
+  // Recover those into the canonical card fields, checking both data-level and
+  // top-level (input) placement. Multiple matches are concatenated (body) or
+  // first-wins (title/subtitle); all alias keys are deleted afterward so they
+  // don't appear as droppedKeys noise.
+  //
+  // body aliases: copy_block's `text`, confirmation's `message`, generic
+  // `content`, and cross-surface `description` (choice/form/oauth/work_result/
+  // dynamic_page — 5 types use it), work_result's `summary`, confirmation's
+  // `detail`.
+  const bodyAliasKeys = [
+    "text",
+    "message",
+    "content",
+    "description",
+    "summary",
+    "detail",
+  ] as const;
+  if (typeof normalized.body !== "string" || normalized.body.trim() === "") {
+    const candidates = allNonEmptyStrings(
+      bodyAliasKeys.map((k) => {
+        const dataVal = normalized[k];
+        if (typeof dataVal === "string" && dataVal.trim().length > 0)
+          return dataVal;
+        return input[k];
+      }),
+    );
+    if (candidates.length > 0) {
+      // Temporary: concatenate all matching aliases so no content is lost.
+      // A future pass should define per-alias semantic roles (e.g. summary
+      // as a subtitle, detail as supplementary) once production telemetry
+      // reveals which combinations actually occur.
+      normalized.body = candidates.join("\n\n");
+      const usedAliases = bodyAliasKeys.filter(
+        (k) =>
+          (typeof normalized[k] === "string" &&
+            (normalized[k] as string).trim().length > 0) ||
+          (typeof input[k] === "string" &&
+            (input[k] as string).trim().length > 0),
+      );
+      Sentry.addBreadcrumb({
+        category: "card-normalization",
+        message: `alias recovery: ${usedAliases.join(", ")} → body`,
+        level: "info",
+        data: { usedAliases, candidateCount: candidates.length },
+      });
+    }
+  }
+  for (const key of bodyAliasKeys) {
+    delete normalized[key];
+  }
+
+  // title aliases: natural synonyms the model reaches for when it doesn't
+  // use `title` verbatim.
+  const titleAliasKeys = ["heading", "header", "name"] as const;
+  if (typeof normalized.title !== "string" || normalized.title.trim() === "") {
+    const aliased = firstNonEmptyString([
+      ...titleAliasKeys.map((k) => normalized[k]),
+      ...titleAliasKeys.map((k) => input[k]),
+    ]);
+    if (aliased !== undefined) {
+      normalized.title = aliased;
+      Sentry.addBreadcrumb({
+        category: "card-normalization",
+        message: `alias recovery: title`,
+        level: "info",
+      });
+    }
+  }
+  for (const key of titleAliasKeys) {
+    delete normalized[key];
+  }
+
+  // subtitle aliases: table's `caption`, natural synonym `subheading`.
+  if (
+    typeof normalized.subtitle !== "string" &&
+    typeof input.subtitle === "string"
+  ) {
+    normalized.subtitle = input.subtitle;
+  }
+  const subtitleAliasKeys = ["subheading", "caption"] as const;
+  if (
+    typeof normalized.subtitle !== "string" ||
+    normalized.subtitle.trim() === ""
+  ) {
+    const aliased = firstNonEmptyString([
+      ...subtitleAliasKeys.map((k) => normalized[k]),
+      ...subtitleAliasKeys.map((k) => input[k]),
+    ]);
+    if (aliased !== undefined) {
+      normalized.subtitle = aliased;
+      Sentry.addBreadcrumb({
+        category: "card-normalization",
+        message: `alias recovery: subtitle`,
+        level: "info",
+      });
+    }
+  }
+  for (const key of subtitleAliasKeys) {
+    delete normalized[key];
+  }
+
+  if (!Array.isArray(normalized.metadata) && Array.isArray(input.metadata)) {
+    normalized.metadata = input.metadata;
+  }
+
   // task_progress cards: additional fallbacks for title from templateData.
   if (
     normalized.template === "task_progress" &&
@@ -533,7 +675,40 @@ function normalizeCardShowData(
     ensureTaskProgressTemplateData(normalized);
   }
 
-  return normalized as unknown as CardSurfaceData;
+  // Parse, don't assert. The old `as unknown as CardSurfaceData` accepted any
+  // shape, so anything the model nested under an unmodelled key was carried
+  // through unread. Parsing draws the boundary; the dropped-key log surfaces
+  // the shapes we still don't recover, so the recovery list above can grow from
+  // real traffic rather than guesswork.
+  const droppedKeys = Object.keys(normalized).filter(
+    (key) => !(key in CardSurfaceDataSchema.shape),
+  );
+  if (droppedKeys.length > 0) {
+    log.warn(
+      { droppedKeys },
+      "ui_show card data carried keys the card contract does not model; their content will not render",
+    );
+    Sentry.addBreadcrumb({
+      category: "card-normalization",
+      message: `dropped keys: ${droppedKeys.join(", ")}`,
+      level: "warning",
+      data: { droppedKeys },
+    });
+  }
+  const parsed = CardSurfaceDataSchema.safeParse(normalized);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  log.warn(
+    { issues: parsed.error.issues },
+    "ui_show card data failed CardSurfaceDataSchema; rendering only the fields that validated",
+  );
+  return CardSurfaceDataSchema.parse({
+    title: typeof normalized.title === "string" ? normalized.title : undefined,
+    subtitle:
+      typeof normalized.subtitle === "string" ? normalized.subtitle : undefined,
+    body: typeof normalized.body === "string" ? normalized.body : undefined,
+  });
 }
 
 function normalizeTaskProgressCardPatch(
@@ -2693,9 +2868,17 @@ export async function surfaceProxyResolver(
     const surfaceType = input.surface_type as SurfaceType;
     const title = typeof input.title === "string" ? input.title : undefined;
     const rawData = isPlainObject(input.data) ? input.data : {};
-    const data = (
+    // Each surface type that has a canonical Zod schema gets parsed through it;
+    // the rest pass through raw until migrated (LUM-2134 scope). The per-type
+    // normalizers validate+recover; the union cast at the end is only for the
+    // unmigrated branches that still return hand-written interfaces.
+    const cardData =
       surfaceType === "card"
         ? normalizeCardShowData(input, rawData)
+        : undefined;
+    const data: SurfaceData =
+      cardData !== undefined
+        ? cardData
         : surfaceType === "choice"
           ? normalizeChoiceShowData(rawData)
           : surfaceType === "copy_block"
@@ -2704,21 +2887,43 @@ export async function surfaceProxyResolver(
               ? normalizeOAuthConnectShowData(rawData)
               : surfaceType === "dynamic_page"
                 ? normalizeDynamicPageShowData(input, rawData)
-                : rawData
-    ) as SurfaceData;
-    const inputActions = input.actions as
-      | Array<{
-          id: string;
-          label: string;
-          style?: string;
-          data?: Record<string, unknown>;
-        }>
-      | undefined;
+                : (rawData as SurfaceData);
+    // Parse actions through the schema instead of typecasting raw model output.
+    // The model may place actions inside `data` instead of the top-level
+    // `actions` param — recover them so they aren't silently dropped.
+    const rawActions = Array.isArray(input.actions)
+      ? input.actions
+      : Array.isArray(rawData.actions)
+        ? rawData.actions
+        : undefined;
+    let inputActions: z.infer<typeof ModelActionSchema>[] | undefined;
+    if (rawActions) {
+      const valid: z.infer<typeof ModelActionSchema>[] = [];
+      for (const raw of rawActions) {
+        const result = ModelActionSchema.safeParse(raw);
+        if (result.success) {
+          valid.push(result.data);
+        } else {
+          Sentry.addBreadcrumb({
+            category: "card-normalization",
+            message: "action parse failure (individual)",
+            level: "warning",
+            data: {
+              issuePaths: result.error.issues.map((i) => i.path.join(".")),
+              keys:
+                typeof raw === "object" && raw !== null
+                  ? Object.keys(raw)
+                  : [typeof raw],
+            },
+          });
+        }
+      }
+      inputActions = valid.length > 0 ? valid : undefined;
+    }
     const actions =
       surfaceType === "choice"
         ? buildChoiceActions(data as ChoiceSurfaceData)
         : inputActions;
-    // Interactive surfaces default to awaiting user action.
     const hasActions = Array.isArray(actions) && actions.length > 0;
     if (surfaceType === "choice" && !hasActions) {
       return {
@@ -2727,6 +2932,39 @@ export async function surfaceProxyResolver(
         isError: true,
       };
     }
+    if (cardData !== undefined) {
+      const hasTitle =
+        (typeof title === "string" && title.trim().length > 0) ||
+        (typeof cardData.title === "string" &&
+          cardData.title.trim().length > 0);
+      const hasBody =
+        typeof cardData.body === "string" && cardData.body.trim().length > 0;
+      const hasSubtitle =
+        typeof cardData.subtitle === "string" &&
+        cardData.subtitle.trim().length > 0;
+      const hasMetadata =
+        Array.isArray(cardData.metadata) && cardData.metadata.length > 0;
+      const hasTemplate = typeof cardData.template === "string";
+      if (
+        !hasTitle &&
+        !hasBody &&
+        !hasSubtitle &&
+        !hasMetadata &&
+        !hasTemplate &&
+        !hasActions
+      ) {
+        Sentry.addBreadcrumb({
+          category: "card-normalization",
+          message: "empty card rejected",
+          level: "warning",
+        });
+        return {
+          content:
+            "Error: ui_show card requires content — provide `data.body`, a `template` (e.g. task_progress with steps), `data.metadata`, `data.subtitle`, a `title`, or `actions`. The surface was not displayed because it carried no renderable content. Resend ui_show with populated card content.",
+          isError: true,
+        };
+      }
+    }
     const oauthProviderKey =
       surfaceType === "oauth_connect"
         ? (data as unknown as Record<string, unknown>).providerKey
@@ -2741,6 +2979,7 @@ export async function surfaceProxyResolver(
         isError: true,
       };
     }
+
     const isInteractive =
       surfaceType === "card"
         ? hasActions
@@ -2777,10 +3016,7 @@ export async function surfaceProxyResolver(
     const mappedActions = actions?.map((a) => ({
       id: a.id,
       label: a.label,
-      style: (a.style ?? "secondary") as
-        | "primary"
-        | "secondary"
-        | "destructive",
+      style: a.style ?? "secondary",
       ...(a.data ? { data: a.data } : {}),
     }));
 
@@ -2896,7 +3132,26 @@ export async function surfaceProxyResolver(
         const currentHtml = (stored.data as DynamicPageSurfaceData).html;
         pushUndoState(ctx.surfaceUndoStacks, surfaceId, currentHtml);
       }
-      mergedData = { ...stored.data, ...patch } as SurfaceData;
+      const rawMerged = { ...stored.data, ...patch };
+      if (stored.surfaceType === "card") {
+        // Validate the merged card data through the canonical schema so
+        // malformed patches (e.g. metadata as a string) are caught here
+        // instead of crashing the client's safeParse.
+        const parsed = CardSurfaceDataSchema.safeParse(rawMerged);
+        mergedData = parsed.success
+          ? parsed.data
+          : (CardSurfaceDataSchema.safeParse(stored.data).data ?? {});
+        if (!parsed.success) {
+          log.warn(
+            { surfaceId, issues: parsed.error.issues },
+            "ui_update card patch produced invalid merged data; reverting to stored data",
+          );
+        }
+      } else {
+        // Other surface types lack canonical Zod schemas (LUM-2134 scope).
+        // The raw merge is the best we can do until they're migrated.
+        mergedData = rawMerged as SurfaceData;
+      }
       stored.data = mergedData;
     } else {
       mergedData = patch as unknown as SurfaceData;

package/src/daemon/message-types/surfaces.ts

@@ -1,6 +1,16 @@
 // Surface types, UI surface lifecycle messages.
 
-import { z } from "zod";
+import {
+  type CardSurfaceData,
+  CardSurfaceDataSchema,
+} from "../../api/surfaces.js";
+
+// Surface `data` shapes are wire payloads owned by `@vellumai/assistant-api`.
+// Card is migrated (canonical Zod schema); the remaining types below are still
+// hand-written interfaces pending migration. Re-exported so the daemon's
+// surface protocol barrel (`message-protocol.ts`) keeps surfacing them to
+// daemon consumers under their canonical names.
+export { type CardSurfaceData, CardSurfaceDataSchema };
 
 // === Surface type definitions ===
 
@@ -37,25 +47,6 @@ export interface SurfaceAction {
   data?: Record<string, unknown>;
 }
 
-/**
- * Card surface data. Defined as a Zod schema so the type is derived (not
- * hand-maintained) and the seed-content-block schema can compose it directly
- * instead of treating card `data` as an opaque record.
- */
-export const CardSurfaceDataSchema = z.object({
-  title: z.string(),
-  subtitle: z.string().optional(),
-  body: z.string(),
-  metadata: z
-    .array(z.object({ label: z.string(), value: z.string() }))
-    .optional(),
-  /** Optional template name for specialized rendering (e.g. "weather_forecast"). */
-  template: z.string().optional(),
-  /** Arbitrary data consumed by the template renderer. Shape depends on template. */
-  templateData: z.record(z.string(), z.unknown()).optional(),
-});
-export type CardSurfaceData = z.infer<typeof CardSurfaceDataSchema>;
-
 export interface ChoiceOption {
   id: string;
   title: string;

package/src/memory/embedding-gemini.ts

@@ -40,7 +40,7 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     this.taskType = options?.taskType;
     this.dimensions = options?.dimensions;
     this.managedBaseUrl = options?.managedBaseUrl;
-    this.interCallDelayMs = options?.interCallDelayMs ?? 5000;
+    this.interCallDelayMs = options?.interCallDelayMs ?? 100;
   }
 
   /** True when requests route through the managed platform proxy. */

package/src/providers/anthropic/client.ts

@@ -835,6 +835,11 @@ export class AnthropicProvider implements Provider {
         disableCache: _disableCache,
         max_tokens: callerMaxTokens,
         usageAttributionHeaders,
+        // Pulled out of `restConfig` so they are forwarded conditionally below:
+        // newer models reject them outright (see `deprecatesSamplingParams`).
+        temperature: callerTemperature,
+        top_p: callerTopP,
+        top_k: callerTopK,
         ...restConfig
       } = (config ?? {}) as Record<string, unknown> & {
         // "xhigh" is an intermediate tier between "high" and "max" supported
@@ -847,6 +852,9 @@ export class AnthropicProvider implements Provider {
         speed?: "standard" | "fast";
         output_config?: Record<string, unknown>;
         usageAttributionHeaders?: Record<string, string>;
+        temperature?: number;
+        top_p?: number;
+        top_k?: number;
       };
       // Haiku does not support the effort / output_config parameter or
       // extended cache TTL betas.
@@ -856,6 +864,16 @@ export class AnthropicProvider implements Provider {
         (restConfig as Record<string, unknown>).model?.toString() ?? this.model;
       const isHaiku = effectiveModel.includes("haiku");
       const supportsEffort = !isHaiku;
+      // opus-4-7 / opus-4-8 reject `temperature` and `top_p` with a 400
+      // "`temperature`/`top_p` is deprecated for this model" — model-wide, not
+      // effort-conditional (verified 2026-06-23). opus-4-6 / sonnet-4-6 /
+      // haiku-4-5 still accept them. fable-5 is included conservatively (a
+      // frontier model that could not be verified directly but follows the same
+      // deprecation direction). Stripping the params here keeps callers that set
+      // them (e.g. the memory-v3 L2 selector's `temperature: 0`) from 400ing.
+      const deprecatesSamplingParams =
+        /claude-opus-4-[78]\b/.test(effectiveModel) ||
+        effectiveModel.startsWith("claude-fable-");
       const mergedOutputConfig = {
         ...(output_config ?? {}),
         ...(effort && effort !== "none" && supportsEffort
@@ -883,6 +901,19 @@ export class AnthropicProvider implements Provider {
             : 64000,
         messages: sentMessages,
         ...restConfig,
+        // Forward `temperature` / `top_p` / `top_k` only to models that still
+        // accept them; newer models 400 on any of the deprecated sampler params.
+        // `temperature: 0` is preserved for accepting models (a `typeof ===
+        // "number"` check, not truthiness).
+        ...(deprecatesSamplingParams
+          ? {}
+          : {
+              ...(typeof callerTemperature === "number"
+                ? { temperature: callerTemperature }
+                : {}),
+              ...(typeof callerTopP === "number" ? { top_p: callerTopP } : {}),
+              ...(typeof callerTopK === "number" ? { top_k: callerTopK } : {}),
+            }),
         ...(Object.keys(mergedOutputConfig).length > 0
           ? { output_config: mergedOutputConfig }
           : {}),

package/src/tools/ui-surface/definitions.ts

@@ -45,14 +45,6 @@ function proxyExecute(toolName: string) {
       };
     }
 
-    if (toolName === "ui_show" && isEmptyCard(input)) {
-      return {
-        content:
-          "Error: ui_show card requires content — provide `data.body`, a `template` (e.g. task_progress with steps), `data.metadata`, or `actions`. The surface was not displayed because it carried only a title, which renders as a blank box. Resend ui_show with populated card content.",
-        isError: true,
-      };
-    }
-
     if (toolName === "ui_show" && isDynamicPageAppSubstitute(input)) {
       return {
         content:
@@ -168,41 +160,6 @@ function isEmptyDynamicPage(input: Record<string, unknown>): boolean {
   return typeof html !== "string" || html.trim().length === 0;
 }
 
-/**
- * A `card` ui_show carrying no renderable content — only a title (or nothing)
- * — renders as a blank bordered box. A declared `template` (task_progress,
- * weather_forecast, …) renders its own shell, and `body`/`subtitle`/`metadata`/
- * `actions` are real content; any of those passes. The model places these
- * either nested in `data` or at the top level, so both are checked. Title is
- * intentionally not content: a title-only card is the blank box.
- */
-function isEmptyCard(input: Record<string, unknown>): boolean {
-  if (input.surface_type !== "card") {
-    return false;
-  }
-  const data = asRecord(input.data) ?? {};
-
-  const template =
-    nonEmptyString(input.template) ?? nonEmptyString(data.template);
-  if (template) {
-    return false;
-  }
-
-  const hasBody = !!(nonEmptyString(input.body) ?? nonEmptyString(data.body));
-  const hasSubtitle = !!nonEmptyString(data.subtitle);
-  const hasMetadata = Array.isArray(data.metadata) && data.metadata.length > 0;
-  const actions = input.actions ?? data.actions;
-  const hasActions = Array.isArray(actions) && actions.length > 0;
-
-  return !(hasBody || hasSubtitle || hasMetadata || hasActions);
-}
-
-function nonEmptyString(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim().length > 0
-    ? value
-    : undefined;
-}
-
 function isDynamicPageAppSubstitute(input: Record<string, unknown>): boolean {
   if (input.surface_type !== "dynamic_page") {
     return false;