@vellumai/assistant 0.9.0-staging.1 → 0.9.0

package/src/runtime/routes/inbound-stages/background-dispatch.test.ts

@@ -85,7 +85,7 @@ mock.module("../../gateway-client.js", () => ({
   },
 }));
 
-mock.module("../channel-delivery-routes.js", () => ({
+mock.module("../../channel-reply-delivery.js", () => ({
   deliverReplyViaCallback: async (...args: unknown[]) => {
     const options = args[4] as
       | { messageId?: string; startFromSegment?: number; messageTs?: string }
@@ -296,7 +296,7 @@ describe("processChannelMessageInBackground — slack thread mapping", () => {
       },
     ]);
     expect(replyDeliveryCalls).toEqual([
-      { messageId: "assistant-msg-delivery-failure" },
+      { messageId: "assistant-msg-delivery-failure", startFromSegment: 0 },
     ]);
     expect(deliveryFailureEvents).toEqual(["evt-delivery-failure"]);
     expect(deliveredEvents).toEqual([]);
@@ -336,7 +336,7 @@ describe("processChannelMessageInBackground — slack thread mapping", () => {
       },
     ]);
     expect(replyDeliveryCalls).toEqual([
-      { messageId: "assistant-msg-fast-path" },
+      { messageId: "assistant-msg-fast-path", startFromSegment: 0 },
     ]);
     expect(deliveredEvents).toEqual(["evt-fast-path"]);
 
@@ -433,6 +433,7 @@ describe("processChannelMessageInBackground — slack thread mapping", () => {
     ]);
     expect(deliveredSegmentCounts).toEqual([
       { eventId: "evt-incremental-text", count: 1 },
+      { eventId: "evt-incremental-text", count: 1 },
     ]);
     expect(storedReplyMessageIds).toEqual([
       {
@@ -574,7 +575,7 @@ describe("processChannelMessageInBackground — slack thread mapping", () => {
         .filter(Boolean),
     ).toEqual([]);
     expect(replyDeliveryCalls).toEqual([
-      { messageId: "assistant-msg-channel-final" },
+      { messageId: "assistant-msg-channel-final", startFromSegment: 0 },
     ]);
     expect(deliveredEvents).toEqual(["evt-channel-final-delivery"]);
 
@@ -658,11 +659,12 @@ describe("processChannelMessageInBackground — slack thread mapping", () => {
         .filter(Boolean),
     ).toEqual(["First live response.", "Second live response."]);
     expect(replyDeliveryCalls).toEqual([
-      { messageId: "assistant-msg-live-failure-final" },
+      { messageId: "assistant-msg-live-failure-final", startFromSegment: 0 },
     ]);
     expect(deliveryFailureEvents).toEqual([]);
     expect(deliveredEvents).toEqual(["evt-live-failure-recovery"]);
     expect(deliveredSegmentCounts).toEqual([
+      { eventId: "evt-live-failure-recovery", count: 0 },
       { eventId: "evt-live-failure-recovery", count: 1 },
     ]);
 

package/src/runtime/routes/inbound-stages/background-dispatch.ts

@@ -14,16 +14,13 @@ import type { TrustContext } from "../../../daemon/trust-context.js";
 import {
   addSlackDmLiveDeliveredTextResponseIndex,
   getSlackDmLiveDeliveredTextResponseIndexes,
-  updateDeliveredSegmentCount,
 } from "../../../memory/delivery-channels.js";
 import {
   linkMessage,
   storeReplyMessageId,
 } from "../../../memory/delivery-crud.js";
 import {
-  markDeliveryDelivered,
   markProcessed,
-  recordDeliveryFailure,
   recordProcessingFailure,
 } from "../../../memory/delivery-status.js";
 import {
@@ -53,7 +50,7 @@ import {
   isSlackDeliveryCallbackUrl,
 } from "../../slack-dm-text-delivery.js";
 import { resolveRoutingState } from "../../trust-context-resolver.js";
-import { deliverReplyViaCallback } from "../channel-delivery-routes.js";
+import { finalizeEventDelivery } from "../channel-delivery-routes.js";
 import { deliverGeneratedApprovalPrompt } from "../guardian-approval-prompt.js";
 
 const log = getLogger("runtime-http");
@@ -326,32 +323,21 @@ export function processChannelMessageInBackground(
 
       if (replyCallbackUrl) {
         try {
-          if (slackDmTextDelivery) {
-            await slackDmTextDelivery.waitForPendingDeliveries();
-          }
-          const liveDeliveryResumeOptions =
-            slackDmTextDelivery?.getFinalDeliveryResumeOptions(replyMessageId);
-
-          await deliverReplyViaCallback(
+          await finalizeEventDelivery({
+            eventId,
             conversationId,
             externalChatId,
             replyCallbackUrl,
             assistantId,
-            {
-              messageId: replyMessageId,
-              sinceMessageId: userMessageId,
-              ...liveDeliveryResumeOptions,
-              onSegmentDelivered: (count) =>
-                updateDeliveredSegmentCount(eventId, count),
-            },
-          );
-          markDeliveryDelivered(eventId);
+            replyMessageId,
+            userMessageId,
+            slackDmTextDelivery,
+          });
         } catch (err) {
           log.error(
             { err, conversationId },
             "Background channel reply delivery failed",
           );
-          recordDeliveryFailure(eventId, err);
         }
       }
     } finally {

package/src/runtime/routes/inbound-stages/escalation-intercept.ts

@@ -34,7 +34,7 @@ export interface EscalationInterceptParams {
   eventId: string;
   content: string | undefined;
   attachmentIds: string[] | undefined;
-  sourceMetadata: Record<string, unknown> | undefined;
+  sourceMetadata: import("@vellumai/gateway-client").SourceMetadata | undefined;
   actorDisplayName: string | undefined;
   actorExternalId: string | undefined;
   actorUsername: string | undefined;
@@ -84,11 +84,11 @@ export function handleEscalationIntercept(
       { sourceChannel, channelId: resolvedMember.channel.id },
       "Ingress ACL: escalate policy but no guardian binding, denying",
     );
-    return ({
+    return {
       accepted: true,
       denied: true,
       reason: "escalate_no_guardian",
-    });
+    };
   }
 
   // Persist the raw payload so the decide handler can recover the original
@@ -159,9 +159,9 @@ export function handleEscalationIntercept(
     "Guardian escalation created — notification pipeline handles channel delivery",
   );
 
-  return ({
+  return {
     accepted: true,
     escalated: true,
     reason: "policy_escalate",
-  });
+  };
 }

package/src/runtime/routes/inbound-stages/guardian-activation-intercept.ts

@@ -32,7 +32,7 @@ export interface GuardianActivationInterceptParams {
   canonicalSenderId: string | null;
   actorDisplayName: string | undefined;
   actorUsername: string | undefined;
-  sourceMetadata: Record<string, unknown> | undefined;
+  sourceMetadata: import("@vellumai/gateway-client").SourceMetadata | undefined;
   replyCallbackUrl: string | undefined;
   assistantId: string;
   externalMessageId: string;
@@ -75,23 +75,14 @@ export async function handleGuardianActivationIntercept(
   } = params;
 
   // ── Extract commandIntent ──
-  const rawCommandIntent = sourceMetadata?.commandIntent;
-  const commandIntent =
-    rawCommandIntent &&
-    typeof rawCommandIntent === "object" &&
-    !Array.isArray(rawCommandIntent)
-      ? (rawCommandIntent as Record<string, unknown>)
-      : undefined;
+  const commandIntent = sourceMetadata?.commandIntent;
 
   // Only proceed for /start commands
   if (!commandIntent || commandIntent.type !== "start") return null;
 
   // If /start has a payload (e.g. gv_token, iv_token), let the existing
   // bootstrap/invite handlers deal with it.
-  if (
-    typeof commandIntent.payload === "string" &&
-    commandIntent.payload.length > 0
-  ) {
+  if (commandIntent.payload && commandIntent.payload.length > 0) {
     return null;
   }
 
@@ -110,7 +101,7 @@ export async function handleGuardianActivationIntercept(
   // Only checked here; marked as processed after successful session creation
   // so transient failures remain retryable.
   if (isAlreadyProcessed(externalMessageId)) {
-    return ({ accepted: true, guardianActivation: true });
+    return { accepted: true, guardianActivation: true };
   }
 
   // ── Idempotency: check for an existing active session from this sender ──
@@ -138,7 +129,7 @@ export async function handleGuardianActivationIntercept(
         });
       }
       markProcessed(externalMessageId);
-      return ({ accepted: true, guardianActivationPending: true });
+      return { accepted: true, guardianActivationPending: true };
     }
   }
 
@@ -193,5 +184,5 @@ export async function handleGuardianActivationIntercept(
     dedupeKey: `guardian-activation:${sessionResult.sessionId}`,
   });
 
-  return ({ accepted: true, guardianActivation: true });
+  return { accepted: true, guardianActivation: true };
 }

package/src/runtime/routes/inbound-stages/secret-ingress-check.ts

@@ -27,7 +27,7 @@ export interface SecretIngressCheckParams {
   content: string | undefined;
   trimmedContent: string;
   attachmentIds: string[] | undefined;
-  sourceMetadata: Record<string, unknown> | undefined;
+  sourceMetadata: import("@vellumai/gateway-client").SourceMetadata | undefined;
   actorDisplayName: string | undefined;
   actorExternalId: string | undefined;
   actorUsername: string | undefined;

package/src/schedule/schedule-store.ts

@@ -986,6 +986,36 @@ export function describeCronExpression(expr: string | null): string {
       }
     }
 
+    // Stepped or fixed minutes constrained to a contiguous range of hours,
+    // every day/month (e.g. "*/30 7-23 * * *" → "Every 30 minutes, 7 AM–11 PM").
+    const hoursAreContiguousRange =
+      !allHours &&
+      activeHours.length > 1 &&
+      activeHours.every((h, i) => i === 0 || h === activeHours[i - 1] + 1);
+
+    if (hoursAreContiguousRange && anyDayAndMonth) {
+      const hourLabel = (h: number) => {
+        const period = h >= 12 ? "PM" : "AM";
+        return `${h % 12 || 12} ${period}`;
+      };
+      const rangeStr = `${hourLabel(activeHours[0])}–${hourLabel(
+        activeHours[activeHours.length - 1],
+      )}`;
+
+      if (steppedMinutes && activeMinutes[0] === 0) {
+        const step = activeMinutes[1] - activeMinutes[0];
+        const isRegularStep = activeMinutes.every((v, i) => v === i * step);
+        if (isRegularStep && 60 % step === 0) {
+          return `Every ${step} minutes, ${rangeStr}`;
+        }
+      }
+      if (fixedMinute) {
+        return activeMinutes[0] === 0
+          ? `Hourly, ${rangeStr}`
+          : `Hourly at minute ${activeMinutes[0]}, ${rangeStr}`;
+      }
+    }
+
     // Fallback: return the raw expression
     return expr;
   } catch {

package/src/tools/apps/executors.ts

@@ -12,6 +12,7 @@ import { compileApp } from "../../bundler/app-compiler.js";
 import { generateAppIcon } from "../../media/app-icon-generator.js";
 import type { AppDefinition } from "../../memory/app-store.js";
 import { getAppDirPath } from "../../memory/app-store.js";
+import { getLogger } from "../../util/logger.js";
 
 // ---------------------------------------------------------------------------
 // Shared result type
@@ -55,6 +56,11 @@ export interface AppStoreWriter {
   ): AppDefinition;
   deleteApp(id: string): void;
   writeAppFile(appId: string, path: string, content: string): void;
+  /**
+   * Associate a freshly created app with the conversation that created it.
+   * Optional so test doubles need not implement it; the real store does.
+   */
+  addAppConversationId?(appId: string, conversationId: string): boolean;
 }
 
 export type AppStore = AppStoreReader & AppStoreWriter;
@@ -158,6 +164,7 @@ export async function executeAppCreate(
   input: AppCreateInput,
   store: AppStore,
   proxyToolResolver?: ProxyResolver,
+  conversationId?: string,
 ): Promise<ExecutorResult> {
   // The model sometimes omits a name; resolve a sensible one rather than
   // erroring out so the build still succeeds. Users can rename via app_update.
@@ -213,6 +220,22 @@ export async function executeAppCreate(
     formatVersion: 2,
   });
 
+  // Associate the app with its conversation at creation so subsequent
+  // `app_*` calls in the same turn can resolve it even when the model omits
+  // `app_id` (see resolveAppId). Without this the link is only formed at
+  // `app_open`, leaving the create→update→refresh gap unresolvable.
+  // Best-effort: a failed association must never fail the create.
+  if (conversationId && store.addAppConversationId) {
+    try {
+      store.addAppConversationId(app.id, conversationId);
+    } catch (err) {
+      getLogger("app-executors").debug(
+        { err, appId: app.id, conversationId },
+        "Failed to associate app with conversation at create",
+      );
+    }
+  }
+
   // Scaffold multifile app with src/ files and compile to dist/
   const htmlSafeName = name
     .replace(/&/g, "&amp;")

package/src/tools/apps/resolve-app-id.ts

@@ -0,0 +1,42 @@
+import { listAppsByConversation } from "../../memory/app-store.js";
+
+/**
+ * Resolve the `app_id` an app-builder tool should operate on.
+ *
+ * Weaker models routinely omit `app_id` when calling `app_*` tools through
+ * `skill_execute`, even though the active app's id is in their context from the
+ * preceding `app_create`/`app_update` result. Left unhandled, the executor
+ * fails with a cryptic "Invalid ID: undefined", the model retries the same
+ * empty call, and the turn burns many steps before recovering.
+ *
+ * An explicit, non-empty `app_id` always wins. When it is missing, fall back to
+ * the conversation's most-recently-updated app — the one being actively built.
+ * Returns `null` when no app_id is supplied and the conversation has no app, so
+ * callers can surface an actionable error instead of a raw store throw.
+ *
+ * Not used for destructive operations (`app_delete`): deleting an inferred app
+ * is unsafe, so deletion requires an explicit id.
+ */
+export function resolveAppId(
+  input: Record<string, unknown>,
+  conversationId: string,
+): string | null {
+  if (typeof input.app_id === "string" && input.app_id.trim().length > 0) {
+    return input.app_id;
+  }
+  // `listAppsByConversation` preserves `listApps`' updatedAt-descending order,
+  // so the first entry is the app the model is actively working on.
+  const apps = listAppsByConversation(conversationId);
+  return apps.length > 0 ? apps[0].id : null;
+}
+
+/** Error payload returned when no app_id is supplied and none can be inferred. */
+export function missingAppIdError(): { content: string; isError: boolean } {
+  return {
+    content: JSON.stringify({
+      error:
+        "app_id is required and no active app exists in this conversation. Call app_create first, or pass app_id explicitly.",
+    }),
+    isError: true,
+  };
+}

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

@@ -43,6 +43,14 @@ 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:
@@ -99,6 +107,41 @@ 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;