@vellumai/assistant 0.8.3 → 0.8.5

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

@@ -74,6 +74,11 @@ export function resolveTrustClass(
   return trustContext?.trustClass ?? "unknown";
 }
 
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import {
+  buildSwitchInferenceProfileToolDef,
+  SWITCH_INFERENCE_PROFILE_TOOL_NAME,
+} from "./switch-inference-profile-tool.js";
 import type { ToolSetupContext } from "./tool-setup-types.js";
 export type { ToolSetupContext } from "./tool-setup-types.js";
 
@@ -86,8 +91,8 @@ export type { ToolSetupContext } from "./tool-setup-types.js";
 export function buildToolDefinitions(): ToolDefinition[] {
   return [
     ...getAllToolDefinitions(),
-    ...allUiSurfaceTools.map((t) => t.getDefinition()),
-    ...coreAppProxyTools.map((t) => t.getDefinition()),
+    ...allUiSurfaceTools,
+    ...coreAppProxyTools,
   ];
 }
 
@@ -209,6 +214,33 @@ 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 input.profile === "string" ? input.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
@@ -326,11 +358,20 @@ 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. */
+  currentTurnOverrideProfile?: string;
+  /**
+   * True when the user has explicitly selected an inference profile for this
+   * conversation (via the composer profile picker). When set, tool-based
+   * auto-routing is suppressed — the user's explicit choice takes precedence.
+   */
+  hasExplicitProfileOverride?: boolean;
 }
 
 // ── Conditional tool sets ────────────────────────────────────────────
 
 const UI_SURFACE_TOOL_NAMES = new Set(["ui_show", "ui_update", "ui_dismiss"]);
+const SLACK_TASK_PROGRESS_UI_TOOL_NAMES = new Set(["ui_show", "ui_update"]);
 /**
  * Single source of truth for which tools are host tools and the capability
  * each one requires from the connected client interface. Adding a tool here
@@ -437,6 +478,12 @@ export function isToolActiveForContext(
     return false;
   }
   if (UI_SURFACE_TOOL_NAMES.has(name)) {
+    if (
+      ctx.channelCapabilities?.channel === "slack" &&
+      SLACK_TASK_PROGRESS_UI_TOOL_NAMES.has(name)
+    ) {
+      return !ctx.hasNoClient;
+    }
     return ctx.channelCapabilities?.supportsDynamicUi ?? !ctx.hasNoClient;
   }
   if (HOST_TOOL_NAMES.has(name)) {
@@ -606,6 +653,26 @@ export function createResolveToolsCallback(
     }
 
     ctx.allowedToolNames = turnAllowed;
-    return injectActivityField(allBaseDefs, ACTIVITY_SKIP_SET);
+    const baseDefs = injectActivityField(allBaseDefs, ACTIVITY_SKIP_SET);
+
+    const config = getConfig();
+    if (
+      isAssistantFeatureFlagEnabled("query-complexity-routing", config) &&
+      config.llm &&
+      !ctx.hasExplicitProfileOverride
+    ) {
+      const currentProfile =
+        ctx.currentTurnOverrideProfile ?? config.llm.activeProfile;
+      const toolDef = buildSwitchInferenceProfileToolDef(
+        config.llm.profiles ?? {},
+        currentProfile,
+      );
+      if (toolDef) {
+        turnAllowed.add(SWITCH_INFERENCE_PROFILE_TOOL_NAME);
+        return [...baseDefs, toolDef];
+      }
+    }
+
+    return baseDefs;
   };
 }

package/src/daemon/conversation-usage.ts

@@ -3,6 +3,7 @@ import { updateConversationUsage } from "../memory/conversation-crud.js";
 import { recordUsageEvent } from "../memory/llm-usage-store.js";
 import type { UsageActor } from "../usage/actors.js";
 import { resolveUsageAttribution } from "../usage/attribution.js";
+import { extractRawUsage } from "../usage/pricing.js";
 import type {
   AnthropicCacheCreationTokenDetails,
   PricingResult,
@@ -235,6 +236,7 @@ export function recordUsage(
         outputTokens,
         cacheCreationInputTokens: normalizedCacheCreationInputTokens,
         cacheReadInputTokens: normalizedCacheReadInputTokens,
+        rawUsage: extractRawUsage(rawResponse),
         conversationId: ctx.conversationId,
         runId: null,
         requestId,

package/src/daemon/conversation.ts

@@ -53,13 +53,13 @@ import {
   getConversation,
   getConversationOriginChannel,
   getConversationOverrideProfileFromRow,
+  setConversationHistoryStrippedAt,
 } from "../memory/conversation-crud.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { shouldExposePersonalMemory } from "../memory/v2/static-context.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { UserDecision } from "../permissions/types.js";
-import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import type { Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
@@ -104,6 +104,7 @@ import {
   type ChannelCapabilities,
   getSlackCompactionWatermarkForPrefix,
   loadSlackChronologicalContext,
+  stripInjectionsForCompaction,
 } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import {
@@ -142,6 +143,13 @@ import { TraceEmitter } from "./trace-emitter.js";
 
 const log = getLogger("conversation");
 
+export interface CleanResult {
+  previousEstimatedInputTokens: number;
+  estimatedInputTokens: number;
+  maxInputTokens: number;
+  preservedMessages: number;
+}
+
 export { findLastUndoableUserMessageIndex } from "./conversation-history.js";
 export type {
   QueueDrainReason,
@@ -240,7 +248,6 @@ export class Conversation {
   /** @internal */ loadedHistoryPersonalMemoryAllowed?: boolean;
   /** @internal */ voiceCallControlPrompt?: string;
   /** @internal */ transportHints?: string[];
-  /** @internal */ slackRuntimeContextNotice?: string;
   /** @internal */ assistantId?: string;
   /** @internal */ commandIntent?: {
     type: string;
@@ -249,6 +256,13 @@ export class Conversation {
   };
   /** @internal */ surfaceActionRequestIds = new Set<string>();
   /** @internal */ approvedViaPromptThisTurn = false;
+  /**
+   * Set by `steerToMessage` to signal the drain path that it should inject
+   * synthetic tool_result messages for any pending tool_use blocks abandoned
+   * by the aborted generation. Cleared after repair.
+   * @internal
+   */
+  pendingSteerRepair = false;
   /**
    * When true, side-effect tools must prompt even if a trust/allow rule
    * would auto-allow. Set by non-interactive callers (e.g. non-guardian
@@ -477,19 +491,12 @@ export class Conversation {
       const resolved: ResolvedSystemPrompt = {
         systemPrompt: this.hasSystemPromptOverride
           ? systemPrompt
-          : (() => {
-              const persona = resolvePersonaContext(
-                this.currentTurnTrustContext,
-                this.currentTurnChannelCapabilities,
-              );
-              return buildSystemPrompt({
-                hasNoClient: this.hasNoClient,
-                userPersona: persona.userPersona,
-                channelPersona: persona.channelPersona,
-                userSlug: persona.userSlug,
-                onboardingContext: this.getOnboardingContext(),
-              });
-            })(),
+          : buildSystemPrompt({
+              hasNoClient: this.hasNoClient,
+              trustContext: this.currentTurnTrustContext,
+              channelCapabilities: this.currentTurnChannelCapabilities,
+              onboardingContext: this.getOnboardingContext(),
+            }),
       };
       if (configuredMaxTokens !== undefined) {
         resolved.maxTokens = configuredMaxTokens;
@@ -568,19 +575,12 @@ export class Conversation {
 
     const systemPrompt = this.hasSystemPromptOverride
       ? this.systemPrompt
-      : (() => {
-          const persona = resolvePersonaContext(
-            this.currentTurnTrustContext,
-            this.currentTurnChannelCapabilities,
-          );
-          return buildSystemPrompt({
-            hasNoClient: this.hasNoClient,
-            userPersona: persona.userPersona,
-            channelPersona: persona.channelPersona,
-            userSlug: persona.userSlug,
-            onboardingContext: this.getOnboardingContext(),
-          });
-        })();
+      : buildSystemPrompt({
+          hasNoClient: this.hasNoClient,
+          trustContext: this.currentTurnTrustContext,
+          channelCapabilities: this.currentTurnChannelCapabilities,
+          onboardingContext: this.getOnboardingContext(),
+        });
     const tools = buildToolDefinitions();
     const provider = this.provider;
 
@@ -1126,6 +1126,32 @@ export class Conversation {
     return result;
   }
 
+  /**
+   * Strip stale runtime injections from the message history and reset the
+   * memory-injection ledger without summarizing any history. Mirrors the
+   * non-LLM side effects of `forceCompact`: the next turn re-injects fresh
+   * NOW.md / knowledge-base / memory-v2 static blocks, and per-turn memory
+   * activations are no longer deduped against the prior session.
+   */
+  async forceClean(): Promise<CleanResult> {
+    const previousEstimatedInputTokens =
+      this.contextWindowManager.estimateInputTokens(this.messages);
+    const stripped = stripInjectionsForCompaction(this.messages);
+    this.messages = stripped;
+    await this.graphMemory.onCompacted(0);
+    this.pendingPostCompactReinject = true;
+    setConversationHistoryStrippedAt(this.conversationId, Date.now());
+    const estimatedInputTokens = this.contextWindowManager.estimateInputTokens(
+      this.messages,
+    );
+    return {
+      previousEstimatedInputTokens,
+      estimatedInputTokens,
+      maxInputTokens: this.contextWindowManager.maxInputTokens,
+      preservedMessages: this.messages.length,
+    };
+  }
+
   setChannelCapabilities(caps: ChannelCapabilities | null): void {
     this.channelCapabilities = caps ?? undefined;
     this.secretPrompter.setChannelContext(
@@ -1158,10 +1184,6 @@ export class Conversation {
     this.transportHints = hints;
   }
 
-  setSlackRuntimeContextNotice(notice: string | undefined): void {
-    this.slackRuntimeContextNotice = notice;
-  }
-
   /**
    * Apply client-reported host environment (home dir, username) from
    * transport metadata onto the conversation. Only interfaces whose

package/src/daemon/disk-pressure-guard.ts

@@ -6,6 +6,7 @@ import { cancelBackgroundTools } from "../tools/background-tool-registry.js";
 import { getDiskUsageInfo } from "../util/disk-usage.js";
 import { getLogger } from "../util/logger.js";
 
+export const DISK_PRESSURE_WARNING_THRESHOLD_PERCENT = 80;
 export const DISK_PRESSURE_THRESHOLD_PERCENT = 95;
 export const DISK_PRESSURE_CHECK_INTERVAL_MS = 60_000;
 export const DISK_PRESSURE_OVERRIDE_CONFIRMATION = "I understand the risks";
@@ -15,7 +16,7 @@ export const DISK_PRESSURE_BLOCKED_CAPABILITIES = [
   "remote-ingress",
 ] as const;
 
-export type DiskPressureState = "disabled" | "ok" | "critical" | "unknown";
+export type DiskPressureState = "disabled" | "ok" | "warning" | "critical" | "unknown";
 
 export type DiskPressureBlockedCapability =
   (typeof DISK_PRESSURE_BLOCKED_CAPABILITIES)[number];
@@ -229,9 +230,10 @@ export function evaluateDiskPressureNow(): DiskPressureStatus {
     (usageInfo.usedMb / usageInfo.totalMb) * 100,
   );
   const isCritical = usagePercent >= DISK_PRESSURE_THRESHOLD_PERCENT;
+  const isWarning = !isCritical && usagePercent >= DISK_PRESSURE_WARNING_THRESHOLD_PERCENT;
   const lastCheckedAt = new Date().toISOString();
 
-  if (!isCritical) {
+  if (!isCritical && !isWarning) {
     return replaceStatus({
       ...OPEN_STATUS,
       usagePercent,
@@ -240,6 +242,16 @@ export function evaluateDiskPressureNow(): DiskPressureStatus {
     });
   }
 
+  if (isWarning) {
+    return replaceStatus({
+      ...OPEN_STATUS,
+      state: "warning",
+      usagePercent,
+      path: usageInfo.path,
+      lastCheckedAt,
+    });
+  }
+
   if (!state.status.locked) {
     cancelTerminalBackgroundToolsForLock();
   }

package/src/daemon/first-greeting.ts

@@ -102,6 +102,16 @@ function resolveTone(raw?: string): Tone {
   return raw && VALID_TONES.has(raw) ? (raw as Tone) : "grounded";
 }
 
+export function buildScanFirstMessage(
+  url: string,
+  variant: "website" | "content-source",
+): string {
+  if (variant === "content-source") {
+    return `Here's a page with content I'd like you to look at: ${url}`;
+  }
+  return `Here's my website: ${url}`;
+}
+
 function buildPersonalizedGreeting(ctx: OnboardingGreetingContext): string {
   const name = ctx.userName?.trim();
   const assistant = ctx.assistantName?.trim();