@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/context/strip-injections.ts

@@ -12,11 +12,14 @@
  * without reaching up into the daemon orchestrator.
  */
 import {
+  isMemorySpotlightText,
   MEMORY_SPOTLIGHT_PREFIX,
   MEMORY_SPOTLIGHT_SUFFIX,
 } from "../plugins/defaults/memory/memory-marker.js";
 import type { Message } from "../providers/types.js";
 
+export { isMemorySpotlightText };
+
 /**
  * A matcher for an injected text block. A plain string matches by prefix
  * (`startsWith`). A `{ prefix, suffix }` wrapper requires BOTH the opening
@@ -115,69 +118,27 @@ export function stripTailUserTextBlocksByPrefix(
 }
 
 /**
- * Full-wrapper matcher for the memory-v3 ephemeral `<memory_spotlight>` block.
- * Shared by the per-turn scoped strip ({@link stripSpotlightInjections}) and
- * the compaction pipeline below so both recognize exactly the same wrapper.
+ * Full-wrapper matcher for the memory-v3 per-turn `<memory_spotlight>` block.
+ * Shared by the leftover cleanup ({@link stripSpotlightInjections}), the
+ * tail-only assembly strip, and the compaction pipeline so every path
+ * recognizes exactly the same wrapper.
  */
-const MEMORY_SPOTLIGHT_MATCHER: InjectionMatcher = {
+export const MEMORY_SPOTLIGHT_MATCHER: InjectionMatcher = {
   prefix: MEMORY_SPOTLIGHT_PREFIX,
   suffix: MEMORY_SPOTLIGHT_SUFFIX,
 };
 
 /**
- * Remove memory-v3 `<memory_spotlight>` blocks from every user message — and
- * ONLY those blocks. The spotlight is ephemeral by contract: runtime assembly
- * strip-and-replaces it each turn (the previous turn's spotlight is stale),
- * while the frozen `<memory>` card blocks stay byte-identical in history for
- * prompt caching. This is deliberately a scoped, single-id strip — the old
- * whole-layer `stripAllMemoryInjections` replace is gone.
+ * Remove leftover `<memory_spotlight>` blocks from every user message, and
+ * only those blocks. Compaction and overflow recovery rewrite history, so
+ * they strip every runtime injection including historical spotlights.
+ * Frozen `<memory>` card blocks stay byte-identical. Assembly uses the
+ * tail-scoped variant so live history keeps each prior turn's spotlight.
  */
 export function stripSpotlightInjections(messages: Message[]): Message[] {
   return stripUserTextBlocksByPrefix(messages, [MEMORY_SPOTLIGHT_MATCHER]);
 }
 
-/**
- * Whether the TURN-STARTING user message carries a memory-v3
- * `<memory_spotlight>` block.
- *
- * The spotlight is the only injected block that is strip-and-replaced from
- * every user message each turn, so its presence is exactly what makes that
- * message volatile across turns. Every other injected block (turn context,
- * workspace, `<info>`, `<memory>` cards, NOW.md) is frozen into history and
- * re-renders byte-identically, so a message without a spotlight is a stable
- * cache anchor. Providers consume this through the `mutableLatestUserMessage`
- * config field when placing cache breakpoints.
- *
- * The turn start is the most recent user message carrying TEXT content, which
- * is the same message the Anthropic client anchors on. Tool-result messages
- * are skipped: they are user-role but carry no injected blocks, and letting
- * them answer this question would flip the signal to `false` partway through a
- * tool loop. The provider would then mark the very same turn-start block at a
- * different TTL than it did on the turn's first request, billing a second
- * write for one reusable prefix. Anchoring on the turn start keeps the signal
- * constant for every request in the turn.
- *
- * Detection uses {@link MEMORY_SPOTLIGHT_MATCHER}, the same full-wrapper
- * matcher {@link stripSpotlightInjections} strips with, so the two can never
- * disagree about which blocks are ephemeral.
- */
-export function turnStartUserMessageHasSpotlight(messages: Message[]): boolean {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-    if (message.role !== "user") {
-      continue;
-    }
-    const textBlocks = message.content.filter((block) => block.type === "text");
-    if (textBlocks.length === 0) {
-      continue;
-    }
-    return textBlocks.some((block) =>
-      textBlockMatchesInjection(block.text, [MEMORY_SPOTLIGHT_MATCHER]),
-    );
-  }
-  return false;
-}
-
 /** `<NOW.md>` scratchpad prefixes (current tag, pre-line-limit variant, legacy `<now_scratchpad>`) — shared with `stripNowScratchpad` so the two strip paths can't drift. */
 export const NOW_SCRATCHPAD_STRIP_PREFIXES: InjectionMatcher[] = [
   "<NOW.md Always keep this up to date",
@@ -217,10 +178,10 @@ export const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
   // matches the full-wrapper requirement in `countMemoryPrefixBlocks`.
   { prefix: "<memory>\n", suffix: "\n</memory>" },
   { prefix: "<info>\n", suffix: "\n</info>" },
-  // The memory-v3 ephemeral spotlight block. Normally strip-and-replaced every
-  // turn by `stripSpotlightInjections`, but registered here too so compaction
-  // and overflow recovery remove a stale spotlight along with the rest of the
-  // runtime injections. Full-wrapper shape for the same reason as `<memory>`.
+  // Memory-v3 per-turn spotlight blocks. Compaction rewrites history, so
+  // it strips them along with the other runtime injections and re-injects
+  // a fresh copy on the new tail. Full-wrapper shape for the same reason
+  // as `<memory>`.
   MEMORY_SPOTLIGHT_MATCHER,
   "<voice_call_control>",
   "<workspace_top_level>", // backward-compat: strip legacy workspace blocks

package/src/conversations/__tests__/message-consolidation.test.ts

@@ -312,6 +312,45 @@ describe("mergeConsecutiveAssistantMessages", () => {
     expect(mergedIdMap.get("anchor")).toEqual(["tail"]);
   });
 
+  test("a row deleted on its channel never merges, in either direction", () => {
+    // The deletion lives in the provider envelope, not in `messageKind`, and
+    // a merged run keeps the anchor's metadata: folding would drop the
+    // deletion or claim it over text the channel still shows.
+    const deleted = makeMsg(
+      "assistant",
+      JSON.stringify([{ type: "text", text: "gone from Slack" }]),
+      {
+        id: "deleted",
+        metadata: JSON.stringify({
+          slackMeta: JSON.stringify({
+            source: "slack",
+            channelId: "C1",
+            channelTs: "1725100000.000100",
+            eventKind: "message",
+            deletedAt: 1725100001000,
+          }),
+        }),
+      },
+    );
+    const { messages, mergedIdMap } = mergeConsecutiveAssistantMessages([
+      makeMsg("user", "hi"),
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "A" }]), {
+        id: "before",
+      }),
+      deleted,
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "B" }]), {
+        id: "after",
+      }),
+    ]);
+    expect(messages.map((m) => m.id)).toEqual([
+      messages[0].id,
+      "before",
+      "deleted",
+      "after",
+    ]);
+    expect(mergedIdMap.size).toBe(0);
+  });
+
   test("leaves a single assistant row unchanged", () => {
     const messages = [
       makeMsg("user", "hi"),

package/src/conversations/message-consolidation.ts

@@ -40,10 +40,11 @@ const log = getLogger("message-consolidation");
 
 /**
  * True when an assistant row is a standalone display turn (system card,
- * provider-error notice, or deliberate-silence marker) that never merges with adjacent assistant rows in
+ * provider-error notice, deliberate-silence marker, reaction, or a row
+ * deleted on its channel) that never merges with adjacent assistant rows in
  * either direction. Merging one into an adjacent run would let the anchor's
- * metadata win and drop the `messageKind` marker from the wire (or stamp it
- * onto a bubble containing real assistant text).
+ * metadata win and drop the marker from the wire (or stamp it onto a bubble
+ * containing real assistant text).
  */
 function isStandaloneAssistantRow(msg: MessageRow): boolean {
   return isStandaloneAssistantMessage(msg.role, msg.metadata);

package/src/credential-health/credential-health-service.ts

@@ -38,6 +38,11 @@ import {
   expectedScopesForStoredToken,
   scopeDifference,
 } from "../oauth/scope-utils.js";
+import { credentialKey } from "../security/credential-key.js";
+import {
+  getSecureKeyAsync,
+  getSecureKeyResultAsync,
+} from "../security/secure-keys.js";
 import {
   TokenExpiredError,
   withValidToken,
@@ -610,6 +615,131 @@ async function checkManagedProvider(
   return results;
 }
 
+/**
+ * Connection id for the Vellum-managed assistant credential.
+ *
+ * The credential is a single workspace-wide slot rather than one row per
+ * account, so it carries the credential-store key as its id instead of a
+ * connection uuid.
+ */
+const ASSISTANT_API_KEY_CONNECTION_ID = "vellum:assistant_api_key";
+
+/**
+ * Health of the platform-provisioned assistant API key, the credential that
+ * authenticates Vellum-managed inference.
+ *
+ * Deliberately not part of {@link checkAllCredentials} yet. Adding it there
+ * makes the heartbeat raise a `credential.health_alert` for this credential,
+ * and that alert has nowhere to send the reader until the notification carries
+ * the repair. It is used on demand for now, by the route a client calls to
+ * confirm a credential it just wrote.
+ *
+ * This is the one credential the assistant cannot mint for itself: the
+ * platform issues it and a signed-in client writes it in. For a self-hosted
+ * or local assistant the platform deliberately does not self-heal a dead key
+ * (`recover_expired_assistant_api_key` excludes registrations of that kind,
+ * because the client owns the reprovision flow), so its health has to be
+ * observed here and acted on by a client.
+ *
+ * Statuses map onto the shared vocabulary:
+ *   - `missing_token`: no key is stored, so managed inference cannot run.
+ *   - `revoked`: the platform settled that the stored key is not accepted.
+ *   - `unreachable`: the credential store or the platform did not answer, so
+ *     health is unknown. The heartbeat drops these before notifying, which is
+ *     what keeps a transient outage from raising a credential alert.
+ *
+ * `canAutoRecover` is true for both failure statuses: recovery needs no
+ * re-authorization from the user, only a signed-in client to rotate the key.
+ */
+export async function checkAssistantApiKey(): Promise<CredentialHealthResult | null> {
+  const base: Omit<
+    CredentialHealthResult,
+    "status" | "details" | "canAutoRecover"
+  > = {
+    connectionId: ASSISTANT_API_KEY_CONNECTION_ID,
+    provider: "vellum",
+    accountInfo: null,
+    missingScopes: [],
+  };
+
+  const stored = await getSecureKeyResultAsync(
+    credentialKey("vellum", "assistant_api_key"),
+  );
+
+  if (stored.unreachable) {
+    return {
+      ...base,
+      status: "unreachable",
+      details:
+        "The credential store is unreachable, so Vellum's managed credentials could not be checked.",
+      canAutoRecover: false,
+    };
+  }
+
+  if (stored.value == null) {
+    // A workspace that was never connected to the platform has no managed
+    // credential and is not unhealthy. Only an install that already carries
+    // the rest of a platform identity is missing something.
+    const baseUrl = await getSecureKeyAsync(
+      credentialKey("vellum", "platform_base_url"),
+    );
+    if (!baseUrl) {
+      return null;
+    }
+    return {
+      ...base,
+      status: "missing_token",
+      details:
+        "No Vellum-managed credentials are stored yet. Log in to the Vellum platform to set them up.",
+      canAutoRecover: true,
+    };
+  }
+
+  const { VellumPlatformClient } = await import("../platform/client.js");
+  const client = await VellumPlatformClient.create();
+  if (!client) {
+    return {
+      ...base,
+      status: "unreachable",
+      details:
+        "The Vellum platform client could not be built, so Vellum's managed credentials could not be checked.",
+      canAutoRecover: false,
+    };
+  }
+
+  const verdict = await client.verifyCredential();
+  if (verdict === "rejected") {
+    return {
+      ...base,
+      status: "revoked",
+      // Names the recovery the app actually performs. A replacement is
+      // provisioned only when someone asks for one, from the repair action or
+      // by logging in from the command line, so the copy points at that
+      // action rather than at reconnecting something the reader never
+      // connected.
+      details:
+        "Vellum's managed credentials stopped working, so chat and background tasks that use them are paused. Restoring takes a moment and will not affect anything else.",
+      canAutoRecover: true,
+    };
+  }
+  if (verdict === "unknown") {
+    return {
+      ...base,
+      status: "unreachable",
+      details:
+        "Vellum did not answer the managed-credential check. Health is unknown until the next check.",
+      canAutoRecover: false,
+    };
+  }
+
+  return {
+    ...base,
+    status: "healthy",
+    details: "Vellum's managed credentials are working.",
+    canAutoRecover: true,
+  };
+}
+
 // ── Public API ────────────────────────────────────────────────────────
 
 /**

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -171,6 +171,37 @@ describe("isToolActiveForContext - client OS eligibility", () => {
     }
   });
 
+  test("falls back to linux client OS from the linux transport interface", () => {
+    const skillId = "linux-transport-client-os-test-skill";
+    registerSkillTools(skillId, [
+      finalizeTool({
+        name: "linux_transport_os_test_tool",
+        supportedClientOs: ["linux"],
+      }),
+    ]);
+
+    try {
+      expect(
+        isToolActiveForContext(
+          "linux_transport_os_test_tool",
+          makeCtx({
+            transportInterface: "linux",
+          }),
+        ),
+      ).toBe(true);
+      expect(
+        isToolActiveForContext(
+          "linux_transport_os_test_tool",
+          makeCtx({
+            transportInterface: "windows",
+          }),
+        ),
+      ).toBe(false);
+    } finally {
+      unregisterSkillTools(skillId);
+    }
+  });
+
   test("uses pinned client OS without falling through to live context", () => {
     const skillId = "pinned-client-os-test-skill";
     registerSkillTools(skillId, [

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -26,8 +26,6 @@ import type { ProviderMessageMetadata } from "../messaging/provider-message-meta
 import {
   formatSlackTimezoneLabel,
   isSlackTs,
-  type SlackMessageMetadata,
-  writeSlackMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
 import {
   recordCompactionEndBestEffort,
@@ -1345,9 +1343,9 @@ function resolveAssistantReplyTimestampTimezone(ctx: Conversation): string {
  * snapshot that handleMessageComplete used to compute at end-of-turn. All
  * inputs (channel context, trust context, turnStartedAt) are stable across
  * the LLM call, so building this once at reserve is equivalent to building
- * it at complete. Slack reply rows further stamp a `slackMeta` sub-object —
- * the `channelTs` field stays absent here and is back-filled by
- * `deliverReplyViaCallback` after the gateway returns the ts.
+ * it at complete. The envelope's `messageId` stays absent here and is
+ * back-filled by `deliverReplyViaCallback` after the transport returns the
+ * sent message's id.
  */
 function buildAssistantChannelMetadata(
   state: EventHandlerState,
@@ -1363,61 +1361,59 @@ function buildAssistantChannelMetadata(
     sentAt: state.turnStartedAt,
   };
 
-  if (deps.turnChannelContext.assistantMessageChannel === "slack") {
-    // The whole envelope resolves from one turn-local snapshot: the actor the
-    // provenance above names is the actor whose channel and thread the row
-    // routes to. Reading the live slot here instead would let a concurrent
-    // inbound repoint the reply mid-turn, and could stamp one actor's class
-    // beside another actor's routing identity.
-    const rowTrust = turnOrRestingTrust(deps.ctx);
-    const channelId = rowTrust?.requesterChatId;
-    if (channelId) {
-      // This turn's own inbound thread id (the same field guardian-approval
-      // cards read). Deliberately not the shared conversation binding: on a
-      // legacy flat→thread aliased Slack conversation a concurrent inbound
-      // can rewrite the binding's externalThreadId mid-turn.
-      const turnThreadTs = rowTrust?.sourceThreadId;
-      const threadTs = isSlackTs(turnThreadTs) ? turnThreadTs : undefined;
-      const timestampTimezone = resolveAssistantReplyTimestampTimezone(
-        deps.ctx,
-      );
-      const timestampTimezoneLabel = formatSlackTimezoneLabel(
-        timestampTimezone,
-        { nowMs: state.turnStartedAt },
-      );
-      const partialSlackMeta: Partial<SlackMessageMetadata> = {
-        source: "slack",
-        eventKind: "message",
-        channelId,
-        ...(threadTs ? { threadTs } : {}),
-        timestampTimezone,
-        ...(timestampTimezoneLabel ? { timestampTimezoneLabel } : {}),
-      };
-      // `channelTs` is filled in by the post-send reconciliation step in
-      // `deliverReplyViaCallback`; cast through the Partial to satisfy
-      // the writer's type at this pre-send boundary.
-      metadata.slackMeta = writeSlackMetadata(
-        partialSlackMeta as SlackMessageMetadata,
-      );
-    }
-  } else if (deps.turnChannelContext.assistantMessageChannel !== "vellum") {
-    // Every other channel row describes itself in the neutral envelope
-    // `readProviderMetadata` serves, the shape a plugin channel writes too.
-    // `messageId` stays absent here and is back-filled by the post-send
-    // reconciliation once the transport returns the sent message's id, which
-    // is what lets a later reaction on this row resolve back to it. No
-    // `threadId`: a value there asserts a thread exists, and the reply's
-    // routing thread is delivery state, not a fact about this row.
-    const chatId = turnOrRestingTrust(deps.ctx)?.requesterChatId;
-    if (chatId) {
-      metadata.providerMeta = JSON.stringify({
-        source: deps.turnChannelContext.assistantMessageChannel,
-        conversationExternalId: chatId,
-        eventKind: "message",
-      } satisfies ProviderMessageMetadata);
-    }
+  const channel = deps.turnChannelContext.assistantMessageChannel;
+  if (channel === "vellum") {
+    // A vellum turn is not a provider message: no envelope.
+    return metadata;
   }
-
+  // Every channel row describes itself in the neutral envelope
+  // `readProviderMetadata` serves, the shape a plugin channel writes too.
+  // `messageId` stays absent here and is back-filled by the post-send
+  // reconciliation once the transport returns the sent message's id, which
+  // is what lets a later reaction or delete on this row resolve back to it.
+  //
+  // The whole envelope resolves from one turn-local snapshot: the actor the
+  // provenance above names is the actor whose channel and thread the row
+  // routes to. Reading the live slot here instead would let a concurrent
+  // inbound repoint the reply mid-turn, and could stamp one actor's class
+  // beside another actor's routing identity.
+  const rowTrust = turnOrRestingTrust(deps.ctx);
+  const chatId = rowTrust?.requesterChatId;
+  if (!chatId) {
+    return metadata;
+  }
+  const envelope: ProviderMessageMetadata = {
+    source: channel,
+    conversationExternalId: chatId,
+    eventKind: "message",
+  };
+  if (channel === "slack") {
+    // Slack's own facts ride the schema's passthrough and come back through
+    // the envelope's Slack view (`slackViewOfProviderMetadata`). The thread
+    // is this turn's own inbound thread id (the same field guardian-approval
+    // cards read), stated because the reply is posted in it and the Slack
+    // transcript is assembled by thread. Deliberately not the shared
+    // conversation binding: on a legacy flat-to-thread aliased Slack
+    // conversation a concurrent inbound can rewrite the binding's
+    // externalThreadId mid-turn.
+    const turnThreadTs = rowTrust?.sourceThreadId;
+    const threadTs = isSlackTs(turnThreadTs) ? turnThreadTs : undefined;
+    const timestampTimezone = resolveAssistantReplyTimestampTimezone(deps.ctx);
+    const timestampTimezoneLabel = formatSlackTimezoneLabel(timestampTimezone, {
+      nowMs: state.turnStartedAt,
+    });
+    metadata.providerMeta = JSON.stringify({
+      ...envelope,
+      ...(threadTs ? { threadId: threadTs } : {}),
+      ...(timestampTimezone ? { timestampTimezone } : {}),
+      ...(timestampTimezoneLabel ? { timestampTimezoneLabel } : {}),
+    });
+    return metadata;
+  }
+  // No `threadId` on the other channels: a value there asserts a thread
+  // exists, and the reply's routing thread is delivery state, not a fact
+  // about this row.
+  metadata.providerMeta = JSON.stringify(envelope);
   return metadata;
 }
 

package/src/daemon/conversation-error.ts

@@ -359,6 +359,8 @@ function connectionResolutionUserMessage(
       return `No provider connection is configured${usedBy}. Ask me to set one up right here, or add an API key in ${fixPath}.`;
     case "unroutable_managed_model":
       return `The model "${error.model ?? "<unset>"}"${usedBy} isn't served by the Vellum managed route. Pick a model from the Vellum catalog, or choose a concrete provider in ${fixPath}.`;
+    case "adapter_unavailable":
+      return `${connection}${usedBy} could not serve model "${error.model ?? "<unset>"}". This model is only available on the Vellum GPU route and was not sent through another provider.`;
     case "missing_credential":
       // Provider-neutral: api_key connections store keys, oauth_subscription
       // connections store login tokens — the fix differs but the location