@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

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/conversation-tool-setup.ts

@@ -17,6 +17,7 @@ import type { LLMCallSite } from "../config/schemas/llm.js";
 import { getBindingByConversation } from "../memory/external-conversation-store.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
+import { advisorEnabledForProfile } from "../plugins/defaults/advisor/advisor-gate.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
@@ -60,12 +61,6 @@ import { FALLBACK_TURN_TRUST, resolveTrustClass } from "./trust-context.js";
 
 const log = getLogger("conversation-tool-setup");
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
-import { AUTO_PROFILE_KEY } from "../config/seed-inference-profiles.js";
-import {
-  buildSwitchInferenceProfileToolDef,
-  SWITCH_INFERENCE_PROFILE_TOOL_NAME,
-} from "./switch-inference-profile-tool.js";
 import type {
   SubagentToolGateMode,
   ToolSetupContext,
@@ -92,8 +87,10 @@ export type {
  * agent's). The conversation id is threaded as the mix selection seed so
  * mix-profile arms match what the dispatch path actually ran.
  *
- * Returns `null` on any failure: attribution is telemetry-only and must
- * never break tool execution (or skill loads, which reuse this helper).
+ * Returns `null` on any failure: attribution must never break tool execution
+ * (or skill loads, which reuse this helper). Consumers read it best-effort —
+ * usage telemetry, and `subagent_spawn`, which inherits the resolved
+ * `appliedProfile` so a child defaults to the invoking turn's profile.
  */
 export function resolveConversationAttribution(
   ctx: Pick<
@@ -168,11 +165,11 @@ export function createToolExecutor(
       resolveToolInvocationAlias(name, input, ctx.allowedToolNames);
 
     // The execution-layer gate must run FIRST — before any interception or
-    // pre-execution side effect (switch_inference_profile profile switching,
-    // DoorDash step marking) — so a non-allowlisted tool can neither run nor
-    // mutate conversation state. `skill_execute` is dispatch indirection: it
-    // is gated on its resolved inner tool name inside the interception below,
-    // mirroring how wire mode gates the underlying tool, not the wrapper.
+    // pre-execution side effect (DoorDash step marking) — so a non-allowlisted
+    // tool can neither run nor mutate conversation state. `skill_execute` is
+    // dispatch indirection: it is gated on its resolved inner tool name inside
+    // the interception below, mirroring how wire mode gates the underlying
+    // tool, not the wrapper.
     if (executionName !== "skill_execute") {
       const rejection = rejectNonAllowlistedTool(executionName);
       if (rejection) return rejection;
@@ -241,7 +238,10 @@ export function createToolExecutor(
           });
         }
       },
-      isInteractive: !ctx.hasNoClient && !ctx.headlessLock,
+      isInteractive:
+        ctx.currentTurnIsNonInteractive !== undefined
+          ? !ctx.currentTurnIsNonInteractive
+          : !ctx.hasNoClient && !ctx.headlessLock,
       proxyToolResolver: (
         toolName: string,
         proxyInput: Record<string, unknown>,
@@ -269,36 +269,6 @@ export function createToolExecutor(
       },
     };
 
-    // Intercept switch_inference_profile: daemon-internal tool that lets the
-    // model self-select a different inference profile mid-turn. No permission
-    // checks — this is a control-flow signal, not a user-visible tool.
-    if (executionName === SWITCH_INFERENCE_PROFILE_TOOL_NAME) {
-      const profile =
-        typeof executionInput.profile === "string"
-          ? executionInput.profile
-          : "";
-      const config = getConfig();
-      const profileEntry = config.llm.profiles?.[profile];
-      if (!profileEntry) {
-        return {
-          content: `Profile "${profile}" not found. Available profiles: ${Object.keys(config.llm.profiles ?? {}).join(", ")}`,
-          isError: true,
-        };
-      }
-      if (profileEntry.status === "disabled") {
-        return {
-          content: `Profile "${profile}" is disabled.`,
-          isError: true,
-        };
-      }
-      ctx.toolRoutedProfile = profile;
-      const label = profileEntry.label ?? profile;
-      return {
-        content: `Switched to ${label} profile. Continue with your response.`,
-        isError: false,
-      };
-    }
-
     // Intercept skill_execute: extract the real tool name and input, then
     // route through the full executor pipeline so the underlying tool's
     // risk level, permission checks, hooks, and lifecycle events all fire
@@ -447,7 +417,7 @@ export interface SkillProjectionContext {
    * host tools into the LLM tool definitions.
    */
   readonly transportInterface?: InterfaceId;
-  /** Per-turn override profile, read by the switch_inference_profile tool injection. */
+  /** Per-turn override profile. */
   currentTurnOverrideProfile?: string;
   /**
    * Conversation id for `skill_loaded` telemetry. Absent (e.g. minimal test
@@ -597,6 +567,15 @@ export function isToolActiveForContext(
       return true;
     }
   }
+  if (name === "advisor") {
+    // Gated per chat-profile (`ProfileEntry.advisorEnabled`): when the resolved
+    // profile disables the advisor, omit the tool from the wire list so the
+    // model never sees a tool it can only no-op on. Resolves the profile the
+    // same way the advisor's execution-time guard does (the per-turn override,
+    // else the active profile). The wire list is fixed before PRE_MODEL_CALL
+    // hooks run, so later profile changes from hooks are not reflected here.
+    return advisorEnabledForProfile(ctx.currentTurnOverrideProfile ?? null);
+  }
   if (UI_SURFACE_TOOL_NAMES.has(name)) {
     if (
       channelCapabilities?.channel === "slack" &&
@@ -799,25 +778,6 @@ export function createResolveToolsCallback(
     ctx.allowedToolNames = turnAllowed;
     const baseDefs = injectActivityField(allBaseDefs, ACTIVITY_SKIP_SET);
 
-    const config = getConfig();
-    if (
-      isAssistantFeatureFlagEnabled("query-complexity-routing", config) &&
-      config.llm
-    ) {
-      const effectiveProfile =
-        ctx.currentTurnOverrideProfile ?? config.llm.activeProfile;
-      if (effectiveProfile === AUTO_PROFILE_KEY) {
-        const toolDef = buildSwitchInferenceProfileToolDef(
-          config.llm.profiles ?? {},
-          effectiveProfile,
-        );
-        if (toolDef) {
-          turnAllowed.add(SWITCH_INFERENCE_PROFILE_TOOL_NAME);
-          return [...baseDefs, toolDef];
-        }
-      }
-    }
-
     return baseDefs;
   };
 }